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

dkist_processing_visp/tasks/instrument_polarization.py

@@ -1,4 +1,5 @@
 """ViSP instrument polarization task. See :doc:`this page </polarization_calibration>` for more information."""
+
 from collections import defaultdict
 
 import numpy as np
@@ -18,8 +19,8 @@ from dkist_processing_pac.input_data.drawer import Drawer
 from dkist_processing_pac.input_data.dresser import Dresser
 from dkist_service_configuration.logging import logger
 from sklearn.linear_model import RANSACRegressor
-from sklearn.pipeline import make_pipeline
 from sklearn.pipeline import Pipeline
+from sklearn.pipeline import make_pipeline
 from sklearn.preprocessing import PolynomialFeatures
 from sklearn.preprocessing import RobustScaler
 
@@ -72,6 +73,15 @@ class InstrumentPolarizationCalibration(
         if not self.constants.correct_for_polarization:
             return
 
+        polcal_readout_exposure_times = self.constants.polcal_readout_exp_times
+        if len(polcal_readout_exposure_times) > 1:
+            logger.info(
+                "WARNING: More than one polcal readout exposure time detected. "
+                "Everything *should* still work, but this is a weird condition that may produce "
+                "strange results."
+            )
+        logger.info(f"{polcal_readout_exposure_times = }")
+
         # Process the pol cal frames
         logger.info(
             f"Demodulation matrices will span FOV with shape 1 spectral bin "
@@ -79,10 +89,22 @@ class InstrumentPolarizationCalibration(
         )
         remove_I_trend = self.parameters.pac_remove_linear_I_trend
         for beam in range(1, self.constants.num_beams + 1):
-            with self.apm_processing_step(f"Reducing CS steps for {beam = }"):
+            with self.telemetry_span("Generate polcal DARK frame"):
+                logger.info("Generating polcal dark frame")
+                self.generate_polcal_dark_calibration(
+                    readout_exp_times=polcal_readout_exposure_times, beam=beam
+                )
+
+            with self.telemetry_span("Generate polcal GAIN frame"):
+                logger.info("Generating polcal gain frame")
+                self.generate_polcal_gain_calibration(
+                    readout_exp_times=polcal_readout_exposure_times, beam=beam
+                )
+
+            with self.telemetry_span(f"Reducing CS steps for {beam = }"):
                 local_reduced_arrays, global_reduced_arrays = self.reduce_cs_steps(beam)
 
-            with self.apm_processing_step(f"Fit CU parameters for {beam = }"):
+            with self.telemetry_span(f"Fit CU parameters for {beam = }"):
                 local_dresser = Dresser()
                 local_dresser.add_drawer(
                     Drawer(local_reduced_arrays, remove_I_trend=remove_I_trend)
@@ -95,13 +117,13 @@ class InstrumentPolarizationCalibration(
                     local_dresser=local_dresser,
                     global_dresser=global_dresser,
                     fit_mode=self.parameters.pac_fit_mode,
-                    init_set=self.parameters.pac_init_set,
+                    init_set=self.constants.pac_init_set,
                     inherit_global_vary_in_local_fit=True,
                     suppress_local_starting_values=True,
                     fit_TM=False,
                 )
 
-            with self.apm_processing_step(f"Resampling demodulation matrices for {beam = }"):
+            with self.telemetry_span(f"Resampling demodulation matrices for {beam = }"):
                 demod_matrices = pac_fitter.demodulation_matrices
 
                 self.write(
@@ -127,7 +149,7 @@ class InstrumentPolarizationCalibration(
                 demod_matrices = self.reshape_demod_matrices(smoothed_demod)
                 logger.info(f"Shape of resampled demodulation matrices: {demod_matrices.shape}")
 
-            with self.apm_writing_step(f"Writing demodulation matrices for {beam = }"):
+            with self.telemetry_span(f"Writing demodulation matrices for {beam = }"):
                 # Save the demod matrices as intermediate products
                 self.write(
                     data=demod_matrices,
@@ -138,10 +160,10 @@ class InstrumentPolarizationCalibration(
                     encoder=fits_array_encoder,
                 )
 
-            with self.apm_processing_step("Computing and recording polcal quality metrics"):
+            with self.telemetry_span("Computing and recording polcal quality metrics"):
                 self.record_polcal_quality_metrics(beam, polcal_fitter=pac_fitter)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_polcal_frames: int = self.scratch.count_all(
                 tags=[
                     VispTag.input(),
@@ -158,7 +180,7 @@ class InstrumentPolarizationCalibration(
         self, beam: int
     ) -> tuple[dict[int, list[VispL0FitsAccess]], dict[int, list[VispL0FitsAccess]]]:
         """
-        Reduce all of the data for the cal sequence steps for this beam.
+        Reduce all the data for the cal sequence steps for this beam.
 
         Parameters
         ----------
@@ -215,10 +237,10 @@ class InstrumentPolarizationCalibration(
 
             for readout_exp_time in self.constants.polcal_readout_exp_times:
                 # Put this loop here because the geometric objects will be constant across exposure times
-                logger.info(f"Loading dark for {readout_exp_time = } and {beam = }")
+                logger.info(f"Loading polcal dark for {beam = }")
                 dark_array = next(
                     self.read(
-                        tags=VispTag.intermediate_frame_dark(
+                        tags=VispTag.intermediate_frame_polcal_dark(
                             beam=beam, readout_exp_time=readout_exp_time
                         ),
                         decoder=fits_array_decoder,
@@ -318,24 +340,25 @@ class InstrumentPolarizationCalibration(
         )
         avg_inst_pol_cal_array = average_numpy_arrays(readout_normalized_arrays)
 
-        with self.apm_processing_step(f"Apply basic corrections for {apm_str}"):
+        with self.telemetry_span(f"Apply basic corrections for {apm_str}"):
             dark_corrected_array = subtract_array_from_arrays(avg_inst_pol_cal_array, dark_array)
 
             background_corrected_array = subtract_array_from_arrays(
                 dark_corrected_array, background_array
             )
 
-            solar_gain_array = next(
+            polcal_gain_array = next(
                 self.read(
                     tags=[
-                        VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                        VispTag.task_solar_gain(),
+                        VispTag.intermediate_frame_polcal_gain(
+                            beam=beam, readout_exp_time=readout_exp_time
+                        ),
                     ],
                     decoder=fits_array_decoder,
                 )
             )
             gain_corrected_array = next(
-                divide_arrays_by_array(background_corrected_array, solar_gain_array)
+                divide_arrays_by_array(background_corrected_array, polcal_gain_array)
             )
 
             geo_corrected_array = self.corrections_correct_geometry(
@@ -346,7 +369,7 @@ class InstrumentPolarizationCalibration(
                 self.corrections_remove_spec_geometry(geo_corrected_array, spec_shift)
             )
 
-        with self.apm_processing_step(f"Extract macro pixels from {apm_str}"):
+        with self.telemetry_span(f"Extract macro pixels from {apm_str}"):
             self.set_original_beam_size(gain_corrected_array)
             filtered_array = self.corrections_mask_hairlines(spectral_corrected_array)
 
@@ -366,7 +389,7 @@ class InstrumentPolarizationCalibration(
             # Add two dummy dimensions just to keep it 2D.
             global_binned_array = np.nanmedian(filtered_array)[None, None]
 
-        with self.apm_processing_step(f"Create reduced VispL0FitsAccess for {apm_str}"):
+        with self.telemetry_span(f"Create reduced VispL0FitsAccess for {apm_str}"):
             local_result = VispL0FitsAccess(
                 fits.ImageHDU(local_array, avg_inst_pol_cal_header),
                 auto_squeeze=False,
@@ -527,3 +550,90 @@ class InstrumentPolarizationCalibration(
         return next(
             resize_arrays(array, output_shape, order=self.parameters.polcal_demod_upsample_order)
         )
+
+    def generate_polcal_dark_calibration(
+        self, readout_exp_times: list[float] | tuple[float], beam: int
+    ) -> None:
+        """Compute an average polcal dark array for all polcal exposure times."""
+        for readout_exp_time in readout_exp_times:
+            logger.info(f"Computing polcal dark for  {readout_exp_time = }")
+
+            dark_arrays = self.read(
+                tags=[
+                    VispTag.input(),
+                    VispTag.frame(),
+                    VispTag.task_polcal_dark(),
+                    VispTag.readout_exp_time(readout_exp_time),
+                ],
+                decoder=fits_access_decoder,
+                fits_access_class=VispL0FitsAccess,
+            )
+
+            readout_normalized_arrays = (
+                self.beam_access_get_beam(o.data, beam=beam) / o.num_raw_frames_per_fpa
+                for o in dark_arrays
+            )
+
+            avg_array = average_numpy_arrays(readout_normalized_arrays)
+            self.write(
+                data=avg_array,
+                tags=[
+                    VispTag.intermediate_frame_polcal_dark(
+                        beam=beam, readout_exp_time=readout_exp_time
+                    ),
+                ],
+                encoder=fits_array_encoder,
+            )
+
+    def generate_polcal_gain_calibration(
+        self, readout_exp_times: list[float] | tuple[float], beam: int
+    ) -> None:
+        """
+        Average 'clear' polcal frames to produce a polcal gain calibration.
+
+        The polcal dark calibration is applied prior to averaging.
+        """
+        for readout_exp_time in readout_exp_times:
+            logger.info(f"Computing polcal gain for {readout_exp_time = }")
+
+            dark_array = next(
+                self.read(
+                    tags=[
+                        VispTag.intermediate_frame(beam=beam),
+                        VispTag.task_polcal_dark(),
+                        VispTag.readout_exp_time(readout_exp_time),
+                    ],
+                    decoder=fits_array_decoder,
+                )
+            )
+
+            gain_arrays = self.read(
+                tags=[
+                    VispTag.input(),
+                    VispTag.frame(),
+                    VispTag.task_polcal_gain(),
+                    VispTag.readout_exp_time(readout_exp_time),
+                ],
+                decoder=fits_access_decoder,
+                fits_access_class=VispL0FitsAccess,
+            )
+
+            readout_normalized_arrays = (
+                self.beam_access_get_beam(o.data, beam=beam) / o.num_raw_frames_per_fpa
+                for o in gain_arrays
+            )
+
+            dark_corrected_arrays = subtract_array_from_arrays(
+                arrays=readout_normalized_arrays, array_to_subtract=dark_array
+            )
+
+            avg_array = average_numpy_arrays(dark_corrected_arrays)
+            self.write(
+                data=avg_array,
+                tags=[
+                    VispTag.intermediate_frame_polcal_gain(
+                        beam=beam, readout_exp_time=readout_exp_time
+                    ),
+                ],
+                encoder=fits_array_encoder,
+            )

dkist_processing_visp/tasks/l1_output_data.py

@@ -1,13 +1,216 @@
 """Subclass of AssembleQualityData that causes the correct polcal metrics to build."""
+
+import numpy as np
+from dkist_processing_common.codecs.asdf import asdf_decoder
+from dkist_processing_common.models.quality import Plot2D
+from dkist_processing_common.models.quality import ReportMetric
+from dkist_processing_common.models.quality import VerticalMultiPanePlot2D
 from dkist_processing_common.tasks import AssembleQualityData
 
 __all__ = ["VispAssembleQualityData"]
 
+from dkist_processing_visp.models.constants import VispConstants
+from dkist_processing_visp.models.metric_code import VispMetricCode
+from dkist_processing_visp.models.tags import VispTag
+
 
 class VispAssembleQualityData(AssembleQualityData):
     """Subclass just so that the polcal_label_list can be populated."""
 
+    constants: VispConstants
+
+    @property
+    def constants_model_class(self):
+        """Get ViSP pipeline constants."""
+        return VispConstants
+
     @property
     def polcal_label_list(self) -> list[str]:
         """Return labels for beams 1 and 2."""
         return ["Beam 1", "Beam 2"]
+
+    def quality_assemble_data(self, polcal_label_list: list[str] | None = None) -> list[dict]:
+        """
+        Assemble the full quality report and insert ViSP-specific metrics.
+
+        We try to place the new metrics right before default polcal ones, if possible.
+        """
+        vignette_metrics = []
+        for beam in range(1, self.constants.num_beams + 1):
+            vignette_metrics.append(self.build_first_vignette_metric(beam=beam))
+            vignette_metrics.append(self.build_final_vignette_metric(beam=beam))
+
+        report = super().quality_assemble_data(polcal_label_list=polcal_label_list)
+
+        # Look for the first "PolCal" metric
+        first_polcal_metric_index = 0
+        try:
+            while not report[first_polcal_metric_index]["name"].lower().startswith("polcal"):
+                first_polcal_metric_index += 1
+        except:
+            # Wasn't found for whatever reason. No big deal, just put the new metrics at the front of the list
+            first_polcal_metric_index = 0
+
+        final_report = (
+            report[:first_polcal_metric_index]
+            + vignette_metrics
+            + report[first_polcal_metric_index:]
+        )
+
+        return final_report
+
+    def build_first_vignette_metric(self, beam: int) -> dict:
+        """Build a ReportMetric showing the initial atlas-with-continuum fit and residuals."""
+        data = next(
+            self.read(
+                tags=[VispTag.quality(VispMetricCode.solar_first_vignette), VispTag.beam(beam)],
+                decoder=asdf_decoder,
+            )
+        )
+
+        wave_vec = data["output_wave_vec"].tolist()
+        input_spectrum = data["input_spectrum"].tolist()
+        best_fit_atlas = data["best_fit_atlas"].tolist()
+        continuum = data["best_fit_continuum"].tolist()
+        residuals = data["residuals"].tolist()
+
+        fit_series = {
+            "Raw input spectrum": [wave_vec, input_spectrum],
+            "Best fit atlas": [wave_vec, best_fit_atlas],
+            "Best fit continuum": [wave_vec, continuum],
+        }
+
+        fit_plot_kwargs = {
+            "Raw input spectrum": {
+                "ls": "-",
+                "ms": 0,
+                "color": "#FAA61C",
+                "zorder": 2.0,
+                "lw": 4,
+                "alpha": 0.6,
+            },
+            "Best fit atlas": {"color": "k", "ls": "-", "ms": 0, "zorder": 2.1},
+            "Best fit continuum": {"ls": "-", "ms": 0, "color": "g", "zorder": 2.2},
+        }
+
+        fit_plot = Plot2D(
+            xlabel="Wavelength [nm]",
+            ylabel="Signal",
+            series_data=fit_series,
+            plot_kwargs=fit_plot_kwargs,
+            sort_series=False,
+        )
+
+        residuals_series = {"Residuals": [wave_vec, residuals]}
+        residuals_plot_kwargs = {"Residuals": {"ls": "-", "color": "k", "ms": 0}}
+
+        y_min = np.nanpercentile(residuals, 2)
+        y_max = np.nanpercentile(residuals, 98)
+        y_range = y_max - y_min
+        y_min -= 0.1 * y_range
+        y_max += 0.1 * y_range
+        residuals_plot = Plot2D(
+            xlabel="Wavelength [nm]",
+            ylabel=r"$\frac{\mathrm{Obs - Atlas}}{\mathrm{Obs}}$",
+            series_data=residuals_series,
+            plot_kwargs=residuals_plot_kwargs,
+            ylim=(y_min, y_max),
+        )
+
+        plot_list = [fit_plot, residuals_plot]
+        height_ratios = [1.5, 1.0]
+
+        full_plot = VerticalMultiPanePlot2D(
+            top_to_bottom_plot_list=plot_list,
+            match_x_axes=True,
+            no_gap=True,
+            top_to_bottom_height_ratios=height_ratios,
+        )
+
+        metric = ReportMetric(
+            name=f"Initial Vignette Estimation - Beam {beam}",
+            description="These plots show the solar atlas fit used to estimate the initial, 1D spectral vignette "
+            "present in solar gain frames. The vignette signature is taken to be the fit continuum shown.",
+            metric_code=VispMetricCode.solar_first_vignette,
+            facet=self._format_facet(f"Beam {beam}"),
+            multi_plot_data=full_plot,
+        )
+
+        return metric.model_dump()
+
+    def build_final_vignette_metric(self, beam: int) -> dict:
+        """Build a ReportMetric showing the quality of the vignette correction on solar gain data."""
+        data = next(
+            self.read(
+                tags=[VispTag.quality(VispMetricCode.solar_final_vignette), VispTag.beam(beam)],
+                decoder=asdf_decoder,
+            )
+        )
+
+        wave_vec = data["output_wave_vec"].tolist()
+        median_spec = data["median_spec"].tolist()
+        low_deviation = data["low_deviation"]
+        high_deviation = data["high_deviation"]
+        diff = (high_deviation - low_deviation).tolist()
+        low_deviation = low_deviation.tolist()
+        high_deviation = high_deviation.tolist()
+
+        bounds_series = {
+            "Median solar signal": [wave_vec, median_spec],
+            "5th percentile bounds": [wave_vec, low_deviation],
+            "95th percentile bounds": [wave_vec, high_deviation],
+        }
+
+        bounds_plot_kwargs = {
+            "Median solar signal": {"ls": "-", "color": "k", "alpha": 0.8, "ms": 0, "zorder": 2.2},
+            "5th percentile bounds": {"color": "#1E317A", "ls": "-", "ms": 0, "zorder": 2.0},
+            "95th percentile bounds": {"ls": "-", "color": "#FAA61C", "ms": 0, "zorder": 2.1},
+        }
+
+        bounds_plot = Plot2D(
+            xlabel="Wavelength [nm]",
+            ylabel="Signal",
+            series_data=bounds_series,
+            plot_kwargs=bounds_plot_kwargs,
+            sort_series=False,
+        )
+
+        residuals_series = {"Residuals": [wave_vec, diff]}
+        residuals_plot_kwargs = {"Residuals": {"ls": "-", "color": "k", "ms": 0}}
+
+        y_min = np.nanpercentile(diff, 5)
+        y_max = np.nanpercentile(diff, 95)
+        y_range = y_max - y_min
+        y_min -= 0.1 * y_range
+        y_max += 0.1 * y_range
+        residuals_plot = Plot2D(
+            xlabel="Wavelength [nm]",
+            ylabel="95th - 5th percentile",
+            series_data=residuals_series,
+            plot_kwargs=residuals_plot_kwargs,
+            ylim=(y_min, y_max),
+        )
+
+        plot_list = [bounds_plot, residuals_plot]
+        height_ratios = [1.5, 1.0]
+
+        full_plot = VerticalMultiPanePlot2D(
+            top_to_bottom_plot_list=plot_list,
+            match_x_axes=True,
+            no_gap=True,
+            top_to_bottom_height_ratios=height_ratios,
+        )
+
+        metric = ReportMetric(
+            name=f"Final Vignette Estimation - Beam {beam}",
+            description="These plots show how well the full, 2D vignette signal was removed from solar gain frames. "
+            "The median solar signal shows a full spatial median of the vignette corrected solar gain; "
+            "this should be very close to the true solar spectrum incident on the DKIST optics. "
+            "The 5th and 9th percentile ranges show how stable this spectrum is along the spatial dimension "
+            "after removing the vignette signal.",
+            metric_code=VispMetricCode.solar_final_vignette,
+            facet=self._format_facet(f"Beam {beam}"),
+            multi_plot_data=full_plot,
+        )
+
+        return metric.model_dump()

dkist_processing_visp/tasks/lamp.py

@@ -1,5 +1,5 @@
 """ViSP lamp calibration task. See :doc:`this page </gain_correction>` for more information."""
-import numpy as np
+
 from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.codecs.fits import fits_array_encoder
@@ -29,13 +29,14 @@ class LampCalibration(
 
     Parameters
     ----------
-    recipe_run_id : int
+    recipe_run_id
         id of the recipe run used to identify the workflow run this task is part of
-    workflow_name : str
+
+    workflow_name
         name of the workflow to which this instance of the task belongs
-    workflow_version : str
-        version of the workflow to which this instance of the task belongs
 
+    workflow_version
+        version of the workflow to which this instance of the task belongs
     """
 
     record_provenance = True
@@ -44,9 +45,11 @@ class LampCalibration(
         """
         For each beam.
 
-            - Gather input lamp gain and averaged dark arrays
-            - Calculate master lamp
-            - Write master lamp
+            - Normalize all input arrays by the number of frames per FPA
+            - Subtract the average dark frame corresponding to the matching readout exposure time
+            - Average all different readout exposure time arrays (if applicable)
+            - Interpolate over the hairlines
+            - Write final lamp gain to disk
             - Record quality metrics
 
         Returns
@@ -54,12 +57,14 @@ class LampCalibration(
         None
 
         """
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Generate lamp gains for {self.constants.num_beams} beams and {len(self.constants.lamp_readout_exp_times)} exposure times"
         ):
-            for readout_exp_time in self.constants.lamp_readout_exp_times:
-                for beam in range(1, self.constants.num_beams + 1):
-                    logger.info(f"Load dark for beam {beam}")
+            for beam in range(1, self.constants.num_beams + 1):
+                all_exp_time_arrays = []
+                for readout_exp_time in self.constants.lamp_readout_exp_times:
+                    apm_str = f"{beam = } and {readout_exp_time = }"
+                    logger.info(f"Load dark for beam {apm_str}")
                     dark_array = next(
                         self.read(
                             tags=VispTag.intermediate_frame_dark(
@@ -69,20 +74,45 @@ class LampCalibration(
                         )
                     )
 
-                    for state_num in range(
-                        1, self.constants.num_modstates + 1
-                    ):  # modulator states go from 1 to n
-                        logger.info(
-                            f"Calculating average lamp gain for beam {beam}, modulator state {state_num}"
+                    with self.telemetry_span(f"Computing gain for {apm_str}"):
+                        tags = [
+                            VispTag.input(),
+                            VispTag.frame(),
+                            VispTag.task_lamp_gain(),
+                            VispTag.readout_exp_time(readout_exp_time),
+                        ]
+                        input_lamp_gain_objs = self.read(
+                            tags=tags,
+                            decoder=fits_access_decoder,
+                            fits_access_class=VispL0FitsAccess,
                         )
-                        self.compute_and_write_master_lamp_gain_for_modstate(
-                            modstate=state_num,
-                            dark_array=dark_array,
-                            beam=beam,
-                            readout_exp_time=readout_exp_time,
+
+                        readout_normalized_arrays = (
+                            self.beam_access_get_beam(o.data, beam=beam) / o.num_raw_frames_per_fpa
+                            for o in input_lamp_gain_objs
+                        )
+                        averaged_gain_data = average_numpy_arrays(readout_normalized_arrays)
+
+                        dark_corrected_gain_data = next(
+                            subtract_array_from_arrays(averaged_gain_data, dark_array)
                         )
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+                        all_exp_time_arrays.append(dark_corrected_gain_data)
+
+                avg_gain_array = average_numpy_arrays(all_exp_time_arrays)
+                filtered_gain_data = self.corrections_mask_hairlines(avg_gain_array)
+
+                with self.telemetry_span(f"Writing gain array for {apm_str}"):
+                    self.write(
+                        data=filtered_gain_data,
+                        tags=[
+                            VispTag.intermediate_frame(beam=beam),
+                            VispTag.task_lamp_gain(),
+                        ],
+                        encoder=fits_array_encoder,
+                    )
+
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_lamp_frames: int = self.scratch.count_all(
                 tags=[
                     VispTag.input(),
@@ -94,73 +124,3 @@ class LampCalibration(
             self.quality_store_task_type_counts(
                 task_type=TaskName.lamp_gain.value, total_frames=no_of_raw_lamp_frames
             )
-
-    def compute_and_write_master_lamp_gain_for_modstate(
-        self,
-        modstate: int,
-        dark_array: np.ndarray,
-        beam: int,
-        readout_exp_time: float,
-    ) -> None:
-        """
-        Compute and write master lamp gain for a given modstate and beam.
-
-        Generally the algorithm is:
-            1. Average input gain arrays
-            2. Subtract average dark to get the dark corrected gain data
-            3. Normalize each beam to unity mean
-            4. Write to disk
-
-        Parameters
-        ----------
-        modstate : int
-            The modulator state to calculate the master lamp gain for
-
-        dark_array : np.ndarray
-            The master dark to be subtracted from each lamp gain file
-
-        beam : int
-            The number of the beam
-
-        readout_exp_time : float
-            Exposure time of single readout
-
-        Returns
-        -------
-        None
-        """
-        apm_str = f"{beam = }, {modstate = }, and {readout_exp_time = }"
-        # Get the input lamp gain arrays
-        tags = [
-            VispTag.input(),
-            VispTag.frame(),
-            VispTag.task_lamp_gain(),
-            VispTag.modstate(modstate),
-            VispTag.readout_exp_time(readout_exp_time),
-        ]
-        input_lamp_gain_objs = self.read(
-            tags=tags, decoder=fits_access_decoder, fits_access_class=VispL0FitsAccess
-        )
-
-        with self.apm_processing_step(f"Computing gain for {apm_str}"):
-
-            readout_normalized_arrays = (
-                self.beam_access_get_beam(o.data, beam=beam) / o.num_raw_frames_per_fpa
-                for o in input_lamp_gain_objs
-            )
-            averaged_gain_data = average_numpy_arrays(readout_normalized_arrays)
-
-            dark_corrected_gain_data = next(
-                subtract_array_from_arrays(averaged_gain_data, dark_array)
-            )
-            filtered_gain_data = self.corrections_mask_hairlines(dark_corrected_gain_data)
-
-        with self.apm_writing_step(f"Writing gain array for {apm_str}"):
-            self.write(
-                data=filtered_gain_data,
-                tags=[
-                    VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                    VispTag.task_lamp_gain(),
-                ],
-                encoder=fits_array_encoder,
-            )