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

dkist_processing_visp/tasks/assemble_movie.py

@@ -1,4 +1,5 @@
 """ViSP-specific assemble movie task subclass."""
+
 from dkist_processing_common.tasks import AssembleMovie
 from PIL import ImageDraw
 

dkist_processing_visp/tasks/background_light.py

@@ -1,4 +1,5 @@
 """ViSP background light calibration task."""
+
 import gc
 import time
 
@@ -114,7 +115,7 @@ class BackgroundLightCalibration(
             del full_background_light
             gc.collect()
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             self.quality_store_task_type_counts(
                 task_type=VispTaskName.background.value,
                 total_frames=num_used_polcal_files,

dkist_processing_visp/tasks/dark.py

@@ -1,4 +1,5 @@
 """Visp dark task."""
+
 from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.fits import fits_array_encoder
 from dkist_processing_common.models.task_name import TaskName
@@ -49,7 +50,7 @@ class DarkCalibration(VispTaskBase, BeamAccessMixin, QualityMixin):
         required_readout_exp_times = list(self.constants.non_dark_task_readout_exp_times)
         logger.info(f"{required_readout_exp_times = }")
 
-        with self.apm_task_step(
+        with self.telemetry_span(
             f"Calculating dark frames for {self.constants.num_beams} beams and "
             f"{len(required_readout_exp_times)} readout exp times"
         ):
@@ -74,7 +75,7 @@ class DarkCalibration(VispTaskBase, BeamAccessMixin, QualityMixin):
                         fits_access_class=VispL0FitsAccess,
                     )
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Calculating dark for {readout_exp_time = } and {beam = }"
                     ):
                         readout_normalized_arrays = (
@@ -83,7 +84,7 @@ class DarkCalibration(VispTaskBase, BeamAccessMixin, QualityMixin):
                         )
                         averaged_dark_array = average_numpy_arrays(readout_normalized_arrays)
 
-                    with self.apm_writing_step(f"Writing dark for {readout_exp_time = } {beam = }"):
+                    with self.telemetry_span(f"Writing dark for {readout_exp_time = } {beam = }"):
                         self.write(
                             data=averaged_dark_array,
                             tags=VispTag.intermediate_frame_dark(
@@ -92,7 +93,7 @@ class DarkCalibration(VispTaskBase, BeamAccessMixin, QualityMixin):
                             encoder=fits_array_encoder,
                         )
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_dark_frames: int = self.scratch.count_all(
                 tags=[
                     VispTag.input(),

dkist_processing_visp/tasks/geometric.py

@@ -3,12 +3,15 @@ Visp geometric calibration task.
 
 See :doc:`this page </geometric>` for more information.
 """
+
 from typing import Generator
 
 import numpy as np
+import peakutils
 import peakutils as pku
 import scipy.ndimage as spnd
 import scipy.optimize as spo
+import scipy.signal as sps
 import skimage.exposure as skie
 import skimage.metrics as skim
 import skimage.morphology as skimo
@@ -32,7 +35,6 @@ from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
 from dkist_processing_visp.tasks.mixin.beam_access import BeamAccessMixin
 from dkist_processing_visp.tasks.mixin.corrections import CorrectionsMixin
-from dkist_processing_visp.tasks.mixin.line_zones import LineZonesMixin
 from dkist_processing_visp.tasks.visp_base import VispTaskBase
 
 __all__ = ["GeometricCalibration"]
@@ -43,7 +45,6 @@ class GeometricCalibration(
     BeamAccessMixin,
     CorrectionsMixin,
     QualityMixin,
-    LineZonesMixin,
 ):
     """
     Task class for computing the spectral geometry. Geometry is represented by three quantities.
@@ -85,15 +86,15 @@ class GeometricCalibration(
         """
         # This lives outside the run() loops and has its own internal loops because the angle calculation
         # only happens for a single modstate
-        with self.apm_processing_step("Basic corrections"):
+        with self.telemetry_span("Basic corrections"):
             self.do_basic_corrections()
 
         for beam in range(1, self.constants.num_beams + 1):
-            with self.apm_task_step(f"Generating geometric calibrations for {beam = }"):
-                with self.apm_processing_step(f"Computing and writing angle for {beam = }"):
+            with self.telemetry_span(f"Generating geometric calibrations for {beam = }"):
+                with self.telemetry_span(f"Computing and writing angle for {beam = }"):
                     angle = self.compute_beam_angle(beam=beam)
                     if beam == 2:
-                        with self.apm_processing_step("Refining beam 2 angle"):
+                        with self.telemetry_span("Refining beam 2 angle"):
                             ang_corr = self.refine_beam2_angle(angle)
                         logger.info(f"Beam 2 angle refinement = {np.rad2deg(ang_corr)} deg")
                         angle += ang_corr
@@ -101,14 +102,12 @@ class GeometricCalibration(
                     self.write_angle(angle=angle, beam=beam)
 
                 for modstate in range(1, self.constants.num_modstates + 1):
-                    with self.apm_processing_step(
-                        f"Removing angle from {beam = } and {modstate = }"
-                    ):
+                    with self.telemetry_span(f"Removing angle from {beam = } and {modstate = }"):
                         angle_corr_array = self.remove_beam_angle(
                             angle=angle, beam=beam, modstate=modstate
                         )
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Computing state offset for {beam = } and {modstate = }"
                     ):
                         state_offset = self.compute_modstate_offset(
@@ -116,7 +115,7 @@ class GeometricCalibration(
                         )
                         self.write_state_offset(offset=state_offset, beam=beam, modstate=modstate)
 
-                    with self.apm_processing_step(
+                    with self.telemetry_span(
                         f"Removing state offset for {beam = } and {modstate = }"
                     ):
                         self.remove_state_offset(
@@ -126,13 +125,13 @@ class GeometricCalibration(
                             modstate=modstate,
                         )
 
-                with self.apm_processing_step(f"Computing spectral shifts for {beam = }"):
+                with self.telemetry_span(f"Computing spectral shifts for {beam = }"):
                     spec_shifts = self.compute_spectral_shifts(beam=beam)
 
-                with self.apm_writing_step(f"Writing spectral shifts for {beam = }"):
+                with self.telemetry_span(f"Writing spectral shifts for {beam = }"):
                     self.write_spectral_shifts(shifts=spec_shifts, beam=beam)
 
-        with self.apm_processing_step("Computing and logging quality metrics"):
+        with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_geo_frames: int = self.scratch.count_all(
                 tags=[
                     VispTag.input(),
@@ -275,7 +274,12 @@ class GeometricCalibration(
         self.prep_input_solar_gain()
 
     def prep_lamp_gain(self):
-        """Apply dark corrections fo INPUT lamp frames."""
+        """
+        Create average, dark-corrected lamp gain images for each modstate from INPUT lamp gains.
+
+        This is different from the results of the `~dkist_processing_visp.tasks.lamp.LampCalibration` task because in
+        that task the hairlines are masked out, but here we *need* the hairlines to compute the rotation angle.
+        """
         for readout_exp_time in self.constants.lamp_readout_exp_times:
             for beam in range(1, self.constants.num_beams + 1):
                 logger.info(
@@ -1075,11 +1079,11 @@ class GeometricCalibration(
         `compute_single_state_offset`.
         """
         zone_kwargs = {
-            "prominence": self.parameters.solar_zone_prominence,
-            "width": self.parameters.solar_zone_width,
-            "bg_order": self.parameters.solar_zone_bg_order,
-            "normalization_percentile": self.parameters.solar_zone_normalization_percentile,
-            "rel_height": self.parameters.solar_zone_rel_height,
+            "prominence": self.parameters.geo_zone_prominence,
+            "width": self.parameters.geo_zone_width,
+            "bg_order": self.parameters.geo_zone_bg_order,
+            "normalization_percentile": self.parameters.geo_zone_normalization_percentile,
+            "rel_height": self.parameters.geo_zone_rel_height,
         }
         zones = self.compute_line_zones(array, **zone_kwargs)
         logger.info(f"Found {zones = }")
@@ -1089,6 +1093,114 @@ class GeometricCalibration(
 
         return mask
 
+    def compute_line_zones(
+        self,
+        spec_2d: np.ndarray,
+        prominence: float = 0.2,
+        width: float = 2,
+        bg_order: int = 22,
+        normalization_percentile: int = 99,
+        rel_height: float = 0.97,
+    ) -> list[tuple[int, int]]:
+        """
+        Identify spectral regions around strong spectra features.
+
+        Parameters
+        ----------
+        spec_2d
+            Data
+
+        prominence
+            Zone prominence threshold used to identify strong spectral features
+
+        width
+            Zone width
+
+        bg_order
+            Order of polynomial fit used to remove continuum when identifying strong spectral features
+
+        normalization_percentile
+            Compute this percentile of the data along a specified axis
+
+        rel_height
+            The relative height at which the peak width is measured as a percentage of its prominence. E.g., 1.0 measures
+            the peak width at the lowest contour line.
+
+        Returns
+        -------
+        regions
+            List of indices defining the found spectral lines
+
+        """
+        logger.info(
+            f"Finding zones using {prominence=}, {width=}, {bg_order=}, {normalization_percentile=}, and {rel_height=}"
+        )
+        # Compute average along slit to improve signal. Line smearing isn't important here
+        avg_1d = np.mean(spec_2d, axis=1)
+
+        # Convert to an emission spectrum and remove baseline continuum so peakutils has an easier time
+        em_spec = -1 * avg_1d + avg_1d.max()
+        em_spec /= np.nanpercentile(em_spec, normalization_percentile)
+        baseline = peakutils.baseline(em_spec, bg_order)
+        em_spec -= baseline
+
+        # Find indices of peaks
+        peak_idxs = sps.find_peaks(em_spec, prominence=prominence, width=width)[0]
+
+        # Find the rough width based only on the height of the peak
+        #  rips and lips are the right and left borders of the region around the peak
+        _, _, rips, lips = sps.peak_widths(em_spec, peak_idxs, rel_height=rel_height)
+
+        # Convert to ints so they can be used as indices
+        rips = np.floor(rips).astype(int)
+        lips = np.ceil(lips).astype(int)
+
+        # Remove any regions that are contained within another region
+        ranges_to_remove = self.identify_overlapping_zones(rips, lips)
+        rips = np.delete(rips, ranges_to_remove)
+        lips = np.delete(lips, ranges_to_remove)
+
+        return list(zip(rips, lips))
+
+    @staticmethod
+    def identify_overlapping_zones(rips: np.ndarray, lips: np.ndarray) -> list[int]:
+        """
+        Identify line zones that overlap with other zones. Any overlap greater than 1 pixel is flagged.
+
+        Parameters
+        ----------
+        rips
+            Right borders of the region around the peak
+
+        lips
+            Left borders of the region around the peak
+
+        Returns
+        -------
+        overlapping regions
+            List indices into the input arrays that represent an overlapped region that can be removed
+        """
+        all_ranges = [np.arange(zmin, zmax) for zmin, zmax in zip(rips, lips)]
+        ranges_to_remove = []
+        for i in range(len(all_ranges)):
+            target_range = all_ranges[i]
+            for j in range(i + 1, len(all_ranges)):
+                if (
+                    np.intersect1d(target_range, all_ranges[j]).size > 1
+                ):  # Allow for a single overlap just to be nice
+                    if target_range.size > all_ranges[j].size:
+                        ranges_to_remove.append(j)
+                        logger.info(
+                            f"Zone ({all_ranges[j][0]}, {all_ranges[j][-1]}) inside zone ({target_range[0]}, {target_range[-1]})"
+                        )
+                    else:
+                        ranges_to_remove.append(i)
+                        logger.info(
+                            f"Zone ({target_range[0]}, {target_range[-1]}) inside zone ({all_ranges[j][0]}, {all_ranges[j][-1]})"
+                        )
+
+        return ranges_to_remove
+
     @staticmethod
     def high_pass_filter_array(array: np.ndarray) -> np.ndarray:
         """Perform a simple high-pass filter to accentuate narrow features (hairlines and spectra)."""

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
 
@@ -88,22 +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("Generate polcal DARK frame"):
+            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.apm_processing_step("Generate polcal GAIN frame"):
+            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.apm_processing_step(f"Reducing CS steps for {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)
@@ -122,7 +123,7 @@ class InstrumentPolarizationCalibration(
                     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(
@@ -148,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,
@@ -159,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(),
@@ -339,7 +340,7 @@ 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(
@@ -368,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)
 
@@ -388,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,

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()