dkist-processing-cryonirsp 1.4.14__py3-none-any.whl → 1.4.16rc1__py3-none-any.whl

dkist_processing_cryonirsp/tasks/gain.py

@@ -1,15 +1,20 @@
 """Cryo gain task."""
 from abc import abstractmethod
-from typing import Callable
 
 import numpy as np
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_math.arithmetic import subtract_array_from_arrays
 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.exposure_conditions import ExposureConditions
 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__ = ["LampGainCalibration", "CISolarGainCalibration"]
@@ -44,8 +49,8 @@ class GainCalibrationBase(CryonirspTaskBase):
 
     @property
     @abstractmethod
-    def gain_array_generator(self) -> Callable:
-        """Return the gain array generator to use based on the gain type."""
+    def gain_tag(self) -> CryonirspTag:
+        """Return the tag to use based on the gain type."""
         pass
 
     @property
@@ -78,13 +83,29 @@ class GainCalibrationBase(CryonirspTaskBase):
         with self.apm_task_step(
             f"Generate {self.gain_type} for {len(target_exposure_conditions)} exposure times"
         ):
-            for exposure_conditions in target_exposure_conditions:
+            for beam in range(1, self.constants.num_beams + 1):
                 # NB: By using num_beams = 1 for CI, this method works for both CI and SP
-                for beam in range(1, self.constants.num_beams + 1):
+                beam_array = next(
+                    self.read(
+                        tags=CryonirspTag.intermediate_beam_boundaries(beam=beam),
+                        decoder=cryo_fits_array_decoder,
+                    )
+                )
+                beam_boundary = BeamBoundary(*beam_array)
+
+                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}"):
-                        dark_array = self.intermediate_frame_load_dark_array(
-                            beam=beam, exposure_conditions=exposure_conditions
+                        dark_array = next(
+                            self.read(
+                                tags=[
+                                    CryonirspTag.intermediate_frame(
+                                        beam=beam, exposure_conditions=exposure_conditions
+                                    ),
+                                    CryonirspTag.task_dark(),
+                                ],
+                                decoder=cryo_fits_array_decoder,
+                            )
                         )
 
                         avg_gain_array = self.compute_average_gain_array(
@@ -96,7 +117,16 @@ class GainCalibrationBase(CryonirspTaskBase):
                         )
 
                     with self.apm_processing_step(f"Correct bad pixels for {apm_str}"):
-                        bad_pixel_map = self.intermediate_frame_load_bad_pixel_map(beam=beam)
+                        bad_pixel_map = next(
+                            self.read(
+                                tags=[
+                                    CryonirspTag.intermediate_frame(),
+                                    CryonirspTag.task_bad_pixel_map(),
+                                ],
+                                decoder=cryo_fits_array_decoder,
+                                beam_boundary=beam_boundary,
+                            )
+                        )
                         bad_pixel_corrected_array = self.corrections_correct_bad_pixels(
                             dark_corrected_gain_array, bad_pixel_map
                         )
@@ -110,17 +140,21 @@ class GainCalibrationBase(CryonirspTaskBase):
                     with self.apm_writing_step(
                         f"Writing gain array for {beam = } and {exposure_conditions = }"
                     ):
-                        self.intermediate_frame_write_arrays(
-                            normalized_gain_array,
-                            beam=beam,
-                            task=self.gain_type,
+                        self.write(
+                            data=normalized_gain_array,
+                            tags=[
+                                CryonirspTag.intermediate_frame(
+                                    beam=beam,
+                                ),
+                                CryonirspTag.task(self.gain_type),
+                            ],
+                            encoder=fits_array_encoder,
                         )
 
         with self.apm_processing_step("Computing and logging quality metrics"):
             no_of_raw_gain_frames: int = self.scratch.count_all(
                 tags=[
-                    CryonirspTag.linearized(),
-                    CryonirspTag.frame(),
+                    CryonirspTag.linearized_frame(),
                     CryonirspTag.task(self.gain_type),
                 ],
             )
@@ -149,8 +183,21 @@ class GainCalibrationBase(CryonirspTaskBase):
         -------
         np.ndarray
         """
-        linearized_gain_arrays = self.gain_array_generator(
-            beam=beam, exposure_conditions=exposure_conditions
+        beam_array = next(
+            self.read(
+                tags=CryonirspTag.intermediate_beam_boundaries(beam=beam),
+                decoder=cryo_fits_array_decoder,
+            )
+        )
+        beam_boundary = BeamBoundary(*beam_array)
+        tags = CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions) + [
+            self.gain_tag
+        ]
+        linearized_gain_arrays = self.read(
+            tags=tags,
+            decoder=cryo_fits_array_decoder,
+            fits_access_class=CryonirspLinearizedFitsAccess,
+            beam_boundary=beam_boundary,
         )
         averaged_gain_data = average_numpy_arrays(linearized_gain_arrays)
         return averaged_gain_data
@@ -205,9 +252,9 @@ class LampGainCalibration(GainCalibrationBase):
         return self.constants.lamp_gain_exposure_conditions_list
 
     @property
-    def gain_array_generator(self) -> Callable:
-        """Return the gain array generator to use based on the gain type."""
-        return self.linearized_frame_lamp_gain_array_generator
+    def gain_tag(self) -> CryonirspTag:
+        """Return the tag to use based on the gain type."""
+        return CryonirspTag.task(self.gain_type)
 
     @property
     def normalize_gain_switch(self) -> True:
@@ -241,9 +288,9 @@ class CISolarGainCalibration(GainCalibrationBase):
         return self.constants.solar_gain_exposure_conditions_list
 
     @property
-    def gain_array_generator(self) -> Callable:
-        """Return the gain array generator to use based on the gain type."""
-        return self.linearized_frame_solar_gain_array_generator
+    def gain_tag(self) -> CryonirspTag:
+        """Return the tag to use based on the gain type."""
+        return CryonirspTag.task(self.gain_type)
 
     @property
     def normalize_gain_switch(self) -> False:

dkist_processing_cryonirsp/tasks/instrument_polarization.py

@@ -5,6 +5,7 @@ from collections import defaultdict
 
 import numpy as np
 from astropy.io import fits
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_math.arithmetic import divide_arrays_by_array
 from dkist_processing_math.arithmetic import subtract_array_from_arrays
@@ -15,9 +16,15 @@ from dkist_processing_pac.input_data.drawer import Drawer
 from dkist_processing_pac.input_data.dresser import Dresser
 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.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
+    CryonirspLinearizedFitsAccess,
+)
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 
 __all__ = ["CIInstrumentPolarizationCalibration", "SPInstrumentPolarizationCalibration"]
@@ -106,10 +113,13 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                 )
 
             with self.apm_writing_step(f"Writing demodulation matrices for {beam = }"):
-                self.intermediate_frame_write_arrays(
-                    demod_matrices,
-                    beam=beam,
-                    task_tag=CryonirspTag.task_demodulation_matrices(),
+                self.write(
+                    data=demod_matrices,
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_demodulation_matrices(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
             with self.apm_processing_step("Computing and recording polcal quality metrics"):
@@ -118,8 +128,7 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
         with self.apm_processing_step("Computing and logging quality metrics"):
             no_of_raw_polcal_frames: int = self.scratch.count_all(
                 tags=[
-                    CryonirspTag.linearized(),
-                    CryonirspTag.frame(),
+                    CryonirspTag.linearized_frame(),
                     CryonirspTag.task_polcal(),
                 ],
             )
@@ -151,9 +160,16 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
             for exposure_conditions in self.constants.polcal_exposure_conditions_list:
                 logger.info(f"Loading dark array for {exposure_conditions = } and {beam = }")
                 try:
-                    dark_array = self.intermediate_frame_load_polcal_dark_array(
-                        exposure_conditions=exposure_conditions,
-                        beam=beam,
+                    dark_array = next(
+                        self.read(
+                            tags=[
+                                CryonirspTag.intermediate_frame(
+                                    beam=beam, exposure_conditions=exposure_conditions
+                                ),
+                                CryonirspTag.task_polcal_dark(),
+                            ],
+                            decoder=cryo_fits_array_decoder,
+                        )
                     )
                 except StopIteration as e:
                     raise ValueError(
@@ -162,8 +178,16 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
 
                 logger.info(f"Loading gain array for {exposure_conditions = } and {beam = }")
                 try:
-                    gain_array = self.intermediate_frame_load_polcal_gain_array(
-                        exposure_conditions=exposure_conditions, beam=beam
+                    gain_array = next(
+                        self.read(
+                            tags=[
+                                CryonirspTag.intermediate_frame(
+                                    beam=beam, exposure_conditions=exposure_conditions
+                                ),
+                                CryonirspTag.task_polcal_gain(),
+                            ],
+                            decoder=cryo_fits_array_decoder,
+                        )
                     )
                 except StopIteration as e:
                     raise ValueError(
@@ -218,25 +242,31 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
         apm_str = f"{beam = }, {modstate = }, {cs_step = }, and {exposure_conditions = }"
         logger.info(f"Reducing {apm_str}")
 
-        pol_cal_headers = (
-            obj.header
-            for obj in self.linearized_frame_polcal_fits_access_generator(
-                modstate=modstate,
-                cs_step=cs_step,
-                exposure_conditions=exposure_conditions,
-                beam=beam,
+        beam_array = next(
+            self.read(
+                tags=CryonirspTag.intermediate_beam_boundaries(beam=beam),
+                decoder=cryo_fits_array_decoder,
             )
         )
-        pol_cal_arrays = (
-            obj.data
-            for obj in self.linearized_frame_polcal_fits_access_generator(
-                modstate=modstate,
-                cs_step=cs_step,
-                exposure_conditions=exposure_conditions,
-                beam=beam,
+        beam_boundary = BeamBoundary(*beam_array)
+        polcal_tags = [
+            CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
+            CryonirspTag.cs_step(cs_step),
+            CryonirspTag.modstate(modstate),
+            CryonirspTag.task_polcal(),
+        ]
+        polcal_list = list(
+            self.read(
+                tags=polcal_tags,
+                decoder=cryo_fits_access_decoder,
+                fits_access_class=CryonirspLinearizedFitsAccess,
+                beam_boundary=beam_boundary,
             )
         )
 
+        pol_cal_headers = (obj.header for obj in polcal_list)
+        pol_cal_arrays = (obj.data for obj in polcal_list)
+
         avg_inst_pol_cal_header = next(pol_cal_headers)
         avg_inst_pol_cal_array = average_numpy_arrays(pol_cal_arrays)
 
@@ -321,24 +351,42 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
         with self.apm_task_step(
             f"Calculating dark frames for {len(target_exposure_conditions_list)} exp times"
         ):
-            for exposure_conditions in target_exposure_conditions_list:
-                for beam in range(1, self.constants.num_beams + 1):
+            for beam in range(1, self.constants.num_beams + 1):
+                beam_array = next(
+                    self.read(
+                        tags=CryonirspTag.intermediate_beam_boundaries(beam=beam),
+                        decoder=cryo_fits_array_decoder,
+                    )
+                )
+                beam_boundary = BeamBoundary(*beam_array)
+                for exposure_conditions in target_exposure_conditions_list:
                     with self.apm_processing_step(
                         f"Calculating polcal dark array(s) for {exposure_conditions = } and {beam = }"
                     ):
-                        linearized_dark_arrays = self.linearized_frame_polcal_dark_array_generator(
-                            exposure_conditions=exposure_conditions,
-                            beam=beam,
+                        linearized_dark_arrays = self.read(
+                            tags=[
+                                CryonirspTag.linearized_frame(
+                                    exposure_conditions=exposure_conditions
+                                ),
+                                CryonirspTag.task_polcal_dark(),
+                            ],
+                            decoder=cryo_fits_array_decoder,
+                            fits_access_class=CryonirspLinearizedFitsAccess,
+                            beam_boundary=beam_boundary,
                         )
                         averaged_dark_array = average_numpy_arrays(linearized_dark_arrays)
                         with self.apm_writing_step(
                             f"Writing dark for {exposure_conditions = } and {beam = }"
                         ):
-                            self.intermediate_frame_write_arrays(
-                                averaged_dark_array,
-                                task_tag=CryonirspTag.task_polcal_dark(),
-                                exposure_conditions=exposure_conditions,
-                                beam=beam,
+                            self.write(
+                                data=averaged_dark_array,
+                                tags=[
+                                    CryonirspTag.intermediate_frame(
+                                        beam=beam, exposure_conditions=exposure_conditions
+                                    ),
+                                    CryonirspTag.task_polcal_dark(),
+                                ],
+                                encoder=fits_array_encoder,
                             )
 
     def generate_polcal_gain_calibration(self, exposure_conditions_list: [ExposureConditions]):
@@ -346,15 +394,29 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
         with self.apm_task_step(
             f"Generate gains for {len(exposure_conditions_list)} exposure conditions"
         ):
-            for exposure_conditions in exposure_conditions_list:
-                for beam in range(1, self.constants.num_beams + 1):
+            for beam in range(1, self.constants.num_beams + 1):
+                beam_array = next(
+                    self.read(
+                        tags=CryonirspTag.intermediate_beam_boundaries(beam=beam),
+                        decoder=cryo_fits_array_decoder,
+                    )
+                )
+                beam_boundary = BeamBoundary(*beam_array)
+                for exposure_conditions in exposure_conditions_list:
                     logger.info(
                         f"Load polcal dark array for {exposure_conditions = } and {beam = }"
                     )
                     try:
-                        dark_array = self.intermediate_frame_load_polcal_dark_array(
-                            exposure_conditions=exposure_conditions,
-                            beam=beam,
+                        dark_array = next(
+                            self.read(
+                                tags=[
+                                    CryonirspTag.intermediate_frame(
+                                        beam=beam, exposure_conditions=exposure_conditions
+                                    ),
+                                    CryonirspTag.task_polcal_dark(),
+                                ],
+                                decoder=cryo_fits_array_decoder,
+                            )
                         )
                     except StopIteration as e:
                         raise ValueError(
@@ -363,16 +425,32 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                     with self.apm_processing_step(
                         f"Calculating polcal gain array(s) for {exposure_conditions = } and {beam = }"
                     ):
-                        linearized_gain_arrays = self.linearized_frame_polcal_gain_array_generator(
-                            exposure_conditions=exposure_conditions,
-                            beam=beam,
+                        linearized_gain_arrays = self.read(
+                            tags=[
+                                CryonirspTag.linearized_frame(
+                                    exposure_conditions=exposure_conditions
+                                ),
+                                CryonirspTag.task_polcal_gain(),
+                            ],
+                            decoder=cryo_fits_array_decoder,
+                            fits_access_class=CryonirspLinearizedFitsAccess,
+                            beam_boundary=beam_boundary,
                         )
                         averaged_gain_array = average_numpy_arrays(linearized_gain_arrays)
                         dark_corrected_gain_array = next(
                             subtract_array_from_arrays(averaged_gain_array, dark_array)
                         )
 
-                        bad_pixel_map = self.intermediate_frame_load_bad_pixel_map(beam=beam)
+                        bad_pixel_map = next(
+                            self.read(
+                                tags=[
+                                    CryonirspTag.intermediate_frame(),
+                                    CryonirspTag.task_bad_pixel_map(),
+                                ],
+                                decoder=cryo_fits_array_decoder,
+                                beam_boundary=beam_boundary,
+                            )
+                        )
                         bad_pixel_corrected_array = self.corrections_correct_bad_pixels(
                             dark_corrected_gain_array, bad_pixel_map
                         )
@@ -384,11 +462,15 @@ class InstrumentPolarizationCalibrationBase(CryonirspTaskBase, ABC):
                     with self.apm_writing_step(
                         f"Writing gain array for exposure time {exposure_conditions} and {beam = }"
                     ):
-                        self.intermediate_frame_write_arrays(
-                            normalized_gain_array,
-                            task_tag=CryonirspTag.task_polcal_gain(),
-                            exposure_conditions=exposure_conditions,
-                            beam=beam,
+                        self.write(
+                            data=normalized_gain_array,
+                            tags=[
+                                CryonirspTag.intermediate_frame(
+                                    beam=beam, exposure_conditions=exposure_conditions
+                                ),
+                                CryonirspTag.task_polcal_gain(),
+                            ],
+                            encoder=fits_array_encoder,
                         )
 
 

dkist_processing_cryonirsp/tasks/l1_output_data.py

@@ -1,7 +1,6 @@
 """Subclasses of AssembleQualityData that cause the correct polcal metrics to build."""
 from typing import Type
 
-from dkist_processing_common.models.constants import ConstantsBase
 from dkist_processing_common.tasks import AssembleQualityData
 
 __all__ = ["CIAssembleQualityData", "SPAssembleQualityData"]

dkist_processing_cryonirsp/tasks/linearity_correction.py

@@ -3,14 +3,12 @@ from dataclasses import dataclass
 from typing import Generator
 
 import numpy as np
-from astropy.io import fits
-from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.fits import fits_array_encoder
-from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_service_configuration.logging import logger
 from numba import njit
 from numba import prange
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_access_decoder
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspRampFitsAccess
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
@@ -73,8 +71,7 @@ class LinearityCorrection(CryonirspTaskBase):
             )
             # Set the tags for the linearized output frame
             tags = [
-                CryonirspTag.linearized(),
-                CryonirspTag.frame(),
+                CryonirspTag.linearized_frame(),
                 CryonirspTag.time_obs(time_obs),
             ]
             # The last frame in the ramp is used for the header
@@ -113,7 +110,7 @@ class LinearityCorrection(CryonirspTaskBase):
                         CryonirspTag.frame(),
                         CryonirspTag.time_obs(time_obs),
                     ],
-                    decoder=fits_access_decoder,
+                    decoder=cryo_fits_access_decoder,
                     fits_access_class=CryonirspRampFitsAccess,
                 )
             )
@@ -186,7 +183,7 @@ class LinearityCorrection(CryonirspTaskBase):
         fits_obj_list = list(
             self.read(
                 tags=tags,
-                decoder=fits_access_decoder,
+                decoder=cryo_fits_access_decoder,
                 fits_access_class=CryonirspRampFitsAccess,
             )
         )

dkist_processing_cryonirsp/tasks/make_movie_frames.py

@@ -5,10 +5,10 @@ from abc import abstractmethod
 import numpy as np
 from astropy.io import fits
 from astropy.visualization import ZScaleInterval
-from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_service_configuration.logging import logger
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_access_decoder
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l1_fits_access import CryonirspL1FitsAccess
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
@@ -73,7 +73,7 @@ class MakeCryonirspMovieFramesBase(CryonirspTaskBase, ABC):
                     CryonirspTag.map_scan(map_scan),
                     CryonirspTag.scan_step(scan_step),
                 ],
-                decoder=fits_access_decoder,
+                decoder=cryo_fits_access_decoder,
                 fits_access_class=CryonirspL1FitsAccess,
             )
         )
@@ -157,7 +157,7 @@ class MakeCryonirspMovieFrames(MakeCryonirspMovieFramesBase):
                     CryonirspTag.map_scan(map_scan),
                     CryonirspTag.scan_step(scan_step),
                 ],
-                decoder=fits_access_decoder,
+                decoder=cryo_fits_access_decoder,
                 fits_access_class=CryonirspL1FitsAccess,
             )
         )
@@ -260,7 +260,7 @@ class SPMakeCryonirspMovieFrames(MakeCryonirspMovieFramesBase):
                     CryonirspTag.map_scan(map_scan),
                     CryonirspTag.scan_step(scan_step),
                 ],
-                decoder=fits_access_decoder,
+                decoder=cryo_fits_access_decoder,
                 fits_access_class=CryonirspL1FitsAccess,
             )
         )
@@ -286,7 +286,7 @@ class SPMakeCryonirspMovieFrames(MakeCryonirspMovieFramesBase):
                         CryonirspTag.map_scan(map_scan),
                         CryonirspTag.scan_step(scan_step),
                     ],
-                    decoder=fits_access_decoder,
+                    decoder=cryo_fits_access_decoder,
                     fits_access_class=CryonirspL1FitsAccess,
                 )
             )

dkist_processing_cryonirsp/tasks/quality_metrics.py

@@ -6,12 +6,12 @@ from typing import Iterable
 
 import numpy as np
 from astropy.time import Time
-from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.parsers.quality import L1QualityFitsAccess
 from dkist_processing_common.tasks import QualityL0Metrics
 from dkist_processing_common.tasks.mixin.quality import QualityMixin
 from dkist_service_configuration.logging import logger
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_access_decoder
 from dkist_processing_cryonirsp.models.constants import CryonirspConstants
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
@@ -212,7 +212,7 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
                         CryonirspTag.stokes(stokes_state),
                         CryonirspTag.meas_num(meas_num),
                     ],
-                    decoder=fits_access_decoder,
+                    decoder=cryo_fits_access_decoder,
                     fits_access_class=L1QualityFitsAccess,
                 )
             )
@@ -241,7 +241,7 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
                     CryonirspTag.stokes("I"),
                     CryonirspTag.meas_num(meas_num),
                 ],
-                decoder=fits_access_decoder,
+                decoder=cryo_fits_access_decoder,
                 fits_access_class=L1QualityFitsAccess,
             )
         )
@@ -258,7 +258,7 @@ class CryonirspL1QualityMetrics(CryonirspTaskBase, QualityMixin):
         tags = [CryonirspTag.calibrated(), CryonirspTag.frame(), CryonirspTag.stokes(stokes)]
         frames: Generator[L1QualityFitsAccess, None, None] = self.read(
             tags=tags,
-            decoder=fits_access_decoder,
+            decoder=cryo_fits_access_decoder,
             fits_access_class=L1QualityFitsAccess,
         )
         result = _QualityData()

dkist_processing_cryonirsp/tasks/science_base.py

@@ -16,9 +16,15 @@ from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_processing_pac.optics.telescope import Telescope
 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.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
+    CryonirspLinearizedFitsAccess,
+)
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 
 
@@ -76,8 +82,7 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         with self.apm_processing_step("Computing and logging quality metrics"):
             no_of_raw_science_frames: int = self.scratch.count_all(
                 tags=[
-                    CryonirspTag.linearized(),
-                    CryonirspTag.frame(),
+                    CryonirspTag.linearized_frame(),
                     CryonirspTag.task_observe(),
                 ],
             )
@@ -143,14 +148,27 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         gain_array = calibrations.solar_gain[CryonirspTag.beam(beam)]
 
         # Grab the input observe frame(s)
+        beam_array = next(
+            self.read(
+                tags=CryonirspTag.intermediate_beam_boundaries(beam=beam),
+                decoder=cryo_fits_array_decoder,
+            )
+        )
+        beam_boundary = BeamBoundary(*beam_array)
+        observe_object_tags = [
+            CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
+            CryonirspTag.map_scan(map_scan),
+            CryonirspTag.scan_step(scan_step),
+            CryonirspTag.meas_num(meas_num),
+            CryonirspTag.modstate(modstate),
+            CryonirspTag.task_observe(),
+        ]
         observe_object_list = list(
-            self.linearized_frame_observe_fits_access_generator(
-                beam=beam,
-                map_scan=map_scan,
-                scan_step=scan_step,
-                meas_num=meas_num,
-                modstate=modstate,
-                exposure_conditions=exposure_conditions,
+            self.read(
+                tags=observe_object_tags,
+                decoder=cryo_fits_access_decoder,
+                fits_access_class=CryonirspLinearizedFitsAccess,
+                beam_boundary=beam_boundary,
             )
         )
         # There can be more than 1 frame if there are sub-repeats
@@ -170,7 +188,13 @@ class ScienceCalibrationBase(CryonirspTaskBase, ABC):
         dark_corrected_array = next(subtract_array_from_arrays(avg_observe_array, dark_array))
 
         # Bad pixel correction
-        bad_pixel_map = self.intermediate_frame_load_bad_pixel_map(beam=beam)
+        bad_pixel_map = next(
+            self.read(
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                decoder=cryo_fits_array_decoder,
+                beam_boundary=beam_boundary,
+            )
+        )
         bad_pixel_corrected_array = self.corrections_correct_bad_pixels(
             dark_corrected_array, bad_pixel_map
         )