musica 0.12.2__cp311-cp311-manylinux_2_26_i686.manylinux_2_28_i686.whl

musica/mechanism_configuration/branched.py

@@ -0,0 +1,299 @@
+from .utils import _add_other_properties
+from .reactions import ReactionComponentSerializer
+from .species import Species
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+
+_backend = backend.get_backend()
+_Branched = _backend._mechanism_configuration._Branched
+_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
+ReactionType = _backend._mechanism_configuration._ReactionType
+
+
+class Branched:
+    """
+    A class representing a branched reaction rate constant.
+
+    (TODO: get details from MusicBox)
+
+    Attributes:
+        name (str): The name of the branched reaction rate constant.
+        X (float): Pre-exponential branching factor [(mol m-3)^-(n-1)s-1].
+        Y (float): Exponential branching factor [K-1].
+        a0 (float): Z parameter [unitless].
+        n (float): A parameter [unitless].
+        reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+        nitrate_products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the nitrate branch.
+        alkoxy_products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the alkoxy branch.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the branched reaction rate constant.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        X: Optional[float] = None,
+        Y: Optional[float] = None,
+        a0: Optional[float] = None,
+        n: Optional[float] = None,
+        reactants: Optional[List[Union[Species,
+                                       Tuple[float, Species]]]] = None,
+        nitrate_products: Optional[List[Union[Species,
+                                              Tuple[float, Species]]]] = None,
+        alkoxy_products: Optional[List[Union[Species,
+                                             Tuple[float, Species]]]] = None,
+        gas_phase: Optional[Phase] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the Branched object with the given parameters.
+
+        Args:
+            name (str): The name of the branched reaction rate constant.
+            X (float): Pre-exponential branching factor [(mol m-3)^-(n-1)s-1].
+            Y (float): Exponential branching factor [K-1].
+            a0 (float): Z parameter [unitless].
+            n (float): A parameter [unitless].
+            reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved in the reaction.
+            nitrate_products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the nitrate branch.
+            alkoxy_products (List[Union[Species, Tuple[float, Species]]]): A list of products formed in the alkoxy branch.
+            gas_phase (Phase): The gas phase in which the reaction occurs.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the branched reaction rate constant.
+        """
+        # Create the internal C++ instance
+        self._instance = _Branched()
+
+        # Set all parameters
+        if name is not None:
+            self.name = name
+        if X is not None:
+            self.X = X
+        if Y is not None:
+            self.Y = Y
+        if a0 is not None:
+            self.a0 = a0
+        if n is not None:
+            self.n = n
+        if reactants is not None:
+            self.reactants = reactants
+        if nitrate_products is not None:
+            self.nitrate_products = nitrate_products
+        if alkoxy_products is not None:
+            self.alkoxy_products = alkoxy_products
+        if gas_phase is not None:
+            self.gas_phase = gas_phase
+        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 branched reaction rate constant."""
+        return self._instance.name
+
+    @name.setter
+    def name(self, value: str):
+        """Set the name of the branched reaction rate constant."""
+        self._instance.name = value
+
+    @property
+    def X(self) -> float:
+        """Get the pre-exponential branching factor."""
+        return self._instance.X
+
+    @X.setter
+    def X(self, value: float):
+        """Set the pre-exponential branching factor."""
+        self._instance.X = value
+
+    @property
+    def Y(self) -> float:
+        """Get the exponential branching factor."""
+        return self._instance.Y
+
+    @Y.setter
+    def Y(self, value: float):
+        """Set the exponential branching factor."""
+        self._instance.Y = value
+
+    @property
+    def a0(self) -> float:
+        """Get the Z parameter."""
+        return self._instance.a0
+
+    @a0.setter
+    def a0(self, value: float):
+        """Set the Z parameter."""
+        self._instance.a0 = value
+
+    @property
+    def n(self) -> float:
+        """Get the A parameter."""
+        return self._instance.n
+
+    @n.setter
+    def n(self, value: float):
+        """Set the A parameter."""
+        self._instance.n = value
+
+    @property
+    def reactants(self) -> List[Union[Species, Tuple[float, Species]]]:
+        """Get the reactants as Python objects."""
+        # Convert from C++ _ReactionComponent objects to Python Species objects
+        result = []
+        for rc in self._instance.reactants:
+            if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
+                # Create a tuple with coefficient and species
+                species = Species(name=rc.species_name)
+                result.append((rc.coefficient, species))
+            else:
+                # Just the species
+                species = Species(name=rc.species_name)
+                result.append(species)
+        return result
+
+    @reactants.setter
+    def reactants(self, value: List[Union[Species, Tuple[float, Species]]]):
+        """Set the reactants, converting from Python to C++ objects."""
+        cpp_reactants = []
+        for r in value:
+            if isinstance(r, Species):
+                cpp_reactants.append(_ReactionComponent(r.name))
+            elif isinstance(r, tuple) and len(r) == 2:
+                coefficient, species = r
+                cpp_reactants.append(_ReactionComponent(species.name, coefficient))
+            else:
+                raise ValueError(f"Invalid reactant format: {r}")
+        self._instance.reactants = cpp_reactants
+
+    @property
+    def nitrate_products(self) -> List[Union[Species, Tuple[float, Species]]]:
+        """Get the nitrate products as Python objects."""
+        # Convert from C++ _ReactionComponent objects to Python Species objects
+        result = []
+        for rc in self._instance.nitrate_products:
+            if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
+                # Create a tuple with coefficient and species
+                species = Species(name=rc.species_name)
+                result.append((rc.coefficient, species))
+            else:
+                # Just the species
+                species = Species(name=rc.species_name)
+                result.append(species)
+        return result
+
+    @nitrate_products.setter
+    def nitrate_products(self, value: List[Union[Species, Tuple[float, Species]]]):
+        """Set the nitrate products, converting from Python to C++ objects."""
+        cpp_products = []
+        for p in value:
+            if isinstance(p, Species):
+                cpp_products.append(_ReactionComponent(p.name))
+            elif isinstance(p, tuple) and len(p) == 2:
+                coefficient, species = p
+                cpp_products.append(_ReactionComponent(species.name, coefficient))
+            else:
+                raise ValueError(f"Invalid nitrate product format: {p}")
+        self._instance.nitrate_products = cpp_products
+
+    @property
+    def alkoxy_products(self) -> List[Union[Species, Tuple[float, Species]]]:
+        """Get the alkoxy products as Python objects."""
+        # Convert from C++ _ReactionComponent objects to Python Species objects
+        result = []
+        for rc in self._instance.alkoxy_products:
+            if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
+                # Create a tuple with coefficient and species
+                species = Species(name=rc.species_name)
+                result.append((rc.coefficient, species))
+            else:
+                # Just the species
+                species = Species(name=rc.species_name)
+                result.append(species)
+        return result
+
+    @alkoxy_products.setter
+    def alkoxy_products(self, value: List[Union[Species, Tuple[float, Species]]]):
+        """Set the alkoxy products, converting from Python to C++ objects."""
+        cpp_products = []
+        for p in value:
+            if isinstance(p, Species):
+                cpp_products.append(_ReactionComponent(p.name))
+            elif isinstance(p, tuple) and len(p) == 2:
+                coefficient, species = p
+                cpp_products.append(_ReactionComponent(species.name, coefficient))
+            else:
+                raise ValueError(f"Invalid alkoxy product format: {p}")
+        self._instance.alkoxy_products = cpp_products
+
+    @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 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.Branched
+
+    def serialize(self) -> Dict:
+        """
+        Serialize the Branched object to a dictionary using only Python-visible data.
+
+        Returns:
+            Dict: A dictionary representation of the Branched object.
+        """
+        serialize_dict = {
+            "type": "BRANCHED_NO_RO2",
+            "name": self.name,
+            "X": self.X,
+            "Y": self.Y,
+            "a0": self.a0,
+            "n": self.n,
+            "reactants": ReactionComponentSerializer.serialize_list_reaction_components(
+                self._instance.reactants),
+            "nitrate products": ReactionComponentSerializer.serialize_list_reaction_components(
+                self._instance.nitrate_products),
+            "alkoxy products": ReactionComponentSerializer.serialize_list_reaction_components(
+                self._instance.alkoxy_products),
+            "gas phase": self.gas_phase,
+        }
+        _add_other_properties(serialize_dict, self.other_properties)
+        return serialize_dict
+
+    @staticmethod
+    def serialize_static(instance) -> Dict:
+        """
+        Static serialize method for compatibility with C++ _Branched objects.
+
+        Args:
+            instance: The _Branched instance to serialize.
+
+        Returns:
+            Dict: A dictionary representation of the Branched object.
+        """
+        # Create a temporary Branched object and use its instance serialize method
+        temp_branched = Branched()
+        temp_branched._instance = instance
+        return temp_branched.serialize()

musica/mechanism_configuration/condensed_phase_arrhenius.py

@@ -0,0 +1,309 @@
+from ..constants import BOLTZMANN
+from .utils import _add_other_properties
+from .reactions import ReactionComponentSerializer
+from .species import Species
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+
+_backend = backend.get_backend()
+_CondensedPhaseArrhenius = _backend._mechanism_configuration._CondensedPhaseArrhenius
+_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
+
+
+class CondensedPhaseArrhenius:
+    """
+    A class representing a condensed phase Arrhenius rate constant.
+
+    Attributes:
+        name (str): The name of the condensed phase Arrhenius rate constant.
+        A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1].
+        B (float): Temperature exponent [unitless].
+        C (float): Exponential term [K-1].
+        Ea (float): Activation energy [J molecule-1].
+        D (float): Reference Temperature [K].
+        E (float): Pressure scaling term [Pa-1].
+        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.
+        condensed_phase (Phase): The condensed phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the condensed phase Arrhenius rate constant.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        A: Optional[float] = None,
+        B: Optional[float] = None,
+        C: Optional[float] = None,
+        Ea: Optional[float] = None,
+        D: Optional[float] = None,
+        E: Optional[float] = None,
+        reactants: Optional[List[Union[Species,
+                                       Tuple[float, Species]]]] = None,
+        products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+        condensed_phase: Optional[Phase] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the CondensedPhaseArrhenius object with the given parameters.
+
+        Args:
+            name (str): The name of the condensed phase Arrhenius rate constant.
+            A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1].
+            B (float): Temperature exponent [unitless].
+            C (float): Exponential term [K-1].
+            Ea (float): Activation energy [J molecule-1].
+            D (float): Reference Temperature [K].
+            E (float): Pressure scaling term [Pa-1].
+            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.
+            condensed_phase (Phase): The condensed phase in which the reaction occurs.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the condensed phase Arrhenius rate constant.
+        """
+        # Create the internal C++ instance
+        self._instance = _CondensedPhaseArrhenius()
+
+        # Store Python objects for reactants, products, phases
+        self._reactants = reactants if reactants is not None else []
+        self._products = products if products is not None else []
+        self._condensed_phase = condensed_phase
+        self._other_properties = other_properties if other_properties is not None else {}
+
+        # Set basic properties on the C++ instance
+        if name is not None:
+            self._instance.name = name
+        if A is not None:
+            self._instance.A = A
+        if B is not None:
+            self._instance.B = B
+        if C is not None and Ea is not None:
+            raise ValueError("Cannot specify both C and Ea.")
+        if Ea is not None:
+            self._instance.C = -Ea / BOLTZMANN
+        elif C is not None:
+            self._instance.C = C
+        if D is not None:
+            self._instance.D = D
+        if E is not None:
+            self._instance.E = E
+
+        # Set reactants on the C++ instance
+        if reactants is not None:
+            self._instance.reactants = [
+                (
+                    _ReactionComponent(r.name)
+                    if isinstance(r, Species)
+                    else _ReactionComponent(r[1].name, r[0])
+                )
+                for r in reactants
+            ]
+
+        # Set products on the C++ instance
+        if products is not None:
+            self._instance.products = [
+                (
+                    _ReactionComponent(p.name)
+                    if isinstance(p, Species)
+                    else _ReactionComponent(p[1].name, p[0])
+                )
+                for p in products
+            ]
+
+        # Set phase information on the C++ instance
+        if condensed_phase is not None:
+            self._instance.condensed_phase = condensed_phase.name
+        if other_properties is not None:
+            self._instance.other_properties = other_properties
+
+    def __getattr__(self, name):
+        """Delegate unknown attribute access to the internal instance."""
+        return getattr(self._instance, name)
+
+    @property
+    def type(self):
+        """The reaction type."""
+        return self._instance.type
+
+    @property
+    def name(self) -> str:
+        """The name of the condensed phase Arrhenius rate constant."""
+        return self._instance.name
+
+    @name.setter
+    def name(self, value: str):
+        self._instance.name = value
+
+    @property
+    def A(self) -> float:
+        """Pre-exponential factor [(mol m-3)^(n-1)s-1]."""
+        return self._instance.A
+
+    @A.setter
+    def A(self, value: float):
+        self._instance.A = value
+
+    @property
+    def B(self) -> float:
+        """Temperature exponent [unitless]."""
+        return self._instance.B
+
+    @B.setter
+    def B(self, value: float):
+        self._instance.B = value
+
+    @property
+    def C(self) -> float:
+        """Exponential term [K-1]."""
+        return self._instance.C
+
+    @C.setter
+    def C(self, value: float):
+        self._instance.C = value
+
+    @property
+    def D(self) -> float:
+        """Reference Temperature [K]."""
+        return self._instance.D
+
+    @D.setter
+    def D(self, value: float):
+        self._instance.D = value
+
+    @property
+    def E(self) -> float:
+        """Pressure scaling term [Pa-1]."""
+        return self._instance.E
+
+    @E.setter
+    def E(self, value: float):
+        self._instance.E = value
+
+    @property
+    def reactants(self) -> List[Union[Species, Tuple[float, Species]]]:
+        """A list of reactants involved in the reaction."""
+        return self._reactants
+
+    @reactants.setter
+    def reactants(self, value: List[Union[Species, Tuple[float, Species]]]):
+        self._reactants = value
+        # Update the C++ instance
+        self._instance.reactants = [
+            (
+                _ReactionComponent(r.name)
+                if isinstance(r, Species)
+                else _ReactionComponent(r[1].name, r[0])
+            )
+            for r in value
+        ]
+
+    @property
+    def products(self) -> List[Union[Species, Tuple[float, Species]]]:
+        """A list of products formed in the reaction."""
+        return self._products
+
+    @products.setter
+    def products(self, value: List[Union[Species, Tuple[float, Species]]]):
+        self._products = value
+        # Update the C++ instance
+        self._instance.products = [
+            (
+                _ReactionComponent(p.name)
+                if isinstance(p, Species)
+                else _ReactionComponent(p[1].name, p[0])
+            )
+            for p in value
+        ]
+
+    @property
+    def condensed_phase(self) -> Phase:
+        """The condensed phase in which the reaction occurs."""
+        return self._condensed_phase
+
+    @condensed_phase.setter
+    def condensed_phase(self, value: Phase):
+        self._condensed_phase = value
+        # Update the C++ instance
+        self._instance.condensed_phase = value.name if value is not None else ""
+
+    @property
+    def other_properties(self) -> Dict[str, Any]:
+        """A dictionary of other properties of the condensed phase Arrhenius rate constant."""
+        return self._other_properties
+
+    @other_properties.setter
+    def other_properties(self, value: Dict[str, Any]):
+        self._other_properties = value
+        # Update the C++ instance
+        self._instance.other_properties = value
+
+    def serialize(self) -> Dict:
+        """
+        Serialize the CondensedPhaseArrhenius instance to a dictionary.
+
+        Returns:
+            Dict: A dictionary representation of the condensed phase Arrhenius rate constant.
+        """
+        # Convert Python reactants/products to serializable format
+        def serialize_python_components(components):
+            result = []
+            for component in components:
+                if isinstance(component, Species):
+                    result.append(component.name)
+                elif isinstance(component, tuple) and len(component) == 2:
+                    # Handle (coefficient, Species) tuples
+                    coefficient, species = component
+                    result.append({
+                        "species name": species.name,
+                        "coefficient": coefficient
+                    })
+                else:
+                    # Fallback: treat as Species
+                    result.append(component.name if hasattr(component, 'name') else str(component))
+            return result
+
+        serialize_dict = {
+            "type": "CONDENSED_PHASE_ARRHENIUS",
+            "name": self.name,
+            "A": self.A,
+            "B": self.B,
+            "C": self.C,
+            "D": self.D,
+            "E": self.E,
+            "reactants": serialize_python_components(self._reactants),
+            "products": serialize_python_components(self._products),
+            "condensed phase": self._condensed_phase.name if self._condensed_phase is not None else "",
+        }
+        _add_other_properties(serialize_dict, self._other_properties)
+        return serialize_dict
+
+    @staticmethod
+    def serialize_static(instance) -> Dict:
+        """
+        Static serialize method for backward compatibility.
+
+        Args:
+            instance: The CondensedPhaseArrhenius instance to serialize (can be Python wrapper or C++ type).
+
+        Returns:
+            Dict: A dictionary representation of the condensed phase Arrhenius rate constant.
+        """
+        # Check if it's the new composition-based Python wrapper
+        if hasattr(instance, '_instance'):
+            # New Python wrapper - use instance method
+            return instance.serialize()
+        else:
+            # Old C++ wrapper type - use direct attribute access
+            serialize_dict = {
+                "type": "CONDENSED_PHASE_ARRHENIUS",
+                "name": instance.name,
+                "A": instance.A,
+                "B": instance.B,
+                "C": instance.C,
+                "D": instance.D,
+                "E": instance.E,
+                "reactants": ReactionComponentSerializer.serialize_list_reaction_components(instance.reactants),
+                "products": ReactionComponentSerializer.serialize_list_reaction_components(instance.products),
+                "condensed phase": instance.condensed_phase,
+            }
+            _add_other_properties(serialize_dict, instance.other_properties)
+            return serialize_dict

musica/mechanism_configuration/condensed_phase_photolysis.py

@@ -0,0 +1,88 @@
+from .utils import _add_other_properties
+from .reactions import ReactionComponentSerializer
+from .species import Species
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+
+_backend = backend.get_backend()
+_CondensedPhasePhotolysis = _backend._mechanism_configuration._CondensedPhasePhotolysis
+_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
+
+
+class CondensedPhasePhotolysis(_CondensedPhasePhotolysis):
+    """
+    A class representing a condensed phase photolysis reaction rate constant.
+
+    Attributes:
+        name (str): The name of the condensed phase photolysis reaction rate constant.
+        scaling_factor (float): The scaling factor for the photolysis rate constant.
+        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.
+        condensed_phase (Phase): The condensed phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the condensed phase photolysis reaction rate constant.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        scaling_factor: Optional[float] = None,
+        reactants: Optional[List[Union[Species,
+                                       Tuple[float, Species]]]] = None,
+        products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+        condensed_phase: Optional[Phase] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the CondensedPhasePhotolysis object with the given parameters.
+
+        Args:
+            name (str): The name of the condensed phase photolysis reaction rate constant.
+            scaling_factor (float): The scaling factor for the photolysis rate constant.
+            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.
+            condensed_phase (Phase): The condensed phase in which the reaction occurs.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the condensed phase photolysis 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.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.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": "CONDENSED_PHASE_PHOTOLYSIS",
+            "name": instance.name,
+            "scaling factor": instance.scaling_factor,
+            "reactants": ReactionComponentSerializer.serialize_list_reaction_components(instance.reactants),
+            "products": ReactionComponentSerializer.serialize_list_reaction_components(instance.products),
+            "condensed phase": instance.condensed_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return serialize_dict