musica 0.11.1.4__cp312-cp312-macosx_11_0_arm64.whl → 0.12.0__cp312-cp312-macosx_11_0_arm64.whl

musica/mechanism_configuration/first_order_loss.py

@@ -0,0 +1,67 @@
+from typing import Optional, Any, Dict, List, Union, Tuple
+from musica import _FirstOrderLoss, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .reactions import ReactionComponentSerializer
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class FirstOrderLoss(_FirstOrderLoss):
+    """
+    A class representing a first-order loss reaction rate constant.
+
+    Attributes:
+        name (str): The name of the first-order loss reaction rate constant.
+        scaling_factor (float): The scaling factor for the first-order loss rate constant.
+        reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved 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 first-order loss reaction rate constant.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        scaling_factor: Optional[float] = None,
+        reactants: Optional[List[Union[Species, Tuple[float, Species]]]] = None,
+        gas_phase: Optional[Phase] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the FirstOrderLoss object with the given parameters.
+
+        Args:
+            name (str): The name of the first-order loss reaction rate constant.
+            scaling_factor (float): The scaling factor for the first-order loss rate constant.
+            reactants (List[Union[Species, Tuple[float, Species]]]): A list of reactants involved 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 first-order loss 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.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": "FIRST_ORDER_LOSS",
+            "name": instance.name,
+            "scaling factor": instance.scaling_factor,
+            "reactants": ReactionComponentSerializer.serialize_list_reaction_components(instance.reactants),
+            "gas phase": instance.gas_phase,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/henrys_law.py

@@ -0,0 +1,85 @@
+from typing import Optional, Any, Dict, Union, Tuple
+from musica import _HenrysLaw, _ReactionComponent
+from .phase import Phase
+from .species import Species
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class HenrysLaw(_HenrysLaw):
+    """
+    A class representing a Henry's law reaction rate constant.
+
+    Attributes:
+        name (str): The name of the Henry's law 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_water (Species): The water species in the aerosol phase.
+        aerosol_phase_species (Union[Species, Tuple[float, Species]]): The aerosol phase species involved in the reaction.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the Henry's law 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_water: Optional[Species] = None,
+        aerosol_phase_species: Optional[Union[Species, Tuple[float, Species]]] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the HenrysLaw object with the given parameters.
+
+        Args:
+            name (str): The name of the Henry's law 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_water (Species): The water species in the aerosol phase.
+            aerosol_phase_species (Union[Species, Tuple[float, Species]]): The aerosol phase species involved in the reaction.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the Henry's law 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_water = (
+            aerosol_phase_water.name if aerosol_phase_water is not None else self.aerosol_phase_water
+        )
+        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
+        )
+        self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+    @staticmethod
+    def serialize(instance) -> Dict:
+        serialize_dict = {
+            "type": "HL_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 water": instance.aerosol_phase_water,
+            "aerosol-phase species": instance.aerosol_phase_species.species_name,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/mechanism_configuration.py

@@ -0,0 +1,161 @@
+# Copyright (C) 2025 University Corporation for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of the musica Python package.
+# For more information, see the LICENSE file in the top-level directory of this distribution.
+import os
+import json
+import yaml
+from typing import Optional, Any, Dict, List
+from musica import _Mechanism, _Version, _Parser
+from .species import Species
+from .phase import Phase
+from .arrhenius import Arrhenius, _Arrhenius
+from .condensed_phase_arrhenius import CondensedPhaseArrhenius, _CondensedPhaseArrhenius
+from .troe import Troe, _Troe
+from .branched import Branched, _Branched
+from .tunneling import Tunneling, _Tunneling
+from .surface import Surface, _Surface
+from .photolysis import Photolysis, _Photolysis
+from .condensed_phase_photolysis import CondensedPhasePhotolysis, _CondensedPhasePhotolysis
+from .emission import Emission, _Emission
+from .first_order_loss import FirstOrderLoss, _FirstOrderLoss
+from .aqueous_equilibrium import AqueousEquilibrium, _AqueousEquilibrium
+from .wet_deposition import WetDeposition, _WetDeposition
+from .henrys_law import HenrysLaw, _HenrysLaw
+from .simpol_phase_transfer import SimpolPhaseTransfer, _SimpolPhaseTransfer
+from .user_defined import UserDefined, _UserDefined
+from .reactions import Reactions, ReactionType
+
+
+class Version(_Version):
+    """
+    A class representing the version of the mechanism.
+    """
+
+
+class Mechanism(_Mechanism):
+    """
+    A class representing a chemical mechanism.
+
+    Attributes:
+        name (str): The name of the mechanism.
+        reactions (List[Reaction]): A list of reactions in the mechanism.
+        species (List[Species]): A list of species in the mechanism.
+        phases (List[Phase]): A list of phases in the mechanism.
+        version (Version): The version of the mechanism.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        reactions: Optional[List[Any]] = None,
+        species: Optional[List[Species]] = None,
+        phases: Optional[List[Phase]] = None,
+        version: Optional[Version] = None,
+    ):
+        """
+        Initializes the Mechanism object with the given parameters.
+
+        Args:
+            name (str): The name of the mechanism.
+            reactions (List[]): A list of reactions in the mechanism.
+            species (List[Species]): A list of species in the mechanism.
+            phases (List[Phase]): A list of phases in the mechanism.
+            version (Version): The version of the mechanism.
+        """
+        super().__init__()
+        self.name = name
+        self.species = species if species is not None else []
+        self.phases = phases if phases is not None else []
+        self.reactions = Reactions(reactions=reactions if reactions is not None else [])
+        self.version = version if version is not None else Version()
+
+    def to_dict(self) -> Dict:
+        species_list = []
+        for species in self.species:
+            species_list.append(Species.serialize(species))
+
+        phases_list = []
+        for phase in self.phases:
+            phases_list.append(Phase.serialize(phase))
+
+        reactions_list = []
+        for reaction in self.reactions:
+            if isinstance(reaction, (_Arrhenius, Arrhenius)):
+                reactions_list.append(Arrhenius.serialize(reaction))
+            elif isinstance(reaction, (_Branched, Branched)):
+                reactions_list.append(Branched.serialize(reaction))
+            elif isinstance(reaction, (_CondensedPhaseArrhenius, CondensedPhaseArrhenius)):
+                reactions_list.append(CondensedPhaseArrhenius.serialize(reaction))
+            elif isinstance(reaction, (_CondensedPhasePhotolysis, CondensedPhasePhotolysis)):
+                reactions_list.append(CondensedPhasePhotolysis.serialize(reaction))
+            elif isinstance(reaction, (_Emission, Emission)):
+                reactions_list.append(Emission.serialize(reaction))
+            elif isinstance(reaction, (_FirstOrderLoss, FirstOrderLoss)):
+                reactions_list.append(FirstOrderLoss.serialize(reaction))
+            elif isinstance(reaction, (_SimpolPhaseTransfer, SimpolPhaseTransfer)):
+                reactions_list.append(SimpolPhaseTransfer.serialize(reaction))
+            elif isinstance(reaction, (_AqueousEquilibrium, AqueousEquilibrium)):
+                reactions_list.append(AqueousEquilibrium.serialize(reaction))
+            elif isinstance(reaction, (_WetDeposition, WetDeposition)):
+                reactions_list.append(WetDeposition.serialize(reaction))
+            elif isinstance(reaction, (_HenrysLaw, HenrysLaw)):
+                reactions_list.append(HenrysLaw.serialize(reaction))
+            elif isinstance(reaction, (_Photolysis, Photolysis)):
+                reactions_list.append(Photolysis.serialize(reaction))
+            elif isinstance(reaction, (_Surface, Surface)):
+                reactions_list.append(Surface.serialize(reaction))
+            elif isinstance(reaction, (_Troe, Troe)):
+                reactions_list.append(Troe.serialize(reaction))
+            elif isinstance(reaction, (_Tunneling, Tunneling)):
+                reactions_list.append(Tunneling.serialize(reaction))
+            elif isinstance(reaction, (_UserDefined, UserDefined)):
+                reactions_list.append(UserDefined.serialize(reaction))
+            else:
+                raise TypeError(f'Reaction type {type(reaction)} is not supported for export.')
+
+        return {
+            "name": self.name,
+            "reactions": reactions_list,
+            "species": species_list,
+            "phases": phases_list,
+            "version": self.version.to_string(),
+        }
+
+    def export(self, file_path: str) -> None:
+        MechanismSerializer.serialize(self, file_path)
+
+
+class Parser(_Parser):
+    """
+    A class for parsing a chemical mechanism.
+    """
+
+
+class MechanismSerializer():
+    """
+    A class for exporting a chemical mechanism.
+    """
+
+    @staticmethod
+    def serialize(mechanism: Mechanism, file_path: str = "./mechanism.json") -> None:        
+        if not isinstance(mechanism, Mechanism):
+            raise TypeError(f"Object {mechanism} is not of type Mechanism.")
+
+        directory, file = os.path.split(file_path)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+        dictionary = mechanism.to_dict()
+        
+        _, file_ext = os.path.splitext(file)
+        file_ext = file_ext.lower()
+        if file_ext in ['.yaml', '.yml']:
+            with open(file_path, 'w') as file:
+                yaml.dump(dictionary, file)
+        elif '.json' == file_ext:
+            json_str = json.dumps(dictionary, indent=4)
+            with open(file_path, 'w') as file:
+                file.write(json_str)
+        else:
+            raise Exception('Allowable write formats are .json, .yaml, and .yml')

musica/mechanism_configuration/phase.py

@@ -0,0 +1,43 @@
+from typing import Optional, Any, Dict, List
+from musica import _Phase
+from .species import Species
+from .utils import _add_other_properties, _remove_empty_keys
+
+
+class Phase(_Phase):
+    """
+    A class representing a phase in a chemical mechanism.
+
+    Attributes:
+        name (str): The name of the phase.
+        species (List[Species]): A list of species in the phase.
+        other_properties (Dict[str, Any]): A dictionary of other properties of the phase.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        species: Optional[List[Species]] = None,
+        other_properties: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initializes the Phase object with the given parameters.
+
+        Args:
+            name (str): The name of the phase.
+            species (List[Species]): A list of species in the phase.
+            other_properties (Dict[str, Any]): A dictionary of other properties of the phase.
+        """
+        super().__init__()
+        self.name = name if name is not None else self.name
+        self.species = [s.name for s in species] if species is not None else self.species
+        self.other_properties = other_properties if other_properties is not None else self.other_properties
+
+    @staticmethod
+    def serialize(instance):
+        serialize_dict = {
+            "name": instance.name,
+            "species": instance.species,
+        }
+        _add_other_properties(serialize_dict, instance.other_properties)
+        return _remove_empty_keys(serialize_dict)

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)