musica 0.11.1.1__cp312-cp312-win_amd64.whl → 0.14.2__cp312-cp312-win_amd64.whl

musica/tuvx/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
+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/tuvx/profile.py

@@ -0,0 +1,130 @@
+# 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 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,
+                 calculate_layer_densities: bool = False,
+                 **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)
+            calculate_layer_densities: If True, calculate layer densities from midpoint values
+            **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 optional values if provided, otherwise calculate them
+        if edge_values is None and midpoint_values is None:
+            self.edge_values = np.zeros(grid.num_sections + 1, dtype=np.float64)
+            self.midpoint_values = np.zeros(grid.num_sections, dtype=np.float64)
+            self.layer_densities = np.zeros(grid.num_sections, dtype=np.float64)
+        if edge_values is not None:
+            self.edge_values = edge_values
+        elif midpoint_values is not None:
+            edge_values = np.zeros(midpoint_values.size + 1, dtype=midpoint_values.dtype)
+            edge_values[1:-1] = 0.5 * (midpoint_values[:-1] + midpoint_values[1:])
+            # Extrapolate first and last edges
+            edge_values[0] = midpoint_values[0] - (edge_values[1] - midpoint_values[0])
+            edge_values[-1] = midpoint_values[-1] + (midpoint_values[-1] - edge_values[-2])
+            self.edge_values = edge_values
+        if midpoint_values is not None:
+            self.midpoint_values = midpoint_values
+        elif edge_values is not None:
+            self.midpoint_values = 0.5 * (edge_values[:-1] + edge_values[1:])
+        if layer_densities is not None:
+            if calculate_layer_densities:
+                raise ValueError("Cannot provide layer_densities and set calculate_layer_densities=True")
+            self.layer_densities = layer_densities
+        elif calculate_layer_densities:
+            self.calculate_layer_densities(grid)
+
+    Profile.__init__ = __init__
+
+    def calculate_layer_densities(self, grid: Grid, conv: Optional[float] = None):
+        """Calculate layer densities from midpoint values and grid spacing.
+
+        Args:
+            conv: Conversion factor to apply (default is 1.0 or 1.0e5 for height in km and concentrations in molecules cm-3)
+        """
+        # Workaround for current non-SI units in TUV-x, layer densities must be in molecules/cm2
+        # and heights in km. This will be fixed in a future TUV-x release.
+        if conv is None:
+            if grid.name == "height" and grid.units == "km" and self.units == "molecule cm-3":
+                conv = 1e5
+            else:
+                conv = 1.0
+        deltas = grid.edges[1:] - grid.edges[:-1]
+        self.layer_densities = self.midpoint_values * deltas * conv
+
+    Profile.calculate_layer_densities = calculate_layer_densities
+
+    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/tuvx/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
+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

musica/tuvx/radiator.py

@@ -0,0 +1,95 @@
+# Copyright (C) 2023-2025 University Corporation for Atmospheric Research
+# SPDX-License-Identifier: Apache-2.0
+"""
+TUV-x Radiator class.
+
+This module provides a class for defining radiators in TUV-x. Radiators represent
+optically active species that should be considered in radiative transfer calculations.
+
+Note: TUV-x is only available on macOS and Linux platforms.
+"""
+
+from typing import Optional
+import numpy as np
+from .. import backend
+from .grid import Grid
+
+_backend = backend.get_backend()
+
+Radiator = _backend._tuvx._Radiator if backend.tuvx_available() else None
+
+if backend.tuvx_available():
+    original_init = Radiator.__init__
+
+    def __init__(self, *, name: str, height_grid: Grid, wavelength_grid: Grid,
+                 optical_depths: Optional[np.ndarray] = None,
+                 single_scattering_albedos: Optional[np.ndarray] = None,
+                 asymmetry_factors: Optional[np.ndarray] = None,
+                 **kwargs):
+        """Initialize a Radiator instance.
+
+        Args:
+            name: Name of the radiator
+            height_grid: Grid on which the radiator is defined (height)
+            wavelength_grid: Grid on which the radiator is defined (wavelength)
+            optical_depths: Optional 2D array of optical depths
+                                       (shape: num_heights x num_wavelengths)
+            single_scattering_albedos: Optional 2D array of single scattering albedos
+                                       (shape: num_heights x num_wavelengths)
+            asymmetry_factors: Optional 2D array of asymmetry parameters
+                                  (shape: num_heights x num_wavelengths)
+            **kwargs: Additional arguments passed to the C++ constructor
+        """
+        # Call the original C++ constructor correctly
+        original_init(self, name=name, height_grid=height_grid,
+                      wavelength_grid=wavelength_grid, **kwargs)
+
+        # Set properties if provided
+        if optical_depths is not None:
+            self.optical_depths = optical_depths
+        if single_scattering_albedos is not None:
+            self.single_scattering_albedos = single_scattering_albedos
+        if asymmetry_factors is not None:
+            self.asymmetry_factors = asymmetry_factors
+
+    Radiator.__init__ = __init__
+
+    def __str__(self):
+        """User-friendly string representation."""
+        return (f"Radiator(name={self.name}, "
+                f"num_height_sections={self.number_of_height_sections}, "
+                f"num_wavelength_sections={self.number_of_wavelength_sections})")
+
+    Radiator.__str__ = __str__
+
+    def __repr__(self):
+        """Detailed string representation for debugging."""
+        return (f"Radiator(name={self.name}, "
+                f"num_height_sections={self.number_of_height_sections}, "
+                f"num_wavelength_sections={self.number_of_wavelength_sections}, "
+                f"optical_depths={self.optical_depths}, "
+                f"single_scattering_albedos={self.single_scattering_albedos}, "
+                f"asymmetry_factors={self.asymmetry_factors})")
+
+    Radiator.__repr__ = __repr__
+
+    def __eq__(self, other):
+        """Check equality between two Radiator instances."""
+        if not isinstance(other, Radiator):
+            return NotImplemented
+        return (self.name == other.name and
+                np.array_equal(self.optical_depths, other.optical_depths) and
+                np.array_equal(self.single_scattering_albedos, other.single_scattering_albedos) and
+                np.array_equal(self.asymmetry_factors, other.asymmetry_factors) and
+                self.number_of_height_sections == other.number_of_height_sections and
+                self.number_of_wavelength_sections == other.number_of_wavelength_sections)
+
+    Radiator.__eq__ = __eq__
+
+    def __bool__(self):
+        """Return True if the radiator has name and height and wavelength sections."""
+        return (bool(self.name) and
+                self.number_of_height_sections > 0 and
+                self.number_of_wavelength_sections > 0)
+
+    Radiator.__bool__ = __bool__