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

musica/mechanism_configuration/reaction_component.py

@@ -0,0 +1,54 @@
+from typing import Optional, Any, Dict
+from .. import backend
+from .utils import _add_other_properties, _remove_empty_keys
+
+_backend = backend.get_backend()
+ReactionComponent = _backend._mechanism_configuration._ReactionComponent
+original_init = ReactionComponent.__init__
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    coefficient: Optional[float] = 1.0,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the ReactionComponent object with the given parameters.
+
+    Args:
+        name (str): The name of the species.
+        coefficient (float): The stichiometric coefficient
+        other_properties (Dict[str, Any]): A dictionary of other properties of the species.
+    """
+    original_init(self)
+    self.species_name = name if name is not None else self.species_name
+    self.coefficient = coefficient if coefficient is not None else self.coefficient
+    self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+
+def serialize(self) -> Dict:
+    serialize_dict = {
+        "species name": self.species_name,
+        "coefficient": self.coefficient,
+        "other_properties": self.other_properties,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return _remove_empty_keys(serialize_dict)
+
+
+ReactionComponent.__doc__ = """
+    A class representing a reaction component in a chemical reaction.
+
+    A reaction component typically consists of a chemical species, its stoichiometric coefficient in the reaction,
+    and any additional properties relevant to its role in the reaction.
+
+    Attributes:
+        species_name (str): The name of the chemical species involved in the reaction.
+        coefficient (float): The stoichiometric coefficient of the species in the reaction.
+        other_properties (Dict[str, Any]): A dictionary of other properties relevant to the reaction component.
+    """
+
+
+ReactionComponent.__init__ = __init__
+ReactionComponent.serialize = serialize

musica/mechanism_configuration/reactions.py

@@ -1,73 +1,32 @@
 from typing import Optional, Any, Dict, List, Union
 from .. import backend
-from .species import Species, _Species
+from .species import 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
+Reactions = _backend._mechanism_configuration._Reactions
 
+original_init = Reactions.__init__
 
-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.
+Reactions.__doc__ = """
+A class representing a collection of reactions in a chemical mechanism.
 
-        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)
+Attributes:
+    reactions (List[Any]): A list of reactions in the mechanism.
+"""
 
 
-class ReactionsIterator(_ReactionsIterator):
+def __init__(
+    self,
+    reactions: Optional[List[Any]] = None,
+):
     """
-    An iterator for the Reactions class.
-    """
-
+    Initializes the Reactions object with the given parameters.
 
-class ReactionComponentSerializer():
+    Args:
+        reactions (List[]): A list of reactions in the mechanism.
     """
-    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
+    original_init(self, reactions)
 
-        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
+Reactions.__init__ = __init__

musica/mechanism_configuration/species.py

@@ -1,91 +1,65 @@
 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
+Species = _backend._mechanism_configuration._Species
+original_init = Species.__init__
 
 
-class Species(_Species):
+def __init__(
+    self,
+    name: Optional[str] = None,
+    molecular_weight_kg_mol: Optional[float] = None,
+    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.
+        molecular_weight_kg_mol (float): Molecular weight [kg mol-1]
+        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.
+    """
+    original_init(self)
+    self.name = name if name is not None else self.name
+    self.molecular_weight_kg_mol = molecular_weight_kg_mol if molecular_weight_kg_mol is not None else self.molecular_weight_kg_mol
+    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
+    self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+
+def serialize(self) -> Dict:
+    serialize_dict = {
+        "name": self.name,
+        "molecular weight [kg mol-1]": self.molecular_weight_kg_mol,
+        "constant concentration [mol m-3]": self.constant_concentration_mol_m3,
+        "constant mixing ratio [mol mol-1]": self.constant_mixing_ratio_mol_mol,
+        "is third body": self.is_third_body,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return _remove_empty_keys(serialize_dict)
+
+
+Species.__doc__ = """
     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)
+Species.__init__ = __init__
+Species.serialize = serialize

musica/mechanism_configuration/surface.py

@@ -2,93 +2,97 @@ 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
+from .utils import _add_other_properties, _remove_empty_keys
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
 
 _backend = backend.get_backend()
-_Surface = _backend._mechanism_configuration._Surface
-_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
+Surface = _backend._mechanism_configuration._Surface
 
+original_init = Surface.__init__
 
-class Surface(_Surface):
-    """
-    A class representing a surface in a chemical mechanism.
 
-    (TODO: get details from MusicBox)
+@property
+def type(self):
+    return ReactionType.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,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the Surface object with the given parameters.
 
-    Attributes:
+    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.
     """
-
-    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 = (
+    original_init(self)
+    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(gas_phase_species.name)
-                if isinstance(gas_phase_species, Species)
-                else _ReactionComponent(gas_phase_species[1].name, gas_phase_species[0])
+                ReactionComponent(p.name)
+                if isinstance(p, Species)
+                else ReactionComponent(p[1].name, p[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
+            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.other_properties = other_properties if other_properties is not None else self.other_properties
+
+
+def serialize(self) -> Dict:
+    serialize_dict = {
+        "type": "SURFACE",
+        "name": self.name,
+        "reaction probability": self.reaction_probability,
+        "gas-phase species": self.gas_phase_species.species_name,
+        "gas-phase products": [r.serialize() for r in self.gas_phase_products],
+        "gas phase": self.gas_phase,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return _remove_empty_keys(serialize_dict)
+
+
+Surface.__doc__ = """
+A class representing a surface in a chemical mechanism.
+
+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.
+    other_properties (Dict[str, Any]): A dictionary of other properties of the surface.
+"""
 
-    @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
+Surface.__init__ = __init__
+Surface.serialize = serialize
+Surface.type = type

musica/mechanism_configuration/taylor_series.py

@@ -0,0 +1,136 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .utils import _add_other_properties, _remove_empty_keys
+from .phase import Phase
+from .species import Species
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+TaylorSeries = _backend._mechanism_configuration._TaylorSeries
+
+original_init = TaylorSeries.__init__
+
+
+@property
+def type(self):
+    return ReactionType.TaylorSeries
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    gas_phase: Optional[Phase] = None,
+    A: Optional[float] = None,
+    B: Optional[float] = None,
+    C: Optional[float] = None,
+    D: Optional[float] = None,
+    E: Optional[float] = None,
+    taylor_coefficients: Optional[List[float]] = None,
+    reactants: Optional[List[Union[Species,
+                                   Tuple[float, Species]]]] = None,
+    products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the TaylorSeries object with the given parameters.
+
+    Args:
+        name (Optional[str]): The name of the TaylorSeries object.
+        gas_phase (Optional[Phase]): The gas phase associated with the reaction.
+        A (Optional[float]): The A coefficient for the Taylor series.
+        B (Optional[float]): The B coefficient for the Taylor series.
+        C (Optional[float]): The C coefficient for the Taylor series.
+        D (Optional[float]): The D coefficient for the Taylor series.
+        E (Optional[float]): The E coefficient for the Taylor series.
+        taylor_coefficients (Optional[List[float]]): List of Taylor series coefficients.
+        reactants (Optional[List[Union[Species, Tuple[float, Species]]]]): List of reactants, either as Species or (stoichiometry, Species) tuples.
+        products (Optional[List[Union[Species, Tuple[float, Species]]]]): List of products, either as Species or (stoichiometry, Species) tuples.
+        other_properties (Optional[Dict[str, Any]]): Additional properties for the reaction.
+    """
+    original_init(self)
+    self.name = name if name is not None else self.name
+    self.A = A if A is not None else self.A
+    self.B = B if B is not None else self.B
+    self.C = C if C is not None else self.C
+    self.D = D if D is not None else self.D
+    self.E = E if E is not None else self.E
+    self.taylor_coefficients = taylor_coefficients if taylor_coefficients is not None else self.taylor_coefficients
+    self.gas_phase = gas_phase.name if gas_phase is not None else self.gas_phase
+    self.reactants = (
+        [
+            (
+                ReactionComponent(r.name)
+                if isinstance(r, Species)
+                else ReactionComponent(r[1].name, r[0])
+            )
+            for r in reactants
+        ]
+        if reactants is not None
+        else self.reactants
+    )
+    self.products = (
+        [
+            (
+                ReactionComponent(p.name)
+                if isinstance(p, Species)
+                else ReactionComponent(p[1].name, p[0])
+            )
+            for p in products
+        ]
+        if products is not None
+        else self.products
+    )
+    self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+
+def serialize(self) -> Dict:
+    serialize_dict = {
+        "type": "TAYLOR_SERIES",
+        "name": self.name,
+        "A": self.A,
+        "B": self.B,
+        "C": self.C,
+        "D": self.D,
+        "E": self.E,
+        "taylor coefficients": list(self.taylor_coefficients),
+        "reactants": [r.serialize() for r in self.reactants],
+        "products": [r.serialize() for r in self.products],
+        "gas phase": self.gas_phase,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return _remove_empty_keys(serialize_dict)
+
+
+TaylorSeries.__doc__ = """
+    A class representing a Taylor series rate constant.
+
+    The rate constant k is represented as a Taylor series expansion in temperature (and optionally other variables):
+
+        k = a0 + a1*T + a2*T^2 + a3*T^3 + ... + an*T^n
+
+    where:
+        k = rate constant
+        T = temperature [K]
+        a0, a1, ..., an = Taylor series coefficients
+
+    Optionally, additional parameters (A, B, C, D, E) may be provided for compatibility or extended forms.
+
+    Attributes:
+        name (str): The name of the Taylor series rate constant.
+        taylor_coefficients (List[float]): Coefficients [a0, a1, ..., an] for the Taylor series expansion.
+        A (float, optional): Optional parameter for extended forms.
+        B (float, optional): Optional parameter for extended forms.
+        C (float, optional): Optional parameter for extended forms.
+        D (float, optional): Optional parameter for extended forms.
+        E (float, optional): Optional parameter for extended forms.
+        reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+        products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the reaction.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the Taylor series rate constant.
+    """
+
+
+TaylorSeries.__init__ = __init__
+TaylorSeries.serialize = serialize
+TaylorSeries.type = type