musica 0.12.1__cp310-cp310-win_arm64.whl → 0.12.2__cp310-cp310-win_arm64.whl

musica/_version.py

@@ -1 +1 @@
-version = "0.12.1"
+version = "0.12.2"

musica/examples/__init__.py

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

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/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/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/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/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/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/test/integration/test_sulfate_box_model.py

@@ -5,6 +5,7 @@ available = musica.backend.carma_available()
 pytestmark = pytest.mark.skipif(
     not available, reason="CARMA backend is not available")
 
+
 def test_sulfate_box_model():
     """Test the sulfate box model implementation."""
     from musica.examples import sulfate_box_model
@@ -31,4 +32,3 @@ def test_sulfate_box_model():
     print(f"   Chemical species tracked: {list(concentrations.columns)}")
     print(f"   CARMA bins: {len(sulfate_data.bin)}")
     print(f"   Vertical levels: {len(sulfate_data.vertical_center)}")
-

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/tools/prepare_build_environment_linux.sh

@@ -5,32 +5,17 @@ set -x
 target_arch="$(uname -m)"
 echo "Detected target_arch: $target_arch"
 
-# Set package manager based on architecture
-# x86_64 and aarch64 use manylinux_2_28 (AlmaLinux 8) with dnf
-# i686 uses manylinux2014 (CentOS 7) with yum
-if [ "$target_arch" = "i686" ]; then
-  PKG_MGR="yum"
-  
-  # CentOS 7 is EOL, so we need to use vault.centos.org for i686 builds
-  # Replace the repo files to point to vault.centos.org
-  sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*.repo
-  sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*.repo
-else
-  PKG_MGR="dnf"
-fi
-
-echo "Using package manager: $PKG_MGR"
-
-$PKG_MGR -y update
+dnf -y update
 
-if [ "$target_arch" = "x86_64" ] || [ "$target_arch" = "aarch64" ]; then
-  # For manylinux_2_28 (AlmaLinux 8), epel-release is required to get netcdf, for some reason
-  $PKG_MGR install -y epel-release
-  $PKG_MGR install -y netcdf-devel netcdf-fortran-devel
+# 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
 
-$PKG_MGR install -y tree wget zip lapack-devel
+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
@@ -44,7 +29,4 @@ if [ "$target_arch" = "x86_64" ]; then
   # Verify CUDA installation
   echo "=== CUDA Installation Verification ==="
   /usr/local/cuda/bin/nvcc --version
-  
-  # list the installed CUDA packages
-  # tree -L 4 /usr/local/cuda
 fi

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:

{musica-0.12.1.dist-info → musica-0.12.2.dist-info}/METADATA

@@ -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.dist-info → musica-0.12.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 musica/__init__.py,sha256=pSZ-H2IJ4EEYIbQDygjGwjhGySXdeifB1DzQBMJzz2g,403
-musica/_musica.cp310-win_amd64.pyd,sha256=thVujIHODau8317jEA113jURuckUBjqGY6kSxw4FCxQ,1667072
-musica/_version.py,sha256=RtCQ8kIuMhcZYVMe49ceaEtTSjdzpfPWuCJXoyjaKg0,20
+musica/_musica.cp310-win_amd64.pyd,sha256=Qrd44IbVXubp2cowwL8wS8f1AMeLcB9-05P53QOrnFw,1671680
+musica/_version.py,sha256=4bzF9LMIExRVigCODQ4A-chBc4NdBm0Fk_FjBxMRo9Q,20
 musica/backend.py,sha256=Fw3-HECqsifQmvRonDTGeEZqS-KXYD09BCwBue_HwfM,1081
 musica/binding_common.cpp,sha256=qrJCfdePt-ZoIgCTrPJqSUF1Ie8Mq7b7S2_pEdpi4CE,1013
 musica/binding_common.hpp,sha256=YAcb9WnfXL7Ps-rR-iMBSwUgBQZfZZdCQQod5CTMEZA,108
@@ -11,12 +11,12 @@ musica/constants.py,sha256=sQqh1UVu2HRvl25qWPW0ACT8NrHe_r4Ugy-v_BiTGG4,126
 musica/cpu_binding.cpp,sha256=Cy06zLErMV0g7Ol9Fg-q2cpG-g5fb8hcBl-M-ihHLyk,236
 musica/cuda.cpp,sha256=oTG2ZnL-SiW2kx9eL4XJOQGJeIiGuy8tJ5BEoLRWL4M,358
 musica/cuda.py,sha256=ClHKnSNiU8SX0BANh5KybismYHH6mFUyC-3r8S9qARo,271
-musica/examples/__init__.py,sha256=y9FNR3NhT9OYCk7S_kktyOSpkRqwQb-VLNiaMp0rbz0,30
-musica/examples/carma_aluminum.py,sha256=QTdJpcpvoyR4HbliFqfuEIwRHGT0v3NUjC9tiTv1mnc,3806
-musica/examples/carma_sulfate.py,sha256=_LgXOupxsLD6UkziRw40nDsDXPFbmKH-8VyPXaqnUD0,8363
+musica/examples/__init__.py,sha256=hR0kZhoHfL9dcup7gg64HDJyIyAQqHAsip8LpuRNnI8,32
+musica/examples/carma_aluminum.py,sha256=Q2IRvU9jxuKAUZvhQkTawVfZV0UADiMvXP-R6uzjemo,3808
+musica/examples/carma_sulfate.py,sha256=MbV1oBrB6rc7yWMxbnYVr_SHlTMqd6uV21kwVhlUymY,8365
 musica/examples/examples.py,sha256=xWnFSNMYPpUhz04YtSSNsr6DoxmQoOdUtTT9GSUm3ps,5901
-musica/examples/sulfate_box_model.py,sha256=AlQ_30dMLf4wbs9pGWw6y9bxNUHLVIsdJlx9fbC-LKk,17107
-musica/examples/ts1_latin_hypercube.py,sha256=yQIUZJiNnJx5yF_pW9RWq9uZNECQagKDFJdEvl9-17w,9866
+musica/examples/sulfate_box_model.py,sha256=LU1kJYtCZNV_4Mi8kJl2V7YQwQuP1dv8Ba4-2vhPFbE,17110
+musica/examples/ts1_latin_hypercube.py,sha256=tLH9swPT4pvDnd7a86-xnt8PqXl4Y7bAXowsA0J7PV8,9868
 musica/gpu_binding.cpp,sha256=X0qISrKYz7Ldjn5UnqNw8oLzOY4VgyF3fUUszm-QSJI,240
 musica/main.py,sha256=gVCfeh44VL4EH7eFRR2wU_I_kANB94furojDi-0LhoE,2797
 musica/mechanism_configuration/__init__.py,sha256=odlwrCvBBnqUBi951RysExLDYqK_AfqP4nRY90MQpcc,40
@@ -47,23 +47,24 @@ musica/test/examples/v1/full_configuration/full_configuration.json,sha256=zBC3EV
 musica/test/examples/v1/full_configuration/full_configuration.yaml,sha256=XY6TW78rus0DyrI70NR3yvTeUIPff8_I9ErOXy2m3KE,5911
 musica/test/integration/test_analytical.py,sha256=eOPb3DtjQEodTZCpjelw1LQZM_VyhFi2TOlx1bmEtkk,14129
 musica/test/integration/test_carma.py,sha256=itPJNxSRp7FHJokYSicZFgqzBBrZ9dr1TDxawDPT9BM,7092
-musica/test/integration/test_carma_aluminum.py,sha256=qDbFtD7b1q7zW8I_8Fky9tQLevVrQ5DBLxeVyD5OEGY,364
-musica/test/integration/test_carma_sulfate.py,sha256=-xChTCI0eLFOWKNQx6KHq8RJ_KgU4cP1nP92_qHn0-M,755
+musica/test/integration/test_carma_aluminum.py,sha256=F7_8xwZnKjSxgnZKdZR1tDwzwfVUiD7ZT1b_9cseE3M,368
+musica/test/integration/test_carma_sulfate.py,sha256=OWQDLQNao5vU2FAMpWDVqs8xrFhpxvRfhx8HrP6GTCs,759
 musica/test/integration/test_chapman.py,sha256=t6p0CadUy-B4OP7A-EZ9Wz52diuYs5yc9LKiFUS9T6A,3651
-musica/test/integration/test_sulfate_box_model.py,sha256=3hb63Tij05VX__CIRT-njNkGgZp57Vo0ieUI7_DC1Fo,1638
+musica/test/integration/test_sulfate_box_model.py,sha256=umqG0PAaCu27J3s5W_cnWJt9T_9EFox9z_JMHKNz5GI,1638
 musica/test/integration/test_tuvx.py,sha256=6MU5RrbNpX_I5VHTDUTreCGdL9c9y3voy68QurVazNI,1980
 musica/test/unit/test_parser.py,sha256=PF7GPddM4-Mbz0qjzqRvl_YSISj-VQR49MGXLfe8dDg,2667
 musica/test/unit/test_serializer.py,sha256=y6u_e2uJm9TGpn7B3x8_LobVGxIFyuKzF-WrIfP1Ewo,2527
+musica/test/unit/test_state.py,sha256=he0cEVOS7fnWRP7cOzift5abSAwEWUC-eQ6V5deTgdM,10694
 musica/test/unit/test_util_full_mechanism.py,sha256=O7nJjpIt1k-pxUNj4zBiLdSXruyhj8qfbp8Me75kPJg,25915
-musica/tools/prepare_build_environment_linux.sh,sha256=IPNqU0d9cNJQkIU4L7bTO7kqBSUSq69wwPoLE-dU0AE,1671
+musica/tools/prepare_build_environment_linux.sh,sha256=i69LuyY25KE-jFIFNuYC4_33_DGTngentBvt2Tbed9g,1017
 musica/tools/prepare_build_environment_macos.sh,sha256=Yhhd-8W6YvR79NabEqixexU6BsClNf7DH_EYYlsmeMo,41
 musica/tools/repair_wheel_gpu.sh,sha256=nQueyGNC2qWcBAicjVdAfB6JH4m_51dFOG83vVxke54,1525
 musica/tuvx.cpp,sha256=vvRi7T8TLZ-U8H7R-jrWIEmHBexXlms-0abhPGibnC8,3108
 musica/tuvx.py,sha256=6EDOULrBc2cojLgK-lNKH68YVHQyOFpBC-jkGYuaraY,6587
-musica/types.py,sha256=R7Iv3iNdp5V3sLABdsnKJm8ShEjY1LbSrjhPY-qe8mE,17029
-musica-0.12.1.dist-info/METADATA,sha256=IShAL_zZWoCFHuV_iXTdW9V9lcjy1QF_ADT_o1EGaIE,26322
-musica-0.12.1.dist-info/WHEEL,sha256=Luasc2BiJxWiaiM0E1hbP6g3pT0Vc_mN1IBvklTrOUk,106
-musica-0.12.1.dist-info/entry_points.txt,sha256=t9qRU9Ya63_yYMKJkTiVS5kCaW6dDDr0wuQ26lgXTH8,49
-musica-0.12.1.dist-info/licenses/AUTHORS.md,sha256=1ssAXR4WOMdfl5Or1raPu_2nxHbkwCpxfwJwzpF_cJM,2691
-musica-0.12.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-musica-0.12.1.dist-info/RECORD,,
+musica/types.py,sha256=zTqzaflhrwQqVMtwN_5eNxkvMis_QWAo3XwcNSpWEqs,17544
+musica-0.12.2.dist-info/METADATA,sha256=FlXiev8ZTGt1gS9XbB3IKm4X5_jaDHB8dmMnUD29alg,26345
+musica-0.12.2.dist-info/WHEEL,sha256=uMkeI2tSowhqEWYht1a0NP9-jXbaWqlBzws5ttgQOes,106
+musica-0.12.2.dist-info/entry_points.txt,sha256=t9qRU9Ya63_yYMKJkTiVS5kCaW6dDDr0wuQ26lgXTH8,49
+musica-0.12.2.dist-info/licenses/AUTHORS.md,sha256=1ssAXR4WOMdfl5Or1raPu_2nxHbkwCpxfwJwzpF_cJM,2691
+musica-0.12.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+musica-0.12.2.dist-info/RECORD,,

{musica-0.12.1.dist-info → musica-0.12.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.5
+Generator: scikit-build-core 0.11.6
 Root-Is-Purelib: false
 Tag: cp310-cp310-win_arm64