musica 0.6.1__tar.gz → 0.6.1.dev0__tar.gz

{musica-0.6.1 → musica-0.6.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: musica
-Version: 0.6.1
+Version: 0.6.1.dev0
 Summary: MUSICA is a Python library for performing computational simulations in atmospheric chemistry.
 Home-page: https://wiki.ucar.edu/display/MUSICA/MUSICA+Home
 Project-URL: Homepage, https://wiki.ucar.edu/display/MUSICA/MUSICA+Home

{musica-0.6.1 → musica-0.6.1.dev0}/cmake/dependencies.cmake

@@ -1,9 +1,9 @@
-find_package(PkgConfig REQUIRED)
 include(FetchContent)
 
 ################################################################################
 # NetCDF library
 if (MUSICA_BUILD_FORTRAN_INTERFACE)
+  find_package(PkgConfig REQUIRED)
   pkg_check_modules(netcdff IMPORTED_TARGET REQUIRED netcdf-fortran)
 endif()
 

{musica-0.6.1 → musica-0.6.1.dev0}/docker/Dockerfile.fortran-gcc

@@ -44,6 +44,6 @@ RUN cd musica/fortran/test/fetch_content_integration \
         -D CMAKE_BUILD_TYPE=Debug \
     && make
 
-RUN cp -r /musica/configs/chapman musica/fortran/test/fetch_content_integration/build
+RUN cp -r /musica/configs musica/fortran/test/fetch_content_integration/build
 
 WORKDIR musica/fortran/test/fetch_content_integration/build

{musica-0.6.1 → musica-0.6.1.dev0}/docker/Dockerfile.fortran-intel

@@ -48,6 +48,6 @@ RUN cd musica/fortran/test/fetch_content_integration \
         -D CMAKE_BUILD_TYPE=Release \
     && make
 
-RUN cp -r /musica/configs/chapman musica/fortran/test/fetch_content_integration/build
+RUN cp -r /musica/configs musica/fortran/test/fetch_content_integration/build
 
 WORKDIR musica/fortran/test/fetch_content_integration/build

{musica-0.6.1 → musica-0.6.1.dev0}/docker/Dockerfile.fortran-nvhpc

@@ -53,6 +53,6 @@ RUN cd musica/fortran/test/fetch_content_integration \
         -D CMAKE_BUILD_TYPE=Release \
     && make
 
-RUN cp -r /musica/configs/chapman musica/fortran/test/fetch_content_integration/build
+RUN cp -r /musica/configs musica/fortran/test/fetch_content_integration/build
 
 WORKDIR musica/fortran/test/fetch_content_integration/build

{musica-0.6.1 → musica-0.6.1.dev0}/fortran/CMakeLists.txt

@@ -40,7 +40,7 @@ target_link_libraries(musica-fortran
 )
 
 target_sources(musica-fortran
-  PUBLIC
+  PRIVATE
     micm_core.F90
 )
 

{musica-0.6.1 → musica-0.6.1.dev0}/fortran/micm_core.F90

@@ -3,13 +3,14 @@ module micm_core
    use iso_c_binding, only: c_ptr, c_char, c_int, c_double, c_null_char, c_size_t, c_f_pointer
    implicit none
 
-   public :: micm_t
+   public :: micm_t, mapping_t
    private
 
-   type, bind(c) :: Mapping
+   type, bind(c) :: mapping_t
       character(kind=c_char, len=1) :: name(256)
       integer(c_size_t) :: index
-   end type Mapping
+      integer(c_size_t) :: string_length
+   end type mapping_t
 
    interface
       function create_micm_c(config_path, error_code) bind(C, name="create_micm")
@@ -24,7 +25,8 @@ module micm_core
          type(c_ptr), intent(in) :: micm
       end subroutine delete_micm_c
 
-      subroutine micm_solve_c(micm, time_step, temperature, pressure, num_concentrations, concentrations) bind(C, name="micm_solve")
+      subroutine micm_solve_c(micm, time_step, temperature, pressure, num_concentrations, concentrations, &
+                              num_user_defined_reaction_rates, user_defined_reaction_rates) bind(C, name="micm_solve")
          import c_ptr, c_double, c_int
          type(c_ptr), value, intent(in)         :: micm
          real(kind=c_double), value, intent(in) :: time_step
@@ -32,6 +34,8 @@ module micm_core
          real(kind=c_double), value, intent(in) :: pressure
          integer(kind=c_int), value, intent(in) :: num_concentrations
          real(kind=c_double), intent(inout)     :: concentrations(num_concentrations)
+         integer(kind=c_int), value, intent(in) :: num_user_defined_reaction_rates
+         real(kind=c_double), intent(inout)     :: user_defined_reaction_rates(num_user_defined_reaction_rates)
       end subroutine micm_solve_c
 
       function get_species_ordering(micm, array_size) bind(c, name="get_species_ordering")
@@ -50,8 +54,8 @@ module micm_core
    end interface
 
    type :: micm_t
-      type(Mapping), pointer   :: species_ordering(:), reaction_rates_ordering(:)
-      integer(kind=c_size_t) :: species_ordering_length, reaction_rates_ordering_length
+      type(mapping_t), pointer   :: species_ordering(:), user_defined_reaction_rates(:)
+      integer(kind=c_size_t) :: species_ordering_length, user_defined_reaction_rates_length
       type(c_ptr), private   :: ptr
    contains
       ! Solve the chemical system
@@ -76,7 +80,6 @@ contains
 
       allocate( this )
 
-      print *, "Config Path:", config_path
       n = len_trim(config_path)
       do i = 1, n
          c_config_path(i) = config_path(i:i)
@@ -92,21 +95,23 @@ contains
       mappings_ptr = get_species_ordering(this%ptr, this%species_ordering_length)
       call c_f_pointer(mappings_ptr, this%species_ordering, [this%species_ordering_length])
 
-      ! this%reaction_rates_ordering = get_user_defined_reaction_rates_ordering(this%ptr, this%reaction_rates_ordering_length)
 
-      ! do i = 1, this%reaction_rates_ordering_length
-      !    print *, "Reaction Rate Name:", this%reaction_rates_ordering(i)%name, ", Index:", this%reaction_rates_ordering(i)%index
-      ! end do
+      mappings_ptr = get_user_defined_reaction_rates_ordering(this%ptr, this%user_defined_reaction_rates_length)
+      call c_f_pointer(mappings_ptr, this%user_defined_reaction_rates, [this%user_defined_reaction_rates_length])
    end function constructor
 
-   subroutine solve(this, time_step, temperature, pressure, num_concentrations, concentrations)
+   subroutine solve(this, time_step, temperature, pressure, num_concentrations, concentrations, &
+                     num_user_defined_reaction_rates, user_defined_reaction_rates)
       class(micm_t)                 :: this
       real(c_double), intent(in)    :: time_step
       real(c_double), intent(in)    :: temperature
       real(c_double), intent(in)    :: pressure
       integer(c_int), intent(in)    :: num_concentrations
       real(c_double), intent(inout) :: concentrations(*)
-      call micm_solve_c(this%ptr, time_step, temperature, pressure, num_concentrations, concentrations)
+      integer(c_int), intent(in)    :: num_user_defined_reaction_rates
+      real(c_double), intent(inout) :: user_defined_reaction_rates(*)
+      call micm_solve_c(this%ptr, time_step, temperature, pressure, num_concentrations, concentrations, &
+                        num_user_defined_reaction_rates, user_defined_reaction_rates)
    end subroutine solve
 
    subroutine finalize(this)

musica-0.6.1.dev0/fortran/test/fetch_content_integration/test_micm_fort_api.F90

@@ -0,0 +1,55 @@
+program test_micm_fort_api
+  use iso_c_binding
+  use micm_core, only: micm_t, mapping_t
+
+  implicit none
+
+  type(micm_t), pointer         :: micm
+  real(c_double)                :: time_step
+  real(c_double)                :: temperature
+  real(c_double)                :: pressure
+  integer(c_int)                :: num_concentrations, num_user_defined_reaction_rates
+  real(c_double), dimension(5)  :: concentrations 
+  real(c_double), dimension(3)  :: user_defined_reaction_rates 
+  integer                       :: errcode, i
+  character(len=256)            :: config_path
+  type(mapping_t)               :: the_mapping
+
+  time_step = 200
+  temperature = 272.5
+  pressure = 101253.4
+  num_concentrations = 5
+  concentrations = (/ 0.75, 0.4, 0.8, 0.01, 0.02 /)
+  config_path = "configs/chapman"
+  num_user_defined_reaction_rates = 3
+  user_defined_reaction_rates = (/ 0.1, 0.2, 0.3 /)
+
+
+  write(*,*) "[test micm fort api] Creating MICM solver..."
+  micm => micm_t(config_path, errcode)
+
+  do i = 1, micm%species_ordering_length
+    the_mapping = micm%species_ordering(i)
+    print *, "Species Name:", the_mapping%name(:the_mapping%string_length), ", Index:", the_mapping%index
+  end do
+  do i = 1, micm%user_defined_reaction_rates_length
+    the_mapping = micm%user_defined_reaction_rates(i)
+    print *, "User Defined Reaction Rate Name:", the_mapping%name(:the_mapping%string_length), ", Index:", the_mapping%index
+  end do
+
+  if (errcode /= 0) then
+    write(*,*) "[test micm fort api] Failed in creating solver."
+    stop 3
+  endif
+
+  write(*,*) "[test micm fort api] Initial concentrations", concentrations
+
+  write(*,*) "[test micm fort api] Solving starts..."
+  call micm%solve(time_step, temperature, pressure, num_concentrations, concentrations, &
+                  num_user_defined_reaction_rates, user_defined_reaction_rates)
+
+  write(*,*) "[test micm fort api] After solving, concentrations", concentrations
+
+  write(*,*) "[test micm fort api] Finished."
+
+end program

{musica-0.6.1 → musica-0.6.1.dev0}/fortran/test/fetch_content_integration/test_micm_fort_api_invalid.F90

@@ -5,19 +5,9 @@ subroutine test_micm_fort_api_invalid()
   implicit none
 
   type(micm_t), pointer         :: micm
-  real(c_double)                :: time_step
-  real(c_double)                :: temperature
-  real(c_double)                :: pressure
-  integer(c_int)                :: num_concentrations
-  real(c_double), dimension(5)  :: concentrations
   integer                       :: errcode
   character(len=7)              :: config_path
 
-  time_step = 200
-  temperature = 272.5
-  pressure = 101253.3
-  num_concentrations = 5
-  concentrations = (/ 0.75, 0.4, 0.8, 0.01, 0.02 /)
   config_path = "invalid_config"
 
   write(*,*) "[test micm fort api] Creating MICM solver..."

musica-0.6.1.dev0/fortran/test/unit/test_musica_fortran_interface.F90

@@ -0,0 +1,55 @@
+program test_micm_fort_api
+  use iso_c_binding
+  use micm_core, only: micm_t, mapping_t
+
+  implicit none
+
+  type(micm_t), pointer         :: micm
+  real(c_double)                :: time_step
+  real(c_double)                :: temperature
+  real(c_double)                :: pressure
+  integer(c_int)                :: num_concentrations, num_user_defined_reaction_rates
+  real(c_double), dimension(5)  :: concentrations 
+  real(c_double), dimension(3)  :: user_defined_reaction_rates 
+  integer                       :: errcode, i
+  character(len=256)            :: config_path
+  type(mapping_t)                 :: the_mapping
+
+  time_step = 200
+  temperature = 272.5
+  pressure = 101253.4
+  num_concentrations = 5
+  concentrations = (/ 0.75, 0.4, 0.8, 0.01, 0.02 /)
+  config_path = "configs/chapman"
+  num_user_defined_reaction_rates = 3
+  user_defined_reaction_rates = (/ 0.1, 0.2, 0.3 /)
+
+
+  write(*,*) "[test micm fort api] Creating MICM solver..."
+  micm => micm_t(config_path, errcode)
+
+  do i = 1, micm%species_ordering_length
+    the_mapping = micm%species_ordering(i)
+    print *, "Species Name:", the_mapping%name(:the_mapping%string_length), ", Index:", the_mapping%index
+  end do
+  do i = 1, micm%user_defined_reaction_rates_length
+    the_mapping = micm%user_defined_reaction_rates(i)
+    print *, "User Defined Reaction Rate Name:", the_mapping%name(:the_mapping%string_length), ", Index:", the_mapping%index
+  end do
+
+  if (errcode /= 0) then
+    write(*,*) "[test micm fort api] Failed in creating solver."
+    stop 3
+  endif
+
+  write(*,*) "[test micm fort api] Initial concentrations", concentrations
+
+  write(*,*) "[test micm fort api] Solving starts..."
+  call micm%solve(time_step, temperature, pressure, num_concentrations, concentrations, &
+                  num_user_defined_reaction_rates, user_defined_reaction_rates)
+
+  write(*,*) "[test micm fort api] After solving, concentrations", concentrations
+
+  write(*,*) "[test micm fort api] Finished."
+
+end program

{musica-0.6.1 → musica-0.6.1.dev0}/include/musica/micm.hpp

@@ -17,8 +17,9 @@ class MICM;
 
 struct Mapping
 {
-    char *name;
+    char name[256];
     size_t index;
+    size_t string_length;
 };
 
 #ifdef __cplusplus
@@ -39,12 +40,6 @@ extern "C"
 class MICM
 {
 public:
-    /// @brief Constructor
-    MICM();
-
-    /// @brief Destructor
-    ~MICM();
-
     /// @brief Create a solver by reading and parsing configuration file
     /// @param config_path Path to configuration file or directory containing configuration file
     /// @return 0 on success, 1 on failure in parsing configuration file

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/.github/workflows/clang_format.yml

@@ -12,7 +12,7 @@ jobs:
 
     steps:
       - name: Install Clang-Format
-        run: sudo apt-get update && sudo apt-get install clang-format
+        run: sudo apt-get update && sudo apt-get install clang-format && clang-format --version
 
       - name: Check out code, run clang format, push changes
         uses: actions/checkout@v3
@@ -22,9 +22,9 @@ jobs:
 
       - name: Format code
         run: |
-          find include -type f \( -name '*.hpp' -o -name '*.h' \) -exec clang-format -i --style=file {} +
-          find src -type f \( -name '*.cu' -o -name '*.hpp' -o -name '*.h' -o -name '*.cpp' \) -exec clang-format -i --style=file {} +
-          find test -type f \( -name '*.hpp' -o -name '*.h' -o -name '*.cpp' \) ! -path 'test/tutorial/*' -exec clang-format -i --style=file {} +
+          find include -type f \( -name '*.hpp' -o -name '*.h' -o -name '*.cuh' -o -name '*.inl' \) -exec clang-format -i --style=file --verbose {} +
+          find src -type f \( -name '*.cu' -o -name '*.hpp' -o -name '*.h' -o -name '*.cpp' \) -exec clang-format -i --style=file --verbose {} +
+          find test -type f \( -name '*.hpp' -o -name '*.h' -o -name '*.cpp' -o -name '*.cuh' -o -name '*.cu' \) ! -path 'test/tutorial/*' -exec clang-format -i --style=file --verbose {} +
 
       - name: Check for changes
         id: check-changes
@@ -55,4 +55,4 @@ jobs:
           commit-message: "Auto-format code using Clang-Format"
           title: "Auto-format code changes"
           body: "This is an automated pull request to apply code formatting using Clang-Format."
-          branch: "main-formatting"
+          branch: "main-formatting"

musica-0.6.1.dev0/lib/micm/.github/workflows/clang_format_non_inline.yml

@@ -0,0 +1,30 @@
+name: Clang-Format
+
+on: [push, pull_request]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  format:
+    name: Run Clang-Format
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Install Clang-Format
+        run: sudo apt-get update && sudo apt-get install clang-format && clang-format --version
+
+      - name: Check out code
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.head_ref }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Format code
+        run: |
+          find include -type f \( -name '*.hpp' -o -name '*.h' -o -name '*.cuh' -o -name '*.inl' \) -exec clang-format -i --style=file --verbose {} +
+          find src -type f \( -name '*.cu' -o -name '*.hpp' -o -name '*.h' -o -name '*.cpp' \) -exec clang-format -i --style=file --verbose {} +
+          find test -type f \( -name '*.hpp' -o -name '*.h' -o -name '*.cpp' -o -name '*.cuh' -o -name '*.cu' \) ! -path 'test/tutorial/*' -exec clang-format -i --style=file --verbose {} +
+          git diff
+

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/CMakeLists.txt

@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.21)
 
 project(
   micm
-  VERSION 3.4.0
+  VERSION 3.5.0
   LANGUAGES CXX
 )
 

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/examples/example.cpp

@@ -271,8 +271,7 @@ int main(const int argc, const char *argv[])
     auto chemical_system = solver_params.system_;
     auto reactions = solver_params.processes_;
 
-    auto params = RosenbrockSolverParameters::three_stage_rosenbrock_parameters();
-    params.relative_tolerance_ = 0.1;
+    auto params = solver_params.parameters_;
     RosenbrockSolver<> solver{ chemical_system, reactions, params};
 
     State state = solver.GetState();

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/include/micm/configure/solver_config.hpp

@@ -16,6 +16,7 @@
 #include <micm/process/troe_rate_constant.hpp>
 #include <micm/process/tunneling_rate_constant.hpp>
 #include <micm/process/user_defined_rate_constant.hpp>
+#include <micm/solver/rosenbrock.hpp>
 #include <micm/system/phase.hpp>
 #include <micm/system/species.hpp>
 #include <micm/system/system.hpp>
@@ -72,16 +73,19 @@ namespace micm
   {
     System system_;
     std::vector<Process> processes_;
+    RosenbrockSolverParameters parameters_;
 
-    SolverParameters(const System& system, std::vector<Process>&& processes)
+    SolverParameters(const System& system, std::vector<Process>&& processes, const RosenbrockSolverParameters&& parameters)
         : system_(system),
-          processes_(std::move(processes))
+          processes_(processes),
+          parameters_(parameters)
     {
     }
 
-    SolverParameters(System&& system, std::vector<Process>&& processes)
-        : system_(std::move(system)),
-          processes_(std::move(processes))
+    SolverParameters(System&& system, std::vector<Process>&& processes, RosenbrockSolverParameters&& parameters)
+        : system_(system),
+          processes_(processes),
+          parameters_(parameters)
     {
     }
   };
@@ -105,6 +109,7 @@ namespace micm
     Phase gas_phase_;
     std::unordered_map<std::string, Phase> phases_;
     std::vector<Process> processes_;
+    RosenbrockSolverParameters parameters_;
 
     // Common JSON
     static const inline std::string DEFAULT_CONFIG_FILE = "config.json";
@@ -115,6 +120,13 @@ namespace micm
     // Error string
     std::stringstream last_json_object_;
 
+    // Constructor
+
+    JsonReaderPolicy(RosenbrockSolverParameters parameters)
+        : parameters_(parameters)
+    {
+    }
+
     // Functions
 
     /// @brief Parse configures
@@ -372,10 +384,11 @@ namespace micm
     {
       // required keys
       const std::string NAME = "name";
+      const std::string TYPE = "type";
 
       auto status = ValidateSchema(
           object,
-          { NAME, "type" },
+          { NAME, TYPE },
           { "tracer type", "absolute tolerance", "diffusion coefficient [m2 s-1]", "molecular weight [kg mol-1]" });
       if (status != ConfigParseStatus::Success)
       {
@@ -383,21 +396,50 @@ namespace micm
       }
 
       std::string name = object[NAME].get<std::string>();
+      Species species{ name };
 
       // Load remaining keys as properties
-      std::map<std::string, double> properties{};
       for (auto& [key, value] : object.items())
       {
-        if (value.is_number_float())
-          properties[key] = value;
+        if (key != NAME && key != TYPE)
+        {
+          if (value.is_string())
+          {
+            species.SetProperty<std::string>(key, value);
+          }
+          else if (value.is_number_integer())
+          {
+            species.SetProperty<int>(key, value);
+          }
+          else if (value.is_number_float())
+          {
+            species.SetProperty<double>(key, value);
+          }
+          else if (value.is_boolean())
+          {
+            species.SetProperty<bool>(key, value);
+          }
+          else
+          {
+            std::cerr << "Unknown type for property " << key << std::endl;
+          }
+        }
       }
-      species_arr_.push_back(Species(name, properties));
+      species_arr_.push_back(species);
 
       return ConfigParseStatus::Success;
     }
 
     ConfigParseStatus ParseRelativeTolerance(const json& object)
     {
+      auto status = ValidateSchema(object, { "value", "type" }, {});
+      if (status != ConfigParseStatus::Success)
+      {
+        return status;
+      }
+
+      this->parameters_.relative_tolerance_ = object["value"].get<double>();
+
       return ConfigParseStatus::Success;
     }
 
@@ -1096,6 +1138,10 @@ namespace micm
     ConfigParseStatus last_parse_status_ = ConfigParseStatus::None;
 
    public:
+
+    SolverConfig() : ConfigTypePolicy(RosenbrockSolverParameters::three_stage_rosenbrock_parameters()) {}
+    SolverConfig(RosenbrockSolverParameters parameters) : ConfigTypePolicy(parameters) {}
+
     /// @brief Reads and parses configures
     /// @param config_dir Path to a the configuration directory
     /// @return an enum indicating the success or failure of the parse
@@ -1118,7 +1164,10 @@ namespace micm
       }
 
       return SolverParameters(
-          std::move(System(std::move(this->gas_phase_), std::move(this->phases_))), std::move(this->processes_));
+          std::move(System(this->gas_phase_, this->phases_)), 
+          std::move(this->processes_),
+          std::move(this->parameters_)
+      );
     }
   };
 }  // namespace micm

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/include/micm/process/cuda_process_set.cuh

@@ -21,16 +21,17 @@ namespace micm
     /// This is the host function that will call the CUDA kernel
     ///   to calculate the forcing terms
     void AddForcingTermsKernelDriver(
-        const CudaVectorMatrixParam& rate_constants_param,
-        const CudaVectorMatrixParam& state_variables_param,
-        CudaVectorMatrixParam& forcing_param,
+        const CudaMatrixParam& rate_constants_param,
+        const CudaMatrixParam& state_variables_param,
+        CudaMatrixParam& forcing_param,
         const ProcessSetParam& devstruct);
 
     /// This is the host function that will call the CUDA kernel
     ///   to form the negative Jacobian matrix (-J)
-    std::chrono::nanoseconds SubtractJacobianTermsKernelDriver(
-        CudaMatrixParam& matrixParam, 
-        CudaSparseMatrixParam& sparseMatrix, 
+    void SubtractJacobianTermsKernelDriver(
+        const CudaMatrixParam& rate_constants_param,
+        const CudaMatrixParam& state_variables_param,
+        CudaMatrixParam& jacobian_param,
         const ProcessSetParam& devstruct);
   }  // namespace cuda
 }  // namespace micm

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/include/micm/process/cuda_process_set.hpp

@@ -39,11 +39,10 @@ namespace micm
 
     template<template<class> class MatrixPolicy, template<class> class SparseMatrixPolicy>
     requires VectorizableDense<MatrixPolicy<double>> && VectorizableSparse<SparseMatrixPolicy<double>>
-        std::chrono::nanoseconds SubtractJacobianTerms(
-            const MatrixPolicy<double>& rate_constants,
-            const MatrixPolicy<double>& state_variables,
-            SparseMatrixPolicy<double>& jacobian)
-    const;
+    void SubtractJacobianTerms(
+        const MatrixPolicy<double>& rate_constants,
+        const MatrixPolicy<double>& state_variables,
+        SparseMatrixPolicy<double>& jacobian) const;
   };
 
   inline CudaProcessSet::CudaProcessSet(
@@ -103,24 +102,14 @@ namespace micm
 
   template<template<class> class MatrixPolicy, template<class> class SparseMatrixPolicy>
   requires VectorizableDense<MatrixPolicy<double>> && VectorizableSparse<SparseMatrixPolicy<double>>
-  inline std::chrono::nanoseconds CudaProcessSet::SubtractJacobianTerms(
+  inline void CudaProcessSet::SubtractJacobianTerms(
       const MatrixPolicy<double>& rate_constants,
       const MatrixPolicy<double>& state_variables,
       SparseMatrixPolicy<double>& jacobian) const
   {
-    CudaMatrixParam matrix;
-    matrix.rate_constants_ = rate_constants.AsVector().data();
-    matrix.state_variables_ = state_variables.AsVector().data();
-    matrix.n_grids_ = rate_constants.size();
-    matrix.n_reactions_ = rate_constants[0].size();
-    matrix.n_species_ = state_variables[0].size();
-
-    CudaSparseMatrixParam sparseMatrix;
-    sparseMatrix.jacobian_ = jacobian.AsVector().data();
-    sparseMatrix.jacobian_size_ = jacobian.AsVector().size();
-
-    std::chrono::nanoseconds kernel_duration =
-        micm::cuda::SubtractJacobianTermsKernelDriver(matrix, sparseMatrix, this->devstruct_);
-    return kernel_duration;  // time performance of kernel function
+    auto jacobian_param =
+        jacobian.AsDeviceParam();  // we need to update jacobian so it can't be constant and must be an lvalue
+    micm::cuda::SubtractJacobianTermsKernelDriver(
+        rate_constants.AsDeviceParam(), state_variables.AsDeviceParam(), jacobian_param, this->devstruct_);
   }
 }  // namespace micm

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/include/micm/process/surface_rate_constant.hpp

@@ -64,8 +64,8 @@ namespace micm
 
   inline SurfaceRateConstant::SurfaceRateConstant(const SurfaceRateConstantParameters& parameters)
       : parameters_(parameters),
-        diffusion_coefficient_(parameters.species_.properties_.at(GAS_DIFFUSION_COEFFICIENT)),
-        mean_free_speed_factor_(8.0 * GAS_CONSTANT / (M_PI * parameters.species_.properties_.at(MOLECULAR_WEIGHT)))
+        diffusion_coefficient_(parameters.species_.GetProperty<double>(GAS_DIFFUSION_COEFFICIENT)),
+        mean_free_speed_factor_(8.0 * GAS_CONSTANT / (M_PI * parameters.species_.GetProperty<double>(MOLECULAR_WEIGHT)))
   {
   }
 

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/include/micm/solver/cuda_linear_solver.cuh

@@ -13,7 +13,7 @@ namespace micm
     ///   to perform the "solve" function on the device
     std::chrono::nanoseconds SolveKernelDriver(
            CudaSparseMatrixParam& sparseMatrix, 
-           CudaMatrixParam& denseMatrix,
+           CudaMatrixParam_to_be_removed& denseMatrix,
            const LinearSolverParam& devstruct);
 
     /// This is the function that will copy the constant data

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/include/micm/solver/cuda_linear_solver.hpp

@@ -73,7 +73,7 @@ namespace micm
         SparseMatrixPolicy<T>& upper_matrix)
     {
       CudaSparseMatrixParam sparseMatrix;
-      CudaMatrixParam denseMatrix;
+      CudaMatrixParam_to_be_removed denseMatrix;
 
       sparseMatrix.lower_matrix_ = lower_matrix.AsVector().data();
       sparseMatrix.lower_matrix_size_ = lower_matrix.AsVector().size();

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/include/micm/solver/cuda_lu_decomposition.hpp

@@ -25,9 +25,9 @@ namespace micm
     /// This is the overloaded constructor that takes one argument called "matrix";
     /// We need to specify the type (e.g., double, int, etc) and
     ///   ordering (e.g., vector-stored, non-vector-stored, etc) of the "matrix";
-    template<typename T, typename OrderingPolicy>
-    CudaLuDecomposition(const SparseMatrix<T, OrderingPolicy>& matrix)
-        : LuDecomposition(matrix)
+    template<typename SparseMatrixPolicy>
+    CudaLuDecomposition(const SparseMatrixPolicy& matrix)
+        : LuDecomposition(LuDecomposition::Create<double, SparseMatrixPolicy>(matrix))
     {
       /// Passing the class itself as an argument is not support by CUDA;
       /// Thus we generate a host struct first to save the pointers to

{musica-0.6.1 → musica-0.6.1.dev0}/lib/micm/include/micm/solver/cuda_rosenbrock.hpp

@@ -63,6 +63,7 @@ namespace micm
       hoststruct.num_grid_cells_ = parameters.number_of_grid_cells_;
       hoststruct.jacobian_diagonal_elements_ = this->state_parameters_.jacobian_diagonal_elements_.data();
       hoststruct.jacobian_diagonal_elements_size_ = this->state_parameters_.jacobian_diagonal_elements_.size();
+      hoststruct.absoluate_tolerance_ = parameters.absolute_tolerance_.data();
       // Copy the data from host struct to device struct
       this->devstruct_ = micm::cuda::CopyConstData(hoststruct);
     };