dkist-processing-cryonirsp 1.3.4__py3-none-any.whl

dkist_processing_cryonirsp/tests/test_corrections.py

@@ -0,0 +1,126 @@
+from typing import Literal
+
+import numpy as np
+import pytest
+from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.tasks import WorkflowTaskBase
+from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
+from dkist_processing_common.tests.conftest import FakeGQLClient
+
+from dkist_processing_cryonirsp.models.constants import CryonirspConstants
+from dkist_processing_cryonirsp.tasks.mixin.corrections import CorrectionsMixin
+from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
+from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
+
+base_bad_pixel_map = np.zeros(shape=(10, 10))
+
+normal_bad_pixel_map = base_bad_pixel_map.copy()
+normal_bad_pixel_map[1, 6] = 1
+
+column_error_bad_pixel_map = base_bad_pixel_map.copy()
+column_error_bad_pixel_map[:, 6] = 1
+
+
+class BadPixelMapTask(WorkflowTaskBase, CorrectionsMixin, InputDatasetMixin):
+    constants: CryonirspConstants
+
+    @property
+    def constants_model_class(self):
+        """Get CryoNIRSP pipeline constants."""
+        return CryonirspConstants
+
+    def run(self):
+        pass
+
+
+@pytest.fixture(params=["CI", "SP"])
+def bad_pixel_mask_task(
+    tmp_path,
+    recipe_run_id,
+    assign_input_dataset_doc_to_task,
+    mocker,
+    request,
+    init_cryonirsp_constants_db,
+):
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+    )
+    constants_db = CryonirspConstantsDb(
+        ARM_ID=request.param,
+    )
+    init_cryonirsp_constants_db(recipe_run_id, constants_db)
+    with BadPixelMapTask(
+        recipe_run_id=recipe_run_id,
+        workflow_name="bad_pixel_mask",
+        workflow_version="VX.Y",
+    ) as task:
+        try:  # This try... block is here to make sure the dbs get cleaned up if there's a failure in the fixture
+            task.scratch = WorkflowFileSystem(
+                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+            )
+            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            assign_input_dataset_doc_to_task(task, param_class())
+            yield task
+        finally:
+            task._purge()
+
+
+def contrive_bad_px_neighborhood(
+    array: np.ndarray, bad_px_location: tuple[int, int], kernel_size: int, desired_median: float
+) -> np.array:
+    """
+    Adjust array values so the neighborhood around a bad pixel results in a known value being used to replace that pixel.
+    """
+    # Sticking with the y, x convention used by `corrections_correct_bad_pixels`.
+    y, x = bad_px_location
+    half_kernel_size = kernel_size // 2
+    num_y, num_x = array.shape
+
+    y_slice = slice(max(y - half_kernel_size, 0), min(y + half_kernel_size + 1, num_y))
+    x_slice = slice(max(x - half_kernel_size, 0), min(x + half_kernel_size + 1, num_x))
+
+    array[y_slice, x_slice] = desired_median
+
+    return array
+
+
+@pytest.mark.parametrize(
+    "bad_pixel_map, algorithm_type",
+    [
+        pytest.param(normal_bad_pixel_map, "normal", id="normal algorithm"),
+        pytest.param(column_error_bad_pixel_map, "fast", id="fast algorithm"),
+    ],
+)
+def test_corrections_correct_bad_pixels(bad_pixel_map, algorithm_type, bad_pixel_mask_task):
+    t = bad_pixel_mask_task
+    bad_pixel_x = 1
+    bad_pixel_y = 6
+
+    # Create a data array. Adding 10 ensures that 0 will be a valid sentinel value of bad-ness
+    rng = np.random.default_rng()
+    array_to_fix = rng.random((10, 10), dtype=float) * 100 + 10.0
+
+    # Assign a single bad pixel to check against
+    if algorithm_type == "normal":
+        expected_corrected_value = rng.random() * 100 + 10
+        array_to_fix = contrive_bad_px_neighborhood(
+            array=array_to_fix,
+            bad_px_location=(1, 6),
+            kernel_size=t.parameters.corrections_bad_pixel_median_filter_size,
+            desired_median=expected_corrected_value,
+        )
+    array_to_fix[bad_pixel_x, bad_pixel_y] = 0
+
+    corrected_array = t.corrections_correct_bad_pixels(
+        array_to_fix=array_to_fix, bad_pixel_map=bad_pixel_map
+    )
+    if algorithm_type == "fast":
+        for val in corrected_array[:, bad_pixel_y]:
+            assert val == np.nanmedian(array_to_fix)
+        assert corrected_array[bad_pixel_x, bad_pixel_y] == np.nanmedian(array_to_fix)
+
+    if algorithm_type == "normal":
+        x, y = np.meshgrid(np.arange(10), np.arange(10))
+        idx = np.where((x != bad_pixel_x) | (y != bad_pixel_y))
+        np.testing.assert_array_equal(corrected_array[idx], array_to_fix[idx])
+        assert corrected_array[bad_pixel_x, bad_pixel_y] == expected_corrected_value

dkist_processing_cryonirsp/tests/test_cryo_base.py

@@ -0,0 +1,202 @@
+import numpy as np
+import pytest
+from astropy.io import fits
+from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.fits import fits_hdu_decoder
+
+from dkist_processing_cryonirsp.models.tags import CryonirspTag
+from dkist_processing_cryonirsp.models.task_name import CryonirspTaskName
+from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
+from dkist_processing_cryonirsp.tasks.mixin.intermediate_frame import (
+    IntermediateFrameMixin,
+)
+from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
+from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
+
+NUM_BEAMS = 2
+NUM_MODSTATES = 8
+NUM_CS_STEPS = 6
+NUM_SCAN_STEPS = 10
+WAVE = 1082.0
+
+
+@pytest.fixture(scope="function")
+def cryo_science_task(
+    tmp_path, recipe_run_id, assign_input_dataset_doc_to_task, init_cryonirsp_constants_db
+):
+    class Task(CryonirspTaskBase, IntermediateFrameMixin):
+        def run(self):
+            ...
+
+    constants_db = CryonirspConstantsDb(
+        NUM_MODSTATES=NUM_MODSTATES,
+        NUM_CS_STEPS=NUM_CS_STEPS,
+        NUM_SCAN_STEPS=NUM_SCAN_STEPS,
+        WAVELENGTH=WAVE,
+    )
+    init_cryonirsp_constants_db(recipe_run_id, constants_db)
+    with Task(
+        recipe_run_id=recipe_run_id,
+        workflow_name="parse_cryonirsp_input_data",
+        workflow_version="VX.Y",
+    ) as task:
+        try:
+            task.scratch = WorkflowFileSystem(
+                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+            )
+            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            assign_input_dataset_doc_to_task(task, param_class())
+            yield task
+        finally:
+            task._purge()
+
+
+def test_write_intermediate_arrays(cryo_science_task):
+    """
+    Given: A CryonirspTaskBase task
+    When: Using the helper to write a single intermediate array
+    Then: The array is written and tagged correctly
+    """
+    data = np.random.random((10, 10))
+    head = fits.Header()
+    head["TEST"] = "foo"
+    cryo_science_task.intermediate_frame_write_arrays(
+        arrays=data, headers=head, beam=1, map_scan=2, scan_step=3, task="BAR"
+    )
+    loaded_list = list(
+        cryo_science_task.read(
+            tags=[
+                CryonirspTag.intermediate(),
+                CryonirspTag.frame(),
+                CryonirspTag.beam(1),
+                CryonirspTag.map_scan(2),
+                CryonirspTag.scan_step(3),
+                CryonirspTag.task("BAR"),
+            ],
+            decoder=fits_hdu_decoder,
+        )
+    )
+    assert len(loaded_list) == 1
+    hdu = loaded_list[0]
+    np.testing.assert_equal(hdu.data, data)
+    assert hdu.header["TEST"] == "foo"
+
+
+def test_write_intermediate_arrays_task_tag(cryo_science_task):
+    """
+    Given: A CryonirspTaskBase task
+    When: Using the helper to write a single intermediate array with a formatted task tag input arg
+    Then: The array is written and tagged correctly
+    """
+    data = np.random.random((10, 10))
+    head = fits.Header()
+    head["TEST"] = "foo"
+
+    # bad_pixel_map chosen for no particular reason
+    cryo_science_task.intermediate_frame_write_arrays(
+        arrays=data, headers=head, task_tag=CryonirspTag.task_bad_pixel_map()
+    )
+    loaded_list = list(
+        cryo_science_task.read(
+            tags=[CryonirspTag.task_bad_pixel_map()],
+            decoder=fits_hdu_decoder,
+        )
+    )
+    assert len(loaded_list) == 1
+    hdu = loaded_list[0]
+    np.testing.assert_equal(hdu.data, data)
+    assert hdu.header["TEST"] == "foo"
+
+
+def test_write_intermediate_arrays_task_collisions(cryo_science_task):
+    """
+    Given: A CryonirspTaskBase task
+    When: Using the helper but providing invalid `task` or `task_tag` inputs
+    Then: An error is raised
+    """
+    data = np.random.random((10, 10))
+
+    # Test both given
+    with pytest.raises(ValueError, match="Cannot specify"):
+        cryo_science_task.intermediate_frame_write_arrays(
+            arrays=data, task_tag=CryonirspTag.task_bad_pixel_map(), task="DARK"
+        )
+
+    # Test neither given
+    with pytest.raises(ValueError, match="Must specify"):
+        cryo_science_task.intermediate_frame_write_arrays(arrays=data)
+
+
+def test_write_intermediate_arrays_none_header(cryo_science_task):
+    """
+    Given: A CryonirspTaskBase task
+    When: Using the helper to write a single intermediate array with no header
+    Then: The array is written and tagged correctly
+    """
+    data = np.random.random((10, 10))
+    cryo_science_task.intermediate_frame_write_arrays(
+        arrays=data, headers=None, beam=1, map_scan=2, scan_step=3, task="BAR"
+    )
+    loaded_list = list(
+        cryo_science_task.read(
+            tags=[
+                CryonirspTag.intermediate(),
+                CryonirspTag.frame(),
+                CryonirspTag.beam(1),
+                CryonirspTag.map_scan(2),
+                CryonirspTag.scan_step(3),
+                CryonirspTag.task("BAR"),
+            ],
+            decoder=fits_hdu_decoder,
+        )
+    )
+    assert len(loaded_list) == 1
+    hdu = loaded_list[0]
+    np.testing.assert_equal(hdu.data, data)
+
+
+@pytest.fixture
+def cryo_science_task_with_tagged_intermediates(
+    recipe_run_id, tmpdir_factory, init_cryonirsp_constants_db
+):
+    class Task(CryonirspTaskBase, IntermediateFrameMixin):
+        def run(self):
+            ...
+
+    init_cryonirsp_constants_db(recipe_run_id, CryonirspConstantsDb())
+    with Task(
+        recipe_run_id=recipe_run_id,
+        workflow_name="parse_cryo_input_data",
+        workflow_version="VX.Y",
+    ) as task:
+        try:
+            task.scratch = WorkflowFileSystem(scratch_base_path=tmpdir_factory.mktemp("data"))
+            tag_names = [["beam"], ["exposure_time", "task"], ["modstate"]]
+            tag_vals = [[1], [10.23, "dark"], [3]]
+            tag_fcns = [[getattr(CryonirspTag, n) for n in nl] for nl in tag_names]
+            tag_list = [[f(v) for f, v in zip(fl, vl)] for fl, vl in zip(tag_fcns, tag_vals)]
+            for i, tags in enumerate(tag_list):
+                hdul = fits.HDUList([fits.PrimaryHDU(data=np.ones((2, 2)) * i)])
+                fname = task.scratch.workflow_base_path / f"file{i}.fits"
+                hdul.writeto(fname)
+                task.tag(fname, tags + [CryonirspTag.intermediate(), CryonirspTag.frame()])
+
+            yield task, tag_names, tag_vals
+        finally:
+            task._purge()
+
+
+def test_load_intermediate_arrays(cryo_science_task_with_tagged_intermediates):
+    """
+    Given: A task with tagged intermediate frames
+    When: Using intermediate frame loaders to grab the intermediate frames
+    Then: The correct arrays are returned
+    """
+    task, tag_names, tag_vals = cryo_science_task_with_tagged_intermediates
+    tag_list_list = [
+        [getattr(CryonirspTag, n)(v) for n, v in zip(nl, vl)] for nl, vl in zip(tag_names, tag_vals)
+    ]
+    for i, tags in enumerate(tag_list_list):
+        arrays = list(task.intermediate_frame_load_intermediate_arrays(tags=tags))
+        assert len(arrays) == 1
+        np.testing.assert_equal(arrays[0], np.ones((2, 2)) * i)

dkist_processing_cryonirsp/tests/test_cryo_constants.py

@@ -0,0 +1,76 @@
+from dataclasses import asdict
+from dataclasses import dataclass
+
+import pytest
+
+from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
+from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
+from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
+
+
+@pytest.fixture(scope="function")
+def testing_constants(polarimetric):
+    @dataclass
+    class testing_constants:
+        obs_ip_start_time: str = "1999-12-31T23:59:59"
+        num_modstates: int = 10 if polarimetric else 1
+        num_beams: int = 2
+        num_cs_steps: int = 18
+        num_scan_steps: int = 1000
+        wavelength: float = 1082.0
+        lamp_gain_exposure_conditions_list: tuple[ExposureConditions, ...] = (
+            ExposureConditions(100.0, AllowableOpticalDensityFilterNames.OPEN.value),
+        )
+        solar_gain_exposure_conditions_list: tuple[ExposureConditions, ...] = (
+            ExposureConditions(1.0, AllowableOpticalDensityFilterNames.OPEN.value),
+        )
+        observe_exposure_conditions_list: tuple[ExposureConditions, ...] = (
+            ExposureConditions(0.01, AllowableOpticalDensityFilterNames.OPEN.value),
+        )
+        modulator_spin_mode: str = "Continuous" if polarimetric else "Off"
+        # We don't need all the common ones, but let's put one just to check
+        instrument: str = "CHECK_OUT_THIS_INSTRUMENT"
+        arm_id: str = "SP"
+
+    return testing_constants()
+
+
+@pytest.fixture(scope="function")
+def expected_constant_dict(testing_constants) -> dict:
+    lower_dict = asdict(testing_constants)
+    return {k.upper(): v for k, v in lower_dict.items()}
+
+
+@pytest.fixture(scope="function")
+def cryo_science_task_with_constants(
+    recipe_run_id, expected_constant_dict, init_cryonirsp_constants_db
+):
+    class Task(CryonirspTaskBase):
+        def run(self):
+            ...
+
+    init_cryonirsp_constants_db(recipe_run_id, expected_constant_dict)
+    task = Task(
+        recipe_run_id=recipe_run_id,
+        workflow_name="parse_cryo_input_data",
+        workflow_version="VX.Y",
+    )
+
+    yield task
+
+    task._purge()
+
+
+@pytest.mark.parametrize(
+    "polarimetric",
+    [pytest.param(True, id="Polarimetric"), pytest.param(False, id="Spectrographic")],
+)
+def test_cryo_constants(cryo_science_task_with_constants, expected_constant_dict, polarimetric):
+    task = cryo_science_task_with_constants
+    for k, v in expected_constant_dict.items():
+        if k.lower() == "modulator_spin_mode":
+            continue
+        if type(v) is tuple:
+            v = list(v)
+        assert getattr(task.constants, k.lower()) == v
+    assert task.constants.correct_for_polarization == polarimetric

dkist_processing_cryonirsp/tests/test_dark.py

@@ -0,0 +1,287 @@
+import json
+
+import numpy as np
+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_hdulist_encoder
+from dkist_processing_common.tests.conftest import FakeGQLClient
+
+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
+from dkist_processing_cryonirsp.tasks.dark import DarkCalibration
+from dkist_processing_cryonirsp.tests.conftest import cryonirsp_testing_parameters_factory
+from dkist_processing_cryonirsp.tests.conftest import CryonirspConstantsDb
+from dkist_processing_cryonirsp.tests.conftest import generate_fits_frame
+from dkist_processing_cryonirsp.tests.header_models import CryonirspHeadersValidDarkFrames
+
+
+@pytest.fixture(scope="function")
+def sp_dark_calibration_task(
+    tmp_path, assign_input_dataset_doc_to_task, init_cryonirsp_constants_db, recipe_run_id
+):
+    # Make sure we test cases where either the exp time or filter are the same, but the other value is
+    # different
+    exposure_conditions = (
+        ExposureConditions(100.0, AllowableOpticalDensityFilterNames.OPEN.value),
+        ExposureConditions(1.0, AllowableOpticalDensityFilterNames.G278.value),
+        ExposureConditions(0.01, AllowableOpticalDensityFilterNames.NONE.value),
+        ExposureConditions(100.0, AllowableOpticalDensityFilterNames.G278.value),
+    )
+    unused_exposure_condition = ExposureConditions(
+        200.0, AllowableOpticalDensityFilterNames.NONE.value
+    )
+    constants_db = CryonirspConstantsDb(
+        NON_DARK_AND_NON_POLCAL_TASK_EXPOSURE_CONDITIONS_LIST=exposure_conditions,
+        ARM_ID="SP",
+    )
+    init_cryonirsp_constants_db(recipe_run_id, constants_db)
+    with DarkCalibration(
+        recipe_run_id=recipe_run_id, workflow_name="dark_calibration", workflow_version="VX.Y"
+    ) as task:
+        illuminated_beam_shape = (6, 4)
+        num_beams = 2
+        num_exp_cond = len(exposure_conditions) + 1  # +1 for the unused condition
+        num_frames_per_condition = 3
+        array_shape = (1, 10, 20)
+        dataset_shape = (num_exp_cond * num_frames_per_condition, 20, 10)
+        try:  # This try... block is here to make sure the dbs get cleaned up if there's a failure in the fixture
+            task.scratch = WorkflowFileSystem(
+                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+            )
+            param_class = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            assign_input_dataset_doc_to_task(task, param_class())
+
+            # Create fake beam border intermediate arrays
+            for beam in range(1, num_beams + 1):
+                spectral_starting_pixel = 5 + ((beam - 1) * 10)
+                beam_boundaries = np.array(
+                    [
+                        3,
+                        3 + illuminated_beam_shape[0],
+                        spectral_starting_pixel,
+                        spectral_starting_pixel + illuminated_beam_shape[1],
+                    ]
+                )
+                task.intermediate_frame_write_arrays(
+                    arrays=beam_boundaries,
+                    task_tag=CryonirspTag.task_beam_boundaries(),
+                    beam=beam,
+                )
+
+            ds = CryonirspHeadersValidDarkFrames(
+                dataset_shape=dataset_shape,
+                array_shape=array_shape,
+                time_delta=10,
+                exposure_time=1.0,
+            )
+            header_generator = (
+                spec122_validator.validate_and_translate_to_214_l0(
+                    d.header(), return_type=fits.HDUList
+                )[0].header
+                for d in ds
+            )
+
+            for condition in exposure_conditions + (unused_exposure_condition,):
+                for _ in range(num_frames_per_condition):
+                    hdul = generate_fits_frame(header_generator=header_generator, shape=array_shape)
+                    hdul[0].data.fill(condition.exposure_time)
+                    task.write(
+                        data=hdul,
+                        tags=[
+                            CryonirspTag.linearized(),
+                            CryonirspTag.frame(),
+                            CryonirspTag.task_dark(),
+                            CryonirspTag.exposure_conditions(condition),
+                        ],
+                        encoder=fits_hdulist_encoder,
+                    )
+            yield task, num_beams, exposure_conditions, unused_exposure_condition, illuminated_beam_shape
+        finally:
+            task._purge()
+
+
+@pytest.fixture(scope="function")
+def ci_dark_calibration_task(
+    tmp_path, assign_input_dataset_doc_to_task, init_cryonirsp_constants_db, recipe_run_id
+):
+    # Make sure we test cases where either the exp time or filter are the same, but the other value is
+    # different
+    exposure_conditions = (
+        ExposureConditions(100.0, AllowableOpticalDensityFilterNames.OPEN.value),
+        ExposureConditions(1.0, AllowableOpticalDensityFilterNames.G278.value),
+        ExposureConditions(0.01, AllowableOpticalDensityFilterNames.NONE.value),
+        ExposureConditions(100.0, AllowableOpticalDensityFilterNames.G278.value),
+    )
+    unused_exposure_condition = ExposureConditions(
+        200.0, AllowableOpticalDensityFilterNames.NONE.value
+    )
+
+    constants_db = CryonirspConstantsDb(
+        NON_DARK_AND_NON_POLCAL_TASK_EXPOSURE_CONDITIONS_LIST=exposure_conditions,
+        ARM_ID="CI",
+    )
+    init_cryonirsp_constants_db(recipe_run_id, constants_db)
+    with DarkCalibration(
+        recipe_run_id=recipe_run_id, workflow_name="dark_calibration", workflow_version="VX.Y"
+    ) as task:
+        num_exp_cond = len(exposure_conditions) + 1  # +1 for the unused condition
+        num_frames_per_condition = 3
+        array_shape = (1, 10, 10)
+        dataset_shape = (num_exp_cond * num_frames_per_condition, 20, 10)
+        try:  # This try... block is here to make sure the dbs get cleaned up if there's a failure in the fixture
+            task.scratch = WorkflowFileSystem(
+                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+            )
+            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, 10, 0, 10]),
+                task_tag=CryonirspTag.task_beam_boundaries(),
+                beam=1,
+            )
+
+            ds = CryonirspHeadersValidDarkFrames(
+                dataset_shape=dataset_shape,
+                array_shape=array_shape,
+                time_delta=10,
+                exposure_time=1.0,
+            )
+            header_generator = (
+                spec122_validator.validate_and_translate_to_214_l0(
+                    d.header(), return_type=fits.HDUList
+                )[0].header
+                for d in ds
+            )
+            for condition in exposure_conditions + (unused_exposure_condition,):
+                for _ in range(num_frames_per_condition):
+                    hdul = generate_fits_frame(header_generator=header_generator, shape=array_shape)
+                    hdul[0].data.fill(condition.exposure_time)
+                    task.write(
+                        data=hdul,
+                        tags=[
+                            CryonirspTag.linearized(),
+                            CryonirspTag.frame(),
+                            CryonirspTag.task_dark(),
+                            CryonirspTag.exposure_conditions(condition),
+                        ],
+                        encoder=fits_hdulist_encoder,
+                    )
+            yield task, exposure_conditions, unused_exposure_condition
+        finally:
+            task._purge()
+
+
+def test_sp_dark_calibration_task(sp_dark_calibration_task, mocker):
+    """
+    Given: A DarkCalibration task with multiple task exposure times
+    When: Calling the task instance
+    Then: Only one average intermediate dark frame exists for each exposure time and unused times are not made
+    """
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+    )
+    # When
+    (
+        task,
+        num_beams,
+        exp_conditions,
+        unused_condition,
+        illuminated_beam_shape,
+    ) = sp_dark_calibration_task
+    task()
+    # Then
+    for condition in exp_conditions:
+        for b in range(num_beams):
+            files = list(
+                task.read(
+                    tags=[
+                        CryonirspTag.task_dark(),
+                        CryonirspTag.intermediate(),
+                        CryonirspTag.frame(),
+                        CryonirspTag.beam(b + 1),
+                        CryonirspTag.exposure_conditions(condition),
+                    ]
+                )
+            )
+            assert len(files) == 1
+            expected = np.ones(illuminated_beam_shape) * condition.exposure_time
+            hdul = fits.open(files[0])
+            np.testing.assert_equal(expected, hdul[0].data)
+            hdul.close()
+
+    unused_time_read = task.read(
+        tags=[
+            CryonirspTag.task_dark(),
+            CryonirspTag.intermediate(),
+            CryonirspTag.frame(),
+            CryonirspTag.exposure_conditions(unused_condition),
+        ]
+    )
+    assert len(list(unused_time_read)) == 0
+
+    quality_files = task.read(tags=[CryonirspTag.quality("TASK_TYPES")])
+    for file in quality_files:
+        with file.open() as f:
+            data = json.load(f)
+            assert isinstance(data, dict)
+            assert data["total_frames"] == task.scratch.count_all(
+                tags=[CryonirspTag.linearized(), CryonirspTag.frame(), CryonirspTag.task_dark()]
+            )
+            assert data["frames_not_used"] == 3
+
+
+def test_ci_dark_calibration_task(ci_dark_calibration_task, mocker):
+    """
+    Given: A DarkCalibration task with multiple task exposure times
+    When: Calling the task instance
+    Then: Only one average intermediate dark frame exists for each exposure time and unused times are not made
+    """
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+    )
+    # When
+    task, exp_conditions, unused_condition = ci_dark_calibration_task
+    task()
+    # Then
+    for condition in exp_conditions:
+        files = list(
+            task.read(
+                tags=[
+                    CryonirspTag.task_dark(),
+                    CryonirspTag.beam(1),
+                    CryonirspTag.intermediate(),
+                    CryonirspTag.frame(),
+                    CryonirspTag.exposure_conditions(condition),
+                ]
+            )
+        )
+        assert len(files) == 1
+        expected = np.ones((10, 10)) * condition.exposure_time
+        hdul = fits.open(files[0])
+        np.testing.assert_equal(expected, hdul[0].data)
+        hdul.close()
+
+    unused_time_read = task.read(
+        tags=[
+            CryonirspTag.task_dark(),
+            CryonirspTag.intermediate(),
+            CryonirspTag.frame(),
+            CryonirspTag.exposure_conditions(unused_condition),
+        ]
+    )
+    assert len(list(unused_time_read)) == 0
+
+    quality_files = task.read(tags=[CryonirspTag.quality("TASK_TYPES")])
+    for file in quality_files:
+        with file.open() as f:
+            data = json.load(f)
+            assert isinstance(data, dict)
+            assert data["total_frames"] == task.scratch.count_all(
+                tags=[CryonirspTag.linearized(), CryonirspTag.frame(), CryonirspTag.task_dark()]
+            )
+            assert data["frames_not_used"] == 3