musica 0.12.1__cp311-cp311-win_amd64.whl → 0.13.0__cp311-cp311-win_amd64.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.1"
+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/examples/__init__.py

@@ -1 +1 @@
-from .examples import Examples
+from .examples import Examples

musica/examples/carma_aluminum.py

@@ -11,6 +11,7 @@ import ussa1976
 
 available = musica.backend.carma_available()
 
+
 def run_carma_aluminum_example():
     group = musica.carma.CARMAGroupConfig(
         name="aluminum",

musica/examples/carma_sulfate.py

@@ -14,6 +14,7 @@ import musica
 
 available = musica.backend.carma_available()
 
+
 def run_carma_sulfate_example():
     """Test CARMA sulfate growth from gas condensation in a simple single grid box."""
 

musica/examples/sulfate_box_model.py

@@ -272,8 +272,8 @@ def run_box_model():
     state.set_concentrations(initial_concentrations)
     state.set_user_defined_rate_parameters({"EMIS.SO2": np.full(NUMBER_OF_GRID_CELLS, 1.0e-8, dtype=np.float64)})
 
-    # Run the simulation for 6 hours with a timestep of 30 seconds
-    time_hours = 2.0
+    # Run the simulation for 30 minutes with a timestep of 30 seconds
+    time_hours = 0.5
     time_seconds = time_hours * np.float64(3600.0)
     dt = np.float64(30.0)
     num_steps = int(time_seconds / dt)

musica/examples/ts1_latin_hypercube.py

@@ -242,4 +242,4 @@ ax[2].set_ylabel('Air Density [kg m-3]')
 ax[2].set_xlabel('Grid Cell')
 
 fig.tight_layout()
-fig.savefig('ts1_latin_hypercube_conditions.png', dpi=300)
+fig.savefig('ts1_latin_hypercube_conditions.png', dpi=300)

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;
+          });
+}