dkist-processing-cryonirsp 1.4.20__py3-none-any.whl → 1.14.9rc1__py3-none-any.whl

dkist_processing_cryonirsp/parsers/polarimetric_check.py

@@ -1,5 +1,7 @@
 """Copy of UniqueBud from common that only activates if the frames are polarimetric "observe" or "polcal" task, or non-polarimetric "observe" task."""
-from collections import namedtuple
+
+from enum import StrEnum
+from typing import NamedTuple
 from typing import Type
 
 from dkist_processing_common.models.flower_pot import SpilledDirt
@@ -7,21 +9,30 @@ from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.models.flower_pot import Thorn
 from dkist_processing_common.models.task_name import TaskName
 
-from dkist_processing_cryonirsp.models.constants import CryonirspBudName
+from dkist_processing_cryonirsp.models.fits_access import CryonirspMetadataKey
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
 
 
+class PolarimetricValueDataContainer(NamedTuple):
+    """Named tuple to hold polarimetric metadata about a task."""
+
+    task: str
+    num_modstates: int
+    spin_mode: str
+    bud_value: str | int | float | bool
+
+
 class PolarimetricCheckingUniqueBud(Stem):
     """Bud for checking if frames are polarimetric."""
 
-    PolarimetricValueData = namedtuple(
-        "PolarimetricValueData", ["task", "num_modstates", "spin_mode", "bud_value"]
-    )
+    PolarimetricValueData = PolarimetricValueDataContainer
     observe_task_name = TaskName.observe.value.casefold()
     polcal_task_name = TaskName.polcal.value.casefold()
 
-    def __init__(self, constant_name: str, metadata_key: str):
+    def __init__(self, constant_name: str, metadata_key: str | StrEnum):
         super().__init__(stem_name=constant_name)
+        if isinstance(metadata_key, StrEnum):
+            metadata_key = metadata_key.name
         self.metadata_key = metadata_key
 
     @property
@@ -71,7 +82,7 @@ class PolarimetricCheckingUniqueBud(Stem):
         # Some intensity mode data has the number of modulator states set to 0
         num_modstates = fits_obj.number_of_modulator_states or 1
 
-        if self.metadata_key == "number_of_modulator_states":
+        if self.metadata_key == CryonirspMetadataKey.number_of_modulator_states.name:
             bud_value = num_modstates
         else:
             bud_value = getattr(fits_obj, self.metadata_key)

dkist_processing_cryonirsp/parsers/scan_step.py

@@ -3,6 +3,7 @@ Machinery for sorting files based on scan step.
 
 Also includes base classes that can be used to sort files based on map scan.
 """
+
 ######################
 # HOW THIS ALL WORKS #
 ######################
@@ -312,11 +313,11 @@ class MapScanStepStemBase(Stem, ABC):
         return step_list.index(scan_step_obj) + 1  # Here we decide that map scan indices start at 1
 
 
-class NumberOfScanStepsBud(MapScanStepStemBase):
-    """Bud for finding the total number of scan steps."""
+class NumberOfScanStepsBase(MapScanStepStemBase, ABC):
+    """Base class for managing scan steps."""
 
-    def __init__(self):
-        super().__init__(stem_name=CryonirspBudName.num_scan_steps.value)
+    def __init__(self, stem_name: CryonirspBudName):
+        super().__init__(stem_name=stem_name)
 
     @cached_property
     def map_scan_to_obj_dict(self) -> dict[int, list[SingleScanStep]]:
@@ -361,6 +362,13 @@ class NumberOfScanStepsBud(MapScanStepStemBase):
 
         return len(completed_steps)
 
+
+class NumberOfScanStepsBud(NumberOfScanStepsBase):
+    """Bud for finding the total number of scan steps."""
+
+    def __init__(self):
+        super().__init__(stem_name=CryonirspBudName.num_scan_steps.value)
+
     def getter(self, key):
         """
         Compute the number of complete scan steps.

dkist_processing_cryonirsp/parsers/time.py

@@ -1,4 +1,5 @@
 """Buds to parse exposure time."""
+
 from typing import Hashable
 from typing import Type
 
@@ -12,12 +13,11 @@ from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import Cryonirs
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspRampFitsAccess
 
 
-class CryonirspSolarGainStartTimeBud(Stem):
-    """Bud for finding the start time of the solar gain."""
+class CryonirspSolarGainTimeObsBud(Stem):
+    """Bud for finding the start time of the solar gain from the time_obs header key."""
 
     def __init__(self):
-        self.metadata_key = "time_obs"
-        super().__init__(stem_name=CryonirspBudName.solar_gain_ip_start_time.value)
+        super().__init__(stem_name=CryonirspBudName.solar_gain_start_time.value)
 
     def setter(self, fits_obj: CryonirspL0FitsAccess) -> Type[SpilledDirt] | int:
         """
@@ -30,12 +30,12 @@ class CryonirspSolarGainStartTimeBud(Stem):
         """
         if parse_header_ip_task_with_gains(fits_obj) != TaskName.solar_gain.value:
             return SpilledDirt
-        return getattr(fits_obj, self.metadata_key)
+        return fits_obj.time_obs
 
     def getter(self, key: Hashable):
         """Return the first date-obs value."""
-        first_date_obs = min(list(self.key_to_petal_dict.values()))
-        return first_date_obs
+        first_time_obs = min(list(self.key_to_petal_dict.values()))
+        return first_time_obs
 
 
 class CryonirspTimeObsBud(Stem):

dkist_processing_cryonirsp/parsers/wavelength.py

@@ -1,4 +1,6 @@
 """CryoNIRSP bud to get the wavelength."""
+
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.flower_pot import SpilledDirt
 from dkist_processing_common.parsers.unique_bud import UniqueBud
 
@@ -10,7 +12,10 @@ class ObserveWavelengthBud(UniqueBud):
     """Bud to find the wavelength."""
 
     def __init__(self):
-        super().__init__(constant_name=CryonirspBudName.wavelength.value, metadata_key="wavelength")
+        super().__init__(
+            constant_name=CryonirspBudName.wavelength.value,
+            metadata_key=MetadataKey.wavelength,
+        )
 
     def setter(self, fits_obj: CryonirspL0FitsAccess):
         """

dkist_processing_cryonirsp/tasks/__init__.py

@@ -1,4 +1,5 @@
 """Init."""
+
 from dkist_processing_cryonirsp.tasks.assemble_movie import *
 from dkist_processing_cryonirsp.tasks.bad_pixel_map import *
 from dkist_processing_cryonirsp.tasks.ci_beam_boundaries import *
@@ -11,8 +12,8 @@ from dkist_processing_cryonirsp.tasks.make_movie_frames import *
 from dkist_processing_cryonirsp.tasks.parse import *
 from dkist_processing_cryonirsp.tasks.quality_metrics import *
 from dkist_processing_cryonirsp.tasks.sp_beam_boundaries import *
-from dkist_processing_cryonirsp.tasks.sp_dispersion_axis_correction import *
 from dkist_processing_cryonirsp.tasks.sp_geometric import *
 from dkist_processing_cryonirsp.tasks.sp_science import *
 from dkist_processing_cryonirsp.tasks.sp_solar_gain import *
+from dkist_processing_cryonirsp.tasks.sp_wavelength_calibration import *
 from dkist_processing_cryonirsp.tasks.write_l1 import *

dkist_processing_cryonirsp/tasks/assemble_movie.py

@@ -1,4 +1,5 @@
 """CryoNIRSP-specific assemble movie task subclass."""
+
 import numpy as np
 from dkist_processing_common.tasks import AssembleMovie
 from dkist_service_configuration.logging import logger

dkist_processing_cryonirsp/tasks/bad_pixel_map.py

@@ -1,4 +1,5 @@
 """Task class for bad pixel map computation."""
+
 import numpy as np
 import scipy.ndimage as spnd
 from dkist_processing_common.codecs.fits import fits_array_encoder
@@ -48,11 +49,11 @@ class BadPixelMapCalibration(CryonirspTaskBase):
         None
 
         """
-        with self.apm_task_step(f"Compute average uncorrected solar gain image"):
+        with self.telemetry_span(f"Compute average uncorrected solar gain image"):
             average_solar_gain_array = self.compute_average_gain_array()
 
-        with self.apm_task_step(f"Compute the bad pixel map"):
-            with self.apm_processing_step("Smooth array with median filter"):
+        with self.telemetry_span(f"Compute the bad pixel map"):
+            with self.telemetry_span("Smooth array with median filter"):
                 filter_size = self.parameters.bad_pixel_map_median_filter_size
                 filtered_array = spnd.median_filter(
                     average_solar_gain_array,
@@ -61,7 +62,7 @@ class BadPixelMapCalibration(CryonirspTaskBase):
                     cval=np.nanmedian(average_solar_gain_array),
                 )
 
-            with self.apm_processing_step("Identify bad pixels"):
+            with self.telemetry_span("Identify bad pixels"):
                 thresh = self.parameters.bad_pixel_map_threshold_factor
 
                 diff = filtered_array - average_solar_gain_array
@@ -71,7 +72,7 @@ class BadPixelMapCalibration(CryonirspTaskBase):
                 zeros = np.where(average_solar_gain_array == 0.0)
                 bad_pixel_map[zeros] = 1
 
-        with self.apm_writing_step("Writing bad pixel map"):
+        with self.telemetry_span("Writing bad pixel map"):
             self.write(
                 data=bad_pixel_map,
                 tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],

dkist_processing_cryonirsp/tasks/beam_boundaries_base.py

@@ -1,4 +1,5 @@
 """CryoNIRSP compute beam boundary task."""
+
 from abc import abstractmethod
 
 import numpy as np
@@ -61,11 +62,11 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
 
         """
         # Step 1:
-        with self.apm_processing_step(f"Compute average solar gain image"):
+        with self.telemetry_span(f"Compute average solar gain image"):
             average_solar_gain_array = self.compute_average_gain_array()
 
         # Step 2:
-        with self.apm_task_step(f"Retrieve bad pixel map"):
+        with self.telemetry_span(f"Retrieve bad pixel map"):
             bad_pixel_map = next(
                 self.read(
                     tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
@@ -77,21 +78,19 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
             )
 
         # Step 3
-        with self.apm_processing_step(f"Smooth the array to get good segmentation"):
+        with self.telemetry_span(f"Smooth the array to get good segmentation"):
             smoothed_solar_gain_array = self.smooth_gain_array(corrected_solar_gain_array)
 
         # Step 4
-        with self.apm_processing_step(f"Split the beam horizontally"):
+        with self.telemetry_span(f"Split the beam horizontally"):
             split_beams = self.split_beams(smoothed_solar_gain_array)
 
         # Step 5
-        with self.apm_processing_step(
-            f"Segment the beams into illuminated and non-illuminated pixels"
-        ):
+        with self.telemetry_span(f"Segment the beams into illuminated and non-illuminated pixels"):
             segmented_beams = self.segment_arrays(split_beams)
 
         # Step 6:
-        with self.apm_processing_step(
+        with self.telemetry_span(
             f"Compute the inscribed rectangular extents of the illuminated portions of the sensor"
         ):
             illuminated_boundaries = self.compute_boundaries_of_beam_illumination_regions(
@@ -99,14 +98,14 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
             )
 
         # Steps 7 - 9:
-        with self.apm_processing_step(f"Compute the boundaries of the illuminated beams"):
+        with self.telemetry_span(f"Compute the boundaries of the illuminated beams"):
             split_beams_float = [split_beam.astype(float) for split_beam in split_beams]
             boundaries = self.compute_final_beam_boundaries(
                 split_beams_float, illuminated_boundaries
             )
 
         # Step 10:
-        with self.apm_writing_step("Writing beam boundaries"):
+        with self.telemetry_span("Writing beam boundaries"):
             for beam, bounds in enumerate(boundaries, start=1):
                 self.write(
                     data=bounds.beam_boundaries_array,
@@ -233,7 +232,9 @@ class BeamBoundariesCalibrationBase(CryonirspTaskBase):
                     f"Unable to compute illuminated image boundaries for beam {beam}"
                 )
 
-            boundaries.append(BeamBoundary(y_min, y_max, x_min, x_max))
+            boundaries.append(
+                BeamBoundary(np.int64(y_min), np.int64(y_max), np.int64(x_min), np.int64(x_max))
+            )
 
         return boundaries
 

dkist_processing_cryonirsp/tasks/ci_beam_boundaries.py

@@ -1,4 +1,5 @@
 """Cryonirsp CI beam boundaries task."""
+
 import largestinteriorrectangle as lir
 import numpy as np
 from dkist_service_configuration.logging import logger

dkist_processing_cryonirsp/tasks/ci_science.py

@@ -1,4 +1,5 @@
 """Cryonirsp CI science calibration task."""
+
 from collections import defaultdict
 
 from dkist_service_configuration.logging import logger

dkist_processing_cryonirsp/tasks/cryonirsp_base.py

@@ -1,8 +1,8 @@
 """CryoNIRSP base class."""
+
 from abc import ABC
 
 from dkist_processing_common.tasks import WorkflowTaskBase
-from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
 from dkist_processing_common.tasks.mixin.quality import QualityMixin
 
 from dkist_processing_cryonirsp.models.constants import CryonirspConstants
@@ -12,7 +12,6 @@ from dkist_processing_cryonirsp.tasks.mixin.corrections import CorrectionsMixin
 
 class CryonirspTaskBase(
     WorkflowTaskBase,
-    InputDatasetMixin,
     CorrectionsMixin,
     QualityMixin,
     ABC,
@@ -50,7 +49,7 @@ class CryonirspTaskBase(
             workflow_version=workflow_version,
         )
         self.parameters = CryonirspParameters(
-            self.input_dataset_parameters,
+            scratch=self.scratch,
             obs_ip_start_time=self.constants.obs_ip_start_time,
             wavelength=self.constants.wavelength,
             arm_id=self.constants.arm_id,

dkist_processing_cryonirsp/tasks/dark.py

@@ -1,4 +1,5 @@
 """CryoNIRSP dark calibration task."""
+
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_math.statistics import average_numpy_arrays
@@ -57,7 +58,7 @@ class DarkCalibration(CryonirspTaskBase):
             )
 
         logger.info(f"{target_exposure_conditions = }")
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Calculating dark frames for {self.constants.num_beams} beams and {len(target_exposure_conditions)} exp times"
         ):
             total_dark_frames_used = 0
@@ -89,12 +90,12 @@ class DarkCalibration(CryonirspTaskBase):
                         beam_boundary=beam_boundary,
                     )
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Calculating dark for {exposure_conditions = } and {beam = }"
                     ):
                         averaged_dark_array = average_numpy_arrays(linearized_dark_arrays)
 
-                    with self.apm_writing_step(
+                    with self.telemetry_span(
                         f"Writing dark for {exposure_conditions = } {beam = }"
                     ):
                         self.write(
@@ -108,7 +109,7 @@ class DarkCalibration(CryonirspTaskBase):
                             encoder=fits_array_encoder,
                         )
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_dark_frames: int = self.scratch.count_all(
                 tags=[
                     CryonirspTag.linearized_frame(),

dkist_processing_cryonirsp/tasks/gain.py

@@ -1,4 +1,5 @@
 """Cryo gain task."""
+
 from abc import abstractmethod
 
 import numpy as np
@@ -80,7 +81,7 @@ class GainCalibrationBase(CryonirspTaskBase):
         target_exposure_conditions = self.exposure_conditions
 
         logger.info(f"{target_exposure_conditions = }")
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Generate {self.gain_type} for {len(target_exposure_conditions)} exposure times"
         ):
             for beam in range(1, self.constants.num_beams + 1):
@@ -95,7 +96,7 @@ class GainCalibrationBase(CryonirspTaskBase):
 
                 for exposure_conditions in target_exposure_conditions:
                     apm_str = f"{beam = } and {exposure_conditions = }"
-                    with self.apm_processing_step(f"Remove dark signal for {apm_str}"):
+                    with self.telemetry_span(f"Remove dark signal for {apm_str}"):
                         dark_array = next(
                             self.read(
                                 tags=[
@@ -116,7 +117,7 @@ class GainCalibrationBase(CryonirspTaskBase):
                             subtract_array_from_arrays(avg_gain_array, dark_array)
                         )
 
-                    with self.apm_processing_step(f"Correct bad pixels for {apm_str}"):
+                    with self.telemetry_span(f"Correct bad pixels for {apm_str}"):
                         bad_pixel_map = next(
                             self.read(
                                 tags=[
@@ -132,12 +133,12 @@ class GainCalibrationBase(CryonirspTaskBase):
                         )
 
                     if self.normalize_gain_switch:
-                        with self.apm_processing_step(f"Normalize final gain for {apm_str}"):
+                        with self.telemetry_span(f"Normalize final gain for {apm_str}"):
                             normalized_gain_array = self.normalize_gain(bad_pixel_corrected_array)
                     else:
                         normalized_gain_array = bad_pixel_corrected_array
 
-                    with self.apm_writing_step(
+                    with self.telemetry_span(
                         f"Writing gain array for {beam = } and {exposure_conditions = }"
                     ):
                         self.write(
@@ -151,7 +152,7 @@ class GainCalibrationBase(CryonirspTaskBase):
                             encoder=fits_array_encoder,
                         )
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_gain_frames: int = self.scratch.count_all(
                 tags=[
                     CryonirspTag.linearized_frame(),

dkist_processing_cryonirsp/tasks/instrument_polarization.py

@@ -1,4 +1,5 @@
 """Cryo instrument polarization task."""
+
 from abc import ABC
 from abc import abstractmethod
 from collections import defaultdict
@@ -87,10 +88,10 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
             f"Demodulation matrices will span FOV with shape {(self.parameters.polcal_num_spatial_bins, self.parameters.polcal_num_spatial_bins)}"
         )
         for beam in range(1, self.constants.num_beams + 1):
-            with self.apm_processing_step(f"Reducing CS steps for {beam = }"):
+            with self.telemetry_span(f"Reducing CS steps for {beam = }"):
                 local_reduced_arrays, global_reduced_arrays = self.reduce_cs_steps(beam)
 
-            with self.apm_processing_step(f"Fit CU parameters for {beam = }"):
+            with self.telemetry_span(f"Fit CU parameters for {beam = }"):
                 local_dresser = Dresser()
                 local_dresser.add_drawer(Drawer(local_reduced_arrays))
                 global_dresser = Dresser()
@@ -99,11 +100,11 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                     local_dresser=local_dresser,
                     global_dresser=global_dresser,
                     fit_mode=self.parameters.polcal_pac_fit_mode,
-                    init_set=self.parameters.polcal_pac_init_set,
+                    init_set=self.constants.pac_init_set,
                     fit_TM=False,
                 )
 
-            with self.apm_processing_step(f"Resampling demodulation matrices for {beam = }"):
+            with self.telemetry_span(f"Resampling demodulation matrices for {beam = }"):
                 demod_matrices = pac_fitter.demodulation_matrices
                 # Reshaping the demodulation matrix to get rid of unit length dimensions
                 logger.info(f"Resampling demodulation matrices for {beam = }")
@@ -112,7 +113,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                     f"Shape of resampled demodulation matrices for {beam = }: {demod_matrices.shape}"
                 )
 
-            with self.apm_writing_step(f"Writing demodulation matrices for {beam = }"):
+            with self.telemetry_span(f"Writing demodulation matrices for {beam = }"):
                 self.write(
                     data=demod_matrices,
                     tags=[
@@ -122,10 +123,10 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                     encoder=fits_array_encoder,
                 )
 
-            with self.apm_processing_step("Computing and recording polcal quality metrics"):
+            with self.telemetry_span("Computing and recording polcal quality metrics"):
                 self.record_polcal_quality_metrics(beam, polcal_fitter=pac_fitter)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_polcal_frames: int = self.scratch.count_all(
                 tags=[
                     CryonirspTag.linearized_frame(),
@@ -270,11 +271,11 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
         avg_inst_pol_cal_header = next(pol_cal_headers)
         avg_inst_pol_cal_array = average_numpy_arrays(pol_cal_arrays)
 
-        with self.apm_processing_step(f"Apply basic corrections for {apm_str}"):
+        with self.telemetry_span(f"Apply basic corrections for {apm_str}"):
             dark_corrected_array = subtract_array_from_arrays(avg_inst_pol_cal_array, dark_array)
             gain_corrected_array = next(divide_arrays_by_array(dark_corrected_array, gain_array))
 
-        with self.apm_processing_step(f"Extract macro pixels from {apm_str}"):
+        with self.telemetry_span(f"Extract macro pixels from {apm_str}"):
             self.set_original_beam_size(gain_corrected_array)
             output_shape = (
                 self.parameters.polcal_num_spatial_bins,
@@ -283,7 +284,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
             local_binned_array = next(resize_arrays(gain_corrected_array, output_shape))
             global_binned_array = next(resize_arrays(gain_corrected_array, (1, 1)))
 
-        with self.apm_processing_step(f"Create reduced CryonirspL0FitsAccess for {apm_str}"):
+        with self.telemetry_span(f"Create reduced CryonirspL0FitsAccess for {apm_str}"):
             local_result = CryonirspL0FitsAccess(
                 fits.ImageHDU(local_binned_array[:, :], avg_inst_pol_cal_header),
                 auto_squeeze=False,
@@ -348,7 +349,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
         self, target_exposure_conditions_list: [ExposureConditions]
     ):
         """Compute the polcal dark calibration."""
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Calculating dark frames for {len(target_exposure_conditions_list)} exp times"
         ):
             for beam in range(1, self.constants.num_beams + 1):
@@ -360,7 +361,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                 )
                 beam_boundary = BeamBoundary(*beam_array)
                 for exposure_conditions in target_exposure_conditions_list:
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Calculating polcal dark array(s) for {exposure_conditions = } and {beam = }"
                     ):
                         linearized_dark_arrays = self.read(
@@ -375,7 +376,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                             beam_boundary=beam_boundary,
                         )
                         averaged_dark_array = average_numpy_arrays(linearized_dark_arrays)
-                        with self.apm_writing_step(
+                        with self.telemetry_span(
                             f"Writing dark for {exposure_conditions = } and {beam = }"
                         ):
                             self.write(
@@ -391,7 +392,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
 
     def generate_polcal_gain_calibration(self, exposure_conditions_list: [ExposureConditions]):
         """Compute the polcal gain calibration."""
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Generate gains for {len(exposure_conditions_list)} exposure conditions"
         ):
             for beam in range(1, self.constants.num_beams + 1):
@@ -422,7 +423,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                         raise ValueError(
                             f"No matching polcal dark found for {exposure_conditions = } s and {beam = }"
                         ) from e
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Calculating polcal gain array(s) for {exposure_conditions = } and {beam = }"
                     ):
                         linearized_gain_arrays = self.read(
@@ -459,7 +460,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                             bad_pixel_corrected_array
                         )
 
-                    with self.apm_writing_step(
+                    with self.telemetry_span(
                         f"Writing gain array for exposure time {exposure_conditions} and {beam = }"
                     ):
                         self.write(

dkist_processing_cryonirsp/tasks/l1_output_data.py

@@ -1,4 +1,5 @@
 """Subclasses of AssembleQualityData that cause the correct polcal metrics to build."""
+
 from typing import Type
 
 from dkist_processing_common.tasks import AssembleQualityData

dkist_processing_cryonirsp/tasks/linearity_correction.py

@@ -1,4 +1,5 @@
 """CryoNIRSP Linearity Correction Task."""
+
 from dataclasses import dataclass
 from typing import Generator
 

dkist_processing_cryonirsp/tasks/make_movie_frames.py

@@ -1,4 +1,5 @@
 """Cryonirsp make movie frames task."""
+
 from abc import ABC
 from abc import abstractmethod
 
@@ -22,10 +23,10 @@ class MakeCryonirspMovieFramesBase(CryonirspTaskBase, ABC):
     def run(self):
         """Create movie frames using all stokes states if they exist, otherwise only use intensity."""
         if self.constants.correct_for_polarization:
-            with self.apm_task_step("Make full stokes movie"):
+            with self.telemetry_span("Make full stokes movie"):
                 self.make_full_stokes_movie_frames()
         else:
-            with self.apm_task_step("Make intensity only movie"):
+            with self.telemetry_span("Make intensity only movie"):
                 self.make_intensity_movie_frames()
 
     @abstractmethod

dkist_processing_cryonirsp/tasks/mixin/corrections.py

@@ -1,4 +1,5 @@
 """Helper for CRYO-Nirsp array corrections."""
+
 from collections.abc import Generator
 from collections.abc import Iterable
 

dkist_processing_cryonirsp/tasks/mixin/shift_measurements.py

@@ -1,4 +1,5 @@
 """Mixin to support array shift calculations."""
+
 import math
 from dataclasses import dataclass
 
@@ -123,10 +124,16 @@ class ShiftMeasurementsMixin:
             array_2_strip, axis=array_2_axis_params.long_axis
         )
 
+        if axis == SPECTRAL:
+            # Chop 10% off of the edges of the spectra to remove known edge effects before determining shift.
+            tenth_of_length = array_1_gradient.shape[0] // 10
+            array_1_gradient = array_1_gradient[tenth_of_length:-tenth_of_length]
+            array_2_gradient = array_2_gradient[tenth_of_length:-tenth_of_length]
+
         # Correlate the gradient signals to get the shift of array 2 relative to array 1
         shift_array, error, phasediff = skir.phase_cross_correlation(
-            array_1_gradient,
-            array_2_gradient,
+            reference_image=array_1_gradient,
+            moving_image=array_2_gradient,
             upsample_factor=upsample_factor,
         )
         # Flip the sign to convert from correction to measurement.