dkist-processing-trend 0.1.0__py3-none-any.whl

dkist_processing_trend/tests/test_run_pac_fitter.py

@@ -0,0 +1,371 @@
+from collections import defaultdict
+
+import astropy.units as u
+import numpy as np
+import pytest
+from astropy.time import Time
+from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.asdf import asdf_encoder
+from dkist_processing_common.codecs.fits import fits_array_decoder
+from dkist_processing_common.tests.conftest import CalibrationUnit
+from dkist_processing_common.tests.conftest import Telescope
+from dkist_processing_pac.fitter.fitter_parameters import PolcalDresserParameters
+from dkist_processing_pac.input_data.drawer import Drawer
+from dkist_processing_pac.input_data.dresser import Dresser
+
+from dkist_processing_trend.models.instrument import InstrumentName
+from dkist_processing_trend.models.parameters import TrendParameters
+from dkist_processing_trend.models.tags import TrendTag
+from dkist_processing_trend.parsers.trend_l0_fits_access import TrendL0FitsAccess
+from dkist_processing_trend.tasks.run_pac_fitter import RunPacFitter
+from dkist_processing_trend.tests.conftest import ModulatedCSStepHeaders
+from dkist_processing_trend.tests.conftest import TrendInputDatasetParameterValues
+from dkist_processing_trend.tests.conftest import TrendTestingConstantsDatabase
+
+
+@pytest.fixture(scope="session")
+def cs_with_correct_geometry():
+    pol_status = [
+        "clear",
+        "clear",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "Sapphire Polarizer",
+        "clear",
+        "clear",
+    ]
+    pol_theta = [0, 0, 0, 60, 120, 0, 0, 0, 45, 45, 45, 45, 0, 0]
+    ret_status = [
+        "clear",
+        "clear",
+        "clear",
+        "clear",
+        "clear",
+        "SiO2 SAR",
+        "SiO2 SAR",
+        "SiO2 SAR",
+        "SiO2 SAR",
+        "SiO2 SAR",
+        "SiO2 SAR",
+        "SiO2 SAR",
+        "clear",
+        "clear",
+    ]
+    ret_theta = [0, 0, 0, 0, 0, 0, 60, 120, 30, 90, 150, 0, 0, 0]
+    dark_status = [
+        "DarkShutter",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "FieldStop (5arcmin)",
+        "DarkShutter",
+    ]
+    return pol_status, pol_theta, ret_status, ret_theta, dark_status
+
+
+@pytest.fixture(scope="session")
+def visp_modulation_matrix() -> np.ndarray:
+    # Modulation matrix for AdW's synthetic ViSP data from mod_matrix_630.out
+    return np.array(
+        [
+            [1.0, 0.19155013, 0.80446989, -0.47479524],
+            [1.0, -0.65839661, 0.68433984, 0.00466389],
+            [1.0, -0.80679413, -0.16112977, 0.48234158],
+            [1.0, -0.04856211, -0.56352868, 0.77578117],
+            [1.0, 0.56844858, 0.03324473, 0.77289873],
+            [1.0, 0.19155013, 0.80446989, 0.47479524],
+            [1.0, -0.65839661, 0.68433984, -0.00466389],
+            [1.0, -0.80679413, -0.16112977, -0.48234158],
+            [1.0, -0.04856211, -0.56352868, -0.77578117],
+            [1.0, 0.56844858, 0.03324473, -0.77289873],
+        ],
+        dtype=np.float64,
+    )
+
+
+@pytest.fixture(scope="session")
+def num_cs_steps(cs_with_correct_geometry) -> int:
+    return len(cs_with_correct_geometry[0])
+
+
+@pytest.fixture(scope="session")
+def num_modstates(visp_modulation_matrix) -> int:
+    return visp_modulation_matrix.shape[0]
+
+
+@pytest.fixture(scope="session")
+def arm_id() -> int:
+    return 1
+
+
+@pytest.fixture(scope="session")
+def full_cs_fits_obj_dict_no_data(
+    cs_with_correct_geometry, num_modstates, arm_id
+) -> dict[int, list[TrendL0FitsAccess]]:
+
+    pol_status, pol_theta, ret_status, ret_theta, dark_status = cs_with_correct_geometry
+
+    step_dict: dict[int, list[TrendL0FitsAccess]] = defaultdict(list)
+
+    base_time = Time("2026-01-01")
+
+    for step, (ps, pt, rs, rt, ds) in enumerate(
+        zip(pol_status, pol_theta, ret_status, ret_theta, dark_status)
+    ):
+
+        step_start = (base_time + (step * 60) * u.s).fits
+
+        ds = ModulatedCSStepHeaders(
+            instrument=InstrumentName.visp,
+            arm_id=arm_id,
+            wavelength=366.0,
+            num_modstates=num_modstates,
+            pol_status=ps,
+            pol_theta=pt,
+            ret_status=rs,
+            ret_theta=rt,
+            dark_status=ds,
+            cs_step_num=step,
+            array_shape=(2, 2),
+            exp_time_ms=6.28,
+            start_date=step_start,
+        )
+        for modstate_frame in ds:
+            step_dict[step].append(
+                TrendL0FitsAccess(header=modstate_frame.header(), data=np.ones((3, 3)))
+            )
+
+    return step_dict
+
+
+@pytest.fixture(scope="session")
+def fit_options_list() -> list[dict[str, str | bool]]:
+    return [
+        {
+            "name": "option1",
+            "remove_I_trend": True,
+            "fit_mode_name": "use_M12",
+            "init_set_name": "OCCal_VIS",
+        },
+        {
+            "name": "option2",
+            "remove_I_trend": False,
+            "fit_mode_name": "use_M12_I_sys_per_step",
+            "init_set_name": "OCCal_VIS",
+        },
+    ]
+
+
+@pytest.fixture(scope="session")
+def full_observed_values(full_cs_fits_obj_dict_no_data, visp_modulation_matrix) -> np.ndarray:
+
+    fit_mode = "use_M12"
+    init_set = "OCCal_VIS"
+    cs_dict = full_cs_fits_obj_dict_no_data
+    dresser = Dresser()
+    dresser.add_drawer(Drawer(cs_dict, skip_darks=False, remove_I_trend=False))
+    CM = CalibrationUnit(dresser)
+    TM = Telescope(dresser)
+    full_params = PolcalDresserParameters(dresser, fit_mode, init_set)
+
+    global_params = full_params.init_params._all_parameters[0]
+    pardict = global_params.valuesdict()
+    CM.load_pars_from_dict(pardict)
+    TM.load_pars_from_dict(pardict)
+
+    CM.I_sys[0] = 1e4
+
+    # Has shape (4, N)
+    S = np.sum((TM.TM @ CM.CM @ TM.M12) * CM.S_in[:, None, :], axis=2).T
+
+    # Has shape (M, N)
+    observed = visp_modulation_matrix @ S
+
+    return observed
+
+
+def write_pac_inputs_to_task(
+    task,
+    step_to_fits_access_dict: dict[int, list[TrendL0FitsAccess]],
+    observed_data: np.ndarray,
+    beam: int,
+    arm_id: str | int,
+    local_fov_shape: tuple[int, ...],
+) -> None:
+    global_dict = defaultdict(list)
+    local_dict = defaultdict(list)
+
+    for step, fits_access_list in step_to_fits_access_dict.items():
+        for modstate, fits_obj in enumerate(fits_access_list):
+            header = fits_obj.header
+            obs_value = observed_data[modstate, step]
+            global_data = np.full((1, 1), obs_value)
+            local_data = np.full(local_fov_shape, obs_value)
+
+            global_dict[step].append({"header": header, "data": global_data})
+            local_dict[step].append({"header": header, "data": local_data})
+
+    # Cheat a little bit and just write the same data for each instrument processing option
+    inst_option_names = [i.name for i in task.parameters.instrument_processing_options]
+    for inst_option_name in inst_option_names:
+        task.write(
+            data=global_dict,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.beam(beam),
+                TrendTag.arm_id(arm_id),
+                TrendTag.instrument_processing_options(inst_option_name),
+                TrendTag.task_global_pac_input(),
+            ],
+            encoder=asdf_encoder,
+        )
+        task.write(
+            data=local_dict,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.beam(beam),
+                TrendTag.arm_id(arm_id),
+                TrendTag.instrument_processing_options(inst_option_name),
+                TrendTag.task_local_pac_input(),
+            ],
+            encoder=asdf_encoder,
+        )
+
+
+@pytest.fixture
+def run_pac_fitter_task(
+    tmp_path,
+    recipe_run_id,
+    link_constants_db,
+    assign_input_dataset_doc_to_task,
+    num_cs_steps,
+    num_modstates,
+    arm_id,
+    fit_options_list,
+):
+    link_constants_db(
+        recipe_run_id,
+        TrendTestingConstantsDatabase(NUM_CS_STEPS=num_cs_steps, NUM_MODSTATES=num_modstates),
+    )
+    with RunPacFitter(
+        arm_id=arm_id, recipe_run_id=recipe_run_id, workflow_name="name", workflow_version="version"
+    ) as task:
+        task.scratch = WorkflowFileSystem(recipe_run_id=recipe_run_id, scratch_base_path=tmp_path)
+        assign_input_dataset_doc_to_task(
+            task, TrendInputDatasetParameterValues(trend_fit_options_list=fit_options_list)
+        )
+        task.parameters = TrendParameters(
+            scratch=task.scratch,
+            obs_ip_start_time=task.constants.earliest_ip_start_time,
+            instrument=task.constants.instrument,
+        )
+
+        yield task
+        task._purge()
+
+
+def test_run_pac_fitter(
+    run_pac_fitter_task,
+    mocker,
+    fake_gql_client,
+    num_cs_steps,
+    num_modstates,
+    full_cs_fits_obj_dict_no_data,
+    full_observed_values,
+    arm_id,
+    fit_options_list,
+):
+    """
+    Given: A set of PAC input data and a `RunPacFitter` task
+    When: Running the task
+    Then: The task completes, the expected outputs exist, and they have the correct shapes
+    """
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
+    )
+
+    task = run_pac_fitter_task
+    fov_shape = (3, 2)
+    num_beams = 2
+    inst_options_name_list = [i.name for i in task.parameters.instrument_processing_options]
+
+    for beam in range(1, num_beams + 1):
+        write_pac_inputs_to_task(
+            task=task,
+            step_to_fits_access_dict=full_cs_fits_obj_dict_no_data,
+            observed_data=full_observed_values,
+            beam=beam,
+            arm_id=arm_id,
+            local_fov_shape=fov_shape,
+        )
+
+    task()
+
+    cal_seq_tags = [
+        TrendTag.intermediate(),
+        TrendTag.arm_id(arm_id),
+        TrendTag.task_calibration_sequence(),
+    ]
+    assert task.count(tags=cal_seq_tags) == 1
+    cal_seq_data = next(
+        task.read(tags=cal_seq_tags, decoder=fits_array_decoder, auto_squeeze=False)
+    )
+    assert cal_seq_data.shape == (1, 8, num_cs_steps)
+
+    for inst_option_name in inst_options_name_list:
+        for beam in range(1, num_beams + 1):
+            for fit_options in fit_options_list:
+                fit_opt_name = fit_options["name"]
+                common_tags = [
+                    TrendTag.intermediate(),
+                    TrendTag.beam(beam),
+                    TrendTag.arm_id(arm_id),
+                    TrendTag.instrument_processing_options(inst_option_name),
+                    TrendTag.pac_fit_options(fit_opt_name),
+                ]
+
+                best_fit_param_tags = common_tags + [TrendTag.task_best_fit_parameters()]
+                assert task.count(best_fit_param_tags) == 1
+                best_fit_param_data = next(
+                    task.read(
+                        tags=best_fit_param_tags, decoder=fits_array_decoder, auto_squeeze=False
+                    )
+                )
+                num_params = 15 + num_cs_steps - 2  # -2 because we don't fit dark steps
+                assert best_fit_param_data.shape == fov_shape + (1, num_params, 3)
+
+                best_fit_demod_tags = common_tags + [TrendTag.task_best_fit_demodulation_matrices()]
+                assert task.count(best_fit_demod_tags) == 1
+                best_fit_demod = next(
+                    task.read(best_fit_demod_tags, decoder=fits_array_decoder, auto_squeeze=False)
+                )
+                assert best_fit_demod.shape == fov_shape + (4, num_modstates)
+
+                best_fit_flux_tags = common_tags + [TrendTag.task_best_fit_flux()]
+                assert task.count(best_fit_flux_tags) == 1
+                best_fit_flux_data = next(
+                    task.read(best_fit_flux_tags, decoder=fits_array_decoder, auto_squeeze=False)
+                )
+                assert best_fit_flux_data.shape == fov_shape + (num_modstates, num_cs_steps - 2)
+
+                fit_residuals_tags = common_tags + [TrendTag.task_fit_residuals()]
+                assert task.count(fit_residuals_tags) == 1
+                fit_residuals_data = next(
+                    task.read(fit_residuals_tags, decoder=fits_array_decoder, auto_squeeze=True)
+                )
+                assert fit_residuals_data.shape == best_fit_flux_data.shape

dkist_processing_trend/tests/test_stems.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+
+import pytest
+from dkist_processing_common.models.fits_access import MetadataKey
+
+from dkist_processing_trend.parsers.arm_id import ArmIdLookupBud
+from dkist_processing_trend.parsers.arm_id import InstrumentArmIdLookupBud
+
+
+@dataclass
+class DummyFitsAccess:
+
+    arm_id: str | int
+    wavelength: float
+    instrument: str = "foo"
+
+
+def test_arm_id_lookup_bud():
+    """
+    Given: A set of `FitsAccess` objects corresponding to multiple arms and wavelengths
+    When: Processing these objects through an `ArmIdLookupBud`
+    Then: The correct value is returned
+    """
+    fo_list = (
+        [DummyFitsAccess(arm_id=1, wavelength=123.4) for _ in range(3)]
+        + [DummyFitsAccess(arm_id="SP", wavelength=1079) for _ in range(5)]
+        + [DummyFitsAccess(arm_id=3, wavelength=567)]
+    )
+    bud = ArmIdLookupBud(constant_name="foo", metadata_key=MetadataKey.wavelength)
+    for fo in fo_list:
+        bud.update(key="doesn't matter", value=fo)
+
+    assert bud.bud.value == {"1": 123.4, '"SP"': 1079, "3": 567}
+
+
+def test_arm_id_to_wavelength_non_singular_wave():
+    """
+    Given: A set of `FitsAccess` objects corresponding to multiple arms where some arms have multiple wavelength values
+    When: Processing these objects through an `ArmIdLookupBud`
+    Then: The error is raised
+    """
+    fo_list = (
+        [DummyFitsAccess(arm_id=1, wavelength=123.4) for _ in range(3)]
+        + [DummyFitsAccess(arm_id=1, wavelength=1079) for _ in range(5)]
+        + [DummyFitsAccess(arm_id=3, wavelength=567)]
+    )
+    bud = ArmIdLookupBud(constant_name="foo", metadata_key=MetadataKey.wavelength)
+    for fo in fo_list:
+        bud.update(key="doesn't matter", value=fo)
+
+    with pytest.raises(
+        ValueError,
+        match=f"Some arms have multiple values for wavelength: arm_id = 1: {{123.4, 1079}}",
+    ):
+        bud.bud
+
+
+def test_instrument_arm_id_lookup_bud():
+    """
+    Given: A set of `FitsAccess` objects from different instruments corresponding to multiple arms and wavelengths
+    When: Processing these objects through an `InstrumentArmIdLookupBud` for only one of the input instruments
+    Then: The correct value for the single instrument is returned
+    """
+    fo_list = (
+        [DummyFitsAccess(arm_id=1, wavelength=123.4, instrument="foo") for _ in range(3)]
+        + [DummyFitsAccess(arm_id="SP", wavelength=1079, instrument="foo") for _ in range(5)]
+        + [DummyFitsAccess(arm_id=1, wavelength=-9999, instrument="bar") for _ in range(3)]
+    )
+    bud = InstrumentArmIdLookupBud(
+        constant_name="asdf", metadata_key=MetadataKey.wavelength, instruments="foo"
+    )
+    for fo in fo_list:
+        bud.update(key="doesn't matter", value=fo)
+
+    assert bud.bud.value == {"1": 123.4, '"SP"': 1079}

dkist_processing_trend/tests/test_transfer_output_data.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+
+import pytest
+from dkist_processing_common._util.scratch import WorkflowFileSystem
+
+from dkist_processing_trend.models.tags import TrendTag
+from dkist_processing_trend.tasks.trend_output_data import TransferTrendData
+from dkist_processing_trend.tasks.trend_output_data import TrendOutputDataBase
+from dkist_processing_trend.tests.conftest import TrendTestingConstantsDatabase
+
+
+def fake_list_objects(self, bucket, prefix=None):
+    return list()
+
+
+@pytest.fixture
+def transfer_l1_data_task(recipe_run_id, tmp_path, link_constants_db):
+    def make_task(
+        instrument,
+        earliest_ip_start_time,
+    ):
+        link_constants_db(
+            recipe_run_id,
+            TrendTestingConstantsDatabase(
+                INSTRUMENT=instrument, EARLIEST_IP_START_TIME=earliest_ip_start_time
+            ),
+        )
+        with TransferTrendData(
+            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,
+            )
+            frame_path = task.scratch.workflow_base_path / Path("frame.fits")
+            with open(frame_path, "w") as f:
+                f.write("Frame")
+            task.tag(path=frame_path, tags=[TrendTag.frame(), TrendTag.output()])
+
+            yield task
+            task._purge()
+
+    return make_task
+
+
+def test_transfer_l1_data(transfer_l1_data_task, mocker, fake_gql_client):
+    """
+    Given: A task with frames and movies tagged as output
+    When: Transfering the L1 data
+    Then: The task completes without errors and the destination object keys are correct
+    """
+    # Yeah, we mock a whole bunch of stuff here, but this test at least confirms that the setup to these calls is correct
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
+    )
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.globus.GlobusMixin.globus_transfer_scratch_to_object_store"
+    )
+    mocker.patch("dkist_processing_common.tasks.mixin.object_store.ObjectClerk.upload_object")
+    mocker.patch(
+        "dkist_processing_common.tasks.mixin.object_store.ObjectClerk.list_objects",
+        fake_list_objects,
+    )
+    instrument = "HELLO"
+    earliest_ip_start_time = "1900-01-01T12:34:45.0002"
+    task = next(
+        transfer_l1_data_task(instrument=instrument, earliest_ip_start_time=earliest_ip_start_time)
+    )
+    task()
+
+    assert (
+        task.format_object_key(Path("scratch/foo/bar/thing.fits"))
+        == "trend/polcal/19000101T123445/HELLO/thing.fits"
+    )

dkist_processing_trend/tests/test_trend_fits_access.py

@@ -0,0 +1,173 @@
+from inspect import get_annotations
+from random import randint
+
+import pytest
+from astropy.io import fits
+
+from dkist_processing_trend.models.fits_access import TrendMetadataKey
+from dkist_processing_trend.models.instrument import InstrumentName
+from dkist_processing_trend.parsers.trend_l0_fits_access import IncorrectInstrumentError
+from dkist_processing_trend.parsers.trend_l0_fits_access import TrendL0FitsAccess
+from dkist_processing_trend.tests.conftest import WAVELENGTH_FOR_ARM
+from dkist_processing_trend.tests.conftest import ModulatedCSStepHeaders
+
+
+@pytest.fixture(scope="function")  # So we get new random for each test
+def random_cs_step_config(
+    small_calibration_sequence, small_num_cs_steps
+) -> tuple[str, float, str, float, str]:
+    idx = randint(0, small_num_cs_steps - 1)
+    return tuple(i[idx] for i in small_calibration_sequence)
+
+
+@pytest.fixture
+def num_modstates() -> int:
+    return 2
+
+
+@pytest.fixture
+def metadata_keys_from_wrong_instruments(instrument):
+    visp_metadata_keys = {
+        TrendMetadataKey.visp_grating_angle,
+        TrendMetadataKey.visp_arm_position,
+        TrendMetadataKey.visp_grating_constant,
+    }
+    cryonirsp_metadata_keys = {
+        TrendMetadataKey.cryonirsp_od_filter_name,
+        TrendMetadataKey.cryonirsp_grating_angle,
+        TrendMetadataKey.cryonirsp_grating_littrow_angle,
+        TrendMetadataKey.cryonirsp_grating_constant,
+        TrendMetadataKey.cryonirsp_slit_width,
+    }
+    dlnirsp_metadata_keys = {
+        TrendMetadataKey.dlnirsp_grating_angle,
+        TrendMetadataKey.dlnirsp_arm_position,
+        TrendMetadataKey.dlnirsp_grating_constant,
+    }
+
+    wrong_inst_metadata_keys = visp_metadata_keys | cryonirsp_metadata_keys | dlnirsp_metadata_keys
+    match instrument:
+        case InstrumentName.visp:
+            wrong_inst_metadata_keys -= visp_metadata_keys
+        case InstrumentName.cryonirsp:
+            wrong_inst_metadata_keys -= cryonirsp_metadata_keys
+        case InstrumentName.dlnirsp:
+            wrong_inst_metadata_keys -= dlnirsp_metadata_keys
+
+    return wrong_inst_metadata_keys
+
+
+@pytest.fixture
+def input_header(
+    instrument: InstrumentName,
+    arm_id: str | int,
+    num_modstates: int,
+    random_cs_step_config: tuple[str, float, str, float, str],
+) -> fits.Header:
+    pol_status, pol_theta, ret_status, ret_theta, dark_status = random_cs_step_config
+    ds = ModulatedCSStepHeaders(
+        instrument=instrument,
+        arm_id=arm_id,
+        wavelength=WAVELENGTH_FOR_ARM[arm_id],
+        num_modstates=num_modstates,
+        pol_status=pol_status,
+        pol_theta=pol_theta,
+        ret_status=ret_status,
+        ret_theta=ret_theta,
+        dark_status=dark_status,
+        array_shape=(2, 2),
+        cs_step_num=1,
+        exp_time_ms=34.0,
+    )
+    return ds.header()
+
+
+@pytest.mark.parametrize(
+    "instrument, arm_id",
+    [
+        pytest.param(InstrumentName.visp, 1, id="visp"),
+        pytest.param(InstrumentName.cryonirsp, "SP", id="cryonirsp"),
+        pytest.param(InstrumentName.dlnirsp, "JBand", id="JBand"),
+    ],
+)
+def test_trend_l0_fits_access(input_header, num_modstates, arm_id):
+    """
+    Given: A Header with instrument-specific trend values
+    When: Parsing the header with `TrendL0FitsAccess`
+    Then: The keys for each instrument are correctly used such that the FitsAccess properties return the correct value
+    """
+    fits_obj = TrendL0FitsAccess(header=input_header)
+
+    assert fits_obj.arm_id == arm_id
+    assert fits_obj.number_of_modulator_states == num_modstates
+    assert fits_obj.modulator_state == 1  # Because we took the first header from the dataset
+
+
+@pytest.mark.parametrize("instrument, arm_id", [pytest.param(InstrumentName.visp, 1, id="")])
+def test_error_on_unknown_instrument(input_header):
+    """
+    Given: A Header where the INSTRUME key is not one of the recognized values
+    When: Parsing the header with `TrendL0FitsAccess`
+    Then: The correct Error is raised
+    """
+    input_header["INSTRUME"] = "WRONG"
+    with pytest.raises(ValueError, match="Did not expect instrument = WRONG"):
+        TrendL0FitsAccess(header=input_header)
+
+
+@pytest.mark.parametrize(
+    "instrument, arm_id",
+    [
+        pytest.param(InstrumentName.visp, 1, id="visp"),
+        pytest.param(InstrumentName.cryonirsp, "SP", id="cryonirsp"),
+        pytest.param(InstrumentName.dlnirsp, "VIS", id="dlnirsp"),
+    ],
+)
+def test_metadata_keys_in_access_bases(input_header):
+    """
+    Given: The set of metadata key names in TrendMetadataKey
+    When: The `TrendL0FitsAccess` class defines a set of new attributes
+    Then: The sets are the same
+    """
+    trend_metadata_key_names = {tmk.name for tmk in TrendMetadataKey}
+    all_trend_fits_access_attrs = set()
+    for access_class in [TrendL0FitsAccess]:
+        fits_obj = access_class(header=input_header)
+        trend_instance_attrs = set(vars(fits_obj).keys())
+
+        # This next line grabs the `InstrumentSpecificProperty` for the instruments not represented in the header
+        trend_instance_attrs |= set(get_annotations(access_class).keys())
+        parent_class = access_class.mro()[1]
+        parent_fits_obj = parent_class(header=input_header)
+        parent_instance_attrs = set(vars(parent_fits_obj).keys())
+        trend_fits_access_attrs = trend_instance_attrs - parent_instance_attrs
+        all_trend_fits_access_attrs |= trend_fits_access_attrs
+    assert trend_metadata_key_names == all_trend_fits_access_attrs
+
+
+@pytest.mark.parametrize(
+    "instrument, arm_id",
+    [
+        pytest.param(InstrumentName.visp, 1, id="visp"),
+        pytest.param(InstrumentName.cryonirsp, "SP", id="cryonirsp"),
+        pytest.param(InstrumentName.dlnirsp, "VIS", id="dlnirsp"),
+    ],
+)
+def test_instrument_specific_properties(
+    input_header, instrument, metadata_keys_from_wrong_instruments
+):
+    """
+    Given: A TrendL0FitsAccess object generated from an input header corresponding to a certain instrument
+    When: Trying to access properties that are not defined for that certain instrument
+    Then: The correct error is raised
+    """
+    fits_obj = TrendL0FitsAccess(header=input_header)
+
+    for metadata_key in metadata_keys_from_wrong_instruments:
+        with pytest.raises(
+            IncorrectInstrumentError,
+            match="This property is only defined for data from .*, which this frame is not.",
+        ) as exc_info:
+            _ = getattr(fits_obj, metadata_key.name)
+            pytest.fail(f"{metadata_key = } did not raise expected error")
+        assert instrument not in exc_info.value.args[0]