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

dkist_processing_cryonirsp/models/tags.py

@@ -0,0 +1,168 @@
+"""CryoNIRSP tags."""
+from enum import Enum
+
+from dkist_processing_common.models.tags import StemName
+from dkist_processing_common.models.tags import Tag
+
+from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
+from dkist_processing_cryonirsp.models.task_name import CryonirspTaskName
+
+
+class CryonirspStemName(str, Enum):
+    """Controlled list of Tag Stems."""
+
+    linearized = "LINEARIZED"
+    beam = "BEAM"
+    scan_step = "SCAN_STEP"
+    curr_frame_in_ramp = "CURR_FRAME_IN_RAMP"
+    time_obs = "TIME_OBS"
+    meas_num = "MEAS_NUM"
+    map_scan = "MAP_SCAN"
+    exposure_conditions = "EXPOSURE_CONDITIONS"
+
+
+class CryonirspTag(Tag):
+    """CryoNIRSP specific tag formatting."""
+
+    @classmethod
+    def beam(cls, beam_num: int) -> str:
+        """
+        Tags by beam number.
+
+        Parameters
+        ----------
+        beam_num
+            The beam number
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(CryonirspStemName.beam, beam_num)
+
+    @classmethod
+    def scan_step(cls, scan_step: int) -> str:
+        """
+        Tags by the current scan step number.
+
+        Parameters
+        ----------
+        scan_step
+            The current scan step number
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(CryonirspStemName.scan_step, scan_step)
+
+    @classmethod
+    def map_scan(cls, map_scan: int) -> str:
+        """
+        Tags by the current scan step number.
+
+        Parameters
+        ----------
+        map_scan
+            The current map_scan number
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(CryonirspStemName.map_scan, map_scan)
+
+    @classmethod
+    def linearized(cls) -> str:
+        """
+        Tags for linearized frames.
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(CryonirspStemName.linearized)
+
+    @classmethod
+    def curr_frame_in_ramp(cls, curr_frame_in_ramp: int) -> str:
+        """
+        Tags based on the current frame number in the ramp.
+
+        Parameters
+        ----------
+        curr_frame_in_ramp
+            The current frame number for this ramp
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(CryonirspStemName.curr_frame_in_ramp, curr_frame_in_ramp)
+
+    @classmethod
+    def time_obs(cls, time_obs: str) -> str:
+        """
+        Tags by the observe date.
+
+        Parameters
+        ----------
+        time_obs
+            The observe time
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(CryonirspStemName.time_obs, time_obs)
+
+    @classmethod
+    def meas_num(cls, meas_num: int) -> str:
+        """
+        Tags by the measurement number.
+
+        Parameters
+        ----------
+        meas_num
+            The current measurement number
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(CryonirspStemName.meas_num, meas_num)
+
+    @classmethod
+    def exposure_conditions(cls, exposure_conditions: ExposureConditions) -> str:
+        """
+        Tags by the measurement number.
+
+        Parameters
+        ----------
+        exposure_conditions
+            A tuple of (exposure time, filter name)
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(CryonirspStemName.exposure_conditions, exposure_conditions)
+
+    @classmethod
+    def task_beam_boundaries(cls) -> str:
+        """Tags intermediate beam boundary calibration objects."""
+        return cls.format_tag(StemName.task, CryonirspTaskName.beam_boundaries.value)
+
+    @classmethod
+    def task_bad_pixel_map(cls) -> str:
+        """Tags intermediate bad pixel map objects."""
+        return cls.format_tag(StemName.task, CryonirspTaskName.bad_pixel_map.value)
+
+    @classmethod
+    def task_spectral_fit(cls) -> str:
+        """Tags spectral fit solution."""
+        return cls.format_tag(StemName.task, CryonirspTaskName.spectral_fit.value)
+
+    @classmethod
+    def task_characteristic_spectra(cls) -> str:
+        """Tags 1D intermediate characteristic spectra."""
+        return cls.format_tag(StemName.task, CryonirspTaskName.solar_char_spec.value)

dkist_processing_cryonirsp/models/task_name.py

@@ -0,0 +1,14 @@
+"""List of intermediate task names."""
+from enum import Enum
+
+
+class CryonirspTaskName(str, Enum):
+    """Controlled list of CryoNirsp task tag names."""
+
+    beam_boundaries = "BEAM_BOUNDARIES"
+    bad_pixel_map = "BAD_PIXEL_MAP"
+    polcal_dark = "POLCAL_DARK"
+    polcal_gain = "POLCAL_GAIN"
+    spectral_corrected_solar_array = "SPECTRAL_CORRECTED_SOLAR_ARRAY"
+    spectral_fit = "SPECTRAL_FIT"
+    solar_char_spec = "SOLAR_CHAR_SPEC"

dkist_processing_cryonirsp/parsers/__init__.py

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

dkist_processing_cryonirsp/parsers/cryonirsp_l0_fits_access.py

@@ -0,0 +1,111 @@
+"""CryoNIRSP FITS access for L0 data."""
+from astropy.io import fits
+from dkist_processing_common.parsers.l0_fits_access import L0FitsAccess
+
+from dkist_processing_cryonirsp.models.exposure_conditions import CRYO_EXP_TIME_ROUND_DIGITS
+from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
+
+
+class CryonirspRampFitsAccess(L0FitsAccess):
+    """
+    Class to provide easy access to L0 headers for non-linearized (raw) CryoNIRSP data.
+
+    i.e. instead of <CryonirspL0FitsAccess>.header['key'] this class lets us use <CryonirspL0FitsAccess>.key instead
+
+    Parameters
+    ----------
+    hdu :
+        Fits L0 header object
+
+    name : str
+        The name of the file that was loaded into this FitsAccess object
+
+    auto_squeeze : bool
+        When set to True, dimensions of length 1 will be removed from the array
+    """
+
+    def __init__(
+        self,
+        hdu: fits.ImageHDU | fits.PrimaryHDU | fits.CompImageHDU,
+        name: str | None = None,
+        auto_squeeze: bool = True,
+    ):
+        super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
+
+        self.camera_readout_mode = self.header["CNCAMMD"]
+        self.curr_frame_in_ramp: int = self.header["CNCNDR"]
+        self.num_frames_in_ramp: int = self.header["CNNNDR"]
+        self.arm_id: str = self.header["CNARMID"]
+        self.filter_name = self.header["CNFILTNP"].upper()
+        self.roi_1_origin_x = self.header["HWROI1OX"]
+        self.roi_1_origin_y = self.header["HWROI1OY"]
+        self.roi_1_size_x = self.header["HWROI1SX"]
+        self.roi_1_size_y = self.header["HWROI1SY"]
+        self.obs_ip_start_time = self.header["DKIST011"]
+
+
+class CryonirspL0FitsAccess(L0FitsAccess):
+    """
+    Class to provide easy access to L0 headers for linearized (ready for processing) CryoNIRSP data.
+
+    i.e. instead of <CryonirspL0FitsAccess>.header['key'] this class lets us use <CryonirspL0FitsAccess>.key instead
+
+    Parameters
+    ----------
+    hdu :
+        Fits L0 header object
+
+    name : str
+        The name of the file that was loaded into this FitsAccess object
+
+    auto_squeeze : bool
+        When set to True, dimensions of length 1 will be removed from the array
+    """
+
+    def __init__(
+        self,
+        hdu: fits.ImageHDU | fits.PrimaryHDU | fits.CompImageHDU,
+        name: str | None = None,
+        auto_squeeze: bool = True,
+    ):
+        super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)
+
+        self.arm_id: str = self.header["CNARMID"]
+        self.number_of_modulator_states: int = self.header["CNMODNST"]
+        self.modulator_state: int = self.header["CNMODCST"]
+        self.scan_step: int = self.header["CNCURSCN"]
+        self.num_scan_steps: int = self.header["CNNUMSCN"]
+        self.num_cn1_scan_steps: int = self.header["CNP1DNSP"]
+        self.num_cn2_scan_steps: int = self.header["CNP2DNSP"]
+        self.cn2_step_size: float = self.header["CNP2DSS"]
+        self.meas_num: int = self.header["CNCMEAS"]
+        self.num_meas: int = self.header["CNNMEAS"]
+        self.sub_repeat_num = self.header["CNCSREP"]
+        self.num_sub_repeats: int = self.header["CNSUBREP"]
+        self.modulator_spin_mode: str = self.header["CNSPINMD"]
+        self.axis_1_type: str = self.header["CTYPE1"]
+        self.axis_2_type: str = self.header["CTYPE2"]
+        self.axis_3_type: str = self.header["CTYPE3"]
+        self.wave_min: float = round(
+            self.header["CRVAL1"] - (self.header["CRPIX1"] * self.header["CDELT1"]), 1
+        )
+        self.wave_max: float = round(
+            self.header["CRVAL1"]
+            + ((self.header["NAXIS1"] - self.header["CRPIX1"]) * self.header["CDELT1"]),
+            1,
+        )
+        self.grating_position_deg: float = self.header["CNGRTPOS"]
+        self.grating_littrow_angle_deg: float = self.header["CNGRTLAT"]
+        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(
+            round(self.fpa_exposure_time_ms, CRYO_EXP_TIME_ROUND_DIGITS),
+            self.header["CNFILTNP"].upper(),
+        )
+        self.solar_gain_ip_start_time = self.header["DATE-OBS"]
+
+    @property
+    def cn1_scan_step(self):
+        """Convert the inner loop step number from float to int."""
+        return int(self.header["CNP1DCUR"])

dkist_processing_cryonirsp/parsers/cryonirsp_l1_fits_access.py

@@ -0,0 +1,30 @@
+"""CryoNIRSP FITS access for L1 data."""
+from astropy.io import fits
+from dkist_processing_common.parsers.l1_fits_access import L1FitsAccess
+
+
+class CryonirspL1FitsAccess(L1FitsAccess):
+    """
+    Class to provide easy access to L1 headers.
+
+    i.e. instead of <CryonirspL1FitsAccess>.header['key'] this class lets us use <CryonirspL1FitsAccess>.key instead
+
+    Parameters
+    ----------
+    hdu :
+        Fits L1 header object
+
+    name : str
+        The name of the file that was loaded into this FitsAccess object
+
+    auto_squeeze : bool
+        When set to True, dimensions of length 1 will be removed from the array
+    """
+
+    def __init__(
+        self,
+        hdu: fits.ImageHDU | fits.PrimaryHDU | fits.CompImageHDU,
+        name: str | None = None,
+        auto_squeeze: bool | None = True,
+    ):
+        super().__init__(hdu=hdu, name=name, auto_squeeze=auto_squeeze)

dkist_processing_cryonirsp/parsers/exposure_conditions.py

@@ -0,0 +1,163 @@
+"""Buds to parse the combination of exposure time and filter name."""
+from collections import namedtuple
+from typing import Hashable
+from typing import Type
+
+from dkist_processing_common.models.flower_pot import SpilledDirt
+from dkist_processing_common.models.flower_pot import Stem
+from dkist_processing_common.models.flower_pot import Thorn
+from dkist_processing_common.models.task_name import TaskName
+from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
+
+from dkist_processing_cryonirsp.models.constants import CryonirspBudName
+from dkist_processing_cryonirsp.models.exposure_conditions import ExposureConditions
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
+
+_DARK_AND_POLCAL_TASK_TYPES = (TaskName.dark.value, TaskName.polcal.value)
+
+
+class CryonirspTaskExposureConditionsBud(Stem):
+    """
+    Bud to allow custom parsing of exposure conditions based on ip task type.
+
+    Parameters
+    ----------
+    stem_name : str
+        The name of the stem of the tag
+    ip_task_type : str
+        Instrument program task type
+    """
+
+    def __init__(self, stem_name: str, ip_task_type: str):
+        super().__init__(stem_name=stem_name)
+        self.metadata_key = "exposure_conditions"
+        self.ip_task_type = ip_task_type
+
+    def setter(self, fits_obj: CryonirspL0FitsAccess):
+        """
+        Set the value of the bud.
+
+        Parameters
+        ----------
+        fits_obj:
+            A single FitsAccess object
+        """
+        ip_task_type = parse_header_ip_task_with_gains(fits_obj)
+        if ip_task_type.lower() == self.ip_task_type.lower():
+            return getattr(fits_obj, self.metadata_key)
+        return SpilledDirt
+
+    def getter(self, key: Hashable) -> tuple[ExposureConditions, ...]:
+        """Return a list of the ExposureConditions for this ip task type."""
+        exposure_conditions_tuple = tuple(sorted(set(self.key_to_petal_dict.values())))
+        return exposure_conditions_tuple
+
+
+class CryonirspNonDarkAndNonPolcalTaskExposureConditionsBud(Stem):
+    """For ip task types that are neither DARK nor POLCAL, produce a list of exposure conditions tuples."""
+
+    def __init__(self):
+        super().__init__(
+            stem_name=CryonirspBudName.non_dark_and_non_polcal_task_exposure_conditions_list.value
+        )
+        self.metadata_key = "exposure_conditions"
+
+    def setter(self, fits_obj: CryonirspL0FitsAccess) -> ExposureConditions | Type[SpilledDirt]:
+        """
+        Set the task exposure conditions tuple for this fits object.
+
+        Parameters
+        ----------
+        fits_obj
+            The input fits object
+        Returns
+        -------
+        The exposure time associated with this fits object
+        """
+        if fits_obj.ip_task_type.upper() not in _DARK_AND_POLCAL_TASK_TYPES:
+            return getattr(fits_obj, self.metadata_key)
+        return SpilledDirt
+
+    def getter(self, key: Hashable) -> tuple[ExposureConditions, ...]:
+        """
+        Get the list of exposure conditions tuples.
+
+        Parameters
+        ----------
+        key
+            The input key
+
+        Returns
+        -------
+        A tuple of (exposure time, filter name) tuples
+        """
+        exposure_conditions_tuple = tuple(sorted(set(self.key_to_petal_dict.values())))
+        return exposure_conditions_tuple
+
+
+class CryonirspPickyDarkExposureConditionsBud(Stem):
+    """Parse exposure conditions tuples to ensure existence of dark frames with the required exposure conditions."""
+
+    DarkTaskTestAndExposureConditions = namedtuple(
+        "DarkTaskTestAndExposureConditions", ["is_dark", "exposure_conditions"]
+    )
+
+    def __init__(self):
+        super().__init__(stem_name=CryonirspBudName.picky_dark_exposure_conditions_list.value)
+        self.metadata_key = "exposure_conditions"
+
+    def setter(self, fits_obj: CryonirspL0FitsAccess) -> tuple | Type[SpilledDirt]:
+        """
+        Set the task exposure conditions tuple and whether it is a DARK task for this fits object.
+
+        Parameters
+        ----------
+        fits_obj
+            The input fits object
+        Returns
+        -------
+        A tuple of a boolean indicating if the task is a dark task, and the exposure conditions for this fits object
+        """
+        if fits_obj.ip_task_type.upper() == TaskName.dark.value:
+            return self.DarkTaskTestAndExposureConditions(
+                is_dark=True, exposure_conditions=getattr(fits_obj, self.metadata_key)
+            )
+        if fits_obj.ip_task_type.upper() not in _DARK_AND_POLCAL_TASK_TYPES:
+            return self.DarkTaskTestAndExposureConditions(
+                is_dark=False, exposure_conditions=getattr(fits_obj, self.metadata_key)
+            )
+            # Polcal falls through
+        return SpilledDirt
+
+    def getter(self, key: Hashable) -> Type[Thorn]:
+        """
+        Parse all exposure conditions and raise an error if any non-dark exposure condition is missing from the set of dark exposure conditions.
+
+        Parameters
+        ----------
+        key
+            The input key
+
+        Returns
+        -------
+        Thorn
+        """
+        dark_task_test_and_exposure_conditions_set = set(self.key_to_petal_dict.values())
+        dark_exposure_conditions_set = {
+            item.exposure_conditions
+            for item in dark_task_test_and_exposure_conditions_set
+            if item.is_dark
+        }
+        other_exposure_conditions_set = {
+            item.exposure_conditions
+            for item in dark_task_test_and_exposure_conditions_set
+            if not item.is_dark
+        }
+        other_exposure_conditions_missing_from_dark_exposure_conditions = (
+            other_exposure_conditions_set - dark_exposure_conditions_set
+        )
+        if other_exposure_conditions_missing_from_dark_exposure_conditions:
+            raise ValueError(
+                f"Exposure conditions required in the set of dark frames not found. Missing conditions = {other_exposure_conditions_missing_from_dark_exposure_conditions}"
+            )
+        return Thorn

dkist_processing_cryonirsp/parsers/map_repeats.py

@@ -0,0 +1,40 @@
+"""Stems for organizing files into separate dsps repeats."""
+from dkist_processing_cryonirsp.models.constants import CryonirspBudName
+from dkist_processing_cryonirsp.models.tags import CryonirspStemName
+from dkist_processing_cryonirsp.parsers.scan_step import MapScanStepStemBase
+
+
+class MapScanFlower(MapScanStepStemBase):
+    """Flower for computing and assigning map scan numbers."""
+
+    def __init__(self):
+        super().__init__(stem_name=CryonirspStemName.map_scan.value)
+
+    def getter(self, key: str) -> int:
+        """Compute the map scan number for a single frame.
+
+        The frame implies a SingleScanStep. That object is then compared to the sorted list of objects for a single
+        (raster_step, meas_num, modstate, sub_repeat) tuple. The location within that sorted list is the map scan number.
+        """
+        return self.get_map_scan_for_key(key)
+
+
+class NumMapScansBud(MapScanStepStemBase):
+    """
+    Bud for determining the total number of dsps repeats.
+
+    Also checks that all scan steps have the same number of dsps repeats.
+    """
+
+    def __init__(self):
+        super().__init__(stem_name=CryonirspBudName.num_map_scans.value)
+
+    def getter(self, key: str) -> int:
+        """
+        Compute the total number of dsps repeats.
+
+        The number of map_scans for every scan step are calculated and if a map_scan is incomplete,
+        it will not be included.
+        Assumes the incomplete map_scan is always the last one due to summit abort or cancellation.
+        """
+        return self.number_of_complete_map_scans

dkist_processing_cryonirsp/parsers/measurements.py

@@ -0,0 +1,55 @@
+"""Copies of UniqueBud and SingleValueSingleKeyFlower from common that only activate if the frames are "observe" task."""
+from typing import Type
+
+from dkist_processing_common.models.flower_pot import SpilledDirt
+from dkist_processing_common.parsers.single_value_single_key_flower import (
+    SingleValueSingleKeyFlower,
+)
+from dkist_processing_common.parsers.unique_bud import UniqueBud
+
+from dkist_processing_cryonirsp.models.constants import CryonirspBudName
+from dkist_processing_cryonirsp.models.tags import CryonirspStemName
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
+
+
+class NumberOfMeasurementsBud(UniqueBud):
+    """Bud for finding the total number of measurements per scan step."""
+
+    def __init__(self):
+        self.metadata_key = "num_meas"
+        super().__init__(
+            constant_name=CryonirspBudName.num_meas.value, metadata_key=self.metadata_key
+        )
+
+    def setter(self, fits_obj: CryonirspL0FitsAccess) -> Type[SpilledDirt] | int:
+        """
+        Setter for the bud.
+
+        Parameters
+        ----------
+        fits_obj:
+            A single FitsAccess object
+        """
+        if fits_obj.ip_task_type != "observe":
+            return SpilledDirt
+        return getattr(fits_obj, self.metadata_key)
+
+
+class MeasurementNumberFlower(SingleValueSingleKeyFlower):
+    """Flower for a measurement number."""
+
+    def __init__(self):
+        super().__init__(tag_stem_name=CryonirspStemName.meas_num.value, metadata_key="meas_num")
+
+    def setter(self, fits_obj: CryonirspL0FitsAccess) -> Type[SpilledDirt] | int:
+        """
+        Setter for a flower.
+
+        Parameters
+        ----------
+        fits_obj:
+            A single FitsAccess object
+        """
+        if fits_obj.ip_task_type != "observe":
+            return SpilledDirt
+        return super().setter(fits_obj)

dkist_processing_cryonirsp/parsers/modstates.py

@@ -0,0 +1,31 @@
+"""Copy of SingleValueSingleKeyFlower from common that only activates if the frames are "observe" task."""
+from typing import Type
+
+from dkist_processing_common.models.flower_pot import SpilledDirt
+from dkist_processing_common.models.tags import StemName
+from dkist_processing_common.parsers.single_value_single_key_flower import (
+    SingleValueSingleKeyFlower,
+)
+
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspL0FitsAccess
+
+
+class ModstateNumberFlower(SingleValueSingleKeyFlower):
+    """Flower for a modstate number."""
+
+    def __init__(self):
+        super().__init__(tag_stem_name=StemName.modstate.value, metadata_key="modulator_state")
+
+    def setter(self, fits_obj: CryonirspL0FitsAccess) -> Type[SpilledDirt] | int:
+        """
+        Setter for a flower.
+
+        Parameters
+        ----------
+        fits_obj:
+            A single FitsAccess object
+        """
+        # Some intensity data incorrectly has modulator state = 0
+        if getattr(fits_obj, self.metadata_key) == 0:
+            return 1
+        return super().setter(fits_obj)

dkist_processing_cryonirsp/parsers/optical_density_filters.py

@@ -0,0 +1,40 @@
+"""PickyBud to implement early parsing of Optical Density Filter Names."""
+from typing import Hashable
+
+from dkist_processing_common.models.flower_pot import Stem
+from dkist_processing_common.models.flower_pot import Thorn
+
+from dkist_processing_cryonirsp.models.exposure_conditions import AllowableOpticalDensityFilterNames
+from dkist_processing_cryonirsp.parsers.cryonirsp_l0_fits_access import CryonirspRampFitsAccess
+
+ALLOWABLE_OPTICAL_DENSITY_FILTERS = {f for f in AllowableOpticalDensityFilterNames}
+
+
+class OpticalDensityFiltersPickyBud(Stem):
+    """PickyBud to implement early parsing of Optical Density Filter Names."""
+
+    def __init__(self):
+        super().__init__(stem_name="OpticalDensityFilterNamePickyBud")
+
+    def setter(self, fits_obj: CryonirspRampFitsAccess):
+        """
+        Set the optical density filter name for this fits object.
+
+        Parameters
+        ----------
+        fits_obj
+            The input fits obj
+
+        Returns
+        -------
+        The optical density filter name associated with this fits object
+        """
+        return fits_obj.filter_name.upper()
+
+    def getter(self, key: Hashable) -> Thorn:
+        """Return a Thorn for valid names or raise an exception for bad names."""
+        filter_names = set(self.key_to_petal_dict.values())
+        bad_filter_names = filter_names.difference(ALLOWABLE_OPTICAL_DENSITY_FILTERS)
+        if bad_filter_names:
+            raise ValueError(f"Unknown Optical Density Filter Name(s): {bad_filter_names = }")
+        return Thorn