musica 0.12.0__cp311-cp311-win_amd64.whl → 0.12.2__cp311-cp311-win_amd64.whl

musica/mechanism_configuration/henrys_law.py

@@ -1,8 +1,12 @@
 from typing import Optional, Any, Dict, Union, Tuple
-from musica import _HenrysLaw, _ReactionComponent
+from .. import backend
 from .phase import Phase
 from .species import Species
-from .utils import _add_other_properties, _remove_empty_keys
+from .utils import _add_other_properties
+
+_backend = backend.get_backend()
+_HenrysLaw = _backend._mechanism_configuration._HenrysLaw
+_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
 
 
 class HenrysLaw(_HenrysLaw):
@@ -11,22 +15,12 @@ class HenrysLaw(_HenrysLaw):
 
     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,
     ):
         """
@@ -34,40 +28,10 @@ class HenrysLaw(_HenrysLaw):
 
         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
@@ -75,11 +39,6 @@ class HenrysLaw(_HenrysLaw):
         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)
+        return serialize_dict

musica/mechanism_configuration/mechanism_configuration.py

@@ -3,29 +3,36 @@
 #
 # This file is part of the musica Python package.
 # For more information, see the LICENSE file in the top-level directory of this distribution.
+from .reactions import Reactions, ReactionType
+from .user_defined import UserDefined, _UserDefined
+from .simpol_phase_transfer import SimpolPhaseTransfer, _SimpolPhaseTransfer
+from .henrys_law import HenrysLaw, _HenrysLaw
+from .wet_deposition import WetDeposition, _WetDeposition
+from .aqueous_equilibrium import AqueousEquilibrium, _AqueousEquilibrium
+from .first_order_loss import FirstOrderLoss, _FirstOrderLoss
+from .emission import Emission, _Emission
+from .condensed_phase_photolysis import CondensedPhasePhotolysis, _CondensedPhasePhotolysis
+from .photolysis import Photolysis, _Photolysis
+from .surface import Surface, _Surface
+from .tunneling import Tunneling, _Tunneling
+from .branched import Branched, _Branched
+from .troe import Troe, _Troe
+from .ternary_chemical_activation import TernaryChemicalActivation, _TernaryChemicalActivation
+from .condensed_phase_arrhenius import CondensedPhaseArrhenius, _CondensedPhaseArrhenius
+from .arrhenius import Arrhenius, _Arrhenius
+from .phase import Phase
+from .species import Species
 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
+from .. import backend
+
+_backend = backend.get_backend()
+_mc = _backend._mechanism_configuration
+_Mechanism = _mc._Mechanism
+_Version = _mc._Version
+_Parser = _mc._Parser
 
 
 class Version(_Version):
@@ -68,7 +75,8 @@ class Mechanism(_Mechanism):
         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.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:
@@ -82,22 +90,46 @@ class Mechanism(_Mechanism):
 
         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))
+            if isinstance(reaction, _Arrhenius):
+                # Handle C++ _Arrhenius objects with static serialize call
+                reactions_list.append(Arrhenius.serialize_static(reaction))
+            elif isinstance(reaction, Arrhenius):
+                # Handle Python Arrhenius objects with instance serialize call
+                reactions_list.append(reaction.serialize())
+            elif isinstance(reaction, _Branched):
+                # Handle C++ _Branched objects with static serialize call
+                reactions_list.append(Branched.serialize_static(reaction))
+            elif isinstance(reaction, Branched):
+                # Handle Python Branched objects with instance serialize call
+                reactions_list.append(reaction.serialize())
             elif isinstance(reaction, (_CondensedPhaseArrhenius, CondensedPhaseArrhenius)):
-                reactions_list.append(CondensedPhaseArrhenius.serialize(reaction))
+                reactions_list.append(
+                    CondensedPhaseArrhenius.serialize_static(reaction))
             elif isinstance(reaction, (_CondensedPhasePhotolysis, CondensedPhasePhotolysis)):
-                reactions_list.append(CondensedPhasePhotolysis.serialize(reaction))
+                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, _FirstOrderLoss):
+                # Handle C++ _FirstOrderLoss objects with static serialize call
+                reactions_list.append(FirstOrderLoss.serialize_static(reaction))
+            elif isinstance(reaction, FirstOrderLoss):
+                # Handle Python FirstOrderLoss objects with instance serialize call
+                reactions_list.append(reaction.serialize())
+            elif isinstance(reaction, _SimpolPhaseTransfer):
+                # Handle C++ _SimpolPhaseTransfer objects with static serialize call
+                reactions_list.append(
+                    SimpolPhaseTransfer.serialize_static(reaction))
+            elif isinstance(reaction, SimpolPhaseTransfer):
+                # Handle Python SimpolPhaseTransfer objects with instance serialize call
+                reactions_list.append(reaction.serialize())
+            elif isinstance(reaction, _AqueousEquilibrium):
+                # Handle C++ _AqueousEquilibrium objects with static serialize call
+                reactions_list.append(
+                    AqueousEquilibrium.serialize_static(reaction))
+            elif isinstance(reaction, AqueousEquilibrium):
+                # Handle Python AqueousEquilibrium objects with instance serialize call
+                reactions_list.append(reaction.serialize())
             elif isinstance(reaction, (_WetDeposition, WetDeposition)):
                 reactions_list.append(WetDeposition.serialize(reaction))
             elif isinstance(reaction, (_HenrysLaw, HenrysLaw)):
@@ -106,14 +138,29 @@ class Mechanism(_Mechanism):
                 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, _Troe):
+                # Handle C++ _Troe objects with static serialize call
+                reactions_list.append(Troe.serialize_static(reaction))
+            elif isinstance(reaction, Troe):
+                # Handle Python Troe objects with instance serialize call
+                reactions_list.append(reaction.serialize())
+            elif isinstance(reaction, _TernaryChemicalActivation):
+                # Handle C++ _TernaryChemicalActivation objects with static serialize call
+                reactions_list.append(TernaryChemicalActivation.serialize_static(reaction))
+            elif isinstance(reaction, TernaryChemicalActivation):
+                # Handle Python TernaryChemicalActivation objects with instance serialize call
+                reactions_list.append(reaction.serialize())
+            elif isinstance(reaction, _Tunneling):
+                # Handle C++ _Tunneling objects with static serialize call
+                reactions_list.append(Tunneling.serialize_static(reaction))
+            elif isinstance(reaction, Tunneling):
+                # Handle Python Tunneling objects with instance serialize call
+                reactions_list.append(reaction.serialize())
             elif isinstance(reaction, (_UserDefined, UserDefined)):
                 reactions_list.append(UserDefined.serialize(reaction))
             else:
-                raise TypeError(f'Reaction type {type(reaction)} is not supported for export.')
+                raise TypeError(
+                    f'Reaction type {type(reaction)} is not supported for export.')
 
         return {
             "name": self.name,
@@ -139,15 +186,40 @@ class MechanismSerializer():
     """
 
     @staticmethod
-    def serialize(mechanism: Mechanism, file_path: str = "./mechanism.json") -> None:        
-        if not isinstance(mechanism, Mechanism):
+    def _convert_cpp_mechanism_to_python(cpp_mechanism: Any) -> Mechanism:
+        """
+        Convert a C++ _Mechanism object to a Python Mechanism object.
+        """
+        reactions_list = []
+        for reaction in cpp_mechanism.reactions:
+            reactions_list.append(reaction)
+
+        python_mechanism = Mechanism(
+            name=cpp_mechanism.name,
+            reactions=reactions_list,
+            species=list(cpp_mechanism.species),
+            phases=list(cpp_mechanism.phases),
+            version=Version() if cpp_mechanism.version is None else cpp_mechanism.version
+        )
+
+        return python_mechanism
+
+    @staticmethod
+    def serialize(mechanism: Mechanism, file_path: str = "./mechanism.json") -> None:
+        if not isinstance(mechanism, (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)
+
+        if isinstance(mechanism, _Mechanism) and not isinstance(mechanism, Mechanism):
+            mechanism = MechanismSerializer._convert_cpp_mechanism_to_python(
+                mechanism)
+
+        # Now we can use the standard to_dict method
         dictionary = mechanism.to_dict()
-        
+
         _, file_ext = os.path.splitext(file)
         file_ext = file_ext.lower()
         if file_ext in ['.yaml', '.yml']:
@@ -158,4 +230,5 @@ class MechanismSerializer():
             with open(file_path, 'w') as file:
                 file.write(json_str)
         else:
-            raise Exception('Allowable write formats are .json, .yaml, and .yml')
+            raise ValueError(
+                'Allowable write formats are .json, .yaml, and .yml')

musica/mechanism_configuration/phase.py

@@ -1,8 +1,11 @@
 from typing import Optional, Any, Dict, List
-from musica import _Phase
+from .. import backend
 from .species import Species
 from .utils import _add_other_properties, _remove_empty_keys
 
+_backend = backend.get_backend()
+_Phase = _backend._mechanism_configuration._Phase
+
 
 class Phase(_Phase):
     """
@@ -30,7 +33,8 @@ class Phase(_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.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

musica/mechanism_configuration/photolysis.py

@@ -1,9 +1,13 @@
-from typing import Optional, Any, Dict, List, Union, Tuple
-from musica import _Photolysis, _ReactionComponent
-from .phase import Phase
-from .species import Species
+from .utils import _add_other_properties
 from .reactions import ReactionComponentSerializer
-from .utils import _add_other_properties, _remove_empty_keys
+from .species import Species
+from .phase import Phase
+from typing import Optional, Any, Dict, List, Union, Tuple
+from .. import backend
+
+_backend = backend.get_backend()
+_Photolysis = _backend._mechanism_configuration._Photolysis
+_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
 
 
 class Photolysis(_Photolysis):
@@ -23,7 +27,8 @@ class Photolysis(_Photolysis):
         self,
         name: Optional[str] = None,
         scaling_factor: Optional[float] = None,
-        reactants: Optional[List[Union[Species, Tuple[float, Species]]]] = 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,
@@ -80,4 +85,4 @@ class Photolysis(_Photolysis):
             "gas phase": instance.gas_phase,
         }
         _add_other_properties(serialize_dict, instance.other_properties)
-        return _remove_empty_keys(serialize_dict)
+        return serialize_dict

musica/mechanism_configuration/reactions.py

@@ -1,13 +1,12 @@
 from typing import Optional, Any, Dict, List, Union
-from musica import _ReactionType, _Reactions, _ReactionsIterator
+from .. import backend
 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.
-    """
+_backend = backend.get_backend()
+ReactionType = _backend._mechanism_configuration._ReactionType
+_Reactions = _backend._mechanism_configuration._Reactions
+_ReactionsIterator = _backend._mechanism_configuration._ReactionsIterator
 
 
 class Reactions(_Reactions):
@@ -28,7 +27,19 @@ class Reactions(_Reactions):
         Args:
             reactions (List[]): A list of reactions in the mechanism.
         """
-        super().__init__(reactions)
+        # Convert Python Arrhenius objects to C++ _Arrhenius objects for the C++ constructor
+        if reactions is not None:
+            cpp_reactions = []
+            for reaction in reactions:
+                if hasattr(reaction, '_instance'):
+                    # This is a Python wrapper around a C++ object, use the internal instance
+                    cpp_reactions.append(reaction._instance)
+                else:
+                    # This is already a C++ object or other supported type
+                    cpp_reactions.append(reaction)
+            super().__init__(cpp_reactions)
+        else:
+            super().__init__(reactions)
 
 
 class ReactionsIterator(_ReactionsIterator):
@@ -57,5 +68,6 @@ class ReactionComponentSerializer():
     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))
+            ret.append(
+                ReactionComponentSerializer.serialize_reaction_component(rc))
         return ret