musica 0.12.0__cp312-cp312-win_amd64.whl → 0.12.2__cp312-cp312-win_amd64.whl

musica/mechanism_configuration/simpol_phase_transfer.py

@@ -1,11 +1,16 @@
-from typing import Optional, Any, Dict, List, Union, Tuple
-from musica import _SimpolPhaseTransfer, _ReactionComponent
-from .phase import Phase
+from .utils import _add_other_properties
 from .species import Species
-from .utils import _add_other_properties, _remove_empty_keys
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+
+_backend = backend.get_backend()
+_SimpolPhaseTransfer = _backend._mechanism_configuration._SimpolPhaseTransfer
+_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
+ReactionType = _backend._mechanism_configuration._ReactionType
 
 
-class SimpolPhaseTransfer(_SimpolPhaseTransfer):
+class SimpolPhaseTransfer:
     """
     A class representing a simplified phase transfer reaction rate constant.
 
@@ -13,19 +18,21 @@ class SimpolPhaseTransfer(_SimpolPhaseTransfer):
         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.
+        condensed_phase (Phase): The condensed phase in which the reaction occurs.
+        condensed_phase_species (Union[Species, Tuple[float, Species]]): The condensed 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.
+        other_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,
+        gas_phase_species: Optional[Union[Species,
+                                          Tuple[float, Species]]] = None,
+        condensed_phase: Optional[Phase] = None,
+        condensed_phase_species: Optional[Union[Species,
+                                                Tuple[float, Species]]] = None,
         B: Optional[List[float]] = None,
         other_properties: Optional[Dict[str, Any]] = None,
     ):
@@ -36,53 +43,175 @@ class SimpolPhaseTransfer(_SimpolPhaseTransfer):
             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.
+            condensed_phase (Phase): The condensed phase in which the reaction occurs.
+            condensed_phase_species (Union[Species, Tuple[float, Species]]): The condensed 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
-        )
+        # Create the internal C++ instance
+        self._instance = _SimpolPhaseTransfer()
+
+        # Set all parameters
+        if name is not None:
+            self.name = name
+        if gas_phase is not None:
+            self.gas_phase = gas_phase
+        if gas_phase_species is not None:
+            self.gas_phase_species = gas_phase_species
+        if condensed_phase is not None:
+            self.condensed_phase = condensed_phase
+        if condensed_phase_species is not None:
+            self.condensed_phase_species = condensed_phase_species
         if B is not None:
-            if len(B) != 4:
-                raise ValueError("B must be a list of 4 elements.")
             self.B = B
+        if other_properties is not None:
+            self.other_properties = other_properties
+
+    # Property delegation to self._instance
+    @property
+    def name(self) -> str:
+        """Get the name of the simplified phase transfer reaction rate constant."""
+        return self._instance.name
+
+    @name.setter
+    def name(self, value: str):
+        """Set the name of the simplified phase transfer reaction rate constant."""
+        self._instance.name = value
+
+    @property
+    def gas_phase(self) -> str:
+        """Get the gas phase name."""
+        return self._instance.gas_phase
+
+    @gas_phase.setter
+    def gas_phase(self, value: Union[Phase, str]):
+        """Set the gas phase."""
+        if isinstance(value, Phase):
+            self._instance.gas_phase = value.name
+        elif isinstance(value, str):
+            self._instance.gas_phase = value
         else:
-            self.B = [0, 0, 0, 0]
-        self.other_properties = other_properties if other_properties is not None else self.other_properties
+            raise ValueError(f"Invalid gas_phase type: {type(value)}")
 
-    @staticmethod
-    def serialize(instance) -> Dict:
+    @property
+    def gas_phase_species(self) -> Union[Species, Tuple[float, Species]]:
+        """Get the gas phase species as Python object."""
+        rc = self._instance.gas_phase_species
+        if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
+            # Create a tuple with coefficient and species
+            species = Species(name=rc.species_name)
+            return (rc.coefficient, species)
+        else:
+            # Just the species
+            return Species(name=rc.species_name)
+
+    @gas_phase_species.setter
+    def gas_phase_species(self, value: Union[Species, Tuple[float, Species]]):
+        """Set the gas phase species, converting from Python to C++ object."""
+        if isinstance(value, Species):
+            self._instance.gas_phase_species = _ReactionComponent(value.name)
+        elif isinstance(value, tuple) and len(value) == 2:
+            coefficient, species = value
+            self._instance.gas_phase_species = _ReactionComponent(species.name, coefficient)
+        else:
+            raise ValueError(f"Invalid gas_phase_species format: {value}")
+
+    @property
+    def condensed_phase(self) -> str:
+        """Get the condensed phase name."""
+        return self._instance.condensed_phase
+
+    @condensed_phase.setter
+    def condensed_phase(self, value: Union[Phase, str]):
+        """Set the condensed phase."""
+        if isinstance(value, Phase):
+            self._instance.condensed_phase = value.name
+        elif isinstance(value, str):
+            self._instance.condensed_phase = value
+        else:
+            raise ValueError(f"Invalid condensed_phase type: {type(value)}")
+
+    @property
+    def condensed_phase_species(self) -> Union[Species, Tuple[float, Species]]:
+        """Get the condensed phase species as Python object."""
+        rc = self._instance.condensed_phase_species
+        if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
+            # Create a tuple with coefficient and species
+            species = Species(name=rc.species_name)
+            return (rc.coefficient, species)
+        else:
+            # Just the species
+            return Species(name=rc.species_name)
+
+    @condensed_phase_species.setter
+    def condensed_phase_species(self, value: Union[Species, Tuple[float, Species]]):
+        """Set the condensed phase species, converting from Python to C++ object."""
+        if isinstance(value, Species):
+            self._instance.condensed_phase_species = _ReactionComponent(value.name)
+        elif isinstance(value, tuple) and len(value) == 2:
+            coefficient, species = value
+            self._instance.condensed_phase_species = _ReactionComponent(species.name, coefficient)
+        else:
+            raise ValueError(f"Invalid condensed_phase_species format: {value}")
+
+    @property
+    def B(self) -> List[float]:
+        """Get the B parameters."""
+        return self._instance.B
+
+    @B.setter
+    def B(self, value: List[float]):
+        """Set the B parameters with validation."""
+        if not isinstance(value, list) or len(value) != 4:
+            raise ValueError("B must be a list of 4 elements.")
+        self._instance.B = value
+
+    @property
+    def other_properties(self) -> Dict[str, Any]:
+        """Get the other properties."""
+        return self._instance.other_properties
+
+    @other_properties.setter
+    def other_properties(self, value: Dict[str, Any]):
+        """Set the other properties."""
+        self._instance.other_properties = value
+
+    @property
+    def type(self):
+        """Get the reaction type."""
+        return ReactionType.SimpolPhaseTransfer
+
+    def serialize(self) -> Dict:
+        """
+        Serialize the SimpolPhaseTransfer object to a dictionary using only Python-visible data.
+
+        Returns:
+            Dict: A dictionary representation of the SimpolPhaseTransfer object.
+        """
         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,
+            "name": self._instance.name,
+            "gas phase": self._instance.gas_phase,
+            "gas-phase species": self._instance.gas_phase_species.species_name,
+            "condensed phase": self._instance.condensed_phase,
+            "condensed-phase species": self._instance.condensed_phase_species.species_name,
+            "B": self._instance.B,
         }
-        _add_other_properties(serialize_dict, instance.other_properties)
-        return _remove_empty_keys(serialize_dict)
+        _add_other_properties(serialize_dict, self.other_properties)
+        return serialize_dict
+
+    @staticmethod
+    def serialize_static(instance) -> Dict:
+        """
+        Static serialize method for compatibility with C++ _SimpolPhaseTransfer objects.
+
+        Args:
+            instance: The _SimpolPhaseTransfer instance to serialize.
+
+        Returns:
+            Dict: A dictionary representation of the SimpolPhaseTransfer object.
+        """
+        # Create a local copy to call serialize
+        temp_obj = SimpolPhaseTransfer()
+        temp_obj._instance = instance
+        return temp_obj.serialize()

musica/mechanism_configuration/species.py

@@ -1,6 +1,10 @@
 from typing import Optional, Any, Dict
-from musica import _Species
+from .. import backend
 from .utils import _add_other_properties, _remove_empty_keys
+from enum import Enum
+
+_backend = backend.get_backend()
+_Species = _backend._mechanism_configuration._Species
 
 
 class Species(_Species):
@@ -15,7 +19,10 @@ class Species(_Species):
         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").
+        tracer_type (str): Type of tracer: 'THIRD_BODY' or None [Deprecated, use is_third_body instead]
+        constant_concentration_mol_m3 (float): Constant concentration of the species (mol m-3)
+        constant_mixing_ratio_mol_mol (float): Constant mixing ratio of the species (mol mol-1)
+        is_third_body (bool): Whether the species is a third body.
         other_properties (Dict[str, Any]): A dictionary of other properties of the species.
     """
 
@@ -28,7 +35,10 @@ class Species(_Species):
         N_star: Optional[float] = None,
         molecular_weight_kg_mol: Optional[float] = None,
         density_kg_m3: Optional[float] = None,
-        tracer_type: Optional[str] = None,
+        tracer_type: Optional[str] = None,  # Deprecated use is_third_body instead
+        constant_concentration_mol_m3: Optional[float] = None,
+        constant_mixing_ratio_mol_mol: Optional[float] = None,
+        is_third_body: Optional[bool] = False,
         other_properties: Optional[Dict[str, Any]] = None,
     ):
         """
@@ -42,7 +52,10 @@ class Species(_Species):
             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").
+            tracer_type (str): Type of tracer: 'THIRD_BODY' or None [Deprecated, use is_third_body instead]
+            constant_concentration_mol_m3 (float): Constant concentration of the species (mol m-3)
+            constant_mixing_ratio_mol_mol (float): Constant mixing ratio of the species (mol mol-1)
+            is_third_body (bool): Whether the species is a third body.
             other_properties (Dict[str, Any]): A dictionary of other properties of the species.
         """
         super().__init__()
@@ -54,6 +67,9 @@ class Species(_Species):
         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.constant_concentration_mol_m3 = constant_concentration_mol_m3 if constant_concentration_mol_m3 is not None else self.constant_concentration_mol_m3
+        self.constant_mixing_ratio_mol_mol = constant_mixing_ratio_mol_mol if constant_mixing_ratio_mol_mol is not None else self.constant_mixing_ratio_mol_mol
+        self.is_third_body = is_third_body if is_third_body is not None else self.is_third_body
         self.other_properties = other_properties if other_properties is not None else self.other_properties
 
     @staticmethod
@@ -67,6 +83,9 @@ class Species(_Species):
             "molecular weight [kg mol-1]": instance.molecular_weight_kg_mol,
             "density [kg m-3]": instance.density_kg_m3,
             "tracer type": instance.tracer_type,
+            "constant concentration [mol m-3]": instance.constant_concentration_mol_m3,
+            "constant mixing ratio [mol mol-1]": instance.constant_mixing_ratio_mol_mol,
+            "is third body": instance.is_third_body,
         }
         _add_other_properties(serialize_dict, instance.other_properties)
         return _remove_empty_keys(serialize_dict)

musica/mechanism_configuration/surface.py

@@ -1,9 +1,13 @@
 from typing import Optional, Any, Dict, List, Union, Tuple
-from musica import _Surface, _ReactionComponent
+from .. import backend
 from .phase import Phase
 from .species import Species
 from .reactions import ReactionComponentSerializer
-from .utils import _add_other_properties, _remove_empty_keys
+from .utils import _add_other_properties
+
+_backend = backend.get_backend()
+_Surface = _backend._mechanism_configuration._Surface
+_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
 
 
 class Surface(_Surface):
@@ -18,7 +22,7 @@ class Surface(_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.
+        condensed_phase (Phase): The condensed phase in which the reaction occurs.
         other_properties (Dict[str, Any]): A dictionary of other properties of the surface.
     """
 
@@ -26,12 +30,13 @@ class Surface(_Surface):
         self,
         name: Optional[str] = None,
         reaction_probability: Optional[float] = None,
-        gas_phase_species: Optional[Union[Species, Tuple[float, Species]]] = 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,
+        condensed_phase: Optional[Phase] = None,
         other_properties: Optional[Dict[str, Any]] = None,
     ):
         """
@@ -43,7 +48,7 @@ class Surface(_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.
+            condensed_phase (Phase): The condensed phase in which the reaction occurs.
             other_properties (Dict[str, Any]): A dictionary of other properties of the surface.
         """
         super().__init__()
@@ -71,7 +76,7 @@ class Surface(_Surface):
             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.condensed_phase = condensed_phase.name if condensed_phase is not None else self.condensed_phase
         self.other_properties = other_properties if other_properties is not None else self.other_properties
 
     @staticmethod
@@ -83,7 +88,7 @@ class Surface(_Surface):
             "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,
+            "condensed phase": instance.condensed_phase,
         }
         _add_other_properties(serialize_dict, instance.other_properties)
-        return _remove_empty_keys(serialize_dict)
+        return serialize_dict