model.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_MODEL_HPP
#define PFC_MODEL_HPP
 
#include "core/decomposition.hpp"
#include "core/world.hpp"
#include "fft.hpp"
#include "mpi.hpp"
#include "openpfc/backends/heffte_adapter.hpp"
#include "types.hpp"
#include <algorithm>
#include <iostream>
#include <memory>
#include <numeric>
#include <string_view>
#include <vector>
 
namespace pfc {
 
class Model {
private:
  FFT &m_fft;
  RealFieldSet m_real_fields;       
  ComplexFieldSet m_complex_fields; 
  const World &m_world;             
  heffte::box3d<int> domain;        
  bool m_rank0 = false;             
 
public:
  ~Model() {}
 
  Model(FFT &fft, const World &world)
      : m_fft(fft), m_world(world),
        domain(to_heffte_box(world)), // Use to_heffte_box
        m_rank0(mpi::get_rank() == 0) {}
 
  Model(const Model &) = delete;
 
  Model &operator=(const Model &) = delete;
 
  inline bool is_rank0() const noexcept { return m_rank0; }
 
  /*
  const Decomposition &get_decomposition() { return get_fft().get_decomposition(); }
  */
 
  const World &get_world() const noexcept { return m_world; }
 
  [[nodiscard]] FFT &get_fft() noexcept { return m_fft; }
 
  virtual void step(double t) = 0;
 
  virtual void initialize(double dt) = 0;
 
  virtual size_t get_allocated_memory_bytes() const { return 0; }
 
  [[nodiscard]] bool has_real_field(std::string_view field_name) const noexcept {
    return m_real_fields.count(std::string(field_name)) > 0;
  }
 
  void add_real_field(std::string_view name, RealField &field) {
    m_real_fields.emplace(std::string(name), field);
  }
 
  [[nodiscard]] bool has_complex_field(std::string_view field_name) const noexcept {
    return m_complex_fields.count(std::string(field_name)) > 0;
  }
 
  void add_complex_field(std::string_view name, ComplexField &field) {
    m_complex_fields.emplace(std::string(name), field);
  }
 
  [[nodiscard]] RealField &get_real_field(std::string_view name) {
    auto it = m_real_fields.find(std::string(name));
    if (it == m_real_fields.end()) {
      throw std::out_of_range("Real field '" + std::string(name) +
                              "' not found. "
                              "Available fields: " +
                              list_field_names());
    }
    return it->second;
  }
 
  [[nodiscard]] const RealField &get_real_field(std::string_view name) const {
    auto it = m_real_fields.find(std::string(name));
    if (it == m_real_fields.end()) {
      throw std::out_of_range("Real field '" + std::string(name) +
                              "' not found. "
                              "Available fields: " +
                              list_field_names());
    }
    return it->second;
  }
 
  [[nodiscard]] ComplexField &get_complex_field(std::string_view name) {
    auto it = m_complex_fields.find(std::string(name));
    if (it == m_complex_fields.end()) {
      throw std::out_of_range("Complex field '" + std::string(name) +
                              "' not found. "
                              "Available fields: " +
                              list_field_names());
    }
    return it->second;
  }
 
  [[nodiscard]] const ComplexField &get_complex_field(std::string_view name) const {
    auto it = m_complex_fields.find(std::string(name));
    if (it == m_complex_fields.end()) {
      throw std::out_of_range("Complex field '" + std::string(name) +
                              "' not found. "
                              "Available fields: " +
                              list_field_names());
    }
    return it->second;
  }
 
  void add_field(const std::string &name, RealField &field) {
    add_real_field(name, field);
  }
 
  void add_field(const std::string &name, ComplexField &field) {
    add_complex_field(name, field);
  }
 
  [[nodiscard]] bool has_field(std::string_view field_name) const noexcept {
    return has_real_field(field_name) || has_complex_field(field_name);
  }
 
  virtual Field &get_field() {
    if (!has_real_field("default")) {
      throw std::runtime_error("'default' field is not defined.");
    }
    return get_real_field("default");
  };
 
private:
  std::string list_field_names() const {
    std::vector<std::string> names;
    for (const auto &[name, _] : m_real_fields) {
      names.push_back(name);
    }
    for (const auto &[name, _] : m_complex_fields) {
      names.push_back(name);
    }
    if (names.empty()) {
      return "(none)";
    }
    return std::accumulate(
        std::next(names.begin()), names.end(), names[0],
        [](const std::string &a, const std::string &b) { return a + ", " + b; });
  }
};
 
} // namespace pfc
 
#endif