dkist-processing-cryonirsp 2.1.5__tar.gz → 3.0.0__tar.gz

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/CHANGELOG.rst

@@ -1,3 +1,26 @@
+v3.0.0 (2026-10-08)
+===================
+
+Features
+--------
+
+- Replace `BeamBoundariesCalibration` task with `SpatialBeamBoundaries`, which only computes the boundaries of the illuminated region along the spatial axis.
+  The spectral axis (or second spatial axis, for CI) boundaries are hard-coded as a pipeline parameter. (`#306 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/306>`__)
+- Save the full set of beam boundaries used to extract illuminated regions from the raw data as a dataset extra (called "BEAM_BOUNDARIES"). (`#306 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/306>`__)
+
+
+Misc
+----
+
+- Replace "y" and "x" language with "axis_0" and "axis_1", respectively, in the `BeamBoundaries` model. (`#306 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/306>`__)
+
+
+Documentation
+-------------
+
+- Update online documentation "Dataset Extras" page to include information about the beam boundaries extra. (`#306 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/306>`__)
+
+
 v2.1.5 (2026-10-08)
 ===================
 

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dkist-processing-cryonirsp
-Version: 2.1.5
+Version: 3.0.0
 Summary: Science processing code for the Cryo-NIRSP instrument on DKIST
 Author-email: NSO / AURA <dkistdc@nso.edu>
 License: BSD-3-Clause
@@ -22,7 +22,6 @@ Requires-Dist: dkist-processing-math==2.2.3
 Requires-Dist: dkist-processing-pac==3.1.2
 Requires-Dist: dkist-spectral-lines==3.0.1
 Requires-Dist: solar-wavelength-calibration==2.0.4
-Requires-Dist: largestinteriorrectangle==0.2.1
 Requires-Dist: dkist-service-configuration==4.3.0
 Requires-Dist: moviepy==2.1.2
 Requires-Dist: numba==0.61.2
@@ -114,8 +113,8 @@ Requires-Dist: babel==2.18.0; extra == "frozen"
 Requires-Dist: beautifulsoup4==4.15.0; extra == "frozen"
 Requires-Dist: billiard==4.3.1; extra == "frozen"
 Requires-Dist: bleach==6.4.0; extra == "frozen"
-Requires-Dist: boto3==1.43.109; extra == "frozen"
-Requires-Dist: botocore==1.43.109; extra == "frozen"
+Requires-Dist: boto3==1.43.110; extra == "frozen"
+Requires-Dist: botocore==1.43.110; extra == "frozen"
 Requires-Dist: cachetools==7.2.1; extra == "frozen"
 Requires-Dist: cadwyn==7.0.0; extra == "frozen"
 Requires-Dist: celery==5.6.3; extra == "frozen"
@@ -141,7 +140,7 @@ Requires-Dist: dill==0.4.1; extra == "frozen"
 Requires-Dist: dkist-header-validator==6.0.0; extra == "frozen"
 Requires-Dist: dkist-processing-common==14.6.0; extra == "frozen"
 Requires-Dist: dkist-processing-core==7.5.0; extra == "frozen"
-Requires-Dist: dkist-processing-cryonirsp==2.1.5; extra == "frozen"
+Requires-Dist: dkist-processing-cryonirsp==3.0.0; extra == "frozen"
 Requires-Dist: dkist-processing-math==2.2.3; extra == "frozen"
 Requires-Dist: dkist-processing-pac==3.1.2; extra == "frozen"
 Requires-Dist: dkist-service-configuration==4.3.0; extra == "frozen"
@@ -196,7 +195,6 @@ Requires-Dist: jupyterlab_pygments==0.3.0; extra == "frozen"
 Requires-Dist: jupyterlab_server==2.28.1; extra == "frozen"
 Requires-Dist: kiwisolver==1.5.1; extra == "frozen"
 Requires-Dist: kombu==5.6.2; extra == "frozen"
-Requires-Dist: largestinteriorrectangle==0.2.1; extra == "frozen"
 Requires-Dist: lark==1.3.1; extra == "frozen"
 Requires-Dist: lazy-loader==0.6; extra == "frozen"
 Requires-Dist: lazy-object-proxy==1.12.0; extra == "frozen"

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/SCIENCE_CHANGELOG.rst

@@ -1,3 +1,13 @@
+v3.0.0 (2026-10-08)
+===================
+
+
+
+
+- The task that computes the boundaries of the useful, illuminated regions of the INPUT data has been simplified and made more robust to data with very high
+  dynamic range. This improvement will most affect data taken at 1430nm, but will slightly change the final array shape for all data. (`#306 <https://bitbucket.org/dkistdc/dkist-processing-cryonirsp/pull-requests/306>`__)
+
+
 v2.0.0 (2026-07-17)
 ===================
 

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/dkist_processing_cryonirsp/codecs/fits.py

@@ -6,13 +6,13 @@ import numpy as np
 from dkist_processing_common.codecs.fits import fits_access_decoder as common_fits_access_decoder
 from dkist_processing_common.models.fits_access import FitsAccessBase
 
-from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundaries
 
 
 def cryo_fits_access_decoder(
     path: Path,
     fits_access_class: FitsAccessBase = FitsAccessBase,
-    beam_boundary: BeamBoundary | None = None,
+    beam_boundary: BeamBoundaries | None = None,
     **fits_access_kwargs,
 ) -> FitsAccessBase:
     """
@@ -33,7 +33,7 @@ def cryo_fits_access_decoder(
 def cryo_fits_array_decoder(
     path: Path,
     fits_access_class: FitsAccessBase = FitsAccessBase,
-    beam_boundary: BeamBoundary | None = None,
+    beam_boundary: BeamBoundaries | None = None,
     auto_squeeze: bool = True,
     **fits_access_kwargs,
 ) -> np.array:

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/dkist_processing_cryonirsp/models/beam_boundaries.py

@@ -6,33 +6,33 @@ import numpy as np
 
 
 @dataclass
-class BeamBoundary:
+class BeamBoundaries:
     """Simple dataclass to hold boundary information for the illuminated portion of the beam array."""
 
-    y_min: int
-    y_max: int
-    x_min: int
-    x_max: int
+    axis_0_min: int
+    axis_0_max: int
+    axis_1_min: int
+    axis_1_max: int
 
     @property
-    def y_slice(self):
-        """Return a slice object representing the illumination along the y-axis (numpy 0 axis)."""
-        return slice(self.y_min, self.y_max)
+    def axis_0_slice(self):
+        """Return a slice object representing the illumination along the 0th axis."""
+        return slice(self.axis_0_min, self.axis_0_max)
 
     @property
-    def x_slice(self):
-        """Return a slice object representing the illumination along the x-axis (numpy 1 axis)."""
-        return slice(self.x_min, self.x_max)
+    def axis_1_slice(self):
+        """Return a slice object representing the illumination along the 1st axis."""
+        return slice(self.axis_1_min, self.axis_1_max)
 
     @property
     def slices(self):
         """Return a tuple of slices in numpy order representing the illuminated portion of the beam array."""
-        return self.y_slice, self.x_slice
+        return self.axis_0_slice, self.axis_1_slice
 
     @property
     def beam_boundaries(self):
         """Return a tuple containing the beam boundaries."""
-        return self.y_min, self.y_max, self.x_min, self.x_max
+        return self.axis_0_min, self.axis_0_max, self.axis_1_min, self.axis_1_max
 
     @property
     def beam_boundaries_array(self):

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/dkist_processing_cryonirsp/models/parameters.py

@@ -110,27 +110,39 @@ class CryonirspParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmI
         return self._find_most_recent_past_value("cryonirsp_polcal_pac_fit_mode")
 
     @property
-    def beam_boundaries_smoothing_disk_size(self) -> int:
-        """Return the size of the smoothing disk (in pixels) to be used in the beam boundaries computation."""
-        return self._find_most_recent_past_value("cryonirsp_beam_boundaries_smoothing_disk_size")
-
-    @property
-    def beam_boundaries_upsample_factor(self) -> int:
-        """Return the upsample factor to be used in the beam boundaries cross correlation computation."""
-        return self._find_most_recent_past_value("cryonirsp_beam_boundaries_upsample_factor")
-
-    @property
-    def beam_boundaries_sp_beam_transition_region_size_fraction(self) -> float:
+    def beam_boundaries_spectral_beam_slices(self) -> list[slice]:
         """
-        Fraction of full spectral size to use as the size of the transition region between the two SP beams.
+        Return a list of `slice` objects that extract beams in the spectral dimension.
 
-        A region with size = (this parameter * full spectral size) and centered at the center of the spectral dimension
-        will be ignored when extracting the beams.
+        For CI the "spectral" dimension is just the same axis of the chip that is spectral in SP data.
         """
+        raw_boundaries = self._find_parameter_for_arm(
+            "cryonirsp_beam_boundaries_spectral_beam_slices"
+        )
+        return [slice(b[0], b[1]) for b in raw_boundaries]
+
+    @property
+    def beam_boundaries_normalization_percentile(self) -> float:
+        """Return the percentile (0, 100) used when collapsing the wavelength dimension into a single spatial profile."""
         return self._find_most_recent_past_value(
-            "cryonirsp_beam_boundaries_sp_beam_transition_region_size_fraction"
+            "cryonirsp_beam_boundaries_normalization_percentile"
         )
 
+    @property
+    def beam_boundaries_edge_profile_window_px(self) -> int:
+        """Return the size of the moving window used to compute an edge profile."""
+        return self._find_most_recent_past_value("cryonirsp_beam_boundaries_edge_profile_window_px")
+
+    @property
+    def beam_boundaries_edge_threshold_sigma(self) -> float:
+        """Return the threshold for determining if an illumination edge is strong enough to consider, in units of edge profile sigma."""
+        return self._find_most_recent_past_value("cryonirsp_beam_boundaries_edge_threshold_sigma")
+
+    @property
+    def beam_boundaries_detector_margin_px(self) -> int:
+        """Return the padding amount from the detector edge that sets a hard limit on the illumination regions."""
+        return self._find_most_recent_past_value("cryonirsp_beam_boundaries_detector_margin_px")
+
     @property
     def bad_pixel_map_median_filter_size(self) -> list[int, int]:
         """Return the smoothing disk size to be used in the bad pixel map computation."""

dkist_processing_cryonirsp-3.0.0/dkist_processing_cryonirsp/tasks/beam_boundaries_base.py

@@ -0,0 +1,252 @@
+"""Task for computing the spatial boundaries of CryoNIRSP data."""
+
+from abc import abstractmethod
+
+import numpy as np
+from dkist_processing_common.codecs.fits import fits_array_encoder
+from dkist_processing_math.statistics import average_numpy_arrays
+from dkist_service_configuration.logging import logger
+from scipy import stats
+
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundaries
+from dkist_processing_cryonirsp.models.tags import CryonirspTag
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
+    CryonirspLinearizedFitsAccess,
+)
+from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
+
+__all__ = ["SpatialBeamBoundariesBase"]
+
+
+class SpatialBeamBoundariesBase(CryonirspTaskBase):
+    """
+    Task class for calculating the illuminated beam boundaries in the spatial dimension for later use during calibration.
+
+    For CI data the term "spatial" here refers to the same chip dimension that corresponds to the spatial dimension in
+    SP data (numpy axis 0).
+
+    Parameters
+    ----------
+    recipe_run_id : int
+        id of the recipe run used to identify the workflow run this task is part of
+
+    workflow_name : str
+        name of the workflow to which this instance of the task belongs
+
+    workflow_version : str
+        version of the workflow to which this instance of the task belongs
+    """
+
+    record_provenance = True
+    num_beams: int = -1
+
+    def run(self):
+        """
+        Compute the beam boundaries by analyzing a set of solar gain images.
+
+        Steps:
+
+        #. Compute the average gain image
+
+        #. For each beam
+
+           i. Extract the beam's spectral extent
+
+           #. Collapse along the spectral dimension to form a 1D spatial signal
+
+           #. Use a moving window comparison to construct a profile showing sharp changes in intensity
+
+           #. Take the maximum and minimum peaks of this profile to be the edges of the illuminated region
+
+        #. Adjust the regions so all beams have the same shape
+
+        #. Write the computed spatial bounds and the spectral bounds from `parameters` to scratch
+
+        NOTE: When this method refers to the "spectral" dimension for CI data we really mean the spatial dimension that
+        corresponds to the chip axis that is the spectral dimension in SP data (numpy axis 1).
+
+        Returns
+        -------
+        None
+        """
+        with self.telemetry_span(f"Compute average solar gain image"):
+            average_solar_gain_array = self.compute_average_gain_array()
+
+        beam_boundaries = []
+        for beam in range(1, self.num_beams + 1):
+            with self.telemetry_span(f"Calculating spatial boundaries for beam {beam}"):
+                beam_array = self.extract_spectral_beam(average_solar_gain_array, beam)
+
+                spatial_signal = np.nanpercentile(
+                    beam_array, self.parameters.beam_boundaries_normalization_percentile, axis=1
+                )
+                # Not really necessary, but helps us compare some debug numbers across datasets
+                spatial_signal /= np.nanmax(spatial_signal)
+
+                edge_profile = self.compute_edge_profile(
+                    spatial_signal, window=self.parameters.beam_boundaries_edge_profile_window_px
+                )
+                min_edge, max_edge = self.find_edges(
+                    edge_profile,
+                    threshold_sigma=self.parameters.beam_boundaries_edge_threshold_sigma,
+                    detector_margin=self.parameters.beam_boundaries_detector_margin_px,
+                )
+
+                beam_boundaries.append((min_edge, max_edge))
+
+        with self.telemetry_span("Matching beam sizes"):
+            spatial_size = beam_array.shape[0]
+            matched_spatial_boundaries = self.match_beam_sizes(
+                beam_boundaries, full_spatial_size=spatial_size
+            )
+
+        with self.telemetry_span("Writing beam boundaries"):
+            final_beam_boundaries = self.construct_final_boundaries_objects(
+                matched_spatial_boundaries
+            )
+            for beam, bounds in enumerate(final_beam_boundaries, start=1):
+                self.write(
+                    data=bounds.beam_boundaries_array,
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_beam_boundaries(),
+                    ],
+                    encoder=fits_array_encoder,
+                )
+
+    def compute_average_gain_array(self) -> np.ndarray:
+        """
+        Compute an average of uncorrected solar gain arrays.
+
+        We are computing the overall illumination pattern for both beams simultaneously,
+        so no dark correction is required and no beam splitting is used at this point.
+        Solar gain images are used because they have larger flux than the lamp gain images
+        and the lamp gain images do not have the same illumination pattern as the solar
+        gain images.
+
+        Returns
+        -------
+        The average gain array
+        """
+        lin_corr_gain_arrays = self.read(
+            tags=[CryonirspTag.linearized_frame(), CryonirspTag.task_solar_gain()],
+            decoder=cryo_fits_array_decoder,
+            fits_access_class=CryonirspLinearizedFitsAccess,
+        )
+        averaged_gain_data = average_numpy_arrays(lin_corr_gain_arrays)
+        spatial_edge_mask = self.parameters.beam_boundaries_detector_margin_px
+
+        # Fill in the masked edge regions with a spatial constant copied from the first pixel past the masked region
+        start_edge_good_signal = averaged_gain_data[spatial_edge_mask + 1, :]
+        end_edge_good_signal = averaged_gain_data[-(spatial_edge_mask + 1), :]
+
+        averaged_gain_data[:spatial_edge_mask, :] = start_edge_good_signal[None, :]
+        averaged_gain_data[-spatial_edge_mask:, :] = end_edge_good_signal[None, :]
+        return averaged_gain_data
+
+    @staticmethod
+    def compute_edge_profile(spatial_signal: np.ndarray, window: int) -> np.ndarray:
+        """
+        Compute a profile showing sharp changes in intensity.
+
+        Each point in the profile is calculated as the mean intensity ``window`` pixels beyond that point minus the mean
+        intensity ``window`` pixels before that point.
+
+        Values within ``window`` pixels of the start/end of the array are set to NaN.
+        """
+        moving_mean = np.convolve(spatial_signal, np.ones(window), "valid") / window
+
+        profile = np.full_like(spatial_signal, np.nan)
+        profile[window : len(profile) - (window - 1)] = moving_mean[window:] - moving_mean[:-window]
+        return profile
+
+    @staticmethod
+    def find_edges(
+        edge_profile: np.ndarray, threshold_sigma: float, detector_margin: int
+    ) -> tuple[int, int]:
+        """
+        Identify peaks in an edge profile.
+
+        The location of the maximum change in the profile is taken to be the minimum edge of the illuminated beam while
+        the location of the most negative change in the profile is taken to be the maximum edge illuminated beam.
+
+        Both edges are checked to ensure they are significant enough by comparing their value to a threshold controlled
+        by ``threshold_sigma``. Edges that are below the threshold are interpreted as being essentially at the edge of
+        the array and set to simply be ``detector_margin`` pixels away from the edge.
+
+        Returns
+        -------
+        `[min_edge_idx, max_edge_idx]`
+        """
+        threshold = threshold_sigma * stats.median_abs_deviation(
+            edge_profile, nan_policy="omit", scale="normal"
+        )
+        num_pix = len(edge_profile)
+
+        bottom_candidate = np.nanargmax(edge_profile)
+        top_candidate = np.nanargmin(edge_profile)
+
+        if bottom_candidate > top_candidate:
+            # If the edges appear flipped around
+            # This could potentially happen if there is some sharp signal right at the edge of the otherwise-unilluminated
+            # detector that gets interpreted as a spurious edge. In this case we make the assumption that the true beginning
+            # of illumination is in the first half of the detector and the true end of illumination is in the second half.
+            logger.info(
+                "Edge profile increasing/decreasing peaks appear to be swapped. This is likely due to spurious edges. Restricting search to half the chip for each."
+            )
+            half_idx = edge_profile.size // 2
+            bottom_candidate = np.nanargmax(edge_profile[:half_idx])
+            top_candidate = np.nanargmin(edge_profile[half_idx:]) + half_idx
+
+        min_edge = (
+            bottom_candidate if edge_profile[bottom_candidate] > threshold else detector_margin
+        )
+        max_edge = (
+            top_candidate if edge_profile[top_candidate] < -threshold else num_pix - detector_margin
+        )
+
+        return min_edge, max_edge
+
+    def construct_final_boundaries_objects(
+        self, spatial_boundary_list: list[tuple[int, int]]
+    ) -> list[BeamBoundaries]:
+        """Package the computed spatial boundaries with the spectral boundaries from parameters into `~dkist_processing_cryonirsp.models.beam_boundaries.BeamBoundaries` objects."""
+        spectral_slices = self.parameters.beam_boundaries_spectral_beam_slices
+
+        output_list = []
+        for spatial_boundaries, spectral_slice in zip(spatial_boundary_list, spectral_slices):
+            spatial_min, spatial_max = spatial_boundaries
+            boundary_obj = BeamBoundaries(
+                axis_0_min=spatial_min,
+                axis_0_max=spatial_max,
+                axis_1_min=spectral_slice.start,
+                axis_1_max=spectral_slice.stop,
+            )
+            output_list.append(boundary_obj)
+
+        return output_list
+
+    def extract_spectral_beam(self, array: np.ndarray, beam: int) -> np.ndarray:
+        """
+        Split the beams along the "spectral" axis (axis 1).
+
+        Parameters
+        ----------
+        array
+            The array to be split
+
+        Returns
+        -------
+        [array, ...]
+            A list of arrays after the split
+        """
+        slices = self.parameters.beam_boundaries_spectral_beam_slices
+        return array[:, slices[beam - 1]]
+
+    @abstractmethod
+    def match_beam_sizes(
+        self, beam_boundary_list: list[tuple[int, int]], full_spatial_size: int
+    ) -> list[tuple[int, int]]:
+        """Ensure that all spatial beam boundaries produce arrays of the same shape."""
+        pass

dkist_processing_cryonirsp-3.0.0/dkist_processing_cryonirsp/tasks/ci_beam_boundaries.py

@@ -0,0 +1,25 @@
+"""Cryonirsp CI beam boundaries task."""
+
+from dkist_service_configuration.logging import logger
+
+from dkist_processing_cryonirsp.tasks.beam_boundaries_base import SpatialBeamBoundariesBase
+
+__all__ = ["CISpatialBeamBoundaries"]
+
+
+class CISpatialBeamBoundaries(SpatialBeamBoundariesBase):
+    """Task class for calculation of the CI beam boundaries for later use during calibration."""
+
+    num_beams = 1
+
+    def match_beam_sizes(
+        self, beam_boundary_list: list[tuple[int, int]], full_spatial_size: int
+    ) -> list[tuple[int, int]]:
+        """
+        Ensure that all spatial beam boundaries produce arrays of the same shape.
+
+        For CI there is only one beam so we just return the input boundaries.
+        """
+        logger.info(f"Full array spatial boundaries = {beam_boundary_list[0]}")
+
+        return beam_boundary_list

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/dkist_processing_cryonirsp/tasks/dark.py

@@ -6,7 +6,7 @@ from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
 
 from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
-from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundaries
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
     CryonirspLinearizedFitsAccess,
@@ -70,7 +70,7 @@ class DarkCalibration(CryonirspTaskBase):
                         decoder=cryo_fits_array_decoder,
                     )
                 )
-                beam_boundary = BeamBoundary(*beam_array)
+                beam_boundary = BeamBoundaries(*beam_array)
 
                 for exposure_conditions in target_exposure_conditions:
                     logger.info(

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/dkist_processing_cryonirsp/tasks/gain.py

@@ -10,7 +10,7 @@ from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
 
 from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
-from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundaries
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
@@ -92,7 +92,7 @@ class GainCalibrationBase(CryonirspTaskBase):
                         decoder=cryo_fits_array_decoder,
                     )
                 )
-                beam_boundary = BeamBoundary(*beam_array)
+                beam_boundary = BeamBoundaries(*beam_array)
 
                 for exposure_conditions in target_exposure_conditions:
                     apm_str = f"{beam = } and {exposure_conditions = }"
@@ -190,7 +190,7 @@ class GainCalibrationBase(CryonirspTaskBase):
                 decoder=cryo_fits_array_decoder,
             )
         )
-        beam_boundary = BeamBoundary(*beam_array)
+        beam_boundary = BeamBoundaries(*beam_array)
         tags = CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions) + [
             self.gain_tag
         ]

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/dkist_processing_cryonirsp/tasks/instrument_polarization.py

@@ -20,7 +20,7 @@ from dkist_service_configuration.logging import logger
 
 from dkist_processing_cryonirsp.codecs.fits import cryo_fits_access_decoder
 from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
-from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundaries
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
@@ -250,7 +250,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                 decoder=cryo_fits_array_decoder,
             )
         )
-        beam_boundary = BeamBoundary(*beam_array)
+        beam_boundary = BeamBoundaries(*beam_array)
         polcal_tags = [
             CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
             CryonirspTag.cs_step(cs_step),
@@ -374,7 +374,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                         decoder=cryo_fits_array_decoder,
                     )
                 )
-                beam_boundary = BeamBoundary(*beam_array)
+                beam_boundary = BeamBoundaries(*beam_array)
                 for exposure_conditions in target_exposure_conditions_list:
                     with self.telemetry_span(
                         f"Calculating polcal dark array(s) for {exposure_conditions = } and {beam = }"
@@ -417,7 +417,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                         decoder=cryo_fits_array_decoder,
                     )
                 )
-                beam_boundary = BeamBoundary(*beam_array)
+                beam_boundary = BeamBoundaries(*beam_array)
                 for exposure_conditions in exposure_conditions_list:
                     logger.info(
                         f"Load polcal dark array for {exposure_conditions = } and {beam = }"

{dkist_processing_cryonirsp-2.1.5 → dkist_processing_cryonirsp-3.0.0}/dkist_processing_cryonirsp/tasks/science_base.py

@@ -20,7 +20,7 @@ from dkist_service_configuration.logging import logger
 
 from dkist_processing_cryonirsp.codecs.fits import cryo_fits_access_decoder
 from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
-from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundaries
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
@@ -156,7 +156,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
                 decoder=cryo_fits_array_decoder,
             )
         )
-        beam_boundary = BeamBoundary(*beam_array)
+        beam_boundary = BeamBoundaries(*beam_array)
         observe_object_tags = self.build_observe_file_tags(
             map_scan=map_scan,
             scan_step=scan_step,

dkist_processing_cryonirsp-3.0.0/dkist_processing_cryonirsp/tasks/sp_beam_boundaries.py

@@ -0,0 +1,52 @@
+"""Cryonirsp SP beam boundaries task."""
+
+from dkist_service_configuration.logging import logger
+
+from dkist_processing_cryonirsp.tasks.beam_boundaries_base import SpatialBeamBoundariesBase
+
+__all__ = ["SPSpatialBeamBoundaries"]
+
+
+class SPSpatialBeamBoundaries(SpatialBeamBoundariesBase):
+    """Task class for calculation of the SP spatial beam boundaries for later use during calibration."""
+
+    num_beams = 2
+
+    def match_beam_sizes(
+        self, beam_boundary_list: list[tuple[int, int]], full_spatial_size: int
+    ) -> list[tuple[int, int]]:
+        """
+        Ensure that all spatial beam boundaries produce arrays of the same shape.
+
+        The final spatial size for both beams is simply the smalles size represented in the raw boundaries; the beam that
+        is larger will have its boundaries adjusted to match the smaller size. This adjustment is only made to one side
+        of the boundaries: the side that is closest to the detector edge. The logic here is that a boundary farther from
+        the detector edge is more likely to be the real edge of illumination (as opposed to simply the edge of the detector),
+        which we take to be a more valid location for the absolute position of that beam.
+        """
+        beam1_boundaries, beam2_boundaries = beam_boundary_list
+
+        beam1_size = beam1_boundaries[1] - beam1_boundaries[0]
+        beam2_size = beam2_boundaries[1] - beam2_boundaries[0]
+
+        final_beam_size = min(beam1_size, beam2_size)
+
+        logger.info(f"{beam1_size = :d}, {beam2_size = :d} => {final_beam_size = :d}")
+
+        final_boundary_objects = []
+        for beam, (boundaries, size) in enumerate(
+            zip(beam_boundary_list, [beam1_size, beam2_size]), start=1
+        ):
+            size_diff = size - final_beam_size
+
+            logger.info(f"Beam {beam} has {size_diff = :d}")
+            logger.info(f"Raw spatial boundaries = {boundaries}")
+            if boundaries[0] > full_spatial_size - boundaries[1]:
+                logger.info(f"Adjusting boundary by -{size_diff} at high end")
+                final_boundary_objects.append((boundaries[0], boundaries[1] - size_diff))
+            else:
+                logger.info(f"Adjusting boundary by {size_diff} at low end")
+                final_boundary_objects.append((boundaries[0] + size_diff, boundaries[1]))
+            logger.info(f"New spatial boundaries = {final_boundary_objects[-1]}")
+
+        return final_boundary_objects