musica 0.12.2__cp312-cp312-win_amd64.whl → 0.13.0__cp312-cp312-win_amd64.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,70 +0,0 @@
-musica/__init__.py,sha256=pSZ-H2IJ4EEYIbQDygjGwjhGySXdeifB1DzQBMJzz2g,403
-musica/_musica.cp312-win_amd64.pyd,sha256=mAyJVsJfi9l-5rco3BKKeWJ9V38C64zrVP-5GGXX8Vs,1590272
-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
-musica/carma.cpp,sha256=v6f2MF1PUGHR46vVZ544o6bEZjCTI2rWvtgL8M0oSns,43244
-musica/carma.py,sha256=FNd4pWJQJ8VJoo2LSl2aXUVSfLZFgABTSKqtTE-Cgv4,68716
-musica/CMakeLists.txt,sha256=MTZYtahh4tLpn6adVKZ9oZ9g-np7Hw8-VHiaFaA-lIM,1817
-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/main.py,sha256=gVCfeh44VL4EH7eFRR2wU_I_kANB94furojDi-0LhoE,2797
-musica/mechanism_configuration/__init__.py,sha256=odlwrCvBBnqUBi951RysExLDYqK_AfqP4nRY90MQpcc,40
-musica/mechanism_configuration/aqueous_equilibrium.py,sha256=60b017VeO9MrzYnkF47hzjQJRdD7k3M6L3S94SKqmAE,11270
-musica/mechanism_configuration/arrhenius.py,sha256=eIDPb485TzsRAvz2bYIjwI7n8ofhahUpCP5HRO-o00E,11479
-musica/mechanism_configuration/branched.py,sha256=g7IsOzaTK1hLWYn1agGzAPRhM0pIsz5fM0pOfVzDyKA,12061
-musica/mechanism_configuration/condensed_phase_arrhenius.py,sha256=bXXu1ctDYiZ4yrzTu2b28R-sstYIXZGNruyMxM31qFQ,11745
-musica/mechanism_configuration/condensed_phase_photolysis.py,sha256=S-J-e4-9TYw_tE1iLEqp1wDohJVx7Vkblc9kxWrXfBc,4203
-musica/mechanism_configuration/emission.py,sha256=GOlyzDqk4-_jDZn7poYJ3Rxo-KSTaPxEO7P_SBzS_xQ,3115
-musica/mechanism_configuration/first_order_loss.py,sha256=4dPG2YKeEHjJkc0biV8tGy3vLxY5f2PTeLFt6cRAuRM,6815
-musica/mechanism_configuration/henrys_law.py,sha256=vuLlqRFwThUJ9icvKJkEWXKvC9cj7ldTzDpWMXBJHQ4,1607
-musica/mechanism_configuration/mechanism_configuration.py,sha256=bLLSsdZAyn01VPbQeSJX8RpKWJoBkH7zjtUsCaCzXKw,10671
-musica/mechanism_configuration/phase.py,sha256=j7sPiVPxpaPeHwoo3SMhBgIuAWlXmKgBLpTjBbhZV3E,1680
-musica/mechanism_configuration/photolysis.py,sha256=7C3RDJ7_iFsfC_duyfl47VMsAS-EHhVdj4QExo5u7mU,3971
-musica/mechanism_configuration/reactions.py,sha256=1YbmKH2tL82ZmUdOvs6vNV9r_1GwtVHtiEZwdgrYSrI,2440
-musica/mechanism_configuration/simpol_phase_transfer.py,sha256=BneQwt4cfyBicxOXFarGqFNjJI9x0VaW1iReLy2h4DQ,9278
-musica/mechanism_configuration/species.py,sha256=dPsBPcc_E7yzxtojw3DiBP3JvUMSjmMsqH89h74ZMuk,5544
-musica/mechanism_configuration/surface.py,sha256=vJBW-brrcdzABeUV5DQSS4xli0KjB_K32sW0dnnxRGo,4440
-musica/mechanism_configuration/ternary_chemical_activation.py,sha256=rbhzhmbvewf2Q6hf3_4TcuMiQaoWiOpCzTzWPKXWE5A,14675
-musica/mechanism_configuration/troe.py,sha256=s3nTWbhRiJ2NiEhPH_Bjlyw-NP9eYy3EASN6WIeLfVQ,13959
-musica/mechanism_configuration/tunneling.py,sha256=LpSRmTjFoniIcS2D-qPL9HKaRSZ1YmxbjHCevm6fKHA,9628
-musica/mechanism_configuration/user_defined.py,sha256=dUuSpj4rc9XRuD8FZJ9CX4DFjvQcUCNt5Krrn0cj-_I,3980
-musica/mechanism_configuration/utils.py,sha256=dhMFrydNchhdRrfeJw35oJB8Y5oQJa6p65Z7I127P-8,356
-musica/mechanism_configuration/wet_deposition.py,sha256=cP8WL6T3FjGF01lyf1tNsJllaHQEOciCX8yZraBycIc,2306
-musica/mechanism_configuration.cpp,sha256=wwH5dDG7AuXRk4-ZZGPYwcAc_EpOwoXYdfje2hOobOE,29712
-musica/musica.cpp,sha256=CMPdG_ddcEhW5r7u-DDjqGAGM97zHd_7h6wk_o5t0Qk,8584
-musica/test/examples/v1/full_configuration/full_configuration.json,sha256=zBC3EVwIWtBy5t3FOIrqMNOsRaNRXth0kCqBps4PxCs,9902
-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=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=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=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=zTqzaflhrwQqVMtwN_5eNxkvMis_QWAo3XwcNSpWEqs,17544
-musica-0.12.2.dist-info/METADATA,sha256=FlXiev8ZTGt1gS9XbB3IKm4X5_jaDHB8dmMnUD29alg,26345
-musica-0.12.2.dist-info/WHEEL,sha256=chqeLhPBtPdrOoreR34YMcofSk3yWDQhkrsDJ2n48LU,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,,