optixstuff 1.3.0__tar.gz → 1.5.0__tar.gz

{optixstuff-1.3.0 → optixstuff-1.5.0}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.5.0](https://github.com/CoreySpohn/optixstuff/compare/v1.4.0...v1.5.0) (2026-06-27)
+
+
+### Features
+
+* **detector:** wavelength-dependent QE via optional qe_curve ([bf7bc6f](https://github.com/CoreySpohn/optixstuff/commit/bf7bc6f8272ff2d011551f3b1b78243c8ada5572))
+* **primary:** add SegmentedPrimary carrying hex segment geometry ([fe7cab9](https://github.com/CoreySpohn/optixstuff/commit/fe7cab9bb6153874b029ead7d2cc888ca9e8709b))
+
+## [1.4.0](https://github.com/CoreySpohn/optixstuff/compare/v1.3.0...v1.4.0) (2026-06-23)
+
+
+### Miscellaneous Chores
+
+* release 1.4.0 ([39c1d25](https://github.com/CoreySpohn/optixstuff/commit/39c1d25741f3aaa47984d32e0e6c7917933a59ba))
+
 ## [1.3.0](https://github.com/CoreySpohn/optixstuff/compare/v1.2.0...v1.3.0) (2026-06-23)
 
 

{optixstuff-1.3.0 → optixstuff-1.5.0}/CITATION.cff

@@ -10,4 +10,4 @@ authors:
     affiliation: "NASA Goddard Space Flight Center"
 repository-code: "https://github.com/CoreySpohn/optixstuff"
 license: MIT
-# doi: add the Zenodo concept ("all versions") DOI here after the first archived release
+doi: "10.5281/zenodo.20819379"

{optixstuff-1.3.0 → optixstuff-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optixstuff
-Version: 1.3.0
+Version: 1.5.0
 Summary: Hardware abstractions for the HWO direct imaging simulation suite
 Project-URL: Homepage, https://github.com/CoreySpohn/optixstuff
 Project-URL: Issues, https://github.com/CoreySpohn/optixstuff/issues

{optixstuff-1.3.0 → optixstuff-1.5.0}/src/optixstuff/__init__.py

@@ -19,7 +19,7 @@ from optixstuff.optical_elements import (
     SpectralThroughput,
 )
 from optixstuff.optical_path import OpticalPath
-from optixstuff.primary import AbstractPrimary, SimplePrimary
+from optixstuff.primary import AbstractPrimary, SegmentedPrimary, SimplePrimary
 from optixstuff.yippy_coronagraph import YippyCoronagraph
 
 __all__ = [
@@ -36,6 +36,7 @@ __all__ = [
     "IdealDetector",
     "LensletDisperser",
     "OpticalPath",
+    "SegmentedPrimary",
     "SimplePrimary",
     "SpectralThroughput",
     "YippyCoronagraph",

{optixstuff-1.3.0 → optixstuff-1.5.0}/src/optixstuff/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.0'
-__version_tuple__ = version_tuple = (1, 3, 0)
+__version__ = version = '1.5.0'
+__version_tuple__ = version_tuple = (1, 5, 0)
 
 __commit_id__ = commit_id = None

{optixstuff-1.3.0 → optixstuff-1.5.0}/src/optixstuff/detector.py

@@ -4,6 +4,7 @@ import abc
 from typing import final
 
 import equinox as eqx
+import interpax
 import jax
 import jax.numpy as jnp
 from equinox import AbstractVar
@@ -392,6 +393,7 @@ class Detector(AbstractDetector):
     read_time_s: float
     dqe: float
     shape: tuple[int, int] = eqx.field(static=True)
+    _qe_interp: interpax.Interpolator1D | None
 
     def __init__(
         self,
@@ -404,8 +406,16 @@ class Detector(AbstractDetector):
         frame_time_s: float = 1.0,
         read_time_s: float = 0.05,
         dqe: float = 0.0,
+        qe_curve: tuple[ArrayLike, ArrayLike] | None = None,
     ) -> None:
-        """Create a full detector with all noise sources."""
+        """Create a full detector with all noise sources.
+
+        Supplying ``qe_curve`` as a ``(wavelengths_nm, qe)`` pair makes
+        :meth:`get_qe` interpolate it (linear, zero outside the measured range)
+        for wavelength-dependent throughput/ETC use; the scalar
+        ``quantum_efficiency`` remains the operating-point QE used by the
+        per-call (monochromatic) readout path.
+        """
         self.pixel_scale_arcsec = pixel_scale_arcsec
         self.shape = shape
         self.quantum_efficiency = quantum_efficiency
@@ -417,10 +427,26 @@ class Detector(AbstractDetector):
         self.frame_time_s = frame_time_s
         self.read_time_s = read_time_s
         self.dqe = dqe
+        if qe_curve is None:
+            self._qe_interp = None
+        else:
+            wavelengths_nm, qe = qe_curve
+            self._qe_interp = interpax.Interpolator1D(
+                jnp.asarray(wavelengths_nm),
+                jnp.asarray(qe),
+                method="linear",
+                extrap=jnp.array([0.0, 0.0]),
+            )
 
     def get_qe(self, wavelength_nm: ArrayLike) -> ArrayLike:
-        """Return constant QE, ignoring wavelength."""
-        return self.quantum_efficiency
+        """Quantum efficiency at a wavelength.
+
+        Interpolates the ``qe_curve`` if one was supplied (linear, zero outside
+        the measured range); otherwise returns the scalar ``quantum_efficiency``.
+        """
+        if self._qe_interp is None:
+            return self.quantum_efficiency
+        return self._qe_interp(wavelength_nm)
 
     def scalar_noise_rate(self, n_pix: ArrayLike, t_photon: ArrayLike) -> ArrayLike:
         """Combined dark + CIC noise variance rate."""
@@ -463,9 +489,14 @@ class Detector(AbstractDetector):
     def __repr__(self) -> str:
         """One-line summary of shape, plate scale, QE, and noise sources."""
         ny, nx = self.shape
+        qe_str = (
+            "spectral"
+            if self._qe_interp is not None
+            else f"{self.quantum_efficiency:.2f}"
+        )
         return (
             f"Detector({ny}x{nx} @ {self.pixel_scale_arcsec:.3g} arcsec/px, "
-            f"QE={self.quantum_efficiency:.2f}, "
+            f"QE={qe_str}, "
             f"dark={self.dark_current_rate_e_per_s:.2g} e-/s/px, "
             f"RN={self.read_noise_e:.2g} e-/read, "
             f"CIC={self.clock_induced_charge_rate_e_per_frame:.2g} e-/frame, "

optixstuff-1.5.0/src/optixstuff/primary.py

@@ -0,0 +1,160 @@
+"""Primary mirror abstractions."""
+
+import equinox as eqx
+import jax.numpy as jnp
+from equinox import AbstractVar
+
+
+class AbstractPrimary(eqx.Module):
+    """Abstract interface for a primary aperture.
+
+    Any concrete implementation must provide the diameter and collecting
+    area of the primary mirror as scalar values in SI units. These are
+    consumed by exposure time calculators and simulation tools alike.
+    """
+
+    diameter_m: AbstractVar[float]
+    """Primary mirror diameter in metres."""
+
+    area_m2: AbstractVar[float]
+    """Effective collecting area in square metres."""
+
+
+class SimplePrimary(AbstractPrimary):
+    """A simple circular primary mirror with a central obscuration.
+
+    Args:
+        diameter_m: Primary mirror diameter in metres.
+        obscuration: Linear obscuration fraction (0 = no obscuration).
+        shape_factor: Fraction of unobscured area that is collecting
+            (accounts for struts, segment gaps, etc.). Default 1.0.
+    """
+
+    _diameter_m: float
+    obscuration: float
+    shape_factor: float
+
+    def __init__(
+        self,
+        diameter_m: float,
+        obscuration: float = 0.0,
+        shape_factor: float = 1.0,
+    ) -> None:
+        """Create a simple circular primary mirror."""
+        self._diameter_m = diameter_m
+        self.obscuration = obscuration
+        self.shape_factor = shape_factor
+
+    @property
+    def diameter_m(self) -> float:
+        """Primary mirror diameter in metres."""
+        return self._diameter_m
+
+    @property
+    def area_m2(self) -> float:
+        """Effective collecting area in square metres."""
+        r = self._diameter_m / 2.0
+        gross_area = jnp.pi * r**2
+        return gross_area * (1.0 - self.obscuration**2) * self.shape_factor
+
+    def __repr__(self) -> str:
+        """One-line summary of diameter, obscuration, and effective area."""
+        return (
+            f"SimplePrimary(D={self._diameter_m:.3g} m, "
+            f"obs={self.obscuration:.3g}, "
+            f"shape_factor={self.shape_factor:.3g}, "
+            f"area={float(self.area_m2):.3g} m^2)"
+        )
+
+
+def _hex_axial_coords(n_rings: int) -> list[tuple[int, int]]:
+    """Axial (q, r) centres of a hex-packed n-ring layout.
+
+    Yields ``1 + 3 n (n + 1)`` coordinates, centre first.
+    """
+    coords = [(0, 0)]
+    for q in range(-n_rings, n_rings + 1):
+        for r in range(-n_rings, n_rings + 1):
+            if max(abs(q), abs(r), abs(q + r)) <= n_rings and not (q == 0 and r == 0):
+                coords.append((q, r))
+    return coords
+
+
+class SegmentedPrimary(AbstractPrimary):
+    """A segmented hex primary that carries pupil geometry, not just scalars.
+
+    Beyond the diameter and collecting area every primary provides, this
+    describes the segment layout -- ring count, segment count, gap, shape -- so a
+    diffraction backend (e.g. dLux) can build the pupil from it. optixstuff only
+    DESCRIBES the geometry; it does not propagate wavefronts.
+
+    Args:
+        diameter_m: Circumscribing diameter in metres.
+        area_m2: Effective collecting area in square metres (gap/fill corrected).
+        n_rings: Number of segment rings around the centre segment.
+        n_segments: Total segment count (``1 + 3 n (n + 1)`` for a full layout).
+        segment_gap_m: Inter-segment optical gap in metres.
+        segment_shape: Segment shape; only ``"hexagon"`` is supported today.
+    """
+
+    _diameter_m: float
+    _area_m2: float
+    segment_gap_m: float
+    n_rings: int = eqx.field(static=True)
+    n_segments: int = eqx.field(static=True)
+    segment_shape: str = eqx.field(static=True)
+
+    def __init__(
+        self,
+        diameter_m: float,
+        area_m2: float,
+        n_rings: int,
+        n_segments: int,
+        segment_gap_m: float,
+        segment_shape: str = "hexagon",
+    ) -> None:
+        """Create a segmented hex primary from its geometry."""
+        self._diameter_m = diameter_m
+        self._area_m2 = area_m2
+        self.segment_gap_m = segment_gap_m
+        self.n_rings = n_rings
+        self.n_segments = n_segments
+        self.segment_shape = segment_shape
+
+    @property
+    def diameter_m(self) -> float:
+        """Circumscribing diameter in metres."""
+        return self._diameter_m
+
+    @property
+    def area_m2(self) -> float:
+        """Effective collecting area in square metres."""
+        return self._area_m2
+
+    @property
+    def segment_flat_to_flat_m(self) -> float:
+        """Segment flat-to-flat size in metres for the circumscribing layout."""
+        return self._diameter_m / (2 * self.n_rings + 1)
+
+    @property
+    def segment_centres_m(self):
+        """``(n_segments, 2)`` array of segment centre (x, y) positions in metres."""
+        if self.segment_shape != "hexagon":
+            msg = f"segment_centres_m undefined for shape {self.segment_shape!r}"
+            raise NotImplementedError(msg)
+        axial = _hex_axial_coords(self.n_rings)
+        spacing = self.segment_flat_to_flat_m + self.segment_gap_m
+        qs = jnp.array([q for q, _ in axial])
+        rs = jnp.array([r for _, r in axial])
+        xs = spacing * (qs + rs / 2.0)
+        ys = spacing * (jnp.sqrt(3.0) / 2.0) * rs
+        return jnp.stack([xs, ys], axis=-1)
+
+    def __repr__(self) -> str:
+        """One-line summary of diameter, segment layout, and effective area."""
+        return (
+            f"SegmentedPrimary(D={self._diameter_m:.3g} m, "
+            f"{self.n_segments} {self.segment_shape} segs, "
+            f"{self.n_rings} rings, gap={self.segment_gap_m * 1e3:.3g} mm, "
+            f"area={float(self._area_m2):.3g} m^2)"
+        )

optixstuff-1.3.0/src/optixstuff/primary.py

@@ -1,67 +0,0 @@
-"""Primary mirror abstractions."""
-
-import equinox as eqx
-import jax.numpy as jnp
-from equinox import AbstractVar
-
-
-class AbstractPrimary(eqx.Module):
-    """Abstract interface for a primary aperture.
-
-    Any concrete implementation must provide the diameter and collecting
-    area of the primary mirror as scalar values in SI units. These are
-    consumed by exposure time calculators and simulation tools alike.
-    """
-
-    diameter_m: AbstractVar[float]
-    """Primary mirror diameter in metres."""
-
-    area_m2: AbstractVar[float]
-    """Effective collecting area in square metres."""
-
-
-class SimplePrimary(AbstractPrimary):
-    """A simple circular primary mirror with a central obscuration.
-
-    Args:
-        diameter_m: Primary mirror diameter in metres.
-        obscuration: Linear obscuration fraction (0 = no obscuration).
-        shape_factor: Fraction of unobscured area that is collecting
-            (accounts for struts, segment gaps, etc.). Default 1.0.
-    """
-
-    _diameter_m: float
-    obscuration: float
-    shape_factor: float
-
-    def __init__(
-        self,
-        diameter_m: float,
-        obscuration: float = 0.0,
-        shape_factor: float = 1.0,
-    ) -> None:
-        """Create a simple circular primary mirror."""
-        self._diameter_m = diameter_m
-        self.obscuration = obscuration
-        self.shape_factor = shape_factor
-
-    @property
-    def diameter_m(self) -> float:
-        """Primary mirror diameter in metres."""
-        return self._diameter_m
-
-    @property
-    def area_m2(self) -> float:
-        """Effective collecting area in square metres."""
-        r = self._diameter_m / 2.0
-        gross_area = jnp.pi * r**2
-        return gross_area * (1.0 - self.obscuration**2) * self.shape_factor
-
-    def __repr__(self) -> str:
-        """One-line summary of diameter, obscuration, and effective area."""
-        return (
-            f"SimplePrimary(D={self._diameter_m:.3g} m, "
-            f"obs={self.obscuration:.3g}, "
-            f"shape_factor={self.shape_factor:.3g}, "
-            f"area={float(self.area_m2):.3g} m^2)"
-        )