musica 0.12.1__tar.gz → 0.12.2__tar.gz

{musica-0.12.1 → musica-0.12.2}/.github/workflows/python-tests.yml

@@ -43,6 +43,8 @@ jobs:
 
     - name: Build and install
       run: pip install --verbose .[test]
+      env:
+        FC: gfortran-14
 
     - name: Test
       run: pytest -s

{musica-0.12.1 → musica-0.12.2}/.github/workflows/python-wheels.yml

@@ -40,8 +40,12 @@ jobs:
           # Linux builds (supports cross-compilation via QEMU)
           - os: ubuntu-latest
             python-version: "3.13"
-            cibw_archs: "x86_64 aarch64 i686"
+            cibw_archs: "x86_64 i686"
           
+          - os: ubuntu-24.04-arm
+            python-version: "3.13"
+            cibw_archs: "aarch64"
+
           # Windows builds (separate runners needed for different archs)
           - os: windows-latest
             python-version: "3.13"
@@ -51,11 +55,13 @@ jobs:
           - os: macos-13  # Intel runner
             python-version: "3.13"
             cibw_archs: "x86_64"
+            fc: gfortran-15
           
           # macOS Apple Silicon
           - os: macos-latest  # ARM64 runner
             python-version: "3.13"
             cibw_archs: "arm64"
+            fc: gfortran-15
 
     steps:
     - uses: actions/checkout@v4
@@ -66,14 +72,16 @@ jobs:
       with:
         python-version: ${{ matrix.python-version }}
   
-    - name: Set up QEMU for cross-architecture builds
-      if: matrix.os == 'ubuntu-latest'
-      uses: docker/setup-qemu-action@v3
-      with:
-        platforms: all
+    - name: CI Build Wheels
+      if: ${{ matrix.fc != '' }}
+      uses: pypa/cibuildwheel@v3.1.3
+      env:
+        CIBW_ARCHS: ${{ matrix.cibw_archs }}
+        FC: ${{ matrix.fc }}
 
     - name: CI Build Wheels
-      uses: pypa/cibuildwheel@v2.17
+      if: ${{ matrix.fc == '' }}
+      uses: pypa/cibuildwheel@v3.1.3
       env:
         CIBW_ARCHS: ${{ matrix.cibw_archs }}
 

{musica-0.12.1 → musica-0.12.2}/CITATION.cff

@@ -64,4 +64,4 @@ number: 10
 page: "E1743 - E1760"
 doi: "10.1175/BAMS-D-19-0331.1"
 url: "https://journals.ametsoc.org/view/journals/bams/101/10/bamsD190331.xml"
-version: 0.12.1
+version: 0.12.2

{musica-0.12.1 → musica-0.12.2}/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.21)
 
 # must be on the same line so that pyproject.toml can correctly identify the version
-project(musica-distribution VERSION 0.12.1)
+project(musica-distribution VERSION 0.12.2)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH};${PROJECT_SOURCE_DIR}/cmake)
 set(CMAKE_USER_MAKE_RULES_OVERRIDE ${PROJECT_SOURCE_DIR}/cmake/SetDefaults.cmake)

{musica-0.12.1 → musica-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: musica
-Version: 0.12.1
+Version: 0.12.2
 Summary: MUSICA is a Python library for performing computational simulations in atmospheric chemistry.
 Author-Email: Matthew Dawsom <mattdawson@ucar.edu>, Jiwon Gim <jiwongim@ucar.edu>, David Fillmore <fillmore@ucar.edu>, Kyle Shores <kshores@ucar.edu>, Montek Thind <mthind@ucar.edu>
 Maintainer-Email: ACOM MUSICA Developers <musica-support@ucar.edu>
@@ -207,6 +207,7 @@ License:                                  Apache License
             limitations under the License.
          
 Project-URL: homepage, https://wiki.ucar.edu/display/MUSICA/MUSICA+Home
+Requires-Python: >=3.9
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: xarray>=2022.3.0
 Requires-Dist: ussa1976>=v0.3.4

{musica-0.12.1 → musica-0.12.2}/binder/environment.yml

@@ -3,5 +3,6 @@ channels:
   - conda-forge
 dependencies:
   - python>=3.9
+  - ipykernel
   - pip:
     - musica[tutorial]

{musica-0.12.1 → musica-0.12.2}/cmake/dependencies.cmake

@@ -75,7 +75,7 @@ endif()
 
 if (MUSICA_ENABLE_MICM AND MUSICA_BUILD_C_CXX_INTERFACE)
   set_git_default(MICM_GIT_REPOSITORY https://github.com/NCAR/micm.git)
-  set_git_default(MICM_GIT_TAG v3.9.0)
+  set_git_default(MICM_GIT_TAG d1c22955dc6af62cb4b2deb09d10bf19324e2340)
 
   FetchContent_Declare(micm
       GIT_REPOSITORY ${MICM_GIT_REPOSITORY}

{musica-0.12.1 → musica-0.12.2}/cmake/summary.cmake

@@ -10,7 +10,7 @@ else()
   set(CXX_COMPILER_NAME_INFO " ")
 endif()
 
-if(MUSICA_BUILD_FORTRAN_INTERFACE)
+if(MUSICA_BUILD_FORTRAN_INTERFACE OR MUSICA_ENABLE_TUVX OR MUSICA_ENABLE_CARMA)
   get_filename_component(Fortran_COMPILER_NAME ${CMAKE_Fortran_COMPILER} NAME)
   set(Fortran_COMPILER_NAME_INFO "${Fortran_COMPILER_NAME}")
   if(${CMAKE_Fortran_COMPILER_VERSION})

{musica-0.12.1 → musica-0.12.2}/docker/Dockerfile.python

@@ -26,4 +26,6 @@ ENV CXX=g++
 ENV CC=gcc
 ENV FC=gfortran
 
-RUN cd musica && pip install .[test]
+RUN cd musica && pip install .[test]
+
+WORKDIR /musica

musica-0.12.2/musica/examples/__init__.py

@@ -0,0 +1 @@
+from .examples import Examples

{musica-0.12.1 → musica-0.12.2}/musica/examples/carma_aluminum.py

@@ -11,6 +11,7 @@ import ussa1976
 
 available = musica.backend.carma_available()
 
+
 def run_carma_aluminum_example():
     group = musica.carma.CARMAGroupConfig(
         name="aluminum",

{musica-0.12.1 → musica-0.12.2}/musica/examples/carma_sulfate.py

@@ -14,6 +14,7 @@ import musica
 
 available = musica.backend.carma_available()
 
+
 def run_carma_sulfate_example():
     """Test CARMA sulfate growth from gas condensation in a simple single grid box."""
 

{musica-0.12.1 → musica-0.12.2}/musica/examples/sulfate_box_model.py

@@ -272,8 +272,8 @@ def run_box_model():
     state.set_concentrations(initial_concentrations)
     state.set_user_defined_rate_parameters({"EMIS.SO2": np.full(NUMBER_OF_GRID_CELLS, 1.0e-8, dtype=np.float64)})
 
-    # Run the simulation for 6 hours with a timestep of 30 seconds
-    time_hours = 2.0
+    # Run the simulation for 30 minutes with a timestep of 30 seconds
+    time_hours = 0.5
     time_seconds = time_hours * np.float64(3600.0)
     dt = np.float64(30.0)
     num_steps = int(time_seconds / dt)

{musica-0.12.1 → musica-0.12.2}/musica/examples/ts1_latin_hypercube.py

@@ -242,4 +242,4 @@ ax[2].set_ylabel('Air Density [kg m-3]')
 ax[2].set_xlabel('Grid Cell')
 
 fig.tight_layout()
-fig.savefig('ts1_latin_hypercube_conditions.png', dpi=300)
+fig.savefig('ts1_latin_hypercube_conditions.png', dpi=300)

{musica-0.12.1 → musica-0.12.2}/musica/test/integration/test_carma_aluminum.py

@@ -5,7 +5,8 @@ available = musica.backend.carma_available()
 pytestmark = pytest.mark.skipif(
     not available, reason="CARMA backend is not available")
 
+
 def test_carma_aluminum():
     from musica.examples import carma_aluminum
     state = carma_aluminum.run_carma_aluminum_example()
-    assert state is not None, "State should not be None"
+    assert state is not None, "State should not be None"

{musica-0.12.1 → musica-0.12.2}/musica/test/integration/test_carma_sulfate.py

@@ -5,6 +5,7 @@ available = musica.backend.carma_available()
 pytestmark = pytest.mark.skipif(
     not available, reason="CARMA backend is not available")
 
+
 def test_carma_sulfate():
     from musica.examples import carma_sulfate
     env_state, gas_state, bin_state = carma_sulfate.run_carma_sulfate_example()
@@ -13,4 +14,4 @@ def test_carma_sulfate():
     assert gas_state is not None, "Gas state should not be None"
     assert bin_state is not None, "Bin state should not be None"
     # Optionally, check expected dimensions or variables
-    assert hasattr(bin_state, "mass_mixing_ratio"), "Bin state should have mass_mixing_ratio"
+    assert hasattr(bin_state, "mass_mixing_ratio"), "Bin state should have mass_mixing_ratio"

musica-0.12.2/musica/test/unit/test_state.py

@@ -0,0 +1,325 @@
+"""Tests for the State class."""
+from __future__ import annotations
+import pytest  # type: ignore # pylint: disable=import-error
+import numpy as np  # type: ignore # pylint: disable=import-error
+from musica.types import State, MICM
+import musica.mechanism_configuration as mc
+from musica.mechanism_configuration import Mechanism
+
+
+def create_test_mechanism() -> Mechanism:
+    """Helper function to create a test mechanism."""
+    # Chemical species
+    A = mc.Species(
+        name="A",
+        diffusion_coefficient_m2_s=20.3,
+        molecular_weight_kg_mol=13.2,
+        other_properties={
+            "__absolute tolerance": "1.0e-30"})
+    B = mc.Species(name="B")
+    C = mc.Species(name="C")
+    M = mc.Species(name="M", is_third_body=True)
+
+    # Chemical phases
+    gas = mc.Phase(name="gas", species=[A, B, C, M])
+
+    # Reactions
+    my_arrhenius = mc.Arrhenius(
+        name="my arrhenius",
+        A=32.1, B=-2.3, C=102.3, D=63.4, E=-1.3,
+        gas_phase=gas,
+        reactants=[B],
+        products=[C],
+        other_properties={"__irrelevant": "2"},
+    )
+
+    my_other_arrhenius = mc.Arrhenius(
+        name="my other arrhenius",
+        A=29.3, B=-1.5, Ea=101.2, D=82.6, E=-0.98,
+        gas_phase=gas,
+        reactants=[A],
+        products=[(1.2, B)]
+    )
+
+    my_troe = mc.Troe(
+        name="my troe",
+        gas_phase=gas,
+        k0_A=1.2e-12,
+        k0_B=167,
+        k0_C=3,
+        kinf_A=136,
+        kinf_B=5,
+        kinf_C=24,
+        Fc=0.9,
+        N=0.8,
+        reactants=[B, A],
+        products=[C],
+        other_properties={"__irrelevant": "2"},
+    )
+
+    my_ternary = mc.TernaryChemicalActivation(
+        name="my ternary chemical activation",
+        gas_phase=gas,
+        k0_A=32.1,
+        k0_B=-2.3,
+        k0_C=102.3,
+        kinf_A=63.4,
+        kinf_B=-1.3,
+        kinf_C=908.5,
+        Fc=1.3,
+        N=32.1,
+        reactants=[B, A],
+        products=[C],
+        other_properties={"__irrelevant": "2"},
+    )
+
+    my_branched = mc.Branched(
+        name="my branched",
+        gas_phase=gas,
+        reactants=[A],
+        alkoxy_products=[B],
+        nitrate_products=[C],
+        X=1.2e-4,
+        Y=167,
+        a0=0.15,
+        n=9,
+        other_properties={"__irrelevant": "2"},
+    )
+
+    my_tunneling = mc.Tunneling(
+        name="my tunneling",
+        gas_phase=gas,
+        reactants=[B],
+        products=[C],
+        A=123.45,
+        B=1200.0,
+        C=1.0e8,
+        other_properties={"__irrelevant": "2"},
+    )
+
+    my_surface = mc.Surface(
+        name="my surface",
+        gas_phase=gas,
+        gas_phase_species=A,
+        reaction_probability=2.0e-2,
+        gas_phase_products=[B, C],
+        other_properties={"__irrelevant": "2"},
+    )
+
+    photo_b = mc.Photolysis(
+        name="photo B",
+        gas_phase=gas,
+        reactants=[B],
+        products=[C],
+        scaling_factor=12.3,
+        other_properties={"__irrelevant": "2"},
+    )
+
+    my_emission = mc.Emission(
+        name="my emission",
+        gas_phase=gas,
+        products=[B],
+        scaling_factor=12.3,
+        other_properties={"__irrelevant": "2"},
+    )
+
+    my_first_order_loss = mc.FirstOrderLoss(
+        name="my first order loss",
+        gas_phase=gas,
+        reactants=[C],
+        scaling_factor=12.3,
+        other_properties={"__irrelevant": "2"},
+    )
+
+    user_defined = mc.UserDefined(
+        name="my user defined",
+        gas_phase=gas,
+        reactants=[A, B],
+        products=[(1.3, C)],
+        scaling_factor=12.3,
+        other_properties={"__irrelevant": "2"}
+    )
+
+    # Mechanism
+    return mc.Mechanism(
+        name="Full Configuration",
+        species=[A, B, C, M],
+        phases=[gas],
+        reactions=[my_arrhenius, my_other_arrhenius, my_troe, my_ternary,
+                   my_branched, my_tunneling, my_surface, photo_b,
+                   my_emission, my_first_order_loss, user_defined],
+        version=mc.Version(1, 0, 0),
+    )
+
+
+def get_test_solver(mech: Mechanism) -> MICM:
+    """Helper function to create a test solver."""
+    return MICM(mechanism=mech)
+
+
+def test_state_initialization():
+    """Test State initialization with various grid cell configurations."""
+    # Use the test mechanism
+    mech = create_test_mechanism()
+
+    # Create MICM instance
+    solver = get_test_solver(mech)
+
+    # Test with valid input
+    state = solver.create_state(number_of_grid_cells=1)
+    assert isinstance(state, State)
+
+    # Test with multiple grid cells
+    state_multi = solver.create_state(number_of_grid_cells=3)
+    assert isinstance(state_multi, State)
+
+    # Test with invalid input
+    with pytest.raises(ValueError, match="number_of_grid_cells must be greater than 0"):
+        solver.create_state(number_of_grid_cells=0)
+
+
+def test_set_get_concentrations():
+    """Test setting and getting concentrations."""
+    # Use the test mechanism
+    mech = create_test_mechanism()
+    solver = get_test_solver(mech)
+
+    # Test single grid cell
+    state = solver.create_state(number_of_grid_cells=1)
+    concentrations = {"A": 1.0, "B": 2.0, "C": 3.0}
+    state.set_concentrations(concentrations)
+    result = state.get_concentrations()
+    assert result["A"][0] == 1.0
+    assert result["B"][0] == 2.0
+    assert result["C"][0] == 3.0
+
+    # Test multiple grid cells
+    state_multi = solver.create_state(number_of_grid_cells=2)
+    concentrations_multi = {"A": [1.0, 2.0], "B": [3.0, 4.0], "C": [5.0, 6.0]}
+    state_multi.set_concentrations(concentrations_multi)
+    result_multi = state_multi.get_concentrations()
+    assert result_multi["A"] == [1.0, 2.0]
+    assert result_multi["B"] == [3.0, 4.0]
+    assert result_multi["C"] == [5.0, 6.0]
+
+    # Test invalid species
+    with pytest.raises(ValueError, match="Species D not found in the mechanism"):
+        state.set_concentrations({"D": 1.0})
+
+    # Test invalid length
+    with pytest.raises(ValueError, match="must have length"):
+        state_multi.set_concentrations({"A": [1.0]})
+
+    # Test cannot set third-body species
+    with pytest.raises(ValueError, match="Species M not found in the mechanism"):
+        state.set_concentrations({"M": 1.0})
+
+
+def test_set_get_conditions():
+    """Test setting and getting environmental conditions."""
+    # Use the test mechanism
+    mech = create_test_mechanism()
+    solver = get_test_solver(mech)
+
+    # Test single grid cell
+    state = solver.create_state(number_of_grid_cells=1)
+    state.set_conditions(temperatures=300.0, pressures=101325.0)
+    conditions = state.get_conditions()
+    assert conditions["temperature"][0] == 300.0
+    assert conditions["pressure"][0] == 101325.0
+    assert np.isclose(conditions["air_density"][0], 40.9, rtol=0.1)  # Approximate value from ideal gas law
+
+    # Test multiple grid cells
+    state_multi = solver.create_state(number_of_grid_cells=2)
+    state_multi.set_conditions(
+        temperatures=[300.0, 310.0],
+        pressures=[101325.0, 101325.0],
+        air_densities=[40.9, 39.5]
+    )
+    conditions_multi = state_multi.get_conditions()
+    assert conditions_multi["temperature"] == [300.0, 310.0]
+    assert conditions_multi["pressure"] == [101325.0, 101325.0]
+    assert conditions_multi["air_density"] == [40.9, 39.5]
+
+    # Test invalid input length
+    with pytest.raises(ValueError, match="must be a list of length"):
+        state_multi.set_conditions(temperatures=[300.0])
+
+
+def test_set_get_user_defined_rate_parameters():
+    """Test setting and getting user-defined rate parameters."""
+    # Use the test mechanism which includes a user-defined reaction
+    mech = create_test_mechanism()
+    solver = get_test_solver(mech)
+
+    # Test single grid cell
+    state = solver.create_state(number_of_grid_cells=1)
+    params = {"EMIS.my emission": 1.0}
+    state.set_user_defined_rate_parameters(params)
+    result = state.get_user_defined_rate_parameters()
+    assert result["EMIS.my emission"][0] == 1.0
+
+    # Test multiple grid cells
+    state_multi = solver.create_state(number_of_grid_cells=2)
+    params_multi = {"PHOTO.photo B": [1.0, 2.0]}
+    state_multi.set_user_defined_rate_parameters(params_multi)
+    result_multi = state_multi.get_user_defined_rate_parameters()
+    assert result_multi["PHOTO.photo B"] == [1.0, 2.0]
+
+    # Test invalid parameter
+    with pytest.raises(ValueError, match="User-defined rate parameter invalid_param not found"):
+        state.set_user_defined_rate_parameters({"invalid_param": 1.0})
+
+    solver = get_test_solver(mech)
+
+    state = solver.create_state(number_of_grid_cells=1)
+
+    # Test species ordering
+    species_ordering = state.get_species_ordering()
+    assert isinstance(species_ordering, dict)
+    assert len(species_ordering) == 3  # A, B, C (M is third-body and not included)
+
+    # Dictionary style access
+    assert species_ordering["A"] >= 0
+    assert species_ordering["B"] >= 0
+    assert species_ordering["C"] >= 0
+
+    # Using get() method with default value
+    assert species_ordering.get("A", -1) >= 0  # returns value if key exists
+    assert species_ordering.get("Z", -1) == -1  # returns -1 since Z doesn't exist
+
+    # Test key membership
+    assert "A" in species_ordering
+    assert "B" in species_ordering
+    assert "C" in species_ordering
+    assert "M" not in species_ordering  # third-body not included
+
+    # Test parameter ordering
+    param_ordering = state.get_user_defined_rate_parameters_ordering()
+    assert isinstance(param_ordering, dict)
+    assert len(param_ordering) == 6
+
+    # Convert dict keys to list using list() function
+    param_names = list(param_ordering.keys())
+    assert len(param_names) == 6
+    assert isinstance(param_names[0], str)
+
+    # Alternative way using list comprehension
+    param_names_alt = [key for key in param_ordering]
+    assert param_names_alt == param_names
+
+    # Sort the keys if needed - useful for consistent ordering in tests
+    sorted_param_names = sorted(param_ordering.keys())
+    assert len(sorted_param_names) == 6
+    assert all(isinstance(name, str) for name in sorted_param_names)
+
+    # Verify all expected keys are present
+    expected_params = [
+        "PHOTO.photo B",
+        "EMIS.my emission",
+        "LOSS.my first order loss",
+        "SURF.my surface.effective radius [m]",
+        "SURF.my surface.particle number concentration [# m-3]",
+        "USER.my user defined"
+    ]
+    assert sorted(expected_params) == sorted(param_names)

musica-0.12.2/musica/tools/prepare_build_environment_linux.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -e
+set -x
+
+target_arch="$(uname -m)"
+echo "Detected target_arch: $target_arch"
+
+dnf -y update
+
+# For 64 bit systems can enable our fortran components, but we require netcdf
+if [[ "$target_arch" == "x86_64" || "$target_arch" == "aarch64" ]]; then
+  dnf install -y epel-release
+  dnf install -y netcdf-devel netcdf-fortran-devel
+fi
+
+dnf install -y tree wget zip lapack-devel
+
+# 64 bit intel and amd systems support building cuda
+if [ "$target_arch" = "x86_64" ]; then
+  # Install CUDA 12.8 for x86_64 on AlmaLinux 8 (manylinux_2_28) - supports GCC 14
+  dnf config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
+  dnf install --setopt=obsoletes=0 -y \
+      cuda-nvcc-12-8 \
+      cuda-cudart-devel-12-8 \
+      libcurand-devel-12-8 \
+      libcublas-devel-12-8 
+  ln -sf cuda-12.8 /usr/local/cuda
+
+  # Verify CUDA installation
+  echo "=== CUDA Installation Verification ==="
+  /usr/local/cuda/bin/nvcc --version
+fi

{musica-0.12.1 → musica-0.12.2}/musica/types.py

@@ -165,30 +165,31 @@ class State():
                     k += 1
 
     def set_conditions(self,
-                       temperatures: Union[Union[float, int], List[Union[float, int]]],
-                       pressures: Union[Union[float, int], List[Union[float, int]]],
+                       temperatures: Optional[Union[Union[float, int], List[Union[float, int]]]] = None,
+                       pressures: Optional[Union[Union[float, int], List[Union[float, int]]]] = None,
                        air_densities: Optional[Union[Union[float, int], List[Union[float, int]]]] = None):
         """
         Set the conditions for the state. The individual conditions can be a single value
         when solving for a single grid cell, or a list of values when solving for multiple grid cells.
         If air density is not provided, it will be calculated from the Ideal Gas Law using the provided
-        temperature and pressure.
+        temperature and pressure. If temperature or pressure are not provided, their values will remain
+        unchanged.
 
         Parameters
         ----------
-        temperatures : Union[float, List[float]]
+        temperatures : Optional[Union[float, List[float]]]
             Temperature in Kelvin.
-        pressures : Union[float, List[float]]
+        pressures : Optional[Union[float, List[float]]]
             Pressure in Pascals.
         air_densities : Optional[Union[float, List[float]]]
             Air density in mol m-3. If not provided, it will be calculated from the Ideal Gas Law.
         """
-        if isinstance(temperatures, float) or isinstance(temperatures, int):
+        if temperatures is not None and (isinstance(temperatures, float) or isinstance(temperatures, int)):
             if self.__number_of_grid_cells > 1:
                 raise ValueError(
                     f"temperatures must be a list of length {self.__number_of_grid_cells}.")
             temperatures = [temperatures]
-        if isinstance(pressures, float) or isinstance(pressures, int):
+        if pressures is not None and (isinstance(pressures, float) or isinstance(pressures, int)):
             if self.__number_of_grid_cells > 1:
                 raise ValueError(
                     f"pressures must be a list of length {self.__number_of_grid_cells}.")
@@ -198,10 +199,10 @@ class State():
                 raise ValueError(
                     f"air_densities must be a list of length {self.__number_of_grid_cells}.")
             air_densities = [air_densities]
-        if len(temperatures) != self.__number_of_grid_cells:
+        if temperatures is not None and len(temperatures) != self.__number_of_grid_cells:
             raise ValueError(
                 f"temperatures must be a list of length {self.__number_of_grid_cells}.")
-        if len(pressures) != self.__number_of_grid_cells:
+        if pressures is not None and len(pressures) != self.__number_of_grid_cells:
             raise ValueError(
                 f"pressures must be a list of length {self.__number_of_grid_cells}.")
         if air_densities is not None and len(air_densities) != self.__number_of_grid_cells:
@@ -210,10 +211,10 @@ class State():
         k = 0
         for state in self.__states:
             for condition in state.conditions:
-                condition.temperature = temperatures[k]
-                condition.pressure = pressures[k]
-                condition.air_density = air_densities[k] if air_densities is not None else pressures[k] / (
-                    GAS_CONSTANT * temperatures[k])
+                condition.temperature = temperatures[k] if temperatures is not None else condition.temperature
+                condition.pressure = pressures[k] if pressures is not None else condition.pressure
+                condition.air_density = air_densities[k] if air_densities is not None else condition.pressure / (
+                    GAS_CONSTANT * condition.temperature)
                 k += 1
 
     def get_concentrations(self) -> Dict[str, List[float]]:
@@ -334,11 +335,13 @@ class MICM():
                 Mechanism object which specifies the chemical mechanism to use. If provided, this will be used
                 to create the solver.
             solver_type : SolverType, optional
-                Type of solver to use. If not provided, the default solver type will be used.
+                Type of solver to use. If not provided, the default Rosenbrock (with standard-ordered matrices) solver type will be used.
             ignore_non_gas_phases : bool, optional
                 If True, non-gas phases will be ignored when configuring micm with the mechanism. This is only needed
                 until micm properly supports non-gas phases. This option is only supported when passing in a mechanism.
         """
+        if solver_type is None:
+            solver_type = SolverType.rosenbrock_standard_order
         self.__solver_type = solver_type
         self.__vector_size = _vector_size(solver_type)
         if config_path is None and mechanism is None: