Refactor World

Author: ahojukka5

.clang-format

@@ -8,7 +8,7 @@
 IndentWidth: 2
 TabWidth: 2
 UseTab: Never
-ColumnLimit: 80
+ColumnLimit: 85
 
 # Allow things on a single line
 

apps/aluminumNew/Aluminum.hpp

@@ -20,8 +20,8 @@ class Aluminum : public Model {
 private:
   std::vector<double> filterMF, opL, opN, opEps, P_F;
   std::vector<double> psiMF, psi, psiN, P_star_psi, temperature, stress;
-  std::vector<std::complex<double>> psiMF_F, psi_F, psiN_F, P_psi_F,
-      temperature_F, stress_F;
+  std::vector<std::complex<double>> psiMF_F, psi_F, psiN_F, P_psi_F, temperature_F,
+      stress_F;
   size_t mem_allocated = 0;
   bool m_first = true;
 
@@ -80,12 +80,8 @@ class Aluminum : public Model {
   void set_x_initial(double x_initial) { params.x_initial = x_initial; }
   void set_m_xpos(double m_xpos) { params.m_xpos = m_xpos; }
   void set_alpha(double alpha) { params.alpha = alpha; }
-  void set_alpha_farTol(double alpha_farTol) {
-    params.alpha_farTol = alpha_farTol;
-  }
-  void set_alpha_highOrd(int alpha_highOrd) {
-    params.alpha_highOrd = alpha_highOrd;
-  }
+  void set_alpha_farTol(double alpha_farTol) { params.alpha_farTol = alpha_farTol; }
+  void set_alpha_highOrd(int alpha_highOrd) { params.alpha_highOrd = alpha_highOrd; }
   void set_tau_const(double tau_const) { params.tau_const = tau_const; }
   void set_lambda(double lambda) { params.lambda = lambda; }
   void set_stabP(double stabP) { params.stabP = stabP; }
@@ -279,19 +275,16 @@ class Aluminum : public Model {
           temperature[idx] = T_var;
           double q2_bar_N = params.q21_bar * T_var / params.T0;
           double q3_bar =
-              params.q31_bar * (params.T_const + T_var) / params.T0 +
-              params.q30_bar;
+              params.q31_bar * (params.T_const + T_var) / params.T0 + params.q30_bar;
           double u = psi[idx];
           double v = psiMF[idx];
-          double kernel_term_N =
-              -(1.0 - exp(-T_var / params.T0)) * P_star_psi[idx];
+          double kernel_term_N = -(1.0 - exp(-T_var / params.T0)) * P_star_psi[idx];
           psiN[idx] = params.p3_bar * u * u + params.p4_bar * u * u * u +
-                      q2_bar_N * v + q3_bar * v * v +
-                      params.q4_bar * v * v * v - kernel_term_N;
+                      q2_bar_N * v + q3_bar * v * v + params.q4_bar * v * v * v -
+                      kernel_term_N;
           local_FE += params.p3_bar * u * u * u / 3. +
-                      params.p4_bar * u * u * u * u / 4. +
-                      q2_bar_N * u * v / 2. + q3_bar * u * v * v / 3. +
-                      params.q4_bar * u * v * v * v / 4. +
+                      params.p4_bar * u * u * u * u / 4. + q2_bar_N * u * v / 2. +
+                      q3_bar * u * v * v / 3. + params.q4_bar * u * v * v * v / 4. +
                       -u * kernel_term_N * u / 2. + -u * P_star_psi[idx] / 2. +
                       params.p2_bar * u * u / 2. + params.q2_bar * u * v / 2.;
           idx++;

apps/aluminumNew/SeedGridFCC.hpp

@@ -30,8 +30,8 @@ class SeedGridFCC : public FieldModifier {
 public:
   SeedGridFCC() = default;
 
-  SeedGridFCC(int Ny, int Nz, double X0, double radius, double amplitude,
-              double rho, double rseed)
+  SeedGridFCC(int Ny, int Nz, double X0, double radius, double amplitude, double rho,
+              double rseed)
       : m_Nx(1), m_Ny(Ny), m_Nz(Nz), m_X0(X0), m_radius(radius),
         m_amplitude(amplitude), m_rho(rho), m_rseed(rseed) {}
 
@@ -98,17 +98,17 @@ class SeedGridFCC : public FieldModifier {
     double Z0 = Dz / 2.0;
     int nseeds = Nx * Ny * Nz;
 
-    std::cout << "Generating " << nseeds << " regular seeds with radius "
-              << radius << "\n";
+    std::cout << "Generating " << nseeds << " regular seeds with radius " << radius
+              << "\n";
 
     std::mt19937_64 re(rseed);
     std::uniform_real_distribution<double> rt(-0.2 * radius, 0.2 * radius);
     std::uniform_real_distribution<double> rr(0.0, 8.0 * atan(1.0));
 
     for (int j = 0; j < Ny; j++) {
       for (int k = 0; k < Nz; k++) {
-        const std::array<double, 3> location = {
-            X0 + rt(re), Y0 + Dy * j + rt(re), Z0 + Dz * k + rt(re)};
+        const std::array<double, 3> location = {X0 + rt(re), Y0 + Dy * j + rt(re),
+                                                Z0 + Dz * k + rt(re)};
         const std::array<double, 3> orientation = {rr(re), rr(re), rr(re)};
         const SeedFCC seed(location, orientation, radius, rho, amplitude);
         seeds.push_back(seed);

apps/aluminumNew/SlabFCC.hpp

@@ -78,14 +78,10 @@ class SlabFCC : public FieldModifier {
     Vec3<int> high = decomp.get_inbox().high;
 
     // auto Lx = w.Lx;
-    auto Ly = w.get_size()[1];
-    auto Lz = w.get_size()[2];
-    auto dx = w.get_spacing()[0];
-    auto dy = w.get_spacing()[1];
-    auto dz = w.get_spacing()[2];
-    auto x0 = w.get_origin()[0];
-    auto y0 = w.get_origin()[1];
-    auto z0 = w.get_origin()[2];
+    auto Ly = get_size(w, 1);
+    auto Lz = get_size(w, 2);
+    auto [dx, dy, dz] = get_spacing(w);
+    auto [x0, y0, z0] = get_origin(w);
 
     std::vector<SeedFCC> seeds;
 
@@ -117,13 +113,13 @@ class SlabFCC : public FieldModifier {
 
     if (randomized) {
 
-      std::cout << "Generating " << nseeds << " random seeds up to distance "
-                << X0 << "\n";
+      std::cout << "Generating " << nseeds << " random seeds up to distance " << X0
+                << "\n";
 
       for (int j = 0; j < Ny; j++) {
         for (int k = 0; k < Nz; k++) {
-          const std::array<double, 3> location = {
-              X0 + rt(re), Y0 + Dy * j + rt(re), Z0 + Dz * k + rt(re)};
+          const std::array<double, 3> location = {X0 + rt(re), Y0 + Dy * j + rt(re),
+                                                  Z0 + Dz * k + rt(re)};
           const std::array<double, 3> orientation = {rr(re), rr(re), rr(re)};
           const SeedFCC seed(location, orientation, radius, rho, amplitude);
           seeds.push_back(seed);
@@ -136,8 +132,8 @@ class SlabFCC : public FieldModifier {
 
       for (int j = 0; j < Ny; j++) {
         for (int k = 0; k < Nz; k++) {
-          const std::array<double, 3> location = {
-              X0 + rt(re), Y0 + Dy * j + rt(re), Z0 + Dz * k + rt(re)};
+          const std::array<double, 3> location = {X0 + rt(re), Y0 + Dy * j + rt(re),
+                                                  Z0 + Dz * k + rt(re)};
           const std::array<double, 3> orientation = orientations[j * Nz + k];
           const SeedFCC seed(location, orientation, radius, rho, amplitude);
           seeds.push_back(seed);
@@ -218,8 +214,7 @@ void from_json(const json &params, SlabFCC &ic) {
               << std::endl;
   }
   if (!params.contains("orientations") || !params["orientations"].is_array()) {
-    std::cout << "No valid orientation vector detected, randomizing."
-              << std::endl;
+    std::cout << "No valid orientation vector detected, randomizing." << std::endl;
   }
   int Nz = params["Nz"];
   int Ny = params["Ny"];

apps/tungsten.cpp

@@ -157,8 +157,7 @@ class Tungsten : public Model {
           // calculation when T is not constant in space
           double opPeak = params.Bx * exp(-params.T / params.T0) * gf;
           // includes the lowest order n_mf term since it is a linear term
-          double opCk =
-              params.stabP + params.p2_bar - opPeak + params.q2_bar * fMF;
+          double opCk = params.stabP + params.p2_bar - opPeak + params.q2_bar * fMF;
 
           filterMF[idx] = fMF;
           opL[idx] = exp(kLap * opCk * dt);

docs/getting_started/01-basics/derivative.cpp

@@ -76,8 +76,8 @@ int main(int argc, char *argv[]) {
   for (int i = ilow[0]; i <= ihigh[0]; i++) {
     double x = x0 + i * dx;
     double diff = abs(dy[i] - cos(x));
-    printf("i=%2d, x(i)=%5.2f, dy(x)=%5.2f, |dy(x)-dy_true(x)|=%0.5f\n", i, x,
-           dy[i], diff);
+    printf("i=%2d, x(i)=%5.2f, dy(x)=%5.2f, |dy(x)-dy_true(x)|=%0.5f\n", i, x, dy[i],
+           diff);
     idx += 1;
   }
 

examples/01_hello_world.cpp

@@ -40,8 +40,7 @@ int main() {
   // Retrieve world properties
   cout << "World properties:" << endl;
   auto size = get_size(world);
-  cout << "Dimensions: " << size[0] << " x " << size[1] << " x " << size[2]
-       << endl;
+  cout << "Dimensions: " << size[0] << " x " << size[1] << " x " << size[2] << endl;
   auto world_origin = get_origin(world);
   cout << "Origin: (" << world_origin[0] << ", " << world_origin[1] << ", "
        << world_origin[2] << ")" << endl;

examples/03_parallel_fft.cpp

@@ -28,8 +28,8 @@ void dft_forward(const vector<double> x, vector<complex<double>> &X) {
   fill(X.begin(), X.end(), 0.0);
   for (int n = 0, N = x.size(); n < N; n++) {
     for (int k = 0; k < N / 2 + 1; k++) {
-      X[k] += x[n] * complex<double>(cos(2 * pi / N * k * n),
-                                     -sin(2 * pi / N * k * n));
+      X[k] +=
+          x[n] * complex<double>(cos(2 * pi / N * k * n), -sin(2 * pi / N * k * n));
     }
   }
 }

examples/04_diffusion_model.cpp

@@ -64,7 +64,7 @@ class Diffusion : public Model {
   using Model::Model; // "Inherit" the default constructor of base class
 
 private:
-  vector<double> opL, psi; // Define linear operator opL and unknown (real) psi
+  vector<double> opL, psi;       // Define linear operator opL and unknown (real) psi
   vector<complex<double>> psi_F; // Define (complex) psi
 
 public:

examples/05_simulator.cpp

@@ -157,8 +157,8 @@ void print_statline(Simulator &s) {
   Diffusion &diffusion_model = dynamic_cast<Diffusion &>(model);
   double min = diffusion_model.get_psi_min();
   double max = diffusion_model.get_psi_max();
-  std::cout << "n = " << n << ", t = " << t << ", min = " << min
-            << ", max = " << max << std::endl;
+  std::cout << "n = " << n << ", t = " << t << ", min = " << min << ", max = " << max
+            << std::endl;
 }
 
 void run_simulator(Simulator &s) {