musica 0.12.2__cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

musica/mechanism_configuration/reactions.py

@@ -0,0 +1,73 @@
+from typing import Optional, Any, Dict, List, Union
+from .. import backend
+from .species import Species, _Species
+from .utils import _remove_empty_keys
+
+_backend = backend.get_backend()
+ReactionType = _backend._mechanism_configuration._ReactionType
+_Reactions = _backend._mechanism_configuration._Reactions
+_ReactionsIterator = _backend._mechanism_configuration._ReactionsIterator
+
+
+class Reactions(_Reactions):
+    """
+    A class representing a collection of reactions in a chemical mechanism.
+
+    Attributes:
+        reactions (List[Any]): A list of reactions in the mechanism.
+    """
+
+    def __init__(
+        self,
+        reactions: Optional[List[Any]] = None,
+    ):
+        """
+        Initializes the Reactions object with the given parameters.
+
+        Args:
+            reactions (List[]): A list of reactions in the mechanism.
+        """
+        # Convert Python Arrhenius objects to C++ _Arrhenius objects for the C++ constructor
+        if reactions is not None:
+            cpp_reactions = []
+            for reaction in reactions:
+                if hasattr(reaction, '_instance'):
+                    # This is a Python wrapper around a C++ object, use the internal instance
+                    cpp_reactions.append(reaction._instance)
+                else:
+                    # This is already a C++ object or other supported type
+                    cpp_reactions.append(reaction)
+            super().__init__(cpp_reactions)
+        else:
+            super().__init__(reactions)
+
+
+class ReactionsIterator(_ReactionsIterator):
+    """
+    An iterator for the Reactions class.
+    """
+
+
+class ReactionComponentSerializer():
+    """
+    A class for serializing reaction components.
+    """
+
+    @staticmethod
+    def serialize_reaction_component(rc) -> Union[Dict, str]:
+        if isinstance(rc, Species) or isinstance(rc, _Species):
+            return rc.name
+
+        return _remove_empty_keys({
+            "species name": rc.species_name,
+            "coefficient": rc.coefficient,
+            "other_properties": rc.other_properties,
+        })
+
+    @staticmethod
+    def serialize_list_reaction_components(reaction_component_list) -> List[Union[Dict, str]]:
+        ret = []
+        for rc in reaction_component_list:
+            ret.append(
+                ReactionComponentSerializer.serialize_reaction_component(rc))
+        return ret

musica/mechanism_configuration/simpol_phase_transfer.py

@@ -0,0 +1,217 @@
+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/species.py

@@ -0,0 +1,91 @@
+from typing import Optional, Any, Dict
+from .. import backend
+from .utils import _add_other_properties, _remove_empty_keys
+from enum import Enum
+
+_backend = backend.get_backend()
+_Species = _backend._mechanism_configuration._Species
+
+
+class Species(_Species):
+    """
+    A class representing a species in a chemical mechanism.
+
+    Attributes:
+        name (str): The name of the species.
+        HLC_298K_mol_m3_Pa (float): Henry's Law Constant at 298K [mol m-3 Pa-1]
+        HLC_exponential_factor_K: Henry's Law Constant exponential factor [K]
+        diffusion_coefficient_m2_s (float): Diffusion coefficient [m2 s-1]
+        N_star (float): A parameter used to calculate the mass accomodation factor (Ervens et al., 2003)
+        molecular_weight_kg_mol (float): Molecular weight [kg mol-1]
+        density_kg_m3 (float): Density [kg m-3]
+        tracer_type (str): Type of tracer: 'THIRD_BODY' or None [Deprecated, use is_third_body instead]
+        constant_concentration_mol_m3 (float): Constant concentration of the species (mol m-3)
+        constant_mixing_ratio_mol_mol (float): Constant mixing ratio of the species (mol mol-1)
+        is_third_body (bool): Whether the species is a third body.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the species.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        HLC_298K_mol_m3_Pa: Optional[float] = None,
+        HLC_exponential_factor_K: Optional[float] = None,
+        diffusion_coefficient_m2_s: Optional[float] = None,
+        N_star: Optional[float] = None,
+        molecular_weight_kg_mol: Optional[float] = None,
+        density_kg_m3: Optional[float] = None,
+        tracer_type: Optional[str] = None,  # Deprecated use is_third_body instead
+        constant_concentration_mol_m3: Optional[float] = None,
+        constant_mixing_ratio_mol_mol: Optional[float] = None,
+        is_third_body: Optional[bool] = False,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the Species object with the given parameters.
+
+        Args:
+            name (str): The name of the species.
+            HLC_298K_mol_m3_Pa (float): Henry's Law Constant at 298K [mol m-3 Pa-1]
+            HLC_exponential_factor_K: Henry's Law Constant exponential factor [K]
+            diffusion_coefficient_m2_s (float): Diffusion coefficient [m2 s-1]
+            N_star (float): A parameter used to calculate the mass accomodation factor (Ervens et al., 2003)
+            molecular_weight_kg_mol (float): Molecular weight [kg mol-1]
+            density_kg_m3 (float): Density [kg m-3]
+            tracer_type (str): Type of tracer: 'THIRD_BODY' or None [Deprecated, use is_third_body instead]
+            constant_concentration_mol_m3 (float): Constant concentration of the species (mol m-3)
+            constant_mixing_ratio_mol_mol (float): Constant mixing ratio of the species (mol mol-1)
+            is_third_body (bool): Whether the species is a third body.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the species.
+        """
+        super().__init__()
+        self.name = name if name is not None else self.name
+        self.HLC_298K_mol_m3_Pa = HLC_298K_mol_m3_Pa if HLC_298K_mol_m3_Pa is not None else self.HLC_298K_mol_m3_Pa
+        self.HLC_exponential_factor_K = HLC_exponential_factor_K if HLC_exponential_factor_K is not None else self.HLC_exponential_factor_K
+        self.diffusion_coefficient_m2_s = diffusion_coefficient_m2_s if diffusion_coefficient_m2_s is not None else self.diffusion_coefficient_m2_s
+        self.N_star = N_star if N_star is not None else self.N_star
+        self.molecular_weight_kg_mol = molecular_weight_kg_mol if molecular_weight_kg_mol is not None else self.molecular_weight_kg_mol
+        self.density_kg_m3 = density_kg_m3 if density_kg_m3 is not None else self.density_kg_m3
+        self.tracer_type = tracer_type if tracer_type is not None else self.tracer_type
+        self.constant_concentration_mol_m3 = constant_concentration_mol_m3 if constant_concentration_mol_m3 is not None else self.constant_concentration_mol_m3
+        self.constant_mixing_ratio_mol_mol = constant_mixing_ratio_mol_mol if constant_mixing_ratio_mol_mol is not None else self.constant_mixing_ratio_mol_mol
+        self.is_third_body = is_third_body if is_third_body is not None else self.is_third_body
+        self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+    @staticmethod
+    def serialize(instance) -> Dict:
+        serialize_dict = {
+            "name": instance.name,
+            "HLC(298K) [mol m-3 Pa-1]": instance.HLC_298K_mol_m3_Pa,
+            "HLC exponential factor [K]": instance.HLC_exponential_factor_K,
+            "diffusion coefficient [m2 s-1]": instance.diffusion_coefficient_m2_s,
+            "N star": instance.N_star,
+            "molecular weight [kg mol-1]": instance.molecular_weight_kg_mol,
+            "density [kg m-3]": instance.density_kg_m3,
+            "tracer type": instance.tracer_type,
+            "constant concentration [mol m-3]": instance.constant_concentration_mol_m3,
+            "constant mixing ratio [mol mol-1]": instance.constant_mixing_ratio_mol_mol,
+            "is third body": instance.is_third_body,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/surface.py

@@ -0,0 +1,94 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties
+
+_backend = backend.get_backend()
+_Surface = _backend._mechanism_configuration._Surface
+_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
+
+
+class Surface(_Surface):
+    """
+    A class representing a surface in a chemical mechanism.
+
+    (TODO: get details from MusicBox)
+
+    Attributes:
+        name (str): The name of the surface.
+        reaction_probability (float): The probability of a reaction occurring on the surface.
+        gas_phase_species (Union[Species, Tuple[float, Species]]): The gas phase species involved in the reaction.
+        gas_phase_products (List[Union[Species, Tuple[float, Species]]]): The gas phase products formed in the reaction.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        condensed_phase (Phase): The condensed phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the surface.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        reaction_probability: Optional[float] = None,
+        gas_phase_species: Optional[Union[Species,
+                                          Tuple[float, Species]]] = None,
+        gas_phase_products: Optional[
+            List[Union[Species, Tuple[float, Species]]]
+        ] = None,
+        gas_phase: Optional[Phase] = None,
+        condensed_phase: Optional[Phase] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the Surface object with the given parameters.
+
+        Args:
+            name (str): The name of the surface.
+            reaction_probability (float): The probability of a reaction occurring on the surface.
+            gas_phase_species (Union[Species, Tuple[float, Species]]): The gas phase species involved in the reaction.
+            gas_phase_products (List[Union[Species, Tuple[float, Species]]]): The gas phase products formed in the reaction.
+            gas_phase (Phase): The gas phase in which the reaction occurs.
+            condensed_phase (Phase): The condensed phase in which the reaction occurs.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the surface.
+        """
+        super().__init__()
+        self.name = name if name is not None else self.name
+        self.reaction_probability = reaction_probability if reaction_probability is not None else self.reaction_probability
+        self.gas_phase_species = (
+            (
+                _ReactionComponent(gas_phase_species.name)
+                if isinstance(gas_phase_species, Species)
+                else _ReactionComponent(gas_phase_species[1].name, gas_phase_species[0])
+            )
+            if gas_phase_species is not None
+            else self.gas_phase_species
+        )
+        self.gas_phase_products = (
+            [
+                (
+                    _ReactionComponent(p.name)
+                    if isinstance(p, Species)
+                    else _ReactionComponent(p[1].name, p[0])
+                )
+                for p in gas_phase_products
+            ]
+            if gas_phase_products is not None
+            else self.gas_phase_products
+        )
+        self.gas_phase = gas_phase.name if gas_phase is not None else self.gas_phase
+        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": "SURFACE",
+            "name": instance.name,
+            "reaction probability": instance.reaction_probability,
+            "gas-phase species": instance.gas_phase_species.species_name,
+            "gas-phase products": ReactionComponentSerializer.serialize_list_reaction_components(instance.gas_phase_products),
+            "gas phase": instance.gas_phase,
+            "condensed phase": instance.condensed_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return serialize_dict