From 0d1eb8bbd25c93a4953221998c8bb9cfdb52597c Mon Sep 17 00:00:00 2001 From: Matt Dawson Date: Thu, 6 Jun 2024 14:55:35 -0700 Subject: [PATCH] rename ProcessSetPolicy to RatesPolicy --- include/micm/solver/backward_euler.hpp | 14 ++-- include/micm/solver/backward_euler.inl | 8 +-- .../backward_euler_solver_parameters.hpp | 6 +- include/micm/solver/cuda_rosenbrock.hpp | 18 +++-- .../micm/solver/cuda_solver_parameters.hpp | 4 +- include/micm/solver/jit_rosenbrock.hpp | 17 +++-- include/micm/solver/jit_solver_parameters.hpp | 4 +- include/micm/solver/rosenbrock.hpp | 18 ++--- include/micm/solver/rosenbrock.inl | 30 ++++----- .../solver/rosenbrock_solver_parameters.hpp | 6 +- include/micm/solver/solver_builder.hpp | 4 +- include/micm/solver/solver_builder.inl | 66 +++++++++---------- .../regression_test_dforce_dy_policy.hpp | 2 +- .../regression_test_p_force_policy.hpp | 2 +- test/unit/process/test_process_set_policy.hpp | 10 +-- 15 files changed, 105 insertions(+), 104 deletions(-) diff --git a/include/micm/solver/backward_euler.hpp b/include/micm/solver/backward_euler.hpp index e5a3de709..370f6d76b 100644 --- a/include/micm/solver/backward_euler.hpp +++ b/include/micm/solver/backward_euler.hpp @@ -4,8 +4,6 @@ */ #pragma once -#include -#include #include #include #include @@ -30,12 +28,12 @@ namespace micm { /// @brief An implementation of the fully implicit backward euler method - template + template class BackwardEuler { BackwardEulerSolverParameters parameters_; LinearSolverPolicy linear_solver_; - ProcessSetPolicy process_set_; + RatesPolicy rates_; std::vector jacobian_diagonal_elements_; public: @@ -43,14 +41,18 @@ namespace micm 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)) { } diff --git a/include/micm/solver/backward_euler.inl b/include/micm/solver/backward_euler.inl index 360bf38a5..70d8bdc7a 100644 --- a/include/micm/solver/backward_euler.inl +++ b/include/micm/solver/backward_euler.inl @@ -42,8 +42,8 @@ inline std::error_code make_error_code(MicmBackwardEulerErrc e) namespace micm { - template - inline SolverResult BackwardEuler::Solve(double time_step, auto& state) + template + inline SolverResult BackwardEuler::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 diff --git a/include/micm/solver/backward_euler_solver_parameters.hpp b/include/micm/solver/backward_euler_solver_parameters.hpp index 3f5b7688c..4614c2655 100644 --- a/include/micm/solver/backward_euler_solver_parameters.hpp +++ b/include/micm/solver/backward_euler_solver_parameters.hpp @@ -12,14 +12,14 @@ namespace micm { - template + template class BackwardEuler; /// @brief BackwardEuler solver parameters struct BackwardEulerSolverParameters { - template - using SolverType = BackwardEuler; + template + using SolverType = BackwardEuler; std::vector absolute_tolerance_; double small{ 1.0e-40 }; diff --git a/include/micm/solver/cuda_rosenbrock.hpp b/include/micm/solver/cuda_rosenbrock.hpp index 0c982f79d..a10fef6b5 100644 --- a/include/micm/solver/cuda_rosenbrock.hpp +++ b/include/micm/solver/cuda_rosenbrock.hpp @@ -4,9 +4,7 @@ */ #pragma once -#include #include -#include #include #include #include @@ -32,8 +30,8 @@ namespace micm { - template - class CudaRosenbrockSolver : public RosenbrockSolver + template + class CudaRosenbrockSolver : public RosenbrockSolver { ///@brief Default constructor public: @@ -47,7 +45,7 @@ namespace micm CudaRosenbrockSolver(const CudaRosenbrockSolver&) = delete; CudaRosenbrockSolver& operator=(const CudaRosenbrockSolver&) = delete; CudaRosenbrockSolver(CudaRosenbrockSolver&& other) - : RosenbrockSolver(std::move(other)), + : RosenbrockSolver(std::move(other)), devstruct_(std::move(other.devstruct_)) { other.devstruct_.errors_input_ = nullptr; @@ -58,7 +56,7 @@ namespace micm CudaRosenbrockSolver& operator=(CudaRosenbrockSolver&& other) { - RosenbrockSolver::operator=(std::move(other)); + RosenbrockSolver::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( + : RosenbrockSolver( parameters, std::move(linear_solver), - std::move(process_set), + std::move(rates), jacobian) { CudaRosenbrockSolverParam hoststruct; diff --git a/include/micm/solver/cuda_solver_parameters.hpp b/include/micm/solver/cuda_solver_parameters.hpp index 0733b5acf..0e0d80aec 100644 --- a/include/micm/solver/cuda_solver_parameters.hpp +++ b/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 - using SolverType = CudaRosenbrockSolver; + template + using SolverType = CudaRosenbrockSolver; /// @brief Constructor from base class /// @param base diff --git a/include/micm/solver/jit_rosenbrock.hpp b/include/micm/solver/jit_rosenbrock.hpp index 6a9599b21..ed2855390 100644 --- a/include/micm/solver/jit_rosenbrock.hpp +++ b/include/micm/solver/jit_rosenbrock.hpp @@ -16,7 +16,6 @@ #pragma once #include -#include #include #include #include @@ -33,8 +32,8 @@ namespace micm struct JitRosenbrockSolverParameters; /// @brief A Rosenbrock solver with JIT-compiled optimizations - template - class JitRosenbrockSolver : public RosenbrockSolver + template + class JitRosenbrockSolver : public RosenbrockSolver { 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(std::move(other)), + : RosenbrockSolver(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::operator=(std::move(other)); + RosenbrockSolver::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( + : RosenbrockSolver( parameters, std::move(linear_solver), - std::move(process_set), + std::move(rates), jacobian) { this->GenerateAlphaMinusJacobian(jacobian); diff --git a/include/micm/solver/jit_solver_parameters.hpp b/include/micm/solver/jit_solver_parameters.hpp index 06ae8db99..80c76aab7 100644 --- a/include/micm/solver/jit_solver_parameters.hpp +++ b/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 - using SolverType = JitRosenbrockSolver; + template + using SolverType = JitRosenbrockSolver; /// @brief Constructor from base class /// @param base diff --git a/include/micm/solver/rosenbrock.hpp b/include/micm/solver/rosenbrock.hpp index a32c463fa..6c270671e 100644 --- a/include/micm/solver/rosenbrock.hpp +++ b/include/micm/solver/rosenbrock.hpp @@ -15,8 +15,6 @@ */ #pragma once -#include -#include #include #include #include @@ -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 + template class RosenbrockSolver { public: RosenbrockSolverParameters parameters_; LinearSolverPolicy linear_solver_; - ProcessSetPolicy process_set_; + RatesPolicy rates_; std::vector 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)) { } diff --git a/include/micm/solver/rosenbrock.inl b/include/micm/solver/rosenbrock.inl index d1d5845f7..ccab1e9ed 100644 --- a/include/micm/solver/rosenbrock.inl +++ b/include/micm/solver/rosenbrock.inl @@ -3,8 +3,8 @@ namespace micm { - template - inline SolverResult RosenbrockSolver::Solve( + template + inline SolverResult RosenbrockSolver::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 + template template - inline void RosenbrockSolver::AlphaMinusJacobian( + inline void RosenbrockSolver::AlphaMinusJacobian( SparseMatrixPolicy& jacobian, const double& alpha) const requires(!VectorizableSparse) { @@ -219,9 +219,9 @@ namespace micm } } - template + template template - inline void RosenbrockSolver::AlphaMinusJacobian( + inline void RosenbrockSolver::AlphaMinusJacobian( SparseMatrixPolicy& jacobian, const double& alpha) const requires(VectorizableSparse) { @@ -237,8 +237,8 @@ namespace micm } } - template - inline void RosenbrockSolver::LinearFactor( + template + inline void RosenbrockSolver::LinearFactor( double& H, const double gamma, bool& singular, @@ -275,9 +275,9 @@ namespace micm } } - template + template template - inline double RosenbrockSolver::NormalizedError( + inline double RosenbrockSolver::NormalizedError( const DenseMatrixPolicy& Y, const DenseMatrixPolicy& Ynew, const DenseMatrixPolicy& errors) const requires(!VectorizableDense) @@ -310,9 +310,9 @@ namespace micm return std::max(std::sqrt(error / N), error_min); } - template + template template - inline double RosenbrockSolver::NormalizedError( + inline double RosenbrockSolver::NormalizedError( const DenseMatrixPolicy& Y, const DenseMatrixPolicy& Ynew, const DenseMatrixPolicy& errors) const requires(VectorizableDense) diff --git a/include/micm/solver/rosenbrock_solver_parameters.hpp b/include/micm/solver/rosenbrock_solver_parameters.hpp index e3475d1cb..53ea8d4c1 100644 --- a/include/micm/solver/rosenbrock_solver_parameters.hpp +++ b/include/micm/solver/rosenbrock_solver_parameters.hpp @@ -14,14 +14,14 @@ namespace micm { - template + template class RosenbrockSolver; /// @brief Rosenbrock solver parameters struct RosenbrockSolverParameters { - template - using SolverType = RosenbrockSolver; + template + using SolverType = RosenbrockSolver; std::size_t stages_{}; std::size_t upper_limit_tolerance_{}; diff --git a/include/micm/solver/solver_builder.hpp b/include/micm/solver/solver_builder.hpp index b42d70ab8..e0b4b3f93 100644 --- a/include/micm/solver/solver_builder.hpp +++ b/include/micm/solver/solver_builder.hpp @@ -29,9 +29,9 @@ namespace micm /// @tparam SolverParametersPolicy Policy for the ODE solver /// @tparam DenseMatrixPolicy Policy for dense matrices /// @tparam SparseMatrixPolicy Policy for sparse matrices - /// @tparam ProcessSetPolicy Policy for sets of processes (used to calculate forcing and the jacobian matrix) + /// @tparam RatesPolicy Calculator of forcing and Jacobian terms /// @tparam LinearSolverPolicy Policy for the linear solver - template + template class SolverBuilder { protected: diff --git a/include/micm/solver/solver_builder.inl b/include/micm/solver/solver_builder.inl index 62cf4e62c..bdc0fd381 100644 --- a/include/micm/solver/solver_builder.inl +++ b/include/micm/solver/solver_builder.inl @@ -56,57 +56,57 @@ inline std::error_code make_error_code(MicmSolverBuilderErrc e) namespace micm { - template - inline SolverBuilder& - SolverBuilder::SetSystem(const System& system) + template + inline SolverBuilder& + SolverBuilder::SetSystem(const System& system) { system_ = system; valid_system_ = true; return *this; } - template - inline SolverBuilder& - SolverBuilder::SetReactions(const std::vector& reactions) + template + inline SolverBuilder& + SolverBuilder::SetReactions(const std::vector& reactions) { reactions_ = reactions; valid_reactions_ = reactions_.size() > 0; return *this; } - template - inline SolverBuilder& - SolverBuilder::SetNumberOfGridCells(int number_of_grid_cells) + template + inline SolverBuilder& + SolverBuilder::SetNumberOfGridCells(int number_of_grid_cells) { number_of_grid_cells_ = number_of_grid_cells; return *this; } - template - inline SolverBuilder& - SolverBuilder::SetIgnoreUnusedSpecies(bool ignore_unused_species) + template + inline SolverBuilder& + SolverBuilder::SetIgnoreUnusedSpecies(bool ignore_unused_species) { ignore_unused_species_ = ignore_unused_species; return *this; } - template - inline SolverBuilder& - SolverBuilder::SetReorderState(bool reorder_state) + template + inline SolverBuilder& + SolverBuilder::SetReorderState(bool reorder_state) { reorder_state_ = reorder_state; return *this; } - template - inline void SolverBuilder::UnusedSpeciesCheck() + template + inline void SolverBuilder::UnusedSpeciesCheck() { if (ignore_unused_species_) { return; } - auto used_species = ProcessSetPolicy::SpeciesUsed(reactions_); + auto used_species = RatesPolicy::SpeciesUsed(reactions_); auto available_species = system_.UniqueNames(); std::sort(available_species.begin(), available_species.end()); std::set unused_species; @@ -126,8 +126,8 @@ namespace micm } } - template - inline std::map SolverBuilder::GetSpeciesMap() const + template + inline std::map SolverBuilder::GetSpeciesMap() const { std::map species_map; std::function& variables, const std::size_t i)> state_reordering; @@ -138,8 +138,8 @@ namespace micm if (reorder_state_) { // get unsorted Jacobian non-zero elements - auto unsorted_process_set = ProcessSetPolicy(reactions_, species_map); - auto unsorted_jac_elements = unsorted_process_set.NonZeroJacobianElements(); + auto unsorted_rates = RatesPolicy(reactions_, species_map); + auto unsorted_jac_elements = unsorted_rates.NonZeroJacobianElements(); using Matrix = typename DenseMatrixPolicy::IntMatrix; Matrix unsorted_jac_non_zeros(system_.StateSize(), system_.StateSize(), 0); @@ -158,8 +158,8 @@ namespace micm return species_map; } - template - inline void SolverBuilder::SetAbsoluteTolerances( + template + inline void SolverBuilder::SetAbsoluteTolerances( std::vector& tolerances, const std::map& species_map) const { @@ -187,8 +187,8 @@ namespace micm } } - template - inline std::vector SolverBuilder::GetCustomParameterLabels() const + template + inline std::vector SolverBuilder::GetCustomParameterLabels() const { std::vector param_labels{}; for (const auto& reaction : reactions_) @@ -198,8 +198,8 @@ namespace micm return param_labels; } - template - inline auto SolverBuilder::Build() + template + inline auto SolverBuilder::Build() { if (!valid_system_) { @@ -209,7 +209,7 @@ namespace micm { throw std::system_error(make_error_code(MicmSolverBuilderErrc::MissingReactions), "Missing reactions."); } - using SolverPolicy = SolverParametersPolicy::template SolverType; + using SolverPolicy = SolverParametersPolicy::template SolverType; auto species_map = this->GetSpeciesMap(); auto labels = this->GetCustomParameterLabels(); std::size_t number_of_species = this->system_.StateSize(); @@ -221,11 +221,11 @@ namespace micm this->UnusedSpeciesCheck(); this->SetAbsoluteTolerances(this->options_.absolute_tolerance_, species_map); - ProcessSetPolicy process_set(this->reactions_, species_map); - auto nonzero_elements = process_set.NonZeroJacobianElements(); + RatesPolicy rates(this->reactions_, species_map); + auto nonzero_elements = rates.NonZeroJacobianElements(); auto jacobian = BuildJacobian(nonzero_elements, this->number_of_grid_cells_, number_of_species); - process_set.SetJacobianFlatIds(jacobian); + rates.SetJacobianFlatIds(jacobian); LinearSolverPolicy linear_solver(jacobian, 1e-30); std::vector variable_names{ number_of_species }; @@ -241,7 +241,7 @@ namespace micm return Solver>( SolverPolicy( - this->options_, std::move(linear_solver), std::move(process_set), jacobian), + this->options_, std::move(linear_solver), std::move(rates), jacobian), state_parameters, this->number_of_grid_cells_, number_of_species, diff --git a/test/regression/RosenbrockChapman/regression_test_dforce_dy_policy.hpp b/test/regression/RosenbrockChapman/regression_test_dforce_dy_policy.hpp index b05e1f54c..fa5aa76cb 100644 --- a/test/regression/RosenbrockChapman/regression_test_dforce_dy_policy.hpp +++ b/test/regression/RosenbrockChapman/regression_test_dforce_dy_policy.hpp @@ -28,7 +28,7 @@ void testJacobian(SolverPolicy& solver) auto& jacobian = state.jacobian_; jacobian.Fill(0.0); - solver.solver_.process_set_.SubtractJacobianTerms(state.rate_constants_, state.variables_, jacobian); + solver.solver_.rates_.SubtractJacobianTerms(state.rate_constants_, state.variables_, jacobian); for (std::size_t i{}; i < 3; ++i) { diff --git a/test/regression/RosenbrockChapman/regression_test_p_force_policy.hpp b/test/regression/RosenbrockChapman/regression_test_p_force_policy.hpp index f836289c3..7a469eef3 100644 --- a/test/regression/RosenbrockChapman/regression_test_p_force_policy.hpp +++ b/test/regression/RosenbrockChapman/regression_test_p_force_policy.hpp @@ -65,7 +65,7 @@ void testForcing(SolverPolicy& solver) MatrixPolicy forcing(3, 9); forcing.Fill(0.0); - solver.solver_.process_set_.AddForcingTerms(state.rate_constants_, state.variables_, forcing); + solver.solver_.rates_.AddForcingTerms(state.rate_constants_, state.variables_, forcing); for (std::size_t i{}; i < 3; ++i) { diff --git a/test/unit/process/test_process_set_policy.hpp b/test/unit/process/test_process_set_policy.hpp index 1139686f3..41eb1d230 100644 --- a/test/unit/process/test_process_set_policy.hpp +++ b/test/unit/process/test_process_set_policy.hpp @@ -13,7 +13,7 @@ void compare_pair(const index_pair& a, const index_pair& b) EXPECT_EQ(a.second, b.second); } -template +template void testProcessSet() { auto foo = micm::Species("foo"); @@ -44,7 +44,7 @@ void testProcessSet() micm::Process r3 = micm::Process::Create().SetReactants({ quz }).SetProducts({}).SetPhase(gas_phase); - auto used_species = ProcessSetPolicy::SpeciesUsed(std::vector{ r1, r2, r3 }); + auto used_species = RatesPolicy::SpeciesUsed(std::vector{ r1, r2, r3 }); EXPECT_EQ(used_species.size(), 6); EXPECT_TRUE(used_species.contains("foo")); @@ -55,7 +55,7 @@ void testProcessSet() EXPECT_TRUE(used_species.contains("qux")); EXPECT_FALSE(used_species.contains("corge")); - ProcessSetPolicy set = ProcessSetPolicy(std::vector{ r1, r2, r3 }, state.variable_map_); + RatesPolicy set = RatesPolicy(std::vector{ r1, r2, r3 }, state.variable_map_); EXPECT_EQ(state.variables_.NumRows(), 2); EXPECT_EQ(state.variables_.NumColumns(), 6); @@ -133,7 +133,7 @@ void testProcessSet() EXPECT_DOUBLE_EQ(jacobian[1][4][2], 100.0 - 2.4 * 110.0 * 1.1); } -template +template void testRandomSystem(std::size_t n_cells, std::size_t n_reactions, std::size_t n_species) { auto get_n_react = std::bind(std::uniform_int_distribution<>(0, 3), std::default_random_engine()); @@ -172,7 +172,7 @@ void testRandomSystem(std::size_t n_cells, std::size_t n_reactions, std::size_t auto proc = micm::Process(micm::Process::Create().SetReactants(reactants).SetProducts(products).SetPhase(gas_phase)); processes.push_back(proc); } - ProcessSetPolicy set = ProcessSetPolicy(processes, state.variable_map_); + RatesPolicy set = RatesPolicy(processes, state.variable_map_); for (auto& elem : state.variables_.AsVector()) elem = get_double();