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

dkist_processing_cryonirsp/tests/test_linearity_correction.py

@@ -0,0 +1,245 @@
+"""Test the linearity correction task."""
+import re
+from dataclasses import dataclass
+from datetime import datetime
+
+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.models.tags import Tag
+from dkist_processing_common.tests.conftest import FakeGQLClient
+from dkist_service_configuration.logging import logger
+
+from dkist_processing_cryonirsp.models.constants import CryonirspBudName
+from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
+from dkist_processing_cryonirsp.models.tags import CryonirspTag
+from dkist_processing_cryonirsp.tasks.linearity_correction import LinearityCorrection
+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 CryonirspHeadersValidNonLinearizedFrames
+
+
+@pytest.fixture(scope="function")
+def linearity_correction(
+    tmp_path,
+    recipe_run_id,
+    assign_input_dataset_doc_to_task,
+    init_cryonirsp_constants_db,
+    arm_id,
+    frames_in_ramp,
+    filter_name,
+):
+    #                    time        y   x
+    dataset_shape = (frames_in_ramp, 10, 10)
+    #              z   y   x
+    array_shape = (1, 10, 10)
+    time_delta = 0.1
+    start_time = datetime.now()
+    expected_num_frames_in_ramp = 10
+    constants_db = CryonirspConstantsDb(
+        TIME_OBS_LIST=(str(start_time),),
+        ARM_ID=arm_id,
+        ROI_1_SIZE_X=array_shape[2],
+        ROI_1_SIZE_Y=array_shape[1],
+    )
+    init_cryonirsp_constants_db(recipe_run_id, constants_db)
+    with LinearityCorrection(
+        recipe_run_id=recipe_run_id,
+        workflow_name="linearity_correction",
+        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())
+            ds = CryonirspHeadersValidNonLinearizedFrames(
+                arm_id=arm_id,
+                camera_readout_mode="FastUpTheRamp",
+                dataset_shape=dataset_shape,
+                array_shape=array_shape,
+                time_delta=time_delta,
+                roi_x_origin=0,
+                roi_y_origin=0,
+                roi_x_size=array_shape[2],
+                roi_y_size=array_shape[1],
+                date_obs=start_time.isoformat("T"),
+                exposure_time=time_delta,
+            )
+            # Initial header creation...
+            header_generator = (
+                spec122_validator.validate_and_translate_to_214_l0(
+                    d.header(), return_type=fits.HDUList
+                )[0].header
+                for d in ds
+            )
+            # Patch the headers for non-linearized Cryo data...
+            header_list = []
+            exp_time = 0.0
+            counter = 0
+            for header in header_generator:
+                # Set the integrated exposure time for this NDR
+                # This is a range from 0 to 90 in 10 steps
+                header["XPOSURE"] = 100 * counter * time_delta
+                # Set the current frame in ramp, 1-based
+                header["CNCNDR"] = counter + 1
+                header["CNNNDR"] = expected_num_frames_in_ramp
+                header["CNFILTNP"] = filter_name
+                header_list.append(header)
+                counter += 1
+            # Step on the old one with the new one
+            header_generator = (header for header in header_list)
+            # Iterate through the headers and create the frames...
+            for _ in header_list:
+                hdul = generate_fits_frame(header_generator=header_generator, shape=array_shape)
+                # Now tweak the data...
+                for hdu in hdul:
+                    header = hdu.header
+                    exp_time = header["XPOSURE"]
+                    # Create a simple perfectly linear ramp
+                    hdu.data.fill(exp_time)
+                    task.write(
+                        data=hdul,
+                        tags=[
+                            CryonirspTag.input(),
+                            CryonirspTag.frame(),
+                            CryonirspTag.curr_frame_in_ramp(header["CNCNDR"]),
+                            # All frames in a ramp have the same date-obs
+                            CryonirspTag.time_obs(str(start_time)),
+                            Tag.readout_exp_time(exp_time),
+                        ],
+                        encoder=fits_hdulist_encoder,
+                    )
+            task.constants._update({CryonirspBudName.camera_readout_mode.value: "FastUpTheRamp"})
+            yield task, filter_name, expected_num_frames_in_ramp
+        finally:
+            task._purge()
+
+
+@pytest.mark.parametrize(
+    "filter_name",
+    [
+        pytest.param(AllowableOpticalDensityFilterNames.G358.value),
+        pytest.param(AllowableOpticalDensityFilterNames.OPEN.value),
+    ],
+)
+@pytest.mark.parametrize(
+    "frames_in_ramp",
+    [pytest.param(10, id="Full ramp"), pytest.param(5, id="Bad ramp")],
+)
+@pytest.mark.parametrize(
+    "arm_id",
+    [pytest.param("CI", id="CI"), pytest.param("SP", id="SP")],
+)
+@pytest.mark.parametrize(
+    "num_chunks",
+    [pytest.param(1, id="1 chunk"), pytest.param(2, id="2 chunks")],
+)
+def test_linearity_correction(
+    linearity_correction,
+    mocker,
+    arm_id,
+    frames_in_ramp,
+    num_chunks,
+    filter_name,
+):
+    """
+    Given: A LinearityCorrection task
+    When: Calling the task instance with known input data
+    Then: The non-linearized frames are linearized and produce the correct results.
+    """
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+    )
+    if num_chunks == 2:
+        mocker.patch(
+            "dkist_processing_cryonirsp.tasks.linearity_correction.LinearityCorrection.compute_linear_chunk_size",
+            new=lambda self, frame_size, num_frames_in_ramp: frame_size // 2,
+        )
+    # Given
+    task, filter_name, expected_num_frames_in_ramp = linearity_correction
+    # When
+    task()
+    # Then
+    tags = [
+        CryonirspTag.linearized(),
+        CryonirspTag.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
+    # filter in use
+    attenuation = 10 ** (task.parameters.linearization_filter_attenuation_dict[filter_name])
+    expected_data = np.ones((10, 10)) * 1000.0 / attenuation
+    files_found = list(task.read(tags=tags))
+    if frames_in_ramp == expected_num_frames_in_ramp:
+        assert len(files_found) == 1
+        hdul = fits.open(files_found[0])
+        data = hdul[0].data
+        assert np.allclose(data, expected_data)
+    else:
+        assert len(files_found) == 0
+
+
+@pytest.fixture
+def simple_linearity_correction_task(recipe_run_id, arm_id, init_cryonirsp_constants_db, tmp_path):
+    constants_db = CryonirspConstantsDb(
+        ARM_ID=arm_id,
+    )
+    init_cryonirsp_constants_db(recipe_run_id, constants_db)
+    with LinearityCorrection(
+        recipe_run_id=recipe_run_id,
+        workflow_name="workflow_name",
+        workflow_version="workflow_version",
+    ) as task:
+        task.scratch = WorkflowFileSystem(recipe_run_id=recipe_run_id, scratch_base_path=tmp_path)
+
+        yield task
+
+        task._purge()
+
+
+@dataclass
+class DummyRampFitsAccess:
+    """Just a class that has the one property that is checked during ramp validation."""
+
+    num_frames_in_ramp: int
+    ip_task_type: str = "TASK"
+
+
+@pytest.mark.parametrize(
+    "arm_id",
+    [pytest.param("CI", id="CI"), pytest.param("SP", id="SP")],
+)
+@pytest.mark.parametrize(
+    "ramp_list, valid, message",
+    [
+        pytest.param(
+            [
+                DummyRampFitsAccess(num_frames_in_ramp=2),
+                DummyRampFitsAccess(num_frames_in_ramp=3),
+            ],
+            False,
+            "Not all frames have the same FRAMES_IN_RAMP value. Set is {2, 3}. Ramp is task TASK. Skipping ramp.",
+            id="num_frames_mismatch_actual_frames",
+        ),
+        pytest.param(
+            [
+                DummyRampFitsAccess(num_frames_in_ramp=8),
+            ],
+            False,
+            "Missing some ramp frames. Expected 8 from header value, but only have 1. Ramp is task TASK. Skipping ramp.",
+            id="num_frames_in_set_mismatch",
+        ),
+    ],
+)
+def test_is_ramp_valid(simple_linearity_correction_task, ramp_list, valid, message, caplog):
+    logger.add(caplog.handler)
+    assert simple_linearity_correction_task.is_ramp_valid(ramp_list) is valid
+    if not valid:
+        assert re.search(message, caplog.text)

dkist_processing_cryonirsp/tests/test_make_movie_frames.py

@@ -0,0 +1,111 @@
+from datetime import datetime
+
+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.tags import CryonirspTag
+from dkist_processing_cryonirsp.tasks.make_movie_frames import MakeCryonirspMovieFrames
+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 CryonirspHeadersValidObserveFrames
+
+
+@pytest.fixture(
+    scope="function",
+    params=[pytest.param(True, id="polarimetric"), pytest.param(False, id="intensity-only")],
+)
+def movie_frames_task(tmp_path, recipe_run_id, init_cryonirsp_constants_db, request):
+    is_polarimetric = request.param
+    map_scans = 3
+    scan_steps = 2
+    array_shape = (3, 4)
+    if is_polarimetric:
+        num_mod = 8
+        spin_mode = "Continuous"
+    else:
+        num_mod = 1
+        spin_mode = "None"
+    constants_db = CryonirspConstantsDb(
+        NUM_MODSTATES=num_mod,
+        MODULATOR_SPIN_MODE=spin_mode,
+        NUM_SCAN_STEPS=scan_steps,
+        NUM_MAP_SCANS=map_scans,
+        TIME_OBS_LIST=(datetime.now().isoformat("T"),),
+    )
+    init_cryonirsp_constants_db(recipe_run_id, constants_db)
+    with MakeCryonirspMovieFrames(
+        recipe_run_id=recipe_run_id, workflow_name="make_movie_frames", 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
+            meas_num = 1  # Use only the first measurement if there are multiple measurements.
+            task.scratch = WorkflowFileSystem(
+                scratch_base_path=tmp_path, recipe_run_id=recipe_run_id
+            )
+            start_time = datetime.now()
+            for stokes_state in ["I", "Q", "U", "V"]:
+                for map_scan in range(1, map_scans + 1):
+                    for scan_step in range(0, scan_steps + 1):
+                        ds = CryonirspHeadersValidObserveFrames(
+                            dataset_shape=(2, *array_shape),
+                            array_shape=(1, *array_shape),
+                            time_delta=10,
+                            num_map_scans=map_scans,
+                            map_scan=map_scan,
+                            num_scan_steps=scan_steps,
+                            scan_step=scan_step,
+                            num_modstates=1,
+                            modstate=1,
+                            start_time=start_time,
+                            num_meas=1,
+                            meas_num=1,
+                            arm_id="CI",
+                        )
+                        header_generator = (
+                            spec122_validator.validate_and_translate_to_214_l0(
+                                d.header(), return_type=fits.HDUList
+                            )[0].header
+                            for d in ds
+                        )
+                        hdul = generate_fits_frame(
+                            header_generator=header_generator, shape=(1, *array_shape)
+                        )
+                        task.write(
+                            data=hdul,
+                            tags=[
+                                CryonirspTag.calibrated(),
+                                CryonirspTag.frame(),
+                                CryonirspTag.map_scan(map_scan),
+                                CryonirspTag.scan_step(scan_step),
+                                CryonirspTag.stokes(stokes_state),
+                                CryonirspTag.meas_num(meas_num),
+                            ],
+                            encoder=fits_hdulist_encoder,
+                        )
+            yield task, map_scans, scan_steps, array_shape, is_polarimetric
+        finally:
+            task._purge()
+
+
+def test_make_movie_frames(movie_frames_task, mocker):
+    """
+    Given: A MakeCryonirspMovieFrames task
+    When: Calling the task instance
+    Then: a fits file is made for each scan containing the movie frame for that scan
+    """
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+    )
+    task, map_scans, scan_steps, array_shape, is_polarimetric = movie_frames_task
+    expected_shape = array_shape
+
+    task()
+    assert len(list(task.read(tags=[CryonirspTag.movie_frame()]))) == map_scans * scan_steps
+    for filepath in task.read(tags=[CryonirspTag.movie_frame()]):
+        assert filepath.exists()
+        hdul = fits.open(filepath)
+        assert hdul[0].header["INSTRUME"] == "CRYO-NIRSP"
+        assert hdul[0].data.shape == expected_shape

dkist_processing_cryonirsp/tests/test_parameters.py

@@ -0,0 +1,266 @@
+from dataclasses import asdict
+from typing import Any
+
+import numpy as np
+import pytest
+from astropy.units import Quantity
+from dkist_processing_common._util.scratch import WorkflowFileSystem
+from hypothesis import example
+from hypothesis import given
+from hypothesis import HealthCheck
+from hypothesis import settings
+from hypothesis import strategies as st
+
+from dkist_processing_cryonirsp.models.parameters import CryonirspParameters
+from dkist_processing_cryonirsp.models.parameters import CryonirspParsingParameters
+from dkist_processing_cryonirsp.parsers.optical_density_filters import (
+    ALLOWABLE_OPTICAL_DENSITY_FILTERS,
+)
+from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
+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 FileParameter
+from dkist_processing_cryonirsp.tests.conftest import TestingParameters
+
+# The property names of all parameters on `CryonirspParsingParameters`
+PARSE_PARAMETER_NAMES = [
+    k for k, v in vars(CryonirspParsingParameters).items() if isinstance(v, property)
+]
+
+
+@pytest.fixture(scope="function")
+def basic_science_task_with_parameter_mixin(
+    tmp_path,
+    recipe_run_id,
+    assign_input_dataset_doc_to_task,
+    init_cryonirsp_constants_db,
+    testing_obs_ip_start_time,
+):
+    def make_task(
+        parameter_class=CryonirspParameters,
+        arm_id: str = "SP",
+        obs_ip_start_time: str = testing_obs_ip_start_time,
+    ):
+        class Task(CryonirspTaskBase):
+            def run(self):
+                ...
+
+        init_cryonirsp_constants_db(recipe_run_id, CryonirspConstantsDb())
+        task = Task(
+            recipe_run_id=recipe_run_id,
+            workflow_name="parse_cryonirsp_input_data",
+            workflow_version="VX.Y",
+        )
+        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
+            )
+            test_params = cryonirsp_testing_parameters_factory(param_path=tmp_path)
+            param_dict = test_params()
+            assign_input_dataset_doc_to_task(
+                task,
+                param_dict,
+                parameter_class=parameter_class,
+                arm_id=arm_id,
+                obs_ip_start_time=obs_ip_start_time,
+            )
+            yield task, param_dict
+        finally:
+            task._purge()
+
+    return make_task
+
+
+def _is_wavelength_param(param_value: Any) -> bool:
+    return isinstance(param_value, dict) and "wavelength" in param_value
+
+
+@given(wave=st.floats(min_value=800.0, max_value=2000.0))
+@settings(suppress_health_check=[HealthCheck.function_scoped_fixture], deadline=None)
+@example(wave=1082.7)
+def test_filter_parameters(basic_science_task_with_parameter_mixin, wave):
+    """
+    Given: A Science task with the parameter mixin
+    When: Accessing properties for the optical density filters
+    Then: The correct value is returned
+    """
+    task, expected = next(basic_science_task_with_parameter_mixin())
+    task_params = task.parameters
+    task_params._wavelength = wave
+    expected = {
+        "_linearization_optical_density_filter_attenuation_g278": -1.64,
+        "_linearization_optical_density_filter_attenuation_g358": -3.75,
+        "_linearization_optical_density_filter_attenuation_g408": -4.26,
+    }
+    for param in expected:
+        assert getattr(task_params, param) == expected[param]
+
+
+def _is_file_param(param_value: Any) -> bool:
+    return isinstance(param_value, dict) and "is_file" in param_value and param_value["is_file"]
+
+
+def test_file_parameters(basic_science_task_with_parameter_mixin):
+    """
+    Given: A Science task with the parameter mixin
+    When: Accessing parameters whose values are loaded from files
+    Then: The correct value is returned
+
+    This test exercises all aspects of file parameters from their names to the loading of values
+    """
+    task, test_params = next(basic_science_task_with_parameter_mixin())
+    task_params = task.parameters
+    # Iterate over the test parameters and check that each file param exists in the task parameters
+    # we load the actual parameter from the task param object using only the param name
+    for pn, pv in asdict(test_params).items():
+        # We want to test only file parameters
+        if _is_file_param(pv):
+            pn_no_prefix = pn.removeprefix("cryonirsp_")
+            # If the param name is an attribute in task_params, then load it directly
+            if hasattr(task_params, pn_no_prefix):
+                param_name = pn_no_prefix
+                actual = getattr(task_params, param_name)
+            # if the param name is not a task param attribute, then check that we can load the param
+            # using the value defined in the input_dataset_parameters list of the task param object
+            else:
+                param_dict = task_params._find_most_recent_past_value(pn)
+                actual = task_params._load_param_value_from_numpy_save(param_dict)
+            # Now get the expected value using the param value dict from the testing params
+            expected = np.load(pv["param_path"])
+            # Compare the actual and expected values
+            assert np.array_equal(actual, expected)
+
+
+def _is_arm_param(
+    param_name: str,
+    task_params: CryonirspParameters,
+    testing_params: TestingParameters,
+    single_arm_only: str | None = None,
+):
+    """
+    Test if a parameter is an arm parameter.
+
+    An arm parameter is one which is present in the task_param class with no arm suffix and is also
+    present in the test_param class with suffixed forms only, one for each arm.
+    This allows a non-arm-specific name to be used as a property in the parameters class which
+    encapsulates the mechanism used to return the arm specific parameter value based on the arm in use.
+    """
+    # NB: param_name is assumed to have a prefix of "cryonirsp_"
+    arm_suffixes = ["_sp", "_ci"] if single_arm_only is None else [f"_{single_arm_only}".casefold()]
+    suffix = param_name[-3:]
+    if suffix not in arm_suffixes:
+        return False
+    param_name_no_suffix = param_name[:-3]
+    param_names_with_suffixes = [f"{param_name_no_suffix}{suffix}" for suffix in arm_suffixes]
+    suffixed_names_exist = all(
+        [hasattr(testing_params, pname) for pname in param_names_with_suffixes]
+    )
+    generic_param_name = param_name_no_suffix.removeprefix("cryonirsp_")
+    return hasattr(task_params, generic_param_name) and suffixed_names_exist
+
+
+@pytest.mark.parametrize("arm_id", ["SP", "CI"])
+def test_arm_parameters(basic_science_task_with_parameter_mixin, arm_id):
+    """
+    Given: A Science task with the parameter mixin
+    When: Accessing parameters that are "arm" parameters
+    Then: The correct value is returned
+
+    This test exercises all aspects of arm parameters from their names to the loading of values,
+    which includes exercising the method _find_parameter_for_arm
+    """
+    # An arm parameter is one which is present in the param class with no arm suffix
+    # and is also present in the testing param class with both suffix forms
+    task, test_params = next(basic_science_task_with_parameter_mixin(arm_id=arm_id))
+    task_params = task.parameters
+    # Iterate over the test parameters
+    for pn, pv in asdict(test_params).items():
+        suffix = f"_{arm_id}".casefold()
+        if _is_arm_param(pn, task_params, test_params, single_arm_only=arm_id):
+            generic_param_name = pn.removeprefix("cryonirsp_").removesuffix(suffix)
+
+            actual = getattr(task_params, generic_param_name)
+            expected = getattr(test_params, pn)
+            if isinstance(expected, FileParameter) and expected.is_file:
+                expected = task_params._load_param_value_from_numpy_save(asdict(expected))
+                assert np.array_equal(expected, actual)
+            elif isinstance(actual, np.ndarray):
+                assert expected == actual.tolist()
+            else:
+                assert expected == actual
+
+
+def test_parameters(basic_science_task_with_parameter_mixin):
+    """
+    Given: A Science task with the parameter mixin
+    When: Accessing properties for parameters that are not wavelength, file or generic parameters
+    Then: The correct value is returned
+    """
+    task, test_params = next(basic_science_task_with_parameter_mixin())
+    task_params = task.parameters
+    for pn, pv in asdict(test_params).items():
+        parameter_name = pn.removeprefix("cryonirsp_")
+        if (
+            _is_file_param(pv)
+            or _is_wavelength_param(pv)
+            or _is_arm_param(pn, task_params, test_params)
+            or parameter_name in PARSE_PARAMETER_NAMES
+        ):
+            continue
+        accessed_parameter_value = getattr(task_params, parameter_name)
+        if isinstance(accessed_parameter_value, Quantity):
+            assert pv == accessed_parameter_value.value
+        else:
+            assert pv == getattr(task_params, parameter_name)
+
+
+def test_parse_parameters(basic_science_task_with_parameter_mixin):
+    """
+    Given: A Science task with ParsingParameters
+    When: Accessing properties for the parsing parameters
+    Then: The correct value is returned
+    """
+    task, test_params = next(
+        basic_science_task_with_parameter_mixin(
+            parameter_class=CryonirspParsingParameters,
+            obs_ip_start_time=None,
+        )
+    )
+    task_param_attr = task.parameters
+    for pn, pv in asdict(test_params).items():
+        property_name = pn.removeprefix("cryonirsp_")
+        if property_name in PARSE_PARAMETER_NAMES and type(pv) is not dict:
+            assert getattr(task_param_attr, property_name) == pv
+
+
+@pytest.mark.parametrize("arm", [pytest.param("CI"), pytest.param("SP")])
+def test_linearization_threshold_parameters(
+    basic_science_task_with_parameter_mixin, arm, init_cryonirsp_constants_db
+):
+    """
+    Given: A Science task with the parameter mixin
+    When: Accessing properties for the linearization thresholds
+    Then: The correct type is returned
+    """
+    task, _ = next(basic_science_task_with_parameter_mixin())
+    recipe_run_id = task.recipe_run_id
+    init_cryonirsp_constants_db(recipe_run_id, CryonirspConstantsDb(ARM_ID=arm))
+    linearization_threshold_array = task.parameters.linearization_thresholds
+
+    assert linearization_threshold_array.dtype == np.float32
+
+
+def test_optical_density_filter_names(basic_science_task_with_parameter_mixin):
+    task, _ = next(basic_science_task_with_parameter_mixin())
+    # List of filter attenuation parameters defined in CryonirspParameters:
+    defined_filter_params = {
+        item[-4:].upper()
+        for item in dir(task.parameters)
+        if item.startswith("_linearization_optical_density_filter_attenuation_")
+    }
+    # List of filters in the filter map:
+    filter_map_params = {k for k in task.parameters.linearization_filter_attenuation_dict.keys()}
+    # Make sure all filter parameters match the allowable list
+    assert not defined_filter_params.symmetric_difference(ALLOWABLE_OPTICAL_DENSITY_FILTERS)
+    # Make sure all filter map keys match the allowable list
+    assert not filter_map_params.symmetric_difference(ALLOWABLE_OPTICAL_DENSITY_FILTERS)