Move m_inbox and m_outbox to FFT class

ahojukka5 · ahojukka5 · commit d70ef2a7225f · 2025-05-05T22:01:53.000+03:00
diff --git a/apps/aluminumNew/Aluminum.hpp b/apps/aluminumNew/Aluminum.hpp
@@ -163,6 +163,7 @@ class Aluminum : public Model {
 
   void prepare_operators(double dt) {
     const Decomposition &decomp = get_decomposition();
+    const FFT &fft = get_fft();
     World w = decomposition::get_world(decomp);
     auto spacing = get_spacing(w);
     auto size = get_size(w);
@@ -173,8 +174,8 @@ class Aluminum : public Model {
     auto Ly = size[1];
     auto Lz = size[2];
 
-    std::array<int, 3> low = get_outbox(decomp).low;
-    std::array<int, 3> high = get_outbox(decomp).high;
+    std::array<int, 3> low = get_outbox(fft).low;
+    std::array<int, 3> high = get_outbox(fft).high;
 
     int idx = 0;
     const double pi = std::atan(1.0) * 4.0;
@@ -242,9 +243,8 @@ class Aluminum : public Model {
     double dx = get_spacing(w, 0);
     double x0 = get_origin(w, 0);
     int Lx = get_size(w, 0);
-    const Decomposition &decomp = get_decomposition();
-    Int3 low = get_inbox(decomp).low;
-    Int3 high = get_inbox(decomp).high;
+    Int3 low = get_inbox(fft).low;
+    Int3 high = get_inbox(fft).high;
 
     // Calculate mean-field density n_mf
     fft.forward(psi, psi_F);
diff --git a/apps/aluminumNew/SeedGridFCC.hpp b/apps/aluminumNew/SeedGridFCC.hpp
@@ -62,10 +62,10 @@ class SeedGridFCC : public FieldModifier {
    */
   void apply(Model &m, double) override {
     const World &w = m.get_world();
-    const Decomposition &decomp = m.get_decomposition();
+    const FFT &fft = m.get_fft();
     Field &field = m.get_real_field("psi");
-    Int3 low = get_inbox(decomp).low;
-    Int3 high = get_inbox(decomp).high;
+    Int3 low = get_inbox(fft).low;
+    Int3 high = get_inbox(fft).high;
 
     // Use the new World API to get size, spacing, and origin
     auto size = get_size(w);
diff --git a/apps/aluminumNew/SlabFCC.hpp b/apps/aluminumNew/SlabFCC.hpp
@@ -72,10 +72,10 @@ class SlabFCC : public FieldModifier {
    */
   void apply(Model &m, double) override {
     const World &w = m.get_world();
-    const Decomposition &decomp = m.get_decomposition();
+    const FFT &fft = m.get_fft();
     Field &field = m.get_real_field("psi");
-    Int3 low = get_inbox(decomp).low;
-    Int3 high = get_inbox(decomp).high;
+    Int3 low = get_inbox(fft).low;
+    Int3 high = get_inbox(fft).high;
 
     // auto Lx = w.Lx;
     auto Ly = get_size(w, 1);
diff --git a/apps/tungsten.cpp b/apps/tungsten.cpp
@@ -102,6 +102,7 @@ class Tungsten : public Model {
   }
 
   void prepare_operators(double dt) {
+    const FFT &fft = get_fft();
     const Decomposition &decomp = get_decomposition();
     World w = decomposition::get_world(decomp);
     auto spacing = get_spacing(w);
@@ -113,8 +114,8 @@ class Tungsten : public Model {
     auto Ly = size[1];
     auto Lz = size[2];
 
-    std::array<int, 3> low = get_outbox(decomp).low;
-    std::array<int, 3> high = get_outbox(decomp).high;
+    std::array<int, 3> low = get_outbox(fft).low;
+    std::array<int, 3> high = get_outbox(fft).high;
 
     int idx = 0;
     const double pi = std::atan(1.0) * 4.0;
diff --git a/examples/02_domain_decomposition.cpp b/examples/02_domain_decomposition.cpp
@@ -33,18 +33,18 @@ int main(int argc, char *argv[]) {
   int comm_rank = 0, comm_size = 2;
   World world1 = world::create({32, 4, 4});
   Decomposition decomp1 = make_decomposition(world1, comm_rank, comm_size);
-  cout << decomp1 << endl;
+  // cout << decomp1 << endl;
 
   // In practice, we let MPI communicator to decide the number of subdomains.
   MPI_Init(&argc, &argv);
   MPI_Comm comm = MPI_COMM_WORLD;
   MPI_Comm_rank(comm, &comm_rank);
   World world2 = world::create({32, 4, 4});
   Decomposition decomp2 = make_decomposition(world2, comm);
-  if (comm_rank == 0) cout << decomp2 << endl;
+  // if (comm_rank == 0) cout << decomp2 << endl;
 
   // By default, MPI_COMM_WORLD is used, so the above example can be simplified:
-  cout << make_decomposition(world2) << endl;
+  // cout << make_decomposition(world2) << endl;
 
   MPI_Finalize();
   return 0;
diff --git a/examples/04_diffusion_model.cpp b/examples/04_diffusion_model.cpp
@@ -110,10 +110,10 @@ class Diffusion : public Model {
     Upper and lower limits for this particular MPI rank, in both inbox and
     outbox, are given by domain decomposition object
     */
-    Int3 i_low = get_inbox(decomp).low;
-    Int3 i_high = get_inbox(decomp).high;
-    Int3 o_low = get_outbox(decomp).low;
-    Int3 o_high = get_outbox(decomp).high;
+    Int3 i_low = get_inbox(fft).low;
+    Int3 i_high = get_inbox(fft).high;
+    Int3 o_low = get_outbox(fft).low;
+    Int3 o_high = get_outbox(fft).high;
 
     /*
     Typically initial conditions are constructed elsewhere. However, to keep
diff --git a/examples/05_simulator.cpp b/examples/05_simulator.cpp
@@ -50,10 +50,10 @@ class GaussianIC : public FieldModifier {
   void apply(Model &m, double t) override {
     (void)t; // suppress compiler warning about unused parameter
     const World &w = m.get_world();
-    const Decomposition &decomp = m.get_decomposition();
+    const FFT &fft = m.get_fft();
     std::vector<double> &field = m.get_real_field("psi");
-    Int3 low = get_inbox(decomp).low;
-    Int3 high = get_inbox(decomp).high;
+    Int3 low = get_inbox(fft).low;
+    Int3 high = get_inbox(fft).high;
 
     if (m.is_rank0()) std::cout << "Create initial condition" << std::endl;
     size_t idx = 0;
@@ -100,8 +100,9 @@ class Diffusion : public Model {
   void prepare_operators(double dt) {
     const Decomposition &decomp = get_decomposition();
     const World &w = decomposition::get_world(decomp);
-    std::array<int, 3> low = get_outbox(decomp).low;
-    std::array<int, 3> high = get_outbox(decomp).high;
+    FFT &fft = get_fft();
+    std::array<int, 3> low = get_outbox(fft).low;
+    std::array<int, 3> high = get_outbox(fft).high;
 
     if (is_rank0()) std::cout << "Prepare operators" << std::endl;
     size_t idx = 0;
diff --git a/examples/08_discrete_fields.cpp b/examples/08_discrete_fields.cpp
@@ -52,23 +52,23 @@ int main() {
   Decomposition decomp4 = make_decomposition(world, 3, 4);
 
   std::cout << decomp1 << std::endl;
-  const std::array<int, 3> &inbox_size1 = get_inbox_size(decomp1);
-  const std::array<int, 3> &inbox_offset1 = get_inbox_offset(decomp1);
+  const std::array<int, 3> &inbox_size1 = get_inbox(decomp1).size;
+  const std::array<int, 3> &inbox_offset1 = get_inbox(decomp1).low;
   DiscreteField<double, 3> field1(inbox_size1, inbox_offset1, get_origin(world),
                                   get_spacing(world));
 
-  const std::array<int, 3> &inbox_size2 = get_inbox_size(decomp2);
-  const std::array<int, 3> &inbox_offset2 = get_inbox_offset(decomp2);
+  const std::array<int, 3> &inbox_size2 = get_inbox(decomp2).size;
+  const std::array<int, 3> &inbox_offset2 = get_inbox(decomp2).low;
   DiscreteField<double, 3> field2(inbox_size2, inbox_offset2, get_origin(world),
                                   get_spacing(world));
 
-  const std::array<int, 3> &inbox_size3 = get_inbox_size(decomp3);
-  const std::array<int, 3> &inbox_offset3 = get_inbox_offset(decomp3);
+  const std::array<int, 3> &inbox_size3 = get_inbox(decomp3).size;
+  const std::array<int, 3> &inbox_offset3 = get_inbox(decomp3).low;
   DiscreteField<double, 3> field3(inbox_size3, inbox_offset3, get_origin(world),
                                   get_spacing(world));
 
-  const std::array<int, 3> &inbox_size4 = get_inbox_size(decomp4);
-  const std::array<int, 3> &inbox_offset4 = get_inbox_offset(decomp4);
+  const std::array<int, 3> &inbox_size4 = get_inbox(decomp4).size;
+  const std::array<int, 3> &inbox_offset4 = get_inbox(decomp4).low;
   DiscreteField<double, 3> field4(inbox_size4, inbox_offset4, get_origin(world),
                                   get_spacing(world));
   std::cout << field1 << std::endl;
diff --git a/examples/09_parallel_fft_high_level.cpp b/examples/09_parallel_fft_high_level.cpp
@@ -17,8 +17,8 @@ int main(int argc, char *argv[]) {
   // Create input field
   // DiscreteField<double, 3> input(decomp);
 
-  auto dimensions = get_inbox_size(decomp);
-  auto offsets = get_inbox_offset(decomp);
+  auto dimensions = decomp.m_inbox.size;
+  auto offsets = decomp.m_inbox.low;
   auto origin = get_origin(world);
   auto discretization = get_spacing(world);
   DiscreteField<double, 3> input(dimensions, offsets, origin, discretization);
@@ -30,21 +30,21 @@ int main(int argc, char *argv[]) {
   // Fill input field with random numbers
   apply(input, [&](auto, auto, auto) { return dis(gen); });
 
+  auto plan_options = heffte::default_options<heffte::backend::fftw>();
+  FFT fft(decomp, MPI_COMM_WORLD, plan_options, world);
+
   // Create output array to store FFT results. If requested array is of type T =
   // complex<double>, then array will be constructed using complex indices so
   // that it matches the Fourier-space, i.e. first dimension is floor(Lx/2) + 1.
-  Array<complex<double>, 3> output(decomp);
+  Array<complex<double>, 3> output(get_outbox_size(fft));
 
   std::cout << "input: " << input << std::endl;   // this is {4, 3, 2}
   std::cout << "output: " << output << std::endl; // this is {3, 3, 2}
 
   // This would construct an array of type T = <double> with different indices
-  // Array<double, 3> output2(decomp);
+  // Array<double, 3> output2(fft);
   // std::cout << output2 << std::endl; // this is {4, 3, 2}
 
-  auto plan_options = heffte::default_options<heffte::backend::fftw>();
-  FFT fft(decomp, MPI_COMM_WORLD, plan_options, world);
-
   fft.forward(input, output);
 
   // Display results
diff --git a/examples/11_write_results.cpp b/examples/11_write_results.cpp
@@ -16,8 +16,8 @@ int main(int argc, char **argv) {
   World world = world::create({4, 3, 2});
   Decomposition decomp = make_decomposition(world);
   // DiscreteField<double, 3> field(decomp);
-  auto dimensions = get_inbox_size(decomp);
-  auto offsets = get_inbox_offset(decomp);
+  auto dimensions = decomp.m_inbox.size;
+  auto offsets = decomp.m_inbox.low;
   auto origin = get_origin(world);
   auto discretization = get_spacing(world);
   DiscreteField<double, 3> field(dimensions, offsets, origin, discretization);
diff --git a/examples/12_cahn_hilliard.cpp b/examples/12_cahn_hilliard.cpp
@@ -31,7 +31,6 @@ class CahnHilliard : public Model {
 
   void initialize(double dt) override {
     FFT &fft = get_fft();
-    const Decomposition &decomp = get_decomposition();
 
     // Allocate space for the main variable and it's fourier transform
     c.resize(fft.size_inbox());
@@ -43,8 +42,8 @@ class CahnHilliard : public Model {
 
     // prepare operators
     World w = get_world();
-    std::array<int, 3> o_low = get_outbox(decomp).low;
-    std::array<int, 3> o_high = get_outbox(decomp).high;
+    std::array<int, 3> o_low = get_outbox(fft).low;
+    std::array<int, 3> o_high = get_outbox(fft).high;
     size_t idx = 0;
     double pi = std::atan(1.0) * 4.0;
     auto spacing = get_spacing(w);
@@ -143,8 +142,7 @@ int main(int argc, char **argv) {
   // file_count
   writer.set_uri(sprintf("cahn_hilliard_%04i.vti", file_count));
   writer.set_field_name("concentration");
-  writer.set_domain(get_size(world), get_inbox_size(decomp),
-                    get_inbox_offset(decomp));
+  writer.set_domain(get_size(world), get_inbox_size(fft), get_inbox_offset(fft));
   writer.set_origin(get_origin(world));
   writer.set_spacing(get_spacing(world));
   writer.initialize();
diff --git a/examples/diffusion_model.hpp b/examples/diffusion_model.hpp
@@ -22,16 +22,15 @@ class Diffusion : public Model {
 
     const World &w = get_world();
     FFT &fft = get_fft();
-    const Decomposition &decomp = get_decomposition();
 
     psi.resize(fft.size_inbox());
     psi_F.resize(fft.size_outbox());
     opL.resize(fft.size_outbox());
 
-    Vec3<int> i_low = get_inbox(decomp).low;
-    Vec3<int> i_high = get_inbox(decomp).high;
-    Vec3<int> o_low = get_outbox(decomp).low;
-    Vec3<int> o_high = get_outbox(decomp).high;
+    Vec3<int> i_low = get_inbox(fft).low;
+    Vec3<int> i_high = get_inbox(fft).high;
+    Vec3<int> o_low = get_outbox(fft).low;
+    Vec3<int> o_high = get_outbox(fft).high;
 
     auto origin = get_origin(w);
     auto spacing = get_spacing(w);
diff --git a/include/openpfc/array.hpp b/include/openpfc/array.hpp
@@ -5,6 +5,7 @@
 #define PFC_ARRAY_HPP
 
 #include "core/decomposition.hpp"
+#include "fft.hpp"
 #include "multi_index.hpp"
 #include "utils/array_to_string.hpp"
 #include "utils/show.hpp"
@@ -27,22 +28,22 @@ template <typename T, size_t D> class Array {
   std::vector<T> data;
 
   /**
-   * @brief Construct a new Array object from Decomposition, using outbox, if
+   * @brief Construct a new Array object from FFT, using outbox, if
    * is_complex<T> = true.
    *
-   * @param decomp
+   * @param fft
    */
-  Array(const Decomposition &decomp, std::true_type)
-      : index(get_outbox_size(decomp), get_outbox_offset(decomp)) {}
+  Array(const FFT &fft, std::true_type)
+      : index(get_outbox_size(fft), get_outbox_offset(fft)) {}
 
   /**
-   * @brief Construct a new Array object from Decomposition, using inbox, if
+   * @brief Construct a new Array object from FFT, using inbox, if
    * is_complex<T> = false.
    *
    * @param decomp
    */
-  Array(const Decomposition &decomp, std::false_type)
-      : index(get_inbox_size(decomp), get_inbox_offset(decomp)) {}
+  Array(const FFT &fft, std::false_type)
+      : index(get_inbox_size(fft), get_inbox_offset(fft)) {}
 
   // Custom type trait to check if a type is complex
   template <typename U> struct is_complex : std::false_type {};
diff --git a/include/openpfc/boundary_conditions/fixed_bc.hpp b/include/openpfc/boundary_conditions/fixed_bc.hpp
@@ -28,11 +28,11 @@ class FixedBC : public FieldModifier {
   const std::string &get_modifier_name() const override { return m_name; }
 
   void apply(Model &m, double) override {
-    const Decomposition &decomp = m.get_decomposition();
+    const FFT &fft = m.get_fft();
     Field &field = m.get_real_field(get_field_name());
     const World &w = m.get_world();
-    Vec3<int> low = get_inbox(decomp).low;
-    Vec3<int> high = get_inbox(decomp).high;
+    Int3 low = get_inbox(fft).low;
+    Int3 high = get_inbox(fft).high;
 
     double Lx = get_size(w, 0);
     double dx = get_spacing(w, 0);
diff --git a/include/openpfc/boundary_conditions/moving_bc.hpp b/include/openpfc/boundary_conditions/moving_bc.hpp
@@ -54,11 +54,11 @@ class MovingBC : public FieldModifier {
   const std::string &get_modifier_name() const override { return m_name; }
 
   void apply(Model &m, double) override {
-    const Decomposition &decomp = m.get_decomposition();
+    const FFT &fft = m.get_fft();
     Field &field = m.get_real_field(get_field_name());
     const World &w = m.get_world();
-    Vec3<int> low = get_inbox(decomp).low;
-    Vec3<int> high = get_inbox(decomp).high;
+    Int3 low = get_inbox(fft).low;
+    Int3 high = get_inbox(fft).high;
 
     auto Lx = get_size(w, 0);
     auto dx = get_spacing(w, 0);
@@ -111,11 +111,11 @@ class MovingBC : public FieldModifier {
   }
 
   void fill_bc(Model &m) {
-    const Decomposition &decomp = m.get_decomposition();
+    const FFT &fft = m.get_fft();
     Field &field = m.get_real_field(get_field_name());
     const World &w = m.get_world();
-    Vec3<int> low = get_inbox(decomp).low;
-    Vec3<int> high = get_inbox(decomp).high;
+    Int3 low = get_inbox(fft).low;
+    Int3 high = get_inbox(fft).high;
 
     auto Lx = get_size(w, 0);
     auto dx = get_spacing(w, 0);
diff --git a/include/openpfc/core/decomposition.hpp b/include/openpfc/core/decomposition.hpp
diff --git a/include/openpfc/fft.hpp b/include/openpfc/fft.hpp
diff --git a/include/openpfc/initial_conditions/file_reader.hpp b/include/openpfc/initial_conditions/file_reader.hpp
diff --git a/include/openpfc/initial_conditions/seed_grid.hpp b/include/openpfc/initial_conditions/seed_grid.hpp
diff --git a/include/openpfc/initial_conditions/single_seed.hpp b/include/openpfc/initial_conditions/single_seed.hpp
