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

dkist_processing_trend/__init__.py

@@ -0,0 +1,10 @@
+"""Package providing support classes and methods used by all workflow tasks."""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version
+
+try:
+    __version__ = version(distribution_name=__name__)
+except PackageNotFoundError:
+    # package is not installed
+    __version__ = "unknown"

dkist_processing_trend/config.py

@@ -0,0 +1,11 @@
+"""Configuration for the dkist-processing-trend package and logging thereof."""
+
+from dkist_processing_common.config import DKISTProcessingCommonConfiguration
+
+
+class DKISTProcessingTrendConfigurations(DKISTProcessingCommonConfiguration):
+    """Configurations custom to the dkist-processing-trend package."""
+
+
+dkist_processing_trend_configurations = DKISTProcessingTrendConfigurations()
+dkist_processing_trend_configurations.log_configurations(log_parent_configurations=False)

dkist_processing_trend/models/__init__.py

@@ -0,0 +1 @@
+"""Objects containing controlled values and logic used by the rest of the pipeline."""

dkist_processing_trend/models/constants.py

@@ -0,0 +1,143 @@
+"""Trend specific parsed constants and controlled name enums."""
+
+import json
+from enum import StrEnum
+from typing import Any
+
+from dkist_processing_common.models.constants import ConstantsBase
+
+
+class TrendBudName(StrEnum):
+    """Names to be used for Trend buds."""
+
+    earliest_ip_start_time = "EARLIEST_IP_START_TIME"
+    arm_id_list = "ARM_ID_LIST"
+    wavelength_for_arm = "WAVELENGTH_FOR_ARM"
+    observing_program_id_list = "OBSERVING_PROGRAM_ID_LIST"
+    experiment_id_list = "EXPERIMENT_ID_LIST"
+    proposal_id_list = "PROPOSAL_ID_LIST"
+    hls_version_list = "HLS_VERSION_LIST"
+    visp_grating_angle_for_arm = "VISP_GRATING_ANGLE_FOR_ARM"
+    visp_arm_position_for_arm = "VISP_ARM_POSITION_FOR_ARM"
+    visp_grating_constant_for_arm = "VISP_GRATING_CONSTANT_FOR_ARM"
+    cryonirsp_od_filter_name_for_arm = "CRYONIRSP_OD_FILTER_NAME_FOR_ARM"
+    cryonirsp_grating_angle_for_arm = "CRYONIRSP_GRATING_ANGLE_FOR_ARM"
+    cryonirsp_grating_littrow_angle_for_arm = "CRYONIRSP_GRATING_LITTROW_ANGLE_FOR_ARM"
+    cryonirsp_grating_constant_for_arm = "CRYONIRSP_GRATING_CONSTANT_FOR_ARM"
+    cryonirsp_slit_width_for_arm = "CRYONIRSP_SLIT_WIDTH_FOR_ARM"
+    dlnirsp_grating_angle_for_arm = "DLNIRSP_GRATING_ANGLE_FOR_ARM"
+    dlnirsp_arm_position_for_arm = "DLNIRSP_ARM_POSITION_FOR_ARM"
+    dlnirsp_grating_constant_for_arm = "DLNIRSP_GRATING_CONSTANT_FOR_ARM"
+
+
+def _unjsonify_dict_keys(input_dict: dict[str, Any]) -> dict[str | int, Any]:
+    """Apply `json.loads` to the keys of the input dictionary."""
+    return {json.loads(k): v for k, v in input_dict.items()}
+
+
+class TrendConstants(ConstantsBase):
+    """Trend specific constants to add to the common constants."""
+
+    @property
+    def earliest_ip_start_time(self) -> str:
+        """Return the start time of the earliest IP in the input data."""
+        return self._db_dict[TrendBudName.earliest_ip_start_time]
+
+    @property
+    def arm_id_list(self) -> list[str | int]:
+        """List of all instrument arms represented in the input data."""
+        return self._db_dict[TrendBudName.arm_id_list]
+
+    @property
+    def wavelength_for_arm(self) -> dict[str | int, float]:
+        """Return a dictionary whose keys are arm_id and value is the associated wavelength."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.wavelength_for_arm])
+
+    @property
+    def observing_program_id_list(self) -> list[str]:
+        """Sorted list of OP IDs, ordered by frequency in the input data."""
+        return self._db_dict[TrendBudName.observing_program_id_list]
+
+    @property
+    def experiment_id_list(self) -> list[str]:
+        """Sorted list of experiment IDs, ordered by frequency in the input data."""
+        return self._db_dict[TrendBudName.experiment_id_list]
+
+    @property
+    def proposal_id_list(self) -> list[str]:
+        """Sorted list of proposal IDs, ordered by frequency in the input data."""
+        return self._db_dict[TrendBudName.proposal_id_list]
+
+    @property
+    def hls_version_list(self) -> list[str]:
+        """Sorted list of HLS versions, ordered by frequency in the input data."""
+        return self._db_dict[TrendBudName.hls_version_list]
+
+    ############
+    ### ViSP ###
+    ############
+
+    @property
+    def visp_grating_angle_for_arm(self) -> dict[int, float]:
+        """Return the ViSP grating angle for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.visp_grating_angle_for_arm])
+
+    @property
+    def visp_arm_position_for_arm(self) -> dict[int, float]:
+        """Return the ViSP grating angle for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.visp_arm_position_for_arm])
+
+    @property
+    def visp_grating_constant_for_arm(self) -> dict[int, float]:
+        """Return the ViSP grating angle for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.visp_grating_constant_for_arm])
+
+    #################
+    ### CryoNIRSP ###
+    #################
+
+    @property
+    def cryonirsp_od_filter_name_for_arm(self) -> dict[str, str]:
+        """Return the Cryo OD filter name for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.cryonirsp_od_filter_name_for_arm])
+
+    @property
+    def cryonirsp_grating_angle_for_arm(self) -> dict[str, float]:
+        """Return the Cryo grating angle for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.cryonirsp_grating_angle_for_arm])
+
+    @property
+    def cryonirsp_grating_littrow_angle_for_arm(self) -> dict[str, float]:
+        """Return the Cryo grating littrow angle for all arms."""
+        return _unjsonify_dict_keys(
+            self._db_dict[TrendBudName.cryonirsp_grating_littrow_angle_for_arm]
+        )
+
+    @property
+    def cryonirsp_grating_constant_for_arm(self) -> dict[str, float]:
+        """Return the Cryo grating constant for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.cryonirsp_grating_constant_for_arm])
+
+    @property
+    def cryonirsp_slit_width_for_arm(self) -> dict[str, float]:
+        """Return the Cryo slit width for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.cryonirsp_slit_width_for_arm])
+
+    ###############
+    ### DLNIRSP ###
+    ###############
+
+    @property
+    def dlnirsp_grating_angle_for_arm(self) -> dict[str, float]:
+        """Return the DLNIRSP grating angle for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.dlnirsp_grating_angle_for_arm])
+
+    @property
+    def dlnirsp_arm_position_for_arm(self) -> dict[str, float]:
+        """Return the DLNIRSP grating angle for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.dlnirsp_arm_position_for_arm])
+
+    @property
+    def dlnirsp_grating_constant_for_arm(self) -> dict[str, float]:
+        """Return the DLNIRSP grating angle for all arms."""
+        return _unjsonify_dict_keys(self._db_dict[TrendBudName.dlnirsp_grating_constant_for_arm])

dkist_processing_trend/models/fit_options.py

@@ -0,0 +1,15 @@
+"""BaseModel to hold `dkist_processing_pac` fit options."""
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+
+
+class FitOptions(BaseModel):
+    """Container for a single set of `dkist_processing_pac` fit options."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    remove_I_trend: bool
+    fit_mode_name: str
+    init_set_name: str

dkist_processing_trend/models/fits_access.py

@@ -0,0 +1,65 @@
+"""Controlled mapping from TrendFitsAccess property names to header key values."""
+
+from enum import StrEnum
+
+# Property names with this value must be set in a `*FitsAccess` class with an instrument-specific `*MetadataKey`.
+# See `TrendL0FitsAccess` for examples.
+INSTRUMENT_SPECIFIC_KEY_SLUG = "You must use the instrument-specific MetadataKeys when setting"
+
+
+class TrendMetadataKey(StrEnum):
+    """
+    Controlled list of property names on `~dkist_processing_trend.parsers.trend_l0_fits_access.TrendL0FitsAccess`.
+
+    Unlike the instrument specific `*MetadataKey` enums defined below many of the property names defined here (the names)
+    do not have a corresponding FITS header key (the values). This is because, in these cases, `~dkist_processing_trend.parsers.trend_l0_fits_access.TrendL0FitsAccess`
+    matches a header's instrument value and then uses the appropriate instrument's `*MetadataKey` to actually match
+    property name to header key.
+    """
+
+    arm_id = f"{INSTRUMENT_SPECIFIC_KEY_SLUG} arm_id"
+    number_of_modulator_states = f"{INSTRUMENT_SPECIFIC_KEY_SLUG} number_of_modulator_states"
+    modulator_state = f"{INSTRUMENT_SPECIFIC_KEY_SLUG} modulator_state"
+    visp_grating_angle = "VSPGRTAN"
+    visp_arm_position = "VSPARMPS"
+    visp_grating_constant = "VSPGRTCN"
+    cryonirsp_od_filter_name = "CNFILTNP"
+    cryonirsp_grating_angle = "CNGRTPOS"
+    cryonirsp_grating_littrow_angle = "CNGRTLAT"
+    cryonirsp_grating_constant = "CNGRTCON"
+    cryonirsp_slit_width = "CNSLITW"
+    dlnirsp_grating_angle = "DLGRTAN"
+    dlnirsp_arm_position = "DLARMPS"
+    dlnirsp_grating_constant = "DLGRTCN"
+
+
+class VispMetadataKey(StrEnum):
+    """Controlled list of names for ViSP FITS metadata header keys."""
+
+    arm_id = "VSPARMID"
+    number_of_modulator_states = "VSPNUMST"
+    modulator_state = "VSPSTNUM"
+
+
+class CryonirspMetadataKey(StrEnum):
+    """Controlled list of names for Cryo-NIRSP FITS metadata header keys."""
+
+    camera_readout_mode = "CNCAMMD"
+    curr_frame_in_ramp = "CNCNDR"
+    num_frames_in_ramp = "CNNNDR"
+    arm_id = "CNARMID"
+    number_of_modulator_states = "CNMODNST"
+    modulator_state = "CNMODCST"
+
+
+class DlnirspMetadataKey(StrEnum):
+    """Controlled list of names for DL-NIRSP FITS metadata header keys."""
+
+    modulator_spin_mode = "DLMOD"
+    camera_readout_mode = "DLCAMSMD"
+    num_frames_in_ramp = "DLCAMNS"
+    current_frame_in_ramp = "DLCAMCUR"
+    arm_id = "DLARMID"
+    camera_sample_sequence = "DLCAMSSQ"
+    number_of_modulator_states = "DLNUMST"
+    modulator_state = "DLSTNUM"

dkist_processing_trend/models/instrument.py

@@ -0,0 +1,35 @@
+"""Controlled list of instrument and arm names."""
+
+from enum import IntEnum
+from enum import StrEnum
+
+
+class InstrumentName(StrEnum):
+    """Controlled set of instrument names."""
+
+    visp = "VISP"
+    cryonirsp = "CRYO-NIRSP"
+    dlnirsp = "DL-NIRSP"
+
+
+class VispArms(IntEnum):
+    """Controlled set of ViSP arm ids."""
+
+    arm1 = 1
+    arm2 = 2
+    arm3 = 3
+
+
+class CryonirspArms(StrEnum):
+    """Controlled set of CryoNIRSP arm ids."""
+
+    CI = "CI"
+    SP = "SP"
+
+
+class DlnirspArms(StrEnum):
+    """Controlled set of DLNIRSP arm ids."""
+
+    VIS = "VIS"
+    JBand = "JBand"
+    HBand = "HBand"

dkist_processing_trend/models/instrument_options.py

@@ -0,0 +1,35 @@
+"""BaseModel to hold instrument-specific pre and post fit processing options."""
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+
+
+class InstrumentOptionsBase(BaseModel):
+    """Base container for a single set of instrument pre and post fit processing options."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+
+
+class VispInstrumentOptions(InstrumentOptionsBase):
+    """Container for ViSP-specific instrument processing options."""
+
+    num_spatial_px: int
+    num_spectral_px: int
+    spatial_smoothing_fit_order: int
+
+
+class CryonirspInstrumentOptions(InstrumentOptionsBase):
+    """Container for CryoNIRSP-specific instrument processing options."""
+
+    num_spatial_px: int
+    num_spectral_px: int
+
+
+class DlnirspInstrumentOptions(InstrumentOptionsBase):
+    """Container for DLNIRSP-specific instrument processing options."""
+
+    num_spatial_px: int
+    num_spectral_px: int
+    spatial_smoothing_fit_order: int

dkist_processing_trend/models/parameters.py

@@ -0,0 +1,134 @@
+"""Classes for holding pipeline parameters read from the input dataset document."""
+
+from datetime import datetime
+from typing import Any
+
+from dkist_processing_common.models.parameters import ParameterBase
+from dkist_processing_common.models.parameters import _ParamMixinBase
+
+from dkist_processing_trend.models.fit_options import FitOptions
+from dkist_processing_trend.models.instrument import InstrumentName
+from dkist_processing_trend.models.instrument_options import CryonirspInstrumentOptions
+from dkist_processing_trend.models.instrument_options import DlnirspInstrumentOptions
+from dkist_processing_trend.models.instrument_options import VispInstrumentOptions
+
+
+class ParameterInstrumentMixin(_ParamMixinBase):
+    """
+    Mixin that provides support for instrument-dependent parameters.
+
+    It allows for the "instrument" kwarg to `__init__` and provides the `self._instrument` attribute and methods for
+    finding parameterValues based on that instrument.
+    """
+
+    def __init__(self, instrument: str, **kwargs):
+        # This lets us use the more common instrument names for parameter database values (e.g., "cryonirsp" instead of "CRYO-NIRSP").
+        # StrEnum called with a *value* returns that enum member as an `InstrumentName`. Magic.
+        self._instrument = InstrumentName(instrument).name
+
+    def _find_parameter_for_instrument(self, parameter_name: str) -> Any:
+        full_param_name = f"{parameter_name}_{self._instrument}"
+        param = self._find_most_recent_past_value(full_param_name)
+        return param
+
+
+class TrendParsingParameters(ParameterBase):
+    """
+    Parameters specifically (and only) for the Parse task.
+
+    Needed because the Parse task doesn't know what things like obs OP start time or wavelength are.
+    """
+
+    @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(
+            "trend_max_cs_step_time_sec", start_date=datetime.now()
+        )
+
+
+class TrendParameters(ParameterBase, ParameterInstrumentMixin):
+    """Trend-specific parameter class that exposes values in the input dataset document as properties on this class."""
+
+    @property
+    def fit_options_list(self) -> list[FitOptions]:
+        """Return a list of `FitOptions` objects where each element represents a set of fit options to use in a separate PAC fit."""
+        raw_value: list[dict] = self._find_most_recent_past_value("trend_fit_options_list")
+        return [FitOptions.model_validate(i) for i in raw_value]
+
+    @property
+    def instrument_processing_options(
+        self,
+    ) -> list[VispInstrumentOptions, CryonirspInstrumentOptions, DlnirspInstrumentOptions]:
+        """Return a list of dicts where each element represents a set of PAC input processing options."""
+        raw_value: list[dict] = self._find_parameter_for_instrument(
+            "trend_instrument_processing_options"
+        )
+        match self._instrument:
+            case InstrumentName.visp.name:
+                return [VispInstrumentOptions.model_validate(i) for i in raw_value]
+            case InstrumentName.cryonirsp.name:
+                return [CryonirspInstrumentOptions.model_validate(i) for i in raw_value]
+            case InstrumentName.dlnirsp.name:
+                return [DlnirspInstrumentOptions.model_validate(i) for i in raw_value]
+
+    @property
+    def visp_beam_border(self) -> int:
+        """Return the pixel location of the border between the two ViSP beams."""
+        return self._find_most_recent_past_value("trend_visp_beam_border")
+
+    @property
+    def visp_geo_upsample_factor(self) -> int:
+        """Return the upsample factor used by `phase_cross_correlation` in the ViSP geometric task."""
+        return self._find_most_recent_past_value("trend_visp_geo_upsample_factor")
+
+    @property
+    def visp_hairline_median_spatial_smoothing_width_px(self) -> int:
+        """Size of median filter in the spatial dimension with which to smooth data for hairline identification."""
+        return self._find_most_recent_past_value(
+            "trend_visp_hairline_median_spatial_smoothing_width_px"
+        )
+
+    @property
+    def visp_hairline_fraction(self):
+        """Relative difference from median used to identify slit positions covered by the hairlines."""
+        return self._find_most_recent_past_value("trend_visp_hairline_fraction")
+
+    @property
+    def visp_hairline_mask_spatial_smoothing_width_px(self) -> float:
+        """Amount to smooth the hairline mask in the spatial direction.
+
+        This helps capture the higher-flux wings of the hairlines that would otherwise require a `hairline_fraction`
+        that was so low it captures other optical features.
+        """
+        return self._find_most_recent_past_value(
+            "trend_visp_hairline_mask_spatial_smoothing_width_px"
+        )
+
+    @property
+    def visp_hairline_mask_gaussian_peak_cutoff_fraction(self) -> float:
+        """Fraction of the maximum smoothed mask value used to truncate the smoothed mask.
+
+        This ensures that very very small values way out in the wings are not included in the mask. For example, if
+        this value is 0.01 then any mask points less than 1% of the maximum will be ignored.
+        """
+        return self._find_most_recent_past_value(
+            "trend_visp_hairline_mask_gaussian_peak_cutoff_fraction"
+        )
+
+    @property
+    def visp_polcal_spatial_median_filter_width_px(self) -> int:
+        """Return the size of the median filter to apply in the spatial dimension to polcal data."""
+        return self._find_most_recent_past_value("trend_visp_polcal_spatial_median_filter_width_px")
+
+    @property
+    def visp_polcal_demod_spatial_smooth_min_samples(self) -> float:
+        """Return fractional number of samples required for the RANSAC regressor used to smooth ViSP demod matrices."""
+        return self._find_most_recent_past_value(
+            "trend_visp_polcal_demod_spatial_smooth_min_samples"
+        )
+
+    @property
+    def visp_polcal_demod_upsample_order(self) -> int:
+        """Interpolation order to use when upsampling the demodulation matrices to the full frame."""
+        return self._find_most_recent_past_value("trend_visp_polcal_demod_upsample_order")

dkist_processing_trend/models/tags.py

@@ -0,0 +1,117 @@
+"""Trend specific file tags and enums."""
+
+from enum import StrEnum
+
+from dkist_processing_common.models.tags import StemName
+from dkist_processing_common.models.tags import Tag
+
+from dkist_processing_trend.models.task_name import TrendTaskName
+
+
+class TrendStemName(StrEnum):
+    """Controlled list of Tag Stems."""
+
+    arm_id = "ARM_ID"
+    beam = "BEAM"
+    instrument_processing_options = "INST_PROC_OPT"
+    pac_fit_options = "PAC_FIT_OPT"
+
+
+class TrendTag(Tag):
+    """Trend specific tag formatting."""
+
+    @classmethod
+    def arm_id(cls, arm_id: str | int) -> str:
+        """
+        Tags based on the arm_id from which the data is recorded.
+
+        Parameters
+        ----------
+        arm_id
+            The arm ID in use; {1, 2, 3} for ViSP, {"CI", "SP"} for Cryo, and {"VIS", "JBand", "HBand"} for DL
+
+        Returns
+        -------
+        The formatted tag string
+        """
+        return cls.format_tag(TrendStemName.arm_id, arm_id)
+
+    @classmethod
+    def beam(cls, beam_num: int) -> str:
+        """
+        Tags by beam number.
+
+        Parameters
+        ----------
+        beam_num: int
+            The beam number
+
+        """
+        return cls.format_tag(TrendStemName.beam, beam_num)
+
+    @classmethod
+    def instrument_processing_options(cls, instrument_processing_options_name: str) -> str:
+        """Tag on a given set of instrument processing options."""
+        return cls.format_tag(
+            TrendStemName.instrument_processing_options, instrument_processing_options_name
+        )
+
+    @classmethod
+    def pac_fit_options(cls, pac_fit_options_name: str) -> str:
+        """Tag on a given set of pac fit options."""
+        return cls.format_tag(TrendStemName.pac_fit_options, pac_fit_options_name)
+
+    @classmethod
+    def task_global_pac_input(cls) -> str:
+        """Tags 'global' PAC inputs."""
+        return cls.format_tag(StemName.task, TrendTaskName.global_pac_input)
+
+    @classmethod
+    def task_local_pac_input(cls) -> str:
+        """Tags 'local' PAC inputs."""
+        return cls.format_tag(StemName.task, TrendTaskName.local_pac_input)
+
+    @classmethod
+    def task_calibration_sequence(cls) -> str:
+        """Tags the full GOS configuration of input calibration sequence(s)."""
+        return cls.format_tag(StemName.task, TrendTaskName.calibration_sequence)
+
+    @classmethod
+    def task_best_fit_parameters(cls) -> str:
+        """Tags the best-fit parameter values."""
+        return cls.format_tag(StemName.task, TrendTaskName.best_fit_parameters)
+
+    @classmethod
+    def task_best_fit_demodulation_matrices(cls) -> str:
+        """Tags the best-fit demodulation matrices."""
+        return cls.format_tag(StemName.task, TrendTaskName.best_fit_demodulation_matrices)
+
+    @classmethod
+    def task_best_fit_flux(cls) -> str:
+        """Tags the best-fit model flux."""
+        return cls.format_tag(StemName.task, TrendTaskName.best_fit_flux)
+
+    @classmethod
+    def task_fit_residuals(cls) -> str:
+        """Tags the flux fit residuals for the best-fit parameters."""
+        return cls.format_tag(StemName.task, TrendTaskName.fit_residuals)
+
+    @classmethod
+    def task_processed_demodulation_matrices(cls) -> str:
+        """Tags the processed demodulation matrices."""
+        return cls.format_tag(StemName.task, TrendTaskName.processed_demodulation_matrices)
+
+    @classmethod
+    def task_single_beam_demodulated_polcal_data(cls) -> str:
+        """Tags the demodulated polcal data (DMPD)."""
+        return cls.format_tag(StemName.task, TrendTaskName.single_beam_demodulated_polcal_data)
+
+    @classmethod
+    def task_demodulated_polcal_data(cls) -> str:
+        """Tags the demodulated polcal data (DMPD)."""
+        return cls.format_tag(StemName.task, TrendTaskName.demodulated_polcal_data)
+
+    @classmethod
+    def task_visp_geometric_calibration(cls) -> str:
+        """Tags the ViSP geometric calibration (angles and shift) intermediate product."""
+        return cls.format_tag(StemName.task, TrendTaskName.visp_geometric_calibration)

dkist_processing_trend/models/task_name.py

@@ -0,0 +1,20 @@
+"""Controlled list of trend-specific TASK tag names."""
+
+from enum import StrEnum
+
+
+class TrendTaskName(StrEnum):
+    """Controlled set of trend task names."""
+
+    global_pac_input = "GLOBAL_PAC_INPUT"
+    local_pac_input = "LOCAL_PAC_INPUT"
+    calibration_sequence = "CALIBRATION_SEQUENCE"
+    best_fit_parameters = "BEST_FIT_PARAMETERS"
+    best_fit_demodulation_matrices = "BEST_FIT_DEMOD_MATRICES"
+    best_fit_flux = "BEST_FIT_FLUX"
+    fit_residuals = "FIT_RESIDUALS"
+    processed_demodulation_matrices = "PROCESSED_DEMODULATION_MATRICES"
+    single_beam_demodulated_polcal_data = "SINGLE_BEAM_DEMODULATED_POLCAL_DATA"
+    demodulated_polcal_data = "DEMODULATED_POLCAL_DATA"
+
+    visp_geometric_calibration = "VISP_GEO_CAL"

dkist_processing_trend/parsers/__init__.py

@@ -0,0 +1 @@
+"""Custom Stems for parsing Trend data."""