dkist-processing-dlnirsp 0.32.8__py3-none-any.whl → 0.33.0__py3-none-any.whl

dkist_processing_dlnirsp/tasks/parse.py

@@ -13,6 +13,7 @@ from dkist_processing_common.parsers.single_value_single_key_flower import (
     SingleValueSingleKeyFlower,
 )
 from dkist_processing_common.parsers.task import PolcalTaskFlower
+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 ObsIpStartTimeBud
 from dkist_processing_common.parsers.time import TaskExposureTimesBud
@@ -36,7 +37,6 @@ from dkist_processing_dlnirsp.parsers.mosaic import NumMosaicRepeatsBud
 from dkist_processing_dlnirsp.parsers.mosaic import NumMosaicXTilesBud
 from dkist_processing_dlnirsp.parsers.mosaic import NumMosaicYTilesBud
 from dkist_processing_dlnirsp.parsers.task import DlnirspTaskTypeFlower
-from dkist_processing_dlnirsp.parsers.task import parse_header_ip_task
 from dkist_processing_dlnirsp.parsers.time import DLnirspSolarGainIpStartTimeBud
 from dkist_processing_dlnirsp.parsers.time import DlnirspTimeObsBud
 from dkist_processing_dlnirsp.parsers.wavelength import ObserveWavelengthBud
@@ -145,6 +145,11 @@ class ParseL0DlnirspLinearizedData(ParseDataBase):
         """Add DLNIRSP specific constants to common constants."""
         return default_constant_bud_factory() + [
             ObserveWavelengthBud(),
+            TaskUniqueBud(
+                constant_name=DlnirspBudName.obs_ip_end_time.value,
+                metadata_key=MetadataKey.ip_end_time,
+                ip_task_types=TaskName.observe,
+            ),
             DLnirspSolarGainIpStartTimeBud(),
             NumCSStepBud(max_cs_step_time_sec=self.parameters.max_cs_step_time_sec),
             UniqueBud(
@@ -175,42 +180,42 @@ class ParseL0DlnirspLinearizedData(ParseDataBase):
             TaskExposureTimesBud(
                 stem_name=DlnirspBudName.lamp_gain_exposure_times.value,
                 ip_task_types=TaskName.lamp_gain.value,
-                header_task_parsing_func=parse_header_ip_task,
+                header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskExposureTimesBud(
                 stem_name=DlnirspBudName.solar_gain_exposure_times.value,
                 ip_task_types=TaskName.solar_gain.value,
-                header_task_parsing_func=parse_header_ip_task,
+                header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskExposureTimesBud(
                 stem_name=DlnirspBudName.observe_exposure_times.value,
                 ip_task_types=TaskName.observe.value,
-                header_task_parsing_func=parse_header_ip_task,
+                header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskExposureTimesBud(
                 stem_name=DlnirspBudName.polcal_exposure_times.value,
                 ip_task_types=TaskName.polcal.value,
-                header_task_parsing_func=parse_header_ip_task,
+                header_task_parsing_func=parse_header_ip_task_with_gains,
             ),
             TaskNearFloatBud(
                 constant_name=DlnirspBudName.arm_position_mm.value,
                 metadata_key=DlnirspMetadataKey.arm_position_mm,
                 ip_task_types=[TaskName.solar_gain.value, TaskName.observe.value],
                 tolerance=0.01,
-                task_type_parsing_function=parse_header_ip_task,
+                task_type_parsing_function=parse_header_ip_task_with_gains,
             ),
             TaskUniqueBud(
                 constant_name=DlnirspBudName.grating_constant_inverse_mm.value,
                 metadata_key=DlnirspMetadataKey.grating_constant_inverse_mm,
                 ip_task_types=[TaskName.solar_gain.value, TaskName.observe.value],
-                task_type_parsing_function=parse_header_ip_task,
+                task_type_parsing_function=parse_header_ip_task_with_gains,
             ),
             TaskNearFloatBud(
                 constant_name=DlnirspBudName.grating_position_deg.value,
                 metadata_key=DlnirspMetadataKey.grating_position_deg,
                 ip_task_types=[TaskName.solar_gain.value, TaskName.observe.value],
                 tolerance=0.01,
-                task_type_parsing_function=parse_header_ip_task,
+                task_type_parsing_function=parse_header_ip_task_with_gains,
             ),
         ]
 

dkist_processing_dlnirsp/tasks/solar.py

@@ -8,6 +8,7 @@ from dkist_processing_common.models.task_name import TaskName
 from dkist_processing_common.tasks.mixin.quality import QualityMixin
 from dkist_processing_math.arithmetic import divide_arrays_by_array
 from dkist_processing_math.arithmetic import subtract_array_from_arrays
+from dkist_processing_math.linear_algebra import nd_left_matrix_multiply
 from dkist_processing_math.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
 
@@ -17,8 +18,10 @@ from dkist_processing_dlnirsp.tasks.mixin.corrections import CorrectionsMixin
 
 __all__ = ["SolarCalibration"]
 
+from dkist_processing_dlnirsp.tasks.mixin.group_id import GroupIdMixin
 
-class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
+
+class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin, GroupIdMixin):
     """
     Task for computing an intermediate solar gain image.
 
@@ -33,21 +36,23 @@ class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
         """
         Compute a solar gain image with the solar spectrum removed.
 
-        1. Apply dark, lamp, and geometric corrections to all solar gain frames and average them together.
-
-        2. Compute a single characteristic spectrum across all slitbeams and place into the full array
-
-        3. Re-apply the geometric calibration (spectral shifts and scales) to the characteristic spectra
-
-        4. Remove the characteristic solar spectra from the dark-corrected solar gain image
+        #. Compute dark-only and fully (additional lamp and geometric) corrected solar gain data.
 
-        5. Rescale each slitbeam to have the same average value as the raw, dark corrected solar gain image
+           a. For polarimetric data, compute a separate average for each modstate and then demodulate and use the Stokes I data
+           #. For intensity data, use the average over all modstates (there should be only one).
 
-        6. Write the final, solar-spectrum-removed, solar gain image.
+        #. Compute a single characteristic spectrum across all slitbeams and place into the full array
+        #. Re-apply the geometric calibration (spectral shifts and scales) to the characteristic spectra
+        #. Remove the characteristic solar spectra from the dark-corrected solar gain image
+        #. Rescale each slitbeam to have the same average value as the raw, dark corrected solar gain image
+        #. Write the final, solar-spectrum-removed solar gain image.
         """
         with self.telemetry_span("Apply dark and lamp corrections"):
             logger.info("Computing average dark/lamp corrected gains")
-            self.compute_average_corrected_gains()
+            if self.constants.correct_for_polarization:
+                self.compute_demodulated_I_gains()
+            else:
+                self.compute_intensity_only_avg_gains()
 
         with self.telemetry_span("Compute characteristic spectra"):
             logger.info("Computing characteristic spectra")
@@ -81,9 +86,12 @@ class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
 
         with self.telemetry_span("Write solar flat calibration"):
             logger.info("Writing solar flat calibration")
+            tags = [DlnirspTag.intermediate_frame(), DlnirspTag.task_solar_gain()]
+            if self.constants.correct_for_polarization:
+                tags.append(DlnirspTag.stokes("I"))
             self.write(
                 data=cleaned_gain,
-                tags=[DlnirspTag.intermediate_frame(), DlnirspTag.task_solar_gain()],
+                tags=tags,
                 encoder=fits_array_encoder,
             )
 
@@ -96,13 +104,110 @@ class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
                 task_type=TaskName.solar_gain.value, total_frames=no_of_raw_solar_frames
             )
 
-    def compute_average_corrected_gains(self):
+    def compute_intensity_only_avg_gains(self):
+        """
+        Compute dark-only and fully-corrected average solar gains for intensity mode data.
+
+        The raw solar gain frames are averaged over all modstates (of which there should only be one anyway).
+        The lamp-corrected data also have geometric corrections applied prior to saving.
+        """
+        dark_corr, lamp_corr = self.compute_average_corrected_gain_for_modstate(modstate=None)
+
+        # This is the array we remove the characteristic solar spectrum from to produce the final gain array
+        self.write(
+            data=dark_corr,
+            tags=[DlnirspTag.intermediate_frame(), DlnirspTag.task("SC_DARK_ONLY")],
+            encoder=fits_array_encoder,
+        )
+
+        geo_corr_gain = self.apply_geometric_correction(lamp_corr)
+
+        self.write(
+            data=geo_corr_gain,
+            tags=[DlnirspTag.intermediate_frame(), DlnirspTag.task("SC_FULL_CORR")],
+            encoder=fits_array_encoder,
+        )
+
+    def compute_demodulated_I_gains(self):
+        """
+        Compute demodulated dark-only and fully-corrected solar gain data.
+
+        The raw solar gains are averaged once for each modstate before having dark and lamp corrections applied.
+        These two sets of arrays (dark-only and dark + lamp) are then demodulated. The resulting Stokes I are then saved
+        to disk for later use. The lamp-corrected data have a geometric correction applied prior to saving.
+        """
+        dark_corr_modstate_stack = np.empty(
+            self.unrectified_array_shape + (self.constants.num_modstates,)
+        )
+        lamp_corr_modstate_stack = np.empty_like(dark_corr_modstate_stack)
+        for modstate in range(1, self.constants.num_modstates + 1):
+            dark_corr, lamp_corr = self.compute_average_corrected_gain_for_modstate(modstate)
+            dark_corr_modstate_stack[:, :, modstate - 1] = dark_corr
+            lamp_corr_modstate_stack[:, :, modstate - 1] = lamp_corr
+
+        logger.info("Loading demodulation matrices")
+        demod_matrices = next(
+            self.read(
+                tags=[DlnirspTag.intermediate_frame(), DlnirspTag.task_demodulation_matrices()],
+                decoder=fits_array_decoder,
+            )
+        )
+
+        demodulated_dark_corr_gain = nd_left_matrix_multiply(
+            vector_stack=dark_corr_modstate_stack, matrix_stack=demod_matrices
+        )
+        demodulated_lamp_corr_gain = nd_left_matrix_multiply(
+            vector_stack=lamp_corr_modstate_stack, matrix_stack=demod_matrices
+        )
+
+        dark_corr_I = demodulated_dark_corr_gain[:, :, 0]
+        lamp_corr_I = demodulated_lamp_corr_gain[:, :, 0]
+
+        # This is the array we remove the characteristic solar spectrum from to produce the final gain array
+        self.write(
+            data=dark_corr_I,
+            tags=[
+                DlnirspTag.intermediate_frame(),
+                DlnirspTag.task("SC_DARK_ONLY"),
+                DlnirspTag.stokes("I"),
+            ],
+            encoder=fits_array_encoder,
+        )
+
+        geo_corr_gain = self.apply_geometric_correction(lamp_corr_I)
+
+        self.write(
+            data=geo_corr_gain,
+            tags=[
+                DlnirspTag.intermediate_frame(),
+                DlnirspTag.task("SC_FULL_CORR"),
+                DlnirspTag.stokes("I"),
+            ],
+            encoder=fits_array_encoder,
+        )
+
+    def compute_average_corrected_gain_for_modstate(
+        self, modstate: int | None
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
-        Compute a single, averaged frame from all linearized solar gain frames.
+        Compute a single, averaged frame from all linearized solar gain frames for a given modstate.
 
-        Also apply dark, lamp, and geometric calibrations. If there are multiple exposure times present in the solar
+        Also apply dark and lamp corrections. If there are multiple exposure times present in the solar
         gain images, all frames for a single exposure time are averged prior to dark correction. Then all averaged
         exposure time frames are averaged again into a single frame.
+
+        Parameters
+        ----------
+        modstate
+            The modstate to average over. If `None` then the average is performed over all modstates.
+
+        Returns
+        -------
+        dark_corrected
+            The average solar gains with only a dark correction applied
+
+        lamp_corrected
+            The average solar gains with both dark and lamp corrections applied
         """
         all_exp_times = []
         for exp_time in self.constants.solar_gain_exposure_times:
@@ -114,12 +219,14 @@ class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
                 )
             )
 
-            logger.info(f"Loading solar gain frames for {exp_time = }")
+            logger.info(f"Loading solar gain frames for {modstate = } and {exp_time = }")
             tags = [
                 DlnirspTag.linearized_frame(),
                 DlnirspTag.task_solar_gain(),
                 DlnirspTag.exposure_time(exp_time),
             ]
+            if modstate is not None:
+                tags.append(DlnirspTag.modstate(modstate))
             gain_arrays = self.read(tags=tags, decoder=fits_array_decoder)
 
             logger.info("Averaging solar gain frames")
@@ -135,13 +242,6 @@ class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
         logger.info(f"Computing final average gain array for {len(all_exp_times)} exposure times")
         avg_gain_array = average_numpy_arrays(all_exp_times)
 
-        # This is the array we remove the characteristic solar spectrum from to produce the final gain array
-        self.write(
-            data=avg_gain_array,
-            tags=[DlnirspTag.intermediate_frame(), DlnirspTag.task("SC_DARK_ONLY")],
-            encoder=fits_array_encoder,
-        )
-
         logger.info("Loading lamp calibration")
         lamp_array = next(
             self.read(
@@ -155,8 +255,11 @@ class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
             divide_arrays_by_array(arrays=avg_gain_array, array_to_divide_by=lamp_array)
         )
 
-        logger.info("Loading geometric calibration")
+        return avg_gain_array, lamp_corrected_array
 
+    def apply_geometric_correction(self, array: np.ndarray) -> np.ndarray:
+        """Apply the geometric correction to an array."""
+        logger.info("Loading geometric calibration")
         geometric_correction = next(
             self.read(
                 tags=[DlnirspTag.intermediate(), DlnirspTag.task_geometric()], decoder=asdf_decoder
@@ -169,7 +272,7 @@ class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
         logger.info("Applying geometric calibration")
         final_gain_array = next(
             self.corrections_remove_spec_geometry(
-                arrays=lamp_corrected_array,
+                arrays=array,
                 shift_dict=shifts,
                 scale_dict=scales,
                 reference_wavelength_axis=reference_wavelength_axis,
@@ -177,11 +280,7 @@ class SolarCalibration(DlnirspTaskBase, CorrectionsMixin, QualityMixin):
             )
         )
 
-        self.write(
-            data=final_gain_array,
-            tags=[DlnirspTag.intermediate_frame(), DlnirspTag.task("SC_FULL_CORR")],
-            encoder=fits_array_encoder,
-        )
+        return final_gain_array
 
     def compute_characteristic_spectra(self) -> np.ndarray:
         """

dkist_processing_dlnirsp/tests/conftest.py

@@ -132,7 +132,7 @@ class DlnirspTestingParameters:
     dlnirsp_geo_reference_wave_min_nonnan_frac: float = 0.05
     dlnirsp_wavecal_atlas_download_config: dict[str, str] = field(
         default_factory=lambda: {
-            "base_url": "doi:10.5281/zenodo.14646787/",
+            "base_url": "https://g-a36282.cd214.a567.data.globus.org/atlas/",
             "telluric_reference_atlas_file_name": "telluric_reference_atlas.npy",
             "telluric_reference_atlas_hash_id": "md5:8db5e12508b293bca3495d81a0747447",
             "solar_reference_atlas_file_name": "solar_reference_atlas.npy",
@@ -170,12 +170,25 @@ class DlnirspTestingParameters:
     dlnirsp_bad_pixel_correction_interpolation_kernel_shape: tuple[int, int] = (10, 3)
     dlnirsp_wcs_pc_correction_matrix: tuple[tuple[int]] = ((1, 0), (0, -1))
     dlnirsp_wcs_crpix_correction_method: str = "swap_then_flip_crpix2"
+    dlnirsp_movie_core_wave_value_nm_vis: float = 853.98
+    dlnirsp_movie_core_wave_value_nm_jband: float = 1083.0
+    dlnirsp_movie_core_wave_value_nm_hband: float = 1564.8
+    dlnirsp_movie_cont_wave_value_nm_vis: float = 854.23
+    dlnirsp_movie_cont_wave_value_nm_jband: float = 1083.268
+    dlnirsp_movie_cont_wave_value_nm_hband: float = 1565.06
+    dlnirsp_movie_vertical_nan_slices: tuple[tuple[int | None, int | None]] = (
+        (None, 1),
+        (31, 34),
+        (-2, None),
+    )
+    dlnirsp_movie_nan_replacement_kernel_shape: tuple[int, int] = (5, 5)
 
 
 @dataclass
 class DlnirspTestingConstants:
     INSTRUMENT: str = "DLNIRSP"
-    OBS_IP_START_TIME: str = "2024-06-06"
+    OBS_IP_START_TIME: str = "2024-06-06T00:00:00"
+    OBS_IP_END_TIME: str = "2024-06-06T00:10:00"
     ARM_ID: str = "HBand"
     NUM_MODSTATES: int = 8
     NUM_MOSAIC_TILES_X: int = 2
@@ -204,6 +217,7 @@ class DlnirspTestingConstants:
         "EXPERID2",
         "EXPERID3",
     )
+    EXPERIMENT_ID: str = "eid_6_28"
     ARM_POSITION_MM: float = -4.2
     GRATING_CONSTANT_INVERSE_MM: float = 20.0
     GRATING_POSITION_DEG: float = 87.4
@@ -1229,6 +1243,8 @@ class CalibratedHeaders(ModulatedObserveHeaders):
         is_polarimetric: bool,
         dither_mode_on: bool = False,
         array_shape: tuple[int, int, int] = (3, 4, 5),
+        crpix1_step_delta: float = 40.0,
+        crpix2_step_delta: float = 30.0,
     ):
 
         # Use the data_cycles loop to represent Stokes parameters
@@ -1246,6 +1262,8 @@ class CalibratedHeaders(ModulatedObserveHeaders):
             allow_3D_arrays=True,
         )
 
+        self.crpix1_step_delta = crpix1_step_delta
+        self.crpix2_step_delta = crpix2_step_delta
         self.stokes_name_list = ["I", "Q", "U", "V"]
         self.add_constant_key("DLN__014", 8 if is_polarimetric else 1)
         self.add_constant_key("DLN__008", "Full Stokes" if is_polarimetric else "Stokes I")
@@ -1263,12 +1281,21 @@ class CalibratedHeaders(ModulatedObserveHeaders):
         )  # -1 b/c data cycles are indexed from 1
         return self.stokes_name_list[stokes_axis_id]
 
+    @property
+    def current_crpix1(self) -> float:
+        return self.array_shape[2] / 2 - self.crpix1_step_delta * self.current_MINDEX1_value
+
+    @property
+    def current_crpix2(self) -> float:
+        return self.array_shape[1] / 2 - self.crpix2_step_delta * self.current_MINDEX2_value
+
     @property
     def fits_wcs(self):
+        # Taken from real data from eid_2_24
         w = WCS(naxis=3)
-        w.wcs.crpix = self.array_shape[2] / 2, self.array_shape[1] / 2, self.array_shape[0] / 2
-        w.wcs.crval = 666.0, 999.0, 1565.0
-        w.wcs.cdelt = 1, 1, 0.2
+        w.wcs.crpix = self.current_crpix1, self.current_crpix2, self.array_shape[0] / 2
+        w.wcs.crval = 176.118, -289.575, 1565.0
+        w.wcs.cdelt = 0.031, 0.031, 0.2
         w.wcs.cunit = "arcsec", "arcsec", "nm"
         w.wcs.ctype = "HPLN-TAN", "HPLT-TAN", "AWAV"
         w.wcs.pc = np.identity(self.array_ndim)
@@ -1342,6 +1369,15 @@ def make_cs_data(
     return data
 
 
+@pytest.fixture
+def make_full_demodulation_matrix(demodulation_matrix):
+    def make_array(frame: Spec122Dataset):
+        array_shape = frame.array_shape[1:]
+        return np.ones(array_shape + demodulation_matrix.shape) * demodulation_matrix
+
+    return make_array
+
+
 def tag_on_modstate(frame: Spec122Dataset) -> list[str]:
     modstate = frame.header()["DLN__015"]
     return [DlnirspTag.modstate(modstate)]
@@ -1631,11 +1667,12 @@ def write_observe_frames_to_task(
     array_shape: tuple[int, int] = (10, 10),
     crpix_delta: tuple[float, float] = (80.3, 20.7),
     swap_crpix_values: bool = False,
+    start_date: str = "2023-01-01T01:23:45",
+    modstate_length_sec: float = 0.5,
     data_func: callable = make_random_data,
     tags: list[str] | None = None,
     tag_func: callable = lambda x: [],
 ) -> int:
-
     frame_generator = ModulatedObserveHeaders(
         num_modstates=num_modstates,
         num_X_tiles=num_X_tiles,
@@ -1650,6 +1687,8 @@ def write_observe_frames_to_task(
         grating_angle=grating_angle,
         crpix_delta=crpix_delta,
         swap_crpix_values=swap_crpix_values,
+        start_date=start_date,
+        modstate_length_sec=modstate_length_sec,
     )
 
     num_frames = write_frames_to_task(
@@ -1700,7 +1739,7 @@ def write_calibrated_frames_to_task(
     is_polarimetric: bool,
     array_shape: tuple[int, int, int],
     dither_mode_on: bool = False,
-    data_func: callable = make_3D_random_data,
+    data_func: Callable = make_3D_random_data,
 ):
     dataset = CalibratedHeaders(
         num_mosaics=num_mosaics,

dkist_processing_dlnirsp/tests/local_trial_workflows/l0_polcals_as_science.py

@@ -13,11 +13,10 @@ from dkist_processing_common.tasks import WorkflowTaskBase
 from dkist_service_configuration.logging import logger
 
 from dkist_processing_dlnirsp.models.tags import DlnirspTag
-from dkist_processing_dlnirsp.tasks import AssembleDlnirspMovie
 from dkist_processing_dlnirsp.tasks import DlnirspAssembleQualityData
 from dkist_processing_dlnirsp.tasks import DlnirspL0QualityMetrics
 from dkist_processing_dlnirsp.tasks import DlnirspL1QualityMetrics
-from dkist_processing_dlnirsp.tasks import MakeDlnirspMovieFrames
+from dkist_processing_dlnirsp.tasks import MakeDlnirspMovie
 from dkist_processing_dlnirsp.tasks.bad_pixel_map import BadPixelCalibration
 from dkist_processing_dlnirsp.tasks.dark import DarkCalibration
 from dkist_processing_dlnirsp.tasks.geometric import GeometricCalibration
@@ -197,10 +196,11 @@ def main(
     load_bad_pixel: bool = False,
     load_geometric: bool = False,
     load_wavelength_calibration: bool = False,
-    load_solar: bool = False,
     load_inst_polcal: bool = False,
+    load_solar: bool = False,
     load_polcals_as_science: bool = False,
     load_calibrated_data: bool = False,
+    skip_movie: bool = False,
     transfer_trial_data: str | None = None,
 ):
     with ManualProcessing(
@@ -298,18 +298,18 @@ def main(
             manual_processing_run.run_task(task=WavelengthCalibration)
             manual_processing_run.run_task(task=SaveWavelengthCal)
 
-        if load_solar:
-            manual_processing_run.run_task(task=LoadSolarCal)
-        else:
-            manual_processing_run.run_task(task=SolarCalibration)
-            manual_processing_run.run_task(task=SaveSolarCal)
-
         if load_inst_polcal:
             manual_processing_run.run_task(task=LoadInstPolCal)
         else:
             manual_processing_run.run_task(task=InstrumentPolarizationCalibration)
             manual_processing_run.run_task(task=SaveInstPolCal)
 
+        if load_solar:
+            manual_processing_run.run_task(task=LoadSolarCal)
+        else:
+            manual_processing_run.run_task(task=SolarCalibration)
+            manual_processing_run.run_task(task=SaveSolarCal)
+
         if load_polcals_as_science:
             manual_processing_run.run_task(task=LoadPolCalAsScience)
         else:
@@ -324,8 +324,6 @@ def main(
 
         manual_processing_run.run_task(task=permissive_write_l1_task(force_intensity_only=False))
         manual_processing_run.run_task(task=ValidateL1Output)
-        manual_processing_run.run_task(task=MakeDlnirspMovieFrames)
-        manual_processing_run.run_task(task=AssembleDlnirspMovie)
 
         manual_processing_run.run_task(task=DlnirspL0QualityMetrics)
         manual_processing_run.run_task(task=DlnirspL1QualityMetrics)
@@ -334,6 +332,9 @@ def main(
 
         manual_processing_run.run_task(task=CreateTrialQualityReport)
 
+        if not skip_movie:
+            manual_processing_run.run_task(task=MakeDlnirspMovie)
+
         if transfer_trial_data:
             transfer_trial_data_locally(
                 trial_output_location=transfer_trial_data, processing_run=manual_processing_run
@@ -425,18 +426,18 @@ if __name__ == "__main__":
         help="Load wavelength calibration solution from previously saved run",
         action="store_true",
     )
-    parser.add_argument(
-        "-S",
-        "--load-solar",
-        help="Load solar calibration from previously saved run",
-        action="store_true",
-    )
     parser.add_argument(
         "-P",
         "--load-inst-polcal",
         help="Load instrument polarization calibration from previously saved run",
         action="store_true",
     )
+    parser.add_argument(
+        "-S",
+        "--load-solar",
+        help="Load solar calibration from previously saved run",
+        action="store_true",
+    )
     parser.add_argument(
         "-O",
         "--load-polcals-as-science",
@@ -446,6 +447,7 @@ if __name__ == "__main__":
     parser.add_argument(
         "-C", "--load-calibrated-data", help="Load CALIBRATED 'science' frames", action="store_true"
     )
+    parser.add_argument("-V", "--skip-movie", help="Don't make a browse movie", action="store_true")
     parser.add_argument(
         "-p",
         "--param-dir",
@@ -472,10 +474,11 @@ if __name__ == "__main__":
             load_bad_pixel=args.load_bad_pixel,
             load_geometric=args.load_geometric,
             load_wavelength_calibration=args.load_wavelength_calibration,
-            load_solar=args.load_solar,
             load_inst_polcal=args.load_inst_polcal,
+            load_solar=args.load_solar,
             load_polcals_as_science=args.load_polcals_as_science,
             load_calibrated_data=args.load_calibrated_data,
+            skip_movie=args.skip_movie,
             transfer_trial_data=args.transfer_trial_data,
         )
     )