musica 0.12.2__cp310-cp310-win32.whl → 0.13.0__cp310-cp310-win32.whl

musica/CMakeLists.txt

@@ -18,6 +18,10 @@ set(
 if (MUSICA_ENABLE_TUVX)
   list(APPEND MUSICA_PYTHON_SOURCES
     tuvx.cpp
+    grid.cpp
+    grid_map.cpp
+    profile.cpp
+    profile_map.cpp
   )
 endif()
 

musica/_version.py

@@ -1 +1 @@
-version = "0.12.2"
+version = "0.13.0"

musica/binding_common.cpp

@@ -1,18 +1,11 @@
 #include "binding_common.hpp"
 
-void bind_cuda(py::module_ &);
-void bind_musica(py::module_ &);
-#ifdef MUSICA_USE_TUVX
-void bind_tuvx(py::module_ &);
-#endif
-#ifdef MUSICA_USE_CARMA
-void bind_carma(py::module_ &);
-#endif
-
 void bind_mechanism_configuration(py::module_ &);
 
 void bind_all(py::module_ &m)
 {
+  py::bind_vector<std::vector<double>>(m, "VectorDouble");
+
   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");
@@ -22,6 +15,10 @@ void bind_all(py::module_ &m)
   bind_cuda(core);
   bind_musica(core);
 #ifdef MUSICA_USE_TUVX
+  bind_tuvx_grid(tuvx);
+  bind_tuvx_grid_map(tuvx);
+  bind_tuvx_profile(tuvx);
+  bind_tuvx_profile_map(tuvx);
   bind_tuvx(tuvx);
 #endif
 

musica/binding_common.hpp

@@ -1,7 +1,23 @@
 #pragma once
 
 #include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/stl_bind.h>
 
 namespace py = pybind11;
 
-void bind_all(py::module_ &m);
+PYBIND11_MAKE_OPAQUE(std::vector<double>)
+
+void bind_all(py::module_ &m);
+void bind_cuda(py::module_ &);
+void bind_musica(py::module_ &);
+#ifdef MUSICA_USE_TUVX
+void bind_tuvx(py::module_ &);
+void bind_tuvx_grid(py::module_ &);
+void bind_tuvx_grid_map(py::module_ &);
+void bind_tuvx_profile(py::module_ &);
+void bind_tuvx_profile_map(py::module_ &);
+#endif
+#ifdef MUSICA_USE_CARMA
+void bind_carma(py::module_ &);
+#endif

musica/grid.cpp

@@ -0,0 +1,206 @@
+// Copyright (C) 2023-2025 National Center for Atmospheric Research
+// SPDX-License-Identifier: Apache-2.0
+//
+// This file defines the Python bindings for the TUV-x Grid class in the musica library.
+#include "binding_common.hpp"
+
+#include <musica/tuvx/grid.hpp>
+
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+void bind_tuvx_grid(py::module_ &grid)
+{
+  py::class_<musica::Grid>(grid, "_Grid")
+      .def(py::init(
+          [](const py::kwargs &kwargs)
+          {
+            if (!kwargs.contains("name"))
+              throw py::value_error("Missing required argument: name");
+            if (!kwargs.contains("units"))
+              throw py::value_error("Missing required argument: units");
+            if (!kwargs.contains("num_sections"))
+              throw py::value_error("Missing required argument: num_sections");
+            if (!py::isinstance<py::str>(kwargs["name"]))
+              throw py::value_error("Argument 'name' must be a string");
+            if (!py::isinstance<py::str>(kwargs["units"]))
+              throw py::value_error("Argument 'units' must be a string");
+            if (!py::isinstance<py::int_>(kwargs["num_sections"]))
+              throw py::value_error("Argument 'num_sections' must be an integer");
+            if (kwargs["num_sections"].cast<std::size_t>() <= 0)
+              throw py::value_error("Argument 'num_sections' must be greater than 0");
+            std::string name = kwargs["name"].cast<std::string>();
+            std::string units = kwargs["units"].cast<std::string>();
+            std::size_t num_sections = kwargs["num_sections"].cast<std::size_t>();
+            musica::Error error;
+            auto grid_instance = new musica::Grid(name.c_str(), units.c_str(), num_sections, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error creating grid: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return grid_instance;
+          }))
+      .def("__del__", [](musica::Grid &grid) {})
+      .def_property_readonly(
+          "name",
+          [](musica::Grid &self)
+          {
+            musica::Error error;
+            std::string name = self.GetName(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting grid name: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            musica::DeleteError(&error);
+            return name;
+          },
+          "The name of the grid")
+      .def_property_readonly(
+          "units",
+          [](musica::Grid &self)
+          {
+            musica::Error error;
+            std::string units = self.GetUnits(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting grid units: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            musica::DeleteError(&error);
+            return units;
+          },
+          "The units of the grid")
+      .def_property_readonly(
+          "num_sections",
+          [](musica::Grid &self)
+          {
+            musica::Error error;
+            std::size_t num_sections = self.GetNumberOfSections(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting number of grid sections: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return num_sections;
+          },
+          "The number of sections in the grid")
+      .def_property(
+          "edges",
+          // Getter - converts C++ array to numpy array
+          [](musica::Grid &self)
+          {
+            musica::Error error;
+            size_t size = self.GetNumberOfSections(&error) + 1;
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting number of grid sections: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            auto result = py::array_t<double>(size);
+            py::buffer_info buf = result.request();
+            double *ptr = static_cast<double *>(buf.ptr);
+            self.GetEdges(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting grid edges: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return result;
+          },
+          // Setter - converts numpy array to C++ array
+          [](musica::Grid &self, py::array_t<double, py::array::c_style | py::array::forcecast> array)
+          {
+            py::buffer_info buf = array.request();
+            musica::Error error;
+            size_t size = self.GetNumberOfSections(&error) + 1;
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting number of grid sections: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            if (buf.ndim != 1)
+            {
+              throw py::value_error("Number of dimensions must be one");
+            }
+            if (static_cast<size_t>(buf.size) != size)
+            {
+              throw py::value_error("Array size must be num_sections + 1");
+            }
+            double *ptr = static_cast<double *>(buf.ptr);
+            self.SetEdges(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error setting grid edges: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+          },
+          "Grid edges array of length num_sections + 1")
+      .def_property(
+          "midpoints",
+          // Getter - converts C++ array to numpy array
+          [](musica::Grid &self)
+          {
+            musica::Error error;
+            size_t size = self.GetNumberOfSections(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting number of grid sections: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            auto result = py::array_t<double>(size);
+            py::buffer_info buf = result.request();
+            double *ptr = static_cast<double *>(buf.ptr);
+            self.GetMidpoints(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting grid midpoints: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return result;
+          },
+          // Setter - converts numpy array to C++ array
+          [](musica::Grid &self, py::array_t<double, py::array::c_style | py::array::forcecast> array)
+          {
+            py::buffer_info buf = array.request();
+            musica::Error error;
+            size_t size = self.GetNumberOfSections(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting number of grid sections: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            if (buf.ndim != 1)
+            {
+              throw py::value_error("Number of dimensions must be one");
+            }
+            if (static_cast<size_t>(buf.size) != size)
+            {
+              throw py::value_error("Array size must be num_sections");
+            }
+            double *ptr = static_cast<double *>(buf.ptr);
+            self.SetMidpoints(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error setting grid midpoints: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+          },
+          "Grid midpoints array of length num_sections");
+}

musica/grid.py

@@ -0,0 +1,98 @@
+# Copyright (C) 2023-2025 National Center for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+"""
+TUV-x Grid class.
+
+This module provides a class for defining grids on which TUV-x profiles exist.
+Typically, this would be used to define vertical and wavelength grids.
+
+Note: TUV-x is only available on macOS and Linux platforms.
+"""
+
+from typing import Dict, Optional
+import numpy as np
+from . import backend
+
+_backend = backend.get_backend()
+
+Grid = _backend._tuvx._Grid if backend.tuvx_available() else None
+
+if backend.tuvx_available():
+    original_init = Grid.__init__
+
+    def __init__(self, *, name: str, units: str,
+                 num_sections: Optional[int] = None,
+                 edges: Optional[np.ndarray] = None,
+                 midpoints: Optional[np.ndarray] = None,
+                 **kwargs):
+        """Initialize a Grid instance. Note that at least one of num_sections, edges, or midpoints
+        must be provided.
+
+        Args:
+            name: Name of the grid
+            units: Units of the grid values
+            num_sections: Optional number of grid sections
+            edges: Optional array of edge values (length num_sections + 1)
+            midpoints: Optional array of midpoint values (length num_sections)
+            **kwargs: Additional arguments passed to the C++ constructor
+        """
+        if (num_sections is None and edges is None and midpoints is None):
+            raise ValueError("At least one of num_sections, edges, or midpoints must be provided.")
+        if (num_sections is None):
+            if (edges is not None):
+                num_sections = len(edges) - 1
+            elif (midpoints is not None):
+                num_sections = len(midpoints)
+        # Call the original C++ constructor correctly
+        original_init(self, name=name, units=units, num_sections=num_sections, **kwargs)
+
+        # Set edges or midpoints if provided
+        if edges is not None:
+            self.edges = edges
+        if midpoints is not None:
+            self.midpoints = midpoints
+
+    Grid.__init__ = __init__
+
+    def __str__(self):
+        """User-friendly string representation."""
+        return f"Grid(name={self.name}, units={self.units}, num_sections={self.num_sections})"
+
+    Grid.__str__ = __str__
+
+    def __repr__(self):
+        """Detailed string representation for debugging."""
+        return (f"Grid(name={self.name}, units={self.units}, num_sections={self.num_sections}, "
+                f"edges={self.edges}, midpoints={self.midpoints})")
+
+    Grid.__repr__ = __repr__
+
+    def __len__(self):
+        """Return the number of sections in the grid."""
+        return self.num_sections
+
+    Grid.__len__ = __len__
+
+    def __eq__(self, other):
+        """Check equality with another Grid instance."""
+        if not isinstance(other, Grid):
+            return NotImplemented
+        return (self.name == other.name and
+                self.units == other.units and
+                self.num_sections == other.num_sections and
+                np.array_equal(self.edges, other.edges) and
+                np.array_equal(self.midpoints, other.midpoints))
+
+    Grid.__eq__ = __eq__
+
+    def __bool__(self):
+        """Return True if the grid has sections."""
+        return self.num_sections > 0
+
+    Grid.__bool__ = __bool__
+
+    def __contains__(self, value):
+        """Check if a value is within the grid bounds."""
+        return self.edges[0] <= value <= self.edges[-1]
+
+    Grid.__contains__ = __contains__

musica/grid_map.cpp

@@ -0,0 +1,117 @@
+// Copyright (C) 2023-2025 National Center for Atmospheric Research
+// SPDX-License-Identifier: Apache-2.0
+#include "binding_common.hpp"
+
+#include <musica/tuvx/grid.hpp>
+#include <musica/tuvx/grid_map.hpp>
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+void bind_tuvx_grid_map(py::module& m)
+{
+  py::class_<musica::GridMap>(m, "_GridMap")
+      .def(py::init<>(
+          []()
+          {
+            musica::Error error;
+            auto grid_map_instance = new musica::GridMap(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error creating GridMap: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return grid_map_instance;
+          }))
+      .def(
+          "add_grid",
+          [](musica::GridMap& self, musica::Grid* grid)
+          {
+            musica::Error error;
+            self.AddGrid(grid, &error);
+            if (error.code_ != 0)
+            {
+              std::string message = "Error adding grid: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw std::runtime_error(message);
+            }
+            DeleteError(&error);
+          })
+      .def(
+          "get_grid",
+          [](musica::GridMap& self, const std::string& name, const std::string& units)
+          {
+            musica::Error error;
+            musica::Grid* grid = self.GetGrid(name.c_str(), units.c_str(), &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error("Error getting grid: " + message);
+            }
+            musica::DeleteError(&error);
+            return grid;
+          },
+          py::return_value_policy::reference)
+      .def(
+          "get_grid_by_index",
+          [](musica::GridMap& self, std::size_t index)
+          {
+            musica::Error error;
+            musica::Grid* grid = self.GetGridByIndex(index, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error("Error getting grid by index: " + message);
+            }
+            musica::DeleteError(&error);
+            return grid;
+          },
+          py::return_value_policy::reference)
+      .def(
+          "remove_grid",
+          [](musica::GridMap& self, const std::string& name, const std::string& units)
+          {
+            musica::Error error;
+            self.RemoveGrid(name.c_str(), units.c_str(), &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error("Error removing grid: " + message);
+            }
+            musica::DeleteError(&error);
+          })
+      .def(
+          "remove_grid_by_index",
+          [](musica::GridMap& self, std::size_t index)
+          {
+            musica::Error error;
+            self.RemoveGridByIndex(index, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error("Error removing grid by index: " + message);
+            }
+            musica::DeleteError(&error);
+          })
+      .def(
+          "get_number_of_grids",
+          [](musica::GridMap& self)
+          {
+            musica::Error error;
+            std::size_t num_grids = self.GetNumberOfGrids(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error("Error getting number of grids: " + message);
+            }
+            musica::DeleteError(&error);
+            return num_grids;
+          });
+}

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