rename ProcessSetPolicy to RatesPolicy

include/micm/solver/backward_euler.hpp

@@ -4,8 +4,6 @@
  */
 #pragma once
 
-#include <micm/process/process.hpp>
-#include <micm/process/process_set.hpp>
 #include <micm/profiler/instrumentation.hpp>
 #include <micm/solver/backward_euler_solver_parameters.hpp>
 #include <micm/solver/linear_solver.hpp>
@@ -30,27 +28,31 @@ namespace micm
 {
 
   /// @brief An implementation of the fully implicit backward euler method
-  template<class LinearSolverPolicy, class ProcessSetPolicy>
+  template<class LinearSolverPolicy, class RatesPolicy>
   class BackwardEuler
   {
     BackwardEulerSolverParameters parameters_;
     LinearSolverPolicy linear_solver_;
-    ProcessSetPolicy process_set_;
+    RatesPolicy rates_;
     std::vector<std::size_t> jacobian_diagonal_elements_;
 
    public:
     /// @brief Solver parameters typename
     using ParametersType = BackwardEulerSolverParameters;
 
     /// @brief Default constructor
+    /// @param parameters Solver parameters
+    /// @param linear_solver Linear solver
+    /// @param rates Rates calculator
+    /// @param jacobian Jacobian matrix
     BackwardEuler(
         BackwardEulerSolverParameters parameters,
         LinearSolverPolicy&& linear_solver,
-        ProcessSetPolicy&& process_set,
+        RatesPolicy&& rates,
         auto& jacobian)
         : parameters_(parameters),
           linear_solver_(std::move(linear_solver)),
-          process_set_(std::move(process_set)),
+          rates_(std::move(rates)),
           jacobian_diagonal_elements_(jacobian.DiagonalIndices(0))
     {
     }

include/micm/solver/backward_euler.inl

@@ -42,8 +42,8 @@ inline std::error_code make_error_code(MicmBackwardEulerErrc e)
 
 namespace micm
 {
-  template<class LinearSolverPolicy, class ProcessSetPolicy>
-  inline SolverResult BackwardEuler<LinearSolverPolicy, ProcessSetPolicy>::Solve(double time_step, auto& state)
+  template<class LinearSolverPolicy, class RatesPolicy>
+  inline SolverResult BackwardEuler<LinearSolverPolicy, RatesPolicy>::Solve(double time_step, auto& state)
   {
     // A fully implicit euler implementation is given by the following equation:
     // y_{n+1} = y_n + H * f(t_{n+1}, y_{n+1})
@@ -89,11 +89,11 @@ namespace micm
         // so we can use Yn1 to calculate the forcing and jacobian
         // calculate forcing
         std::fill(forcing.AsVector().begin(), forcing.AsVector().end(), 0.0);
-        process_set_.AddForcingTerms(state.rate_constants_, Yn1, forcing);
+        rates_.AddForcingTerms(state.rate_constants_, Yn1, forcing);
 
         // calculate jacobian
         std::fill(state.jacobian_.AsVector().begin(), state.jacobian_.AsVector().end(), 0.0);
-        process_set_.SubtractJacobianTerms(state.rate_constants_, Yn1, state.jacobian_);
+        rates_.SubtractJacobianTerms(state.rate_constants_, Yn1, state.jacobian_);
 
         // subtract the inverse of the time step from the diagonal
         // TODO: handle vectorized jacobian matrix

include/micm/solver/backward_euler_solver_parameters.hpp

@@ -12,14 +12,14 @@
 namespace micm
 {
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
   class BackwardEuler;
 
   /// @brief BackwardEuler solver parameters
   struct BackwardEulerSolverParameters
   {
-    template<class ProcessSetPolicy, class LinearSolverPolicy>
-    using SolverType = BackwardEuler<LinearSolverPolicy, ProcessSetPolicy>;
+    template<class RatesPolicy, class LinearSolverPolicy>
+    using SolverType = BackwardEuler<LinearSolverPolicy, RatesPolicy>;
 
     std::vector<double> absolute_tolerance_;
     double small{ 1.0e-40 };

include/micm/solver/cuda_rosenbrock.hpp

@@ -4,9 +4,7 @@
  */
 #pragma once
 
-#include <micm/process/cuda_process_set.hpp>
 #include <micm/process/process.hpp>
-#include <micm/process/process_set.hpp>
 #include <micm/solver/cuda_linear_solver.hpp>
 #include <micm/solver/cuda_rosenbrock.cuh>
 #include <micm/solver/linear_solver.hpp>
@@ -32,8 +30,8 @@
 namespace micm
 {
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
-  class CudaRosenbrockSolver : public RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
+  class CudaRosenbrockSolver : public RosenbrockSolver<RatesPolicy, LinearSolverPolicy>
   {
     ///@brief Default constructor
    public:
@@ -47,7 +45,7 @@ namespace micm
     CudaRosenbrockSolver(const CudaRosenbrockSolver&) = delete;
     CudaRosenbrockSolver& operator=(const CudaRosenbrockSolver&) = delete;
     CudaRosenbrockSolver(CudaRosenbrockSolver&& other)
-        : RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>(std::move(other)),
+        : RosenbrockSolver<RatesPolicy, LinearSolverPolicy>(std::move(other)),
           devstruct_(std::move(other.devstruct_))
     {
       other.devstruct_.errors_input_ = nullptr;
@@ -58,7 +56,7 @@ namespace micm
 
     CudaRosenbrockSolver& operator=(CudaRosenbrockSolver&& other)
     {
-      RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>::operator=(std::move(other));
+      RosenbrockSolver<RatesPolicy, LinearSolverPolicy>::operator=(std::move(other));
       devstruct_ = std::move(other.devstruct_);
       other.devstruct_.errors_input_ = nullptr;
       other.devstruct_.errors_output_ = nullptr;
@@ -77,17 +75,17 @@ namespace micm
     /// @brief Builds a CUDA Rosenbrock solver for the given system and solver parameters
     /// @param parameters Solver parameters
     /// @param linear_solver Linear solver
-    /// @param process_set Process set
+    /// @param rates Rates calculator
     /// @param jacobian Jacobian matrix
     CudaRosenbrockSolver(
         RosenbrockSolverParameters parameters,
         LinearSolverPolicy&& linear_solver,
-        ProcessSetPolicy&& process_set,
+        RatesPolicy&& rates,
         auto& jacobian)
-        : RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>(
+        : RosenbrockSolver<RatesPolicy, LinearSolverPolicy>(
               parameters,
               std::move(linear_solver),
-              std::move(process_set),
+              std::move(rates),
               jacobian)
     {
       CudaRosenbrockSolverParam hoststruct;

include/micm/solver/cuda_solver_parameters.hpp

@@ -11,8 +11,8 @@ namespace micm
     /// @brief Parameters for the CUDA Rosenbrock solver
     struct CudaRosenbrockSolverParameters : public RosenbrockSolverParameters
     {
-        template<class ProcessSetPolicy, class LinearSolverPolicy>
-        using SolverType = CudaRosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>;
+        template<class RatesPolicy, class LinearSolverPolicy>
+        using SolverType = CudaRosenbrockSolver<RatesPolicy, LinearSolverPolicy>;
 
         /// @brief Constructor from base class
         /// @param base

include/micm/solver/jit_rosenbrock.hpp

@@ -16,7 +16,6 @@
 #pragma once
 
 #include <micm/jit/jit_function.hpp>
-#include <micm/process/jit_process_set.hpp>
 #include <micm/solver/jit_linear_solver.hpp>
 #include <micm/solver/rosenbrock.hpp>
 #include <micm/solver/rosenbrock_solver_parameters.hpp>
@@ -33,8 +32,8 @@ namespace micm
   struct JitRosenbrockSolverParameters;
 
   /// @brief A Rosenbrock solver with JIT-compiled optimizations
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
-  class JitRosenbrockSolver : public RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
+  class JitRosenbrockSolver : public RosenbrockSolver<RatesPolicy, LinearSolverPolicy>
   {
     llvm::orc::ResourceTrackerSP function_resource_tracker_;
     using FuncPtr = void (*)(double*, const double);
@@ -48,7 +47,7 @@ namespace micm
     JitRosenbrockSolver(const JitRosenbrockSolver&) = delete;
     JitRosenbrockSolver& operator=(const JitRosenbrockSolver&) = delete;
     JitRosenbrockSolver(JitRosenbrockSolver&& other)
-        : RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>(std::move(other)),
+        : RosenbrockSolver<RatesPolicy, LinearSolverPolicy>(std::move(other)),
           function_resource_tracker_(std::move(other.function_resource_tracker_)),
           alpha_minus_jacobian_(std::move(other.alpha_minus_jacobian_))
     {
@@ -57,7 +56,7 @@ namespace micm
 
     JitRosenbrockSolver& operator=(JitRosenbrockSolver&& other)
     {
-      RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>::operator=(std::move(other));
+      RosenbrockSolver<RatesPolicy, LinearSolverPolicy>::operator=(std::move(other));
       function_resource_tracker_ = std::move(other.function_resource_tracker_);
       alpha_minus_jacobian_ = std::move(other.alpha_minus_jacobian_);
       other.alpha_minus_jacobian_ = NULL;
@@ -67,17 +66,17 @@ namespace micm
     /// @brief Builds a Rosenbrock solver for the given system and solver parameters
     /// @param parameters Solver parameters
     /// @param linear_solver Linear solver
-    /// @param process_set Process set
+    /// @param rates Rates calculator
     /// @param jacobian Jacobian matrix
     JitRosenbrockSolver(
         RosenbrockSolverParameters parameters,
         LinearSolverPolicy linear_solver,
-        ProcessSetPolicy process_set,
+        RatesPolicy rates,
         auto& jacobian)
-        : RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>(
+        : RosenbrockSolver<RatesPolicy, LinearSolverPolicy>(
               parameters,
               std::move(linear_solver),
-              std::move(process_set),
+              std::move(rates),
               jacobian)
     {
       this->GenerateAlphaMinusJacobian(jacobian);

include/micm/solver/jit_solver_parameters.hpp

@@ -11,8 +11,8 @@ namespace micm
     /// @brief Parameters for the JIT Rosenbrock solver
     struct JitRosenbrockSolverParameters : public RosenbrockSolverParameters
     {
-        template<class ProcessSetPolicy, class LinearSolverPolicy>
-        using SolverType = JitRosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>;
+        template<class RatesPolicy, class LinearSolverPolicy>
+        using SolverType = JitRosenbrockSolver<RatesPolicy, LinearSolverPolicy>;
 
         /// @brief Constructor from base class
         /// @param base

include/micm/solver/rosenbrock.hpp

@@ -15,8 +15,6 @@
  */
 #pragma once
 
-#include <micm/process/process.hpp>
-#include <micm/process/process_set.hpp>
 #include <micm/profiler/instrumentation.hpp>
 #include <micm/solver/linear_solver.hpp>
 #include <micm/solver/rosenbrock_solver_parameters.hpp>
@@ -42,17 +40,17 @@ namespace micm
 {
 
   /// @brief An implementation of the Rosenbrock ODE solver
-  /// @tparam ProcessSetPolicy The policy to use for the process set
-  /// @tparam LinearSolverPolicy The policy to use for the linear solver
+  /// @tparam RatesPolicy Calculator of forcing and Jacobian terms
+  /// @tparam LinearSolverPolicy Linear solver
   ///
   /// The template parameter is the type of matrix to use
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
   class RosenbrockSolver
   {
    public:
     RosenbrockSolverParameters parameters_;
     LinearSolverPolicy linear_solver_;
-    ProcessSetPolicy process_set_;
+    RatesPolicy rates_;
     std::vector<std::size_t> jacobian_diagonal_elements_;
 
     static constexpr double DELTA_MIN = 1.0e-6;
@@ -61,16 +59,20 @@ namespace micm
     using ParametersType = RosenbrockSolverParameters;
 
     /// @brief Default constructor
+    /// @param parameters Solver parameters
+    /// @param linear_solver Linear solver
+    /// @param rates Rates calculator
+    /// @param jacobian Jacobian matrix
     ///
     /// Note: This constructor is not intended to be used directly. Instead, use the SolverBuilder to create a solver
     RosenbrockSolver(
         RosenbrockSolverParameters parameters,
         LinearSolverPolicy linear_solver,
-        ProcessSetPolicy process_set,
+        RatesPolicy rates,
         auto& jacobian)
         : parameters_(parameters),
           linear_solver_(std::move(linear_solver)),
-          process_set_(std::move(process_set)),
+          rates_(std::move(rates)),
           jacobian_diagonal_elements_(jacobian.DiagonalIndices(0))
     {
     }

include/micm/solver/rosenbrock.inl

@@ -3,8 +3,8 @@
 namespace micm
 {
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
-  inline SolverResult RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>::Solve(
+  template<class RatesPolicy, class LinearSolverPolicy>
+  inline SolverResult RosenbrockSolver<RatesPolicy, LinearSolverPolicy>::Solve(
       double time_step,
       auto& state) noexcept
   {
@@ -69,12 +69,12 @@ namespace micm
 
       // compute the forcing at the beginning of the current time
       initial_forcing.Fill(0.0);
-      process_set_.AddForcingTerms(state.rate_constants_, Y, initial_forcing);
+      rates_.AddForcingTerms(state.rate_constants_, Y, initial_forcing);
       stats.function_calls_ += 1;
 
       // compute the negative jacobian at the beginning of the current time
       state.jacobian_.Fill(0.0);
-      process_set_.SubtractJacobianTerms(state.rate_constants_, Y, state.jacobian_);
+      rates_.SubtractJacobianTerms(state.rate_constants_, Y, state.jacobian_);
       stats.jacobian_updates_ += 1;
 
       bool accepted = false;
@@ -108,7 +108,7 @@ namespace micm
                 Ynew.Axpy(parameters_.a_[stage_combinations + j], K[j]);
               }
               forcing.Fill(0.0);
-              process_set_.AddForcingTerms(state.rate_constants_, Ynew, forcing);
+              rates_.AddForcingTerms(state.rate_constants_, Ynew, forcing);
               stats.function_calls_ += 1;
             }
           }
@@ -203,9 +203,9 @@ namespace micm
     return result;
   }
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
   template<class SparseMatrixPolicy>
-  inline void RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>::AlphaMinusJacobian(
+  inline void RosenbrockSolver<RatesPolicy, LinearSolverPolicy>::AlphaMinusJacobian(
       SparseMatrixPolicy& jacobian,
       const double& alpha) const requires(!VectorizableSparse<SparseMatrixPolicy>)
   {
@@ -219,9 +219,9 @@ namespace micm
     }
   }
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
   template<class SparseMatrixPolicy>
-  inline void RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>::AlphaMinusJacobian(
+  inline void RosenbrockSolver<RatesPolicy, LinearSolverPolicy>::AlphaMinusJacobian(
       SparseMatrixPolicy& jacobian,
       const double& alpha) const requires(VectorizableSparse<SparseMatrixPolicy>)
   {
@@ -237,8 +237,8 @@ namespace micm
     }
   }
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
-  inline void RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>::LinearFactor(
+  template<class RatesPolicy, class LinearSolverPolicy>
+  inline void RosenbrockSolver<RatesPolicy, LinearSolverPolicy>::LinearFactor(
       double& H,
       const double gamma,
       bool& singular,
@@ -275,9 +275,9 @@ namespace micm
     }
   }
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
   template<class DenseMatrixPolicy>
-  inline double RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>::NormalizedError(
+  inline double RosenbrockSolver<RatesPolicy, LinearSolverPolicy>::NormalizedError(
       const DenseMatrixPolicy& Y,
       const DenseMatrixPolicy& Ynew,
       const DenseMatrixPolicy& errors) const requires(!VectorizableDense<DenseMatrixPolicy>)
@@ -310,9 +310,9 @@ namespace micm
     return std::max(std::sqrt(error / N), error_min);
   }
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
   template<class DenseMatrixPolicy>
-  inline double RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>::NormalizedError(
+  inline double RosenbrockSolver<RatesPolicy, LinearSolverPolicy>::NormalizedError(
       const DenseMatrixPolicy& Y,
       const DenseMatrixPolicy& Ynew,
       const DenseMatrixPolicy& errors) const requires(VectorizableDense<DenseMatrixPolicy>)

include/micm/solver/rosenbrock_solver_parameters.hpp

@@ -14,14 +14,14 @@
 namespace micm
 {
 
-  template<class ProcessSetPolicy, class LinearSolverPolicy>
+  template<class RatesPolicy, class LinearSolverPolicy>
   class RosenbrockSolver;
 
   /// @brief Rosenbrock solver parameters
   struct RosenbrockSolverParameters
   {
-    template<class ProcessSetPolicy, class LinearSolverPolicy>
-    using SolverType = RosenbrockSolver<ProcessSetPolicy, LinearSolverPolicy>;
+    template<class RatesPolicy, class LinearSolverPolicy>
+    using SolverType = RosenbrockSolver<RatesPolicy, LinearSolverPolicy>;
 
     std::size_t stages_{};
     std::size_t upper_limit_tolerance_{};