lsurf 1.0.0__py3-none-any.whl

lsurf/propagation/kernels/propagation/spectral.py

@@ -0,0 +1,875 @@
+# 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.
+
+"""
+GPU Kernels for SpectralInhomogeneousModel
+
+CUDA kernels for GPU-accelerated ray propagation through
+radially-symmetric materials with wavelength-dependent refractive index,
+using 2D lookup table interpolation (altitude × wavelength).
+"""
+
+import math
+
+# GPU support is optional
+try:
+    from numba import cuda
+
+    HAS_CUDA = True
+except ImportError:
+
+    class _FakeCuda:
+        """Fake cuda module for when numba is not installed."""
+
+        class devicearray:
+            """Fake devicearray submodule."""
+
+            DeviceNDArray = object
+
+        @staticmethod
+        def jit(*args, **kwargs):
+            """Return a no-op decorator."""
+
+            def decorator(func):
+                return func
+
+            if args and callable(args[0]):
+                return args[0]
+            return decorator
+
+        @staticmethod
+        def is_available():
+            return False
+
+        @staticmethod
+        def grid(n):
+            return 0
+
+        @staticmethod
+        def synchronize():
+            pass
+
+    cuda = _FakeCuda()  # type: ignore[assignment]
+    HAS_CUDA = False
+
+from ..device_functions import device_euler_step
+from ..registry import PropagationKernelID, register_kernel
+
+SPEED_OF_LIGHT = 299792458.0
+
+
+@cuda.jit(device=True)
+def _device_bilinear_interpolate(
+    val1: float,
+    val2: float,
+    lut: cuda.devicearray.DeviceNDArray,
+    min1: float,
+    delta1: float,
+    n1: int,
+    min2: float,
+    delta2: float,
+    n2: int,
+) -> float:
+    """
+    Generic bilinear interpolation in 2D LUT.
+
+    Parameters
+    ----------
+    val1 : float
+        Value in first dimension (e.g., altitude)
+    val2 : float
+        Value in second dimension (e.g., wavelength)
+    lut : device array
+        2D lookup table [dim1, dim2]
+    min1 : float
+        Minimum value in first dimension
+    delta1 : float
+        Spacing in first dimension
+    n1 : int
+        Number of entries in first dimension
+    min2 : float
+        Minimum value in second dimension
+    delta2 : float
+        Spacing in second dimension
+    n2 : int
+        Number of entries in second dimension
+
+    Returns
+    -------
+    float
+        Interpolated value
+    """
+    # Normalize coordinates to fractional indices
+    idx1 = (val1 - min1) / delta1
+    idx2 = (val2 - min2) / delta2
+
+    # Clamp to valid bounds
+    if idx1 < 0.0:
+        idx1 = 0.0
+    if idx1 > n1 - 1.001:
+        idx1 = n1 - 1.001
+    if idx2 < 0.0:
+        idx2 = 0.0
+    if idx2 > n2 - 1.001:
+        idx2 = n2 - 1.001
+
+    # Get integer indices
+    i0 = int(idx1)
+    j0 = int(idx2)
+    i1 = i0 + 1
+    j1 = j0 + 1
+
+    # Clamp upper indices
+    if i1 > n1 - 1:
+        i1 = n1 - 1
+    if j1 > n2 - 1:
+        j1 = n2 - 1
+
+    # Fractional parts
+    fi = idx1 - i0
+    fj = idx2 - j0
+
+    # Bilinear interpolation
+    c00 = lut[i0, j0]
+    c01 = lut[i0, j1]
+    c10 = lut[i1, j0]
+    c11 = lut[i1, j1]
+
+    # Interpolate along second dimension first
+    c0 = c00 * (1.0 - fj) + c01 * fj
+    c1 = c10 * (1.0 - fj) + c11 * fj
+
+    # Then interpolate along first dimension
+    return c0 * (1.0 - fi) + c1 * fi
+
+
+@cuda.jit(device=True)
+def _device_spectral_n_and_gradient(
+    x: float,
+    y: float,
+    z: float,
+    wavelength: float,
+    center_x: float,
+    center_y: float,
+    center_z: float,
+    ref_radius: float,
+    alt_min: float,
+    alt_delta: float,
+    n_alt: int,
+    wl_min: float,
+    wl_delta: float,
+    n_wl: int,
+    lut_n: cuda.devicearray.DeviceNDArray,
+    lut_dn_dh: cuda.devicearray.DeviceNDArray,
+) -> tuple[float, float, float, float]:
+    """
+    Compute n and gradient for any SpectralInhomogeneousModel.
+
+    Parameters
+    ----------
+    x, y, z : float
+        Position in Cartesian coordinates
+    wavelength : float
+        Wavelength in meters
+    center_x, center_y, center_z : float
+        Center of spherical symmetry
+    ref_radius : float
+        Reference radius (e.g., Earth radius)
+    alt_min : float
+        Minimum altitude in LUT
+    alt_delta : float
+        Altitude spacing in LUT
+    n_alt : int
+        Number of altitude samples in LUT
+    wl_min : float
+        Minimum wavelength in LUT
+    wl_delta : float
+        Wavelength spacing in LUT
+    n_wl : int
+        Number of wavelength samples in LUT
+    lut_n : device array
+        2D lookup table for n [altitude, wavelength]
+    lut_dn_dh : device array
+        2D lookup table for dn/dh [altitude, wavelength]
+
+    Returns
+    -------
+    tuple
+        (n, grad_x, grad_y, grad_z)
+    """
+    # Compute distance from center
+    dx = x - center_x
+    dy = y - center_y
+    dz = z - center_z
+    r = math.sqrt(dx * dx + dy * dy + dz * dz)
+
+    # Compute altitude
+    altitude = r - ref_radius
+    if altitude < 0.0:
+        altitude = 0.0
+
+    # 2D interpolation for n and dn/dh
+    n = _device_bilinear_interpolate(
+        altitude, wavelength, lut_n, alt_min, alt_delta, n_alt, wl_min, wl_delta, n_wl
+    )
+    dn_dh = _device_bilinear_interpolate(
+        altitude,
+        wavelength,
+        lut_dn_dh,
+        alt_min,
+        alt_delta,
+        n_alt,
+        wl_min,
+        wl_delta,
+        n_wl,
+    )
+
+    # Compute radial unit vector (gradient direction)
+    if r < 1e-10:
+        r_hat_x, r_hat_y, r_hat_z = 0.0, 0.0, 1.0
+    else:
+        r_inv = 1.0 / r
+        r_hat_x = dx * r_inv
+        r_hat_y = dy * r_inv
+        r_hat_z = dz * r_inv
+
+    # Gradient = dn/dh * r_hat
+    grad_x = dn_dh * r_hat_x
+    grad_y = dn_dh * r_hat_y
+    grad_z = dn_dh * r_hat_z
+
+    return n, grad_x, grad_y, grad_z
+
+
+@cuda.jit(device=True)
+def _device_spectral_euler_step(
+    x: float,
+    y: float,
+    z: float,
+    dir_x: float,
+    dir_y: float,
+    dir_z: float,
+    step_size: float,
+    wavelength: float,
+    center_x: float,
+    center_y: float,
+    center_z: float,
+    ref_radius: float,
+    alt_min: float,
+    alt_delta: float,
+    n_alt: int,
+    wl_min: float,
+    wl_delta: float,
+    n_wl: int,
+    lut_n: cuda.devicearray.DeviceNDArray,
+    lut_dn_dh: cuda.devicearray.DeviceNDArray,
+) -> tuple[float, float, float, float, float, float, float]:
+    """Euler step for SpectralInhomogeneousModel."""
+    n, grad_x, grad_y, grad_z = _device_spectral_n_and_gradient(
+        x,
+        y,
+        z,
+        wavelength,
+        center_x,
+        center_y,
+        center_z,
+        ref_radius,
+        alt_min,
+        alt_delta,
+        n_alt,
+        wl_min,
+        wl_delta,
+        n_wl,
+        lut_n,
+        lut_dn_dh,
+    )
+
+    new_x, new_y, new_z, new_dx, new_dy, new_dz = device_euler_step(
+        x, y, z, dir_x, dir_y, dir_z, n, grad_x, grad_y, grad_z, step_size
+    )
+
+    return new_x, new_y, new_z, new_dx, new_dy, new_dz, n
+
+
+@cuda.jit(device=True)
+def _device_spectral_rk4_step(
+    x: float,
+    y: float,
+    z: float,
+    dir_x: float,
+    dir_y: float,
+    dir_z: float,
+    step_size: float,
+    wavelength: float,
+    center_x: float,
+    center_y: float,
+    center_z: float,
+    ref_radius: float,
+    alt_min: float,
+    alt_delta: float,
+    n_alt: int,
+    wl_min: float,
+    wl_delta: float,
+    n_wl: int,
+    lut_n: cuda.devicearray.DeviceNDArray,
+    lut_dn_dh: cuda.devicearray.DeviceNDArray,
+) -> tuple[float, float, float, float, float, float, float]:
+    """RK4 step for SpectralInhomogeneousModel."""
+    h = step_size
+    h2 = h / 2.0
+
+    def get_n_and_kappa(px, py, pz, dx, dy, dz):
+        n, gx, gy, gz = _device_spectral_n_and_gradient(
+            px,
+            py,
+            pz,
+            wavelength,
+            center_x,
+            center_y,
+            center_z,
+            ref_radius,
+            alt_min,
+            alt_delta,
+            n_alt,
+            wl_min,
+            wl_delta,
+            n_wl,
+            lut_n,
+            lut_dn_dh,
+        )
+        dot = dx * gx + dy * gy + dz * gz
+        kx = (gx - dot * dx) / n
+        ky = (gy - dot * dy) / n
+        kz = (gz - dot * dz) / n
+        return n, kx, ky, kz
+
+    def normalize(dx, dy, dz):
+        norm = math.sqrt(dx * dx + dy * dy + dz * dz)
+        if norm < 1e-12:
+            norm = 1.0
+        return dx / norm, dy / norm, dz / norm
+
+    # k1
+    n0, kx1, ky1, kz1 = get_n_and_kappa(x, y, z, dir_x, dir_y, dir_z)
+    k1_rx, k1_ry, k1_rz = dir_x, dir_y, dir_z
+    k1_dx, k1_dy, k1_dz = kx1, ky1, kz1
+
+    # k2
+    px = x + h2 * k1_rx
+    py = y + h2 * k1_ry
+    pz = z + h2 * k1_rz
+    dx, dy, dz = normalize(dir_x + h2 * k1_dx, dir_y + h2 * k1_dy, dir_z + h2 * k1_dz)
+    n1, kx2, ky2, kz2 = get_n_and_kappa(px, py, pz, dx, dy, dz)
+    k2_rx, k2_ry, k2_rz = dx, dy, dz
+    k2_dx, k2_dy, k2_dz = kx2, ky2, kz2
+
+    # k3
+    px = x + h2 * k2_rx
+    py = y + h2 * k2_ry
+    pz = z + h2 * k2_rz
+    dx, dy, dz = normalize(dir_x + h2 * k2_dx, dir_y + h2 * k2_dy, dir_z + h2 * k2_dz)
+    n2, kx3, ky3, kz3 = get_n_and_kappa(px, py, pz, dx, dy, dz)
+    k3_rx, k3_ry, k3_rz = dx, dy, dz
+    k3_dx, k3_dy, k3_dz = kx3, ky3, kz3
+
+    # k4
+    px = x + h * k3_rx
+    py = y + h * k3_ry
+    pz = z + h * k3_rz
+    dx, dy, dz = normalize(dir_x + h * k3_dx, dir_y + h * k3_dy, dir_z + h * k3_dz)
+    n3, kx4, ky4, kz4 = get_n_and_kappa(px, py, pz, dx, dy, dz)
+
+    # Final RK4 combination
+    new_x = x + (h / 6.0) * (k1_rx + 2 * k2_rx + 2 * k3_rx + dx)
+    new_y = y + (h / 6.0) * (k1_ry + 2 * k2_ry + 2 * k3_ry + dy)
+    new_z = z + (h / 6.0) * (k1_rz + 2 * k2_rz + 2 * k3_rz + dz)
+
+    new_dx = dir_x + (h / 6.0) * (k1_dx + 2 * k2_dx + 2 * k3_dx + kx4)
+    new_dy = dir_y + (h / 6.0) * (k1_dy + 2 * k2_dy + 2 * k3_dy + ky4)
+    new_dz = dir_z + (h / 6.0) * (k1_dz + 2 * k2_dz + 2 * k3_dz + kz4)
+
+    new_dx, new_dy, new_dz = normalize(new_dx, new_dy, new_dz)
+
+    # Simpson's rule for average n
+    n_avg = (n0 + 4 * n1 + n2) / 6.0
+
+    return new_x, new_y, new_z, new_dx, new_dy, new_dz, n_avg
+
+
+@register_kernel(PropagationKernelID.SPECTRAL_EULER)
+@cuda.jit
+def _kernel_spectral_inhomogeneous_euler(
+    positions,
+    directions,
+    active,
+    geo_path,
+    opt_path,
+    acc_time,
+    step_size: float,
+    num_steps: int,
+    center_x: float,
+    center_y: float,
+    center_z: float,
+    ref_radius: float,
+    alt_min: float,
+    alt_delta: float,
+    n_alt: int,
+    wl_min: float,
+    wl_delta: float,
+    n_wl: int,
+    lut_n,
+    lut_dn_dh,
+    wavelength: float,
+):
+    """
+    GPU kernel for SpectralInhomogeneousModel using Euler integration.
+
+    Parameters
+    ----------
+    positions : device array, shape (N, 3)
+        Ray positions
+    directions : device array, shape (N, 3)
+        Ray directions (unit vectors)
+    active : device array, shape (N,)
+        Boolean mask for active rays
+    geo_path : device array, shape (N,)
+        Accumulated geometric path length
+    opt_path : device array, shape (N,)
+        Accumulated optical path length
+    acc_time : device array, shape (N,)
+        Accumulated travel time
+    step_size : float
+        Integration step size in meters
+    num_steps : int
+        Number of steps to take
+    center_x, center_y, center_z : float
+        Center of spherical symmetry
+    ref_radius : float
+        Reference radius
+    alt_min : float
+        Minimum altitude in LUT
+    alt_delta : float
+        Altitude spacing in LUT
+    n_alt : int
+        Number of altitude samples
+    wl_min : float
+        Minimum wavelength in LUT
+    wl_delta : float
+        Wavelength spacing in LUT
+    n_wl : int
+        Number of wavelength samples
+    lut_n : device array, shape (n_alt, n_wl)
+        2D lookup table for n
+    lut_dn_dh : device array, shape (n_alt, n_wl)
+        2D lookup table for dn/dh
+    wavelength : float
+        Wavelength in meters (same for all rays in this kernel call)
+    """
+    c = SPEED_OF_LIGHT
+
+    idx = cuda.grid(1)
+    if idx >= positions.shape[0]:
+        return
+    if not active[idx]:
+        return
+
+    # Load ray state
+    x = positions[idx, 0]
+    y = positions[idx, 1]
+    z = positions[idx, 2]
+    dx = directions[idx, 0]
+    dy = directions[idx, 1]
+    dz = directions[idx, 2]
+    gp = geo_path[idx]
+    op = opt_path[idx]
+    at = acc_time[idx]
+
+    for _ in range(num_steps):
+        x, y, z, dx, dy, dz, n = _device_spectral_euler_step(
+            x,
+            y,
+            z,
+            dx,
+            dy,
+            dz,
+            step_size,
+            wavelength,
+            center_x,
+            center_y,
+            center_z,
+            ref_radius,
+            alt_min,
+            alt_delta,
+            n_alt,
+            wl_min,
+            wl_delta,
+            n_wl,
+            lut_n,
+            lut_dn_dh,
+        )
+        gp += step_size
+        op += n * step_size
+        at += n * step_size / c
+
+    # Store updated state
+    positions[idx, 0] = x
+    positions[idx, 1] = y
+    positions[idx, 2] = z
+    directions[idx, 0] = dx
+    directions[idx, 1] = dy
+    directions[idx, 2] = dz
+    geo_path[idx] = gp
+    opt_path[idx] = op
+    acc_time[idx] = at
+
+
+@register_kernel(PropagationKernelID.SPECTRAL_RK4)
+@cuda.jit
+def _kernel_spectral_inhomogeneous_rk4(
+    positions,
+    directions,
+    active,
+    geo_path,
+    opt_path,
+    acc_time,
+    step_size: float,
+    num_steps: int,
+    center_x: float,
+    center_y: float,
+    center_z: float,
+    ref_radius: float,
+    alt_min: float,
+    alt_delta: float,
+    n_alt: int,
+    wl_min: float,
+    wl_delta: float,
+    n_wl: int,
+    lut_n,
+    lut_dn_dh,
+    wavelength: float,
+):
+    """
+    GPU kernel for SpectralInhomogeneousModel using RK4 integration.
+
+    Parameters
+    ----------
+    Same as _kernel_spectral_inhomogeneous_euler
+    """
+    c = SPEED_OF_LIGHT
+
+    idx = cuda.grid(1)
+    if idx >= positions.shape[0]:
+        return
+    if not active[idx]:
+        return
+
+    # Load ray state
+    x = positions[idx, 0]
+    y = positions[idx, 1]
+    z = positions[idx, 2]
+    dx = directions[idx, 0]
+    dy = directions[idx, 1]
+    dz = directions[idx, 2]
+    gp = geo_path[idx]
+    op = opt_path[idx]
+    at = acc_time[idx]
+
+    for _ in range(num_steps):
+        x, y, z, dx, dy, dz, n_avg = _device_spectral_rk4_step(
+            x,
+            y,
+            z,
+            dx,
+            dy,
+            dz,
+            step_size,
+            wavelength,
+            center_x,
+            center_y,
+            center_z,
+            ref_radius,
+            alt_min,
+            alt_delta,
+            n_alt,
+            wl_min,
+            wl_delta,
+            n_wl,
+            lut_n,
+            lut_dn_dh,
+        )
+        gp += step_size
+        op += n_avg * step_size
+        at += n_avg * step_size / c
+
+    # Store updated state
+    positions[idx, 0] = x
+    positions[idx, 1] = y
+    positions[idx, 2] = z
+    directions[idx, 0] = dx
+    directions[idx, 1] = dy
+    directions[idx, 2] = dz
+    geo_path[idx] = gp
+    opt_path[idx] = op
+    acc_time[idx] = at
+
+
+# =============================================================================
+# PER-RAY WAVELENGTH KERNELS
+# =============================================================================
+# These variants take wavelength as a per-ray array instead of a scalar.
+# Use with SpectralGPUGradientPropagator for chromatic dispersion simulation.
+
+
+@register_kernel(PropagationKernelID.SPECTRAL_EULER_PERRAY)
+@cuda.jit
+def _kernel_spectral_inhomogeneous_euler_perray(
+    positions,
+    directions,
+    wavelengths,  # Per-ray wavelength array, shape (N,)
+    active,
+    geo_path,
+    opt_path,
+    acc_time,
+    step_size: float,
+    num_steps: int,
+    center_x: float,
+    center_y: float,
+    center_z: float,
+    ref_radius: float,
+    alt_min: float,
+    alt_delta: float,
+    n_alt: int,
+    wl_min: float,
+    wl_delta: float,
+    n_wl: int,
+    lut_n,
+    lut_dn_dh,
+):
+    """
+    GPU kernel for SpectralInhomogeneousModel with per-ray wavelengths.
+
+    Uses Euler integration. Each ray has its own wavelength value,
+    allowing simulation of chromatic dispersion.
+
+    Parameters
+    ----------
+    positions : device array, shape (N, 3)
+        Ray positions
+    directions : device array, shape (N, 3)
+        Ray directions (unit vectors)
+    wavelengths : device array, shape (N,)
+        Per-ray wavelengths in meters
+    active : device array, shape (N,)
+        Boolean mask for active rays
+    geo_path : device array, shape (N,)
+        Accumulated geometric path length
+    opt_path : device array, shape (N,)
+        Accumulated optical path length
+    acc_time : device array, shape (N,)
+        Accumulated travel time
+    step_size : float
+        Integration step size in meters
+    num_steps : int
+        Number of steps to take
+    center_x, center_y, center_z : float
+        Center of spherical symmetry
+    ref_radius : float
+        Reference radius
+    alt_min : float
+        Minimum altitude in LUT
+    alt_delta : float
+        Altitude spacing in LUT
+    n_alt : int
+        Number of altitude samples
+    wl_min : float
+        Minimum wavelength in LUT
+    wl_delta : float
+        Wavelength spacing in LUT
+    n_wl : int
+        Number of wavelength samples
+    lut_n : device array, shape (n_alt, n_wl)
+        2D lookup table for n
+    lut_dn_dh : device array, shape (n_alt, n_wl)
+        2D lookup table for dn/dh
+    """
+    c = SPEED_OF_LIGHT
+
+    idx = cuda.grid(1)
+    if idx >= positions.shape[0]:
+        return
+    if not active[idx]:
+        return
+
+    # Load ray state including per-ray wavelength
+    x = positions[idx, 0]
+    y = positions[idx, 1]
+    z = positions[idx, 2]
+    dx = directions[idx, 0]
+    dy = directions[idx, 1]
+    dz = directions[idx, 2]
+    wavelength = wavelengths[idx]  # Per-ray wavelength
+    gp = geo_path[idx]
+    op = opt_path[idx]
+    at = acc_time[idx]
+
+    for _ in range(num_steps):
+        x, y, z, dx, dy, dz, n = _device_spectral_euler_step(
+            x,
+            y,
+            z,
+            dx,
+            dy,
+            dz,
+            step_size,
+            wavelength,
+            center_x,
+            center_y,
+            center_z,
+            ref_radius,
+            alt_min,
+            alt_delta,
+            n_alt,
+            wl_min,
+            wl_delta,
+            n_wl,
+            lut_n,
+            lut_dn_dh,
+        )
+        gp += step_size
+        op += n * step_size
+        at += n * step_size / c
+
+    # Store updated state
+    positions[idx, 0] = x
+    positions[idx, 1] = y
+    positions[idx, 2] = z
+    directions[idx, 0] = dx
+    directions[idx, 1] = dy
+    directions[idx, 2] = dz
+    geo_path[idx] = gp
+    opt_path[idx] = op
+    acc_time[idx] = at
+
+
+@register_kernel(PropagationKernelID.SPECTRAL_RK4_PERRAY)
+@cuda.jit
+def _kernel_spectral_inhomogeneous_rk4_perray(
+    positions,
+    directions,
+    wavelengths,  # Per-ray wavelength array, shape (N,)
+    active,
+    geo_path,
+    opt_path,
+    acc_time,
+    step_size: float,
+    num_steps: int,
+    center_x: float,
+    center_y: float,
+    center_z: float,
+    ref_radius: float,
+    alt_min: float,
+    alt_delta: float,
+    n_alt: int,
+    wl_min: float,
+    wl_delta: float,
+    n_wl: int,
+    lut_n,
+    lut_dn_dh,
+):
+    """
+    GPU kernel for SpectralInhomogeneousModel with per-ray wavelengths.
+
+    Uses RK4 integration. Each ray has its own wavelength value,
+    allowing simulation of chromatic dispersion.
+
+    Parameters
+    ----------
+    Same as _kernel_spectral_inhomogeneous_euler_perray
+    """
+    c = SPEED_OF_LIGHT
+
+    idx = cuda.grid(1)
+    if idx >= positions.shape[0]:
+        return
+    if not active[idx]:
+        return
+
+    # Load ray state including per-ray wavelength
+    x = positions[idx, 0]
+    y = positions[idx, 1]
+    z = positions[idx, 2]
+    dx = directions[idx, 0]
+    dy = directions[idx, 1]
+    dz = directions[idx, 2]
+    wavelength = wavelengths[idx]  # Per-ray wavelength
+    gp = geo_path[idx]
+    op = opt_path[idx]
+    at = acc_time[idx]
+
+    for _ in range(num_steps):
+        x, y, z, dx, dy, dz, n_avg = _device_spectral_rk4_step(
+            x,
+            y,
+            z,
+            dx,
+            dy,
+            dz,
+            step_size,
+            wavelength,
+            center_x,
+            center_y,
+            center_z,
+            ref_radius,
+            alt_min,
+            alt_delta,
+            n_alt,
+            wl_min,
+            wl_delta,
+            n_wl,
+            lut_n,
+            lut_dn_dh,
+        )
+        gp += step_size
+        op += n_avg * step_size
+        at += n_avg * step_size / c
+
+    # Store updated state
+    positions[idx, 0] = x
+    positions[idx, 1] = y
+    positions[idx, 2] = z
+    directions[idx, 0] = dx
+    directions[idx, 1] = dy
+    directions[idx, 2] = dz
+    geo_path[idx] = gp
+    opt_path[idx] = op
+    acc_time[idx] = at