Extract exp_* to classes

Author: ProExpertProg

cpp/lib/Exponentials.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "constants.hpp"
+#include "grid.hpp"
+#include "hyper.hpp"
+
+namespace ahr::exp {
+class Base {
+public:
+  explicit Base(Grid const &grid) : grid(grid) {}
+
+  void update(HyperCoefficients hyper, Real dt) {
+    this->hyper = hyper;
+    this->dt = dt;
+  }
+
+protected:
+  Grid const &grid;
+  HyperCoefficients hyper{};
+  Real dt{-1};
+};
+
+class Eta : Base {
+public:
+  using Base::Base;
+  using Base::update;
+
+  Real operator()(Dim kx, Dim ky) {
+    return std::exp(
+        -(res * grid.kPerp2(kx, ky) + hyper.eta2 * std::pow(grid.kPerp2(kx, ky), hyper_order)) *
+        dt / (1.0 + grid.kPerp2(kx, ky) * de * de));
+  }
+};
+
+class Nu : Base {
+public:
+  using Base::Base;
+  using Base::update;
+
+  Real operator()(Dim kx, Dim ky) {
+    return std::exp(
+        -(nu * grid.kPerp2(kx, ky) + hyper.nu_2 * std::pow(grid.kPerp2(kx, ky), hyper_order)) * dt);
+  }
+};
+
+class NuG : Base {
+public:
+  using Base::Base;
+  using Base::update;
+
+  Real operator()(Dim kx, Dim ky) {
+    return std::exp(
+        -(nu * grid.kPerp2(kx, ky) + hyper.nu_g * std::pow(grid.kPerp2(kx, ky), hyper_order)) * dt);
+  }
+};
+
+class GM : Base {
+public:
+  using Base::Base;
+  using Base::update;
+
+  Real operator()(Dim m) {
+    return std::exp(-(Real(m) * nu_ei + std::pow(m, 2 * hyper_morder) * hyper.nu_ei) * dt);
+  }
+};
+
+} // namespace ahr::exp

cpp/lib/Naive.cpp

@@ -81,9 +81,14 @@ void Naive::run(Dim N, Dim saveInterval) {
       divergent = false;
     } else if (dt == -1) {
       dt = getTimestep(dPhi, Grid::sliceXY(dGM, N_E), Grid::sliceXY(dGM, A_PAR));
-      hyper = HyperCoefficients::calculate(dt, g);
     }
 
+    hyper = HyperCoefficients::calculate(dt, g);
+    exp_nu.update(hyper, dt);
+    exp_nu_g.update(hyper, dt);
+    exp_eta.update(hyper, dt);
+    exp_gm.update(hyper, dt);
+
     spdlog::debug("dt: {}", dt);
 
     // store results of nonlinear operators, as well as results of predictor step
@@ -396,7 +401,6 @@ void Naive::run(Dim N, Dim saveInterval) {
     Real tempDt =
         getTimestep(dPhi_Loop, Grid::sliceXY(dGM_Loop, N_E), Grid::sliceXY(dGM_Loop, A_PAR));
     dt = updateTimestep(dt, tempDt, noInc, relative_error);
-    hyper = HyperCoefficients::calculate(dt, g);
 
     spdlog::info("Moving on to next timestep: {}\n"
                  "dt is: {}",
@@ -419,7 +423,6 @@ void Naive::run(Dim N, Dim saveInterval) {
     spdlog::info("t={} magnetic energy: {}, kinetic energy: {}", t, magnetic, kinetic);
 
     // Log moment values when level is trace (most verbose)
-
     for (Dim m = 0; m < g.M; ++m) {
       spdlog::trace(
           "t={} m={}:\n{}", t, m,

cpp/lib/Naive.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Brackets.hpp"
+#include "Exponentials.hpp"
 #include "Exporter.hpp"
 #include "Filter.hpp"
 #include "HermiteRunner.hpp"
@@ -97,25 +98,12 @@ class Naive : public ahr::HermiteRunner {
   // TODO other file/class
   // =================
 
-  [[nodiscard]] Real exp_nu(Dim kx, Dim ky) const {
-    return std::exp(
-        -(nu * g.kPerp2(kx, ky) + hyper.nu_2 * std::pow(g.kPerp2(kx, ky), hyper_order)) * dt);
-  }
-
-  [[nodiscard]] Real exp_nu_g(Dim kx, Dim ky) const {
-    return std::exp(
-        -(nu * g.kPerp2(kx, ky) + hyper.nu_g * std::pow(g.kPerp2(kx, ky), hyper_order)) * dt);
-  }
-
-  [[nodiscard]] Real exp_gm(Dim m) const {
-    return std::exp(-(Real(m) * nu_ei + std::pow(m, 2 * hyper_morder) * hyper.nu_ei) * dt);
-  }
-
-  [[nodiscard]] Real exp_eta(Dim kx, Dim ky) const {
-    return std::exp(
-        -(res * g.kPerp2(kx, ky) + hyper.eta2 * std::pow(g.kPerp2(kx, ky), hyper_order)) * dt /
-        (1.0 + g.kPerp2(kx, ky) * de * de));
-  }
+  /// \defgroup @{
+  exp::Nu exp_nu{g};
+  exp::NuG exp_nu_g{g};
+  exp::Eta exp_eta{g};
+  exp::GM exp_gm{g};
+  /// @}
 
   /// getTimestep calculates flows and magnetic fields to determine a dt.
   /// It also updates bPerpMax in the process.