dkist-processing-cryonirsp 1.9.0__py3-none-any.whl → 1.10.0rc1__py3-none-any.whl

changelog/167.feature.rst

@@ -0,0 +1 @@
+This change pulls the dispersion axis correction out of the Cryonirsp pipeline and uses the generalized solar-wavelength-calibration library.

dkist_processing_cryonirsp/config.py

@@ -1,11 +1,14 @@
 """Configuration for the dkist-processing-cryonirsp package and the logging thereof."""
 from dkist_processing_common.config import DKISTProcessingCommonConfiguration
+from pydantic import Field
 
 
 class DKISTProcessingCryoNIRSPConfigurations(DKISTProcessingCommonConfiguration):
     """Configurations custom to the dkist-processing-cryonirsp package."""
 
-    pass  # nothing custom yet
+    fts_atlas_data_dir: str | None = Field(
+        default=None, description="Common cached directory for a downloaded FTS Atlas."
+    )
 
 
 dkist_processing_cryonirsp_configurations = DKISTProcessingCryoNIRSPConfigurations()

dkist_processing_cryonirsp/models/constants.py

@@ -2,6 +2,7 @@
 from enum import Enum
 from enum import unique
 
+import astropy.units as u
 from dkist_processing_common.models.constants import BudName
 from dkist_processing_common.models.constants import ConstantsBase
 
@@ -54,6 +55,8 @@ class CryonirspBudName(Enum):
     gain_frame_type_list = "GAIN_FRAME_TYPE_LIST"
     lamp_gain_frame_type_list = "LAMP_GAIN_FRAME_TYPE_LIST"
     solar_gain_frame_type_list = "SOLAR_GAIN_FRAME_TYPE_LIST"
+    center_wavelength = "CENTER_WAVELENGTH"
+    slit_width = "SLIT_WIDTH"
 
 
 class CryonirspConstants(ConstantsBase):
@@ -112,10 +115,20 @@ class CryonirspConstants(ConstantsBase):
         """Grating littrow angle (deg)."""
         return self._db_dict[CryonirspBudName.grating_littrow_angle_deg.value]
 
+    @property
+    def center_wavelength(self) -> float:
+        """Center wavelength of the selected filter (nm)."""
+        return self._db_dict[CryonirspBudName.center_wavelength.value]
+
+    @property
+    def slit_width(self) -> float:
+        """Physical width of the selected slit (um)."""
+        return self._db_dict[CryonirspBudName.slit_width.value]
+
     @property
     def grating_constant(self) -> float:
         """Grating constant."""
-        return self._db_dict[CryonirspBudName.grating_constant.value]
+        return self._db_dict[CryonirspBudName.grating_constant.value] / u.mm
 
     @property
     def camera_readout_mode(self) -> str:

dkist_processing_cryonirsp/models/parameters.py

@@ -7,6 +7,7 @@ import numpy as np
 from dkist_processing_common.models.parameters import ParameterArmIdMixin
 from dkist_processing_common.models.parameters import ParameterBase
 from dkist_processing_common.models.parameters import ParameterWavelengthMixin
+from solar_wavelength_calibration import DownloadConfig
 
 from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
 
@@ -267,24 +268,15 @@ class CryonirspParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmI
         """Return the CryoNIRSP pixel pitch."""
         return self._find_most_recent_past_value("cryonirsp_pixel_pitch_micron") * u.micron
 
-    @cached_property
-    def solar_atlas(self) -> np.ndarray:
-        """Solar reference atlas.
-
-        Contains two arrays:
-        - wavelength in nanometers
-        - transmission at given wavelength
-        """
-        param_obj = self._find_most_recent_past_value("cryonirsp_solar_atlas")
-        return self._load_param_value_from_numpy_save(param_obj=param_obj)
+    @property
+    def wavecal_atlas_download_config(self) -> DownloadConfig:
+        """Define the `~solar_wavelength_calibration.DownloadConfig` used to grab the Solar atlas used for wavelength calibration."""
+        config_dict = self._find_most_recent_past_value("cryonirsp_wavecal_atlas_download_config")
+        return DownloadConfig.model_validate(config_dict)
 
     @cached_property
-    def telluric_atlas(self) -> np.ndarray:
-        """Telluric reference atlas.
-
-        Contains two arrays:
-        - wavelength in nanometers
-        - transmission at given wavelength
-        """
-        param_obj = self._find_most_recent_past_value("cryonirsp_telluric_atlas")
-        return self._load_param_value_from_numpy_save(param_obj=param_obj)
+    def wavecal_fraction_of_unweighted_edge_pixels(self) -> int:
+        """Return the fraction of edge pixels to weight to zero during the wavelength calibration."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_wavecal_fraction_of_unweighted_edge_pixels"
+        )

dkist_processing_cryonirsp/parsers/cryonirsp_l0_fits_access.py

@@ -97,8 +97,7 @@ class CryonirspL0FitsAccess(L0FitsAccess):
         )
         self.grating_position_deg: float = self.header["CNGRTPOS"]
         self.grating_littrow_angle_deg: float = self.header["CNGRTLAT"]
-        # grating_constant is in the L0 header in (mm)^(-1) when needed in (m)^(-1) hence multiply by 1000.
-        self.grating_constant: float = self.header["CNGRTCON"] * 1000
+        self.grating_constant: float = self.header["CNGRTCON"]
         self.obs_ip_start_time = self.header["DKIST011"]
         # The ExposureConditions are a combination of the exposure time and the OD filter name:
         self.exposure_conditions = ExposureConditions(
@@ -106,6 +105,8 @@ class CryonirspL0FitsAccess(L0FitsAccess):
             self.header["CNFILTNP"].upper(),
         )
         self.solar_gain_ip_start_time = self.header["DATE-OBS"]
+        self.center_wavelength = self.header["CNCENWAV"]
+        self.slit_width = self.header["CNSLITW"]
 
     @property
     def cn1_scan_step(self):

dkist_processing_cryonirsp/tasks/__init__.py

@@ -11,8 +11,8 @@ from dkist_processing_cryonirsp.tasks.make_movie_frames import *
 from dkist_processing_cryonirsp.tasks.parse import *
 from dkist_processing_cryonirsp.tasks.quality_metrics import *
 from dkist_processing_cryonirsp.tasks.sp_beam_boundaries import *
-from dkist_processing_cryonirsp.tasks.sp_dispersion_axis_correction import *
 from dkist_processing_cryonirsp.tasks.sp_geometric import *
 from dkist_processing_cryonirsp.tasks.sp_science import *
 from dkist_processing_cryonirsp.tasks.sp_solar_gain import *
+from dkist_processing_cryonirsp.tasks.sp_wavelength_calibration import *
 from dkist_processing_cryonirsp.tasks.write_l1 import *

dkist_processing_cryonirsp/tasks/parse.py

@@ -247,21 +247,21 @@ class ParseL0CryonirspSPLinearizedData(ParseL0CryonirspLinearizedData):
             TaskNearFloatBud(
                 constant_name=CryonirspBudName.grating_position_deg.value,
                 metadata_key="grating_position_deg",
-                ip_task_types=TaskName.solar_gain.value,
+                ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
                 task_type_parsing_function=parse_header_ip_task_with_gains,
                 tolerance=0.01,
             ),
             TaskNearFloatBud(
                 constant_name=CryonirspBudName.grating_littrow_angle_deg.value,
                 metadata_key="grating_littrow_angle_deg",
-                ip_task_types=TaskName.solar_gain.value,
+                ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
                 task_type_parsing_function=parse_header_ip_task_with_gains,
                 tolerance=0.01,
             ),
             TaskUniqueBud(
                 constant_name=CryonirspBudName.grating_constant.value,
                 metadata_key="grating_constant",
-                ip_task_types=TaskName.solar_gain.value,
+                ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
                 task_type_parsing_function=parse_header_ip_task_with_gains,
             ),
             TaskUniqueBud(
@@ -276,6 +276,18 @@ class ParseL0CryonirspSPLinearizedData(ParseL0CryonirspLinearizedData):
                 ip_task_types=TaskName.solar_gain.value,
                 task_type_parsing_function=parse_header_ip_task_with_gains,
             ),
+            TaskUniqueBud(
+                constant_name=CryonirspBudName.center_wavelength.value,
+                metadata_key="center_wavelength",
+                ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
+                task_type_parsing_function=parse_header_ip_task_with_gains,
+            ),
+            TaskUniqueBud(
+                constant_name=CryonirspBudName.slit_width.value,
+                metadata_key="slit_width",
+                ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
+                task_type_parsing_function=parse_header_ip_task_with_gains,
+            ),
             CheckLampGainFramesPickyBud(),
             CryonirspTaskExposureConditionsBud(
                 stem_name=CryonirspBudName.lamp_gain_exposure_conditions_list.value,

dkist_processing_cryonirsp/tasks/sp_wavelength_calibration.py

@@ -0,0 +1,300 @@
+"""Cryo SP wavelength calibration task. See :doc:`this page </wavelength_calibration>` for more information."""
+import math
+
+import astropy.units as u
+import numpy as np
+from astropy.time import Time
+from astropy.wcs import WCS
+from dkist_processing_common.codecs.json import json_encoder
+from dkist_processing_common.models.dkist_location import location_of_dkist
+from dkist_service_configuration.logging import logger
+from solar_wavelength_calibration import Atlas
+from solar_wavelength_calibration import WavelengthCalibrationFitter
+from solar_wavelength_calibration.fitter.parameters import AngleBoundRange
+from solar_wavelength_calibration.fitter.parameters import BoundsModel
+from solar_wavelength_calibration.fitter.parameters import DispersionBoundRange
+from solar_wavelength_calibration.fitter.parameters import LengthBoundRange
+from solar_wavelength_calibration.fitter.parameters import UnitlessBoundRange
+from solar_wavelength_calibration.fitter.parameters import WavelengthCalibrationParameters
+from solar_wavelength_calibration.fitter.wavelength_fitter import calculate_initial_crval_guess
+from solar_wavelength_calibration.fitter.wavelength_fitter import WavelengthParameters
+from sunpy.coordinates import HeliocentricInertial
+
+from dkist_processing_cryonirsp.codecs.fits import cryo_fits_array_decoder
+from dkist_processing_cryonirsp.models.tags import CryonirspTag
+from dkist_processing_cryonirsp.tasks.cryonirsp_base import CryonirspTaskBase
+
+__all__ = ["SPWavelengthCalibration"]
+
+
+class SPWavelengthCalibration(CryonirspTaskBase):
+    """Task class for correcting the dispersion axis wavelength values.
+
+    Parameters
+    ----------
+    recipe_run_id : int
+        id of the recipe run used to identify the workflow run this task is part of
+    workflow_name : str
+        name of the workflow to which this instance of the task belongs
+    workflow_version : str
+        version of the workflow to which this instance of the task belongs
+
+    """
+
+    record_provenance = True
+
+    def run(self) -> None:
+        """
+        Run method for the task.
+
+        - Gather 1D characteristic spectrum. This will be the initial spectrum.
+        - Get a header from a solar gain frame for initial wavelength estimation.
+        - Compute the theoretical dispersion, order, and incident light angle.
+        - Compute the input wavelength vector from the spectrum and header.
+        - Get the Doppler velocity and resolving power.
+        - Define fitting bounds and initialize model parameters.
+        - Set and normalize spectral weights, zeroing edges.
+        - Fit the profile using WavelengthCalibrationFitter.
+        - Write fit results to disk.
+
+        Returns
+        -------
+        None
+        """
+        with self.apm_processing_step("Load input spectrum and wavelength"):
+            logger.info("Loading input spectrum")
+            input_spectrum = next(
+                self.read(
+                    tags=[
+                        CryonirspTag.intermediate_frame(beam=1),
+                        CryonirspTag.task_characteristic_spectra(),
+                    ],
+                    decoder=cryo_fits_array_decoder,
+                )
+            )
+
+            logger.info(
+                "Computing instrument specific dispersion, order, and incident light angle."
+            )
+            (
+                dispersion,
+                order,
+                incident_light_angle,
+            ) = self.get_theoretical_dispersion_order_light_angle()
+
+            logger.info("Computing initial wavelength vector.")
+            input_wavelength_vector = self.compute_input_wavelength_vector(
+                spectrum=input_spectrum,
+                dispersion=dispersion,
+                order=order,
+                incident_light_angle=incident_light_angle,
+            )
+
+        # Get the doppler velocity
+        doppler_velocity = self.get_doppler_velocity()
+        logger.info(f"{doppler_velocity = !s}")
+
+        # Get the resolving power
+        resolving_power = self.get_resolving_power()
+        logger.info(f"{resolving_power = }")
+
+        with self.apm_processing_step("Compute brute-force CRVAL initial guess"):
+            atlas = Atlas(config=self.parameters.wavecal_atlas_download_config)
+            crval = calculate_initial_crval_guess(
+                input_wavelength_vector=input_wavelength_vector,
+                input_spectrum=input_spectrum,
+                atlas=atlas,
+                negative_limit=-2 * u.nm,
+                positive_limit=2 * u.nm,
+                num_steps=550,
+            )
+            logger.info(f"{crval = !s}")
+
+        with self.apm_task_step("Set up wavelength fit"):
+            logger.info("Setting bounds")
+            bounds = BoundsModel(
+                crval=LengthBoundRange(min=crval - (5 * u.nm), max=crval + (5 * u.nm)),
+                dispersion=DispersionBoundRange(
+                    min=dispersion - (0.05 * u.nm / u.pix), max=dispersion + (0.05 * u.nm / u.pix)
+                ),
+                incident_light_angle=AngleBoundRange(
+                    min=incident_light_angle - (180 * u.deg),
+                    max=incident_light_angle + (180 * u.deg),
+                ),
+                resolving_power=UnitlessBoundRange(
+                    min=resolving_power - (resolving_power * 0.1),
+                    max=resolving_power + (resolving_power * 0.1),
+                ),
+                opacity_factor=UnitlessBoundRange(min=0.0, max=10.0),
+                straylight_fraction=UnitlessBoundRange(min=0.0, max=0.4),
+            )
+
+            logger.info("Initializing parameters")
+            input_parameters = WavelengthCalibrationParameters(
+                crval=crval,
+                dispersion=dispersion,
+                incident_light_angle=incident_light_angle,
+                resolving_power=resolving_power,
+                opacity_factor=5.0,
+                straylight_fraction=0.2,
+                grating_constant=self.constants.grating_constant,
+                doppler_velocity=doppler_velocity,
+                order=order,
+                bounds=bounds,
+            )
+
+            # Define spectral weights to apply
+            weights = np.ones_like(input_spectrum)
+            # Set edge weights to zero to mitigate flat field artifacts (inner and outer 10% of array)
+            num_pixels = len(weights)
+            weights[: num_pixels // self.parameters.wavecal_fraction_of_unweighted_edge_pixels] = 0
+            weights[-num_pixels // self.parameters.wavecal_fraction_of_unweighted_edge_pixels :] = 0
+
+            fitter = WavelengthCalibrationFitter(
+                input_parameters=input_parameters,
+                atlas=atlas,
+            )
+
+            logger.info(f"Input parameters: {input_parameters.lmfit_parameters.pretty_repr()}")
+
+        with self.apm_processing_step("Run wavelength solution fit"):
+            fit_result = fitter(
+                input_wavelength_vector=input_wavelength_vector,
+                input_spectrum=input_spectrum,
+                spectral_weights=weights,
+            )
+
+        with self.apm_writing_step("Save wavelength solution and quality metrics"):
+            self.write(
+                data=fit_result.wavelength_parameters.to_header(
+                    axis_num=1, add_alternate_keys=True
+                ),
+                tags=[CryonirspTag.task_spectral_fit(), CryonirspTag.intermediate()],
+                encoder=json_encoder,
+            )
+            self.quality_store_wavecal_results(
+                input_wavelength=input_wavelength_vector,
+                input_spectrum=input_spectrum,
+                fit_result=fit_result,
+                weights=weights,
+            )
+
+    def get_theoretical_dispersion_order_light_angle(self) -> tuple[u.Quantity, int, u.Quantity]:
+        # TODO: Make this docstring correct (we use grating constant, not grating spacing) and show calculation of all values.
+        r"""
+        Compute theoretical dispersion, spectral order, and incident light angle.
+
+        The incident light angle, :math:`\alpha`, is computed as
+
+        .. math::
+            \alpha = \phi + \theta_L
+
+        where :math:`\phi`, the grating position, and :math:`\theta_L`, the Littrow angle, come from L0 headers.
+
+        From the grating equation, the spectral order, :math:`m`, is
+
+        .. math::
+            m = \frac{\sin\alpha + \sin\beta}{\sigma\lambda}
+
+        where :math:`\sigma` is the grating constant (lines per mm), :math:`\beta` is the diffracted light angle,
+        and :math:`\lambda` is the wavelength. The wavelength comes from L0 headers and :math:`\beta = \phi - \theta_L`.
+
+        Finally, the linear dispersion (nm / px) is
+
+        .. math::
+            \frac{d\lambda}{dl} = \frac{\mu \cos\beta}{m \sigma f}
+
+        where :math:`\mu` is the detector pixel pitch and :math:`f` is the camera focal length, both of which come from
+        L0 headers.
+        """
+        wavelength = self.constants.wavelength * u.nanometer
+        grating_position_angle_phi = self.constants.grating_position_deg * u.deg
+        grating_littrow_angle_theta = self.constants.grating_littrow_angle_deg * u.deg
+        incident_light_angle = grating_position_angle_phi + grating_littrow_angle_theta
+        beta = grating_position_angle_phi - grating_littrow_angle_theta
+        order = int(
+            (np.sin(incident_light_angle) + np.sin(beta))
+            / (wavelength * self.constants.grating_constant)
+        )
+        camera_mirror_focal_length = self.parameters.camera_mirror_focal_length_mm
+        pixpitch = self.parameters.pixel_pitch_micron
+        linear_disp = (
+            order * (self.constants.grating_constant / np.cos(beta)) * camera_mirror_focal_length
+        )
+        theoretical_dispersion = (pixpitch / linear_disp).to(u.nanometer) / u.pix
+
+        logger.info(f"{theoretical_dispersion = !s}")
+        logger.info(f"{order = }")
+        logger.info(f"{incident_light_angle = !s}")
+
+        return theoretical_dispersion, order, incident_light_angle
+
+    def compute_input_wavelength_vector(
+        self,
+        *,
+        spectrum: np.ndarray,
+        dispersion: u.Quantity,
+        order: int,
+        incident_light_angle: u.Quantity,
+    ) -> u.Quantity:
+        """Compute the expected wavelength vector based on the header information."""
+        num_wave_pix = spectrum.size
+        wavelength_parameters = WavelengthParameters(
+            crpix=num_wave_pix // 2 + 1,
+            crval=self.constants.wavelength,
+            dispersion=dispersion.to_value(u.nm / u.pix),
+            grating_constant=self.constants.grating_constant.to_value(1 / u.mm),
+            order=order,
+            incident_light_angle=incident_light_angle.to_value(u.deg),
+            cunit="nm",
+        )
+        header = wavelength_parameters.to_header(axis_num=1)
+        wcs = WCS(header)
+        input_wavelength_vector = wcs.spectral.pixel_to_world(np.arange(num_wave_pix)).to(u.nm)
+
+        return input_wavelength_vector
+
+    def get_doppler_velocity(self) -> u.Quantity:
+        """Find the speed at which DKIST is moving relative to the Sun's center.
+
+        Positive values refer to when DKIST is moving away from the sun.
+        """
+        coord = location_of_dkist.get_gcrs(obstime=Time(self.constants.solar_gain_ip_start_time))
+        heliocentric_coord = coord.transform_to(
+            HeliocentricInertial(obstime=Time(self.constants.solar_gain_ip_start_time))
+        )
+        obs_vr_kms = heliocentric_coord.d_distance
+        return obs_vr_kms
+
+    def get_resolving_power(self) -> int:
+        """Find the resolving power for the slit and filter center wavelength used during observation."""
+        # Map of (center wavelength) → (slit width) → resolving power
+        resolving_power_map = {1080.0: {175: 39580, 52: 120671}, 1430.0: {175: 42943, 52: 133762}}
+
+        center_wavelength = self.constants.center_wavelength
+        slit_width = self.constants.slit_width
+
+        # Find the closest matching key within tolerance
+        matched_wavelength = next(
+            (
+                key
+                for key in resolving_power_map
+                if math.isclose(center_wavelength, key, abs_tol=10)
+            ),
+            None,
+        )
+
+        if matched_wavelength is None:
+            raise ValueError(
+                f"{center_wavelength} not a valid filter center wavelength. "
+                f"Should be within 10 nm of one of {', '.join(str(k) for k in resolving_power_map)} nm."
+            )
+
+        slit_dict = resolving_power_map[matched_wavelength]
+        if slit_width not in slit_dict:
+            raise ValueError(
+                f"{slit_width} not a valid slit width. "
+                f"Should be one of {', '.join(str(k) for k in slit_dict)} µm."
+            )
+
+        return slit_dict[slit_width]

dkist_processing_cryonirsp/tasks/write_l1.py

@@ -11,7 +11,7 @@ from astropy.coordinates.builtin_frames.altaz import AltAz
 from astropy.coordinates.sky_coordinate import SkyCoord
 from astropy.io import fits
 from astropy.time.core import Time
-from dkist_processing_common.codecs.asdf import asdf_decoder
+from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.models.dkist_location import location_of_dkist
 from dkist_processing_common.models.wavelength import WavelengthRange
 from dkist_processing_common.tasks import WriteL1Frame
@@ -1020,24 +1020,14 @@ class SPWriteL1Frame(CryonirspWriteL1Frame):
 
     @cached_property
     def spectral_fit_results(self) -> dict:
-        """Get the spectral fit results."""
-        fit_dict = next(
+        """Get the spectral fit results from disk."""
+        return next(
             self.read(
-                tags=[CryonirspTag.task_spectral_fit(), CryonirspTag.intermediate()],
-                decoder=asdf_decoder,
+                tags=[CryonirspTag.intermediate(), CryonirspTag.task_spectral_fit()],
+                decoder=json_decoder,
             )
         )
-        del fit_dict["asdf_library"]
-        del fit_dict["history"]
-        return fit_dict
 
     def update_spectral_headers(self, header: fits.Header):
         """Update spectral headers after spectral correction."""
-        for key, value in self.spectral_fit_results.items():
-            # update the headers
-            header[key] = value
-
-        header["CTYPE1"] = "AWAV-GRA"
-        header["CUNIT1"] = "nm"
-        header["CTYPE1A"] = "AWAV-GRA"
-        header["CUNIT1A"] = "nm"
+        header.update(self.spectral_fit_results)

dkist_processing_cryonirsp/tests/conftest.py

@@ -166,7 +166,7 @@ class CryonirspConstantsDb:
         "EXPERID3",
     )
     # These are SP defaults...
-    AXIS_1_TYPE: str = "AWAV"
+    AXIS_1_TYPE: str = "AWAV-GRA"
     AXIS_2_TYPE: str = "HPLT-TAN"
     AXIS_3_TYPE: str = "HPLN-TAN"
     ROI_1_ORIGIN_X: int = 0
@@ -177,6 +177,8 @@ class CryonirspConstantsDb:
     GRATING_LITTROW_ANGLE_DEG: float = -5.5
     GRATING_CONSTANT: float = 31.6
     SOLAR_GAIN_IP_START_TIME: str = "2021-01-01T00:00:00"
+    CENTER_WAVELENGTH: float = 1074.9
+    SLIT_WIDTH: int = 175
 
 
 @pytest.fixture()
@@ -287,8 +289,6 @@ class FileParameter(InputDatasetFilePointer):
 # and in CryonirspTestingParameters.
 LINEARIZATION_THRESHOLDS_CI = "cryonirsp_linearization_thresholds_ci.npy"
 LINEARIZATION_THRESHOLDS_SP = "cryonirsp_linearization_thresholds_sp.npy"
-SOLAR_ATLAS = "cryonirsp_solar_atlas.npy"
-TELLURIC_ATLAS = "cryonirsp_telluric_atlas.npy"
 
 
 def _create_parameter_files(task: WorkflowTaskBase) -> None:
@@ -301,13 +301,6 @@ def _create_parameter_files(task: WorkflowTaskBase) -> None:
         data=thresh, tags=CryonirspTag.parameter(LINEARIZATION_THRESHOLDS_SP), encoder=array_encoder
     )
 
-    # solar and telluric atlases
-    atlas_wavelengths = range(300, 16600)
-    atlas_transmission = np.random.rand(16300)
-    atlas = [atlas_wavelengths, atlas_transmission]
-    task.write(data=atlas, tags=CryonirspTag.parameter(SOLAR_ATLAS), encoder=array_encoder)
-    task.write(data=atlas, tags=CryonirspTag.parameter(TELLURIC_ATLAS), encoder=array_encoder)
-
 
 TestingParameters = TypeVar("TestingParameters", bound="CryonirspTestingParameters")
 
@@ -380,18 +373,18 @@ def cryonirsp_testing_parameters_factory(
         cryonirsp_linearization_optical_density_filter_attenuation_g408: WavelengthParameter = (
             WavelengthParameter(values=(-4.26, -4.26, -4.26, -4.26))
         )
-        cryonirsp_solar_atlas: FileParameter = field(
-            default_factory=lambda: FileParameter(
-                object_key=SOLAR_ATLAS,
-            )
-        )
-        cryonirsp_telluric_atlas: FileParameter = field(
-            default_factory=lambda: FileParameter(
-                object_key=TELLURIC_ATLAS,
-            )
-        )
         cryonirsp_camera_mirror_focal_length_mm: float = 932.0
         cryonirsp_pixel_pitch_micron: float = 18.0
+        cryonirsp_wavecal_atlas_download_config: dict[str, str] = field(
+            default_factory=lambda: {
+                "base_url": "doi:10.5281/zenodo.14646787/",
+                "telluric_reference_atlas_file_name": "telluric_reference_atlas.npy",
+                "telluric_reference_atlas_hash_id": "md5:8db5e12508b293bca3495d81a0747447",
+                "solar_reference_atlas_file_name": "solar_reference_atlas.npy",
+                "solar_reference_atlas_hash_id": "md5:84ab4c50689ef235fe5ed4f7ee905ca0",
+            }
+        )
+        cryonirsp_wavecal_fraction_of_unweighted_edge_pixels: int = 10
 
     return CryonirspTestingParameters
 

dkist_processing_cryonirsp/tests/header_models.py

@@ -374,6 +374,8 @@ class SimpleModulatedHeaders(CryonirspHeaders):
         ),
         start_date: str = "2023-01-01T01:23:45",
         modstate_length_sec: float = 0.5,
+        center_wavelength: float = 1080.0,
+        slit_width: float = 52.0,
     ):
         dataset_shape = (1, *array_shape)
         super().__init__(
@@ -395,9 +397,11 @@ class SimpleModulatedHeaders(CryonirspHeaders):
         self.add_constant_key("CRSP_042", modstate)
         self.add_constant_key("CAM__004", exposure_condition.exposure_time)
         self.add_constant_key("CRSP_048", exposure_condition.filter_name)
+        self.add_constant_key("CRSP_053", center_wavelength)
         self.add_constant_key("CRSP_074", grating_angle_deg)
         self.add_constant_key("CRSP_079", grating_littrow_angle)
         self.add_constant_key("CRSP_077", grating_constant)
+        self.add_constant_key("CRSP_082", slit_width)
         self.add_constant_key("CRVAL1", CRVAL1)
         self.add_constant_key("CRPIX1", CRPIX1)
         self.add_constant_key("CDELT1", CDELT1)
@@ -445,6 +449,8 @@ class ModulatedSolarGainHeaders(SimpleModulatedHeaders):
         modstate_length_sec: float = 0.5,
         num_modstates: int = 1,
         modstate: int = 1,
+        center_wavelength: float = 1080.0,
+        slit_width: float = 52.0,
     ):
         super().__init__(
             num_modstates=num_modstates,
@@ -454,6 +460,8 @@ class ModulatedSolarGainHeaders(SimpleModulatedHeaders):
             exposure_condition=exposure_condition,
             start_date=start_date,
             modstate_length_sec=modstate_length_sec,
+            center_wavelength=center_wavelength,
+            slit_width=slit_width,
         )
 
         self.add_constant_key("PAC__002", "clear")
@@ -565,6 +573,8 @@ class ModulatedObserveHeaders(SimpleModulatedHeaders):
         start_date: str = "2023-01-01T01:23:45",
         modstate_length_sec: float = 0.5,
         meas_num: int = 1,
+        center_wavelength: float = 1080.0,
+        slit_width: float = 52.0,
     ):
         super().__init__(
             num_modstates=num_modstates,
@@ -574,6 +584,8 @@ class ModulatedObserveHeaders(SimpleModulatedHeaders):
             exposure_condition=exposure_condition,
             start_date=start_date,
             modstate_length_sec=modstate_length_sec,
+            center_wavelength=center_wavelength,
+            slit_width=slit_width,
         )
 
         self.num_map_scans = num_map_scans