musica 0.11.1.3__cp310-cp310-win32.whl → 0.12.0__cp310-cp310-win32.whl

musica/mechanism_configuration/photolysis.py

@@ -0,0 +1,83 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _Photolysis, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class Photolysis(_Photolysis):
+    """
+    A class representing a photolysis 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.
+    """
+
+    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 Photolysis 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.
+        """
+        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.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
+
+    @staticmethod
+    def serialize(instance) -> Dict:
+        serialize_dict = {
+            "type": "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),
+            "gas phase": instance.gas_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/reactions.py

@@ -0,0 +1,61 @@
+from typing import Optional, Any, Dict, List, Union
+from musica import _ReactionType, _Reactions, _ReactionsIterator
+from .species import Species, _Species
+from .utils import _remove_empty_keys
+
+
+class ReactionType(_ReactionType):
+    """
+    A enum class representing a reaction type in a chemical mechanism.
+    """
+
+
+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.
+        """
+        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,88 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _SimpolPhaseTransfer, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class SimpolPhaseTransfer(_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.
+        aerosol_phase (Phase): The aerosol phase in which the reaction occurs.
+        aerosol_phase_species (Union[Species, Tuple[float, Species]]): The aerosol phase species involved in the reaction.
+        B (List[float]): The B parameters [unitless].
+        unknown_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,
+        aerosol_phase: Optional[Phase] = None,
+        aerosol_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.
+            aerosol_phase (Phase): The aerosol phase in which the reaction occurs.
+            aerosol_phase_species (Union[Species, Tuple[float, Species]]): The aerosol 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.
+        """
+        super().__init__()
+        self.name = name if name is not None else self.name
+        self.gas_phase = gas_phase.name if gas_phase is not None else self.gas_phase
+        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.aerosol_phase = aerosol_phase.name if aerosol_phase is not None else self.aerosol_phase
+        self.aerosol_phase_species = (
+            (
+                _ReactionComponent(aerosol_phase_species.name)
+                if isinstance(aerosol_phase_species, Species)
+                else _ReactionComponent(
+                    aerosol_phase_species[1].name, aerosol_phase_species[0]
+                )
+            )
+            if aerosol_phase_species is not None
+            else self.aerosol_phase_species
+        )
+        if B is not None:
+            if len(B) != 4:
+                raise ValueError("B must be a list of 4 elements.")
+            self.B = B
+        else:
+            self.B = [0, 0, 0, 0]
+        self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+    @staticmethod
+    def serialize(instance) -> Dict:
+        serialize_dict = {
+            "type": "SIMPOL_PHASE_TRANSFER",
+            "name": instance.name,
+            "gas phase": instance.gas_phase,
+            "gas-phase species": instance.gas_phase_species.species_name,
+            "aerosol phase": instance.aerosol_phase,
+            "aerosol-phase species": instance.aerosol_phase_species.species_name,
+            "B": instance.B,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/species.py

@@ -0,0 +1,72 @@
+from typing import Optional, Any, Dict
+from musica import _Species
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+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): The type of tracer ("AEROSOL", "THIRD_BODY", "CONSTANT").
+        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,
+        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): The type of tracer ("AEROSOL", "THIRD_BODY", "CONSTANT").
+            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.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,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/surface.py

@@ -0,0 +1,89 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _Surface, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+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.
+        aerosol_phase (Phase): The aerosol 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,
+        aerosol_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.
+            aerosol_phase (Phase): The aerosol 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.aerosol_phase = aerosol_phase.name if aerosol_phase is not None else self.aerosol_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,
+            "aerosol phase": instance.aerosol_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/troe.py

@@ -0,0 +1,137 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _Troe, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class Troe(_Troe):
+    """
+    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.
+    """
+
+    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.
+        """
+        super().__init__()
+        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.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
+
+    @staticmethod
+    def serialize(instance) -> Dict:
+        serialize_dict = {
+            "type": "TROE",
+            "name": instance.name,
+            "k0_A": instance.k0_A,
+            "k0_B": instance.k0_B,
+            "k0_C": instance.k0_C,
+            "kinf_A": instance.kinf_A,
+            "kinf_B": instance.kinf_B,
+            "kinf_C": instance.kinf_C,
+            "Fc": instance.Fc,
+            "N": instance.N,
+            "reactants": ReactionComponentSerializer.serialize_list_reaction_components(instance.reactants),
+            "products": ReactionComponentSerializer.serialize_list_reaction_components(instance.products),
+            "gas phase": instance.gas_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/tunneling.py

@@ -0,0 +1,103 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _Tunneling, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class Tunneling(_Tunneling):
+    """
+    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.
+    """
+
+    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.
+        """
+        super().__init__()
+        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.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
+
+    @staticmethod
+    def serialize(instance) -> Dict:
+        serialize_dict = {
+            "type": "TUNNELING",
+            "name": instance.name,
+            "A": instance.A,
+            "B": instance.B,
+            "C": instance.C,
+            "reactants": ReactionComponentSerializer.serialize_list_reaction_components(instance.reactants),
+            "products": ReactionComponentSerializer.serialize_list_reaction_components(instance.products),
+            "gas phase": instance.gas_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)