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

musica/profile.cpp

@@ -0,0 +1,294 @@
+// 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 Profile class in the musica library.
+#include "binding_common.hpp"
+
+#include <musica/tuvx/grid.hpp>
+#include <musica/tuvx/profile.hpp>
+
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+void bind_tuvx_profile(py::module_ &profile)
+{
+  py::class_<musica::Profile>(profile, "_Profile")
+      .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("grid"))
+              throw py::value_error("Missing required argument: grid");
+            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<musica::Grid>(kwargs["grid"].cast<py::object>()))
+              throw py::value_error("Argument 'grid' must be a Grid object");
+
+            std::string name = kwargs["name"].cast<std::string>();
+            std::string units = kwargs["units"].cast<std::string>();
+            musica::Grid *grid = kwargs["grid"].cast<musica::Grid *>();
+
+            musica::Error error;
+            auto profile_instance = new musica::Profile(name.c_str(), units.c_str(), grid, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error creating profile: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return profile_instance;
+          }))
+      .def("__del__", [](musica::Profile &profile) {})
+      .def_property_readonly(
+          "name",
+          [](musica::Profile &self)
+          {
+            musica::Error error;
+            std::string name = self.GetName(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting profile name: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            musica::DeleteError(&error);
+            return name;
+          },
+          "The name of the profile")
+      .def_property_readonly(
+          "units",
+          [](musica::Profile &self)
+          {
+            musica::Error error;
+            std::string units = self.GetUnits(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting profile units: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            musica::DeleteError(&error);
+            return units;
+          },
+          "The units of the profile")
+      .def_property_readonly(
+          "number_of_sections",
+          [](musica::Profile &self)
+          {
+            musica::Error error;
+            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);
+            }
+            musica::DeleteError(&error);
+            return num_sections;
+          },
+          "The number of sections in the profile grid")
+      .def_property(
+          "edge_values",
+          // Getter - converts C++ array to numpy array
+          [](musica::Profile &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.GetEdgeValues(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting edge values: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return result;
+          },
+          // Setter - converts numpy array to C++ array
+          [](musica::Profile &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("Array must be one-dimensional");
+            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.SetEdgeValues(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error setting edge values: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+          },
+          "Profile values at grid edges array of length num_sections + 1")
+      .def_property(
+          "midpoint_values",
+          // Getter - converts C++ array to numpy array
+          [](musica::Profile &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.GetMidpointValues(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting midpoint values: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return result;
+          },
+          // Setter - converts numpy array to C++ array
+          [](musica::Profile &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("Array must be one-dimensional");
+            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.SetMidpointValues(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error setting midpoint values: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+          },
+          "Profile values at grid midpoints array of length num_sections")
+      .def_property(
+          "layer_densities",
+          // Getter - converts C++ array to numpy array
+          [](musica::Profile &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.GetLayerDensities(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting layer densities: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return result;
+          },
+          // Setter - converts numpy array to C++ array
+          [](musica::Profile &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("Array must be one-dimensional");
+            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.SetLayerDensities(ptr, size, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error setting layer densities: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+          },
+          "Layer densities array of length num_sections")
+      .def_property(
+          "exo_layer_density",
+          // Getter
+          [](musica::Profile &self)
+          {
+            musica::Error error;
+            double density = self.GetExoLayerDensity(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error getting exospheric layer density: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return density;
+          },
+          // Setter
+          [](musica::Profile &self, double density)
+          {
+            musica::Error error;
+            self.SetExoLayerDensity(density, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error setting exospheric layer density: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+          },
+          "Exospheric layer density")
+      .def(
+          "calculate_exo_layer_density",
+          [](musica::Profile &self, double scale_height)
+          {
+            musica::Error error;
+            self.CalculateExoLayerDensity(scale_height, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error calculating exospheric layer density: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+          },
+          "Calculate the exospheric layer density using the given scale height",
+          py::arg("scale_height"));
+}

musica/profile.py

@@ -0,0 +1,93 @@
+# Copyright (C) 2023-2025 National Center for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+"""
+TUV-x Profile class.
+
+This module provides a class for defining profiles in TUV-x. Profiles represent
+physical quantities that vary along a grid, such as temperature or species
+concentrations.
+
+Note: TUV-x is only available on macOS and Linux platforms.
+"""
+
+from typing import Dict, Optional
+import numpy as np
+from . import backend
+from .grid import Grid
+
+_backend = backend.get_backend()
+
+Profile = _backend._tuvx._Profile if backend.tuvx_available() else None
+
+if backend.tuvx_available():
+    original_init = Profile.__init__
+
+    def __init__(self, *, name: str, units: str, grid: Grid,
+                 edge_values: Optional[np.ndarray] = None,
+                 midpoint_values: Optional[np.ndarray] = None,
+                 layer_densities: Optional[np.ndarray] = None,
+                 **kwargs):
+        """Initialize a Profile instance.
+
+        Args:
+            name: Name of the profile
+            units: Units of the profile values
+            grid: Grid on which the profile is defined
+            edge_values: Optional array of values at grid edges (length num_sections + 1)
+            midpoint_values: Optional array of values at grid midpoints (length num_sections)
+            layer_densities: Optional array of layer densities (length num_sections)
+            **kwargs: Additional arguments passed to the C++ constructor
+        """
+        # Call the original C++ constructor correctly
+        original_init(self, name=name, units=units, grid=grid, **kwargs)
+
+        # Set values if provided
+        if edge_values is not None:
+            self.edge_values = edge_values
+        if midpoint_values is not None:
+            self.midpoint_values = midpoint_values
+        if layer_densities is not None:
+            self.layer_densities = layer_densities
+
+    Profile.__init__ = __init__
+
+    def __str__(self):
+        """User-friendly string representation."""
+        return f"Profile(name={self.name}, units={self.units}, number_of_sections={self.number_of_sections})"
+
+    Profile.__str__ = __str__
+
+    def __repr__(self):
+        """Detailed string representation for debugging."""
+        return (f"Profile(name={self.name}, units={self.units}, number_of_sections={self.number_of_sections}, "
+                f"edge_values={self.edge_values}, midpoint_values={self.midpoint_values}, "
+                f"layer_densities={self.layer_densities}, "
+                f"exo_layer_density={self.exo_layer_density})")
+
+    Profile.__repr__ = __repr__
+
+    def __len__(self):
+        """Return the number of sections in the grid."""
+        return self.number_of_sections
+
+    Profile.__len__ = __len__
+
+    def __eq__(self, other):
+        """Check equality with another Profile instance."""
+        if not isinstance(other, Profile):
+            return NotImplemented
+        return (self.name == other.name and
+                self.units == other.units and
+                self.number_of_sections == other.number_of_sections and
+                np.array_equal(self.edge_values, other.edge_values) and
+                np.array_equal(self.midpoint_values, other.midpoint_values) and
+                np.array_equal(self.layer_densities, other.layer_densities) and
+                self.exo_layer_density == other.exo_layer_density)
+
+    Profile.__eq__ = __eq__
+
+    def __bool__(self):
+        """Return True if the profile has a name, units, and one or more sections."""
+        return bool(self.name) and bool(self.units) and self.number_of_sections > 0
+
+    Profile.__bool__ = __bool__

musica/profile_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/profile.hpp>
+#include <musica/tuvx/profile_map.hpp>
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+void bind_tuvx_profile_map(py::module& m)
+{
+  py::class_<musica::ProfileMap>(m, "_ProfileMap")
+      .def(py::init<>(
+          []()
+          {
+            musica::Error error;
+            auto profile_map_instance = new musica::ProfileMap(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = "Error creating ProfileMap: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error(message);
+            }
+            return profile_map_instance;
+          }))
+      .def(
+          "add_profile",
+          [](musica::ProfileMap& self, musica::Profile* profile)
+          {
+            musica::Error error;
+            self.AddProfile(profile, &error);
+            if (error.code_ != 0)
+            {
+              std::string message = "Error adding profile: " + std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw std::runtime_error(message);
+            }
+            DeleteError(&error);
+          })
+      .def(
+          "get_profile",
+          [](musica::ProfileMap& self, const std::string& name, const std::string& units)
+          {
+            musica::Error error;
+            musica::Profile* profile = self.GetProfile(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 profile: " + message);
+            }
+            musica::DeleteError(&error);
+            return profile;
+          },
+          py::return_value_policy::reference)
+      .def(
+          "get_profile_by_index",
+          [](musica::ProfileMap& self, std::size_t index)
+          {
+            musica::Error error;
+            musica::Profile* profile = self.GetProfileByIndex(index, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error("Error getting profile by index: " + message);
+            }
+            musica::DeleteError(&error);
+            return profile;
+          },
+          py::return_value_policy::reference)
+      .def(
+          "remove_profile",
+          [](musica::ProfileMap& self, const std::string& name, const std::string& units)
+          {
+            musica::Error error;
+            self.RemoveProfile(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 profile: " + message);
+            }
+            musica::DeleteError(&error);
+          })
+      .def(
+          "remove_profile_by_index",
+          [](musica::ProfileMap& self, std::size_t index)
+          {
+            musica::Error error;
+            self.RemoveProfileByIndex(index, &error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error("Error removing profile by index: " + message);
+            }
+            musica::DeleteError(&error);
+          })
+      .def(
+          "get_number_of_profiles",
+          [](musica::ProfileMap& self)
+          {
+            musica::Error error;
+            std::size_t num_profiles = self.GetNumberOfProfiles(&error);
+            if (!musica::IsSuccess(error))
+            {
+              std::string message = std::string(error.message_.value_);
+              musica::DeleteError(&error);
+              throw py::value_error("Error getting number of profiles: " + message);
+            }
+            musica::DeleteError(&error);
+            return num_profiles;
+          });
+}

musica/profile_map.py

@@ -0,0 +1,167 @@
+# Copyright (C) 2023-2025 National Center for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+"""
+TUV-x ProfileMap class.
+
+This module provides a class for managing collections of TUV-x profiles.
+The ProfileMap class allows dictionary-style access to profiles 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 .profile import Profile
+
+_backend = backend.get_backend()
+
+ProfileMap = _backend._tuvx._ProfileMap if backend.tuvx_available() else None
+
+if backend.tuvx_available():
+    original_init = ProfileMap.__init__
+
+    def __init__(self, **kwargs):
+        """Initialize a ProfileMap instance.
+
+        Args:
+            **kwargs: Additional arguments passed to the C++ constructor
+        """
+        original_init(self, **kwargs)
+
+    ProfileMap.__init__ = __init__
+
+    def __str__(self):
+        """User-friendly string representation."""
+        return f"ProfileMap(num_profiles={len(self)})"
+
+    ProfileMap.__str__ = __str__
+
+    def __repr__(self):
+        """Detailed string representation for debugging."""
+        profile_details = []
+        for i in range(len(self)):
+            profile = self.get_profile_by_index(i)
+            profile_details.append(f"({profile.name}, {profile.units})")
+        return f"ProfileMap(profiles={profile_details})"
+
+    ProfileMap.__repr__ = __repr__
+
+    def __len__(self):
+        """Return the number of profiles in the map."""
+        return self.get_number_of_profiles()
+
+    ProfileMap.__len__ = __len__
+
+    def __bool__(self):
+        """Return True if the map has any profiles."""
+        return len(self) > 0
+
+    ProfileMap.__bool__ = __bool__
+
+    def __getitem__(self, key) -> Profile:
+        """Get a profile using dictionary-style access with (name, units) tuple as key.
+
+        Args:
+            key: A tuple of (profile_name, profile_units)
+
+        Returns:
+            The requested Profile object
+
+        Raises:
+            KeyError: If no profile 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("Profile access requires a tuple of (name, units)")
+        name, units = key
+        try:
+            return self.get_profile(name, units)
+        except Exception as e:
+            raise KeyError(f"No profile found with name='{name}' and units='{units}'") from e
+
+    ProfileMap.__getitem__ = __getitem__
+
+    def __setitem__(self, key, profile):
+        """Add a profile to the map using dictionary-style access.
+
+        Args:
+            key: A tuple of (profile_name, profile_units)
+            profile: The Profile object to add
+
+        Raises:
+            TypeError: If key is not a tuple, or if key components are not strings
+            TypeError: If profile is not a Profile object
+            ValueError: If profile name/units don't match the key
+        """
+        if not isinstance(key, tuple) or len(key) != 2:
+            raise TypeError("Profile assignment requires a tuple of (name, units)")
+        name, units = key
+        if not isinstance(name, str):
+            raise TypeError("Profile name must be a string")
+        if not isinstance(units, str):
+            raise TypeError("Profile units must be a string")
+        if not isinstance(profile, Profile):
+            raise TypeError("Value must be a Profile object")
+        if profile.name != name or profile.units != units:
+            raise ValueError("Profile name/units must match the key tuple")
+        self.add_profile(profile)
+
+    ProfileMap.__setitem__ = __setitem__
+
+    def __iter__(self) -> Iterator:
+        """Return an iterator over (name, units) tuples of all profiles."""
+        for i in range(len(self)):
+            profile = self.get_profile_by_index(i)
+            yield (profile.name, profile.units)
+
+    ProfileMap.__iter__ = __iter__
+
+    def __contains__(self, key) -> bool:
+        """Check if a profile with given name and units exists in the map.
+
+        Args:
+            key: A tuple of (profile_name, profile_units)
+
+        Returns:
+            True if a matching profile exists, False otherwise
+        """
+        if not isinstance(key, tuple) or len(key) != 2:
+            return False
+        name, units = key
+        try:
+            profile = self.get_profile(str(name), str(units))
+            return profile is not None
+        except (ValueError, KeyError):
+            return False
+
+    ProfileMap.__contains__ = __contains__
+
+    def clear(self):
+        """Remove all profiles from the map."""
+        while len(self) > 0:
+            self.remove_profile_by_index(0)
+
+    ProfileMap.clear = clear
+
+    def items(self):
+        """Return an iterator over (key, profile) pairs, where key is (name, units)."""
+        for i in range(len(self)):
+            profile = self.get_profile_by_index(i)
+            yield ((profile.name, profile.units), profile)
+
+    ProfileMap.items = items
+
+    def keys(self):
+        """Return an iterator over profile keys (name, units) tuples."""
+        for i in range(len(self)):
+            profile = self.get_profile_by_index(i)
+            yield (profile.name, profile.units)
+
+    ProfileMap.keys = keys
+
+    def values(self):
+        """Return an iterator over Profile objects in the map."""
+        for i in range(len(self)):
+            yield self.get_profile_by_index(i)
+
+    ProfileMap.values = values