Expose solver parameters through all language bindings (#783)

* Expose solver parameters through all language bindings

Add RosenbrockSolverParameters and BackwardEulerSolverParameters structs
that allow users to configure solver-specific settings (tolerances, step
size controls, max steps) through C++, C API, Fortran, Python, and
JavaScript interfaces. Parameters are validated at runtime to ensure the
correct type matches the solver. Tolerances are propagated to newly
created states.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix solver parameter tests and validation

- Add absolute_tolerances test coverage in micm_wrapper.cpp for both
  Rosenbrock and BackwardEuler parameter round-trips
- Fix memory leak in micm_c_api.cpp by cleaning up allocated
  absolute_tolerances arrays before DeleteMicm
- Throw error in cpu_solver.cpp when time_step_reductions size doesn't
  match the expected size instead of silently ignoring
- Replace hardcoded size 5 with actual array size from MICM solver

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* removing ununsed option

* Enforce fixed size of 5 for time_step_reductions across all bindings

- Fortran: change time_step_reductions from allocatable to fixed array
  of 5 with default values, simplify set/get parameter methods
- Python: add ValueError if time_step_reductions length is not 5
- JavaScript: add Error if time_step_reductions length is not 5
- C++: add comment documenting the 5-element requirement
- Update Fortran test to remove unnecessary allocate call

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: K20shores

fortran/micm/micm.F90

@@ -5,12 +5,13 @@ module musica_micm
 #define ASSERT( expr ) call assert( expr, __FILE__, __LINE__ )
   use iso_c_binding, only: c_ptr, c_char, c_int, c_int64_t, c_bool, c_double, c_null_char, &
                           c_size_t, c_f_pointer, c_funptr, c_null_ptr, c_associated
-  use iso_fortran_env, only: int64
+  use iso_fortran_env, only: int64, real64
   use musica_state, only: state_t
   use musica_util, only: assert, mappings_t, string_t, string_t_c, error_t_c
   implicit none
 
   public :: micm_t, solver_stats_t, get_micm_version, is_cuda_available
+  public :: rosenbrock_solver_parameters_t, backward_euler_solver_parameters_t
   public :: UndefinedSolver, Rosenbrock, RosenbrockStandardOrder, BackwardEuler, BackwardEulerStandardOrder, CudaRosenbrock
   private
 
@@ -37,6 +38,46 @@ module musica_micm
     enumerator :: CudaRosenbrock             = 5
   end enum
 
+  !> C-binding type for Rosenbrock solver parameters
+  type, bind(c) :: rosenbrock_solver_parameters_t_c
+    real(c_double)    :: relative_tolerance
+    type(c_ptr)       :: absolute_tolerances = c_null_ptr
+    integer(c_size_t) :: num_absolute_tolerances = 0
+    real(c_double)    :: h_min
+    real(c_double)    :: h_max
+    real(c_double)    :: h_start
+    integer(c_size_t) :: max_number_of_steps
+  end type rosenbrock_solver_parameters_t_c
+
+  !> C-binding type for Backward Euler solver parameters
+  type, bind(c) :: backward_euler_solver_parameters_t_c
+    real(c_double)    :: relative_tolerance
+    type(c_ptr)       :: absolute_tolerances = c_null_ptr
+    integer(c_size_t) :: num_absolute_tolerances = 0
+    integer(c_size_t) :: max_number_of_steps
+    type(c_ptr)       :: time_step_reductions = c_null_ptr
+    integer(c_size_t) :: num_time_step_reductions = 0
+  end type backward_euler_solver_parameters_t_c
+
+  !> Fortran-native type for Rosenbrock solver parameters
+  type :: rosenbrock_solver_parameters_t
+    real(real64)              :: relative_tolerance = 1.0e-6_real64
+    real(real64), allocatable :: absolute_tolerances(:)
+    real(real64)              :: h_min = 0.0_real64
+    real(real64)              :: h_max = 0.0_real64
+    real(real64)              :: h_start = 0.0_real64
+    integer                   :: max_number_of_steps = 1000
+  end type rosenbrock_solver_parameters_t
+
+  !> Fortran-native type for Backward Euler solver parameters
+  type :: backward_euler_solver_parameters_t
+    real(real64)              :: relative_tolerance = 1.0e-6_real64
+    real(real64), allocatable :: absolute_tolerances(:)
+    integer                   :: max_number_of_steps = 11
+    real(real64)              :: time_step_reductions(5) = &  ! must have exactly 5 elements
+        (/ 0.5_real64, 0.5_real64, 0.5_real64, 0.5_real64, 0.1_real64 /)
+  end type backward_euler_solver_parameters_t
+
   interface
     function create_micm_c(config_path, solver_type, error) &
         bind(C, name="CreateMicm")
@@ -125,6 +166,42 @@ integer(c_size_t) function get_maximum_number_of_grid_cells_c(micm) &
       import c_ptr, c_size_t
       type(c_ptr), value, intent(in)            :: micm
     end function get_maximum_number_of_grid_cells_c
+
+    subroutine set_rosenbrock_solver_parameters_c(micm, params, error) &
+        bind(C, name="SetRosenbrockSolverParameters")
+      use musica_util, only: error_t_c
+      import c_ptr, rosenbrock_solver_parameters_t_c
+      type(c_ptr), value, intent(in)                       :: micm
+      type(rosenbrock_solver_parameters_t_c), intent(in)   :: params
+      type(error_t_c), intent(inout)                       :: error
+    end subroutine set_rosenbrock_solver_parameters_c
+
+    subroutine set_backward_euler_solver_parameters_c(micm, params, error) &
+        bind(C, name="SetBackwardEulerSolverParameters")
+      use musica_util, only: error_t_c
+      import c_ptr, backward_euler_solver_parameters_t_c
+      type(c_ptr), value, intent(in)                          :: micm
+      type(backward_euler_solver_parameters_t_c), intent(in)  :: params
+      type(error_t_c), intent(inout)                          :: error
+    end subroutine set_backward_euler_solver_parameters_c
+
+    subroutine get_rosenbrock_solver_parameters_c(micm, params, error) &
+        bind(C, name="GetRosenbrockSolverParameters")
+      use musica_util, only: error_t_c
+      import c_ptr, rosenbrock_solver_parameters_t_c
+      type(c_ptr), value, intent(in)                        :: micm
+      type(rosenbrock_solver_parameters_t_c), intent(inout) :: params
+      type(error_t_c), intent(inout)                        :: error
+    end subroutine get_rosenbrock_solver_parameters_c
+
+    subroutine get_backward_euler_solver_parameters_c(micm, params, error) &
+        bind(C, name="GetBackwardEulerSolverParameters")
+      use musica_util, only: error_t_c
+      import c_ptr, backward_euler_solver_parameters_t_c
+      type(c_ptr), value, intent(in)                           :: micm
+      type(backward_euler_solver_parameters_t_c), intent(inout) :: params
+      type(error_t_c), intent(inout)                           :: error
+    end subroutine get_backward_euler_solver_parameters_c
   end interface
 
   type :: micm_t
@@ -140,6 +217,11 @@ end function get_maximum_number_of_grid_cells_c
     procedure :: get_species_property_double
     procedure :: get_species_property_int
     procedure :: get_species_property_bool
+    ! Solver parameters
+    procedure :: set_rosenbrock_solver_parameters
+    procedure :: set_backward_euler_solver_parameters
+    procedure :: get_rosenbrock_solver_parameters
+    procedure :: get_backward_euler_solver_parameters
     ! Deallocate the micm instance
     final :: finalize
   end type micm_t
@@ -434,5 +516,123 @@ function is_cuda_available(error) result(value)
     value = is_cuda_available_c(error_c)
     error = error_t(error_c)
   end function is_cuda_available
-  
+
+  subroutine set_rosenbrock_solver_parameters(this, params, error)
+    use musica_util, only: error_t_c, error_t
+    use iso_c_binding, only: c_loc
+    class(micm_t), intent(in)                        :: this
+    type(rosenbrock_solver_parameters_t), intent(in), target :: params
+    type(error_t), intent(inout)                     :: error
+
+    type(rosenbrock_solver_parameters_t_c) :: params_c
+    type(error_t_c)                        :: error_c
+    real(c_double), allocatable, target     :: abs_tol_c(:)
+
+    params_c%relative_tolerance = real(params%relative_tolerance, c_double)
+    params_c%h_min = real(params%h_min, c_double)
+    params_c%h_max = real(params%h_max, c_double)
+    params_c%h_start = real(params%h_start, c_double)
+    params_c%max_number_of_steps = int(params%max_number_of_steps, c_size_t)
+    if (allocated(params%absolute_tolerances)) then
+      allocate(abs_tol_c(size(params%absolute_tolerances)))
+      abs_tol_c = real(params%absolute_tolerances, c_double)
+      params_c%absolute_tolerances = c_loc(abs_tol_c(1))
+      params_c%num_absolute_tolerances = int(size(abs_tol_c), c_size_t)
+    else
+      params_c%absolute_tolerances = c_null_ptr
+      params_c%num_absolute_tolerances = 0
+    end if
+    call set_rosenbrock_solver_parameters_c(this%ptr, params_c, error_c)
+    error = error_t(error_c)
+  end subroutine set_rosenbrock_solver_parameters
+
+  subroutine set_backward_euler_solver_parameters(this, params, error)
+    use musica_util, only: error_t_c, error_t
+    use iso_c_binding, only: c_loc
+    class(micm_t), intent(in)                           :: this
+    type(backward_euler_solver_parameters_t), intent(in), target :: params
+    type(error_t), intent(inout)                        :: error
+
+    type(backward_euler_solver_parameters_t_c) :: params_c
+    type(error_t_c)                            :: error_c
+    real(c_double), allocatable, target         :: abs_tol_c(:)
+    real(c_double), allocatable, target         :: tsr_c(:)
+
+    params_c%relative_tolerance = real(params%relative_tolerance, c_double)
+    params_c%max_number_of_steps = int(params%max_number_of_steps, c_size_t)
+    if (allocated(params%absolute_tolerances)) then
+      allocate(abs_tol_c(size(params%absolute_tolerances)))
+      abs_tol_c = real(params%absolute_tolerances, c_double)
+      params_c%absolute_tolerances = c_loc(abs_tol_c(1))
+      params_c%num_absolute_tolerances = int(size(abs_tol_c), c_size_t)
+    else
+      params_c%absolute_tolerances = c_null_ptr
+      params_c%num_absolute_tolerances = 0
+    end if
+    allocate(tsr_c(size(params%time_step_reductions)))
+    tsr_c = real(params%time_step_reductions, c_double)
+    params_c%time_step_reductions = c_loc(tsr_c(1))
+    params_c%num_time_step_reductions = int(size(tsr_c), c_size_t)
+    call set_backward_euler_solver_parameters_c(this%ptr, params_c, error_c)
+    error = error_t(error_c)
+  end subroutine set_backward_euler_solver_parameters
+
+  function get_rosenbrock_solver_parameters(this, error) result(params)
+    use musica_util, only: error_t_c, error_t
+    class(micm_t), intent(in)    :: this
+    type(error_t), intent(inout) :: error
+    type(rosenbrock_solver_parameters_t) :: params
+
+    type(rosenbrock_solver_parameters_t_c) :: params_c
+    type(error_t_c)                        :: error_c
+    real(c_double), pointer                :: abs_tol_ptr(:)
+
+    params_c%absolute_tolerances = c_null_ptr
+    params_c%num_absolute_tolerances = 0
+    call get_rosenbrock_solver_parameters_c(this%ptr, params_c, error_c)
+    error = error_t(error_c)
+    if (.not. error%is_success()) return
+    params%relative_tolerance = real(params_c%relative_tolerance, real64)
+    params%h_min = real(params_c%h_min, real64)
+    params%h_max = real(params_c%h_max, real64)
+    params%h_start = real(params_c%h_start, real64)
+    params%max_number_of_steps = int(params_c%max_number_of_steps)
+    if (params_c%num_absolute_tolerances > 0 .and. c_associated(params_c%absolute_tolerances)) then
+      call c_f_pointer(params_c%absolute_tolerances, abs_tol_ptr, [int(params_c%num_absolute_tolerances)])
+      allocate(params%absolute_tolerances(int(params_c%num_absolute_tolerances)))
+      params%absolute_tolerances = real(abs_tol_ptr, real64)
+    end if
+  end function get_rosenbrock_solver_parameters
+
+  function get_backward_euler_solver_parameters(this, error) result(params)
+    use musica_util, only: error_t_c, error_t
+    class(micm_t), intent(in)    :: this
+    type(error_t), intent(inout) :: error
+    type(backward_euler_solver_parameters_t) :: params
+
+    type(backward_euler_solver_parameters_t_c) :: params_c
+    type(error_t_c)                            :: error_c
+    real(c_double), pointer                    :: abs_tol_ptr(:)
+    real(c_double), pointer                    :: tsr_ptr(:)
+
+    params_c%absolute_tolerances = c_null_ptr
+    params_c%num_absolute_tolerances = 0
+    params_c%time_step_reductions = c_null_ptr
+    params_c%num_time_step_reductions = 0
+    call get_backward_euler_solver_parameters_c(this%ptr, params_c, error_c)
+    error = error_t(error_c)
+    if (.not. error%is_success()) return
+    params%relative_tolerance = real(params_c%relative_tolerance, real64)
+    params%max_number_of_steps = int(params_c%max_number_of_steps)
+    if (params_c%num_absolute_tolerances > 0 .and. c_associated(params_c%absolute_tolerances)) then
+      call c_f_pointer(params_c%absolute_tolerances, abs_tol_ptr, [int(params_c%num_absolute_tolerances)])
+      allocate(params%absolute_tolerances(int(params_c%num_absolute_tolerances)))
+      params%absolute_tolerances = real(abs_tol_ptr, real64)
+    end if
+    if (params_c%num_time_step_reductions > 0 .and. c_associated(params_c%time_step_reductions)) then
+      call c_f_pointer(params_c%time_step_reductions, tsr_ptr, [int(params_c%num_time_step_reductions)])
+      params%time_step_reductions = real(tsr_ptr, real64)
+    end if
+  end function get_backward_euler_solver_parameters
+
 end module musica_micm

fortran/test/integration/test_micm_api.F90

@@ -9,6 +9,7 @@ program test_micm_api
   use musica_util, only: assert, error_t, mapping_t, string_t, find_mapping_index
   use musica_micm, only: micm_t, solver_stats_t, get_micm_version, is_cuda_available
   use musica_micm, only: Rosenbrock, RosenbrockStandardOrder, BackwardEuler, BackwardEulerStandardOrder, CudaRosenbrock
+  use musica_micm, only: rosenbrock_solver_parameters_t, backward_euler_solver_parameters_t
   use musica_state, only: conditions_t, state_t
 
 #include "micm/util/error.hpp"
@@ -51,7 +52,10 @@ program test_micm_api
 
   write(*,*) "Testing multiple grid cell solvers with CUDA Rosenbrock method..."
   call test_multiple_grid_cell_cuda_Rosenbrock()
-  
+
+  write(*,*) "Testing solver parameters..."
+  call test_solver_parameters()
+
 contains
 
   function calculate_arrhenius( reaction, temperature, pressure ) result( rate )
@@ -479,6 +483,53 @@ subroutine test_multiple_grid_cell_cuda_Rosenbrock()
 
   end subroutine test_multiple_grid_cell_cuda_Rosenbrock
 
+  subroutine test_solver_parameters()
+
+    type(micm_t), pointer :: micm
+    type(error_t) :: error
+    type(rosenbrock_solver_parameters_t) :: ros_params, ros_result
+    type(backward_euler_solver_parameters_t) :: be_params, be_result
+
+    write(*,*) "[test solver params] Testing Rosenbrock solver parameters..."
+    micm => micm_t("configs/v0/analytical", RosenbrockStandardOrder, error)
+    ASSERT( error%is_success() )
+
+    ros_params%relative_tolerance = 1.0e-8_real64
+    ros_params%h_min = 1.0e-10_real64
+    ros_params%h_max = 100.0_real64
+    ros_params%h_start = 1.0e-5_real64
+    ros_params%max_number_of_steps = 500
+
+    call micm%set_rosenbrock_solver_parameters(ros_params, error)
+    ASSERT( error%is_success() )
+
+    ros_result = micm%get_rosenbrock_solver_parameters(error)
+    ASSERT( error%is_success() )
+    ASSERT_EQ( ros_result%max_number_of_steps, 500 )
+
+    deallocate(micm)
+
+    write(*,*) "[test solver params] Testing Backward Euler solver parameters..."
+    micm => micm_t("configs/v0/analytical", BackwardEulerStandardOrder, error)
+    ASSERT( error%is_success() )
+
+    be_params%relative_tolerance = 1.0e-8_real64
+    be_params%max_number_of_steps = 20
+    be_params%time_step_reductions = (/ 0.3_real64, 0.3_real64, 0.3_real64, 0.3_real64, 0.05_real64 /)
+
+    call micm%set_backward_euler_solver_parameters(be_params, error)
+    ASSERT( error%is_success() )
+
+    be_result = micm%get_backward_euler_solver_parameters(error)
+    ASSERT( error%is_success() )
+    ASSERT_EQ( be_result%max_number_of_steps, 20 )
+
+    deallocate(micm)
+
+    write(*,*) "[test solver params] Finished."
+
+  end subroutine test_solver_parameters
+
   subroutine test_api_v1_parser()
 
     type(string_t)                :: micm_version

include/musica/micm/cpu_solver.hpp

@@ -71,9 +71,17 @@ namespace musica
     std::unordered_map<std::string, std::size_t> GetRateParameterOrdering() const override;
     std::size_t GetVectorSize() const override;
 
+    void SetRosenbrockSolverParameters(const RosenbrockSolverParameters& params) override;
+    void SetBackwardEulerSolverParameters(const BackwardEulerSolverParameters& params) override;
+    RosenbrockSolverParameters GetRosenbrockSolverParameters() const override;
+    BackwardEulerSolverParameters GetBackwardEulerSolverParameters() const override;
+
    private:
     SolverVariant solver_;
     int solver_type_;
+    double relative_tolerance_{ 1e-6 };
+    std::vector<double> absolute_tolerances_{};
+    bool tolerances_set_{ false };
   };
 
 }  // namespace musica

include/musica/micm/micm.hpp

@@ -8,6 +8,7 @@
 #include <musica/micm/chemistry.hpp>
 #include <musica/micm/parse.hpp>
 #include <musica/micm/solver_interface.hpp>
+#include <musica/micm/solver_parameters.hpp>
 
 #include <micm/solver/solver_result.hpp>
 #include <micm/system/system.hpp>
@@ -100,6 +101,10 @@ namespace musica
    public:
     MICM(const Chemistry& chemistry, MICMSolver solver_type);
     MICM(std::string config_path, MICMSolver solver_type);
+    MICM(const Chemistry& chemistry, MICMSolver solver_type, const RosenbrockSolverParameters& params);
+    MICM(std::string config_path, MICMSolver solver_type, const RosenbrockSolverParameters& params);
+    MICM(const Chemistry& chemistry, MICMSolver solver_type, const BackwardEulerSolverParameters& params);
+    MICM(std::string config_path, MICMSolver solver_type, const BackwardEulerSolverParameters& params);
     MICM() = default;
     ~MICM();
 
@@ -160,6 +165,22 @@ namespace musica
     /// @return Pointer to the IMicmSolver implementation
     IMicmSolver* GetSolverInterface();
 
+    /// @brief Set Rosenbrock solver parameters
+    /// @param params The parameters to set
+    void SetSolverParameters(const RosenbrockSolverParameters& params);
+
+    /// @brief Set Backward Euler solver parameters
+    /// @param params The parameters to set
+    void SetSolverParameters(const BackwardEulerSolverParameters& params);
+
+    /// @brief Get Rosenbrock solver parameters
+    /// @return The current parameters
+    RosenbrockSolverParameters GetRosenbrockSolverParameters() const;
+
+    /// @brief Get Backward Euler solver parameters
+    /// @return The current parameters
+    BackwardEulerSolverParameters GetBackwardEulerSolverParameters() const;
+
    private:
     SolverPtr solver_;
     MICMSolver solver_type_ = UndefinedSolver;