musica 0.11.1.4__cp39-cp39-macosx_11_0_arm64.whl → 0.12.0__cp39-cp39-macosx_11_0_arm64.whl

musica/_version.py

@@ -1 +1 @@
-version = "0.11.1.4"
+version = "0.12.0"

musica/constants.py

@@ -0,0 +1,3 @@
+AVOGADRO = 6.02214076e23  # mol^-1
+BOLTZMANN = 1.380649e-23  # J K^-1
+GAS_CONSTANT = AVOGADRO * BOLTZMANN  # J K^-1 mol^-1

musica/mechanism_configuration/__init__.py

@@ -0,0 +1 @@
+from .mechanism_configuration import *

musica/mechanism_configuration/aqueous_equilibrium.py

@@ -0,0 +1,101 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _AqueousEquilibrium, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class AqueousEquilibrium(_AqueousEquilibrium):
+    """
+    A class representing an aqueous equilibrium reaction rate constant.
+
+    Attributes:
+        name (str): The name of the aqueous equilibrium reaction rate constant.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        aerosol_phase (Phase): The aerosol phase in which the reaction occurs.
+        aerosol_phase_water (Species): The water species in the aerosol phase.
+        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.
+        A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1].
+        C (float): Exponential term [K-1].
+        k_reverse (float): Reverse rate constant [(mol m-3)^(n-1)s-1].
+        other_properties (Dict[str, Any]): A dictionary of other properties of the aqueous equilibrium reaction rate constant.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        aerosol_phase: Optional[Phase] = None,
+        aerosol_phase_water: Optional[Species] = None,
+        reactants: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+        products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+        A: Optional[float] = None,
+        C: Optional[float] = None,
+        k_reverse: Optional[float] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the AqueousEquilibrium object with the given parameters.
+
+        Args:
+            name (str): The name of the aqueous equilibrium reaction rate constant.
+            aerosol_phase (Phase): The aerosol phase in which the reaction occurs.
+            aerosol_phase_water (Species): The water species in the aerosol phase.
+            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.
+            A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1].
+            C (float): Exponential term [K-1].
+            k_reverse (float): Reverse rate constant [(mol m-3)^(n-1)s-1].
+            other_properties (Dict[str, Any]): A dictionary of other properties of the aqueous equilibrium reaction rate constant.
+        """
+        super().__init__()
+        self.name = name if name is not None else self.name
+        self.aerosol_phase = aerosol_phase.name if aerosol_phase is not None else self.aerosol_phase
+        self.aerosol_phase_water = (
+            aerosol_phase_water.name if aerosol_phase_water is not None else self.aerosol_phase_water
+        )
+        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.A = A if A is not None else self.A
+        self.C = C if C is not None else self.C
+        self.k_reverse = k_reverse if k_reverse is not None else self.k_reverse
+        self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+    @staticmethod
+    def serialize(instance) -> Dict:
+        serialize_dict = {
+            "type": "AQUEOUS_EQUILIBRIUM",
+            "name": instance.name,
+            "aerosol phase": instance.aerosol_phase,
+            "aerosol-phase water": instance.aerosol_phase_water,
+            "reactants": ReactionComponentSerializer.serialize_list_reaction_components(instance.reactants),
+            "products": ReactionComponentSerializer.serialize_list_reaction_components(instance.products),
+            "A": instance.A,
+            "C": instance.C,
+            "k_reverse": instance.k_reverse,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/arrhenius.py

@@ -0,0 +1,121 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _Arrhenius, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+from musica.constants import BOLTZMANN
+
+
+class Arrhenius(_Arrhenius):
+    """
+    A class representing an Arrhenius rate constant.
+
+    k = A * exp( C / T ) * ( T / D )^B * exp( 1 - E * P )
+
+    where:
+        k = rate constant
+        A = pre-exponential factor [(mol m-3)^(n-1)s-1]
+        B = temperature exponent [unitless]
+        C = exponential term [K-1]
+        D = reference temperature [K]
+        E = pressure scaling term [Pa-1]
+        T = temperature [K]
+        P = pressure [Pa]
+        n = number of reactants
+
+    Attributes:
+        name (str): The name of the Arrhenius rate constant.
+        A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1] where n is the number of reactants.
+        B (float): Temperature exponent [unitless].
+        C (float): Exponential term [K-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.
+        gas_phase (Phase): The gas phase in which the reaction occurs.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the 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,
+        gas_phase: Optional[Phase] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the Arrhenius object with the given parameters.
+
+        Args:
+            name (str): The name of the Arrhenius rate constant.
+            A (float): Pre-exponential factor [(mol m-3)^(n-1)s-1] where n is the number of reactants.
+            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.
+            gas_phase (Phase): The gas phase in which the reaction occurs.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the Arrhenius 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
+        if C is not None and Ea is not None:
+            raise ValueError("Cannot specify both C and Ea.")
+        self.C = -Ea / BOLTZMANN if Ea is not None else 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.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": "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),
+            "gas phase": instance.gas_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/branched.py

@@ -0,0 +1,116 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _Branched, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class Branched(_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.
+        """
+        super().__init__()
+        self.name = name if name is not None else self.name
+        self.X = X if X is not None else self.X
+        self.Y = Y if Y is not None else self.Y
+        self.a0 = a0 if a0 is not None else self.a0
+        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.nitrate_products = (
+            [
+                (
+                    _ReactionComponent(p.name)
+                    if isinstance(p, Species)
+                    else _ReactionComponent(p[1].name, p[0])
+                )
+                for p in nitrate_products
+            ]
+            if nitrate_products is not None
+            else self.nitrate_products
+        )
+        self.alkoxy_products = (
+            [
+                (
+                    _ReactionComponent(p.name)
+                    if isinstance(p, Species)
+                    else _ReactionComponent(p[1].name, p[0])
+                )
+                for p in alkoxy_products
+            ]
+            if alkoxy_products is not None
+            else self.alkoxy_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": "BRANCHED_NO_RO2",
+            "name": instance.name,
+            "X": instance.X,
+            "Y": instance.Y,
+            "a0": instance.a0,
+            "n": instance.n,
+            "reactants": ReactionComponentSerializer.serialize_list_reaction_components(instance.reactants),
+            "nitrate products": ReactionComponentSerializer.serialize_list_reaction_components(instance.nitrate_products),
+            "alkoxy products": ReactionComponentSerializer.serialize_list_reaction_components(instance.alkoxy_products),
+            "gas phase": instance.gas_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/condensed_phase_arrhenius.py

@@ -0,0 +1,116 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _CondensedPhaseArrhenius, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+from musica.constants import BOLTZMANN
+
+
+class CondensedPhaseArrhenius(_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.
+        aerosol_phase (Phase): The aerosol phase in which the reaction occurs.
+        aerosol_phase_water (Species): The water species in the aerosol phase.
+        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,
+        aerosol_phase: Optional[Phase] = None,
+        aerosol_phase_water: Optional[Species] = 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.
+            aerosol_phase (Phase): The aerosol phase in which the reaction occurs.
+            aerosol_phase_water (Species): The water species in the aerosol phase.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the condensed phase Arrhenius 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
+        if C is not None and Ea is not None:
+            raise ValueError("Cannot specify both C and Ea.")
+        self.C = -Ea / BOLTZMANN if Ea is not None else 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.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.aerosol_phase = aerosol_phase.name if aerosol_phase is not None else self.aerosol_phase
+        self.aerosol_phase_water = (
+            aerosol_phase_water.name if aerosol_phase_water is not None else self.aerosol_phase_water
+        )
+        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_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),
+            "aerosol phase": instance.aerosol_phase,
+            "aerosol-phase water": instance.aerosol_phase_water,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/condensed_phase_photolysis.py

@@ -0,0 +1,91 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _CondensedPhasePhotolysis, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+
+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.
+        aerosol_phase (Phase): The aerosol phase in which the reaction occurs.
+        aerosol_phase_water (float): The water species in the aerosol phase [unitless].
+        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,
+        aerosol_phase: Optional[Phase] = None,
+        aerosol_phase_water: Optional[Species] = 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.
+            aerosol_phase (Phase): The aerosol phase in which the reaction occurs.
+            aerosol_phase_water (Species): The water species in the aerosol phase [unitless].
+            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.aerosol_phase = aerosol_phase.name if aerosol_phase is not None else self.aerosol_phase
+        self.aerosol_phase_water = (
+            aerosol_phase_water.name if aerosol_phase_water is not None else self.aerosol_phase_water
+        )
+        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),
+            "aerosol phase": instance.aerosol_phase,
+            "aerosol-phase water": instance.aerosol_phase_water,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/emission.py

@@ -0,0 +1,67 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _Emission, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class Emission(_Emission):
+    """
+    A class representing an emission reaction rate constant.
+
+    Attributes:
+        name (str): The name of the emission reaction rate constant.
+        scaling_factor (float): The scaling factor for the emission rate constant.
+        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 emission reaction rate constant.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        scaling_factor: Optional[float] = None,
+        products: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+        gas_phase: Optional[Phase] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the Emission object with the given parameters.
+
+        Args:
+            name (str): The name of the emission reaction rate constant.
+            scaling_factor (float): The scaling factor for the emission rate constant.
+            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 emission 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.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": "EMISSION",
+            "name": instance.name,
+            "scaling factor": instance.scaling_factor,
+            "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)