musica 0.12.1__cp39-cp39-win_amd64.whl → 0.13.0__cp39-cp39-win_amd64.whl

musica/tuvx.cpp

@@ -1,6 +1,7 @@
 #include "binding_common.hpp"
 
 #include <musica/tuvx/tuvx.hpp>
+#include <musica/util.hpp>
 
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
@@ -13,13 +14,30 @@ void bind_tuvx(py::module_& tuvx)
   tuvx.def("_get_tuvx_version", []() { return musica::TUVX::GetVersion(); }, "Get the version of the TUV-x instance");
 
   tuvx.def(
-      "_create_tuvx",
+      "_create_tuvx_from_string",
+      [](const char* config_string)
+      {
+        try
+        {
+          auto tuvx_instance = new musica::TUVX();
+          tuvx_instance->CreateFromConfigString(config_string);
+          return reinterpret_cast<std::uintptr_t>(tuvx_instance);
+        }
+        catch (const std::exception& e)
+        {
+          throw py::value_error("Error creating TUV-x instance from config string: " + std::string(e.what()));
+        }
+      },
+      "Create a TUV-x instance from a JSON/YAML configuration string");
+
+  tuvx.def(
+      "_create_tuvx_from_file",
       [](const char* config_path)
       {
         try
         {
           auto tuvx_instance = new musica::TUVX();
-          tuvx_instance->CreateFromConfigOnly(config_path);
+          tuvx_instance->CreateFromConfigFile(config_path);
           return reinterpret_cast<std::uintptr_t>(tuvx_instance);
         }
         catch (const std::exception& e)
@@ -28,7 +46,7 @@ void bind_tuvx(py::module_& tuvx)
               "Error creating TUV-x instance from config file: " + std::string(config_path) + " - " + e.what());
         }
       },
-      "Create a TUV-x instance from a JSON configuration file");
+      "Create a TUV-x instance from a JSON/YAML configuration file");
 
   tuvx.def(
       "_delete_tuvx",
@@ -46,48 +64,109 @@ void bind_tuvx(py::module_& tuvx)
         musica::TUVX* tuvx_instance = reinterpret_cast<musica::TUVX*>(tuvx_ptr);
 
         // Get dimensions
-        int n_photolysis = tuvx_instance->GetPhotolysisRateCount();
-
+        int n_photolysis = tuvx_instance->GetPhotolysisRateConstantCount();
         int n_heating = tuvx_instance->GetHeatingRateCount();
-
+        int n_dose = tuvx_instance->GetDoseRateCount();
         int n_layers = tuvx_instance->GetNumberOfLayers();
-
         int n_sza_steps = tuvx_instance->GetNumberOfSzaSteps();
 
         // Allocate output arrays (3D: sza_step, layer, reaction/heating_type)
         std::vector<double> photolysis_rates(n_sza_steps * n_layers * n_photolysis);
         std::vector<double> heating_rates(n_sza_steps * n_layers * n_heating);
+        std::vector<double> dose_rates(n_sza_steps * n_layers * n_dose);
 
         // Run TUV-x (everything comes from the JSON config)
-        tuvx_instance->RunFromConfig(photolysis_rates.data(), heating_rates.data());
+        tuvx_instance->RunFromConfig(photolysis_rates.data(), heating_rates.data(), dose_rates.data());
 
         // Return as numpy arrays with shape (n_sza_steps, n_layers, n_reactions/n_heating)
         py::array_t<double> py_photolysis =
             py::array_t<double>({ n_sza_steps, n_layers, n_photolysis }, photolysis_rates.data());
         py::array_t<double> py_heating = py::array_t<double>({ n_sza_steps, n_layers, n_heating }, heating_rates.data());
+        py::array_t<double> py_dose = py::array_t<double>({ n_sza_steps, n_layers, n_dose }, dose_rates.data());
 
-        return py::make_tuple(py_photolysis, py_heating);
+        return py::make_tuple(py_photolysis, py_heating, py_dose);
       },
       "Run TUV-x (all parameters come from JSON config)",
       py::arg("tuvx_instance"));
 
   tuvx.def(
-      "_get_photolysis_rate_names",
+      "_get_photolysis_rate_constants_ordering",
       [](std::uintptr_t tuvx_ptr)
       {
         musica::TUVX* tuvx_instance = reinterpret_cast<musica::TUVX*>(tuvx_ptr);
 
-        return tuvx_instance->GetPhotolysisRateNames();
+        musica::Error error;
+        musica::Mappings rate_map = tuvx_instance->GetPhotolysisRateConstantsOrdering(&error);
+        if (!musica::IsSuccess(error))
+        {
+          std::string error_message = std::string(error.message_.value_);
+          musica::DeleteError(&error);
+          throw py::value_error("Error getting photolysis rate constants ordering: " + error_message);
+        }
+        musica::DeleteError(&error);
+
+        py::dict rate_dict;
+        for (std::size_t i = 0; i < rate_map.size_; ++i)
+        {
+          py::str name(rate_map.mappings_[i].name_.value_);
+          std::size_t index = rate_map.mappings_[i].index_;
+          rate_dict[name] = index;
+        }
+        return rate_dict;
+      },
+      "Get photolysis rate names and their ordering in the output arrays");
+
+  tuvx.def(
+      "_get_heating_rates_ordering",
+      [](std::uintptr_t tuvx_ptr)
+      {
+        musica::TUVX* tuvx_instance = reinterpret_cast<musica::TUVX*>(tuvx_ptr);
+
+        musica::Error error;
+        musica::Mappings rate_map = tuvx_instance->GetHeatingRatesOrdering(&error);
+        if (!musica::IsSuccess(error))
+        {
+          std::string error_message = std::string(error.message_.value_);
+          musica::DeleteError(&error);
+          throw py::value_error("Error getting heating rates ordering: " + error_message);
+        }
+        musica::DeleteError(&error);
+
+        py::dict rate_dict;
+        for (std::size_t i = 0; i < rate_map.size_; ++i)
+        {
+          py::str name(rate_map.mappings_[i].name_.value_);
+          std::size_t index = rate_map.mappings_[i].index_;
+          rate_dict[name] = index;
+        }
+        return rate_dict;
       },
-      "Get photolysis rate names");
+      "Get heating rate names and their ordering in the output arrays");
 
   tuvx.def(
-      "_get_heating_rate_names",
+      "_get_dose_rates_ordering",
       [](std::uintptr_t tuvx_ptr)
       {
         musica::TUVX* tuvx_instance = reinterpret_cast<musica::TUVX*>(tuvx_ptr);
 
-        return tuvx_instance->GetHeatingRateNames();
+        musica::Error error;
+        musica::Mappings rate_map = tuvx_instance->GetDoseRatesOrdering(&error);
+        if (!musica::IsSuccess(error))
+        {
+          std::string error_message = std::string(error.message_.value_);
+          musica::DeleteError(&error);
+          throw py::value_error("Error getting dose rates ordering: " + error_message);
+        }
+        musica::DeleteError(&error);
+
+        py::dict rate_dict;
+        for (std::size_t i = 0; i < rate_map.size_; ++i)
+        {
+          py::str name(rate_map.mappings_[i].name_.value_);
+          std::size_t index = rate_map.mappings_[i].index_;
+          rate_dict[name] = index;
+        }
+        return rate_dict;
       },
-      "Get heating rate names");
+      "Get dose rate names and their ordering in the output arrays");
 }

musica/tuvx.py

@@ -11,7 +11,7 @@ Note: TUV-x is only available on macOS and Linux platforms.
 import os
 import json
 import tempfile
-from typing import Dict, Tuple, List
+from typing import Dict, Optional, Tuple, List
 import numpy as np
 from . import backend
 
@@ -19,40 +19,68 @@ _backend = backend.get_backend()
 
 version = _backend._tuvx._get_tuvx_version() if backend.tuvx_available() else None
 
+# Import the GridMap class from the backend
+if backend.tuvx_available():
+    from .grid_map import GridMap
+    from .profile import Profile
+    from .profile_map import ProfileMap
+else:
+    GridMap = None
+    Profile = None
+    ProfileMap = None
+
 
 class TUVX:
     """
     A Python interface to the TUV-x photolysis calculator.
 
-    This class provides a simplified interface that only requires a JSON configuration
-    file to set up and run TUV-x calculations. All parameters (solar zenith angle,
-    earth-sun distance, atmospheric profiles, etc.) are specified in the JSON config.
+    This class provides a simplified interface that only requires a JSON/YAML configuration
+    to set up and run TUV-x calculations. All parameters (solar zenith angle,
+    earth-sun distance, atmospheric profiles, etc.) are specified in the JSON/YAML configuration.
+
+    The configuration can be in a file or provided as a string. Exactly one of `config_path` or
+    `config_string` must be provided.
     """
 
-    def __init__(self, config_path: str):
+    def __init__(self,
+                 config_path: Optional[str] = None,
+                 config_string: Optional[str] = None):
         """
         Initialize a TUV-x instance from a configuration file.
 
         Args:
             config_path: Path to the JSON configuration file
+            config_string: JSON configuration as a string
 
         Raises:
             FileNotFoundError: If the configuration file doesn't exist
             ValueError: If TUV-x initialization fails or TUVX is not available
         """
         if not backend.tuvx_available():
-            raise ValueError("TUV-x backend is not available on windows.")
+            raise ValueError("TUV-x backend is not available.")
 
-        if not os.path.exists(config_path):
+        if (config_path is None and config_string is None) or \
+           (config_path is not None and config_string is not None):
+            raise ValueError(
+                "Exactly one of config_path or config_string must be provided.")
+
+        if config_path is not None and not os.path.exists(config_path):
             raise FileNotFoundError(
                 f"Configuration file not found: {config_path}")
 
-        self._tuvx_instance = _backend._tuvx._create_tuvx(config_path)
-        self._config_path = config_path
+        if config_path is not None:
+            self._tuvx_instance = _backend._tuvx._create_tuvx_from_file(config_path)
+            self._config_path = config_path
+            self._config_string = None
+        elif config_string is not None:
+            self._tuvx_instance = _backend._tuvx._create_tuvx_from_string(config_string)
+            self._config_path = None
+            self._config_string = config_string
 
         # Cache the names for efficiency
         self._photolysis_names = None
         self._heating_names = None
+        self._dose_names = None
 
     def __del__(self):
         """Clean up the TUV-x instance."""
@@ -60,32 +88,45 @@ class TUVX:
             _backend._tuvx._delete_tuvx(self._tuvx_instance)
 
     @property
-    def photolysis_rate_names(self) -> List[str]:
+    def photolysis_rate_names(self) -> dict[str, int]:
         """
         Get the names of photolysis rates.
 
         Returns:
-            List of photolysis rate names
+            Dictionary mapping photolysis rate names to their indices in the output arrays
         """
         if self._photolysis_names is None:
-            self._photolysis_names = _backend._tuvx._get_photolysis_rate_names(
+            self._photolysis_names = _backend._tuvx._get_photolysis_rate_constants_ordering(
                 self._tuvx_instance)
         return self._photolysis_names
 
     @property
-    def heating_rate_names(self) -> List[str]:
+    def heating_rate_names(self) -> dict[str, int]:
         """
         Get the names of heating rates.
 
         Returns:
-            List of heating rate names
+            Dictionary mapping heating rate names to their indices in the output arrays
         """
         if self._heating_names is None:
-            self._heating_names = _backend._tuvx._get_heating_rate_names(
+            self._heating_names = _backend._tuvx._get_heating_rates_ordering(
                 self._tuvx_instance)
         return self._heating_names
 
-    def run(self) -> Tuple[np.ndarray, np.ndarray]:
+    @property
+    def dose_rate_names(self) -> dict[str, int]:
+        """
+        Get the names of dose rates.
+
+        Returns:
+            Dictionary mapping dose rate names to their indices in the output arrays
+        """
+        if self._dose_names is None:
+            self._dose_names = _backend._tuvx._get_dose_rates_ordering(
+                self._tuvx_instance)
+        return self._dose_names
+
+    def run(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Run the TUV-x photolysis calculator.
 
@@ -94,13 +135,14 @@ class TUVX:
 
         Returns:
             Tuple of (photolysis_rate_constants, heating_rates) as numpy arrays
-            - photolysis_rate_constants: Shape (n_layers, n_reactions) [s^-1]
-            - heating_rates: Shape (n_layers, n_heating_rates) [K s^-1]
+            - photolysis_rate_constants: Shape (n_sza, n_layers, n_reactions) [s^-1]
+            - heating_rates: Shape (n_sza, n_layers, n_heating_rates) [K s^-1]
+            - dose_rates: Shape (n_sza, n_layers, n_dose_rates) [W m^-2]
         """
-        photolysis_rates, heating_rates = _backend._tuvx._run_tuvx(
+        photolysis_rates, heating_rates, dose_rates = _backend._tuvx._run_tuvx(
             self._tuvx_instance)
 
-        return photolysis_rates, heating_rates
+        return photolysis_rates, heating_rates, dose_rates
 
     def get_photolysis_rate_constant(
         self,
@@ -127,7 +169,7 @@ class TUVX:
                 f"Available reactions: {names}"
             )
 
-        reaction_index = names.index(reaction_name)
+        reaction_index = names[reaction_name]
         return photolysis_rates[:, reaction_index]
 
     def get_heating_rate(
@@ -155,9 +197,37 @@ class TUVX:
                 f"Available rates: {names}"
             )
 
-        rate_index = names.index(rate_name)
+        rate_index = names[rate_name]
         return heating_rates[:, rate_index]
 
+    def get_dose_rate(
+        self,
+        rate_name: str,
+        dose_rates: np.ndarray
+    ) -> np.ndarray:
+        """
+        Extract dose rates for a specific rate type.
+
+        Args:
+            rate_name: Name of the dose rate
+            dose_rates: Output from run() method
+
+        Returns:
+            1D array of dose rates for all layers [W m^-2]
+
+        Raises:
+            KeyError: If rate_name is not found
+        """
+        names = self.dose_rate_names
+        if rate_name not in names:
+            raise KeyError(
+                f"Dose rate '{rate_name}' not found. "
+                f"Available rates: {names}"
+            )
+
+        rate_index = names[rate_name]
+        return dose_rates[:, rate_index]
+
     @staticmethod
     def create_config_from_dict(config_dict: Dict) -> 'TUVX':
         """

musica/types.py

@@ -8,6 +8,7 @@ from .constants import GAS_CONSTANT
 from typing import Optional, Dict, List, Union, Tuple, TYPE_CHECKING, Any
 from os import PathLike
 import math
+import numpy as np
 
 # Import backend symbols from the backend module
 from . import backend
@@ -35,6 +36,13 @@ else:
 FilePath = Union[str, "PathLike[str]"]
 
 
+def is_scalar_number(x):
+    return (
+        isinstance(x, (int, float, np.number))
+        and not isinstance(x, bool)
+    )
+
+
 class Conditions(_Conditions):
     """
     Conditions class for the MICM solver. If air density is not provided,
@@ -119,7 +127,7 @@ class State():
             if name not in self.__species_ordering:
                 raise ValueError(f"Species {name} not found in the mechanism.")
             i_species = self.__species_ordering[name]
-            if isinstance(value, float) or isinstance(value, int):
+            if is_scalar_number(value):
                 value = [value]
             if len(value) != self.__number_of_grid_cells:
                 raise ValueError(
@@ -150,7 +158,7 @@ class State():
                 raise ValueError(
                     f"User-defined rate parameter {name} not found in the mechanism.")
             i_param = self.__user_defined_rate_parameters_ordering[name]
-            if isinstance(value, float) or isinstance(value, int):
+            if is_scalar_number(value):
                 value = [value]
             if len(value) != self.__number_of_grid_cells:
                 raise ValueError(
@@ -165,43 +173,44 @@ 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 is_scalar_number(temperatures):
             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 is_scalar_number(pressures):
             if self.__number_of_grid_cells > 1:
                 raise ValueError(
                     f"pressures must be a list of length {self.__number_of_grid_cells}.")
             pressures = [pressures]
-        if air_densities is not None and (isinstance(air_densities, float) or isinstance(air_densities, int)):
+        if air_densities is not None and is_scalar_number(air_densities):
             if self.__number_of_grid_cells > 1:
                 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 +219,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 +343,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.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: musica
-Version: 0.12.1
+Version: 0.13.0
 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,24 +207,25 @@ License:                                  Apache License
             limitations under the License.
          
 Project-URL: homepage, https://wiki.ucar.edu/display/MUSICA/MUSICA+Home
+Requires-Python: >=3.9
+Requires-Dist: numpy>=2.0.0
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: xarray>=2022.3.0
 Requires-Dist: ussa1976>=v0.3.4
+Requires-Dist: xarray>=2022.3.0
 Provides-Extra: test
-Requires-Dist: numpy; extra == "test"
-Requires-Dist: pytest; extra == "test"
-Requires-Dist: matplotlib; extra == "test"
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: matplotlib>=3.6.0; extra == "test"
 Provides-Extra: gpu
-Requires-Dist: nvidia-cublas-cu12; extra == "gpu"
-Requires-Dist: nvidia-cuda-runtime-cu12; extra == "gpu"
+Requires-Dist: nvidia-cublas-cu12>=12.6.4.1; extra == "gpu"
+Requires-Dist: nvidia-cuda-runtime-cu12>=12.6.68; extra == "gpu"
 Provides-Extra: tutorial
-Requires-Dist: pandas; extra == "tutorial"
-Requires-Dist: matplotlib; extra == "tutorial"
-Requires-Dist: numpy; extra == "tutorial"
-Requires-Dist: scipy; extra == "tutorial"
-Requires-Dist: seaborn; extra == "tutorial"
-Requires-Dist: dask[distributed]; extra == "tutorial"
-Requires-Dist: dask-jobqueue; extra == "tutorial"
+Requires-Dist: dask-jobqueue>=0.8.0; extra == "tutorial"
+Requires-Dist: dask[distributed]>=2022.3.0; extra == "tutorial"
+Requires-Dist: matplotlib>=3.6.0; extra == "tutorial"
+Requires-Dist: numpy>=2.0.0; extra == "tutorial"
+Requires-Dist: pandas>=2.2.0; extra == "tutorial"
+Requires-Dist: scipy>=1.10.0; extra == "tutorial"
+Requires-Dist: seaborn>=0.12.0; extra == "tutorial"
 Description-Content-Type: text/markdown
 
 # MUSICA

musica-0.13.0.dist-info/RECORD

@@ -0,0 +1,80 @@
+musica/__init__.py,sha256=pSZ-H2IJ4EEYIbQDygjGwjhGySXdeifB1DzQBMJzz2g,403
+musica/_musica.cp39-win_amd64.pyd,sha256=h0E5BtSjv09JNQQDQeggvMkGJzrN9Z0Zd6mKVt6G29o,1820160
+musica/_version.py,sha256=c4IRHcVoNZR6rdRjBv_PU37jj0p2ePPRz7W2q-uSro4,20
+musica/backend.py,sha256=Fw3-HECqsifQmvRonDTGeEZqS-KXYD09BCwBue_HwfM,1081
+musica/binding_common.cpp,sha256=gAmVhVmnLUWMNQXDTjbZPwWOudJl0qObbR2v4MXG7vE,991
+musica/binding_common.hpp,sha256=GMPcEBYI4NkVFeKAQ_EJCJsQrWPBDhzOORvQRmjC_1s,572
+musica/carma.cpp,sha256=v6f2MF1PUGHR46vVZ544o6bEZjCTI2rWvtgL8M0oSns,43244
+musica/carma.py,sha256=FNd4pWJQJ8VJoo2LSl2aXUVSfLZFgABTSKqtTE-Cgv4,68716
+musica/CMakeLists.txt,sha256=FYgmuRSgrsO1dSlwNQy4Wa2FRls2DGE6LAAznDUrxkQ,1887
+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=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=LU1kJYtCZNV_4Mi8kJl2V7YQwQuP1dv8Ba4-2vhPFbE,17110
+musica/examples/ts1_latin_hypercube.py,sha256=tLH9swPT4pvDnd7a86-xnt8PqXl4Y7bAXowsA0J7PV8,9868
+musica/gpu_binding.cpp,sha256=X0qISrKYz7Ldjn5UnqNw8oLzOY4VgyF3fUUszm-QSJI,240
+musica/grid.cpp,sha256=Zw32VIrFCzLjYaJhS0BS5QZe9gtJ1U1yshOTRoHSdKg,8769
+musica/grid.py,sha256=MFO5k6uxzDGxTjmwXor1zlTCAqzfe4OtmNIC6RjIgII,3587
+musica/grid_map.cpp,sha256=iV7AQk85dQOCveQwy3rsIKgfyTZzQiz20Gg75BnEHtY,4249
+musica/grid_map.py,sha256=rQzHQOpNiUP5a73OxAgn9mUwRKRrvNson8ojTWtNN-U,5394
+musica/main.py,sha256=gVCfeh44VL4EH7eFRR2wU_I_kANB94furojDi-0LhoE,2797
+musica/mechanism_configuration/__init__.py,sha256=vw3OCq138IgMn-r9tGwL6d-cn7QBsPKmOtqzrmTdNI0,686
+musica/mechanism_configuration/ancillary.py,sha256=lBYSta0nWXbp59gPXkIsr920ysY_oIX3lFgGzEO6mrM,230
+musica/mechanism_configuration/arrhenius.py,sha256=drJyt4aAsjvixMtXCXliZlIv3g2f9usDi208XvBG1Sw,5410
+musica/mechanism_configuration/branched.py,sha256=6LSFRAkcIPWnUjU4FqUYZaYzdcSfTEz2moZQJW3NZRg,5384
+musica/mechanism_configuration/emission.py,sha256=M9cCYgaPrCto5y16UWXfcjt_23-AN41D14vFrgLnwT4,2984
+musica/mechanism_configuration/first_order_loss.py,sha256=nIk-nTrCtkmUjhATXbQ_AsTh0IUtRz73YAicS0bgHSE,3370
+musica/mechanism_configuration/mechanism.py,sha256=w4not9yIvOzS0CNGPFKAvU3vgZpVoJ_mzkLa4mnsphc,3069
+musica/mechanism_configuration/phase.py,sha256=-znETgYbkS3wZnW05BC0wqgDQJI2BOKNQ-F5ncrfB7s,1963
+musica/mechanism_configuration/phase_species.py,sha256=O1_eG8xN4BrABPLdeMWPjozlEC08X0UGJA0Pay0Pxyc,2283
+musica/mechanism_configuration/photolysis.py,sha256=KPs1ts9pUj9XJJd99GAMX4vdxvfcl6Dcn6x1MKKO3Fo,3679
+musica/mechanism_configuration/reaction_component.py,sha256=gS91SwThchLBT-ukz9NkhDSZFqHWBTAL-vvJTZvGiG0,2056
+musica/mechanism_configuration/reactions.py,sha256=x-Qv648H3saSnHNAWAX1jolSNqa85MEXLeMAY5FSFSc,776
+musica/mechanism_configuration/species.py,sha256=NCL6XYEEnBD8FARWFWnWLqpsfpcFVrzbGT7eUzND5Jo,2964
+musica/mechanism_configuration/surface.py,sha256=ViaAjGLhdAICiaSNxaI_gHWBUHBwLSmq7gE2bDRvWO8,3824
+musica/mechanism_configuration/taylor_series.py,sha256=ooDooCuhYy7VRxursVbAOu_YNckHiNyZoDGqw-Av3ew,5533
+musica/mechanism_configuration/ternary_chemical_activation.py,sha256=qRt_5yWo1N_rFQ5BHTY8aGcSDWlpDhlkMmLAvWvuRk0,7066
+musica/mechanism_configuration/troe.py,sha256=HaAB-8i0Hk9XNUulkUElTkxnkXhjjg6YM-Tn1ITVWsg,6553
+musica/mechanism_configuration/tunneling.py,sha256=Nbve_L2pZ9_SMp5_qzPEKTPsgib1wb2cBJBLvvzPfIE,4439
+musica/mechanism_configuration/user_defined.py,sha256=Bcv9JQ5R--34xQpfuJOJc9-91RUhGyBueFx3tUlxxgY,3768
+musica/mechanism_configuration/utils.py,sha256=dhMFrydNchhdRrfeJw35oJB8Y5oQJa6p65Z7I127P-8,356
+musica/mechanism_configuration.cpp,sha256=62ws5qLkUPOnDapSNQ0Z9ZkZ8a4N-eutBuR1L-VymCY,22929
+musica/musica.cpp,sha256=eVHiG898fg39n62hOkfxH1xld4ejAXgSepJTFPJEuDM,8420
+musica/profile.cpp,sha256=ZMdtMKEAjZE5c_ds1WSkGPsYqsJIH0kQw_IO9m4abcc,12775
+musica/profile.py,sha256=kAYPmxKkwTwTcAlaU2Ip3ToDxFzbFguODHagPgkJh5A,3712
+musica/profile_map.cpp,sha256=oxj8TTLSm-s5K7B3DUhUvXN1YOEpbFoQbL8Y_2gEY7Y,4379
+musica/profile_map.py,sha256=2Zx_fMCZx1vEwTGwpS_ZhXzO6Hr8KiBR_yNj6RNXlxA,5673
+musica/test/examples/v1/full_configuration/full_configuration.json,sha256=v9ircJPE8QxaIxsBJs1-GM42tfTMfJdWVChj1oZGbM0,6472
+musica/test/examples/v1/full_configuration/full_configuration.yaml,sha256=hdZpOm9y6u79j_mszEFiy8u7Put9k_6eZ36-LGIlkZU,4147
+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=F7_8xwZnKjSxgnZKdZR1tDwzwfVUiD7ZT1b_9cseE3M,368
+musica/test/integration/test_carma_sulfate.py,sha256=OWQDLQNao5vU2FAMpWDVqs8xrFhpxvRfhx8HrP6GTCs,759
+musica/test/integration/test_chapman.py,sha256=igtiyoiT1OjvT0bA7lvGxVzBlh0ElNNrWVEr5s-9GvQ,3621
+musica/test/integration/test_sulfate_box_model.py,sha256=umqG0PAaCu27J3s5W_cnWJt9T_9EFox9z_JMHKNz5GI,1638
+musica/test/integration/test_tuvx.py,sha256=fOaOzlupFOJJGlbhZfH_-_Wdh6DTSx_rVXBcGYxOW2M,5748
+musica/test/unit/test_grid.py,sha256=sTUG_6uF_8F3PJHNnhaNf46LiAeBkI-yezGW3CYVK88,4602
+musica/test/unit/test_grid_map.py,sha256=cAUqCFL1nmXmh_RWstTjj8HgaIDkyu0ESR1DdMErgVk,3646
+musica/test/unit/test_parser.py,sha256=-HUQXfsr3auMFv5f9SvAUskkcUpPG32b2l3XYU7aHJ0,2378
+musica/test/unit/test_profile.py,sha256=CKRAnAN1aNBz3zGVZgQtRNeFccNvjHLq9bIb7yDDKbg,6703
+musica/test/unit/test_profile_map.py,sha256=uPADG32XXaa8x23TgpeB_H-5CivLfl9v_jTkP9xeudk,4693
+musica/test/unit/test_serializer.py,sha256=gvRQDbn3MadHqZvlUYcrtFWMMcH7LGZ4VnKq477bvVg,2198
+musica/test/unit/test_state.py,sha256=Mlo5UFhj4fvOu2sqB1E0xPnhLWs9ocJhnPTnR_PZojU,11210
+musica/test/unit/test_util_full_mechanism.py,sha256=3zvr8TNc2y7KMU2wYQzabcfsGs95sfppPpjCKnRqTic,16831
+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=2JHst374H8lIKLTptmEogY0YqMhfwKyponh3FtL54u4,6415
+musica/tuvx.py,sha256=kAa3tGMoTWD1Gvay-n-ST2k29BqtaMnER9G9PzuFcZc,9184
+musica/types.py,sha256=9OErDNWwkoNU2rkB8Q4Vo8zbDjO0vGkBK_T984LiX48,17540
+musica-0.13.0.dist-info/METADATA,sha256=TH2C-ia8-RRs9ea99MPrN5uk24JBz85UisjjvgjfccY,26422
+musica-0.13.0.dist-info/WHEEL,sha256=9tsL4JT94eZPTkcS3bNng2riasYJMxXndrO9CxUfJHs,104
+musica-0.13.0.dist-info/entry_points.txt,sha256=t9qRU9Ya63_yYMKJkTiVS5kCaW6dDDr0wuQ26lgXTH8,49
+musica-0.13.0.dist-info/licenses/AUTHORS.md,sha256=1ssAXR4WOMdfl5Or1raPu_2nxHbkwCpxfwJwzpF_cJM,2691
+musica-0.13.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+musica-0.13.0.dist-info/RECORD,,

{musica-0.12.1.dist-info → musica-0.13.0.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: cp39-cp39-win_amd64