dkist-processing-visp 2.20.14__py3-none-any.whl → 5.1.1__py3-none-any.whl

dkist_processing_visp/__init__.py

@@ -1,4 +1,5 @@
 """init."""
+
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
 

dkist_processing_visp/config.py

@@ -1,4 +1,5 @@
 """Configuration for the dkist-processing-visp package and the logging thereof."""
+
 from dkist_processing_common.config import DKISTProcessingCommonConfiguration
 
 

dkist_processing_visp/models/constants.py

@@ -1,13 +1,16 @@
 """Visp additions to common constants."""
+
 from enum import Enum
 
-from dkist_processing_common.models.constants import BudName
+import astropy.units as u
+from astropy.units import Quantity
 from dkist_processing_common.models.constants import ConstantsBase
 
 
 class VispBudName(Enum):
     """Names to be used in Visp buds."""
 
+    arm_id = "ARM_ID"
     num_raster_steps = "NUM_RASTER_STEPS"
     polarimeter_mode = "POLARIMETER_MODE"
     wavelength = "WAVELENGTH"
@@ -22,6 +25,10 @@ class VispBudName(Enum):
     polcal_readout_exp_times = "POLCAL_READOUT_EXP_TIMES"
     non_dark_task_readout_exp_times = "NON_DARK_TASK_READOUT_EXP_TIMES"
     num_map_scans = "NUM_MAP_SCANS"
+    incident_light_angle_deg = "INCIDENT_LIGHT_ANGLE_DEG"
+    reflected_light_angle_deg = "REFLECTED_LIGHT_ANGLE_DEG"
+    grating_constant_inverse_mm = "GRATING_CONSTANT_INVERSE_MM"
+    solar_gain_ip_start_time = "SOLAR_GAIN_IP_START_TIME"
     axis_1_type = "AXIS_1_TYPE"
     axis_2_type = "AXIS_2_TYPE"
     axis_3_type = "AXIS_3_TYPE"
@@ -31,6 +38,16 @@ class VispBudName(Enum):
 class VispConstants(ConstantsBase):
     """Visp specific constants to add to the common constants."""
 
+    @property
+    def arm_id(self) -> str:
+        """
+        Return the current ViSP arm ID.
+
+        Arm IDs are ints in the headers, but we convert them to str here because that's what downstream machinery expects
+        the type to be.
+        """
+        return str(self._db_dict[VispBudName.arm_id])
+
     @property
     def wavelength(self) -> float:
         """Wavelength."""
@@ -41,11 +58,6 @@ class VispConstants(ConstantsBase):
         """Return the start time of the observe IP."""
         return self._db_dict[VispBudName.obs_ip_start_time.value]
 
-    @property
-    def num_modstates(self):
-        """Find the number of modulation states."""
-        return self._db_dict[BudName.num_modstates.value]
-
     @property
     def num_beams(self):
         """
@@ -55,11 +67,6 @@ class VispConstants(ConstantsBase):
         """
         return 2
 
-    @property
-    def num_cs_steps(self):
-        """Find the number of calibration sequence steps."""
-        return self._db_dict[BudName.num_cs_steps.value]
-
     @property
     def num_raster_steps(self):
         """Find the number of raster steps."""
@@ -76,17 +83,27 @@ class VispConstants(ConstantsBase):
         return self._db_dict[VispBudName.polarimeter_mode.value] == "observe_polarimetric"
 
     @property
-    def lamp_exposure_times(self) -> [float]:
+    def pac_init_set(self):
+        """Return the label for the initial set of parameter values used when fitting demodulation matrices."""
+        retarder_name = self.retarder_name
+        match retarder_name:
+            case "SiO2 OC":
+                return "OCCal_VIS"
+            case _:
+                raise ValueError(f"No init set known for {retarder_name = }")
+
+    @property
+    def lamp_exposure_times(self) -> list[float]:
         """Find the lamp exposure time."""
         return self._db_dict[VispBudName.lamp_exposure_times.value]
 
     @property
-    def solar_exposure_times(self) -> [float]:
+    def solar_exposure_times(self) -> list[float]:
         """Find the solar exposure time."""
         return self._db_dict[VispBudName.solar_exposure_times.value]
 
     @property
-    def polcal_exposure_times(self) -> [float]:
+    def polcal_exposure_times(self) -> list[float]:
         """Find the polarization calibration exposure time."""
         if self.correct_for_polarization:
             return self._db_dict[VispBudName.polcal_exposure_times.value]
@@ -94,22 +111,22 @@ class VispConstants(ConstantsBase):
             return []
 
     @property
-    def observe_exposure_times(self) -> [float]:
+    def observe_exposure_times(self) -> list[float]:
         """Find the observation exposure time."""
         return self._db_dict[VispBudName.observe_exposure_times.value]
 
     @property
-    def lamp_readout_exp_times(self) -> [float]:
+    def lamp_readout_exp_times(self) -> list[float]:
         """Find the lamp readout exposure time."""
         return self._db_dict[VispBudName.lamp_readout_exp_times.value]
 
     @property
-    def solar_readout_exp_times(self) -> [float]:
+    def solar_readout_exp_times(self) -> list[float]:
         """Find the solar readout exposure time."""
         return self._db_dict[VispBudName.solar_readout_exp_times.value]
 
     @property
-    def polcal_readout_exp_times(self) -> [float]:
+    def polcal_readout_exp_times(self) -> list[float]:
         """Find the polarization calibration readout exposure time."""
         if self.correct_for_polarization:
             return self._db_dict[VispBudName.polcal_readout_exp_times.value]
@@ -117,7 +134,7 @@ class VispConstants(ConstantsBase):
             return []
 
     @property
-    def non_dark_task_readout_exp_times(self) -> [float]:
+    def non_dark_task_readout_exp_times(self) -> list[float]:
         """
         Find all readout exposure times that *need* to exist in a dark IP.
 
@@ -127,10 +144,34 @@ class VispConstants(ConstantsBase):
         return self._db_dict[VispBudName.non_dark_task_readout_exp_times.value]
 
     @property
-    def observe_readout_exp_times(self) -> [float]:
+    def observe_readout_exp_times(self) -> list[float]:
         """Find the observation readout exposure time."""
         return self._db_dict[VispBudName.observe_readout_exp_times.value]
 
+    @property
+    def incident_light_angle_deg(self) -> Quantity:
+        """Return the spectrograph incident light angle [deg]."""
+        return self._db_dict[VispBudName.incident_light_angle_deg] * u.deg
+
+    @property
+    def reflected_light_angle_deg(self) -> Quantity:
+        """
+        Return the spectrograph reflected light angle [deg].
+
+        This angle is the incident light angle plus the angular position of the ViSP arm.
+        """
+        return self._db_dict[VispBudName.reflected_light_angle_deg] * u.deg
+
+    @property
+    def grating_constant_inverse_mm(self) -> Quantity:
+        """Return the spectrograph grating constant [1/mm]."""
+        return self._db_dict[VispBudName.grating_constant_inverse_mm] / u.mm
+
+    @property
+    def solar_gain_ip_start_time(self) -> str:
+        """Return the start time of the SOLAR GAIN Instrument Program."""
+        return self._db_dict[VispBudName.solar_gain_ip_start_time]
+
     @property
     def axis_1_type(self) -> str:
         """Find the type of the first array axis."""

dkist_processing_visp/models/fits_access.py

@@ -0,0 +1,20 @@
+"""ViSP control of FITS key names and values."""
+
+from enum import StrEnum
+
+
+class VispMetadataKey(StrEnum):
+    """Controlled list of names for FITS metadata header keys."""
+
+    arm_id = "VSPARMID"
+    number_of_modulator_states = "VSPNUMST"
+    raster_scan_step = "VSPSTP"
+    total_raster_steps = "VSPNSTP"
+    modulator_state = "VSPSTNUM"
+    polarimeter_mode = "VISP_006"
+    grating_angle_deg = "VSPGRTAN"
+    arm_position_deg = "VSPARMPS"
+    grating_constant_inverse_mm = "VSPGRTCN"
+    axis_1_type = "CTYPE1"
+    axis_2_type = "CTYPE2"
+    axis_3_type = "CTYPE3"

dkist_processing_visp/models/metric_code.py

@@ -0,0 +1,10 @@
+"""Controlled list of quality metric codes."""
+
+from enum import StrEnum
+
+
+class VispMetricCode(StrEnum):
+    """Controlled list of quality metric codes."""
+
+    solar_first_vignette = "SOLAR_CAL_FIRST_VIGNETTE"
+    solar_final_vignette = "SOLAR_CAL_FINAL_VIGNETTE"

dkist_processing_visp/models/parameters.py

@@ -1,8 +1,14 @@
 """Visp calibration pipeline parameters."""
+
 from datetime import datetime
+from random import randint
+from typing import Any
 
+import astropy.units as u
+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
 
 
 class VispParsingParameters(ParameterBase):
@@ -21,7 +27,7 @@ class VispParsingParameters(ParameterBase):
         )
 
 
-class VispParameters(ParameterBase, ParameterWavelengthMixin):
+class VispParameters(ParameterBase, ParameterWavelengthMixin, ParameterArmIdMixin):
     """Put all Visp parameters parsed from the input dataset document in a single property."""
 
     @property
@@ -68,7 +74,7 @@ class VispParameters(ParameterBase, ParameterWavelengthMixin):
 
     @property
     def hairline_mask_spatial_smoothing_width_px(self) -> float:
-        """Amount to smooth the hairling mask in the spatial direction.
+        """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.
@@ -133,9 +139,34 @@ class VispParameters(ParameterBase, ParameterWavelengthMixin):
         return self._find_most_recent_past_value("visp_geo_poly_fit_order")
 
     @property
-    def solar_spectral_avg_window(self):
+    def geo_zone_prominence(self):
+        """Relative peak prominence threshold used to identify strong spectral features."""
+        return self._find_parameter_closest_wavelength("visp_geo_zone_prominence")
+
+    @property
+    def geo_zone_width(self):
+        """Pixel width used to search for strong spectral features."""
+        return self._find_parameter_closest_wavelength("visp_geo_zone_width")
+
+    @property
+    def geo_zone_bg_order(self):
+        """Order of polynomial fit used to remove continuum when identifying strong spectral features."""
+        return self._find_parameter_closest_wavelength("visp_geo_zone_bg_order")
+
+    @property
+    def geo_zone_normalization_percentile(self):
+        """Fraction of CDF to use for normalizing spectrum when search for strong features."""
+        return self._find_parameter_closest_wavelength("visp_geo_zone_normalization_percentile")
+
+    @property
+    def geo_zone_rel_height(self):
+        """Relative height at which to compute the width of strong spectral features."""
+        return self._find_most_recent_past_value("visp_geo_zone_rel_height")
+
+    @property
+    def solar_spatial_median_filter_width_px(self):
         """Pixel width of spatial median filter used to compute characteristic solar spectra."""
-        return self._find_parameter_closest_wavelength("visp_solar_spectral_avg_window")
+        return self._find_parameter_closest_wavelength("visp_solar_spatial_median_filter_width_px")
 
     @property
     def solar_characteristic_spatial_normalization_percentile(self) -> float:
@@ -145,29 +176,108 @@ class VispParameters(ParameterBase, ParameterWavelengthMixin):
         )
 
     @property
-    def solar_zone_prominence(self):
-        """Relative peak prominence threshold used to identify strong spectral features."""
-        return self._find_parameter_closest_wavelength("visp_solar_zone_prominence")
+    def solar_vignette_initial_continuum_poly_fit_order(self) -> int:
+        """
+        Define the order of polynomial to use when fitting the initial continuum function.
+
+        Note that "initial" in this context does not refer to an initial guess in the wavecal fitter, but rather the
+        fact that this represents the initial estimate of the vignette signal.
+        """
+        return self._find_most_recent_past_value(
+            "visp_solar_vignette_initial_continuum_poly_fit_order"
+        )
 
     @property
-    def solar_zone_width(self):
-        """Pixel width used to search for strong spectral features."""
-        return self._find_parameter_closest_wavelength("visp_solar_zone_width")
+    def solar_vignette_crval_bounds_px(self) -> float:
+        """
+        Define the bounds (in *pixels*) on crval when fitting the initial vignette signal.
+
+        The actual bounds on the value of crval are equal to ± the initial dispersion times this number. Note that the
+        total range searched by the fitting algorithm will be twice this number (in pixels).
+        """
+        return self._find_most_recent_past_value("visp_solar_vignette_crval_bounds_px") * u.pix
 
     @property
-    def solar_zone_bg_order(self):
-        """Order of polynomial fit used to remove continuum when identifying strong spectral features."""
-        return self._find_parameter_closest_wavelength("visp_solar_zone_bg_order")
+    def solar_vignette_dispersion_bounds_fraction(self) -> float:
+        """
+        Define the ± fraction away from the initial value for bounds on dispersion when fitting the initial vignette signal.
+
+        This value should be between 0 and 1. For example, the minimum bound is `init_value * (1 - solar_vignette_dispersion_bounds_fraction)`.
+        """
+        return self._find_most_recent_past_value("visp_solar_vignette_dispersion_bounds_fraction")
 
     @property
-    def solar_zone_normalization_percentile(self):
-        """Fraction of CDF to use for normalzing spectrum when search for strong features."""
-        return self._find_parameter_closest_wavelength("visp_solar_zone_normalization_percentile")
+    def solar_vignette_wavecal_fit_kwargs(self) -> dict[str, Any]:
+        """Define extra keyword arguments to pass to the wavelength calibration fitter."""
+        doc_dict = self._find_most_recent_past_value("visp_solar_vignette_wavecal_fit_kwargs")
+        rng_kwarg = dict()
+        fitting_method = doc_dict.get("method", False)
+        if fitting_method in ["basinhopping", "differential_evolution", "dual_annealing"]:
+            rng = randint(1, 1_000_000)
+            rng_kwarg["rng"] = rng
+
+        # The order here allows us to override `rng` in a parameter value
+        fit_kwargs = rng_kwarg | doc_dict
+        return fit_kwargs
 
     @property
-    def solar_zone_rel_height(self):
-        """Relative height at which to compute the width of strong spectral features."""
-        return self._find_most_recent_past_value("visp_solar_zone_rel_height")
+    def solar_vignette_spectral_poly_fit_order(self) -> int:
+        """Define the order of spectral polynomial used when computing the full, 2D vignette signal."""
+        return self._find_most_recent_past_value("visp_solar_vignette_spectral_poly_fit_order")
+
+    @property
+    def solar_vignette_min_samples(self) -> float:
+        """Return fractional number of samples required for the RANSAC regressor used to fit the 2D vignette signal."""
+        return self._find_most_recent_past_value("visp_solar_vignette_min_samples")
+
+    @property
+    def wavecal_camera_lens_parameters(self) -> list[u.Quantity]:
+        r"""
+        Define the 2nd order polynomial coefficients for computing the total camera focal length as a function of wavelength.
+
+        The total focal length of the lens is :math:`f = a_0 + a_1\lambda + a_2\lambda^2` where this property is
+        :math:`[a_0, a_1, a_2]`
+        """
+        value_list = self._find_parameter_for_arm("visp_wavecal_camera_lens_parameters")
+        unit_list = [u.m, u.m / u.nm, u.m / u.nm**2]
+        return [v * u for v, u in zip(value_list, unit_list)]
+
+    @property
+    def wavecal_pixel_pitch_micron_per_pix(self) -> u.Quantity:
+        """Define the physical size of ViSP detector pixels."""
+        return (
+            self._find_most_recent_past_value("visp_wavecal_pixel_pitch_micron_per_pix")
+            * u.micron
+            / u.pix
+        )
+
+    @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("visp_wavecal_atlas_download_config")
+        return DownloadConfig.model_validate(config_dict)
+
+    @property
+    def wavecal_init_crval_guess_normalization_percentile(self) -> float | None:
+        """Define the CDF percentage used to normalize the Atlas to the input spectrum level when computing an initial CRVAL guess."""
+        return self._find_most_recent_past_value(
+            "visp_wavecal_init_crval_guess_normalization_percentile"
+        )
+
+    @property
+    def wavecal_init_resolving_power(self) -> int:
+        """Define the initial guess for ViSP resolving power in wavecal fits."""
+        return self._find_most_recent_past_value("visp_wavecal_init_resolving_power")
+
+    @property
+    def wavecal_init_straylight_fraction(self) -> float:
+        """Define the initial guess for straylight fraction in wavecal fits."""
+        return self._find_most_recent_past_value("visp_wavecal_init_straylight_fraction")
+
+    @property
+    def wavecal_init_opacity_factor(self) -> float:
+        """Define the initial guess for opacity factor in wavecal fits."""
+        return self._find_most_recent_past_value("visp_wavecal_init_opacity_factor")
 
     @property
     def polcal_spatial_median_filter_width_px(self) -> int:
@@ -213,8 +323,3 @@ class VispParameters(ParameterBase, ParameterWavelengthMixin):
     def 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("visp_pac_fit_mode")
-
-    @property
-    def pac_init_set(self):
-        """Name of set of initial values for Calibration Unit parameter fit."""
-        return self._find_most_recent_past_value("visp_pac_init_set")

dkist_processing_visp/models/tags.py

@@ -1,4 +1,5 @@
 """ViSP tags."""
+
 from enum import Enum
 
 from dkist_processing_common.models.tags import Tag
@@ -76,7 +77,7 @@ class VispTag(Tag):
     @classmethod
     def intermediate_frame_dark(
         cls,
-        beam: float,
+        beam: int,
         readout_exp_time: float,
     ) -> list[str]:
         """Tag by intermediate_frame composite tag, task_dark, and readout_exposure_time."""
@@ -86,3 +87,23 @@ class VispTag(Tag):
             cls.readout_exp_time(readout_exp_time),
         ]
         return tag_list
+
+    @classmethod
+    def intermediate_frame_polcal_dark(cls, beam: int, readout_exp_time: float) -> list[str]:
+        """Return tag list for averaged polcal dark frames."""
+        tag_list = [
+            cls.intermediate_frame(beam),
+            cls.task_polcal_dark(),
+            cls.readout_exp_time(readout_exp_time),
+        ]
+        return tag_list
+
+    @classmethod
+    def intermediate_frame_polcal_gain(cls, beam: int, readout_exp_time: float) -> list[str]:
+        """Return tag list for averaged polcal gain frames."""
+        tag_list = [
+            cls.intermediate_frame(beam),
+            cls.task_polcal_gain(),
+            cls.readout_exp_time(readout_exp_time),
+        ]
+        return tag_list

dkist_processing_visp/models/task_name.py

@@ -1,4 +1,5 @@
 """Controlled list of visp-specific task tag names."""
+
 from enum import Enum
 
 

dkist_processing_visp/parsers/map_repeats.py

@@ -1,4 +1,5 @@
 """Stems for organizing files into separate map scans."""
+
 from __future__ import annotations
 
 from abc import ABC

dkist_processing_visp/parsers/modulator_states.py

@@ -1,4 +1,5 @@
 """ViSP modulator state parser."""
+
 from dkist_processing_common.models.constants import BudName
 from dkist_processing_common.models.flower_pot import Stem
 from dkist_processing_common.models.tags import StemName

dkist_processing_visp/parsers/polarimeter_mode.py

@@ -1,8 +1,10 @@
 """ViSP polarimeter mode parser."""
+
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
 
 from dkist_processing_visp.models.constants import VispBudName
+from dkist_processing_visp.models.fits_access import VispMetadataKey
 
 
 class PolarimeterModeBud(TaskUniqueBud):
@@ -11,6 +13,6 @@ class PolarimeterModeBud(TaskUniqueBud):
     def __init__(self):
         super().__init__(
             constant_name=VispBudName.polarimeter_mode.value,
-            metadata_key="polarimeter_mode",
-            ip_task_type=TaskName.observe.value,
+            metadata_key=VispMetadataKey.polarimeter_mode,
+            ip_task_types=TaskName.observe.value,
         )

dkist_processing_visp/parsers/raster_step.py

@@ -1,4 +1,5 @@
 """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
@@ -9,6 +10,7 @@ from dkist_processing_common.parsers.single_value_single_key_flower import (
 )
 
 from dkist_processing_visp.models.constants import VispBudName
+from dkist_processing_visp.models.fits_access import VispMetadataKey
 from dkist_processing_visp.models.tags import VispStemName
 from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
 
@@ -68,7 +70,8 @@ class RasterScanStepFlower(SingleValueSingleKeyFlower):
 
     def __init__(self):
         super().__init__(
-            tag_stem_name=VispStemName.raster_step.value, metadata_key="raster_scan_step"
+            tag_stem_name=VispStemName.raster_step.value,
+            metadata_key=VispMetadataKey.raster_scan_step,
         )
 
     def setter(self, fits_obj: VispL0FitsAccess):

dkist_processing_visp/parsers/spectrograph_configuration.py

@@ -0,0 +1,75 @@
+"""Buds for parsing the incident and reflected light angles of the ViSP spectrograph."""
+
+from dkist_processing_common.models.flower_pot import SpilledDirt
+from dkist_processing_common.models.flower_pot import Stem
+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_common.parsers.unique_bud import TaskUniqueBud
+
+from dkist_processing_visp.models.constants import VispBudName
+from dkist_processing_visp.models.fits_access import VispMetadataKey
+from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
+
+
+def convert_grating_angle_to_incident_light_angle(grating_angle: float) -> float:
+    """Convert the raw header "grating angle" to the incident light angle expected by the solar wavecal library."""
+    return -1 * grating_angle
+
+
+class IncidentLightAngleBud(TaskUniqueBud):
+    """Special case of `TaskUniqueBud` so we can apply the sign shift to the header incident light angle values."""
+
+    def __init__(self):
+        super().__init__(
+            constant_name=VispBudName.incident_light_angle_deg.value,
+            metadata_key=VispMetadataKey.grating_angle_deg,
+            ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
+            task_type_parsing_function=parse_header_ip_task_with_gains,
+        )
+
+    def setter(self, fits_obj: VispL0FitsAccess) -> float | type[SpilledDirt]:
+        """Apply a sign flip to the raw header value for incident light angle."""
+        grating_angle = super().setter(fits_obj)
+
+        if grating_angle is SpilledDirt:
+            return grating_angle
+
+        return convert_grating_angle_to_incident_light_angle(grating_angle)
+
+
+class ReflectedLightAngleBud(Stem):
+    """Bud that combines the incident light angle and arm position header values to compute the reflected light angle."""
+
+    key_to_petal_dict: dict[str, float]
+
+    def __init__(self):
+        super().__init__(stem_name=VispBudName.reflected_light_angle_deg.value)
+        self.ip_task_types = [
+            task.casefold() for task in [TaskName.observe.value, TaskName.solar_gain.value]
+        ]
+
+    def setter(self, fits_obj: VispL0FitsAccess) -> float | type[SpilledDirt]:
+        """
+        Compute the reflected light angle.
+
+        The reflected light angle is `-1 * fits_objs.grating_angle_deg + fits_obj.arm_position_deg`.
+        """
+        task = parse_header_ip_task_with_gains(fits_obj)
+
+        if task.casefold() in self.ip_task_types:
+            incident_light_angle = convert_grating_angle_to_incident_light_angle(
+                fits_obj.grating_angle_deg
+            )
+            arm_position = fits_obj.arm_position_deg
+            return incident_light_angle + arm_position
+
+        return SpilledDirt
+
+    def getter(self, key: str) -> float:
+        """Get the value for the reflected light angle and raise an error if it is not unique."""
+        value_set = set(self.key_to_petal_dict.values())
+        if len(value_set) > 1:
+            raise ValueError(
+                f"Multiple {self.stem_name} values found for key {key}. Values: {value_set}"
+            )
+        return value_set.pop()