dkist-processing-visp 4.0.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

dkist_processing_visp/tests/test_solar.py

@@ -2,14 +2,28 @@ import json
 from functools import partial
 from typing import Callable
 
+import asdf
+import astropy.units as u
 import numpy as np
 import pytest
+from asdf.tags.core import NDArrayType
+from astropy import constants
+from astropy.coordinates import EarthLocation
+from astropy.io import fits
+from astropy.stats import gaussian_fwhm_to_sigma
+from astropy.time import Time
 from dkist_processing_common._util.scratch import WorkflowFileSystem
 from dkist_processing_common.codecs.fits import fits_array_decoder
+from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.tags import Tag
+from scipy.ndimage import gaussian_filter1d
+from solar_wavelength_calibration import Atlas
+from sunpy.coordinates import HeliocentricInertial
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.solar import SolarCalibration
+from dkist_processing_visp.tasks.solar import WavelengthCalibrationParametersWithContinuum
+from dkist_processing_visp.tasks.solar import compute_initial_dispersion
 from dkist_processing_visp.tests.conftest import VispConstantsDb
 from dkist_processing_visp.tests.conftest import VispInputDatasetParameterValues
 from dkist_processing_visp.tests.conftest import tag_on_modstate
@@ -17,36 +31,188 @@ from dkist_processing_visp.tests.conftest import write_frames_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_background_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_darks_to_task
 from dkist_processing_visp.tests.conftest import write_intermediate_geometric_to_task
-from dkist_processing_visp.tests.conftest import write_intermediate_lamp_to_task
 from dkist_processing_visp.tests.header_models import VispHeadersInputSolarGainFrames
 
 
-def lamp_signal_func(beam: int, modstate: int):
-    return 10 * beam * modstate
+def lamp_signal_func(beam: int):
+    return 10 * beam
+
+
+@pytest.fixture(scope="session")
+def num_wave_pix() -> int:
+    return 1000
+
+
+@pytest.fixture(scope="session")
+def telluric_opacity_factor() -> float:
+    return 5.0
+
+
+@pytest.fixture(scope="session")
+def solar_ip_start_time() -> str:
+    return "1988-07-02T10:00:00"
+
+
+@pytest.fixture(scope="session")
+def doppler_velocity(solar_ip_start_time) -> u.Quantity:
+    _dkist_site_info = {
+        "aliases": ["DKIST", "ATST"],
+        "name": "Daniel K. Inouye Solar Telescope",
+        "elevation": 3067,
+        "elevation_unit": "meter",
+        "latitude": 20.7067,
+        "latitude_unit": "degree",
+        "longitude": 203.7436,
+        "longitude_unit": "degree",
+        "timezone": "US/Hawaii",
+        "source": "DKIST website: https://www.nso.edu/telescopes/dki-solar-telescope/",
+    }
+    location_of_dkist = EarthLocation.from_geodetic(
+        _dkist_site_info["longitude"] * u.Unit(_dkist_site_info["longitude_unit"]),
+        _dkist_site_info["latitude"] * u.Unit(_dkist_site_info["latitude_unit"]),
+        _dkist_site_info["elevation"] * u.Unit(_dkist_site_info["elevation_unit"]),
+    )
+
+    coord = location_of_dkist.get_gcrs(obstime=Time(solar_ip_start_time))
+    heliocentric_coord = coord.transform_to(HeliocentricInertial(obstime=Time(solar_ip_start_time)))
+    obs_vr_kms = heliocentric_coord.d_distance
+
+    return obs_vr_kms
+
+
+@pytest.fixture(scope="session")
+def central_wavelength() -> u.Quantity:
+    return 854.2 * u.nm
+
+
+@pytest.fixture(scope="session")
+def grating_constant() -> u.Quantity:
+    return 316.0 / u.mm
+
+
+@pytest.fixture(scope="session")
+def incident_light_angle() -> u.Quantity:
+    return 73.22 * u.deg
+
+
+@pytest.fixture(scope="session")
+def reflected_light_angle() -> u.Quantity:
+    return 68.76 * u.deg
+
+
+@pytest.fixture(scope="session")
+def pixel_pitch() -> u.Quantity:
+    return 6.5 * u.micron / u.pix
+
+
+@pytest.fixture(scope="session")
+def lens_parameters_no_units() -> list[float]:
+    return [0.7613, 1.720e-4, -8.139e-8]
+
+
+@pytest.fixture(scope="session")
+def lens_parameters(lens_parameters_no_units) -> list[u.Quantity]:
+    return [
+        lens_parameters_no_units[0] * u.m,
+        lens_parameters_no_units[1] * u.m / u.nm,
+        lens_parameters_no_units[2] * u.m / u.nm**2,
+    ]
+
+
+@pytest.fixture(scope="session")
+def dispersion(
+    central_wavelength, incident_light_angle, reflected_light_angle, lens_parameters, pixel_pitch
+) -> u.Quantity:
+    return compute_initial_dispersion(
+        central_wavelength=central_wavelength,
+        incident_light_angle=incident_light_angle,
+        reflected_light_angle=reflected_light_angle,
+        lens_parameters=lens_parameters,
+        pixel_pitch=pixel_pitch,
+    )
+
+
+@pytest.fixture(scope="session")
+def resolving_power() -> int:
+    return int(1.15e5)
+
+
+@pytest.fixture(scope="session")
+def solar_atlas() -> Atlas:
+    return Atlas()
+
+
+@pytest.fixture(scope="session")
+def spectral_vignette_function(num_wave_pix) -> np.ndarray:
+    return (np.arange(num_wave_pix) - num_wave_pix // 2) / (num_wave_pix * 10) + 1.0
+
+
+@pytest.fixture
+def observed_solar_spectrum(
+    central_wavelength,
+    dispersion,
+    num_wave_pix,
+    solar_atlas,
+    telluric_opacity_factor,
+    doppler_velocity,
+    resolving_power,
+) -> np.ndarray:
+    """Make an "observed" solar spectrum from a shifted and atmospherically corrected combination of solar and telluric atlases."""
+    # Making a simple solution with just y = mx + b (no higher order angle or order stuff)
+    wave_vec = (
+        np.arange(num_wave_pix) - num_wave_pix // 2
+    ) * u.pix * dispersion + central_wavelength
+
+    doppler_shift = doppler_velocity / constants.c * central_wavelength
+    solar_signal = np.interp(
+        wave_vec,
+        solar_atlas.solar_atlas_wavelength + doppler_shift,
+        solar_atlas.solar_atlas_transmission,
+    )
+    telluric_signal = (
+        np.interp(
+            wave_vec,
+            solar_atlas.telluric_atlas_wavelength,
+            solar_atlas.telluric_atlas_transmission,
+        )
+        ** telluric_opacity_factor
+    )
+
+    combined_spec = solar_signal * telluric_signal
+
+    sigma_wavelength = (
+        central_wavelength.to_value(u.nm) / resolving_power
+    ) * gaussian_fwhm_to_sigma
+    sigma_pix = sigma_wavelength / np.abs(dispersion.to_value(u.nm / u.pix))
+    observed_spec = gaussian_filter1d(combined_spec, np.abs(sigma_pix))
+
+    return observed_spec
 
 
 def write_full_set_of_intermediate_lamp_cals_to_task(
     task,
     data_shape: tuple[int, int],
-    num_modstates: int,
-    lamp_signal_func: Callable[[int, int], float] = lamp_signal_func,
+    lamp_signal_func: Callable[[int], float] = lamp_signal_func,
 ):
     for beam in [1, 2]:
-        for modstate in range(1, num_modstates + 1):
-            lamp_signal = lamp_signal_func(beam, modstate)
-            write_intermediate_lamp_to_task(
-                task=task,
-                lamp_signal=lamp_signal,
-                beam=beam,
-                modstate=modstate,
-                data_shape=data_shape,
-            )
+        lamp_signal = lamp_signal_func(beam)
+        lamp_array = np.ones(data_shape) * lamp_signal
+        task.write(
+            data=lamp_array,
+            tags=[
+                VispTag.intermediate_frame(beam=beam),
+                VispTag.task_lamp_gain(),
+            ],
+            encoder=fits_array_encoder,
+        )
 
 
 def make_solar_input_array_data(
     frame: VispHeadersInputSolarGainFrames,
     dark_signal: float,
-    lamp_signal_func: Callable[[int, int], float] = lamp_signal_func,
+    true_solar_signal: np.ndarray,
+    spectral_vignette_signal: np.ndarray,
+    lamp_signal_func: Callable[[int], float] = lamp_signal_func,
 ):
     data_shape = frame.array_shape[1:]
     beam_shape = (data_shape[0] // 2, data_shape[1])
@@ -55,12 +221,14 @@ def make_solar_input_array_data(
 
     beam_list = []
     for beam in [1, 2]:
-        true_gain = np.ones(beam_shape) + modstate + beam
-        true_solar_signal = np.arange(1, beam_shape[0] + 1) / 5
+        true_gain = np.ones(beam_shape) * spectral_vignette_signal[:, None]
         true_solar_gain = true_gain * true_solar_signal[:, None]
-        lamp_signal = lamp_signal_func(beam, modstate)
+        lamp_signal = lamp_signal_func(beam)
         raw_beam = (true_solar_gain * lamp_signal) + dark_signal
-        beam_list.append(raw_beam)
+        if beam == 2:
+            beam_list.append(raw_beam[::-1, :])
+        else:
+            beam_list.append(raw_beam)
 
     raw_solar = np.concatenate(beam_list) * num_raw_per_fpa
     return raw_solar
@@ -72,6 +240,8 @@ def write_input_solar_gains_to_task(
     dark_signal: float,
     readout_exp_time: float,
     num_modstates: int,
+    true_solar_signal: np.ndarray,
+    spectra_vignette_signal: np.ndarray,
     lamp_signal_func: Callable[[int, int], float] = lamp_signal_func,
 ):
     array_shape = (1, *data_shape)
@@ -81,7 +251,11 @@ def write_input_solar_gains_to_task(
         num_modstates=num_modstates,
     )
     data_func = partial(
-        make_solar_input_array_data, dark_signal=dark_signal, lamp_signal_func=lamp_signal_func
+        make_solar_input_array_data,
+        dark_signal=dark_signal,
+        lamp_signal_func=lamp_signal_func,
+        true_solar_signal=true_solar_signal,
+        spectral_vignette_signal=spectra_vignette_signal,
     )
     write_frames_to_task(
         task=task,
@@ -101,11 +275,23 @@ def solar_gain_task(
     tmp_path,
     recipe_run_id,
     init_visp_constants_db,
+    central_wavelength,
+    incident_light_angle,
+    reflected_light_angle,
+    grating_constant,
+    solar_ip_start_time,
 ):
     number_of_modstates = 3
     readout_exp_time = 40.0
     constants_db = VispConstantsDb(
-        NUM_MODSTATES=number_of_modstates, SOLAR_READOUT_EXP_TIMES=(readout_exp_time,)
+        ARM_ID=1,
+        WAVELENGTH=central_wavelength.to_value(u.nm),
+        NUM_MODSTATES=number_of_modstates,
+        SOLAR_READOUT_EXP_TIMES=(readout_exp_time,),
+        SOLAR_GAIN_IP_START_TIME=solar_ip_start_time,
+        INCIDENT_LIGHT_ANGLE_DEG=incident_light_angle.to_value(u.deg),
+        REFLECTED_LIGHT_ANGLE_DEG=reflected_light_angle.to_value(u.deg),
+        GRATING_CONSTANT_INVERSE_MM=grating_constant.to_value(1 / u.mm),
     )
     init_visp_constants_db(recipe_run_id, constants_db)
     with SolarCalibration(
@@ -125,10 +311,24 @@ def solar_gain_task(
 
 @pytest.mark.parametrize(
     "background_on",
-    [pytest.param(True, id="Background on"), pytest.param(False, id="Background off")],
+    [
+        pytest.param(True, id="background_on"),
+        pytest.param(False, id="background_off"),
+    ],
 )
 def test_solar_gain_task(
-    solar_gain_task, background_on, assign_input_dataset_doc_to_task, mocker, fake_gql_client
+    solar_gain_task,
+    background_on,
+    num_wave_pix,
+    spectral_vignette_function,
+    observed_solar_spectrum,
+    solar_ip_start_time,
+    lens_parameters_no_units,
+    resolving_power,
+    telluric_opacity_factor,
+    assign_input_dataset_doc_to_task,
+    mocker,
+    fake_gql_client,
 ):
     """
     Given: A set of raw solar gain images and necessary intermediate calibrations
@@ -139,23 +339,22 @@ def test_solar_gain_task(
         "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
 
-    # It's way too hard to make data for a unit test that will get through the line zones calculation.
-    # Leave that for grogu.
-    mocker.patch(
-        "dkist_processing_visp.tasks.solar.SolarCalibration.compute_line_zones",
-        return_value=[(4, 7)],
-    )
-
     task, readout_exp_time, num_modstates = solar_gain_task
     dark_signal = 3.0
-    input_shape = (20, 10)
-    intermediate_shape = (10, 10)
+    input_shape = (num_wave_pix * 2, 100)
+    intermediate_shape = (num_wave_pix, 100)
     beam_border = input_shape[0] // 2
     assign_input_dataset_doc_to_task(
         task,
         VispInputDatasetParameterValues(
-            visp_background_on=background_on, visp_beam_border=beam_border
+            visp_background_on=background_on,
+            visp_beam_border=beam_border,
+            visp_wavecal_init_opacity_factor=telluric_opacity_factor,
+            visp_wavecal_init_resolving_power=resolving_power,
+            visp_wavecal_camera_lens_parameters_1=lens_parameters_no_units,
+            visp_solar_vignette_initial_continuum_poly_fit_order=1,
         ),
+        arm_id=1,
     )
     write_intermediate_darks_to_task(
         task=task,
@@ -168,7 +367,8 @@ def test_solar_gain_task(
             task=task, background_signal=0.0, data_shape=intermediate_shape
         )
     write_full_set_of_intermediate_lamp_cals_to_task(
-        task=task, data_shape=intermediate_shape, num_modstates=num_modstates
+        task=task,
+        data_shape=intermediate_shape,
     )
     write_intermediate_geometric_to_task(
         task=task, num_modstates=num_modstates, data_shape=intermediate_shape
@@ -179,43 +379,38 @@ def test_solar_gain_task(
         dark_signal=dark_signal,
         readout_exp_time=readout_exp_time,
         num_modstates=num_modstates,
+        true_solar_signal=observed_solar_spectrum,
+        spectra_vignette_signal=spectral_vignette_function,
     )
 
     task()
     for beam in range(1, task.constants.num_beams + 1):
-        equalization_flux = np.nanmedian(
-            [
-                np.ones(intermediate_shape)
-                * (1 + beam + m)
-                * (10 * beam * m)
-                * np.nanpercentile(
-                    np.arange(1, 11) / 5,
-                    task.parameters.solar_characteristic_spatial_normalization_percentile,
-                )
-                for m in range(1, task.constants.num_modstates + 1)
-            ],
-            axis=0,
+        # We need to multiply by the percentile normalization factor that is divided from the characteristic spectra.
+        # I.e., the `true_solar_signal` defined above is modified by this scalar prior to removal from the raw spectra
+        # so we need to undo that modification here.
+        expected_signal = (
+            np.ones(intermediate_shape)
+            * spectral_vignette_function[:, None]
+            * 10
+            * beam  # Lamp signal
+            * np.nanpercentile(
+                observed_solar_spectrum,
+                task.parameters.solar_characteristic_spatial_normalization_percentile,
+            )
         )
 
-        for modstate in range(1, task.constants.num_modstates + 1):
-            # Gains aren't normalized so their expected value is weird. This expression comes from the math applied above. Sorry.
-            raw = (
-                np.ones(intermediate_shape)
-                * (1 + beam + modstate)
-                * (10 * beam * modstate)
-                * np.mean(np.arange(1, 11) / 5)
+        solar_gain = next(
+            task.read(
+                tags=[
+                    VispTag.intermediate_frame(beam=beam),
+                    VispTag.task_solar_gain(),
+                ],
+                decoder=fits_array_decoder,
             )
-            expected = raw * equalization_flux / np.nanmedian(raw)
-            solar_gain = next(
-                task.read(
-                    tags=[
-                        VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                        VispTag.task_solar_gain(),
-                    ],
-                    decoder=fits_array_decoder,
-                )
-            )
-            np.testing.assert_allclose(expected, solar_gain)
+        )
+
+        # Testing that the ratio is close to 1.0 give us a bit more leeway in the deviation
+        np.testing.assert_allclose(expected_signal / solar_gain, 1.0, atol=1e-2, rtol=1e-2)
 
     quality_files = task.read(tags=[Tag.quality("TASK_TYPES")])
     for file in quality_files:
@@ -226,43 +421,65 @@ def test_solar_gain_task(
                 tags=[VispTag.input(), VispTag.frame(), VispTag.task_solar_gain()]
             )
 
-
-def test_line_zones(solar_gain_task):
-    """
-    Given: A spectrum with some absorption lines
-    When: Computing zones around the lines
-    Then: Correct results are returned
-    """
-
-    # This is here because we mocked it out in the solar gain task test above
-    # NOTE that it does not test for removal of overlapping regions
-    def gaussian(x, amp, mu, sig):
-        return amp * np.exp(-np.power(x - mu, 2.0) / (2 * np.power(sig, 2.0)))
-
-    spec = np.ones(1000) * 100
-    x = np.arange(1000.0)
-    expected = []
-    for m, s in zip([100.0, 300.0, 700], [10.0, 20.0, 5.0]):
-        spec -= gaussian(x, 40, m, s)
-        hwhm = s * 2.355 / 2
-        expected.append((np.floor(m - hwhm).astype(int), np.ceil(m + hwhm).astype(int)))
-
-    task = solar_gain_task[0]
-
-    zones = task.compute_line_zones(spec[:, None], bg_order=0, rel_height=0.5)
-    assert zones == expected
-
-
-def test_identify_overlapping_zones(solar_gain_task):
+    first_vignette_quality_files = list(task.read(tags=[Tag.quality("SOLAR_CAL_FIRST_VIGNETTE")]))
+    assert len(first_vignette_quality_files) == 2
+    for beam_file in first_vignette_quality_files:
+        with asdf.open(beam_file, lazy_load=False, memmap=False) as f:
+            results = f.tree
+            assert isinstance(results["output_wave_vec"], NDArrayType)
+            assert isinstance(results["input_spectrum"], NDArrayType)
+            assert isinstance(results["best_fit_atlas"], NDArrayType)
+            assert isinstance(results["best_fit_continuum"], NDArrayType)
+            assert isinstance(results["residuals"], NDArrayType)
+
+    final_vignette_quality_files = list(task.read(tags=[Tag.quality("SOLAR_CAL_FINAL_VIGNETTE")]))
+    assert len(final_vignette_quality_files) == 2
+    for beam_file in final_vignette_quality_files:
+        with asdf.open(beam_file, lazy_load=False, memmap=False) as f:
+            results = f.tree
+            assert isinstance(results["output_wave_vec"], NDArrayType)
+            assert isinstance(results["median_spec"], NDArrayType)
+            assert isinstance(results["low_deviation"], NDArrayType)
+            assert isinstance(results["high_deviation"], NDArrayType)
+
+
+def test_continuum_wavecal_parameters():
     """
-    Given: A list of zone borders that contain overlapping zones
-    When: Identifying zones that overlap
-    Then: The smaller of the overlapping zones are identified for removal
+    Given: A `WavelengthCalibrationParametersWithContinuum` class instantiated with a poly fit order
+    When: Constructing the `lmfit_parameters` object
+    Then: The polynomial coefficients are present
     """
-    rips = np.array([100, 110, 220, 200])
-    lips = np.array([150, 120, 230, 250])
-
-    task = solar_gain_task[0]
-
-    idx_to_remove = task.identify_overlapping_zones(rips, lips)
-    assert idx_to_remove == [1, 2]
+    order = 3
+    zeroth_order = 6.28
+    param_object = WavelengthCalibrationParametersWithContinuum(
+        continuum_poly_fit_order=order,
+        zeroth_order_continuum_coefficient=zeroth_order,
+        crval=400 * u.nm,
+        dispersion=3 * u.nm / u.pix,
+        incident_light_angle=4 * u.deg,
+        grating_constant=3 / u.mm,
+        doppler_velocity=0 * u.km / u.s,
+        order=1,
+        normalized_abscissa=np.arange(10),
+        continuum_level=99999.9,
+    )
+    lmfit_params = param_object.lmfit_parameters
+
+    assert "poly_coeff_03" in lmfit_params
+    assert "poly_coeff_02" in lmfit_params
+    assert "poly_coeff_01" in lmfit_params
+    assert "poly_coeff_00" in lmfit_params
+
+    assert lmfit_params["poly_coeff_03"].init_value == zeroth_order
+    assert lmfit_params["poly_coeff_02"].init_value == 0
+    assert lmfit_params["poly_coeff_01"].init_value == 0
+    assert lmfit_params["poly_coeff_00"].init_value == 0
+
+    assert lmfit_params["poly_coeff_03"].min == zeroth_order * 0.5
+    assert lmfit_params["poly_coeff_03"].max == zeroth_order * 1.5
+    assert lmfit_params["poly_coeff_02"].min == -1
+    assert lmfit_params["poly_coeff_02"].max == 1
+    assert lmfit_params["poly_coeff_01"].min == -1
+    assert lmfit_params["poly_coeff_01"].max == 1
+    assert lmfit_params["poly_coeff_00"].min == -1
+    assert lmfit_params["poly_coeff_00"].max == 1

dkist_processing_visp/tests/test_visp_constants.py

@@ -1,6 +1,7 @@
 from dataclasses import asdict
 from dataclasses import dataclass
 
+import astropy.units as u
 import pytest
 
 from dkist_processing_visp.tasks.visp_base import VispTaskBase
@@ -8,6 +9,7 @@ from dkist_processing_visp.tasks.visp_base import VispTaskBase
 
 @dataclass
 class testing_constants:
+    arm_id: int = 2
     obs_ip_start_time: str = "1999-12-31T23:59:59"
     num_modstates: int = 10
     num_beams: int = 2
@@ -22,10 +24,23 @@ class testing_constants:
     solar_readout_exp_times: tuple[float] = (2.0,)
     observe_readout_exp_times: tuple[float] = (0.02,)
     retarder_name: str = "SiO2 OC"
+    incident_light_angle_deg: float = 74.2
+    reflected_light_angle_deg: float = 71.3
+    grating_constant_inverse_mm: float = 316.0
+    solar_gain_ip_start_time: str = "2000-01-01T00:00:01"
     # We don't need all the common ones, but let's put one just to check
     instrument: str = "CHECK_OUT_THIS_INSTRUMENT"
 
 
+@pytest.fixture(scope="session")
+def unit_constant_names_and_units() -> dict[str, u.Unit]:
+    return {
+        "incident_light_angle_deg": u.deg,
+        "reflected_light_angle_deg": u.deg,
+        "grating_constant_inverse_mm": 1 / u.mm,
+    }
+
+
 @pytest.fixture(scope="session")
 def expected_constant_dict() -> dict:
     lower_dict = asdict(testing_constants())
@@ -49,14 +64,28 @@ def visp_science_task_with_constants(recipe_run_id, expected_constant_dict, init
     task._purge()
 
 
-def test_visp_constants(visp_science_task_with_constants, expected_constant_dict):
-
+def test_visp_constants(
+    visp_science_task_with_constants, unit_constant_names_and_units, expected_constant_dict
+):
+    """
+    Given: A task with an attached `VispConstants` object and a populated constants db
+    When: Accessing values through the `.constants.VALUE` machinery
+    Then: The correct values form the db are returned
+    """
     task = visp_science_task_with_constants
     for k, v in expected_constant_dict.items():
-        if type(v) is tuple:
-            v = list(v)
-        if k in ["POLARIMETER_MODE", "RETARDER_NAME"]:
+        if k in ["ARM_ID", "POLARIMETER_MODE", "RETARDER_NAME"]:
+            # These have some extra logic after db retrieval
             continue
-        assert getattr(task.constants, k.lower()) == v
+        if k.lower() in unit_constant_names_and_units:
+            united_value = getattr(task.constants, k.lower())
+            assert united_value.value == v
+            assert united_value.unit == unit_constant_names_and_units[k.lower()]
+        else:
+            if type(v) is tuple:
+                v = list(v)
+            assert getattr(task.constants, k.lower()) == v
+
     assert task.constants.correct_for_polarization == True
     assert task.constants.pac_init_set == "OCCal_VIS"
+    assert task.constants.arm_id == str(expected_constant_dict["ARM_ID"])