lsurf 1.0.0__py3-none-any.whl

lsurf/materials/implementations/layered_atmosphere.py

@@ -0,0 +1,134 @@
+# The Clear BSD License
+#
+# Copyright (c) 2026 Tobias Heibges
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted (subject to the limitations in the disclaimer
+# below) provided that the following conditions are met:
+#
+#      * Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+#      * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#
+#      * Neither the name of the copyright holder nor the names of its
+#      contributors may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+# NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+# THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Layered Atmosphere Implementation (CPU-only)
+
+Atmosphere with discrete horizontal layers.
+"""
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ..base import FullInhomogeneousModel
+
+
+class LayeredAtmosphere(FullInhomogeneousModel):
+    """
+    Atmosphere with discrete horizontal layers (CPU-only).
+
+    Each layer has a constant refractive index. This is useful for
+    modeling simplified atmospheric profiles or testing ray tracing
+    through discrete media.
+
+    Parameters
+    ----------
+    layer_boundaries : list of float
+        Altitudes (z values) of layer boundaries, in ascending order.
+        The first value is the ground level.
+    layer_n_values : list of float
+        Refractive index for each layer. Length should be len(boundaries) - 1.
+    default_n : float
+        Refractive index above the highest boundary. Default 1.0.
+
+    Example
+    -------
+    >>> # Create 3-layer atmosphere
+    >>> layers = LayeredAtmosphere(
+    ...     layer_boundaries=[0, 10000, 20000, 50000],
+    ...     layer_n_values=[1.0003, 1.0002, 1.0001],
+    ...     default_n=1.0,
+    ... )
+    """
+
+    def __init__(
+        self,
+        layer_boundaries: list[float],
+        layer_n_values: list[float],
+        default_n: float = 1.0,
+    ):
+        super().__init__(name="Layered Atmosphere")
+
+        if len(layer_n_values) != len(layer_boundaries) - 1:
+            raise ValueError(
+                f"Need {len(layer_boundaries) - 1} n values for "
+                f"{len(layer_boundaries)} boundaries"
+            )
+
+        self._boundaries = np.array(layer_boundaries)
+        self._n_values = np.array(layer_n_values)
+        self._default_n = default_n
+
+    def get_refractive_index(
+        self,
+        x: float | NDArray[np.float64],
+        y: float | NDArray[np.float64],
+        z: float | NDArray[np.float64],
+        wavelength: float | NDArray[np.float64],
+    ) -> float | NDArray[np.float64]:
+        """Return n based on which layer z falls into."""
+        z = np.asarray(z)
+        scalar_input = z.ndim == 0
+        z = np.atleast_1d(z)
+
+        # Find layer index for each z value
+        result = np.full_like(z, self._default_n, dtype=np.float64)
+
+        for i in range(len(self._n_values)):
+            mask = (z >= self._boundaries[i]) & (z < self._boundaries[i + 1])
+            result[mask] = self._n_values[i]
+
+        if scalar_input:
+            return float(result[0])
+        return result
+
+    def get_refractive_index_gradient(
+        self,
+        x: float | NDArray[np.float64],
+        y: float | NDArray[np.float64],
+        z: float | NDArray[np.float64],
+        wavelength: float | NDArray[np.float64],
+    ) -> tuple[
+        float | NDArray[np.float64],
+        float | NDArray[np.float64],
+        float | NDArray[np.float64],
+    ]:
+        """Gradient is zero everywhere (piecewise constant)."""
+        z = np.asarray(z)
+        if z.ndim == 0:
+            return 0.0, 0.0, 0.0
+        zeros = np.zeros_like(z)
+        return zeros, zeros, zeros
+
+
+__all__ = ["LayeredAtmosphere"]

lsurf/materials/implementations/linear_gradient.py

@@ -0,0 +1,109 @@
+# The Clear BSD License
+#
+# Copyright (c) 2026 Tobias Heibges
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted (subject to the limitations in the disclaimer
+# below) provided that the following conditions are met:
+#
+#      * Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+#      * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#
+#      * Neither the name of the copyright holder nor the names of its
+#      contributors may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+# NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+# THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Linear Gradient Atmosphere Implementation
+
+Simple linear gradient atmosphere for testing.
+"""
+
+from ..base import SimpleInhomogeneousModel
+from ..utils.constants import EARTH_RADIUS
+
+
+class LinearGradientAtmosphere(SimpleInhomogeneousModel):
+    """
+    Simple linear gradient atmosphere for testing.
+
+    n decreases linearly with altitude from n_surface to n_top.
+
+    Parameters
+    ----------
+    n_surface : float
+        Refractive index at surface. Default 1.0003.
+    n_top : float
+        Refractive index at top altitude. Default 1.0.
+    top_altitude : float
+        Altitude where n reaches n_top. Default 100 km.
+    earth_center : tuple, optional
+        Center of Earth. Default is (0, 0, 0).
+    earth_radius : float, optional
+        Radius of Earth in meters. Default is 6,371,000 m.
+    """
+
+    def __init__(
+        self,
+        n_surface: float = 1.0003,
+        n_top: float = 1.0,
+        top_altitude: float = 100_000.0,
+        earth_center: tuple[float, float, float] = (0.0, 0.0, 0.0),
+        earth_radius: float = EARTH_RADIUS,
+        # Legacy parameter aliases for backward compatibility
+        dn_dh: float | None = None,
+        max_altitude: float | None = None,
+    ):
+        # Handle legacy parameters
+        if dn_dh is not None and max_altitude is not None:
+            # Old-style parameters: dn_dh and max_altitude
+            top_altitude = max_altitude
+            n_top = n_surface + dn_dh * max_altitude
+
+        super().__init__(
+            name="Linear Gradient Atmosphere",
+            center=earth_center,
+            reference_radius=earth_radius,
+            altitude_range=(0.0, top_altitude * 1.1),
+            lut_resolution=5000,
+        )
+        self.n_surface = n_surface
+        self.n_top = n_top
+        self.top_altitude = top_altitude
+        self._gradient = (n_top - n_surface) / top_altitude
+
+    def n_at_altitude(self, altitude: float, wavelength: float | None = None) -> float:
+        """Linear interpolation of n with altitude."""
+        altitude = max(altitude, 0.0)
+        if altitude >= self.top_altitude:
+            return self.n_top
+        return self.n_surface + self._gradient * altitude
+
+    def dn_dh_at_altitude(
+        self, altitude: float, wavelength: float | None = None
+    ) -> float:
+        """Constant gradient."""
+        if altitude < 0 or altitude > self.top_altitude:
+            return 0.0
+        return self._gradient
+
+
+__all__ = ["LinearGradientAtmosphere"]