lsurf 1.0.0__py3-none-any.whl

lsurf/propagation/propagator_protocol.py

@@ -0,0 +1,222 @@
+# 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.
+
+"""
+Protocol definitions for ray propagators and GPU materials.
+
+This module defines:
+- RayPropagatorProtocol: Common interface for CPU/GPU propagators
+- MaterialFieldProtocol: Interface for materials providing refractive index
+- GPUMaterialProtocol: Interface for GPU-accelerated materials
+- GPUMaterialID: Enum for GPU material types
+"""
+
+from enum import IntEnum
+from typing import Protocol, runtime_checkable
+
+import numpy.typing as npt
+
+
+# =============================================================================
+# GPU Material Registry
+# =============================================================================
+
+
+class GPUMaterialID(IntEnum):
+    """
+    Registry of GPU-compatible material types.
+
+    Each material type has specialized device functions compiled into the
+    CUDA kernels. This enum identifies which material's functions to use.
+
+    Tiers:
+    - EXPONENTIAL_ATMOSPHERE (1): Legacy specialized kernels
+    - SIMPLE_INHOMOGENEOUS (2): 1D radial profile via LUT interpolation
+    - GRID_INHOMOGENEOUS (3): 3D grid data via trilinear interpolation
+    - SPECTRAL_INHOMOGENEOUS (4): 2D LUT-based (altitude × wavelength)
+    """
+
+    EXPONENTIAL_ATMOSPHERE = 1  # Legacy: specialized hard-coded kernels
+    SIMPLE_INHOMOGENEOUS = 2  # Tier 1: 1D LUT-based (SimpleInhomogeneousModel)
+    GRID_INHOMOGENEOUS = 3  # Tier 2: 3D grid interpolation (GridInhomogeneousModel)
+    SPECTRAL_INHOMOGENEOUS = 4  # 2D LUT-based (SpectralInhomogeneousModel)
+
+
+@runtime_checkable
+class RayPropagatorProtocol(Protocol):
+    """
+    Protocol for ray propagators in inhomogeneous media.
+
+    All propagators (CPU and GPU) must implement this interface to ensure
+    they are interchangeable drop-in replacements.
+
+    The propagator operates on RayBatch objects and modifies them in-place.
+    """
+
+    def propagate_step(
+        self,
+        rays,  # RayBatch - avoiding import to prevent circular dependency
+        step_size: float,
+        wavelength: float = 532e-9,
+    ) -> None:
+        """
+        Propagate rays by a single integration step.
+
+        This is the primary interface method that all propagators must implement.
+        It takes a RayBatch object and advances all active rays by one step.
+
+        Parameters
+        ----------
+        rays : RayBatch
+            Ray batch containing positions, directions, and other ray properties.
+            Modified in-place.
+        step_size : float
+            Integration step size in meters. For gradient-based propagators,
+            this is the nominal step size that may be adaptively adjusted.
+        wavelength : float, optional
+            Wavelength in meters, default 532 nm (green light).
+            Used for wavelength-dependent effects like dispersion.
+
+        Notes
+        -----
+        - Modifies `rays.positions`, `rays.directions` in-place
+        - Updates path length accumulators if present
+        - Only propagates rays where `rays.active` is True
+        - Implementations may use different integration schemes (Euler, RK4, etc.)
+        """
+        ...
+
+    def propagate(
+        self,
+        rays,  # RayBatch
+        total_distance: float,
+        step_size: float,
+        wavelength: float = 532e-9,
+    ) -> None:
+        """
+        Propagate rays through a total distance.
+
+        This is a convenience method that calls propagate_step repeatedly.
+        Implementations may optimize this for batch processing.
+
+        Parameters
+        ----------
+        rays : RayBatch
+            Ray batch to propagate (modified in-place)
+        total_distance : float
+            Total distance to propagate in meters
+        step_size : float
+            Integration step size in meters
+        wavelength : float, optional
+            Wavelength in meters, default 532 nm
+        """
+        ...
+
+
+@runtime_checkable
+class MaterialFieldProtocol(Protocol):
+    """
+    Protocol for material fields that provide refractive index.
+
+    Materials must implement these methods to work with gradient propagators.
+    """
+
+    def get_refractive_index(
+        self,
+        x: npt.NDArray,
+        y: npt.NDArray,
+        z: npt.NDArray,
+        wavelength: float = 532e-9,
+    ) -> npt.NDArray:
+        """
+        Get refractive index at given positions.
+
+        Parameters
+        ----------
+        x, y, z : ndarray
+            Positions in meters
+        wavelength : float
+            Wavelength in meters
+
+        Returns
+        -------
+        ndarray
+            Refractive index at each position
+        """
+        ...
+
+    def get_refractive_index_gradient(
+        self,
+        x: npt.NDArray,
+        y: npt.NDArray,
+        z: npt.NDArray,
+        wavelength: float = 532e-9,
+    ) -> tuple[npt.NDArray, npt.NDArray, npt.NDArray]:
+        """
+        Get gradient of refractive index at given positions.
+
+        Parameters
+        ----------
+        x, y, z : ndarray
+            Positions in meters
+        wavelength : float
+            Wavelength in meters
+
+        Returns
+        -------
+        tuple of (dn_dx, dn_dy, dn_dz)
+            Gradient components in m^-1
+        """
+        ...
+
+
+@runtime_checkable
+class GPUMaterialProtocol(Protocol):
+    """
+    Protocol for GPU-accelerated materials.
+
+    Materials implementing this protocol can be used with GPU propagators.
+    """
+
+    @property
+    def gpu_material_id(self) -> GPUMaterialID:
+        """Return GPU material ID enum value."""
+        ...
+
+    def get_gpu_kernels(self) -> dict:
+        """Return dict of GPU kernel functions keyed by method name."""
+        ...
+
+    def get_gpu_parameters(self) -> tuple:
+        """Return tuple of material-specific parameters for GPU kernels."""
+        ...

lsurf/propagation/propagators/__init__.py

@@ -0,0 +1,101 @@
+# 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.
+
+"""
+Propagators for ray tracing in gradient media.
+
+This subpackage contains:
+- GradientPropagator: CPU-based propagator using NumPy vectorization
+- GPUGradientPropagator: GPU-accelerated propagator using CUDA
+- SpectralGPUGradientPropagator: GPU propagator with per-ray wavelengths
+- SurfacePropagator: GPU propagator with multi-surface intersection detection
+- create_propagator: Factory function for creating propagators based on material compatibility
+
+New architecture components:
+- MaterialPropagator: Clean wrapper for in-material propagation with surface detection
+- SurfaceInteractionProcessor: Handles Fresnel physics, detection, absorption
+- PropagationResult, SurfaceCrossing, SurfaceInteractionResult: Data structures
+"""
+
+from .gradient import GradientPropagator
+from .gpu_gradient import GPUGradientPropagator
+from .spectral_gpu_gradient import SpectralGPUGradientPropagator
+from .surface_propagator import SurfacePropagator, HitData
+from .gpu_surface_propagator import GPUSurfacePropagator
+from .factory import create_propagator
+from .material_propagator import (
+    MaterialPropagator,
+    CPUMaterialPropagator,
+    GPUMaterialPropagator,
+    MaterialPropagatorProtocol,
+    PropagationResult,
+)
+from .surface_interaction import (
+    SurfaceInteractionProcessor,
+    SurfaceCrossing,
+    SurfaceInteractionResult,
+)
+from .signed_distance_handler import (
+    compute_signed_distance_gpu,
+    compute_surface_normal_gpu,
+)
+
+# Re-export kernel registry types for convenience
+from ..kernels.registry import PropagationKernelID, PropagatorID
+
+__all__ = [
+    # Factory
+    "create_propagator",
+    # Kernel/propagator IDs
+    "PropagationKernelID",
+    "PropagatorID",
+    # Legacy propagators
+    "GradientPropagator",
+    "GPUGradientPropagator",
+    "SpectralGPUGradientPropagator",
+    "SurfacePropagator",
+    "GPUSurfacePropagator",
+    "HitData",
+    # New architecture
+    "MaterialPropagator",
+    "CPUMaterialPropagator",
+    "GPUMaterialPropagator",
+    "MaterialPropagatorProtocol",
+    "PropagationResult",
+    "SurfaceInteractionProcessor",
+    "SurfaceCrossing",
+    "SurfaceInteractionResult",
+    # Signed distance handlers
+    "compute_signed_distance_gpu",
+    "compute_surface_normal_gpu",
+]

lsurf/propagation/propagators/detector_handler.py

@@ -0,0 +1,354 @@
+# 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.
+
+"""
+Detector Handler
+
+GPU memory management for ray detection kernels.
+This module provides high-level interfaces that handle cuda.to_device(),
+copy_to_host(), and kernel launching for the detection kernels.
+"""
+
+import numpy as np
+from numpy.typing import NDArray
+
+from ..kernels.detection import (
+    kernel_spherical_detect_single,
+    kernel_spherical_detect_multi,
+)
+
+# GPU support is optional
+try:
+    from numba import cuda
+
+    _HAS_CUDA = cuda.is_available()
+except ImportError:
+    _HAS_CUDA = False
+
+    class _FakeCuda:
+        @staticmethod
+        def is_available():
+            return False
+
+    cuda = _FakeCuda()  # type: ignore[assignment]
+
+
+def detect_spherical_gpu(
+    ray_positions: NDArray[np.float32],
+    ray_directions: NDArray[np.float32],
+    ray_active: NDArray[np.bool_],
+    ray_times: NDArray[np.float32],
+    ray_wavelengths: NDArray[np.float32],
+    ray_intensities: NDArray[np.float32],
+    detector_center: NDArray[np.float32],
+    detector_radius: float,
+    threads_per_block: int = 256,
+) -> tuple[NDArray[np.bool_], NDArray[np.float32], NDArray[np.float32]]:
+    """
+    GPU-accelerated detection for a single spherical detector.
+
+    Parameters
+    ----------
+    ray_positions : ndarray, shape (N, 3)
+        Ray starting positions
+    ray_directions : ndarray, shape (N, 3)
+        Ray directions
+    ray_active : ndarray, shape (N,)
+        Boolean mask of active rays
+    ray_times : ndarray, shape (N,)
+        Accumulated ray times
+    ray_wavelengths : ndarray, shape (N,)
+        Ray wavelengths
+    ray_intensities : ndarray, shape (N,)
+        Ray intensities
+    detector_center : ndarray, shape (3,)
+        Detector center position
+    detector_radius : float
+        Detector radius
+    threads_per_block : int
+        CUDA threads per block
+
+    Returns
+    -------
+    hit_mask : ndarray, shape (N,)
+        Boolean mask of rays that hit detector
+    hit_distances : ndarray, shape (N,)
+        Distance to detector for each ray
+    hit_times : ndarray, shape (N,)
+        Arrival time at detector for each ray
+    """
+    num_rays = len(ray_positions)
+
+    # Output arrays
+    hit_mask = np.zeros(num_rays, dtype=np.bool_)
+    hit_distances = np.zeros(num_rays, dtype=np.float32)
+    hit_times = np.zeros(num_rays, dtype=np.float32)
+
+    if _HAS_CUDA:
+        # Transfer to GPU
+        d_positions = cuda.to_device(ray_positions.astype(np.float32))
+        d_directions = cuda.to_device(ray_directions.astype(np.float32))
+        d_active = cuda.to_device(ray_active)
+        d_times = cuda.to_device(ray_times.astype(np.float32))
+        d_wavelengths = cuda.to_device(ray_wavelengths.astype(np.float32))
+        d_intensities = cuda.to_device(ray_intensities.astype(np.float32))
+        d_center = cuda.to_device(detector_center.astype(np.float32))
+        d_hit_mask = cuda.to_device(hit_mask)
+        d_hit_distances = cuda.to_device(hit_distances)
+        d_hit_times = cuda.to_device(hit_times)
+
+        # Launch kernel
+        blocks = (num_rays + threads_per_block - 1) // threads_per_block
+        kernel_spherical_detect_single[blocks, threads_per_block](
+            d_positions,
+            d_directions,
+            d_active,
+            d_times,
+            d_wavelengths,
+            d_intensities,
+            d_center,
+            np.float32(detector_radius),
+            d_hit_mask,
+            d_hit_distances,
+            d_hit_times,
+        )
+
+        cuda.synchronize()
+        hit_mask = d_hit_mask.copy_to_host()
+        hit_distances = d_hit_distances.copy_to_host()
+        hit_times = d_hit_times.copy_to_host()
+    else:
+        # CPU fallback
+        hit_mask, hit_distances, hit_times = _detect_spherical_cpu(
+            ray_positions,
+            ray_directions,
+            ray_active,
+            ray_times,
+            detector_center,
+            detector_radius,
+        )
+
+    return hit_mask, hit_distances, hit_times
+
+
+def detect_multi_spherical_gpu(
+    ray_positions: NDArray[np.float32],
+    ray_directions: NDArray[np.float32],
+    ray_active: NDArray[np.bool_],
+    ray_times: NDArray[np.float32],
+    ray_intensities: NDArray[np.float32],
+    detector_centers: NDArray[np.float32],
+    detector_radius: float,
+    threads_per_block: int = 256,
+) -> tuple[NDArray[np.int32], NDArray[np.float32]]:
+    """
+    GPU-accelerated detection across multiple spherical detectors.
+
+    This is optimized for detector scans where we want to quickly count
+    hits and sum intensities for many detector positions at once.
+
+    Parameters
+    ----------
+    ray_positions : ndarray, shape (N, 3)
+        Ray starting positions
+    ray_directions : ndarray, shape (N, 3)
+        Ray directions
+    ray_active : ndarray, shape (N,)
+        Boolean mask of active rays
+    ray_times : ndarray, shape (N,)
+        Accumulated ray times
+    ray_intensities : ndarray, shape (N,)
+        Ray intensities
+    detector_centers : ndarray, shape (M, 3)
+        Detector center positions
+    detector_radius : float
+        Detector radius (same for all)
+    threads_per_block : int
+        CUDA threads per block
+
+    Returns
+    -------
+    hit_counts : ndarray, shape (M,)
+        Number of rays hitting each detector
+    hit_intensities : ndarray, shape (M,)
+        Sum of intensities for rays hitting each detector
+    """
+    num_rays = len(ray_positions)
+    num_detectors = len(detector_centers)
+
+    # Output arrays
+    hit_counts = np.zeros(num_detectors, dtype=np.int32)
+    hit_intensities = np.zeros(num_detectors, dtype=np.float32)
+
+    if _HAS_CUDA:
+        # Transfer to GPU
+        d_positions = cuda.to_device(ray_positions.astype(np.float32))
+        d_directions = cuda.to_device(ray_directions.astype(np.float32))
+        d_active = cuda.to_device(ray_active)
+        d_times = cuda.to_device(ray_times.astype(np.float32))
+        d_intensities = cuda.to_device(ray_intensities.astype(np.float32))
+        d_centers = cuda.to_device(detector_centers.astype(np.float32))
+        d_hit_counts = cuda.to_device(hit_counts)
+        d_hit_intensities = cuda.to_device(hit_intensities)
+
+        # Launch kernel (1D grid over rays)
+        blocks = (num_rays + threads_per_block - 1) // threads_per_block
+        kernel_spherical_detect_multi[blocks, threads_per_block](
+            d_positions,
+            d_directions,
+            d_active,
+            d_times,
+            d_centers,
+            np.float32(detector_radius),
+            d_hit_counts,
+            d_hit_intensities,
+            d_intensities,
+        )
+
+        cuda.synchronize()
+        hit_counts = d_hit_counts.copy_to_host()
+        hit_intensities = d_hit_intensities.copy_to_host()
+    else:
+        # CPU fallback
+        hit_counts, hit_intensities = _detect_multi_spherical_cpu(
+            ray_positions,
+            ray_directions,
+            ray_active,
+            ray_intensities,
+            detector_centers,
+            detector_radius,
+        )
+
+    return hit_counts, hit_intensities
+
+
+# =============================================================================
+# CPU Fallback Implementations
+# =============================================================================
+
+
+def _detect_spherical_cpu(
+    ray_positions: NDArray[np.float32],
+    ray_directions: NDArray[np.float32],
+    ray_active: NDArray[np.bool_],
+    ray_times: NDArray[np.float32],
+    detector_center: NDArray[np.float32],
+    detector_radius: float,
+) -> tuple[NDArray[np.bool_], NDArray[np.float32], NDArray[np.float32]]:
+    """CPU fallback for single detector detection."""
+    num_rays = len(ray_positions)
+    hit_mask = np.zeros(num_rays, dtype=np.bool_)
+    hit_distances = np.zeros(num_rays, dtype=np.float32)
+    hit_times = np.zeros(num_rays, dtype=np.float32)
+
+    c = 299792458.0
+
+    for i in range(num_rays):
+        if not ray_active[i]:
+            continue
+
+        origin = ray_positions[i]
+        direction = ray_directions[i]
+        d_len = np.linalg.norm(direction)
+        if d_len < 1e-10:
+            continue
+        direction = direction / d_len
+
+        oc = detector_center - origin
+        t_closest = np.dot(oc, direction)
+
+        if t_closest < 0:
+            continue
+
+        closest_point = origin + t_closest * direction
+        dist = np.linalg.norm(closest_point - detector_center)
+
+        if dist <= detector_radius:
+            hit_mask[i] = True
+            hit_distances[i] = t_closest
+            hit_times[i] = ray_times[i] + t_closest / c
+
+    return hit_mask, hit_distances, hit_times
+
+
+def _detect_multi_spherical_cpu(
+    ray_positions: NDArray[np.float32],
+    ray_directions: NDArray[np.float32],
+    ray_active: NDArray[np.bool_],
+    ray_intensities: NDArray[np.float32],
+    detector_centers: NDArray[np.float32],
+    detector_radius: float,
+) -> tuple[NDArray[np.int32], NDArray[np.float32]]:
+    """CPU fallback for multi-detector detection."""
+    num_rays = len(ray_positions)
+    num_detectors = len(detector_centers)
+
+    hit_counts = np.zeros(num_detectors, dtype=np.int32)
+    hit_intensities = np.zeros(num_detectors, dtype=np.float32)
+
+    radius_sq = detector_radius**2
+
+    for i in range(num_rays):
+        if not ray_active[i]:
+            continue
+
+        origin = ray_positions[i]
+        direction = ray_directions[i]
+        d_len = np.linalg.norm(direction)
+        if d_len < 1e-10:
+            continue
+        direction = direction / d_len
+        intensity = ray_intensities[i]
+
+        for det_idx in range(num_detectors):
+            center = detector_centers[det_idx]
+            oc = center - origin
+            t_closest = np.dot(oc, direction)
+
+            if t_closest < 0:
+                continue
+
+            closest_point = origin + t_closest * direction
+            dist_sq = np.sum((closest_point - center) ** 2)
+
+            if dist_sq <= radius_sq:
+                hit_counts[det_idx] += 1
+                hit_intensities[det_idx] += intensity
+
+    return hit_counts, hit_intensities
+
+
+__all__ = [
+    "detect_spherical_gpu",
+    "detect_multi_spherical_gpu",
+]