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

dkist_processing_visp/tests/local_trial_workflows/local_trial_helpers.py

@@ -4,30 +4,45 @@ from datetime import datetime
 from pathlib import Path
 
 import asdf
+from astropy.io import fits
+from dkist_header_validator import spec122_validator
+from dkist_header_validator import spec214_validator
+from dkist_processing_common.codecs.fits import fits_array_decoder
+from dkist_processing_common.codecs.fits import fits_hdulist_encoder
 from dkist_processing_common.models.constants import BudName
+from dkist_processing_common.models.fits_access import MetadataKey
 from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.parsers.cs_step import CSStepFlower
 from dkist_processing_common.parsers.cs_step import NumCSStepBud
-from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
+from dkist_processing_common.parsers.retarder import RetarderNameBud
+from dkist_processing_common.parsers.task import PolcalTaskFlower
 from dkist_processing_common.parsers.task import TaskTypeFlower
+from dkist_processing_common.parsers.task import parse_header_ip_task_with_gains
 from dkist_processing_common.parsers.time import ExposureTimeFlower
 from dkist_processing_common.parsers.time import ReadoutExpTimeFlower
 from dkist_processing_common.parsers.time import TaskExposureTimesBud
 from dkist_processing_common.parsers.time import TaskReadoutExpTimesBud
+from dkist_processing_common.parsers.unique_bud import TaskUniqueBud
+from dkist_processing_common.parsers.unique_bud import UniqueBud
 from dkist_processing_common.tasks import ParseL0InputDataBase
 from dkist_processing_common.tasks import WorkflowTaskBase
 from dkist_processing_common.tasks.mixin.globus import GlobusTransferItem
-from dkist_processing_common.tasks.mixin.input_dataset import InputDatasetMixin
 from dkist_processing_common.tasks.trial_output_data import TransferTrialData
-from dkist_service_configuration.logging import logger
+from dkist_processing_math.statistics import average_numpy_arrays
+from loguru import logger
 
 from dkist_processing_visp.models.constants import VispBudName
+from dkist_processing_visp.models.constants import VispConstants
+from dkist_processing_visp.models.fits_access import VispMetadataKey
+from dkist_processing_visp.models.metric_code import VispMetricCode
 from dkist_processing_visp.models.parameters import VispParsingParameters
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.models.task_name import VispTaskName
 from dkist_processing_visp.parsers.modulator_states import ModulatorStateFlower
+from dkist_processing_visp.parsers.spectrograph_configuration import IncidentLightAngleBud
+from dkist_processing_visp.parsers.spectrograph_configuration import ReflectedLightAngleBud
 from dkist_processing_visp.parsers.time import DarkReadoutExpTimePickyBud
-from dkist_processing_visp.parsers.time import NonDarkTaskReadoutExpTimesBud
+from dkist_processing_visp.parsers.time import NonDarkNonPolcalTaskReadoutExpTimesBud
 from dkist_processing_visp.parsers.visp_l0_fits_access import VispL0FitsAccess
 from dkist_processing_visp.tasks.visp_base import VispTaskBase
 
@@ -255,7 +270,9 @@ class SaveSolarCal(SaveTaskTags):
     @property
     def tag_lists_to_save(self) -> list[list[str]]:
         return super().tag_lists_to_save + [
-            [VispTag.quality("TASK_TYPES"), VispTag.workflow_task("SolarCalibration")]
+            [VispTag.quality("TASK_TYPES"), VispTag.workflow_task("SolarCalibration")],
+            [VispTag.quality(VispMetricCode.solar_first_vignette)],
+            [VispTag.quality(VispMetricCode.solar_final_vignette)],
         ]
 
     @property
@@ -299,6 +316,22 @@ class LoadInstPolCal(LoadTaskTags):
         return "inst_pol_cal.asdf"
 
 
+class SaveCalibratedData(SaveTaskTags):
+    @property
+    def tag_lists_to_save(self) -> list[str]:
+        return [VispTag.frame(), VispTag.calibrated()]
+
+    @property
+    def relative_save_file(self) -> str:
+        return "calibrated_science.asdf"
+
+
+class LoadCalibratedData(LoadTaskTags):
+    @property
+    def relative_save_file(self) -> str:
+        return "calibrated_science.asdf"
+
+
 def set_observe_wavelength_task(wavelength: float = 630.0):
     class SetObserveWavelength(WorkflowTaskBase):
         def run(self):
@@ -322,6 +355,29 @@ class SetObserveExpTime(VispTaskBase):
         )
 
 
+class SetCadenceConstants(WorkflowTaskBase):
+    def run(self):
+        self.constants._update(
+            {
+                BudName.average_cadence.value: 1.0,
+                BudName.minimum_cadence.value: 0.0,
+                BudName.maximum_cadence.value: 3.0,
+                BudName.variance_cadence.value: 1,
+            }
+        )
+
+
+class SetAxesTypes(WorkflowTaskBase):
+    def run(self):
+        self.constants._update(
+            {
+                VispBudName.axis_1_type.value: "HPLT-TAN",
+                VispBudName.axis_2_type.value: "AWAV",
+                VispBudName.axis_3_type.value: "HPLN-TAN",
+            }
+        )
+
+
 class SetPolarimeterMode(VispTaskBase):
     def run(self):
         self.constants._update({VispBudName.polarimeter_mode.value: "observe_polarimetric"})
@@ -332,7 +388,7 @@ class SetNumModstates(VispTaskBase):
         self.constants._update({BudName.num_modstates.value: 10})
 
 
-class ParseCalOnlyL0InputData(ParseL0InputDataBase, InputDatasetMixin):
+class ParseCalOnlyL0InputData(ParseL0InputDataBase):
     """
     Parse input ViSP data. Subclassed from the ParseL0InputDataBase task in dkist_processing_common to add ViSP specific parameters.
 
@@ -358,7 +414,7 @@ class ParseCalOnlyL0InputData(ParseL0InputDataBase, InputDatasetMixin):
             workflow_name=workflow_name,
             workflow_version=workflow_version,
         )
-        self.parameters = VispParsingParameters(self.input_dataset_parameters)
+        self.parameters = VispParsingParameters(scratch=self.scratch)
 
     @property
     def fits_parsing_class(self):
@@ -368,38 +424,55 @@ class ParseCalOnlyL0InputData(ParseL0InputDataBase, InputDatasetMixin):
     @property
     def constant_buds(self):
         """Add ViSP specific constants to common constants."""
+        # TODO: Subclass ViSP parse task and *remove* unneeded things from this list
         return super().constant_buds + [
+            UniqueBud(constant_name=VispBudName.arm_id.value, metadata_key=VispMetadataKey.arm_id),
             NumCSStepBud(self.parameters.max_cs_step_time_sec),
-            NonDarkTaskReadoutExpTimesBud(),
+            NonDarkNonPolcalTaskReadoutExpTimesBud(),
             DarkReadoutExpTimePickyBud(),
+            RetarderNameBud(),
+            IncidentLightAngleBud(),
+            ReflectedLightAngleBud(),
+            TaskUniqueBud(
+                constant_name=VispBudName.grating_constant_inverse_mm.value,
+                metadata_key=VispMetadataKey.grating_constant_inverse_mm,
+                ip_task_types=[TaskName.observe.value, TaskName.solar_gain.value],
+                task_type_parsing_function=parse_header_ip_task_with_gains,
+            ),
+            TaskUniqueBud(
+                constant_name=VispBudName.solar_gain_ip_start_time.value,
+                metadata_key=MetadataKey.ip_start_time,
+                ip_task_types=TaskName.solar_gain,
+                task_type_parsing_function=parse_header_ip_task_with_gains,
+            ),
             TaskExposureTimesBud(
                 stem_name=VispBudName.lamp_exposure_times.value,
-                ip_task_type=TaskName.lamp_gain.value,
+                ip_task_types=TaskName.lamp_gain.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskExposureTimesBud(
                 stem_name=VispBudName.solar_exposure_times.value,
-                ip_task_type=TaskName.solar_gain.value,
+                ip_task_types=TaskName.solar_gain.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskExposureTimesBud(
                 stem_name=VispBudName.polcal_exposure_times.value,
-                ip_task_type=TaskName.polcal.value,
+                ip_task_types=TaskName.polcal.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskReadoutExpTimesBud(
                 stem_name=VispBudName.lamp_readout_exp_times.value,
-                ip_task_type=TaskName.lamp_gain.value,
+                ip_task_types=TaskName.lamp_gain.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskReadoutExpTimesBud(
                 stem_name=VispBudName.solar_readout_exp_times.value,
-                ip_task_type=TaskName.solar_gain.value,
+                ip_task_types=TaskName.solar_gain.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskReadoutExpTimesBud(
                 stem_name=VispBudName.polcal_readout_exp_times.value,
-                ip_task_type=TaskName.polcal.value,
+                ip_task_types=TaskName.polcal.value,
                 header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
         ]
@@ -410,12 +483,21 @@ class ParseCalOnlyL0InputData(ParseL0InputDataBase, InputDatasetMixin):
         return super().tag_flowers + [
             CSStepFlower(max_cs_step_time_sec=self.parameters.max_cs_step_time_sec),
             TaskTypeFlower(header_task_parsing_func=parse_header_ip_task_with_gains),
+            PolcalTaskFlower(),
             ModulatorStateFlower(),
             ExposureTimeFlower(),
             ReadoutExpTimeFlower(),
         ]
 
 
+class ValidateL1Output(VispTaskBase):
+    def run(self) -> None:
+        files = self.read(tags=[VispTag.output(), VispTag.frame()])
+        for f in files:
+            logger.info(f"Validating {f}")
+            spec214_validator.validate(f, extra=False)
+
+
 def transfer_trial_data_locally_task(
     trial_dir: str | Path,
 ):
@@ -443,3 +525,253 @@ def transfer_trial_data_locally_task(
                 os.system(f"cp {frame.source_path} {frame.destination_path}")
 
     return LocalTrialData
+
+
+def translate_122_to_214l0_task(suffix: str):
+    class Translate122To214L0(WorkflowTaskBase):
+        def run(self) -> None:
+            raw_dir = Path(self.scratch.scratch_base_path) / f"VISP{self.recipe_run_id:03n}"
+            if not os.path.exists(self.scratch.workflow_base_path):
+                os.makedirs(self.scratch.workflow_base_path)
+
+            if not raw_dir.exists():
+                raise FileNotFoundError(
+                    f"Expected to find a raw VISP{{run_id:03n}} folder in {self.scratch.scratch_base_path}"
+                )
+
+            for file in raw_dir.glob(f"*{suffix}"):
+                translated_file_name = Path(self.scratch.workflow_base_path) / os.path.basename(
+                    file
+                )
+                logger.info(f"Translating {file} -> {translated_file_name}")
+                hdl = fits.open(file)
+                i = 0
+                if hdl[i].data is None:
+                    i = 1
+
+                header = spec122_validator.validate_and_translate_to_214_l0(
+                    hdl[i].header, return_type=fits.HDUList
+                )[0].header
+
+                comp_hdu = fits.CompImageHDU(header=header, data=hdl[i].data)
+                comp_hdl = fits.HDUList([fits.PrimaryHDU(), comp_hdu])
+                comp_hdl.writeto(translated_file_name, overwrite=True)
+
+                hdl.close()
+                del hdl
+                comp_hdl.close()
+                del comp_hdl
+
+    return Translate122To214L0
+
+
+def tag_inputs_task(suffix: str):
+    class TagInputs(WorkflowTaskBase):
+        def run(self) -> None:
+            logger.info(f"Looking in {os.path.abspath(self.scratch.workflow_base_path)}")
+            input_file_list = list(self.scratch.workflow_base_path.glob(f"*.{suffix}"))
+            if len(input_file_list) == 0:
+                raise FileNotFoundError(
+                    f"Did not find any files matching '*.{suffix}' in {self.scratch.workflow_base_path}"
+                )
+            for file in input_file_list:
+                logger.info(f"Found {file}")
+                self.tag(path=file, tags=[VispTag.input(), VispTag.frame()])
+
+    return TagInputs
+
+
+class TagSingleSolarGainAsScience(VispTaskBase):
+    """Do."""
+
+    def run(self) -> None:
+        """Do."""
+        tags = [
+            VispTag.input(),
+            VispTag.frame(),
+            VispTag.task_solar_gain(),
+        ]
+        file_list = list(self.read(tags=tags))
+        first_hdul = fits.open(file_list[0])
+        idx = 1 if first_hdul[0].data is None else 0
+        first_header = first_hdul[idx].header
+        logger.info(f"Averaging {len(file_list)} files")
+        arrays = self.read(tags=tags, decoder=fits_array_decoder)
+        avg_array = average_numpy_arrays(arrays=arrays)
+
+        hdul = fits.HDUList([fits.PrimaryHDU(data=avg_array, header=first_header)])
+        hdul[0].header[VispMetadataKey.raster_scan_step] = 0
+        hdul[0].header[VispMetadataKey.total_raster_steps] = 1
+        hdul[0].header[VispMetadataKey.modulator_state] = 1
+        hdul[0].header["VSPPOLMD"] = "observe_intensity"
+        # hdul[0].header["POL_NOIS"] = 0.666
+        # hdul[0].header["POL_SENS"] = 0.666
+
+        new_tags = [
+            VispTag.task_observe(),
+            VispTag.input(),
+            VispTag.frame(),
+            VispTag.map_scan(1),
+            VispTag.raster_step(0),
+            VispTag.modstate(1),
+            VispTag.readout_exp_time(self.constants.solar_readout_exp_times[0]),
+        ]
+        file_name = self.write(data=hdul, tags=new_tags, encoder=fits_hdulist_encoder)
+        final_tags = self.tags(self.scratch.workflow_base_path / file_name)
+        logger.info(f"after re-tagging tags for {str(file_name) = } are {final_tags}")
+
+        del self.constants._db_dict[VispBudName.polarimeter_mode.value]
+        self.constants._update(
+            {
+                VispBudName.num_map_scans.value: 1,
+                VispBudName.num_raster_steps.value: 1,
+                VispBudName.polarimeter_mode.value: "observe_intensity",
+            }
+        )
+
+
+class TagModulatedSolarGainsAsScience(VispTaskBase):
+    """Do."""
+
+    def run(self) -> None:
+        """Do."""
+        for modstate in range(1, self.constants.num_modstates + 1):
+            tags = [
+                VispTag.task_solar_gain(),
+                VispTag.input(),
+                VispTag.frame(),
+                VispTag.modstate(modstate),
+            ]
+            file_list = list(self.read(tags=tags))
+            first_hdul = fits.open(file_list[0])
+            idx = 1 if first_hdul[0].data is None else 0
+            first_header = first_hdul[idx].header
+            logger.info(f"Averaging {len(file_list)} files")
+            arrays = self.read(tags=tags, decoder=fits_array_decoder)
+            avg_array = average_numpy_arrays(arrays=arrays)
+
+            hdul = fits.HDUList([fits.PrimaryHDU(data=avg_array, header=first_header)])
+            hdul[0].header[VispMetadataKey.raster_scan_step] = 0
+            hdul[0].header[VispMetadataKey.total_raster_steps] = 1
+            hdul[0].header[VispMetadataKey.modulator_state] = modstate
+            hdul[0].header["VSPPOLMD"] = "observe_polarimetric"
+
+            new_tags = [
+                VispTag.task_observe(),
+                VispTag.input(),
+                VispTag.frame(),
+                VispTag.map_scan(1),
+                VispTag.raster_step(0),
+                VispTag.modstate(modstate),
+                VispTag.readout_exp_time(self.constants.solar_readout_exp_times[0]),
+            ]
+            file_name = self.write(data=hdul, tags=new_tags, encoder=fits_hdulist_encoder)
+            final_tags = self.tags(self.scratch.workflow_base_path / file_name)
+            logger.info(f"after re-tagging tags for {str(file_name) = } are {final_tags}")
+
+        del self.constants._db_dict[VispBudName.polarimeter_mode.value]
+        self.constants._update(
+            {
+                VispBudName.num_map_scans.value: 1,
+                VispBudName.num_raster_steps.value: 1,
+                VispBudName.polarimeter_mode.value: "observe_polarimetric",
+            }
+        )
+        logger.info(f"{self.constants.correct_for_polarization = }")
+
+
+class SaveSolarGainAsScience(SaveTaskTags):
+    @property
+    def tag_lists_to_save(self) -> list[str]:
+        return [VispTag.task_observe(), VispTag.input(), VispTag.frame()]
+
+    @property
+    def relative_save_file(self) -> str:
+        return "solar_gain_as_science.asdf"
+
+
+def load_solar_gain_as_science_task(force_intensity_only: bool):
+    class LoadSolarGainAsScience(LoadTaskTags):
+        constants: VispConstants
+
+        @property
+        def constants_model_class(self):
+            """Get ViSP pipeline constants."""
+            return VispConstants
+
+        @property
+        def relative_save_file(self) -> str:
+            return "solar_gain_as_science.asdf"
+
+        def run(self):
+            super().run()
+            del self.constants._db_dict[VispBudName.polarimeter_mode.value]
+            self.constants._update(
+                {
+                    VispBudName.num_map_scans.value: 1,
+                    VispBudName.num_raster_steps.value: 1,
+                    VispBudName.polarimeter_mode.value: "observe_intensity" if force_intensity_only else "observe_polarimetric",  # fmt: skip
+                }
+            )
+            logger.info(f"{self.constants.correct_for_polarization = }")
+
+    return LoadSolarGainAsScience
+
+
+class SavePolcalAsScience(WorkflowTaskBase):
+    constants: VispConstants
+
+    @property
+    def constants_model_class(self):
+        """Get ViSP pipeline constants."""
+        return VispConstants
+
+    @property
+    def tag_lists_to_save(self) -> list[str]:
+        return [VispTag.task_observe(), VispTag.input(), VispTag.frame()]
+
+    @property
+    def relative_save_file(self) -> str:
+        return "polcal_as_science.asdf"
+
+    def run(self):
+        file_tag_dict = dict()
+        tag_list_list = self.tag_lists_to_save
+        if isinstance(tag_list_list[0], str):
+            tag_list_list = [tag_list_list]
+
+        pcas_constants = {
+            VispBudName.num_map_scans.value: self.constants.num_map_scans,
+            VispBudName.num_raster_steps.value: self.constants.num_raster_steps,
+        }
+
+        for tags_to_save in tag_list_list:
+            path_list = self.read(tags=tags_to_save)
+            save_dir = self.scratch.workflow_base_path / Path(self.relative_save_file).stem
+            save_dir.mkdir(exist_ok=True)
+            for p in path_list:
+                copied_path = shutil.copy(str(p), save_dir)
+                tags = self.tags(p)
+                file_tag_dict[copied_path] = tags
+
+        full_save_file = self.scratch.workflow_base_path / self.relative_save_file
+        tree = {"file_tag_dict": file_tag_dict, "pcas_constants": pcas_constants}
+        af = asdf.AsdfFile(tree)
+        af.write_to(full_save_file)
+        logger.info(f"Saved polcal science frames to {full_save_file}")
+
+
+class LoadPolcalAsScience(WorkflowTaskBase):
+    @property
+    def relative_save_file(self) -> str:
+        return "polcal_as_science.asdf"
+
+    def run(self):
+        full_save_file = self.scratch.workflow_base_path / self.relative_save_file
+        with asdf.open(full_save_file) as af:
+            for f, t in af.tree["file_tag_dict"].items():
+                self.tag(path=f, tags=t)
+
+            self.constants._db_dict.update(**af.tree["pcas_constants"])
+
+        logger.info(f"Loaded database entries from {full_save_file}")

dkist_processing_visp/tests/test_assemble_movie.py

@@ -1,6 +1,5 @@
 import pytest
 from dkist_processing_common._util.scratch import WorkflowFileSystem
-from dkist_processing_common.tests.conftest import FakeGQLClient
 
 from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.assemble_movie import AssembleVispMovie
@@ -49,9 +48,9 @@ def assemble_task_with_tagged_movie_frames(tmp_path, recipe_run_id, init_visp_co
             task._purge()
 
 
-def test_assemble_movie(assemble_task_with_tagged_movie_frames, mocker):
+def test_assemble_movie(assemble_task_with_tagged_movie_frames, mocker, fake_gql_client):
     mocker.patch(
-        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=FakeGQLClient
+        "dkist_processing_common.tasks.mixin.metadata_store.GraphQLClient", new=fake_gql_client
     )
     task, num_maps = assemble_task_with_tagged_movie_frames
     write_movie_frames_to_task(task, num_maps)

dkist_processing_visp/tests/test_assemble_quality.py

@@ -1,27 +1,65 @@
+from typing import Generator
 from unittest.mock import MagicMock
 
+import numpy as np
 import pytest
+from dkist_processing_common._util.scratch import WorkflowFileSystem
+from dkist_processing_common.codecs.asdf import asdf_encoder
+from dkist_processing_common.codecs.quality import quality_data_decoder
 
+from dkist_processing_visp.models.metric_code import VispMetricCode
+from dkist_processing_visp.models.tags import VispTag
 from dkist_processing_visp.tasks.l1_output_data import VispAssembleQualityData
 
 
 @pytest.fixture
-def visp_assemble_quality_data_task(tmp_path, recipe_run_id) -> VispAssembleQualityData:
+def visp_assemble_quality_data_task(
+    tmp_path, recipe_run_id
+) -> Generator[VispAssembleQualityData, None, None]:
 
     with VispAssembleQualityData(
         recipe_run_id=recipe_run_id, workflow_name="visp_assemble_quality", workflow_version="VX.Y"
     ) as task:
+        task.scratch = WorkflowFileSystem(scratch_base_path=tmp_path, recipe_run_id=recipe_run_id)
         yield task
         task._purge()
 
 
+def write_raw_vignette_metrics_to_task(task):
+    for beam in [1, 2]:
+        dummy_vec = np.arange(10)
+        first_vignette_quality_outputs = {
+            "output_wave_vec": dummy_vec,
+            "input_spectrum": dummy_vec,
+            "best_fit_atlas": dummy_vec,
+            "best_fit_continuum": dummy_vec,
+            "residuals": dummy_vec,
+        }
+        task.write(
+            data=first_vignette_quality_outputs,
+            tags=[VispTag.quality(VispMetricCode.solar_first_vignette), VispTag.beam(beam)],
+            encoder=asdf_encoder,
+        )
+        final_correction_quality_outputs = {
+            "output_wave_vec": dummy_vec,
+            "median_spec": dummy_vec,
+            "low_deviation": dummy_vec,
+            "high_deviation": dummy_vec,
+        }
+        task.write(
+            data=final_correction_quality_outputs,
+            tags=[VispTag.quality(VispMetricCode.solar_final_vignette), VispTag.beam(beam)],
+            encoder=asdf_encoder,
+        )
+
+
 @pytest.fixture
 def dummy_quality_data() -> list[dict]:
     return [{"dummy_key": "dummy_value"}]
 
 
 @pytest.fixture
-def quality_assemble_data_mock(mocker, dummy_quality_data) -> MagicMock:
+def common_quality_assemble_data_mock(mocker, dummy_quality_data) -> MagicMock:
     yield mocker.patch(
         "dkist_processing_common.tasks.mixin.quality.QualityMixin.quality_assemble_data",
         return_value=dummy_quality_data,
@@ -29,13 +67,60 @@ def quality_assemble_data_mock(mocker, dummy_quality_data) -> MagicMock:
     )
 
 
-def test_correct_polcal_label_list(visp_assemble_quality_data_task, quality_assemble_data_mock):
+def test_vignette_metrics_built(visp_assemble_quality_data_task):
+    """
+    Given: A `VispAssembleQualityData` task with raw vignette metrics in scratch
+    When: Building the quality report data
+    Then: The vignette metrics are included in the data
+    """
+    task = visp_assemble_quality_data_task
+    write_raw_vignette_metrics_to_task(task)
+
+    task()
+
+    final_report_list = list(task.read(tags=VispTag.quality_data(), decoder=quality_data_decoder))
+    assert len(final_report_list) == 1
+    final_report = final_report_list[0]
+
+    initial_vignette_metrics = list(
+        filter(lambda i: i["name"].startswith("Initial Vignette Estimation"), final_report)
+    )
+    assert len(initial_vignette_metrics) == 2
+    facet_set = set()
+    for m in initial_vignette_metrics:
+        assert m["metric_code"] == VispMetricCode.solar_first_vignette.value
+        assert m["description"]
+        assert m["multi_plot_data"]
+        facet_set.add(m["facet"])
+
+    assert facet_set == {"BEAM_1", "BEAM_2"}
+
+    final_vignette_metrics = list(
+        filter(lambda i: i["name"].startswith("Final Vignette Estimation"), final_report)
+    )
+    assert len(final_vignette_metrics) == 2
+    facet_set = set()
+    for m in final_vignette_metrics:
+        assert m["metric_code"] == VispMetricCode.solar_final_vignette.value
+        assert m["description"]
+        assert m["multi_plot_data"]
+        facet_set.add(m["facet"])
+
+    assert facet_set == {"BEAM_1", "BEAM_2"}
+
+
+def test_correct_polcal_label_list(
+    visp_assemble_quality_data_task, common_quality_assemble_data_mock
+):
     """
     Given: A VispAssembleQualityData task
     When: Calling the task
     Then: The correct polcal_label_list property is passed to .quality_assemble_data
     """
     task = visp_assemble_quality_data_task
+    write_raw_vignette_metrics_to_task(task)
 
     task()
-    quality_assemble_data_mock.assert_called_once_with(task, polcal_label_list=["Beam 1", "Beam 2"])
+    common_quality_assemble_data_mock.assert_called_once_with(
+        task, polcal_label_list=["Beam 1", "Beam 2"]
+    )