dkist-processing-cryonirsp 1.13.1__py3-none-any.whl → 1.14.1rc1__py3-none-any.whl

changelog/223.misc.rst

@@ -0,0 +1 @@
+Update `dkist-processing-common` to v11.7.0, which makes constants for the dataset extras.

dkist_processing_cryonirsp/tasks/bad_pixel_map.py

@@ -49,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,
@@ -62,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
@@ -72,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

@@ -62,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()],
@@ -78,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(
@@ -100,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,

dkist_processing_cryonirsp/tasks/dark.py

@@ -58,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
@@ -90,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(
@@ -109,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

@@ -81,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):
@@ -96,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=[
@@ -117,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=[
@@ -133,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(
@@ -152,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

@@ -88,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()
@@ -104,7 +104,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                     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 = }")
@@ -113,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=[
@@ -123,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(),
@@ -271,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,
@@ -284,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,
@@ -349,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):
@@ -361,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(
@@ -376,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(
@@ -392,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):
@@ -423,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(
@@ -460,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/make_movie_frames.py

@@ -23,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/quality_metrics.py

@@ -108,26 +108,26 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
     def run(self) -> None:
         """Calculate sensitivity and noise quality metrics."""
         if self.constants.correct_for_polarization:
-            with self.apm_processing_step(
-                "Calculating L1 Sensitivity metrics for all stokes states"
-            ):
+            with self.telemetry_span("Calculating L1 Sensitivity metrics for all stokes states"):
                 self.compute_full_stokes_sensitivity()
-            with self.apm_task_step("Calculating L1 Cryonirsp noise metrics for all stokes states"):
+            with self.telemetry_span(
+                "Calculating L1 Cryonirsp noise metrics for all stokes states"
+            ):
                 self.compute_full_stokes_noise()
         else:
-            with self.apm_processing_step("Calculating L1 Sensitivity metrics for intensity only"):
+            with self.telemetry_span("Calculating L1 Sensitivity metrics for intensity only"):
                 self.compute_intensity_only_sensitivity()
-            with self.apm_task_step("Calculating L1 Cryonirsp noise metrics for intensity only"):
+            with self.telemetry_span("Calculating L1 Cryonirsp noise metrics for intensity only"):
                 self.compute_intensity_only_noise()
 
     def compute_full_stokes_sensitivity(self):
         """Compute the sensitivities of each map scan for each stokes state."""
         for stokes_state in self.constants.stokes_params:
-            with self.apm_processing_step(f"Calculating sensitivity for stokes = {stokes_state}"):
+            with self.telemetry_span(f"Calculating sensitivity for stokes = {stokes_state}"):
                 quality_data = self.calculate_sensitivity_for_stokes_state(
                     stokes_state=stokes_state
                 )
-            with self.apm_writing_step(f"Writing sensitivity data for stokes = {stokes_state}"):
+            with self.telemetry_span(f"Writing sensitivity data for stokes = {stokes_state}"):
                 self.quality_store_sensitivity(
                     stokes=stokes_state,
                     datetimes=quality_data.datetimes,
@@ -136,9 +136,9 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
 
     def compute_intensity_only_sensitivity(self):
         """Compute the sensitivities of each map scan for the intensity stokes state only."""
-        with self.apm_processing_step(f"Calculating sensitivity for intensity only"):
+        with self.telemetry_span(f"Calculating sensitivity for intensity only"):
             quality_data = self.calculate_sensitivity_for_stokes_state(stokes_state="I")
-        with self.apm_writing_step("Writing sensitivity data for intensity only"):
+        with self.telemetry_span("Writing sensitivity data for intensity only"):
             self.quality_store_sensitivity(
                 stokes="I", datetimes=quality_data.datetimes, values=quality_data.values
             )
@@ -146,9 +146,9 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
     def compute_full_stokes_noise(self):
         """Compute noise in data broken down by each stokes state."""
         for stokes in self.constants.stokes_params:
-            with self.apm_processing_step(f"Compile noise values for {stokes=}"):
+            with self.telemetry_span(f"Compile noise values for {stokes=}"):
                 noise_data = self.compile_noise_data(stokes=stokes)
-            with self.apm_writing_step(f"Write noise values for {stokes=}"):
+            with self.telemetry_span(f"Write noise values for {stokes=}"):
                 self.quality_store_noise(
                     datetimes=noise_data.datetimes, values=noise_data.values, stokes=stokes
                 )
@@ -156,9 +156,9 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
     def compute_intensity_only_noise(self):
         """Compute noise in data for the intensity stokes state only."""
         stokes = "I"
-        with self.apm_processing_step(f"Compile noise values for {stokes=}"):
+        with self.telemetry_span(f"Compile noise values for {stokes=}"):
             noise_data = self.compile_noise_data(stokes=stokes)
-        with self.apm_writing_step(f"Write noise values for {stokes=}"):
+        with self.telemetry_span(f"Write noise values for {stokes=}"):
             self.quality_store_noise(
                 datetimes=noise_data.datetimes, values=noise_data.values, stokes=stokes
             )

dkist_processing_cryonirsp/tasks/science_base.py

@@ -70,17 +70,17 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         None
 
         """
-        with self.apm_task_step("Loading calibration objects"):
+        with self.telemetry_span("Loading calibration objects"):
             calibrations = self.collect_calibration_objects()
 
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Calibrating Science Frames for "
             f"{self.constants.num_map_scans} map scans and "
             f"{self.constants.num_scan_steps} scan steps"
         ):
             self.calibrate_and_write_frames(calibrations=calibrations)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_science_frames: int = self.scratch.count_all(
                 tags=[
                     CryonirspTag.linearized_frame(),
@@ -227,7 +227,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         array_stack = np.zeros(array_shape + (self.constants.num_modstates,))
         header_stack = []
 
-        with self.apm_processing_step(f"Correcting {self.constants.num_modstates} modstates"):
+        with self.telemetry_span(f"Correcting {self.constants.num_modstates} modstates"):
             for modstate in range(1, self.constants.num_modstates + 1):
                 # Correct the arrays
                 corrected_array, corrected_header = self.apply_basic_corrections(
@@ -243,7 +243,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
                 array_stack[:, :, modstate - 1] = corrected_array
                 header_stack.append(corrected_header)
 
-        with self.apm_processing_step("Applying instrument polarization correction"):
+        with self.telemetry_span("Applying instrument polarization correction"):
             intermediate_array = self.polarization_correction(
                 array_stack, calibrations.demod_matrices[CryonirspTag.beam(beam)]
             )

dkist_processing_cryonirsp/tasks/sp_geometric.py

@@ -71,39 +71,39 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         """
         # The basic corrections are done outside the loop structure below as it makes these loops much
         # simpler than they would be otherwise. See the comments in do_basic_corrections for more details.
-        with self.apm_processing_step("Basic corrections"):
+        with self.telemetry_span("Basic corrections"):
             self.do_basic_corrections()
 
         for beam in range(1, self.constants.num_beams + 1):
-            with self.apm_task_step(f"Generating geometric calibrations for {beam = }"):
-                with self.apm_processing_step(f"Computing and writing angle for {beam = }"):
+            with self.telemetry_span(f"Generating geometric calibrations for {beam = }"):
+                with self.telemetry_span(f"Computing and writing angle for {beam = }"):
                     angle = self.compute_beam_angle(beam=beam)
                     self.write_angle(angle=angle, beam=beam)
 
-                with self.apm_processing_step(f"Removing angle from {beam = }"):
+                with self.telemetry_span(f"Removing angle from {beam = }"):
                     angle_corr_array = self.remove_beam_angle(angle=angle, beam=beam)
 
-                with self.apm_processing_step(f"Computing offset for {beam = }"):
+                with self.telemetry_span(f"Computing offset for {beam = }"):
                     beam_offset = self.compute_offset(
                         array=angle_corr_array,
                         beam=beam,
                     )
                     self.write_beam_offset(offset=beam_offset, beam=beam)
 
-                with self.apm_processing_step(f"Removing offset for {beam = }"):
+                with self.telemetry_span(f"Removing offset for {beam = }"):
                     self.remove_beam_offset(
                         array=angle_corr_array,
                         offset=beam_offset,
                         beam=beam,
                     )
 
-                with self.apm_processing_step(f"Computing spectral shifts for {beam = }"):
+                with self.telemetry_span(f"Computing spectral shifts for {beam = }"):
                     spec_shifts = self.compute_spectral_shifts(beam=beam)
 
-                with self.apm_writing_step(f"Writing spectral shifts for {beam = }"):
+                with self.telemetry_span(f"Writing spectral shifts for {beam = }"):
                     self.write_spectral_shifts(shifts=spec_shifts, beam=beam)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_geo_frames: int = self.scratch.count_all(
                 tags=[
                     CryonirspTag.linearized_frame(),

dkist_processing_cryonirsp/tasks/sp_solar_gain.py

@@ -60,29 +60,31 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         """
         target_exposure_conditions = self.constants.solar_gain_exposure_conditions_list
 
-        with self.apm_step(f"Computing SP gain calibrations for {target_exposure_conditions=}"):
+        with self.telemetry_span(
+            f"Computing SP gain calibrations for {target_exposure_conditions=}"
+        ):
             for exposure_conditions in target_exposure_conditions:
                 for beam in range(1, self.constants.num_beams + 1):
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Perform initial corrections for {beam = } and {exposure_conditions = }"
                     ):
                         spectral_corrected_solar_array = self.do_initial_corrections(
                             beam=beam, exposure_conditions=exposure_conditions
                         )
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Compute the characteristic spectrum for {beam = } and {exposure_conditions = }"
                     ):
                         char_spectrum = self.compute_char_spectrum(
                             array=spectral_corrected_solar_array, beam=beam
                         )
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Re-apply the spectral and geometric distortions for {beam = } and {exposure_conditions = }"
                     ):
                         distorted_char_spectrum = self.distort_char_spectrum(char_spectrum)
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Remove the solar spectrum for {beam = } and {exposure_conditions = }"
                     ):
                         # This is the final gain image, as we do not normalize
@@ -93,7 +95,7 @@ class SPSolarGainCalibration(CryonirspTaskBase):
                         )
 
                     if self.parameters.fringe_correction_on:
-                        with self.apm_processing_step(
+                        with self.telemetry_span(
                             f"Computing final solar gain based on fringe-corrected flux-scaled lamp gain for {beam = } and {exposure_conditions = }"
                         ):
                             # Compute a solar gain based on a fringe-corrected lamp gain
@@ -101,7 +103,7 @@ class SPSolarGainCalibration(CryonirspTaskBase):
                                 beam, exposure_conditions
                             )
 
-                    with self.apm_writing_step(
+                    with self.telemetry_span(
                         f"Writing the final solar gain array for {beam = } and {exposure_conditions = }"
                     ):
                         self.write_solar_gain_calibration(
@@ -109,7 +111,7 @@ class SPSolarGainCalibration(CryonirspTaskBase):
                             beam=beam,
                         )
 
-            with self.apm_processing_step("Computing and logging quality metrics"):
+            with self.telemetry_span("Computing and logging quality metrics"):
                 no_of_raw_solar_frames: int = self.scratch.count_all(
                     tags=[
                         CryonirspTag.linearized_frame(),
@@ -449,18 +451,18 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         """
         apm_str = f"{beam = } and {exposure_conditions = }"
 
-        with self.apm_processing_step(f"Perform initial corrections for {apm_str}"):
+        with self.telemetry_span(f"Perform initial corrections for {apm_str}"):
             corrected_solar_array = self.do_dark_and_bad_pixel_corrections(
                 beam=beam, exposure_conditions=exposure_conditions
             )
 
-        with self.apm_processing_step(f"Compute the flux-scaled lamp gain for {apm_str}"):
+        with self.telemetry_span(f"Compute the flux-scaled lamp gain for {apm_str}"):
             scaled_lamp_array = self.compute_flux_scaled_lamp_gain(corrected_solar_array, beam)
 
-        with self.apm_processing_step(f"Apply spectral filtering for {apm_str}"):
+        with self.telemetry_span(f"Apply spectral filtering for {apm_str}"):
             filtered_lamp_array = self.apply_spectral_and_spatial_filtering(scaled_lamp_array)
 
-        with self.apm_processing_step(f"Isolate and remove fringes for {apm_str}"):
+        with self.telemetry_span(f"Isolate and remove fringes for {apm_str}"):
             final_gain_array = self.isolate_and_remove_fringes(
                 filtered_lamp_array, scaled_lamp_array
             )

dkist_processing_cryonirsp/tasks/sp_wavelength_calibration.py

@@ -62,7 +62,7 @@ class SPWavelengthCalibration(CryonirspTaskBase):
         -------
         None
         """
-        with self.apm_processing_step("Load input spectrum and wavelength"):
+        with self.telemetry_span("Load input spectrum and wavelength"):
             logger.info("Loading input spectrum")
             input_spectrum = next(
                 self.read(
@@ -99,7 +99,7 @@ class SPWavelengthCalibration(CryonirspTaskBase):
         resolving_power = self.get_resolving_power()
         logger.info(f"{resolving_power = }")
 
-        with self.apm_processing_step("Compute brute-force CRVAL initial guess"):
+        with self.telemetry_span("Compute brute-force CRVAL initial guess"):
             atlas = Atlas(config=self.parameters.wavecal_atlas_download_config)
             crval = calculate_initial_crval_guess(
                 input_wavelength_vector=input_wavelength_vector,
@@ -111,7 +111,7 @@ class SPWavelengthCalibration(CryonirspTaskBase):
             )
             logger.info(f"{crval = !s}")
 
-        with self.apm_task_step("Set up wavelength fit"):
+        with self.telemetry_span("Set up wavelength fit"):
             logger.info("Setting bounds")
             bounds = BoundsModel(
                 crval=LengthBoundRange(min=crval - (5 * u.nm), max=crval + (5 * u.nm)),
@@ -158,14 +158,14 @@ class SPWavelengthCalibration(CryonirspTaskBase):
 
             logger.info(f"Input parameters: {input_parameters.lmfit_parameters.pretty_repr()}")
 
-        with self.apm_processing_step("Run wavelength solution fit"):
+        with self.telemetry_span("Run wavelength solution fit"):
             fit_result = fitter(
                 input_wavelength_vector=input_wavelength_vector,
                 input_spectrum=input_spectrum,
                 spectral_weights=weights,
             )
 
-        with self.apm_writing_step("Save wavelength solution and quality metrics"):
+        with self.telemetry_span("Save wavelength solution and quality metrics"):
             self.write(
                 data=fit_result.wavelength_parameters.to_header(
                     axis_num=1, add_alternate_keys=True