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

dkist_processing_cryonirsp/tests/test_gain.py

@@ -6,6 +6,7 @@ import pytest
 from astropy.io import fits
 from dkist_header_validator import spec122_validator
 from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.tests.conftest import FakeGQLClient
 
@@ -45,24 +46,30 @@ def ci_solar_gain_calibration_task(
             param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
             assign_input_dataset_doc_to_task(task, param_class())
             # Need a beam boundary file
-            task.intermediate_frame_write_arrays(
-                arrays=np.array([0, intermediate_shape[0], 0, intermediate_shape[1]]),
-                task_tag=CryonirspTag.task_beam_boundaries(),
-                beam=1,
+            task.write(
+                data=np.array([0, intermediate_shape[0], 0, intermediate_shape[1]]),
+                tags=[CryonirspTag.intermediate_frame(beam=1), CryonirspTag.task_beam_boundaries()],
+                encoder=fits_array_encoder,
             )
             # Create fake bad pixel map
-            task.intermediate_frame_write_arrays(
-                arrays=np.zeros(array_shape[1:]), task_tag=CryonirspTag.task_bad_pixel_map()
+            task.write(
+                data=np.zeros(array_shape[1:]),
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                encoder=fits_array_encoder,
             )
             dark_signal = 3.0
             start_time = datetime.now()
             # Make intermediate dark frame
             dark_cal = np.ones(intermediate_shape) * dark_signal
-            task.intermediate_frame_write_arrays(
-                arrays=dark_cal,
-                beam=1,
-                task_tag=CryonirspTag.task_dark(),
-                exposure_conditions=exposure_conditions,
+            task.write(
+                data=dark_cal,
+                tags=[
+                    CryonirspTag.intermediate_frame(
+                        beam=1, exposure_conditions=exposure_conditions
+                    ),
+                    CryonirspTag.task_dark(),
+                ],
+                encoder=fits_array_encoder,
             )
 
             solar_signal = 6.28
@@ -82,10 +89,8 @@ def ci_solar_gain_calibration_task(
 
             hdul[0].data.fill(solar_signal + dark_signal)
             tags = [
-                CryonirspTag.linearized(),
+                CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
                 CryonirspTag.task_solar_gain(),
-                CryonirspTag.frame(),
-                CryonirspTag.exposure_conditions(exposure_conditions),
             ]
             task.write(
                 data=hdul,
@@ -124,14 +129,16 @@ def lamp_calibration_task(
             param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
             assign_input_dataset_doc_to_task(task, param_class())
             # Need a beam boundary file
-            task.intermediate_frame_write_arrays(
-                arrays=np.array([0, intermediate_shape[0], 0, intermediate_shape[1]]),
-                task_tag=CryonirspTag.task_beam_boundaries(),
-                beam=1,
+            task.write(
+                data=np.array([0, intermediate_shape[0], 0, intermediate_shape[1]]),
+                tags=[CryonirspTag.intermediate_frame(beam=1), CryonirspTag.task_beam_boundaries()],
+                encoder=fits_array_encoder,
             )
             # Create fake bad pixel map
-            task.intermediate_frame_write_arrays(
-                arrays=np.zeros(array_shape[1:]), task_tag=CryonirspTag.task_bad_pixel_map()
+            task.write(
+                data=np.zeros(array_shape[1:]),
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                encoder=fits_array_encoder,
             )
             dark_signal = 3.0
             start_time = datetime.now()
@@ -140,17 +147,25 @@ def lamp_calibration_task(
 
             # Need a dark for each beam
             for b in range(number_of_beams):
-                task.intermediate_frame_write_arrays(
-                    arrays=dark_cal,
-                    beam=b + 1,
-                    task_tag=CryonirspTag.task_dark(),
-                    exposure_conditions=exposure_conditions,
+                task.write(
+                    data=dark_cal,
+                    tags=[
+                        CryonirspTag.intermediate_frame(
+                            beam=b + 1, exposure_conditions=exposure_conditions
+                        ),
+                        CryonirspTag.task_dark(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
+
                 # Create fake beam border intermediate arrays
-                task.intermediate_frame_write_arrays(
-                    arrays=np.array([0, 10, (b * 10), 10 + (b * 10)]),
-                    task_tag=CryonirspTag.task_beam_boundaries(),
-                    beam=b + 1,
+                task.write(
+                    data=np.array([0, 10, (b * 10), 10 + (b * 10)]),
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=b + 1),
+                        CryonirspTag.task_beam_boundaries(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
                 # does this need to be in the beam loop as well?
@@ -173,10 +188,8 @@ def lamp_calibration_task(
                 hdul[0].data.fill(1.1)
                 tags = [
                     CryonirspTag.beam(b + 1),
-                    CryonirspTag.linearized(),
                     CryonirspTag.task_lamp_gain(),
-                    CryonirspTag.frame(),
-                    CryonirspTag.exposure_conditions(exposure_conditions),
+                    CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
                 ]
                 task.write(
                     data=hdul,
@@ -203,9 +216,7 @@ def test_ci_solar_gain_calibration_task(ci_solar_gain_calibration_task, mocker):
     # Then
     tags = [
         CryonirspTag.task_solar_gain(),
-        CryonirspTag.intermediate(),
-        CryonirspTag.frame(),
-        CryonirspTag.beam(1),
+        CryonirspTag.intermediate_frame(beam=1),
     ]
     files = list(task.read(tags=tags))
     num_files = len(files)

dkist_processing_cryonirsp/tests/test_instrument_polarization.py

@@ -7,6 +7,7 @@ import pytest
 from astropy.io import fits
 from dkist_header_validator import spec122_validator
 from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.tests.conftest import FakeGQLClient
@@ -87,9 +88,7 @@ def _create_polcal_dark_or_gain_array(
                 CryonirspTag.task_polcal(),
                 CryonirspTag.modstate(m),
                 CryonirspTag.cs_step(cs_step),
-                CryonirspTag.linearized(),
-                CryonirspTag.frame(),
-                CryonirspTag.exposure_conditions(exposure_conditions),
+                CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
             ],
             encoder=fits_hdulist_encoder,
         )
@@ -130,9 +129,7 @@ def _create_polcal_arrays(
                     CryonirspTag.task_polcal(),
                     CryonirspTag.modstate(modstate),
                     CryonirspTag.cs_step(cs_step),
-                    CryonirspTag.linearized(),
-                    CryonirspTag.frame(),
-                    CryonirspTag.exposure_conditions(exposure_conditions),
+                    CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
                 ],
                 encoder=fits_hdulist_encoder,
             )
@@ -189,13 +186,17 @@ def ci_instrument_polarization_calibration_task(
             )
 
             # Create beam border intermediate array that is consistent with a single pixel array
-            task.intermediate_frame_write_arrays(
-                arrays=np.array([0, 1, 0, 1]), task_tag=CryonirspTag.task_beam_boundaries(), beam=1
+            task.write(
+                data=np.array([0, 1, 0, 1]),
+                tags=[CryonirspTag.intermediate_frame(beam=1), CryonirspTag.task_beam_boundaries()],
+                encoder=fits_array_encoder,
             )
 
             # Create fake bad pixel map
-            task.intermediate_frame_write_arrays(
-                arrays=np.zeros((1, 1)), task_tag=CryonirspTag.task_bad_pixel_map()
+            task.write(
+                data=np.zeros((1, 1)),
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                encoder=fits_array_encoder,
             )
 
             start_time = datetime.now()
@@ -305,15 +306,20 @@ def sp_instrument_polarization_calibration_task(
 
             # Create beam border intermediate arrays that are consistent with a single pixel array
             for beam in range(1, num_beams + 1):
-                task.intermediate_frame_write_arrays(
-                    arrays=np.array([0, 1, 0, 1]),
-                    task_tag=CryonirspTag.task_beam_boundaries(),
-                    beam=beam,
+                task.write(
+                    data=np.array([0, 1, 0, 1]),
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_beam_boundaries(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
             # Create fake bad pixel map
-            task.intermediate_frame_write_arrays(
-                arrays=np.zeros((1, 1)), task_tag=CryonirspTag.task_bad_pixel_map()
+            task.write(
+                data=np.zeros((1, 1)),
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                encoder=fits_array_encoder,
             )
 
             start_time = datetime.now()

dkist_processing_cryonirsp/tests/test_linearity_correction.py

@@ -166,10 +166,7 @@ def test_linearity_correction(
     # When
     task()
     # Then
-    tags = [
-        CryonirspTag.linearized(),
-        CryonirspTag.frame(),
-    ]
+    tags = CryonirspTag.linearized_frame()
     # We used a perfect linear ramp from 0 to 90, where the ramp value is equal to the exposure time in ms
     # The algorithm normalizes the linearized frame by the exposure time in seconds, so the expected value is:
     # 90 / (90 / 1000) = 1000 / attenuation, where attenuation is the multiplicative attenuation due to the

dkist_processing_cryonirsp/tests/test_parse.py

@@ -1504,3 +1504,44 @@ def test_missing_lamp_gain_frames(parse_linearized_task, arm_id):
 
     with pytest.raises(ValueError, match="lamp_gain frames not found."):
         task()
+
+
+@pytest.mark.parametrize("arm_id", ["CI"])
+def test_wrong_exposure_time_lamp_gain_dark(parse_linearized_task, arm_id):
+    """
+    Given: lamp gain frames with a different exposure time than the dark frames
+    When: parsing data where the lamp gain has no matching exposure time
+    Then: everything is fine because CRYO-CI ignores lamp gains
+    """
+    task = parse_linearized_task
+    lin_tag = [CryonirspTag.linearized()]
+    solar_gain_exposure_condition = ExposureConditions(
+        10.0, AllowableOpticalDensityFilterNames.OPEN.value
+    )
+    write_solar_gain_frames_to_task(
+        task,
+        tags=lin_tag,
+        exposure_condition=solar_gain_exposure_condition,
+        num_modstates=1,
+    )
+    lamp_gain_exposure_condition = ExposureConditions(
+        1000.0, AllowableOpticalDensityFilterNames.OPEN.value
+    )
+    write_lamp_gain_frames_to_task(
+        task,
+        tags=lin_tag,
+        exposure_condition=lamp_gain_exposure_condition,
+        num_modstates=1,
+    )
+    dark_exp_condition = ExposureConditions(10.0, AllowableOpticalDensityFilterNames.OPEN.value)
+    write_dark_frames_to_task(task, exposure_condition=dark_exp_condition, tags=lin_tag)
+
+    task()
+
+    assert task.constants._db_dict["DARK_FRAME_EXPOSURE_CONDITIONS_LIST"] == [[10.0, "OPEN"]]
+    assert task.constants._db_dict["SOLAR_GAIN_EXPOSURE_CONDITIONS_LIST"] == [[10.0, "OPEN"]]
+    assert task.constants._db_dict[
+        "CI_NON_DARK_AND_NON_POLCAL_AND_NON_LAMP_GAIN_TASK_EXPOSURE_CONDITIONS_LIST"
+    ] == [[10.0, "OPEN"]]
+    with pytest.raises(KeyError):
+        assert task.constants._db_dict["LAMP_GAIN_EXPOSURE_CONDITIONS_LIST"]

dkist_processing_cryonirsp/tests/test_quality.py

@@ -69,8 +69,7 @@ def write_l0_task_frames_to_task(num_modstates, dataset_task_types):
                     data=data,
                     header=header,
                     tags=[
-                        CryonirspTag.linearized(),
-                        CryonirspTag.frame(),
+                        CryonirspTag.linearized_frame(),
                         CryonirspTag.task(task_type),
                         CryonirspTag.modstate(modstate),
                     ],

dkist_processing_cryonirsp/tests/test_sp_beam_boundaries.py

@@ -5,6 +5,7 @@ import pytest
 from astropy.io import fits
 from dkist_header_validator import spec122_validator
 from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.tests.conftest import FakeGQLClient
 
@@ -40,9 +41,10 @@ def compute_beam_boundaries_task(
             param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
             assign_input_dataset_doc_to_task(task, param_class())
             # Create fake bad pixel map
-            task.intermediate_frame_write_arrays(
-                arrays=np.zeros(array_shape[1:]),
-                task_tag=CryonirspTag.task_bad_pixel_map(),
+            task.write(
+                data=np.zeros(array_shape[1:]),
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                encoder=fits_array_encoder,
             )
             start_time = datetime.now()
             ds = CryonirspHeadersValidSPSolarGainFrames(
@@ -73,9 +75,8 @@ def compute_beam_boundaries_task(
             task.write(
                 data=hdul,
                 tags=[
-                    CryonirspTag.linearized(),
+                    CryonirspTag.linearized_frame(),
                     CryonirspTag.task_solar_gain(),
-                    CryonirspTag.frame(),
                 ],
                 encoder=fits_hdulist_encoder,
             )

dkist_processing_cryonirsp/tests/test_sp_dispersion_axis_correction.py

@@ -7,6 +7,7 @@ from astropy.io import fits
 from dkist_header_validator import spec122_validator
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.asdf import asdf_decoder
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.tests.conftest import FakeGQLClient
 
@@ -65,8 +66,7 @@ def sp_dispersion_axis_correction_task(
                 task.write(
                     data=char_spec_hdul,
                     tags=[
-                        CryonirspTag.intermediate(),
-                        CryonirspTag.frame(),
+                        CryonirspTag.intermediate_frame(beam=beam),
                         CryonirspTag.task_characteristic_spectra(),
                         CryonirspTag.beam(beam),
                     ],
@@ -74,10 +74,13 @@ def sp_dispersion_axis_correction_task(
                 )
 
                 # And a beam border intermediate array
-                task.intermediate_frame_write_arrays(
-                    arrays=np.array([0, 30, ((beam - 1) * 30), (30 + (beam - 1) * 30)]),
-                    task_tag=CryonirspTag.task_beam_boundaries(),
-                    beam=beam,
+                task.write(
+                    data=np.array([0, 30, ((beam - 1) * 30), (30 + (beam - 1) * 30)]),
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_beam_boundaries(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
                 # Create fake linearized solar gain array with headers
@@ -99,10 +102,8 @@ def sp_dispersion_axis_correction_task(
                 task.write(
                     data=hdul,
                     tags=[
-                        CryonirspTag.linearized(),
-                        CryonirspTag.frame(),
+                        CryonirspTag.linearized_frame(beam=beam),
                         CryonirspTag.task_solar_gain(),
-                        CryonirspTag.beam(beam),
                     ],
                     encoder=fits_hdulist_encoder,
                 )

dkist_processing_cryonirsp/tests/test_sp_geometric.py

@@ -3,10 +3,12 @@ import json
 import numpy as np
 import pytest
 from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.tests.conftest import FakeGQLClient
 from dkist_processing_math import transform
 
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
 from dkist_processing_cryonirsp.models.tags import CryonirspTag
@@ -59,32 +61,42 @@ def geometric_calibration_task_that_completes(
 
             # Create the intermediate frames needed
             # Create fake bad pixel map
-            task.intermediate_frame_write_arrays(
-                arrays=np.zeros(data_shape_raw),
-                task_tag=CryonirspTag.task_bad_pixel_map(),
+            task.write(
+                data=np.zeros(data_shape_raw),
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                encoder=fits_array_encoder,
             )
+
             for beam in range(1, number_of_beams + 1):
                 dark_cal = np.ones(data_shape_int) * 3.0
-                task.intermediate_frame_write_arrays(
-                    arrays=dark_cal,
-                    beam=beam,
-                    task_tag=CryonirspTag.task_dark(),
-                    exposure_conditions=exposure_conditions,
+                task.write(
+                    data=dark_cal,
+                    tags=[
+                        CryonirspTag.intermediate_frame(
+                            beam=beam, exposure_conditions=exposure_conditions
+                        ),
+                        CryonirspTag.task_dark(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
                 # Need a lamp for each beam
                 lamp_gain = np.ones(data_shape_int)
-                task.intermediate_frame_write_arrays(
-                    arrays=lamp_gain,
-                    beam=beam,
-                    task_tag=CryonirspTag.task_lamp_gain(),
-                    exposure_conditions=exposure_conditions,
+                task.write(
+                    data=lamp_gain,
+                    tags=[
+                        CryonirspTag.intermediate_frame(
+                            beam=beam, exposure_conditions=exposure_conditions
+                        ),
+                        CryonirspTag.task_lamp_gain(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
                 # And a beam border intermediate array
                 border = data_shape_raw[1] // 2
-                task.intermediate_frame_write_arrays(
-                    arrays=np.array(
+                task.write(
+                    data=np.array(
                         [
                             0,
                             data_shape_int[0],
@@ -92,8 +104,11 @@ def geometric_calibration_task_that_completes(
                             (border + (beam - 1) * border),
                         ]
                     ),
-                    task_tag=CryonirspTag.task_beam_boundaries(),
-                    beam=beam,
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_beam_boundaries(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
             # Create the raw data, which is based on two beams per frame
@@ -133,11 +148,10 @@ def geometric_calibration_task_that_completes(
             task.write(
                 data=solar_hdul,
                 tags=[
-                    CryonirspTag.linearized(),
+                    CryonirspTag.linearized_frame(
+                        beam=beam, exposure_conditions=exposure_conditions
+                    ),
                     CryonirspTag.task_solar_gain(),
-                    CryonirspTag.frame(),
-                    CryonirspTag.beam(beam),
-                    CryonirspTag.exposure_conditions(exposure_conditions),
                 ],
                 encoder=fits_hdulist_encoder,
             )
@@ -179,32 +193,41 @@ def geometric_calibration_task_with_simple_raw_data(
 
             # Create the intermediate frames needed
             # Create a fake bad pixel map
-            task.intermediate_frame_write_arrays(
-                arrays=np.zeros(data_shape_raw),
-                task_tag=CryonirspTag.task_bad_pixel_map(),
+            task.write(
+                data=np.zeros(data_shape_raw),
+                tags=[CryonirspTag.intermediate_frame(), CryonirspTag.task_bad_pixel_map()],
+                encoder=fits_array_encoder,
             )
             for beam in range(1, number_of_beams + 1):
                 dark_cal = np.ones(data_shape_int) * 3.0
-                task.intermediate_frame_write_arrays(
-                    arrays=dark_cal,
-                    beam=beam,
-                    task_tag=CryonirspTag.task_dark(),
-                    exposure_conditions=exposure_conditions,
+                task.write(
+                    data=dark_cal,
+                    tags=[
+                        CryonirspTag.intermediate_frame(
+                            beam=beam, exposure_conditions=exposure_conditions
+                        ),
+                        CryonirspTag.task_dark(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
                 # Need a lamp for each beam
                 lamp_gain = np.ones(data_shape_int)
-                task.intermediate_frame_write_arrays(
-                    arrays=lamp_gain,
-                    beam=beam,
-                    task_tag=CryonirspTag.task_lamp_gain(),
-                    exposure_conditions=exposure_conditions,
+                task.write(
+                    data=lamp_gain,
+                    tags=[
+                        CryonirspTag.intermediate_frame(
+                            beam=beam, exposure_conditions=exposure_conditions
+                        ),
+                        CryonirspTag.task_lamp_gain(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
                 # And a beam border intermediate array
                 border = data_shape_raw[1] // 2
-                task.intermediate_frame_write_arrays(
-                    arrays=np.array(
+                task.write(
+                    data=np.array(
                         [
                             0,
                             data_shape_int[0],
@@ -212,18 +235,26 @@ def geometric_calibration_task_with_simple_raw_data(
                             (border + (beam - 1) * border),
                         ]
                     ),
-                    task_tag=CryonirspTag.task_beam_boundaries(),
-                    beam=beam,
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=beam),
+                        CryonirspTag.task_beam_boundaries(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
                 # Let's write a dark with the wrong exposure time, just to make sure it doesn't get used
-                task.intermediate_frame_write_arrays(
-                    arrays=np.ones(data_shape_int) * 1e6,
-                    beam=beam,
-                    task_tag=CryonirspTag.task_dark(),
-                    exposure_conditions=ExposureConditions(
-                        exposure_time**2, AllowableOpticalDensityFilterNames.OPEN.value
-                    ),
+                task.write(
+                    data=np.ones(data_shape_int) * 1e6,
+                    tags=[
+                        CryonirspTag.intermediate_frame(
+                            beam=beam,
+                            exposure_conditions=ExposureConditions(
+                                exposure_time**2, AllowableOpticalDensityFilterNames.OPEN.value
+                            ),
+                        ),
+                        CryonirspTag.task_dark(),
+                    ],
+                    encoder=fits_array_encoder,
                 )
 
             # Create the raw data, which is based on two beams per frame
@@ -245,10 +276,8 @@ def geometric_calibration_task_with_simple_raw_data(
             task.write(
                 data=solar_hdul,
                 tags=[
-                    CryonirspTag.linearized(),
+                    CryonirspTag.linearized_frame(exposure_conditions=exposure_conditions),
                     CryonirspTag.task_solar_gain(),
-                    CryonirspTag.frame(),
-                    CryonirspTag.exposure_conditions(exposure_conditions),
                 ],
                 encoder=fits_hdulist_encoder,
             )
@@ -271,9 +300,36 @@ def test_geometric_task(geometric_calibration_task_that_completes, mocker):
     task, beam_shape = geometric_calibration_task_that_completes
     task()
     for beam in range(1, task.constants.num_beams + 1):
-        assert type(task.intermediate_frame_load_angle(beam=beam)) is float
-        assert task.intermediate_frame_load_spec_shift(beam=beam).shape[0] == beam_shape[0]
-        assert task.intermediate_frame_load_state_offset(beam=beam).shape == (2,)
+        angle_array = next(
+            task.read(
+                tags=[
+                    CryonirspTag.intermediate_frame(beam=beam),
+                    CryonirspTag.task_geometric_angle(),
+                ],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
+        assert type(float(angle_array[0])) is float
+        spec_shift_array = next(
+            task.read(
+                tags=[
+                    CryonirspTag.intermediate_frame(beam=beam),
+                    CryonirspTag.task_geometric_spectral_shifts(),
+                ],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
+        assert spec_shift_array.shape[0] == beam_shape[0]
+        state_offset_array = next(
+            task.read(
+                tags=[
+                    CryonirspTag.intermediate_frame(beam=beam),
+                    CryonirspTag.task_geometric_offset(),
+                ],
+                decoder=cryo_fits_array_decoder,
+            )
+        )
+        assert state_offset_array.shape == (2,)
 
     quality_files = task.read(tags=[CryonirspTag.quality("TASK_TYPES")])
     for file in quality_files:
@@ -282,8 +338,7 @@ def test_geometric_task(geometric_calibration_task_that_completes, mocker):
             assert isinstance(data, dict)
             assert data["total_frames"] == task.scratch.count_all(
                 tags=[
-                    CryonirspTag.linearized(),
-                    CryonirspTag.frame(),
+                    CryonirspTag.linearized_frame(),
                     CryonirspTag.task_solar_gain(),
                 ]
             )