musica 0.11.1.3__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl → 0.12.0__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

musica/CMakeLists.txt

@@ -1,47 +1,42 @@
-pybind11_add_module(_musica
-  binding.cpp
-  musica.cpp
-  mechanism_configuration.cpp
-)
+################################################################################
+# Python Extension Modules
+
+#include(setup_muisca_target)
+
+# Define the list of Python extension module targets
+set(PY_MODULES _musica)
+
+set(
+  MUSICA_PYTHON_SOURCES 
+    binding_common.cpp
+    cuda.cpp 
+    mechanism_configuration.cpp 
+    musica.cpp 
 
-target_link_libraries(_musica
-  PRIVATE
-    musica::musica
+    ${MUSICA_SOURCES}
 )
 
-include(silence_warnings)
-silence_warnings(_musica)
-
-if (APPLE)
-  # set the rpath for the shared library
-  set_target_properties(_musica PROPERTIES
-    INSTALL_RPATH "@loader_path"
-    BUILD_WITH_INSTALL_RPATH TRUE
-  )
-elseif(UNIX)
-  set_target_properties(_musica PROPERTIES
-    INSTALL_RPATH "$ORIGIN"
-    BUILD_WITH_INSTALL_RPATH TRUE
-  )
-endif()
+pybind11_add_module(_musica cpu_binding.cpp ${MUSICA_PYTHON_SOURCES})
+musica_setup_target(_musica MODE CPU)
 
-if(WIN32)
-  # makefiles on windows don't need the config directory
-  if (${CMAKE_GENERATOR} MATCHES "MinGW Makefiles")
-      set(PYTHON_MODULE_PATH "${CMAKE_CURRENT_BINARY_DIR}")
-  else()
-  # but visual studio does
-      set(PYTHON_MODULE_PATH "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>")
-  endif()
-else()
-  set(PYTHON_MODULE_PATH "${CMAKE_CURRENT_BINARY_DIR}")
+if (NOT ${MUSICA_GPU_TYPE} STREQUAL "None")
+  pybind11_add_module(_musica_gpu gpu_binding.cpp ${MUSICA_PYTHON_SOURCES}) 
+  musica_setup_target(_musica_gpu MODE GPU)
+  list(APPEND PY_MODULES _musica_gpu)
 endif()
 
-install(TARGETS _musica LIBRARY DESTINATION musica)
+foreach(lib ${PY_MODULES})
+  if (APPLE)
+    set_target_properties(${lib} PROPERTIES
+      INSTALL_RPATH "@loader_path"
+      BUILD_WITH_INSTALL_RPATH TRUE
+    )
+  elseif(UNIX)
+    set_target_properties(${lib} PROPERTIES
+      INSTALL_RPATH "$ORIGIN"
+      BUILD_WITH_INSTALL_RPATH TRUE
+    )
+  endif()
 
-install(
-  TARGETS 
-    yaml-cpp musica 
-    LIBRARY DESTINATION musica/lib
-    ARCHIVE DESTINATION musica/lib
-)
+  install(TARGETS ${lib} LIBRARY DESTINATION musica)
+endforeach()

musica/__init__.py

@@ -1,3 +1,51 @@
-from musica._musica import *
-from .types import *
-from .mechanism_configuration import *
+import importlib.util
+
+
+def _safe_find_spec(name):
+    try:
+        return importlib.util.find_spec(name)
+    except ModuleNotFoundError:
+        return None
+
+
+def _gpu_deps_installed():
+    return (
+        _safe_find_spec("nvidia.cublas") is not None or
+        _safe_find_spec("nvidia_cuda_runtime") is not None or
+        _safe_find_spec("nvidia-cublas-cu12") is not None or
+        _safe_find_spec("nvidia-cuda-runtime-cu12") is not None
+    )
+
+
+if _gpu_deps_installed():
+    from . import _musica_gpu as _backend
+else:
+    from . import _musica as _backend
+
+# Helper to re-export names from a module
+def _export_all(module, names, globals_):
+    for name in names:
+        globals_[name] = getattr(module, name)
+
+
+_core_names = [
+    "_Conditions", "_SolverType", "_Solver", "_State", "_create_solver",
+    "_create_solver_from_mechanism", "_create_state", "_micm_solve", "_vector_size",
+    "_species_ordering", "_user_defined_rate_parameters_ordering",
+]
+_mechanism_names = [
+    "_ReactionType", "_Species", "_Phase", "_ReactionComponent", "_Arrhenius",
+    "_CondensedPhaseArrhenius", "_Troe", "_Branched", "_Tunneling", "_Surface",
+    "_Photolysis", "_CondensedPhasePhotolysis", "_Emission", "_FirstOrderLoss",
+    "_AqueousEquilibrium", "_WetDeposition", "_HenrysLaw", "_SimpolPhaseTransfer",
+    "_UserDefined", "_Reactions", "_ReactionsIterator", "_Mechanism", "_Version", "_Parser"
+]
+
+# this allows us to use the same symbols in both the GPU and CPU versionspp
+_export_all(_backend._core, _core_names, globals())
+_export_all(_backend._mechanism_configuration, _mechanism_names, globals())
+
+__all__ = _core_names + _mechanism_names
+
+from .types import MICM, SolverType, State, Conditions
+from ._version import version as __version__

musica/_version.py

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

musica/binding_common.cpp

@@ -0,0 +1,16 @@
+#include "binding_common.hpp"
+
+void bind_cuda(py::module_ &);
+void bind_musica(py::module_ &);
+
+void bind_mechanism_configuration(py::module_ &);
+
+void bind_all(py::module_ &m) {
+    py::module_ core = m.def_submodule("_core", "Wrapper classes for MUSICA C library structs and functions");
+    py::module_ mechanism_configuration = m.def_submodule("_mechanism_configuration", "Wrapper classes for Mechanism Configuration library structs and functions");
+
+    bind_cuda(core);
+    bind_musica(core);
+
+    bind_mechanism_configuration(mechanism_configuration);
+}

musica/binding_common.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+void bind_all(py::module_ &m);

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/cpu_binding.cpp

@@ -0,0 +1,10 @@
+// Copyright (C) 2023-2025 University Corporation for Atmospheric Research
+// SPDX-License-Identifier: Apache-2.0
+
+#include <pybind11/pybind11.h>
+#include "binding_common.hpp"
+
+PYBIND11_MODULE(_musica, m)
+{
+  bind_all(m);
+}

musica/cuda.cpp

@@ -0,0 +1,12 @@
+// Copyright (C) 2023-2025 University Corporation for Atmospheric Research
+// SPDX-License-Identifier: Apache-2.0
+#include <musica/micm/cuda_availability.hpp>
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+void bind_cuda(py::module_ &cuda)
+{
+  cuda.def("_is_cuda_available", &musica::IsCudaAvailable, "Check if CUDA is available");
+}

musica/cuda.py

@@ -0,0 +1,10 @@
+from . import _backend
+
+def is_cuda_available() -> bool:
+    """
+    Check if CUDA is available.
+
+    Returns:
+        bool: True if CUDA is available, False otherwise.
+    """
+    return _backend._core._is_cuda_available()

musica/gpu_binding.cpp

@@ -0,0 +1,10 @@
+// Copyright (C) 2023-2025 University Corporation for Atmospheric Research
+// SPDX-License-Identifier: Apache-2.0
+
+#include <pybind11/pybind11.h>
+#include "binding_common.hpp"
+
+PYBIND11_MODULE(_musica_gpu, m)
+{
+  bind_all(m);
+}

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)