musica 0.12.2__cp39-cp39-macosx_15_0_arm64.whl → 0.13.0__cp39-cp39-macosx_15_0_arm64.whl

musica/mechanism_configuration/henrys_law.py

@@ -1,44 +0,0 @@
-from typing import Optional, Any, Dict, Union, Tuple
-from .. import backend
-from .phase import Phase
-from .species import Species
-from .utils import _add_other_properties
-
-_backend = backend.get_backend()
-_HenrysLaw = _backend._mechanism_configuration._HenrysLaw
-_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
-
-
-class HenrysLaw(_HenrysLaw):
-    """
-    A class representing a Henry's law reaction rate constant.
-
-    Attributes:
-        name (str): The name of the Henry's law reaction rate constant.
-        other_properties (Dict[str, Any]): A dictionary of other properties of the Henry's law reaction rate constant.
-    """
-
-    def __init__(
-        self,
-        name: Optional[str] = None,
-        other_properties: Optional[Dict[str, Any]] = None,
-    ):
-        """
-        Initializes the HenrysLaw object with the given parameters.
-
-        Args:
-            name (str): The name of the Henry's law reaction rate constant.
-            other_properties (Dict[str, Any]): A dictionary of other properties of the Henry's law reaction rate constant.
-        """
-        super().__init__()
-        self.name = name if name is not None else self.name
-        self.other_properties = other_properties if other_properties is not None else self.other_properties
-
-    @staticmethod
-    def serialize(instance) -> Dict:
-        serialize_dict = {
-            "type": "HL_PHASE_TRANSFER",
-            "name": instance.name,
-        }
-        _add_other_properties(serialize_dict, instance.other_properties)
-        return serialize_dict

musica/mechanism_configuration/mechanism_configuration.py

@@ -1,234 +0,0 @@
-# Copyright (C) 2025 University Corporation for Atmospheric Research
-# SPDX-License-Identifier: Apache-2.0
-#
-# This file is part of the musica Python package.
-# For more information, see the LICENSE file in the top-level directory of this distribution.
-from .reactions import Reactions, ReactionType
-from .user_defined import UserDefined, _UserDefined
-from .simpol_phase_transfer import SimpolPhaseTransfer, _SimpolPhaseTransfer
-from .henrys_law import HenrysLaw, _HenrysLaw
-from .wet_deposition import WetDeposition, _WetDeposition
-from .aqueous_equilibrium import AqueousEquilibrium, _AqueousEquilibrium
-from .first_order_loss import FirstOrderLoss, _FirstOrderLoss
-from .emission import Emission, _Emission
-from .condensed_phase_photolysis import CondensedPhasePhotolysis, _CondensedPhasePhotolysis
-from .photolysis import Photolysis, _Photolysis
-from .surface import Surface, _Surface
-from .tunneling import Tunneling, _Tunneling
-from .branched import Branched, _Branched
-from .troe import Troe, _Troe
-from .ternary_chemical_activation import TernaryChemicalActivation, _TernaryChemicalActivation
-from .condensed_phase_arrhenius import CondensedPhaseArrhenius, _CondensedPhaseArrhenius
-from .arrhenius import Arrhenius, _Arrhenius
-from .phase import Phase
-from .species import Species
-import os
-import json
-import yaml
-from typing import Optional, Any, Dict, List
-from .. import backend
-
-_backend = backend.get_backend()
-_mc = _backend._mechanism_configuration
-_Mechanism = _mc._Mechanism
-_Version = _mc._Version
-_Parser = _mc._Parser
-
-
-class Version(_Version):
-    """
-    A class representing the version of the mechanism.
-    """
-
-
-class Mechanism(_Mechanism):
-    """
-    A class representing a chemical mechanism.
-
-    Attributes:
-        name (str): The name of the mechanism.
-        reactions (List[Reaction]): A list of reactions in the mechanism.
-        species (List[Species]): A list of species in the mechanism.
-        phases (List[Phase]): A list of phases in the mechanism.
-        version (Version): The version of the mechanism.
-    """
-
-    def __init__(
-        self,
-        name: Optional[str] = None,
-        reactions: Optional[List[Any]] = None,
-        species: Optional[List[Species]] = None,
-        phases: Optional[List[Phase]] = None,
-        version: Optional[Version] = None,
-    ):
-        """
-        Initializes the Mechanism object with the given parameters.
-
-        Args:
-            name (str): The name of the mechanism.
-            reactions (List[]): A list of reactions in the mechanism.
-            species (List[Species]): A list of species in the mechanism.
-            phases (List[Phase]): A list of phases in the mechanism.
-            version (Version): The version of the mechanism.
-        """
-        super().__init__()
-        self.name = name
-        self.species = species if species is not None else []
-        self.phases = phases if phases is not None else []
-        self.reactions = Reactions(
-            reactions=reactions if reactions is not None else [])
-        self.version = version if version is not None else Version()
-
-    def to_dict(self) -> Dict:
-        species_list = []
-        for species in self.species:
-            species_list.append(Species.serialize(species))
-
-        phases_list = []
-        for phase in self.phases:
-            phases_list.append(Phase.serialize(phase))
-
-        reactions_list = []
-        for reaction in self.reactions:
-            if isinstance(reaction, _Arrhenius):
-                # Handle C++ _Arrhenius objects with static serialize call
-                reactions_list.append(Arrhenius.serialize_static(reaction))
-            elif isinstance(reaction, Arrhenius):
-                # Handle Python Arrhenius objects with instance serialize call
-                reactions_list.append(reaction.serialize())
-            elif isinstance(reaction, _Branched):
-                # Handle C++ _Branched objects with static serialize call
-                reactions_list.append(Branched.serialize_static(reaction))
-            elif isinstance(reaction, Branched):
-                # Handle Python Branched objects with instance serialize call
-                reactions_list.append(reaction.serialize())
-            elif isinstance(reaction, (_CondensedPhaseArrhenius, CondensedPhaseArrhenius)):
-                reactions_list.append(
-                    CondensedPhaseArrhenius.serialize_static(reaction))
-            elif isinstance(reaction, (_CondensedPhasePhotolysis, CondensedPhasePhotolysis)):
-                reactions_list.append(
-                    CondensedPhasePhotolysis.serialize(reaction))
-            elif isinstance(reaction, (_Emission, Emission)):
-                reactions_list.append(Emission.serialize(reaction))
-            elif isinstance(reaction, _FirstOrderLoss):
-                # Handle C++ _FirstOrderLoss objects with static serialize call
-                reactions_list.append(FirstOrderLoss.serialize_static(reaction))
-            elif isinstance(reaction, FirstOrderLoss):
-                # Handle Python FirstOrderLoss objects with instance serialize call
-                reactions_list.append(reaction.serialize())
-            elif isinstance(reaction, _SimpolPhaseTransfer):
-                # Handle C++ _SimpolPhaseTransfer objects with static serialize call
-                reactions_list.append(
-                    SimpolPhaseTransfer.serialize_static(reaction))
-            elif isinstance(reaction, SimpolPhaseTransfer):
-                # Handle Python SimpolPhaseTransfer objects with instance serialize call
-                reactions_list.append(reaction.serialize())
-            elif isinstance(reaction, _AqueousEquilibrium):
-                # Handle C++ _AqueousEquilibrium objects with static serialize call
-                reactions_list.append(
-                    AqueousEquilibrium.serialize_static(reaction))
-            elif isinstance(reaction, AqueousEquilibrium):
-                # Handle Python AqueousEquilibrium objects with instance serialize call
-                reactions_list.append(reaction.serialize())
-            elif isinstance(reaction, (_WetDeposition, WetDeposition)):
-                reactions_list.append(WetDeposition.serialize(reaction))
-            elif isinstance(reaction, (_HenrysLaw, HenrysLaw)):
-                reactions_list.append(HenrysLaw.serialize(reaction))
-            elif isinstance(reaction, (_Photolysis, Photolysis)):
-                reactions_list.append(Photolysis.serialize(reaction))
-            elif isinstance(reaction, (_Surface, Surface)):
-                reactions_list.append(Surface.serialize(reaction))
-            elif isinstance(reaction, _Troe):
-                # Handle C++ _Troe objects with static serialize call
-                reactions_list.append(Troe.serialize_static(reaction))
-            elif isinstance(reaction, Troe):
-                # Handle Python Troe objects with instance serialize call
-                reactions_list.append(reaction.serialize())
-            elif isinstance(reaction, _TernaryChemicalActivation):
-                # Handle C++ _TernaryChemicalActivation objects with static serialize call
-                reactions_list.append(TernaryChemicalActivation.serialize_static(reaction))
-            elif isinstance(reaction, TernaryChemicalActivation):
-                # Handle Python TernaryChemicalActivation objects with instance serialize call
-                reactions_list.append(reaction.serialize())
-            elif isinstance(reaction, _Tunneling):
-                # Handle C++ _Tunneling objects with static serialize call
-                reactions_list.append(Tunneling.serialize_static(reaction))
-            elif isinstance(reaction, Tunneling):
-                # Handle Python Tunneling objects with instance serialize call
-                reactions_list.append(reaction.serialize())
-            elif isinstance(reaction, (_UserDefined, UserDefined)):
-                reactions_list.append(UserDefined.serialize(reaction))
-            else:
-                raise TypeError(
-                    f'Reaction type {type(reaction)} is not supported for export.')
-
-        return {
-            "name": self.name,
-            "reactions": reactions_list,
-            "species": species_list,
-            "phases": phases_list,
-            "version": self.version.to_string(),
-        }
-
-    def export(self, file_path: str) -> None:
-        MechanismSerializer.serialize(self, file_path)
-
-
-class Parser(_Parser):
-    """
-    A class for parsing a chemical mechanism.
-    """
-
-
-class MechanismSerializer():
-    """
-    A class for exporting a chemical mechanism.
-    """
-
-    @staticmethod
-    def _convert_cpp_mechanism_to_python(cpp_mechanism: Any) -> Mechanism:
-        """
-        Convert a C++ _Mechanism object to a Python Mechanism object.
-        """
-        reactions_list = []
-        for reaction in cpp_mechanism.reactions:
-            reactions_list.append(reaction)
-
-        python_mechanism = Mechanism(
-            name=cpp_mechanism.name,
-            reactions=reactions_list,
-            species=list(cpp_mechanism.species),
-            phases=list(cpp_mechanism.phases),
-            version=Version() if cpp_mechanism.version is None else cpp_mechanism.version
-        )
-
-        return python_mechanism
-
-    @staticmethod
-    def serialize(mechanism: Mechanism, file_path: str = "./mechanism.json") -> None:
-        if not isinstance(mechanism, (Mechanism, _Mechanism)):
-            raise TypeError(f"Object {mechanism} is not of type Mechanism.")
-
-        directory, file = os.path.split(file_path)
-        if directory:
-            os.makedirs(directory, exist_ok=True)
-
-        if isinstance(mechanism, _Mechanism) and not isinstance(mechanism, Mechanism):
-            mechanism = MechanismSerializer._convert_cpp_mechanism_to_python(
-                mechanism)
-
-        # Now we can use the standard to_dict method
-        dictionary = mechanism.to_dict()
-
-        _, file_ext = os.path.splitext(file)
-        file_ext = file_ext.lower()
-        if file_ext in ['.yaml', '.yml']:
-            with open(file_path, 'w') as file:
-                yaml.dump(dictionary, file)
-        elif '.json' == file_ext:
-            json_str = json.dumps(dictionary, indent=4)
-            with open(file_path, 'w') as file:
-                file.write(json_str)
-        else:
-            raise ValueError(
-                'Allowable write formats are .json, .yaml, and .yml')

musica/mechanism_configuration/simpol_phase_transfer.py

@@ -1,217 +0,0 @@
-from .utils import _add_other_properties
-from .species import Species
-from .phase import Phase
-from typing import Optional, Any, Dict, List, Union, Tuple
-from .. import backend
-
-_backend = backend.get_backend()
-_SimpolPhaseTransfer = _backend._mechanism_configuration._SimpolPhaseTransfer
-_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
-ReactionType = _backend._mechanism_configuration._ReactionType
-
-
-class SimpolPhaseTransfer:
-    """
-    A class representing a simplified phase transfer reaction rate constant.
-
-    Attributes:
-        name (str): The name of the simplified phase transfer reaction rate constant.
-        gas_phase (Phase): The gas phase in which the reaction occurs.
-        gas_phase_species (Union[Species, Tuple[float, Species]]): The gas phase species involved in the reaction.
-        condensed_phase (Phase): The condensed phase in which the reaction occurs.
-        condensed_phase_species (Union[Species, Tuple[float, Species]]): The condensed phase species involved in the reaction.
-        B (List[float]): The B parameters [unitless].
-        other_properties (Dict[str, Any]): A dictionary of other properties of the simplified phase transfer reaction rate constant.
-    """
-
-    def __init__(
-        self,
-        name: Optional[str] = None,
-        gas_phase: Optional[Phase] = None,
-        gas_phase_species: Optional[Union[Species,
-                                          Tuple[float, Species]]] = None,
-        condensed_phase: Optional[Phase] = None,
-        condensed_phase_species: Optional[Union[Species,
-                                                Tuple[float, Species]]] = None,
-        B: Optional[List[float]] = None,
-        other_properties: Optional[Dict[str, Any]] = None,
-    ):
-        """
-        Initializes the SimpolPhaseTransfer object with the given parameters.
-
-        Args:
-            name (str): The name of the simplified phase transfer reaction rate constant.
-            gas_phase (Phase): The gas phase in which the reaction occurs.
-            gas_phase_species (Union[Species, Tuple[float, Species]]): The gas phase species involved in the reaction.
-            condensed_phase (Phase): The condensed phase in which the reaction occurs.
-            condensed_phase_species (Union[Species, Tuple[float, Species]]): The condensed phase species involved in the reaction.
-            B (List[float]): The B parameters [unitless].
-            other_properties (Dict[str, Any]): A dictionary of other properties of the simplified phase transfer reaction rate constant.
-        """
-        # Create the internal C++ instance
-        self._instance = _SimpolPhaseTransfer()
-
-        # Set all parameters
-        if name is not None:
-            self.name = name
-        if gas_phase is not None:
-            self.gas_phase = gas_phase
-        if gas_phase_species is not None:
-            self.gas_phase_species = gas_phase_species
-        if condensed_phase is not None:
-            self.condensed_phase = condensed_phase
-        if condensed_phase_species is not None:
-            self.condensed_phase_species = condensed_phase_species
-        if B is not None:
-            self.B = B
-        if other_properties is not None:
-            self.other_properties = other_properties
-
-    # Property delegation to self._instance
-    @property
-    def name(self) -> str:
-        """Get the name of the simplified phase transfer reaction rate constant."""
-        return self._instance.name
-
-    @name.setter
-    def name(self, value: str):
-        """Set the name of the simplified phase transfer reaction rate constant."""
-        self._instance.name = value
-
-    @property
-    def gas_phase(self) -> str:
-        """Get the gas phase name."""
-        return self._instance.gas_phase
-
-    @gas_phase.setter
-    def gas_phase(self, value: Union[Phase, str]):
-        """Set the gas phase."""
-        if isinstance(value, Phase):
-            self._instance.gas_phase = value.name
-        elif isinstance(value, str):
-            self._instance.gas_phase = value
-        else:
-            raise ValueError(f"Invalid gas_phase type: {type(value)}")
-
-    @property
-    def gas_phase_species(self) -> Union[Species, Tuple[float, Species]]:
-        """Get the gas phase species as Python object."""
-        rc = self._instance.gas_phase_species
-        if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
-            # Create a tuple with coefficient and species
-            species = Species(name=rc.species_name)
-            return (rc.coefficient, species)
-        else:
-            # Just the species
-            return Species(name=rc.species_name)
-
-    @gas_phase_species.setter
-    def gas_phase_species(self, value: Union[Species, Tuple[float, Species]]):
-        """Set the gas phase species, converting from Python to C++ object."""
-        if isinstance(value, Species):
-            self._instance.gas_phase_species = _ReactionComponent(value.name)
-        elif isinstance(value, tuple) and len(value) == 2:
-            coefficient, species = value
-            self._instance.gas_phase_species = _ReactionComponent(species.name, coefficient)
-        else:
-            raise ValueError(f"Invalid gas_phase_species format: {value}")
-
-    @property
-    def condensed_phase(self) -> str:
-        """Get the condensed phase name."""
-        return self._instance.condensed_phase
-
-    @condensed_phase.setter
-    def condensed_phase(self, value: Union[Phase, str]):
-        """Set the condensed phase."""
-        if isinstance(value, Phase):
-            self._instance.condensed_phase = value.name
-        elif isinstance(value, str):
-            self._instance.condensed_phase = value
-        else:
-            raise ValueError(f"Invalid condensed_phase type: {type(value)}")
-
-    @property
-    def condensed_phase_species(self) -> Union[Species, Tuple[float, Species]]:
-        """Get the condensed phase species as Python object."""
-        rc = self._instance.condensed_phase_species
-        if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
-            # Create a tuple with coefficient and species
-            species = Species(name=rc.species_name)
-            return (rc.coefficient, species)
-        else:
-            # Just the species
-            return Species(name=rc.species_name)
-
-    @condensed_phase_species.setter
-    def condensed_phase_species(self, value: Union[Species, Tuple[float, Species]]):
-        """Set the condensed phase species, converting from Python to C++ object."""
-        if isinstance(value, Species):
-            self._instance.condensed_phase_species = _ReactionComponent(value.name)
-        elif isinstance(value, tuple) and len(value) == 2:
-            coefficient, species = value
-            self._instance.condensed_phase_species = _ReactionComponent(species.name, coefficient)
-        else:
-            raise ValueError(f"Invalid condensed_phase_species format: {value}")
-
-    @property
-    def B(self) -> List[float]:
-        """Get the B parameters."""
-        return self._instance.B
-
-    @B.setter
-    def B(self, value: List[float]):
-        """Set the B parameters with validation."""
-        if not isinstance(value, list) or len(value) != 4:
-            raise ValueError("B must be a list of 4 elements.")
-        self._instance.B = value
-
-    @property
-    def other_properties(self) -> Dict[str, Any]:
-        """Get the other properties."""
-        return self._instance.other_properties
-
-    @other_properties.setter
-    def other_properties(self, value: Dict[str, Any]):
-        """Set the other properties."""
-        self._instance.other_properties = value
-
-    @property
-    def type(self):
-        """Get the reaction type."""
-        return ReactionType.SimpolPhaseTransfer
-
-    def serialize(self) -> Dict:
-        """
-        Serialize the SimpolPhaseTransfer object to a dictionary using only Python-visible data.
-
-        Returns:
-            Dict: A dictionary representation of the SimpolPhaseTransfer object.
-        """
-        serialize_dict = {
-            "type": "SIMPOL_PHASE_TRANSFER",
-            "name": self._instance.name,
-            "gas phase": self._instance.gas_phase,
-            "gas-phase species": self._instance.gas_phase_species.species_name,
-            "condensed phase": self._instance.condensed_phase,
-            "condensed-phase species": self._instance.condensed_phase_species.species_name,
-            "B": self._instance.B,
-        }
-        _add_other_properties(serialize_dict, self.other_properties)
-        return serialize_dict
-
-    @staticmethod
-    def serialize_static(instance) -> Dict:
-        """
-        Static serialize method for compatibility with C++ _SimpolPhaseTransfer objects.
-
-        Args:
-            instance: The _SimpolPhaseTransfer instance to serialize.
-
-        Returns:
-            Dict: A dictionary representation of the SimpolPhaseTransfer object.
-        """
-        # Create a local copy to call serialize
-        temp_obj = SimpolPhaseTransfer()
-        temp_obj._instance = instance
-        return temp_obj.serialize()

musica/mechanism_configuration/wet_deposition.py

@@ -1,52 +0,0 @@
-from typing import Optional, Any, Dict
-from .. import backend
-from .phase import Phase
-from .utils import _add_other_properties
-
-_backend = backend.get_backend()
-_WetDeposition = _backend._mechanism_configuration._WetDeposition
-
-
-class WetDeposition(_WetDeposition):
-    """
-    A class representing a wet deposition reaction rate constant.
-
-    Attributes:
-        name (str): The name of the wet deposition reaction rate constant.
-        scaling_factor (float): The scaling factor for the wet deposition rate constant.
-        condensed_phase (Phase): The condensed phase which undergoes wet deposition.
-        unknown_properties (Dict[str, Any]): A dictionary of other properties of the wet deposition reaction rate constant.
-    """
-
-    def __init__(
-        self,
-        name: Optional[str] = None,
-        scaling_factor: Optional[float] = None,
-        condensed_phase: Optional[Phase] = None,
-        other_properties: Optional[Dict[str, Any]] = None,
-    ):
-        """
-        Initializes the WetDeposition object with the given parameters.
-
-        Args:
-            name (str): The name of the wet deposition reaction rate constant.
-            scaling_factor (float): The scaling factor for the wet deposition rate constant.
-            condensed_phase (Phase): The condensed phase which undergoes wet deposition.
-            other_properties (Dict[str, Any]): A dictionary of other properties of the wet deposition reaction rate constant.
-        """
-        super().__init__()
-        self.name = name if name is not None else self.name
-        self.scaling_factor = scaling_factor if scaling_factor is not None else self.scaling_factor
-        self.condensed_phase = condensed_phase.name if condensed_phase is not None else self.condensed_phase
-        self.other_properties = other_properties if other_properties is not None else self.other_properties
-
-    @staticmethod
-    def serialize(instance) -> Dict:
-        serialize_dict = {
-            "type": "WET_DEPOSITION",
-            "name": instance.name,
-            "scaling factor": instance.scaling_factor,
-            "condensed phase": instance.condensed_phase,
-        }
-        _add_other_properties(serialize_dict, instance.other_properties)
-        return serialize_dict

musica-0.12.2.dist-info/RECORD

@@ -1,80 +0,0 @@
-musica-0.12.2.dist-info/RECORD,,
-musica-0.12.2.dist-info/WHEEL,sha256=qdO6WnDiDW9GigE7BL6ZZjKOjAgb6iacSCh606yDCxw,139
-musica-0.12.2.dist-info/entry_points.txt,sha256=t9qRU9Ya63_yYMKJkTiVS5kCaW6dDDr0wuQ26lgXTH8,49
-musica-0.12.2.dist-info/METADATA,sha256=FlXiev8ZTGt1gS9XbB3IKm4X5_jaDHB8dmMnUD29alg,26345
-musica-0.12.2.dist-info/licenses/AUTHORS.md,sha256=CYIlKZmXT9ngFk6d0MiD0A_Pt8BFoID4n-29OMrKkbM,2632
-musica-0.12.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-musica/backend.py,sha256=Ed0vqpdem4a4sz5XOPiBdi1TPQy80qVDcmZUqI5lZvw,1040
-musica/CMakeLists.txt,sha256=3b_ipe2i0ZwtLqmmX9-NgF7G4eoq7QN_cnb9eYQ9yqc,1749
-musica/_version.py,sha256=hCVcx_5bAXLIccGTgYEYZL1ymSpFddakc6toGfEFtF8,19
-musica/constants.py,sha256=RsZrtjy8vlIcQxV9F9xzlSYFeGBQBHmhFWDPB7pRQH8,123
-musica/binding_common.cpp,sha256=CigfwqYcETNUe4Ct0P8QMauAFdxPs1iu6ddCqhlckNY,981
-musica/__init__.py,sha256=2xoebKVljHzrzupxtAbK3Wg05p38Lq0SFIbDjR0--bs,392
-musica/tuvx.py,sha256=utrhxwHw1BsoMri9PxfY_I3ip50JzB5TYwFUZtGBr2I,6388
-musica/cpu_binding.cpp,sha256=AZXO6EpL5HofGJ1s11fprrXYVG2U1ZrdUxe3M9j5kpw,225
-musica/types.py,sha256=huXgtEf28B13eygMs6TbLkXic9mAifDslY4ONQKpogg,17137
-musica/gpu_binding.cpp,sha256=y9Fzgn9unoGz_Fqqlk_NBWy4jHOwTv8E82e3bq_phMg,229
-musica/tuvx.cpp,sha256=HnxxysJezO6U6sG9KibHHjfIuKD9KhqHU4Myn5JkmRY,3015
-musica/_musica.cpython-39-darwin.so,sha256=qfOWRNZAwFll_Y5Vl7ou_PIGDLS6yrP05g7Ucz_xNxU,3721856
-musica/cuda.py,sha256=rtMNdmixfEsy5J4pfKOc6LfBuFECxCKsi8J0jAvtyHo,258
-musica/cuda.cpp,sha256=qQOLKTUOB83gE-963rT579Me-NrqMUWnXDKmpTPMVFg,346
-musica/binding_common.hpp,sha256=YVG7TS1JeVC4W_yisV4kL61qo3N6Dt6JdAh9bdr6z2w,102
-musica/mechanism_configuration.cpp,sha256=iaD8zZvvMH4nt-tZ9dTBsFiqP28xHi5_wpsp07FJ3RM,29105
-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=Krb2GSVHoXeHZI3cJLXZnQv7MlNlhzOuYV0N-9n3heo,8383
-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=RhDWTmX2E9RiISFuKyqH3DJn38sxfaSfgzxPM-Rs1h0,2603
-musica/test/unit/test_serializer.py,sha256=U0aQwXtOwdpFlfJH915rLikde7U97pJ1p0KiH2__jro,2458
-musica/test/unit/test_util_full_mechanism.py,sha256=9_n8_RbG3X60YGV59mOpp_hvsh6-hMKhXZCijE5beRg,25217
-musica/test/unit/test_state.py,sha256=JOoFKCQBYK93hRh5XWW5JBmHhgR9uPIsiGKmCBkpXzo,10369
-musica/test/integration/test_chapman.py,sha256=gOISpApVIMLCEv6W0Hq1yNGF0xu2MlZMHQQhOGPmoQI,3512
-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=9jQvE-LxTRPpoKXi3JponF1G4-xcAhhE1sLX1KV-EOQ,1918
-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=cLyG0HJP2Jxl44e52Z94R6_WGsGLBjXAWiOIfDk1yuY,5617
-musica/test/examples/v1/full_configuration/full_configuration.json,sha256=WfJ2hw-XOhrM9RRAYrdW5C_9bc7ACB835xKWK5UWUhY,9437
-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=etZfelp8uKAtQO-lkhokXOX7mWXe6V6_sVQkxx-Xjbw,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=ZVBFvjKhF2_mty4vnshhdHtpOLncbg3u8diBtK4Trps,362768
-musica/.dylibs/libgcc_s.1.1.dylib,sha256=p4iJ87gq_K353gV1yo8ih7TVYCLiu3yLvogtuxSVAjs,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=rOEExkNxrzHQSKwclrnQltXzanWnLA9vt5UFDnbQOi4,1633
-musica/mechanism_configuration/species.py,sha256=JyNPFVH9abznBb-pNLHVKynU6qx7s2PzGt2gXDcM-jI,5453
-musica/mechanism_configuration/henrys_law.py,sha256=aLgVAWROMxOfx0ng_FOovZeTWXXtfD8Kz-GwGn_2Fi8,1563
-musica/mechanism_configuration/tunneling.py,sha256=zGEVG034ERLHgx9HW74SYlTbb-_LPSvEeIdKvrvc3qA,9378
-musica/mechanism_configuration/mechanism_configuration.py,sha256=6t3ulJpXZhXe-XNpjfKkhu5FlmjLOwg3a10cWC0gEjY,10437
-musica/mechanism_configuration/branched.py,sha256=WWYVSRv2yTAvLe91zUsmqeTL0PAAKEIY7t9zujYRGgE,11762
-musica/mechanism_configuration/reactions.py,sha256=R3uJwDXMtu1r2xijBmq1FsaMqzKQXqFqteho7leQ8hc,2367
-musica/mechanism_configuration/__init__.py,sha256=LwedZpjLpPM5wUGzVx7mv9HreL8DCbzZQedtcp0OWYM,39
-musica/mechanism_configuration/user_defined.py,sha256=E5pioPg7UQVY6eUe7wvzwC_2ooCwliAPWl_9Do5EX_g,3892
-musica/mechanism_configuration/aqueous_equilibrium.py,sha256=QCWH6IfdpY_vQXEdwnWiXpkJEfpINAhPp9L8gRNnFjY,10996
-musica/mechanism_configuration/condensed_phase_arrhenius.py,sha256=XX_t-54FFGFKJrorsGxS3MVBV5CMLIMpSBN6I3HMbho,11436
-musica/mechanism_configuration/first_order_loss.py,sha256=6IMOoX7ykECgPCVokcaVsJM1712P4bVjqvldk-chPQk,6641
-musica/mechanism_configuration/utils.py,sha256=nR-ukwYsplFfnsjXtKQsXnryMPvtjkZkFQv7TjcSrnE,346
-musica/mechanism_configuration/wet_deposition.py,sha256=ROc57JgXTxCCoGCSvNUZMXkAMLqcT9PVfuIDGNXT65U,2254
-musica/mechanism_configuration/condensed_phase_photolysis.py,sha256=KxnCUvgvIidLWXsVdPkGFbcEuxyuQ_8PPubw3x05EBI,4115
-musica/mechanism_configuration/arrhenius.py,sha256=0B0fT1mzajyJ68Ns-bdxjDsh7btBf4r1UYIgInZ9_FE,11172
-musica/mechanism_configuration/troe.py,sha256=1uj0vL4-Vzk1Ue2j-v1G3FrVsQ0bRpfOnMHzphUsL2U,13607
-musica/mechanism_configuration/simpol_phase_transfer.py,sha256=o-JPNwPVJtBpRsmiIzDJ-iNWU-L8lk8uCI9FvbC_FQY,9061
-musica/mechanism_configuration/photolysis.py,sha256=f6LQmsL9NmUyy7cp8PPU0zI2sExcyirJ62LmzcfFB_U,3883
-musica/mechanism_configuration/emission.py,sha256=HS1QVJWYj4Omk2lK_NrxFFPeEu_HLXaSGAG0I0BXU4s,3044
-musica/mechanism_configuration/surface.py,sha256=2cFsIvFvL8lmxe0c8cB9LYDjg4qD6Y020ZziCjT6iaw,4346
-musica/mechanism_configuration/ternary_chemical_activation.py,sha256=AlY9yFq0ZXgEnUaNd249wrgmYyW1TvkzOi2ZoK4B3gQ,14323
-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