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

dkist_processing_cryonirsp/tasks/sp_beam_boundaries.py

@@ -4,8 +4,8 @@ import math
 import numpy as np
 from dkist_service_configuration.logging import logger
 
+from dkist_processing_cryonirsp.models.beam_boundaries import BeamBoundary
 from dkist_processing_cryonirsp.tasks.beam_boundaries_base import BeamBoundariesCalibrationBase
-from dkist_processing_cryonirsp.tasks.beam_boundaries_base import BeamBoundary
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import ShiftMeasurementsMixin
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import SPATIAL
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import SPECTRAL

dkist_processing_cryonirsp/tasks/sp_dispersion_axis_correction.py

@@ -17,7 +17,10 @@ from scipy.optimize import differential_evolution
 from scipy.optimize import OptimizeResult
 from sunpy.coordinates import HeliocentricInertial
 
+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.tags import CryonirspTag
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 
 __all__ = ["SPDispersionAxisCorrection"]
@@ -126,8 +129,9 @@ class SPDispersionAxisCorrection(CryonirspTaskBase, InputDatasetMixin):
         """Load intermediate 1d characteristic measured_spectra for beam 1."""
         # Only fitting with the left beam.
         beam = 1
-        array_generator = self.intermediate_frame_load_intermediate_arrays(
-            tags=[CryonirspTag.task("SOLAR_CHAR_SPEC"), CryonirspTag.beam(beam)]
+        array_generator = self.read(
+            tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task("SOLAR_CHAR_SPEC")],
+            decoder=cryo_fits_array_decoder,
         )
 
         return next(array_generator)
@@ -136,11 +140,15 @@ class SPDispersionAxisCorrection(CryonirspTaskBase, InputDatasetMixin):
         """Grab a header from a random solar gain frame to be used to find a rough initial wavelength estimate."""
         # Only fitting with the left beam.
         beam = 1
-        solar_header = next(
-            self.linearized_frame_fits_access_generator(
-                tags=[CryonirspTag.task("SOLAR_GAIN")], beam=beam
+        solar_tags = [CryonirspTag.linearized_frame(), CryonirspTag.task("SOLAR_GAIN")]
+        solar_obj = next(
+            self.read(
+                tags=solar_tags,
+                decoder=cryo_fits_access_decoder,
+                fits_access_class=CryonirspL0FitsAccess,
             )
-        ).header
+        )
+        solar_header = solar_obj.header
         return solar_header
 
     def get_theoretical_dispersion(self) -> tuple[u.Quantity, int, float]:

dkist_processing_cryonirsp/tasks/sp_geometric.py

@@ -4,6 +4,7 @@ import math
 import numpy as np
 import peakutils as pku
 import scipy.ndimage as spnd
+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
@@ -11,7 +12,12 @@ from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
 from scipy.optimize import minimize
 
+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.tags import CryonirspTag
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
+    CryonirspLinearizedFitsAccess,
+)
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import ShiftMeasurementsMixin
 from dkist_processing_cryonirsp.tasks.mixin.shift_measurements import SPATIAL
@@ -99,8 +105,7 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         with self.apm_processing_step("Computing and logging quality metrics"):
             no_of_raw_geo_frames: int = self.scratch.count_all(
                 tags=[
-                    CryonirspTag.linearized(),
-                    CryonirspTag.frame(),
+                    CryonirspTag.linearized_frame(),
                     CryonirspTag.task_solar_gain(),
                 ],
             )
@@ -123,8 +128,12 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         np.ndarray
             Dark corrected data array
         """
-        array_generator = self.intermediate_frame_load_intermediate_arrays(
-            tags=[CryonirspTag.task("GC_BASIC_GAIN_CORRECTED"), CryonirspTag.beam(beam)]
+        array_generator = self.read(
+            tags=[
+                CryonirspTag.intermediate_frame(beam=beam),
+                CryonirspTag.task("GC_BASIC_GAIN_CORRECTED"),
+            ],
+            decoder=cryo_fits_array_decoder,
         )
         return average_numpy_arrays(array_generator)
 
@@ -142,8 +151,12 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         np.ndarray
             Dark and bad pixel corrected data array
         """
-        array_generator = self.intermediate_frame_load_intermediate_arrays(
-            tags=[CryonirspTag.task("GC_BASIC_DARK_BP_CORRECTED"), CryonirspTag.beam(beam)]
+        array_generator = self.read(
+            tags=[
+                CryonirspTag.intermediate_frame(beam=beam),
+                CryonirspTag.task("GC_BASIC_DARK_BP_CORRECTED"),
+            ],
+            decoder=cryo_fits_array_decoder,
         )
         return average_numpy_arrays(array_generator)
 
@@ -161,8 +174,9 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         np.ndarray
             Offset corrected data array
         """
-        array_generator = self.intermediate_frame_load_intermediate_arrays(
-            tags=[CryonirspTag.task("GC_OFFSET"), CryonirspTag.beam(beam)]
+        array_generator = self.read(
+            tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task("GC_OFFSET")],
+            decoder=cryo_fits_array_decoder,
         )
         return average_numpy_arrays(array_generator)
 
@@ -171,24 +185,50 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         # There is likely only a single exposure conditions tuple in the list, but we iterate over the list
         # in case there are multiple exposure conditions tuples. We also need a specific exposure conditions tag
         # to ensure we get the proper dark arrays to use in the correction.
-        for exposure_conditions in self.constants.solar_gain_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 self.constants.solar_gain_exposure_conditions_list:
                 logger.info(f"Starting basic reductions for {exposure_conditions = } and {beam = }")
                 try:
-                    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,
+                        )
                     )
                 except StopIteration as e:
                     raise ValueError(f"No matching dark found for {exposure_conditions = }") from e
 
-                lamp_gain_array = self.intermediate_frame_load_lamp_gain_array(
-                    beam=beam,
+                lamp_gain_array = next(
+                    self.read(
+                        tags=[
+                            CryonirspTag.intermediate_frame(beam=beam),
+                            CryonirspTag.task_lamp_gain(),
+                        ],
+                        decoder=cryo_fits_array_decoder,
+                    )
                 )
 
-                input_solar_arrays = self.linearized_frame_gain_array_generator(
-                    gain_type=TaskName.solar_gain.value,
-                    beam=beam,
-                    exposure_conditions=exposure_conditions,
+                input_solar_arrays = self.read(
+                    tags=[
+                        CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
+                        CryonirspTag.task_solar_gain(),
+                    ],
+                    decoder=cryo_fits_array_decoder,
+                    fits_access_class=CryonirspLinearizedFitsAccess,
+                    beam_boundary=beam_boundary,
                 )
 
                 avg_solar_array = average_numpy_arrays(input_solar_arrays)
@@ -197,24 +237,36 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
                     subtract_array_from_arrays(arrays=avg_solar_array, array_to_subtract=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_solar_array, bad_pixel_map
                 )
                 logger.info(f"Writing bad pixel corrected data for {beam=}")
-                self.intermediate_frame_write_arrays(
-                    arrays=bad_pixel_corrected_array,
-                    beam=beam,
-                    task="GC_BASIC_DARK_BP_CORRECTED",
+                self.write(
+                    data=bad_pixel_corrected_array,
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task("GC_BASIC_DARK_BP_CORRECTED"),
+                    ],
+                    encoder=fits_array_encoder,
                 )
                 gain_corrected_solar_array = next(
                     divide_arrays_by_array(bad_pixel_corrected_array, lamp_gain_array)
                 )
                 logger.info(f"Writing gain corrected data for {beam=}")
-                self.intermediate_frame_write_arrays(
-                    arrays=gain_corrected_solar_array,
-                    beam=beam,
-                    task="GC_BASIC_GAIN_CORRECTED",
+                self.write(
+                    data=gain_corrected_solar_array,
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task("GC_BASIC_GAIN_CORRECTED"),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
     def compute_beam_angle(self, beam: int) -> float:
@@ -239,7 +291,12 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         # Step 1
         # Do not use a gain corrected image here, as it will cancel out the slit structure
         # that is used for the shift measurement computations
-        gain_array = self.intermediate_frame_load_lamp_gain_array(beam=beam)
+        gain_array = next(
+            self.read(
+                tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task_lamp_gain()],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
 
         full_spatial_size, full_spectral_size = gain_array.shape
 
@@ -344,7 +401,11 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
 
         """
         corrected_array = next(self.corrections_correct_geometry(array, shift=offset))
-        self.intermediate_frame_write_arrays(arrays=corrected_array, beam=beam, task="GC_OFFSET")
+        self.write(
+            data=corrected_array,
+            tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task("GC_OFFSET")],
+            encoder=fits_array_encoder,
+        )
 
     def compute_spectral_shifts(self, beam: int) -> np.ndarray:
         """
@@ -404,10 +465,13 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
             logger.info(f"Mean of spectral shifts = {self.mean_shifts}")
 
         beam_shifts -= self.mean_shifts
-        self.intermediate_frame_write_arrays(
-            arrays=beam_shifts,
-            beam=beam,
-            task="GC_RAW_SPECTRAL_SHIFTS",
+        self.write(
+            data=beam_shifts,
+            tags=[
+                CryonirspTag.intermediate_frame(beam=beam),
+                CryonirspTag.task("GC_RAW_SPECTRAL_SHIFTS"),
+            ],
+            encoder=fits_array_encoder,
         )
 
         # Finally, fit the shifts and return the resulting polynomial. Any "bad" fits were set to NaN and will be
@@ -538,8 +602,10 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         None
         """
         array = np.array([angle])
-        self.intermediate_frame_write_arrays(
-            arrays=array, beam=beam, task_tag=CryonirspTag.task_geometric_angle()
+        self.write(
+            data=array,
+            tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task_geometric_angle()],
+            encoder=fits_array_encoder,
         )
 
     def write_beam_offset(self, offset: np.ndarray, beam: int) -> None:
@@ -559,8 +625,10 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         None
 
         """
-        self.intermediate_frame_write_arrays(
-            arrays=offset, beam=beam, task_tag=CryonirspTag.task_geometric_offset()
+        self.write(
+            data=offset,
+            tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task_geometric_offset()],
+            encoder=fits_array_encoder,
         )
 
     def write_spectral_shifts(self, shifts: np.ndarray, beam: int) -> None:
@@ -580,6 +648,11 @@ class SPGeometricCalibration(CryonirspTaskBase, ShiftMeasurementsMixin):
         None
 
         """
-        self.intermediate_frame_write_arrays(
-            arrays=shifts, beam=beam, task_tag=CryonirspTag.task_geometric_sepectral_shifts()
+        self.write(
+            data=shifts,
+            tags=[
+                CryonirspTag.intermediate_frame(beam=beam),
+                CryonirspTag.task_geometric_spectral_shifts(),
+            ],
+            encoder=fits_array_encoder,
         )

dkist_processing_cryonirsp/tasks/sp_science.py

@@ -6,6 +6,7 @@ from astropy.io import fits
 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.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
 from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
@@ -258,35 +259,76 @@ class SPScienceCalibration(ScienceCalibrationBase):
         for beam in range(1, self.constants.num_beams + 1):
             # Load the dark arrays
             for exposure_conditions in self.constants.observe_exposure_conditions_list:
-                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,
+                    )
                 )
                 dark_dict[CryonirspTag.beam(beam)][
                     CryonirspTag.exposure_conditions(exposure_conditions)
                 ] = dark_array
 
             # Load the gain arrays
-            solar_dict[CryonirspTag.beam(beam)] = self.intermediate_frame_load_solar_gain_array(
-                beam=beam,
+            solar_dict[CryonirspTag.beam(beam)] = next(
+                self.read(
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_solar_gain(),
+                    ],
+                    decoder=cryo_fits_array_decoder,
+                )
             )
 
             # Load the angle arrays
-            angle_dict[CryonirspTag.beam(beam)] = self.intermediate_frame_load_angle(beam=beam)
+            angle_array = next(
+                self.read(
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_geometric_angle(),
+                    ],
+                    decoder=cryo_fits_array_decoder,
+                )
+            )
+            angle_dict[CryonirspTag.beam(beam)] = float(angle_array[0])
 
             # Load the state offsets
-            state_offset_dict[CryonirspTag.beam(beam)] = self.intermediate_frame_load_state_offset(
-                beam=beam
+            state_offset_dict[CryonirspTag.beam(beam)] = next(
+                self.read(
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_geometric_offset(),
+                    ],
+                    decoder=cryo_fits_array_decoder,
+                )
             )
 
             # Load the spectral shifts
-            spec_shift_dict[CryonirspTag.beam(beam)] = self.intermediate_frame_load_spec_shift(
-                beam=beam
+            spec_shift_dict[CryonirspTag.beam(beam)] = next(
+                self.read(
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_geometric_spectral_shifts(),
+                    ],
+                    decoder=cryo_fits_array_decoder,
+                )
             )
 
             # Load the demod matrices
             if self.constants.correct_for_polarization:
-                demod_dict[CryonirspTag.beam(beam)] = self.intermediate_frame_load_demod_matrices(
-                    beam=beam
+                demod_dict[CryonirspTag.beam(beam)] = next(
+                    self.read(
+                        tags=[
+                            CryonirspTag.intermediate_frame(beam=beam),
+                            CryonirspTag.task_demodulation_matrices(),
+                        ],
+                        decoder=cryo_fits_array_decoder,
+                    )
                 )
 
         return CalibrationCollection(

dkist_processing_cryonirsp/tasks/sp_solar_gain.py

@@ -1,6 +1,7 @@
 """Cryo SP solar gain task."""
 import numpy as np
 import scipy.ndimage as spnd
+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
@@ -8,9 +9,14 @@ from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
 from scipy import signal
 
+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.models.task_name import CryonirspTaskName
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import (
+    CryonirspLinearizedFitsAccess,
+)
 from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
 
 __all__ = ["SPSolarGainCalibration"]
@@ -105,8 +111,7 @@ class SPSolarGainCalibration(CryonirspTaskBase):
             with self.apm_processing_step("Computing and logging quality metrics"):
                 no_of_raw_solar_frames: int = self.scratch.count_all(
                     tags=[
-                        CryonirspTag.linearized(),
-                        CryonirspTag.frame(),
+                        CryonirspTag.linearized_frame(),
                         CryonirspTag.task_solar_gain(),
                     ],
                 )
@@ -137,13 +142,21 @@ class SPSolarGainCalibration(CryonirspTaskBase):
             beam, exposure_conditions
         )
         # Save as intermediate result for final gain computation
-        self.intermediate_frame_write_arrays(
-            arrays=basic_corrected_solar_array,
-            beam=beam,
-            task="SC_DARK_BP_CORRECTED_ONLY",
+        self.write(
+            data=basic_corrected_solar_array,
+            tags=[
+                CryonirspTag.intermediate_frame(beam=beam),
+                CryonirspTag.task("SC_DARK_BP_CORRECTED_ONLY"),
+            ],
+            encoder=fits_array_encoder,
         )
         # Gain correct using the lamp gain. This removes internal optical effects.
-        lamp_array = self.intermediate_frame_load_lamp_gain_array(beam=beam)
+        lamp_array = next(
+            self.read(
+                tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task_lamp_gain()],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
         lamp_corrected_solar_array = next(
             divide_arrays_by_array(basic_corrected_solar_array, lamp_array)
         )
@@ -152,10 +165,13 @@ class SPSolarGainCalibration(CryonirspTaskBase):
             lamp_corrected_solar_array, beam
         )
         # Save as an intermediate result for science users
-        self.intermediate_frame_write_arrays(
-            arrays=spectral_corrected_solar_array,
-            beam=beam,
-            task=CryonirspTaskName.spectral_corrected_solar_array.value,
+        self.write(
+            data=spectral_corrected_solar_array,
+            tags=[
+                CryonirspTag.intermediate_frame(beam=beam),
+                CryonirspTag.task(CryonirspTaskName.spectral_corrected_solar_array.value),
+            ],
+            encoder=fits_array_encoder,
         )
         return spectral_corrected_solar_array
 
@@ -178,18 +194,45 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         A solar array with dark and bad pixel corrections
         """
         # Load the necessary files
-        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,
+            )
         )
         # Compute the avg solar array
-        linearized_solar_arrays = self.linearized_frame_gain_array_generator(
-            beam=beam, exposure_conditions=exposure_conditions, gain_type=TaskName.solar_gain.value
+        beam_array = next(
+            self.read(
+                tags=CryonirspTag.intermediate_beam_boundaries(beam=beam),
+                decoder=cryo_fits_array_decoder,
+            )
+        )
+        beam_boundary = BeamBoundary(*beam_array)
+        linearized_solar_arrays = self.read(
+            tags=[
+                CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
+                CryonirspTag.task_solar_gain(),
+            ],
+            decoder=cryo_fits_array_decoder,
+            fits_access_class=CryonirspLinearizedFitsAccess,
+            beam_boundary=beam_boundary,
         )
         avg_solar_array = average_numpy_arrays(linearized_solar_arrays)
         # Dark correct it
         dark_corrected_solar_array = next(subtract_array_from_arrays(avg_solar_array, dark_array))
         # Correct for bad pixels
-        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_solar_array = self.corrections_correct_bad_pixels(
             dark_corrected_solar_array, bad_pixel_map
         )
@@ -212,9 +255,34 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         An array that has geometric and spectral corrections
         """
         # Get the parameters and save them to self for use later on...
-        self.angle = self.intermediate_frame_load_angle(beam=beam)
-        self.state_offset = self.intermediate_frame_load_state_offset(beam=beam)
-        self.spec_shift = self.intermediate_frame_load_spec_shift(beam=beam)
+        angle_array = next(
+            self.read(
+                tags=[
+                    CryonirspTag.intermediate_frame(beam=beam),
+                    CryonirspTag.task_geometric_angle(),
+                ],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
+        self.angle = float(angle_array[0])
+        self.state_offset = next(
+            self.read(
+                tags=[
+                    CryonirspTag.intermediate_frame(beam=beam),
+                    CryonirspTag.task_geometric_offset(),
+                ],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
+        self.spec_shift = next(
+            self.read(
+                tags=[
+                    CryonirspTag.intermediate_frame(beam=beam),
+                    CryonirspTag.task_geometric_spectral_shifts(),
+                ],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
         # Correct for rotation and state offset. This does not correct for spectral curvature!
         geo_corrected_solar_array = next(
             self.corrections_correct_geometry(lamp_corrected_array, self.state_offset, self.angle)
@@ -245,8 +313,13 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         char_spec_1d = np.nanmedian(array_row_norm, axis=0)
         # Expand the 1D median along the columns (along the slit)
         median_char_spec_2d = np.tile(char_spec_1d, (array_row_norm.shape[0], 1))
-        self.intermediate_frame_write_arrays(
-            arrays=char_spec_1d, task_tag=CryonirspTag.task_characteristic_spectra(), beam=beam
+        self.write(
+            data=char_spec_1d,
+            tags=[
+                CryonirspTag.intermediate_frame(beam=beam),
+                CryonirspTag.task_characteristic_spectra(),
+            ],
+            encoder=fits_array_encoder,
         )
         return median_char_spec_2d
 
@@ -294,11 +367,12 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         -------
         A dark and bad pixel corrected solar array
         """
-        array_generator = self.intermediate_frame_load_intermediate_arrays(
+        array_generator = self.read(
             tags=[
+                CryonirspTag.intermediate_frame(beam=beam),
                 CryonirspTag.task("SC_DARK_BP_CORRECTED_ONLY"),
-                CryonirspTag.beam(beam),
-            ]
+            ],
+            decoder=cryo_fits_array_decoder,
         )
         return next(array_generator)
 
@@ -350,10 +424,10 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         None
         """
         logger.info(f"Writing final SolarGain for {beam=}")
-        self.intermediate_frame_write_arrays(
-            arrays=gain_array,
-            beam=beam,
-            task_tag=CryonirspTag.task_solar_gain(),
+        self.write(
+            data=gain_array,
+            tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task_solar_gain()],
+            encoder=fits_array_encoder,
         )
 
     def compute_fringe_corrected_gain(self, beam: int, exposure_conditions: float) -> np.ndarray:
@@ -416,7 +490,12 @@ class SPSolarGainCalibration(CryonirspTaskBase):
         -------
         The scaled lamp array
         """
-        lamp_array = self.intermediate_frame_load_lamp_gain_array(beam=beam)
+        lamp_array = next(
+            self.read(
+                tags=[CryonirspTag.intermediate_frame(beam=beam), CryonirspTag.task_lamp_gain()],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
         lamp_corrected_solar_array = next(divide_arrays_by_array(corrected_solar_array, lamp_array))
         flux_ratio = np.nanmedian(lamp_corrected_solar_array, axis=1)
         scaled_lamp_array = lamp_array * flux_ratio[:, None]