musica 0.12.1__cp311-cp311-win32.whl → 0.13.0__cp311-cp311-win32.whl

musica/grid_map.py

@@ -0,0 +1,167 @@
+# Copyright (C) 2023-2025 National Center for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+"""
+TUV-x GridMap class.
+
+This module provides a class for managing collections of TUV-x grids.
+The GridMap class allows dictionary-style access to grids using (name, units) tuples as keys.
+
+Note: TUV-x is only available on macOS and Linux platforms.
+"""
+
+from typing import Iterator, Sequence
+from . import backend
+from .grid import Grid
+
+_backend = backend.get_backend()
+
+GridMap = _backend._tuvx._GridMap if backend.tuvx_available() else None
+
+if backend.tuvx_available():
+    original_init = GridMap.__init__
+
+    def __init__(self, **kwargs):
+        """Initialize a GridMap instance.
+
+        Args:
+            **kwargs: Additional arguments passed to the C++ constructor
+        """
+        original_init(self, **kwargs)
+
+    GridMap.__init__ = __init__
+
+    def __str__(self):
+        """User-friendly string representation."""
+        return f"GridMap(num_grids={len(self)})"
+
+    GridMap.__str__ = __str__
+
+    def __repr__(self):
+        """Detailed string representation for debugging."""
+        grid_details = []
+        for i in range(len(self)):
+            grid = self.get_grid_by_index(i)
+            grid_details.append(f"({grid.name}, {grid.units})")
+        return f"GridMap(grids={grid_details})"
+
+    GridMap.__repr__ = __repr__
+
+    def __len__(self):
+        """Return the number of grids in the map."""
+        return self.get_number_of_grids()
+
+    GridMap.__len__ = __len__
+
+    def __bool__(self):
+        """Return True if the map has any grids."""
+        return len(self) > 0
+
+    GridMap.__bool__ = __bool__
+
+    def __getitem__(self, key) -> Grid:
+        """Get a grid using dictionary-style access with (name, units) tuple as key.
+
+        Args:
+            key: A tuple of (grid_name, grid_units)
+
+        Returns:
+            The requested Grid object
+
+        Raises:
+            KeyError: If no grid matches the given name and units
+            TypeError: If key is not a tuple of (str, str)
+        """
+        if not isinstance(key, tuple) or len(key) != 2:
+            raise TypeError("Grid access requires a tuple of (name, units)")
+        name, units = key
+        try:
+            return self.get_grid(name, units)
+        except Exception as e:
+            raise KeyError(f"No grid found with name='{name}' and units='{units}'") from e
+
+    GridMap.__getitem__ = __getitem__
+
+    def __setitem__(self, key, grid):
+        """Add a grid to the map using dictionary-style access.
+
+        Args:
+            key: A tuple of (grid_name, grid_units)
+            grid: The Grid object to add
+
+        Raises:
+            TypeError: If key is not a tuple, or if key components are not strings
+            TypeError: If grid is not a Grid object
+            ValueError: If grid name/units don't match the key
+        """
+        if not isinstance(key, tuple) or len(key) != 2:
+            raise TypeError("Grid assignment requires a tuple of (name, units)")
+        name, units = key
+        if not isinstance(name, str):
+            raise TypeError("Grid name must be a string")
+        if not isinstance(units, str):
+            raise TypeError("Grid units must be a string")
+        if not isinstance(grid, Grid):
+            raise TypeError("Value must be a Grid object")
+        if grid.name != name or grid.units != units:
+            raise ValueError("Grid name/units must match the key tuple")
+        self.add_grid(grid)
+
+    GridMap.__setitem__ = __setitem__
+
+    def __iter__(self) -> Iterator:
+        """Return an iterator over (name, units) tuples of all grids."""
+        for i in range(len(self)):
+            grid = self.get_grid_by_index(i)
+            yield (grid.name, grid.units)
+
+    GridMap.__iter__ = __iter__
+
+    def __contains__(self, key) -> bool:
+        """Check if a grid with given name and units exists in the map.
+
+        Args:
+            key: A tuple of (grid_name, grid_units)
+
+        Returns:
+            True if a matching grid exists, False otherwise
+        """
+        if not isinstance(key, tuple) or len(key) != 2:
+            return False
+        name, units = key
+        try:
+            grid = self.get_grid(str(name), str(units))
+            return grid is not None
+        except (ValueError, KeyError):
+            return False
+
+    GridMap.__contains__ = __contains__
+
+    def clear(self):
+        """Remove all grids from the map."""
+        while len(self) > 0:
+            self.remove_grid_by_index(0)
+
+    GridMap.clear = clear
+
+    def items(self):
+        """Return an iterator over (key, grid) pairs, where key is (name, units)."""
+        for i in range(len(self)):
+            grid = self.get_grid_by_index(i)
+            yield ((grid.name, grid.units), grid)
+
+    GridMap.items = items
+
+    def keys(self):
+        """Return an iterator over grid keys (name, units) tuples."""
+        for i in range(len(self)):
+            grid = self.get_grid_by_index(i)
+            yield (grid.name, grid.units)
+
+    GridMap.keys = keys
+
+    def values(self):
+        """Return an iterator over Grid objects in the map."""
+        for i in range(len(self)):
+            yield self.get_grid_by_index(i)
+
+    GridMap.values = values

musica/mechanism_configuration/__init__.py

@@ -1 +1,18 @@
-from .mechanism_configuration import *
+from .arrhenius import Arrhenius
+from .branched import Branched
+from .emission import Emission
+from .first_order_loss import FirstOrderLoss
+from .mechanism import Mechanism
+from .ancillary import Version, Parser, ReactionType
+from .phase import Phase
+from .phase_species import PhaseSpecies
+from .photolysis import Photolysis
+from .reaction_component import ReactionComponent
+from .reactions import Reactions
+from .species import Species
+from .surface import Surface
+from .taylor_series import TaylorSeries
+from .ternary_chemical_activation import TernaryChemicalActivation
+from .troe import Troe
+from .tunneling import Tunneling
+from .user_defined import UserDefined

musica/mechanism_configuration/ancillary.py

@@ -0,0 +1,6 @@
+from .. import backend
+
+_backend = backend.get_backend()
+Version = _backend._mechanism_configuration._Version
+Parser = _backend._mechanism_configuration._Parser
+ReactionType = _backend._mechanism_configuration._ReactionType

musica/mechanism_configuration/arrhenius.py

@@ -2,18 +2,120 @@ from typing import Optional, Any, Dict, List, Union, Tuple
 from .. import backend
 from .phase import Phase
 from .species import Species
-from .reactions import ReactionComponentSerializer
-from .utils import _add_other_properties
+from .utils import _add_other_properties, _remove_empty_keys
 from ..constants import BOLTZMANN
+from .reaction_component import ReactionComponent
+from .ancillary import ReactionType
 
 _backend = backend.get_backend()
-_Arrhenius = _backend._mechanism_configuration._Arrhenius
-_ReactionComponent = _backend._mechanism_configuration._ReactionComponent
-ReactionType = _backend._mechanism_configuration._ReactionType
+Arrhenius = _backend._mechanism_configuration._Arrhenius
+
+original_init = Arrhenius.__init__
+
+
+@property
+def type(self):
+    """Get the reaction type."""
+    return ReactionType.Arrhenius
+
+
+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.
+    """
+    original_init(self)
+
+    # Validate mutually exclusive parameters
+    if C is not None and Ea is not None:
+        raise ValueError("Cannot specify both C and Ea.")
+    if Ea is not None:
+        C = -Ea / BOLTZMANN
+
+    self.name = name if name is not None else self.name
+    self.A = A if A is not None else self.A
+    self.B = B if B is not None else self.B
+    self.C = C if C is not None else self.C
+    self.D = D if D is not None else self.D
+    self.E = E if E is not None else self.E
+    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
+    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
+    )
+
+
+def serialize(self) -> Dict:
+    """
+    Serialize the Arrhenius object to a dictionary using only Python-visible data.
 
-class Arrhenius:
+    Returns:
+        Dict: A dictionary representation of the Arrhenius object.
     """
+    serialize_dict = {
+        "type": "ARRHENIUS",
+        "name": self.name,
+        "A": self.A,
+        "B": self.B,
+        "C": self.C,
+        "D": self.D,
+        "E": self.E,
+        "reactants": [r.serialize() for r in self.reactants],
+        "products": [r.serialize() for r in self.products],
+        "gas phase": self.gas_phase,
+    }
+    _add_other_properties(serialize_dict, self.other_properties)
+    return _remove_empty_keys(serialize_dict)
+
+
+Arrhenius.__doc__ = """
     A class representing an Arrhenius rate constant.
 
     k = A * exp( C / T ) * ( T / D )^B * exp( 1 - E * P )
@@ -42,266 +144,6 @@ class Arrhenius:
         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.
-        """
-        # Create the internal C++ instance
-        self._instance = _Arrhenius()
-
-        # Validate mutually exclusive parameters
-        if C is not None and Ea is not None:
-            raise ValueError("Cannot specify both C and Ea.")
-
-        # Set all parameters
-        if name is not None:
-            self.name = name
-        if A is not None:
-            self.A = A
-        if B is not None:
-            self.B = B
-        if Ea is not None:
-            self.C = -Ea / BOLTZMANN
-        elif C is not None:
-            self.C = C
-        if D is not None:
-            self.D = D
-        if E is not None:
-            self.E = E
-        if reactants is not None:
-            self.reactants = reactants
-        if products is not None:
-            self.products = products
-        if gas_phase is not None:
-            self.gas_phase = gas_phase
-        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 Arrhenius rate constant."""
-        return self._instance.name
-
-    @name.setter
-    def name(self, value: str):
-        """Set the name of the Arrhenius rate constant."""
-        self._instance.name = value
-
-    @property
-    def A(self) -> float:
-        """Get the pre-exponential factor."""
-        return self._instance.A
-
-    @A.setter
-    def A(self, value: float):
-        """Set the pre-exponential factor."""
-        self._instance.A = value
-
-    @property
-    def B(self) -> float:
-        """Get the temperature exponent."""
-        return self._instance.B
-
-    @B.setter
-    def B(self, value: float):
-        """Set the temperature exponent."""
-        self._instance.B = value
-
-    @property
-    def C(self) -> float:
-        """Get the exponential term."""
-        return self._instance.C
-
-    @C.setter
-    def C(self, value: float):
-        """Set the exponential term."""
-        self._instance.C = value
-
-    @property
-    def D(self) -> float:
-        """Get the reference temperature."""
-        return self._instance.D
-
-    @D.setter
-    def D(self, value: float):
-        """Set the reference temperature."""
-        self._instance.D = value
-
-    @property
-    def E(self) -> float:
-        """Get the pressure scaling term."""
-        return self._instance.E
-
-    @E.setter
-    def E(self, value: float):
-        """Set the pressure scaling term."""
-        self._instance.E = value
-
-    @property
-    def reactants(self) -> List[Union[Species, Tuple[float, Species]]]:
-        """Get the reactants as Python objects."""
-        # Convert from C++ _ReactionComponent objects to Python Species objects
-        result = []
-        for rc in self._instance.reactants:
-            if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
-                # Create a tuple with coefficient and species
-                species = Species(name=rc.species_name)
-                result.append((rc.coefficient, species))
-            else:
-                # Just the species
-                species = Species(name=rc.species_name)
-                result.append(species)
-        return result
-
-    @reactants.setter
-    def reactants(self, value: List[Union[Species, Tuple[float, Species]]]):
-        """Set the reactants, converting from Python to C++ objects."""
-        cpp_reactants = []
-        for r in value:
-            if isinstance(r, Species):
-                cpp_reactants.append(_ReactionComponent(r.name))
-            elif isinstance(r, tuple) and len(r) == 2:
-                coefficient, species = r
-                cpp_reactants.append(_ReactionComponent(species.name, coefficient))
-            else:
-                raise ValueError(f"Invalid reactant format: {r}")
-        self._instance.reactants = cpp_reactants
-
-    @property
-    def products(self) -> List[Union[Species, Tuple[float, Species]]]:
-        """Get the products as Python objects."""
-        # Convert from C++ _ReactionComponent objects to Python Species objects
-        result = []
-        for rc in self._instance.products:
-            if hasattr(rc, 'coefficient') and rc.coefficient != 1.0:
-                # Create a tuple with coefficient and species
-                species = Species(name=rc.species_name)
-                result.append((rc.coefficient, species))
-            else:
-                # Just the species
-                species = Species(name=rc.species_name)
-                result.append(species)
-        return result
-
-    @products.setter
-    def products(self, value: List[Union[Species, Tuple[float, Species]]]):
-        """Set the products, converting from Python to C++ objects."""
-        cpp_products = []
-        for p in value:
-            if isinstance(p, Species):
-                cpp_products.append(_ReactionComponent(p.name))
-            elif isinstance(p, tuple) and len(p) == 2:
-                coefficient, species = p
-                cpp_products.append(_ReactionComponent(species.name, coefficient))
-            else:
-                raise ValueError(f"Invalid product format: {p}")
-        self._instance.products = cpp_products
-
-    @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:
-            raise ValueError(f"Invalid gas_phase type: {type(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.Arrhenius
-
-    def _create_serialize_dict(self, instance) -> Dict:
-        """
-        Helper method to create the serialization dictionary.
-
-        Args:
-            instance: The instance to serialize (either self._instance or a _Arrhenius object).
-
-        Returns:
-            Dict: Base serialization dictionary.
-        """
-        return {
-            "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,
-        }
-
-    def serialize(self) -> Dict:
-        """
-        Serialize the Arrhenius object to a dictionary using only Python-visible data.
-
-        Returns:
-            Dict: A dictionary representation of the Arrhenius object.
-        """
-        serialize_dict = self._create_serialize_dict(self._instance)
-        _add_other_properties(serialize_dict, self.other_properties)
-        return serialize_dict
-
-    @staticmethod
-    def serialize_static(instance) -> Dict:
-        """
-        Static serialize method for compatibility with C++ _Arrhenius objects.
-
-        Args:
-            instance: The _Arrhenius instance to serialize.
-
-        Returns:
-            Dict: A dictionary representation of the Arrhenius object.
-        """
-        # Create a temporary Arrhenius object to use the helper method
-        temp_arrhenius = Arrhenius()
-        serialize_dict = temp_arrhenius._create_serialize_dict(instance)
-        _add_other_properties(serialize_dict, instance.other_properties)
-        return serialize_dict
+Arrhenius.__init__ = __init__
+Arrhenius.serialize = serialize
+Arrhenius.type = type