musica 0.12.2__cp39-cp39-macosx_15_0_arm64.whl → 0.13.0__cp39-cp39-macosx_15_0_arm64.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(
@@ -184,17 +192,17 @@ class State():
         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 temperatures is not None and (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 pressures is not None and (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}.")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: musica
-Version: 0.12.2
+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>
@@ -208,24 +208,24 @@ License:                                  Apache 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,90 @@
+musica-0.13.0.dist-info/RECORD,,
+musica-0.13.0.dist-info/WHEEL,sha256=qdO6WnDiDW9GigE7BL6ZZjKOjAgb6iacSCh606yDCxw,139
+musica-0.13.0.dist-info/entry_points.txt,sha256=t9qRU9Ya63_yYMKJkTiVS5kCaW6dDDr0wuQ26lgXTH8,49
+musica-0.13.0.dist-info/METADATA,sha256=TH2C-ia8-RRs9ea99MPrN5uk24JBz85UisjjvgjfccY,26422
+musica-0.13.0.dist-info/licenses/AUTHORS.md,sha256=CYIlKZmXT9ngFk6d0MiD0A_Pt8BFoID4n-29OMrKkbM,2632
+musica-0.13.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+musica/grid.py,sha256=Gl8pD7jdD1WKquEaxPoUhngXKkqj0HoTbel9IFAk_-k,3489
+musica/backend.py,sha256=Ed0vqpdem4a4sz5XOPiBdi1TPQy80qVDcmZUqI5lZvw,1040
+musica/CMakeLists.txt,sha256=jSV0QLWVBacLSPZt6a_KL85Pf9cImIwPk1YfMTYBHGo,1815
+musica/grid_map.cpp,sha256=ubfKALauWZdcA_o6_bQ_Ox3f8OK5zr1QmGNnUz9Hzd8,4132
+musica/_version.py,sha256=GUSloiYVJdj7bMD9lC6vxo5gID8BFxzSPteJ-Fdni1c,19
+musica/profile.py,sha256=8cbg1ais2J40AvqMK3OzdZEXHH3_2BHmH277_Vsvtvw,3619
+musica/constants.py,sha256=RsZrtjy8vlIcQxV9F9xzlSYFeGBQBHmhFWDPB7pRQH8,123
+musica/binding_common.cpp,sha256=lBL02ssrTPIxOb9bTRjKQdz0b6HVWbAbXNFgeM1ht5s,962
+musica/__init__.py,sha256=2xoebKVljHzrzupxtAbK3Wg05p38Lq0SFIbDjR0--bs,392
+musica/profile.cpp,sha256=UrywN_oX7C_Ma7iTOg9-wQzPSZZcpwnqb89XWOJWkz8,12482
+musica/tuvx.py,sha256=LBIikwFFvG_38wJ27nMRUJPXp9NMX89kdc23u0MWIGE,8915
+musica/cpu_binding.cpp,sha256=AZXO6EpL5HofGJ1s11fprrXYVG2U1ZrdUxe3M9j5kpw,225
+musica/types.py,sha256=KqIiFDH8_siO8rcg8lgaK5hpPi7Aa8RkN4dWt4ZqZ24,17125
+musica/gpu_binding.cpp,sha256=y9Fzgn9unoGz_Fqqlk_NBWy4jHOwTv8E82e3bq_phMg,229
+musica/tuvx.cpp,sha256=KFUihqAdc3pR1ubUzf-SeVsawYrytPfTQgguRM-vzqc,6243
+musica/_musica.cpython-39-darwin.so,sha256=S_i8McjwujD3bZVoEsbH19lLfZHaOdqjrcpPhh1QVQ4,3947952
+musica/cuda.py,sha256=rtMNdmixfEsy5J4pfKOc6LfBuFECxCKsi8J0jAvtyHo,258
+musica/cuda.cpp,sha256=qQOLKTUOB83gE-963rT579Me-NrqMUWnXDKmpTPMVFg,346
+musica/binding_common.hpp,sha256=UHkJDBl3wdbLJn51jspU0EAq-kqRAQ3GYSAkTmcCl5A,549
+musica/grid.cpp,sha256=EyUe9sXzdZClodU0eC--Hw3kFU-uFXj1Vi1VDxL9VDE,8564
+musica/grid_map.py,sha256=lmalFY2bLj4aVZ2YiJpgVs0iTSAyt5VHooqIgK2iiQg,5227
+musica/mechanism_configuration.cpp,sha256=1Wcettuy1dzujVmbmICbBiAxfKl49RBMu5jZ-PW7WE4,22430
+musica/profile_map.py,sha256=t-KwmmW37kiC9AzYvyPIoq7io9zURDbdweNG-TEP5UY,5506
+musica/profile_map.cpp,sha256=lR2rriQrZhsOfLxozTClAGP-50-lsmqo9f0GYINtvjw,4263
+musica/carma.py,sha256=fmM3K0Rm1hl2l8vGM9mIi0aKgnMhT0xsU3Xo2sP43Ug,66987
+musica/main.py,sha256=-TOa-WvGKY1aPewQ2WtzFV3myoEQI6-MYoQt2Hw5GXc,2708
+musica/carma.cpp,sha256=K3LxfhzetHeZikSZ_mg1YchmCJ8Sr7eoo55Lu6MBqts,42334
+musica/musica.cpp,sha256=T0LuAJnzaSE3VxBygautNOWnBT62gSF3Nl1NFT29-BI,8222
+musica/tools/prepare_build_environment_macos.sh,sha256=Yhhd-8W6YvR79NabEqixexU6BsClNf7DH_EYYlsmeMo,41
+musica/tools/prepare_build_environment_linux.sh,sha256=zqpqoI3hFYftBfj2MTpHz2Gg3TGVhcJ1U2z7IauSPug,986
+musica/tools/repair_wheel_gpu.sh,sha256=GJcKUJ2n9KMsj3QC5Shxt_ks9uFu2f9Than-4vVhG9U,1485
+musica/test/unit/test_parser.py,sha256=-dWfwiaGiyNrWbBC_HW0ws8bhhHhM8b-qfW0v3e7bZU,2314
+musica/test/unit/test_grid.py,sha256=ZI64kushvZzA1YonGqiu6dAX-fIkSGs_iWWRqJdrlF0,4465
+musica/test/unit/test_serializer.py,sha256=AuOl_5nhbowq_HGsy1hoRJpyOW60frS2fyb-o0PsQvA,2128
+musica/test/unit/test_profile.py,sha256=eARs7XGFgM_EsQYVEP7oK0fqAeEsM4lGjwMkLMIG_Zk,6534
+musica/test/unit/test_util_full_mechanism.py,sha256=izP631HB2j8U0JMHtd0A1zMI7GpA9sdcalf0Y1XIKkY,16353
+musica/test/unit/test_state.py,sha256=xjIn4uwLLm7NdgFBnMhUGL9HqTWtADn8gOVNVzIs6ck,10872
+musica/test/unit/test_profile_map.py,sha256=-tfY8c96EAws1WhYCAi_WFwCDd6Ml00zk_tctOKc0P0,4556
+musica/test/unit/test_grid_map.py,sha256=JlNhwuHi8PxsgIeGtZh5MTqTyz2vD7pSO5QCMQY-5W8,3520
+musica/test/integration/test_chapman.py,sha256=AQGyzh8ESiJk-jj0Vx1eUTv3OtK0vbI4DLkZI6rfx1I,3482
+musica/test/integration/test_sulfate_box_model.py,sha256=Ww6rI8_f4vgiYZ2_pt6hFu13abNaOm8i1TocISYET_s,1604
+musica/test/integration/test_carma_aluminum.py,sha256=B4xpfYEQxQIeUe5TcAXdtS4s1yD9cd6dQFZSUXY8ZLM,356
+musica/test/integration/test_carma_sulfate.py,sha256=6SWcRjKY96uJhk4ifqiwTjFmH396j3i4bUfKXoJMtNI,742
+musica/test/integration/test_tuvx.py,sha256=DuTCQ0l8krlIU95FtHvFJ6s4MsNwEYx7bxjYkYBdiUA,5629
+musica/test/integration/test_carma.py,sha256=iR6FnhSfG6seta4K-C9IPtYdia9GlH8DzyVyP3w07zc,6865
+musica/test/integration/test_analytical.py,sha256=3P9pw7mRnXi7oXn_2vdEZSBFc4U5m0eRJgKEvX3esZ8,13805
+musica/test/examples/v1/full_configuration/full_configuration.yaml,sha256=3JmeA5457k78ZLQLHE2OC9gsNXUTMC-ZYMYasYmRRkg,3952
+musica/test/examples/v1/full_configuration/full_configuration.json,sha256=jEMW84FjWI2rdqfAA7S7KSWSeTiJQw-1GCdDrFwRiRM,6149
+musica/.dylibs/libhdf5.310.5.1.dylib,sha256=83ZEgjgvsW-33kHKGygxRBjKqJd1WretY1xMvGMHCIU,3277072
+musica/.dylibs/libaec.0.1.4.dylib,sha256=_C-rTFuk7CkvfqzOFQrY4CqNXfhtaQ0ckGkUYP_F6ew,70928
+musica/.dylibs/libnetcdf.22.dylib,sha256=f5kk7mMIK1ia2Ac8IiKAkXQbq6V2g_5Em7Kkgg_m10Y,1309456
+musica/.dylibs/libgfortran.5.dylib,sha256=8ZjiwRSk2dI5q9jZPVlLtfC1bjuK3BittDQFZdSBZ_Y,2161472
+musica/.dylibs/libsz.2.0.1.dylib,sha256=jkXYTFpNzAsfqN64UMAJVGZfThfQ_rNkzku2cS3xTIg,71344
+musica/.dylibs/libhdf5_hl.310.0.6.dylib,sha256=spwH6SJg-kdpEEdrlii-NH_T7hCYy7yv2Kgbaxiec3Q,155824
+musica/.dylibs/libquadmath.0.dylib,sha256=61M_AHSknldrC3N-YdjkurQ1zU_9gYIccIrQPy9Ua_s,362768
+musica/.dylibs/libgcc_s.1.1.dylib,sha256=RROUGdpfPwsbOtunOwCfguzhxRSP0SlmF2FMERjgFBU,220288
+musica/.dylibs/libnetcdff.7.1.0.dylib,sha256=9HqSrG2wkwdrs-0-4N_5wrVOfaQ89GGbH4iT-4iBTyw,894768
+musica/.dylibs/libzstd.1.5.7.dylib,sha256=MQGj484yvsxhgqlQFGJtjbuBR0MOBVImXwujJ7rO0Hk,654000
+musica/mechanism_configuration/phase.py,sha256=_u55lBuBiJzXAhwmqzkjFB1LcjWdvficzRK6QDKfynA,1905
+musica/mechanism_configuration/species.py,sha256=5Y-4UfCOHRss-pgWW9i0VsV5fKnJ6qYSTFLduhjjYOQ,2899
+musica/mechanism_configuration/tunneling.py,sha256=CbaoW_jarD0asMzi0ZB6fWpD64Pz9pZ9YVFWkUtmm8A,4313
+musica/mechanism_configuration/taylor_series.py,sha256=Ir8EpMsSIRF4gcdIcudBJKgkCuuVOvio5EQpks-meP8,5397
+musica/mechanism_configuration/phase_species.py,sha256=OHb8kpjliSE6ROQgKOtd9Er4SW20vFYJKpstJTrfdTY,2225
+musica/mechanism_configuration/branched.py,sha256=3_Z_LdkCkf4jTePECNx0w7ZiNF9-Q2l6zA5owe2aPs4,5244
+musica/mechanism_configuration/reactions.py,sha256=rk90j-Q2R-wl6UDYKc-u9Bv4Fv2hJCULoPXdH6_GPr4,744
+musica/mechanism_configuration/__init__.py,sha256=kX2xE_xxdTuLJXfzJRrQHC4fHuoXDmATArwdYf5RzfI,668
+musica/mechanism_configuration/user_defined.py,sha256=lxG1t2Exab-kPnKkUWWBBNMJqZplT6-D67_ErvHCNlY,3669
+musica/mechanism_configuration/reaction_component.py,sha256=OugCa_q4aA_zTMCi1Ymfk6tOpgjhrYfisGfsGpBNtpQ,2002
+musica/mechanism_configuration/mechanism.py,sha256=E-H_bNI0wopKScyU01jNy5BB8NMSZ5SWAqn4x3CUQ7k,2976
+musica/mechanism_configuration/first_order_loss.py,sha256=NET7HTjUgQfrg3Ijh5dxDffkgQIEZKTUMTfmPY48z3g,3280
+musica/mechanism_configuration/utils.py,sha256=nR-ukwYsplFfnsjXtKQsXnryMPvtjkZkFQv7TjcSrnE,346
+musica/mechanism_configuration/ancillary.py,sha256=wavdS74AirouENvx8oxDMjr7_f3WWMH08vtaCHShgpQ,224
+musica/mechanism_configuration/arrhenius.py,sha256=kGjCFWsoHU6R3nqsRXl47gES5RH-iPUmjO4AtH_ESS0,5261
+musica/mechanism_configuration/troe.py,sha256=ndHbX-I5BAG54RNBWOKeJChneBv7dQyiQ8MKW0xBckA,6393
+musica/mechanism_configuration/photolysis.py,sha256=o6uyj3y9zXx3uQFftMY97MUA5yi-_jqXnESPdLmTBmc,3581
+musica/mechanism_configuration/emission.py,sha256=Bik-_c3W_im6Zqu22CRgILp2EdyITYTiMe6oDfWxyhk,2902
+musica/mechanism_configuration/surface.py,sha256=uVUkSnZ4EbQKrYHHpBCfVeJTdaYXFjvvJCGOYmp_UE8,3726
+musica/mechanism_configuration/ternary_chemical_activation.py,sha256=YZEXgKF29yMzWTWbNc-3Aa6laWuzG8fi2DmUsJ6fxPk,6906
+musica/examples/__init__.py,sha256=A4k3hoNAvcGzHlzJZ9yuy9H2n1jTSJzB6LsS7veUa_w,31
+musica/examples/carma_sulfate.py,sha256=Jmm8CLyBtNDK06Hb94jsnR-hVGxZNES3HNxrIrHIW84,8119
+musica/examples/sulfate_box_model.py,sha256=cf0-_Z8rrTSxFrFPjIwYDYZcwNdiiYnk6IZ2zPH1cTo,16671
+musica/examples/examples.py,sha256=087VoazqnByZSjMEb_Vo1KoUNOO0xRw_fQ9XY7eitNc,5736
+musica/examples/ts1_latin_hypercube.py,sha256=v6FhWxVQSZJvj55XblsIGVdq4f7CucttxDKjVlz6k1A,9623
+musica/examples/carma_aluminum.py,sha256=tYji_Gna2VoKVFxzNOymeIqRzLvGo0PRefeyqaK0N-k,3684