lsurf 1.0.0__py3-none-any.whl

lsurf/materials/implementations/linsley_atmosphere.py

@@ -0,0 +1,764 @@
+# 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.
+
+"""
+Linsley Atmosphere Model
+
+GPU-compatible implementation of Linsley's 5-layer atmospheric model with
+wavelength-dependent refraction (dispersion) and optional extinction data.
+
+Physics:
+- Density: ρ(z) = (b[layer] / c[layer]) * exp(-z / c[layer])
+- Refraction: n(z, λ) = 1 + 0.283e-3 * (ρ(z)/ρ₀) * (0.967 + 0.033 * (400/λ)^2.5)
+- Extinction: From Elterman (1968) data tables + Rayleigh above 50km
+
+References:
+- J. Linsley, Proc. 15th ICRC, 12:89, 1977
+- L. Elterman, Number Tech. Rep. AFCRL-68-0153, 1968
+- K. Bernlohr, Astropart. Phys., 30:149-158, 2008
+- Handbook of Chemistry and Physics, 67th Edition
+"""
+
+from pathlib import Path
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.interpolate import RegularGridInterpolator
+
+from ..base.spectral_inhomogeneous import SpectralInhomogeneousModel
+
+# =============================================================================
+# Linsley (1981) US Standard Atmosphere Parameterization
+# =============================================================================
+
+# Layer boundaries in km: 0-4, 4-10, 10-40, 40-100, 100+
+LAYER_BOUNDARIES_KM = np.array([4.0, 10.0, 40.0, 100.0])
+
+# Linsley parameters for each layer (5 layers)
+# b values in g/cm²
+ATMOS_B = np.array([1222.6562, 1144.9069, 1305.5948, 540.1778, 1.0])
+# c values in cm (scale heights)
+ATMOS_C = np.array([994186.38, 878153.55, 636143.04, 772170.16, 1e9])
+
+# Physical constants
+N_AVOGADRO = 6.02214076e23  # mol⁻¹
+MM_AIR = 28.966  # g/mol (mean molecular mass of air)
+Z_MAX_KM = 112.8  # Maximum altitude in model (km)
+ALT_MAX_KM = 100.0  # Maximum altitude for extinction data (km)
+
+# Standard conditions
+N_STP_MINUS_1 = 0.283e-3  # (n - 1) at STP
+
+# Earth radius in meters
+EARTH_RADIUS_M = 6_371_000.0
+
+# King factor for Rayleigh scattering (depolarization correction)
+# From: Thalman et al., J. Quant. Spectrosc. Radiat. Transf., 147:171-177, 2014
+FK_KING = 1.0608
+
+
+class LinsleyAtmosphere(SpectralInhomogeneousModel):
+    """
+    Linsley's 5-layer atmospheric model with wavelength dispersion.
+
+    This model provides:
+    - Atmospheric density profile from Linsley's parameterization
+    - Wavelength-dependent refractive index with dispersion
+    - Optional Elterman extinction coefficients for optical depth
+    - Rayleigh scattering coefficients
+
+    The refractive index formula combines:
+    - Baseline n(z) from density ratio: n = 1 + 0.283e-3 * (ρ/ρ₀)
+    - Wavelength correction: factor = 0.967 + 0.033 * (400/λ)^2.5
+
+    Parameters
+    ----------
+    name : str
+        Name of the atmosphere model
+    earth_radius : float
+        Earth radius in meters. Default: 6,371,000
+    earth_center : tuple
+        Center of Earth (x, y, z) in meters. Default: (0, 0, 0)
+    altitude_range : tuple
+        (min, max) altitude in meters for LUT. Default: (0, 120,000)
+    altitude_resolution : int
+        Number of altitude samples in LUT. Default: 1200
+    wavelength_range : tuple
+        (min, max) wavelength in meters. Default: (270e-9, 4000e-9)
+    wavelength_resolution : int
+        Number of wavelength samples in LUT. Default: 100
+    extinction_data_file : str or None
+        Path to extinction coefficient data file. If None, uses default.
+
+    Example
+    -------
+    >>> atm = LinsleyAtmosphere()
+    >>> n = atm.n_at_altitude(10000, 550e-9)  # n at 10km, 550nm
+    >>> rho = atm.density_at_altitude(5000)   # density at 5km
+    """
+
+    def __init__(
+        self,
+        name: str = "Linsley Atmosphere",
+        earth_radius: float = EARTH_RADIUS_M,
+        earth_center: tuple[float, float, float] = (0.0, 0.0, 0.0),
+        altitude_range: tuple[float, float] = (0.0, 120_000.0),
+        altitude_resolution: int = 1200,
+        wavelength_range: tuple[float, float] = (270e-9, 4000e-9),
+        wavelength_resolution: int = 100,
+        extinction_data_file: str | Path | None = None,
+    ):
+        super().__init__(
+            name=name,
+            center=earth_center,
+            reference_radius=earth_radius,
+            altitude_range=altitude_range,
+            altitude_resolution=altitude_resolution,
+            wavelength_range=wavelength_range,
+            wavelength_resolution=wavelength_resolution,
+        )
+
+        # Precompute sea-level density for normalization
+        self._rho_sea_level = self._compute_density_km(0.0)
+
+        # Load extinction data
+        self._ext_wavelengths: NDArray[np.float64] | None = None
+        self._ext_altitudes: NDArray[np.float64] | None = None
+        self._ext_coefficients: NDArray[np.float64] | None = None
+        self._ext_interpolator: RegularGridInterpolator | None = None
+
+        if extinction_data_file is not None:
+            self._load_extinction_data(Path(extinction_data_file))
+        else:
+            # Try to load default data file
+            default_path = (
+                Path(__file__).parent
+                / "data"
+                / "alpha_values_typical_atmosphere_updated.txt"
+            )
+            if default_path.exists():
+                self._load_extinction_data(default_path)
+
+    # =========================================================================
+    # CORE PHYSICS: Density Profile
+    # =========================================================================
+
+    def _get_layer_index(
+        self, z_km: float | NDArray[np.float64]
+    ) -> int | NDArray[np.int64]:
+        """Get atmospheric layer index for altitude(s) in km."""
+        z_km = np.asarray(z_km)
+        scalar_input = z_km.ndim == 0
+        z_km = np.atleast_1d(z_km)
+
+        # Find layer: 0 for 0-4km, 1 for 4-10km, etc.
+        layer = np.searchsorted(LAYER_BOUNDARIES_KM, z_km, side="right")
+        layer = np.clip(layer, 0, 4)
+
+        return int(layer[0]) if scalar_input else layer
+
+    def _compute_density_km(
+        self, z_km: float | NDArray[np.float64]
+    ) -> float | NDArray[np.float64]:
+        """
+        Compute atmospheric density in g/cm³ for altitude in km.
+
+        Uses Linsley's 5-layer parameterization.
+        """
+        z_km = np.asarray(z_km)
+        scalar_input = z_km.ndim == 0
+        z_km = np.atleast_1d(z_km)
+
+        layer = self._get_layer_index(z_km)
+
+        # Vectorized computation
+        b = ATMOS_B[layer]
+        c = ATMOS_C[layer]
+
+        # Convert altitude to cm for c values (which are in cm)
+        z_cm = z_km * 1e5
+
+        density = np.where(
+            layer < 4,
+            (b / c) * np.exp(-z_cm / c),
+            1.0 / c,  # Layer 4 is constant (very thin)
+        )
+
+        # Above maximum altitude, density is 0
+        density = np.where(z_km > Z_MAX_KM, 0.0, density)
+
+        return float(density[0]) if scalar_input else density
+
+    def density_at_altitude(self, altitude: float) -> float:
+        """
+        Get atmospheric density at altitude.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+
+        Returns
+        -------
+        float
+            Density in g/cm³
+        """
+        return float(self._compute_density_km(altitude / 1000.0))
+
+    def density_ratio(self, altitude: float) -> float:
+        """
+        Get density ratio ρ(z)/ρ(0) at altitude.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+
+        Returns
+        -------
+        float
+            Density ratio (dimensionless)
+        """
+        return self.density_at_altitude(altitude) / self._rho_sea_level
+
+    def number_density(self, altitude: float) -> float:
+        """
+        Get particle number density at altitude.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+
+        Returns
+        -------
+        float
+            Number density in particles/cm³
+        """
+        rho = self.density_at_altitude(altitude)
+        return rho * (N_AVOGADRO / MM_AIR)
+
+    # =========================================================================
+    # CORE PHYSICS: Refractive Index
+    # =========================================================================
+
+    def n_at_altitude(self, altitude: float, wavelength: float) -> float:
+        """
+        Compute refractive index at altitude and wavelength.
+
+        Uses baseline approximation from Handbook of Chemistry and Physics
+        with wavelength correction from Bernlohr (2008).
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+        wavelength : float
+            Wavelength in meters
+
+        Returns
+        -------
+        float
+            Refractive index n
+        """
+        # Density ratio
+        rho_ratio = self.density_ratio(altitude)
+
+        # Baseline n at this density
+        n_minus_1_base = N_STP_MINUS_1 * rho_ratio
+
+        # Wavelength correction factor
+        # Convert wavelength to nm for the formula
+        lambda_nm = wavelength * 1e9
+        correction = 0.967 + 0.033 * (400.0 / lambda_nm) ** 2.5
+
+        return 1.0 + n_minus_1_base * correction
+
+    def dn_dh_at_altitude(self, altitude: float, wavelength: float) -> float:
+        """
+        Compute analytical derivative dn/dh at altitude and wavelength.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+        wavelength : float
+            Wavelength in meters
+
+        Returns
+        -------
+        float
+            Derivative dn/dh in m⁻¹
+        """
+        # Get layer parameters
+        z_km = altitude / 1000.0
+
+        # Handle altitude above model
+        if z_km > Z_MAX_KM:
+            return 0.0
+
+        layer = self._get_layer_index(z_km)
+
+        # For layer 4 (constant density), derivative is 0
+        if layer >= 4:
+            return 0.0
+
+        c_cm = ATMOS_C[layer]
+        c_m = c_cm / 100.0  # Convert to meters
+
+        # d(n-1)/dh = -(n-1) / c for exponential atmosphere
+        n = self.n_at_altitude(altitude, wavelength)
+        n_minus_1 = n - 1.0
+
+        # Derivative: dn/dh = d(n-1)/dh = -(n-1) / c
+        return -n_minus_1 / c_m
+
+    def alpha_at_altitude(self, altitude: float, wavelength: float) -> float:
+        """
+        Return absorption/extinction coefficient at altitude and wavelength.
+
+        Uses Elterman extinction data if available, otherwise Rayleigh scattering.
+        This enables Beer-Lambert absorption during ray propagation.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+        wavelength : float
+            Wavelength in meters
+
+        Returns
+        -------
+        float
+            Extinction coefficient α in m⁻¹
+        """
+        return self.get_extinction_coefficient(altitude, wavelength)
+
+    # =========================================================================
+    # EXTINCTION AND SCATTERING
+    # =========================================================================
+
+    def _load_extinction_data(self, file_path: Path) -> None:
+        """
+        Load Elterman (1968) extinction coefficients.
+
+        File format:
+        - Row 1: Wavelengths in nm
+        - Row 2: Altitudes in km
+        - Rows 3+: Extinction coefficients in km⁻¹ for each wavelength
+        """
+        # Load wavelengths (nm)
+        wavelengths = np.loadtxt(file_path, delimiter=",", max_rows=1)
+
+        # Load altitudes (km)
+        altitudes = np.loadtxt(file_path, delimiter=",", skiprows=1, max_rows=1)
+
+        # Load extinction coefficients (km⁻¹)
+        coefficients = np.loadtxt(file_path, delimiter=",", skiprows=2)
+
+        # Remove any 0 values (replace with small number)
+        coefficients[coefficients == 0.0] = 1e-10
+
+        # Convert to m⁻¹ and take log for smooth interpolation
+        # Store log(alpha) to enable interpolation in log space
+        self._ext_coefficients_log = np.log(coefficients / 1000.0)  # m⁻¹
+
+        # Store raw data
+        self._ext_wavelengths = wavelengths  # nm
+        self._ext_altitudes = altitudes  # km
+        self._ext_coefficients = coefficients / 1000.0  # m⁻¹
+
+        # Create interpolator (wavelength, altitude) -> log(extinction)
+        # Note: coefficients shape is (n_wavelengths, n_altitudes)
+        self._ext_interpolator = RegularGridInterpolator(
+            (wavelengths, altitudes),
+            self._ext_coefficients_log,
+            method="linear",
+            bounds_error=False,
+            fill_value=-20.0,  # exp(-20) ≈ 0
+        )
+
+    def get_extinction_coefficient(
+        self, altitude: float, wavelength: float, use_rayleigh_above_50km: bool = True
+    ) -> float:
+        """
+        Get extinction coefficient from Elterman data.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+        wavelength : float
+            Wavelength in meters
+        use_rayleigh_above_50km : bool
+            If True, use Rayleigh scattering above 50km instead of data
+
+        Returns
+        -------
+        float
+            Extinction coefficient in m⁻¹
+        """
+        z_km = altitude / 1000.0
+        lambda_nm = wavelength * 1e9
+
+        # Above max altitude, no extinction
+        if z_km > ALT_MAX_KM:
+            return 0.0
+
+        # Above 50km, optionally use Rayleigh only
+        if use_rayleigh_above_50km and z_km > 50.0:
+            return self.rayleigh_extinction(altitude, wavelength)
+
+        # Interpolate from data
+        if self._ext_interpolator is not None:
+            log_alpha = float(self._ext_interpolator((lambda_nm, z_km)))
+            return np.exp(log_alpha)
+
+        # Fallback to Rayleigh if no data
+        return self.rayleigh_extinction(altitude, wavelength)
+
+    def rayleigh_extinction(self, altitude: float, wavelength: float) -> float:
+        """
+        Compute Rayleigh scattering extinction coefficient.
+
+        From Lord Rayleigh with King factor correction.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+        wavelength : float
+            Wavelength in meters
+
+        Returns
+        -------
+        float
+            Rayleigh extinction coefficient in m⁻¹
+        """
+        # Get refractive index and number density
+        n = self.n_at_altitude(altitude, wavelength)
+        n_squared = n * n
+        N = self.number_density(altitude) * 1e6  # Convert cm⁻³ to m⁻³
+
+        # Avoid division by zero
+        if N < 1e-10:
+            return 0.0
+
+        # Rayleigh formula with King factor
+        alpha_rayleigh = (
+            24.0
+            * np.pi**3
+            * ((n_squared - 1) / (n_squared + 2)) ** 2
+            * FK_KING
+            / (wavelength**4 * N)
+        )
+
+        return float(alpha_rayleigh)
+
+    def get_scattering_coefficient(
+        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]:
+        """
+        Get scattering coefficient at position.
+
+        Uses extinction data below 50km, Rayleigh above.
+        """
+        altitude = self._compute_altitude(x, y, z)
+
+        if isinstance(altitude, np.ndarray):
+            wavelength = np.atleast_1d(wavelength)
+            if altitude.shape != wavelength.shape:
+                altitude, wavelength = np.broadcast_arrays(altitude, wavelength)
+            return np.array(
+                [
+                    self.get_extinction_coefficient(float(h), float(wl))
+                    for h, wl in zip(altitude.flat, wavelength.flat)
+                ]
+            ).reshape(altitude.shape)
+
+        return self.get_extinction_coefficient(float(altitude), float(wavelength))
+
+    # =========================================================================
+    # OPTICAL DEPTH CALCULATION
+    # =========================================================================
+
+    def optical_depth_vertical(
+        self,
+        z1: float,
+        z2: float,
+        wavelength: float,
+        num_points: int = 100,
+        use_rayleigh_above_50km: bool = True,
+    ) -> float:
+        """
+        Compute optical depth for vertical path between two altitudes.
+
+        Parameters
+        ----------
+        z1 : float
+            Starting altitude in meters (lower)
+        z2 : float
+            Ending altitude in meters (upper)
+        wavelength : float
+            Wavelength in meters
+        num_points : int
+            Number of integration points
+        use_rayleigh_above_50km : bool
+            Use Rayleigh scattering above 50km
+
+        Returns
+        -------
+        float
+            Optical depth (dimensionless)
+        """
+        # Integration points
+        altitudes = np.linspace(z1, z2, num_points)
+
+        # Get extinction at each point
+        extinctions = np.array(
+            [
+                self.get_extinction_coefficient(h, wavelength, use_rayleigh_above_50km)
+                for h in altitudes
+            ]
+        )
+
+        # Trapezoidal integration
+        return float(np.trapezoid(extinctions, altitudes))
+
+    def optical_depth_slant(
+        self,
+        positions: NDArray[np.float64],
+        wavelength: float,
+        use_rayleigh_above_50km: bool = True,
+    ) -> NDArray[np.float64]:
+        """
+        Compute cumulative optical depth along a slant path.
+
+        Parameters
+        ----------
+        positions : ndarray of shape (N, 3)
+            Positions along the path in meters
+        wavelength : float
+            Wavelength in meters
+        use_rayleigh_above_50km : bool
+            Use Rayleigh scattering above 50km
+
+        Returns
+        -------
+        ndarray of shape (N,)
+            Cumulative optical depth at each position
+        """
+        # Compute altitudes
+        altitudes = self._compute_altitude(
+            positions[:, 0], positions[:, 1], positions[:, 2]
+        )
+
+        # Get extinctions
+        extinctions = np.array(
+            [
+                self.get_extinction_coefficient(
+                    float(h), wavelength, use_rayleigh_above_50km
+                )
+                for h in altitudes
+            ]
+        )
+
+        # Compute path lengths between points
+        diffs = np.diff(positions, axis=0)
+        path_lengths = np.sqrt(np.sum(diffs**2, axis=1))
+
+        # Cumulative integration using midpoint rule
+        mid_extinctions = (extinctions[:-1] + extinctions[1:]) / 2
+        optical_depths = np.zeros(len(positions))
+        optical_depths[1:] = np.cumsum(mid_extinctions * path_lengths)
+
+        return optical_depths
+
+    # =========================================================================
+    # ADDITIONAL ATMOSPHERIC PROPERTIES
+    # =========================================================================
+
+    def moliere_radius(self, altitude: float) -> float:
+        """
+        Compute Molière radius at altitude.
+
+        The Molière radius characterizes multiple Coulomb scattering.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+
+        Returns
+        -------
+        float
+            Molière radius in meters
+        """
+        # Molière radius: r_M = X_0 / (rho * 9.6 MeV/c)
+        # X_0 for air ≈ 36.62 g/cm²
+        X_0_AIR = 36.62  # g/cm²
+        rho = self.density_at_altitude(altitude)  # g/cm³
+
+        if rho < 1e-20:
+            return float("inf")
+
+        # r_M in cm, convert to m
+        r_M_cm = X_0_AIR / (rho * 9.6)
+        return r_M_cm / 100.0
+
+    def scale_height(self, altitude: float) -> float:
+        """
+        Get atmospheric scale height at altitude.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+
+        Returns
+        -------
+        float
+            Scale height in meters
+        """
+        z_km = altitude / 1000.0
+
+        if z_km > Z_MAX_KM:
+            return float("inf")
+
+        layer = self._get_layer_index(z_km)
+
+        if layer >= 4:
+            return float("inf")
+
+        # c is scale height in cm, convert to m
+        return ATMOS_C[layer] / 100.0
+
+    def pressure_at_altitude(self, altitude: float) -> float:
+        """
+        Estimate atmospheric pressure at altitude.
+
+        Uses ideal gas approximation: P ∝ ρ * T, with isothermal assumption.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+
+        Returns
+        -------
+        float
+            Pressure in Pa (approximate)
+        """
+        # Sea level pressure
+        P_0 = 101325.0  # Pa
+
+        # Pressure ratio ≈ density ratio for isothermal atmosphere
+        return P_0 * self.density_ratio(altitude)
+
+    def temperature_at_altitude(self, altitude: float) -> float:
+        """
+        Estimate temperature at altitude using standard lapse rate.
+
+        Parameters
+        ----------
+        altitude : float
+            Altitude in meters
+
+        Returns
+        -------
+        float
+            Temperature in Kelvin (approximate)
+        """
+        z_km = altitude / 1000.0
+
+        # Standard atmosphere temperature profile (simplified)
+        if z_km < 11.0:
+            # Troposphere: -6.5 K/km lapse rate
+            return 288.15 - 6.5 * z_km
+        elif z_km < 20.0:
+            # Tropopause: isothermal
+            return 216.65
+        elif z_km < 47.0:
+            # Stratosphere: +1-3 K/km
+            return 216.65 + 1.0 * (z_km - 20.0)
+        else:
+            # Upper atmosphere: complex, use constant
+            return 270.0
+
+
+# =============================================================================
+# Factory Functions
+# =============================================================================
+
+
+def create_linsley_atmosphere(
+    earth_center: tuple[float, float, float] = (0.0, 0.0, 0.0),
+    earth_radius: float = EARTH_RADIUS_M,
+    with_extinction: bool = True,
+) -> LinsleyAtmosphere:
+    """
+    Create a LinsleyAtmosphere with standard parameters.
+
+    Parameters
+    ----------
+    earth_center : tuple
+        Center of Earth in meters
+    earth_radius : float
+        Earth radius in meters
+    with_extinction : bool
+        Whether to load extinction data
+
+    Returns
+    -------
+    LinsleyAtmosphere
+        Configured atmosphere model
+    """
+    extinction_file = None
+    if with_extinction:
+        default_path = (
+            Path(__file__).parent
+            / "data"
+            / "alpha_values_typical_atmosphere_updated.txt"
+        )
+        if default_path.exists():
+            extinction_file = default_path
+
+    return LinsleyAtmosphere(
+        earth_center=earth_center,
+        earth_radius=earth_radius,
+        extinction_data_file=extinction_file,
+    )