musica 0.11.1.1__cp312-cp312-win_amd64.whl → 0.14.2__cp312-cp312-win_amd64.whl

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

musica/mechanism_configuration/ternary_chemical_activation.py

@@ -0,0 +1,160 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .phase import Phase
+from .species import Species
+from .utils import _add_other_properties, _remove_empty_keys
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+TernaryChemicalActivation = _backend._mechanism_configuration._TernaryChemicalActivation
+
+original_init = TernaryChemicalActivation.__init__
+
+
+@property
+def type(self):
+    return ReactionType.TernaryChemicalActivation
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    k0_A: Optional[float] = None,
+    k0_B: Optional[float] = None,
+    k0_C: Optional[float] = None,
+    kinf_A: Optional[float] = None,
+    kinf_B: Optional[float] = None,
+    kinf_C: Optional[float] = None,
+    Fc: Optional[float] = None,
+    N: Optional[float] = None,
+    reactants: Optional[List[Union[Species,
+                                   Tuple[float, Species]]]] = None,
+    products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+    gas_phase: Optional[Phase] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the Ternary Chemical Activation object with the given parameters.
+
+    k0 = k0_A * exp( k0_C / T ) * ( T / 300.0 )^k0_B
+    kinf = kinf_A * exp( kinf_C / T ) * ( T / 300.0 )^kinf_B
+    k = k0[M] / ( 1 + k0[M] / kinf ) * Fc^(1 + 1/N*(log10(k0[M]/kinf))^2)^-1
+
+    where:
+        k = rate constant
+        k0 = low-pressure limit rate constant
+        kinf = high-pressure limit rate constant
+        k0_A = pre-exponential factor for the low-pressure limit [(mol m-3)^(n-1)s-1]
+        k0_B = temperature exponent for the low-pressure limit [unitless]
+        k0_C = exponential term for the low-pressure limit [K-1]
+        kinf_A = pre-exponential factor for the high-pressure limit [(mol m-3)^(n-1)s-1]
+        kinf_B = temperature exponent for the high-pressure limit [unitless]
+        kinf_C = exponential term for the high-pressure limit [K-1]
+        Fc = Ternary Chemical Activation parameter [unitless]
+        N = Ternary Chemical Activation parameter [unitless]
+        T = temperature [K]
+        M = concentration of the third body [mol m-3]
+
+    Args:
+        name (str): The name of the Ternary Chemical Activation rate constant.
+        k0_A (float): Pre-exponential factor for the low-pressure limit [(mol m-3)^(n-1)s-1].
+        k0_B (float): Temperature exponent for the low-pressure limit [unitless].
+        k0_C (float): Exponential term for the low-pressure limit [K-1].
+        kinf_A (float): Pre-exponential factor for the high-pressure limit [(mol m-3)^(n-1)s-1].
+        kinf_B (float): Temperature exponent for the high-pressure limit [unitless].
+        kinf_C (float): Exponential term for the high-pressure limit [K-1].
+        Fc (float): Ternary Chemical Activation parameter [unitless].
+        N (float): Ternary Chemical Activation parameter [unitless].
+        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 Ternary Chemical Activation rate constant.
+    """
+    original_init(self)
+
+    self.name = name if name is not None else self.name
+    self.k0_A = k0_A if k0_A is not None else self.k0_A
+    self.k0_B = k0_B if k0_B is not None else self.k0_B
+    self.k0_C = k0_C if k0_C is not None else self.k0_C
+    self.kinf_A = kinf_A if kinf_A is not None else self.kinf_A
+    self.kinf_B = kinf_B if kinf_B is not None else self.kinf_B
+    self.kinf_C = kinf_C if kinf_C is not None else self.kinf_C
+    self.Fc = Fc if Fc is not None else self.Fc
+    self.N = N if N is not None else self.N
+    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
+    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
+    )
+
+
+def serialize(self) -> Dict:
+    """
+    Serialize the Ternary Chemical Activation object to a dictionary using only Python-visible data.
+
+    Returns:
+        Dict: A dictionary representation of the Ternary Chemical Activation object.
+    """
+    serialize_dict = {
+        "type": "TERNARY_CHEMICAL_ACTIVATION",
+        "name": self.name,
+        "k0_A": self.k0_A,
+        "k0_B": self.k0_B,
+        "k0_C": self.k0_C,
+        "kinf_A": self.kinf_A,
+        "kinf_B": self.kinf_B,
+        "kinf_C": self.kinf_C,
+        "Fc": self.Fc,
+        "N": self.N,
+        "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)
+
+
+TernaryChemicalActivation.__doc__ = """
+A class representing a Ternary Chemical Activation rate constant.
+
+Attributes:
+    name (str): The name of the Ternary Chemical Activation rate constant.
+    k0_A (float): Pre-exponential factor for the low-pressure limit [(mol m-3)^(n-1)s-1].
+    k0_B (float): Temperature exponent for the low-pressure limit [unitless].
+    k0_C (float): Exponential term for the low-pressure limit [K-1].
+    kinf_A (float): Pre-exponential factor for the high-pressure limit [(mol m-3)^(n-1)s-1].
+    kinf_B (float): Temperature exponent for the high-pressure limit [unitless].
+    kinf_C (float): Exponential term for the high-pressure limit [K-1].
+    Fc (float): Ternary Chemical Activation parameter [unitless].
+    N (float): Ternary Chemical Activation parameter [unitless].
+    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 Ternary Chemical Activation rate constant.
+"""
+
+TernaryChemicalActivation.__init__ = __init__
+TernaryChemicalActivation.serialize = serialize
+TernaryChemicalActivation.type = type

musica/mechanism_configuration/troe.py

@@ -0,0 +1,160 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .phase import Phase
+from .species import Species
+from .utils import _add_other_properties, _remove_empty_keys
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+Troe = _backend._mechanism_configuration._Troe
+
+original_init = Troe.__init__
+
+
+@property
+def type(self):
+    return ReactionType.Troe
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    k0_A: Optional[float] = None,
+    k0_B: Optional[float] = None,
+    k0_C: Optional[float] = None,
+    kinf_A: Optional[float] = None,
+    kinf_B: Optional[float] = None,
+    kinf_C: Optional[float] = None,
+    Fc: Optional[float] = None,
+    N: Optional[float] = None,
+    reactants: Optional[List[Union[Species,
+                                   Tuple[float, Species]]]] = None,
+    products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+    gas_phase: Optional[Phase] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the Troe object with the given parameters.
+
+    k0 = k0_A * exp( k0_C / T ) * ( T / 300.0 )^k0_B
+    kinf = kinf_A * exp( kinf_C / T ) * ( T / 300.0 )^kinf_B
+    k = k0[M] / ( 1 + k0[M] / kinf ) * Fc^(1 + 1/N*(log10(k0[M]/kinf))^2)^-1
+
+    where:
+        k = rate constant
+        k0 = low-pressure limit rate constant
+        kinf = high-pressure limit rate constant
+        k0_A = pre-exponential factor for the low-pressure limit [(mol m-3)^(n-1)s-1]
+        k0_B = temperature exponent for the low-pressure limit [unitless]
+        k0_C = exponential term for the low-pressure limit [K-1]
+        kinf_A = pre-exponential factor for the high-pressure limit [(mol m-3)^(n-1)s-1]
+        kinf_B = temperature exponent for the high-pressure limit [unitless]
+        kinf_C = exponential term for the high-pressure limit [K-1]
+        Fc = Troe parameter [unitless]
+        N = Troe parameter [unitless]
+        T = temperature [K]
+        M = concentration of the third body [mol m-3]
+
+    Args:
+        name (str): The name of the Troe rate constant.
+        k0_A (float): Pre-exponential factor for the low-pressure limit [(mol m-3)^(n-1)s-1].
+        k0_B (float): Temperature exponent for the low-pressure limit [unitless].
+        k0_C (float): Exponential term for the low-pressure limit [K-1].
+        kinf_A (float): Pre-exponential factor for the high-pressure limit [(mol m-3)^(n-1)s-1].
+        kinf_B (float): Temperature exponent for the high-pressure limit [unitless].
+        kinf_C (float): Exponential term for the high-pressure limit [K-1].
+        Fc (float): Troe parameter [unitless].
+        N (float): Troe parameter [unitless].
+        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 Troe rate constant.
+    """
+    original_init(self)
+
+    self.name = name if name is not None else self.name
+    self.k0_A = k0_A if k0_A is not None else self.k0_A
+    self.k0_B = k0_B if k0_B is not None else self.k0_B
+    self.k0_C = k0_C if k0_C is not None else self.k0_C
+    self.kinf_A = kinf_A if kinf_A is not None else self.kinf_A
+    self.kinf_B = kinf_B if kinf_B is not None else self.kinf_B
+    self.kinf_C = kinf_C if kinf_C is not None else self.kinf_C
+    self.Fc = Fc if Fc is not None else self.Fc
+    self.N = N if N is not None else self.N
+    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
+    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
+    )
+
+
+def serialize(self) -> Dict:
+    """
+    Serialize the Troe object to a dictionary using only Python-visible data.
+
+    Returns:
+        Dict: A dictionary representation of the Troe object.
+    """
+    serialize_dict = {
+        "type": "TROE",
+        "name": self.name,
+        "k0_A": self.k0_A,
+        "k0_B": self.k0_B,
+        "k0_C": self.k0_C,
+        "kinf_A": self.kinf_A,
+        "kinf_B": self.kinf_B,
+        "kinf_C": self.kinf_C,
+        "Fc": self.Fc,
+        "N": self.N,
+        "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)
+
+
+Troe.__doc__ = """
+A class representing a Troe rate constant.
+
+Attributes:
+    name (str): The name of the Troe rate constant.
+    k0_A (float): Pre-exponential factor for the low-pressure limit [(mol m-3)^(n-1)s-1].
+    k0_B (float): Temperature exponent for the low-pressure limit [unitless].
+    k0_C (float): Exponential term for the low-pressure limit [K-1].
+    kinf_A (float): Pre-exponential factor for the high-pressure limit [(mol m-3)^(n-1)s-1].
+    kinf_B (float): Temperature exponent for the high-pressure limit [unitless].
+    kinf_C (float): Exponential term for the high-pressure limit [K-1].
+    Fc (float): Troe parameter [unitless].
+    N (float): Troe parameter [unitless].
+    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 Troe rate constant.
+"""
+
+Troe.__init__ = __init__
+Troe.serialize = serialize
+Troe.type = type

musica/mechanism_configuration/tunneling.py

@@ -0,0 +1,126 @@
+from .utils import _add_other_properties, _remove_empty_keys
+from .species import Species
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+Tunneling = _backend._mechanism_configuration._Tunneling
+
+original_init = Tunneling.__init__
+
+
+@property
+def type(self):
+    return ReactionType.Tunneling
+
+
+def __init__(
+    self,
+    name: Optional[str] = None,
+    A: Optional[float] = None,
+    B: Optional[float] = None,
+    C: Optional[float] = None,
+    reactants: Optional[List[Union[Species,
+                                   Tuple[float, Species]]]] = None,
+    products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+    gas_phase: Optional[Phase] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the Tunneling object with the given parameters.
+
+    Args:
+        name (str): The name of the tunneling reaction rate constant.
+        A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1].
+        B (float): Tunneling parameter [K^-1].
+        C (float): Tunneling parameter [K^-3].
+        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 tunneling reaction rate constant.
+    """
+    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.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
+    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
+    )
+
+
+def serialize(self) -> Dict:
+    """
+    Serialize the Tunneling object to a dictionary using only Python-visible data.
+
+    Returns:
+        Dict: A dictionary representation of the Tunneling object.
+    """
+    serialize_dict = {
+        "type": "TUNNELING",
+        "name": self.name,
+        "A": self.A,
+        "B": self.B,
+        "C": self.C,
+        "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)
+
+
+Tunneling.__doc__ = """
+A class representing a quantum tunneling reaction rate constant.
+
+k = A * exp( -B / T ) * exp( C / T^3 )
+
+where:
+    k = rate constant
+    A = pre-exponential factor [(mol m-3)^(n-1)s-1]
+    B = tunneling parameter [K^-1]
+    C = tunneling parameter [K^-3]
+    T = temperature [K]
+    n = number of reactants
+
+Attributes:
+    name (str): The name of the tunneling reaction rate constant.
+    A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1].
+    B (float): Tunneling parameter [K^-1].
+    C (float): Tunneling parameter [K^-3].
+    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 tunneling reaction rate constant.
+"""
+
+Tunneling.__init__ = __init__
+Tunneling.serialize = serialize
+Tunneling.type = type

musica/mechanism_configuration/user_defined.py

@@ -0,0 +1,99 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+from .phase import Phase
+from .species import Species
+from .utils import _add_other_properties, _remove_empty_keys
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
+
+_backend = backend.get_backend()
+UserDefined = _backend._mechanism_configuration._UserDefined
+
+original_init = UserDefined.__init__
+
+
+@property
+def type(self):
+    return ReactionType.UserDefined
+
+
+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,
+    gas_phase: Optional[Phase] = None,
+    other_properties: Optional[Dict[str, Any]] = None,
+):
+    """
+    Initializes the UserDefined object with the given parameters.
+
+    Args:
+        name (str): The name of the 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.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the photolysis reaction rate constant.
+    """
+    original_init(self)
+    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.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": "USER_DEFINED",
+        "name": self.name,
+        "scaling factor": self.scaling_factor,
+        "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)
+
+
+UserDefined.__doc__ = """
+A class representing a user-defined reaction rate constant.
+
+Attributes:
+    name (str): The name of the 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.
+    gas_phase (Phase): The gas phase in which the reaction occurs.
+    other_properties (Dict[str, Any]): A dictionary of other properties of the photolysis reaction rate constant.
+"""
+
+UserDefined.__init__ = __init__
+UserDefined.serialize = serialize
+UserDefined.type = type

musica/mechanism_configuration/utils.py

@@ -0,0 +1,10 @@
+from typing import Dict
+
+
+def _remove_empty_keys(dictionary: Dict) -> Dict:
+    return {k: v for k, v in dictionary.items() if v is not None and v != "" and v != [] and v != {}}
+
+
+def _add_other_properties(serialize_dict: Dict, other_properties: Dict) -> None:
+    for key in other_properties:
+        serialize_dict[key] = other_properties[key]