simulator.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 VTT Technical Research Centre of Finland Ltd
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef PFC_SIMULATOR_HPP
#define PFC_SIMULATOR_HPP
 
#include "core/world.hpp"
#include "field_modifier.hpp"
#include "model.hpp"
#include "results_writer.hpp"
#include "time.hpp"
#include <iostream>
#include <memory>
#include <unordered_map>
 
namespace pfc {
 
void step(class Simulator &s, Model &m);
 
class Simulator {
 
private:
  Model &m_model;
  Time &m_time;
 
  std::unordered_map<std::string, std::unique_ptr<ResultsWriter>> m_result_writers;
  std::vector<std::unique_ptr<FieldModifier>> m_initial_conditions;
  std::vector<std::unique_ptr<FieldModifier>> m_boundary_conditions;
  int m_result_counter = 0;
 
public:
  Simulator(Model &model, Time &time) : m_model(model), m_time(time) {}
 
  Model &get_model() { return m_model; }
 
  /*
  const Decomposition &get_decomposition() {
    return get_model().get_decomposition();
  }
  */
 
  const World &get_world() { return get_model().get_world(); }
 
  FFT &get_fft() { return get_model().get_fft(); }
 
  Time &get_time() { return m_time; }
 
  Field &get_field() { return get_model().get_field(); }
 
  void initialize() { get_model().initialize(get_time().get_dt()); }
 
  bool is_rank0() { return get_model().is_rank0(); }
 
  unsigned int get_increment() { return get_time().get_increment(); }
 
  bool add_results_writer(const std::string &field_name,
                          std::unique_ptr<ResultsWriter> writer) {
    auto inbox = get_inbox(get_fft());
    auto world = get_world();
    writer->set_domain(get_size(world), inbox.size, inbox.low);
 
    Model &model = get_model();
    if (model.has_field(field_name)) {
      m_result_writers.insert({field_name, std::move(writer)});
      return true;
    } else {
      std::cout << "Warning: tried to add writer for inexistent field " << field_name
                << ", RESULTS ARE NOT WRITTEN!" << std::endl;
      return false;
    }
  }
 
  bool add_results_writer(std::unique_ptr<ResultsWriter> writer) {
    std::cout << "Warning: adding result writer to write field 'default'"
              << std::endl;
    return add_results_writer("default", std::move(writer));
  }
 
  bool add_initial_conditions(std::unique_ptr<FieldModifier> modifier) {
    Model &model = get_model();
    std::string field_name = modifier->get_field_name();
    if (field_name == "default") {
      std::cout << "Warning: adding initial condition to modify field 'default'"
                << std::endl;
    }
    if (model.has_field(field_name)) {
      m_initial_conditions.push_back(std::move(modifier));
      return true;
    } else {
      std::cout << "Warning: tried to add initial condition for inexistent field "
                << field_name << ", INITIAL CONDITIONS ARE NOT APPLIED!"
                << std::endl;
      return false;
    }
  }
 
  const std::vector<std::unique_ptr<FieldModifier>> &get_initial_conditions() const {
    return m_initial_conditions;
  }
 
  bool add_boundary_conditions(std::unique_ptr<FieldModifier> modifier) {
    Model &model = get_model();
    std::string field_name = modifier->get_field_name();
    if (field_name == "default") {
      std::cout << "Warning: adding boundary condition to modify field 'default'"
                << std::endl;
    }
    if (model.has_field(field_name)) {
      m_boundary_conditions.push_back(std::move(modifier));
      return true;
    } else {
      std::cout << "Warning: tried to add boundary condition for inexistent field "
                << field_name << ", BOUNDARY CONDITIONS ARE NOT APPLIED!"
                << std::endl;
      return false;
    }
  }
 
  const std::vector<std::unique_ptr<FieldModifier>> &
  get_boundary_conditions() const {
    return m_boundary_conditions;
  }
 
  void set_result_counter(int result_counter) { m_result_counter = result_counter; }
 
  double get_result_counter() const { return m_result_counter; }
 
  void write_results() {
    int file_num = get_result_counter();
    Model &model = get_model();
    for (const auto &[field_name, writer] : m_result_writers) {
      if (model.has_real_field(field_name)) {
        writer->write(file_num, get_model().get_real_field(field_name));
      }
      if (model.has_complex_field(field_name)) {
        writer->write(file_num, get_model().get_complex_field(field_name));
      }
    }
    set_result_counter(file_num + 1);
  }
 
  void apply_initial_conditions() {
    Model &model = get_model();
    Time &time = get_time();
    for (const auto &ic : m_initial_conditions) {
      ic->apply(model, time.get_current());
    }
  }
 
  void apply_boundary_conditions() {
    Model &model = get_model();
    Time &time = get_time();
    for (const auto &bc : m_boundary_conditions) {
      bc->apply(model, time.get_current());
    }
  }
 
  void step() {
    Time &time = get_time();
    Model &model = get_model();
    if (time.get_increment() == 0) {
      apply_initial_conditions();
      apply_boundary_conditions();
      if (time.do_save()) {
        write_results();
      }
    }
    time.next();
    apply_boundary_conditions();
    model.step(time.get_current());
    if (time.do_save()) {
      write_results();
    }
    return;
  }
 
  bool done() {
    Time &time = get_time();
    return time.done();
  }
};
 
inline void step(Simulator &s, Model &m) { m.step(s.get_time().get_current()); }
 
} // namespace pfc
 
#endif // PFC_SIMULATOR_HPP