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

dkist_processing_cryonirsp/__init__.py

@@ -0,0 +1,11 @@
+"""Init."""
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version
+
+from dkist_service_configuration.logging import logger  # first import to set logging.BasicConfig
+
+try:
+    __version__ = version(distribution_name=__name__)
+except PackageNotFoundError:
+    # package is not installed
+    __version__ = "unknown"

dkist_processing_cryonirsp/config.py

@@ -0,0 +1,12 @@
+"""Configuration for the dkist-processing-cryonirsp package and the logging thereof."""
+from dkist_processing_common.config import DKISTProcessingCommonConfiguration
+
+
+class DKISTProcessingCryoNIRSPConfigurations(DKISTProcessingCommonConfiguration):
+    """Configurations custom to the dkist-processing-cryonirsp package."""
+
+    pass  # nothing custom yet
+
+
+dkist_processing_cryonirsp_configurations = DKISTProcessingCryoNIRSPConfigurations()
+dkist_processing_cryonirsp_configurations.log_configurations()

dkist_processing_cryonirsp/models/__init__.py

@@ -0,0 +1 @@
+"""Init."""

dkist_processing_cryonirsp/models/constants.py

@@ -0,0 +1,248 @@
+"""CryoNIRSP additions to common constants."""
+from enum import Enum
+from enum import unique
+
+from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.constants import ConstantsBase
+
+from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
+
+
+@unique
+class CryonirspBudName(Enum):
+    """Names to be used for CryoNIRSP buds."""
+
+    arm_id = "ARM_ID"
+    num_beams = "NUM_BEAMS"
+    num_scan_steps = "NUM_SCAN_STEPS"
+    num_map_scans = "NUM_MAP_SCANS"
+    num_modstates = "NUM_MODSTATES"
+    wavelength = "WAVELENGTH"
+    wave_min = "WAVE_MIN"
+    wave_max = "WAVE_MAX"
+    grating_position_deg = "GRATING_POSITION_DEG"
+    grating_littrow_angle_deg = "GRATING_LITTROW_ANGLE_DEG"
+    grating_constant = "GRATING_CONSTANT"
+    camera_readout_mode = "CAM_READOUT_MODE"
+    num_meas = "NUM_MEAS"
+    time_obs_list = "TIME_OBS_LIST"
+    exposure_conditions_list = "EXPOSURE_CONDITIONS_LIST"
+    dark_frame_exposure_conditions_list = "DARK_FRAME_EXPOSURE_CONDITIONS_LIST"
+    lamp_gain_exposure_conditions_list = "LAMP_GAIN_EXPOSURE_CONDITIONS_LIST"
+    solar_gain_exposure_conditions_list = "SOLAR_GAIN_EXPOSURE_CONDITIONS_LIST"
+    polcal_exposure_conditions_list = "POLCAL_EXPOSURE_CONDITIONS_LIST"
+    observe_exposure_conditions_list = "OBSERVE_EXPOSURE_CONDITIONS_LIST"
+    non_dark_and_non_polcal_task_exposure_conditions_list = (
+        "NON_DARK_AND_NON_POLCAL_TASK_EXPOSURE_CONDITIONS_LIST"
+    )
+    picky_dark_exposure_conditions_list = "PICKY_DARK_EXPOSURE_CONDITIONS_LIST"
+    modulator_spin_mode = "MODULATOR_SPIN_MODE"
+    axis_1_type = "AXIS_1_TYPE"
+    axis_2_type = "AXIS_2_TYPE"
+    axis_3_type = "AXIS_3_TYPE"
+    roi_1_origin_x = "ROI_1_ORIGIN_X"
+    roi_1_origin_y = "ROI_1_ORIGIN_Y"
+    roi_1_size_x = "ROI_1_SIZE_X"
+    roi_1_size_y = "ROI_1_SIZE_Y"
+    optical_density_filter_picky_bud = "OPTICAL_DENSITY_FILTER_PICKY_BUD"
+    solar_gain_ip_start_time = "SOLAR_GAIN_IP_START_TIME"
+
+
+class CryonirspConstants(ConstantsBase):
+    """CryoNIRSP specific constants to add to the common constants."""
+
+    @property
+    def arm_id(self) -> str:
+        """Arm used to record the data, SP or CI."""
+        return self._db_dict[CryonirspBudName.arm_id.value]
+
+    @property
+    def num_beams(self) -> int:
+        """Determine the number of beams present in the data."""
+        if self.arm_id == "SP":
+            return 2
+        else:
+            return 1
+
+    @property
+    def num_scan_steps(self) -> int:
+        """Determine the number of scan steps."""
+        return self._db_dict[CryonirspBudName.num_scan_steps.value]
+
+    @property
+    def num_map_scans(self) -> int:
+        """Determine the number of scan steps."""
+        return self._db_dict[CryonirspBudName.num_map_scans.value]
+
+    @property
+    def wavelength(self) -> float:
+        """Wavelength."""
+        return self._db_dict[CryonirspBudName.wavelength.value]
+
+    @property
+    def wave_min(self) -> float:
+        """Wavelength minimum."""
+        return self._db_dict[CryonirspBudName.wave_min.value]
+
+    @property
+    def wave_max(self) -> float:
+        """Wavelength maximum."""
+        return self._db_dict[CryonirspBudName.wave_max.value]
+
+    @property
+    def solar_gain_ip_start_time(self) -> str:
+        """Solar gain IP start time."""
+        return self._db_dict[CryonirspBudName.solar_gain_ip_start_time.value]
+
+    @property
+    def grating_position_deg(self) -> float:
+        """Grating position angle (deg)."""
+        return self._db_dict[CryonirspBudName.grating_position_deg.value]
+
+    @property
+    def grating_littrow_angle_deg(self) -> float:
+        """Grating littrow angle (deg)."""
+        return self._db_dict[CryonirspBudName.grating_littrow_angle_deg.value]
+
+    @property
+    def grating_constant(self) -> float:
+        """Grating constant."""
+        return self._db_dict[CryonirspBudName.grating_constant.value]
+
+    @property
+    def camera_readout_mode(self) -> str:
+        """Determine the readout mode of the camera."""
+        return self._db_dict[CryonirspBudName.camera_readout_mode.value]
+
+    @property
+    def num_meas(self) -> int:
+        """Determine the number of measurements in dataset."""
+        return self._db_dict[CryonirspBudName.num_meas.value]
+
+    @property
+    def time_obs_list(self) -> tuple[str]:
+        """Construct a sorted tuple of all the dateobs for this dataset."""
+        return self._db_dict[CryonirspBudName.time_obs_list.value]
+
+    @property
+    def exposure_conditions_list(self) -> [ExposureConditions]:
+        """Construct a list of ExposureConditions tuples for the dataset."""
+        raw_conditions: list[list[int, str]] = self._db_dict[
+            CryonirspBudName.exposure_conditions.value
+        ]
+        conditions = [ExposureConditions(*item) for item in raw_conditions]
+        return conditions
+
+    @property
+    def dark_exposure_conditions_list(self) -> [ExposureConditions]:
+        """Construct a list of dark frame ExposureConditions tuples for the dataset."""
+        raw_conditions: list[list[int, str]] = self._db_dict[
+            CryonirspBudName.dark_frame_exposure_conditions_list.value
+        ]
+        conditions = [ExposureConditions(*item) for item in raw_conditions]
+        return conditions
+
+    @property
+    def lamp_gain_exposure_conditions_list(self) -> [ExposureConditions]:
+        """Construct a list of lamp gain ExposureConditions tuples for the dataset."""
+        raw_conditions: list[list[int, str]] = self._db_dict[
+            CryonirspBudName.lamp_gain_exposure_conditions_list.value
+        ]
+        conditions = [ExposureConditions(*item) for item in raw_conditions]
+        return conditions
+
+    @property
+    def solar_gain_exposure_conditions_list(self) -> [ExposureConditions]:
+        """Construct a list of solar gain ExposureConditions tuples for the dataset."""
+        raw_conditions: list[list[int, str]] = self._db_dict[
+            CryonirspBudName.solar_gain_exposure_conditions_list.value
+        ]
+        conditions = [ExposureConditions(*item) for item in raw_conditions]
+        return conditions
+
+    @property
+    def observe_exposure_conditions_list(self) -> [ExposureConditions]:
+        """Construct a list of observe ExposureConditions tuples for the dataset."""
+        raw_conditions: list[list[int, str]] = self._db_dict[
+            CryonirspBudName.observe_exposure_conditions_list.value
+        ]
+        conditions = [ExposureConditions(*item) for item in raw_conditions]
+        return conditions
+
+    @property
+    def polcal_exposure_conditions_list(self) -> [ExposureConditions]:
+        """Construct a list of polcal ExposureConditions tuples for the dataset."""
+        if self.correct_for_polarization:
+            raw_conditions: list[list[int, str]] = self._db_dict[
+                CryonirspBudName.polcal_exposure_conditions_list.value
+            ]
+            conditions = [ExposureConditions(*item) for item in raw_conditions]
+            return conditions
+        else:
+            return []
+
+    @property
+    def non_dark_and_non_polcal_task_exposure_conditions_list(self) -> [ExposureConditions]:
+        """Return a list of all exposure times required for all tasks other than dark and polcal."""
+        raw_conditions: list[list[int, str]] = self._db_dict[
+            CryonirspBudName.non_dark_and_non_polcal_task_exposure_conditions_list.value
+        ]
+        conditions = [ExposureConditions(*item) for item in raw_conditions]
+        return conditions
+
+    @property
+    def num_modstates(self) -> int:
+        """Find the number of modulation states."""
+        return self._db_dict[CryonirspBudName.num_modstates.value]
+
+    @property
+    def num_cs_steps(self) -> int:
+        """Find the number of calibration sequence steps."""
+        return self._db_dict[BudName.num_cs_steps.value]
+
+    @property
+    def stokes_I_list(self) -> [str]:
+        """List containing only the Stokes-I parameter."""
+        return ["I"]
+
+    @property
+    def correct_for_polarization(self) -> bool:
+        """Correct for polarization."""
+        return self.num_modstates > 1 and self._db_dict[
+            CryonirspBudName.modulator_spin_mode.value
+        ] in ["Continuous", "Stepped"]
+
+    @property
+    def axis_1_type(self) -> str:
+        """Find the type of the first array axis."""
+        return self._db_dict[CryonirspBudName.axis_1_type.value]
+
+    @property
+    def axis_2_type(self) -> str:
+        """Find the type of the second array axis."""
+        return self._db_dict[CryonirspBudName.axis_2_type.value]
+
+    @property
+    def axis_3_type(self) -> str:
+        """Find the type of the third array axis."""
+        return self._db_dict[CryonirspBudName.axis_3_type.value]
+
+    @property
+    def roi_1_origin_x(self) -> int:
+        """Get the ROI #1 x origin."""
+        return self._db_dict[CryonirspBudName.roi_1_origin_x.value]
+
+    @property
+    def roi_1_origin_y(self) -> int:
+        """Get the ROI #1 y origin."""
+        return self._db_dict[CryonirspBudName.roi_1_origin_y.value]
+
+    @property
+    def roi_1_size_x(self) -> int:
+        """Get the ROI #1 x size."""
+        return self._db_dict[CryonirspBudName.roi_1_size_x.value]
+
+    @property
+    def roi_1_size_y(self) -> int:
+        """Get the ROI #1 y size."""
+        return self._db_dict[CryonirspBudName.roi_1_size_y.value]

dkist_processing_cryonirsp/models/exposure_conditions.py

@@ -0,0 +1,26 @@
+"""Support classes for exposure conditions."""
+from collections import namedtuple
+from enum import StrEnum
+
+# Number of digits used to round the exposure when creating the ExposureConditions tuple in fits_access
+CRYO_EXP_TIME_ROUND_DIGITS: int = 3
+
+"""Base class to hold a tuple of exposure time and filter name."""
+ExposureConditionsBase = namedtuple("ExposureConditions", ["exposure_time", "filter_name"])
+
+
+class ExposureConditions(ExposureConditionsBase):
+    """Define str to make tags look reasonable."""
+
+    def __str__(self):
+        return f"{self.exposure_time}_{self.filter_name}"
+
+
+class AllowableOpticalDensityFilterNames(StrEnum):
+    """Enum to implement list of allowable Optical Density Filter names."""
+
+    G278 = "G278"
+    G358 = "G358"
+    G408 = "G408"
+    OPEN = "OPEN"
+    NONE = "NONE"

dkist_processing_cryonirsp/models/parameters.py

@@ -0,0 +1,296 @@
+"""CryoNIRSP calibration pipeline parameters."""
+from datetime import datetime
+from functools import cached_property
+
+import astropy.units as u
+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 dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
+
+from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
+
+
+class CryonirspParsingParameters(ParameterBase):
+    """
+    Parameters specifically (and only) for the Parse task.
+
+    Needed because the Parse task doesn't yet know about arm id, wavelength, or obs_ip_start_time, which are all
+    required to initialize the main parameter class.
+    """
+
+    @property
+    def max_cs_step_time_sec(self):
+        """Time window within which CS steps with identical GOS configurations are considered to be the same."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_max_cs_step_time_sec", start_date=datetime.now()
+        )
+
+
+class CryonirspParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmIdMixin):
+    """Put all CryoNIRSP parameters parsed from the input dataset document in a single property."""
+
+    @property
+    def geo_upsample_factor(self) -> int:
+        """Pixel precision (1/upsample_factor) to use during phase matching of beam/modulator images."""
+        return self._find_most_recent_past_value("cryonirsp_geo_upsample_factor")
+
+    @property
+    def geo_max_shift(self) -> int:
+        """Max allowed pixel shift when computing spectral curvature."""
+        return self._find_most_recent_past_value("cryonirsp_geo_max_shift")
+
+    @property
+    def geo_poly_fit_order(self) -> int:
+        """Order of polynomial used to fit spectral shift as a function of slit position."""
+        return self._find_most_recent_past_value("cryonirsp_geo_poly_fit_order")
+
+    @property
+    def geo_long_axis_gradient_displacement(self) -> int:
+        """Number of pixels to shift along the long axis of a strip when computing a gradient."""
+        return self._find_most_recent_past_value("cryonirsp_geo_long_axis_gradient_displacement")
+
+    @property
+    def geo_strip_long_axis_size_fraction(self) -> float:
+        """Fraction of full array size for the long axis of the strips used to find the beam angle."""
+        return self._find_most_recent_past_value("cryonirsp_geo_strip_long_axis_size_fraction")
+
+    @property
+    def geo_strip_short_axis_size_fraction(self) -> float:
+        """Fraction of full array size for the short axis of the strips used to find the beam angle."""
+        return self._find_most_recent_past_value("cryonirsp_geo_strip_short_axis_size_fraction")
+
+    @property
+    def geo_strip_spectral_offset_size_fraction(self) -> float:
+        """Fraction of full spectral size to set as the +/- offset from spectral center for the two strips used to find the beam angle."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_geo_strip_spectral_offset_size_fraction"
+        )
+
+    @property
+    def polcal_num_spectral_bins(self) -> int:
+        """Return Number of demodulation matrices to compute across the entire FOV in the spectral dimension."""
+        return self._find_most_recent_past_value("cryonirsp_polcal_num_spectral_bins")
+
+    @property
+    def polcal_num_spatial_bins(self) -> int:
+        """Return Number of demodulation matrices to compute across the entire FOV in the spatial dimension."""
+        return self._find_most_recent_past_value("cryonirsp_polcal_num_spatial_bins")
+
+    @property
+    def polcal_pac_fit_mode(self):
+        """Name of set of fitting flags to use during PAC Calibration Unit parameter fits."""
+        return self._find_most_recent_past_value("cryonirsp_polcal_pac_fit_mode")
+
+    @property
+    def polcal_pac_init_set(self):
+        """Name of set of initial values for Calibration Unit parameter fit."""
+        return self._find_most_recent_past_value("cryonirsp_polcal_pac_init_set")
+
+    @property
+    def beam_boundaries_smoothing_disk_size(self) -> int:
+        """Return the size of the smoothing disk (in pixels) to be used in the beam boundaries computation."""
+        return self._find_most_recent_past_value("cryonirsp_beam_boundaries_smoothing_disk_size")
+
+    @property
+    def beam_boundaries_upsample_factor(self) -> int:
+        """Return the upsample factor to be used in the beam boundaries cross correlation computation."""
+        return self._find_most_recent_past_value("cryonirsp_beam_boundaries_upsample_factor")
+
+    @property
+    def beam_boundaries_sp_beam_transition_region_size_fraction(self) -> float:
+        """
+        Fraction of full spectral size to use as the size of the transition region between the two SP beams.
+
+        A region with size = (this parameter * full spectral size) and centered at the center of the spectral dimension
+        will be ignored when extracting the beams.
+        """
+        return self._find_most_recent_past_value(
+            "cryonirsp_beam_boundaries_sp_beam_transition_region_size_fraction"
+        )
+
+    @property
+    def bad_pixel_map_median_filter_size(self) -> list[int, int]:
+        """Return the smoothing disk size to be used in the bad pixel map computation."""
+        filter_size = self._find_parameter_for_arm("cryonirsp_bad_pixel_map_median_filter_size")
+        return filter_size
+
+    @property
+    def bad_pixel_map_threshold_factor(self) -> float:
+        """Return the threshold multiplicative factor to be used in the bad pixel map computation."""
+        return self._find_most_recent_past_value("cryonirsp_bad_pixel_map_threshold_factor")
+
+    @property
+    def corrections_bad_pixel_median_filter_size(self) -> int:
+        """Return the size of the median filter to be used for bad pixel correction."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_corrections_bad_pixel_median_filter_size"
+        )
+
+    @cached_property
+    def corrections_bad_pixel_fraction_threshold(self) -> float:
+        """
+        Return the fraction of the bad pixel mask.
+
+        If exceeded, will cause the fallback to a faster but worse algorithm.
+        """
+        return self._find_most_recent_past_value(
+            "cryonirsp_corrections_bad_pixel_fraction_threshold"
+        )
+
+    @cached_property
+    def linearization_thresholds(self) -> np.ndarray:
+        """Name of parameter associated with the linearization thresholds."""
+        param_dict = self._find_parameter_for_arm("cryonirsp_linearization_thresholds")
+        value = self._load_param_value_from_numpy_save(param_dict)
+        # float64 data can blow up the memory required for linearization - convert to float32
+        if np.issubdtype(value.dtype, np.float64):
+            value = value.astype(np.float32, casting="same_kind")
+        return value
+
+    @cached_property
+    def linearization_polyfit_coeffs(self) -> np.ndarray:
+        """Name of parameter associated with the linearization polyfit coefficients."""
+        param_value = self._find_parameter_for_arm("cryonirsp_linearization_polyfit_coeffs")
+        return np.asarray(param_value, dtype=np.float32)
+
+    @cached_property
+    def linearization_max_memory_gb(self) -> float:
+        """Get the maximum amount of memory in GB available to the linearity correction task worker."""
+        mem_size = self._find_most_recent_past_value("cryonirsp_linearization_max_memory_gb")
+        return mem_size
+
+    @property
+    def solar_characteristic_spatial_normalization_percentile(self) -> float:
+        """Percentile to pass to `np.nanpercentile` when normalizing each spatial position of the characteristic spectra."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_solar_characteristic_spatial_normalization_percentile"
+        )
+
+    @property
+    def fringe_correction_on(self) -> bool:
+        """Return True if fringe correction should be performed."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_fringe_correction_on",
+            start_date=self._obs_ip_start_datetime,
+        )
+
+    @property
+    def fringe_correction_spectral_filter_size(self) -> list[int, int]:
+        """Get the filter kernel size for the spectral filtering in the fringe removal process."""
+        return self._find_most_recent_past_value("cryonirsp_fringe_correction_spectral_filter_size")
+
+    @property
+    def fringe_correction_spatial_filter_size(self) -> list[int, int]:
+        """Get the filter kernel size for the spatial filtering in the fringe removal process."""
+        return self._find_most_recent_past_value("cryonirsp_fringe_correction_spatial_filter_size")
+
+    @property
+    def fringe_correction_lowpass_cutoff_period(self) -> float:
+        """Get the lowpass filter cutoff period in pixels for the fringe removal process."""
+        return self._find_most_recent_past_value(
+            "cryonirsp_fringe_correction_lowpass_cutoff_period"
+        )
+
+    @cached_property
+    def linearization_filter_attenuation_dict(self) -> dict:
+        """Return a dict that maps the filter name to its attenuation parameter."""
+        filter_attenuation_dict = {
+            AllowableOpticalDensityFilterNames.G278.value: self._linearization_optical_density_filter_attenuation_g278,
+            AllowableOpticalDensityFilterNames.G358.value: self._linearization_optical_density_filter_attenuation_g358,
+            AllowableOpticalDensityFilterNames.G408.value: self._linearization_optical_density_filter_attenuation_g408,
+            AllowableOpticalDensityFilterNames.OPEN.value: self._linearization_optical_density_filter_attenuation_open,
+            AllowableOpticalDensityFilterNames.NONE.value: self._linearization_optical_density_filter_attenuation_none,
+        }
+        return filter_attenuation_dict
+
+    @cached_property
+    def _linearization_optical_density_filter_attenuation_g278(self) -> float:
+        """Return the attenuation value for the G278 filter."""
+        return self._find_parameter_closest_wavelength(
+            "cryonirsp_linearization_optical_density_filter_attenuation_g278"
+        )
+
+    @cached_property
+    def _linearization_optical_density_filter_attenuation_g358(self) -> float:
+        """Return the attenuation value for the G358 filter."""
+        return self._find_parameter_closest_wavelength(
+            "cryonirsp_linearization_optical_density_filter_attenuation_g358"
+        )
+
+    @cached_property
+    def _linearization_optical_density_filter_attenuation_g408(self) -> float:
+        """Return the attenuation value for the G408 filter."""
+        return self._find_parameter_closest_wavelength(
+            "cryonirsp_linearization_optical_density_filter_attenuation_g408"
+        )
+
+    @cached_property
+    def _linearization_optical_density_filter_attenuation_none(self) -> float:
+        """Return the attenuation value for a filter of 'none'."""
+        return 0.0
+
+    @cached_property
+    def _linearization_optical_density_filter_attenuation_open(self) -> float:
+        """Return the attenuation value for a filter of 'Open'."""
+        return 0.0
+
+    @property
+    def cryo_instrument_alignment_angle(self) -> u.Quantity:
+        """Return the CryoNIRSP instrument alignment angle."""
+        alignment_angle = -91.0 * u.deg
+        return alignment_angle
+
+    @property
+    def ci_spatial_scale_along_slit(self) -> u.Quantity:
+        """Return the CryoNIRSP CI spatial scale along the slit."""
+        spatial_scale_along_slit = 0.05308 * u.arcsec / u.pix
+        return spatial_scale_along_slit
+
+    @property
+    def sp_spatial_scale_along_slit(self) -> u.Quantity:
+        """Return the CryoNIRSP SP spatial scale along the slit."""
+        spatial_scale_along_slit = 0.12 * u.arcsec / u.pix
+        return spatial_scale_along_slit
+
+    @property
+    def mirror_scan_recalibration_constant(self) -> float:
+        """Return the CryoNIRSP mirror scan recalibration constant."""
+        mirror_scan_recalibration_constant = 0.466 / 0.5
+        return mirror_scan_recalibration_constant
+
+    @property
+    def camera_mirror_focal_length_mm(self) -> u.Quantity:
+        """Return the CryoNIRSP camera mirror focal length."""
+        return (
+            self._find_most_recent_past_value("cryonirsp_camera_mirror_focal_length_mm")
+            * u.millimeter
+        )
+
+    @property
+    def pixel_pitch_micron(self) -> u.Quantity:
+        """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_dict = self._find_most_recent_past_value("cryonirsp_solar_atlas")
+        return self._load_param_value_from_numpy_save(param_dict)
+
+    @cached_property
+    def telluric_atlas(self) -> np.ndarray:
+        """Telluric reference atlas.
+
+        Contains two arrays:
+        - wavelength in nanometers
+        - transmission at given wavelength
+        """
+        param_dict = self._find_most_recent_past_value("cryonirsp_telluric_atlas")
+        return self._load_param_value_from_numpy_save(param_dict)