dkist-processing-trend 0.1.0rc1__py3-none-any.whl

dkist_processing_trend/tasks/prepare_fit_data_base.py

@@ -0,0 +1,257 @@
+"""Base task for preparing input data for the PAC fitter."""
+
+from abc import ABC
+from abc import abstractmethod
+from collections import defaultdict
+
+import numpy as np
+from dkist_processing_common.codecs.asdf import asdf_encoder
+from dkist_processing_common.codecs.fits import fits_array_decoder
+from dkist_processing_common.codecs.fits import fits_header_decoder
+from dkist_processing_math.arithmetic import divide_arrays_by_array
+from dkist_processing_math.arithmetic import subtract_array_from_arrays
+from dkist_processing_math.statistics import average_numpy_arrays
+from dkist_service_configuration.logging import logger
+
+from dkist_processing_trend.models.instrument_options import InstrumentOptionsBase
+from dkist_processing_trend.models.tags import TrendTag
+from dkist_processing_trend.parsers.trend_l0_fits_access import TrendL0FitsAccess
+from dkist_processing_trend.tasks.trend_base import TrendArmTaskBase
+
+
+class PrepareFitDataBase(TrendArmTaskBase, ABC):
+    """
+    Base class for processing INPUT data to prepare it for fitting by `~dkist_processing_trend.tasks.run_pac_fitter.RunPacFitter`.
+
+    This class provides a populated `run` method that does steps common to all instruments (e.g., dark and gain correction).
+
+    Instrument-specific subclasses need to define the following methods:
+
+    * `extract_beam` - For getting a certain beam from a full-FOV array
+    * `apply_global_instrument_options` - Use any `*InstrumentOptions` to produce the "global" PAC input data for a single cs step, beam, and modstate
+    * `apply_local_instrument_options` - Use any `*InstrumentOptions` to produce the "local" PAC input data for a single cs step, beam, and modstate
+
+    Parameters
+    ----------
+    arm_id
+        id of the instrument arm to operate on
+
+    recipe_run_id
+        id of the recipe run used to identify the workflow run this task is part of
+
+    workflow_name
+        name 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
+
+    def run(self):
+        """
+        Prepare input data for fitting with `dkist_processing_pac`.
+
+        At a high level this involves three steps:
+
+        #. Perform dark and gain corrections to all input frames
+        #. Apply any instrument-specific processing (e.g., binning) to the resulting frames
+        #. Organize the results into the structure expected by `~dkist_processing_trend.tasks.run_pac_fitter.RunPacFitter`
+
+        This method should not be overloaded by instrument-specific subclasses. Rather they should define `extract_beam`,
+        `apply_global_instrument_options`, and `apply_local_instrument_options`, which are called from this method.
+        """
+        logger.info("Loading INTERMEDIATE dark frame")
+        avg_dark = next(
+            self.read(
+                tags=[
+                    TrendTag.intermediate(),
+                    TrendTag.frame(),
+                    TrendTag.arm_id(self.arm_id),
+                    TrendTag.task_dark(),
+                ],
+                decoder=fits_array_decoder,
+            )
+        )
+
+        logger.info("Loading INTERMEDIATE gain frame")
+        avg_gain = next(
+            self.read(
+                tags=[
+                    TrendTag.intermediate(),
+                    TrendTag.frame(),
+                    TrendTag.arm_id(self.arm_id),
+                    TrendTag.task_gain(),
+                ],
+                decoder=fits_array_decoder,
+            )
+        )
+
+        beam_dark_dict = {
+            beam: self.extract_beam(array=avg_dark, beam=beam)
+            for beam in range(1, self.num_beams + 1)
+        }
+        beam_gain_dict = {
+            beam: self.extract_beam(array=avg_gain, beam=beam)
+            for beam in range(1, self.num_beams + 1)
+        }
+
+        with self.telemetry_span("Prepare polcal fit inputs"):
+            for inst_options in self.parameters.instrument_processing_options:
+                for beam in range(1, self.num_beams + 1):
+                    global_obj_dict = defaultdict(list)
+                    local_obj_dict = defaultdict(list)
+                    beam_dark = beam_dark_dict[beam]
+                    beam_gain = beam_gain_dict[beam]
+                    for cs_step in range(self.constants.num_cs_steps):
+                        for modstate in range(1, self.constants.num_modstates + 1):
+                            logger.info(
+                                f"Processing instrument options = {inst_options.name}, {beam = }, {cs_step = }, and {modstate = }"
+                            )
+                            global_obj, local_obj = self.process_single_modstate(
+                                instrument_options=inst_options,
+                                cs_step=cs_step,
+                                modstate=modstate,
+                                beam=beam,
+                                avg_dark=beam_dark,
+                                avg_gain=beam_gain,
+                            )
+                            global_obj_dict[cs_step].append(global_obj)
+                            local_obj_dict[cs_step].append(local_obj)
+
+                    logger.info(
+                        f"Writing PAC inputs for instrument options = {inst_options.name} and {beam = }"
+                    )
+                    self.write_pac_inputs(
+                        global_obj_dict=global_obj_dict,
+                        local_obj_dict=local_obj_dict,
+                        instrument_options=inst_options,
+                        beam=beam,
+                    )
+
+    @property
+    def num_beams(self) -> int:
+        """Return the number of beams associated with this instance's arm_id."""
+        if self.arm_id == "CI":
+            return 1
+        return 2
+
+    def process_single_modstate(
+        self,
+        instrument_options: InstrumentOptionsBase,
+        cs_step: int,
+        modstate: int,
+        beam: int,
+        avg_dark: np.ndarray,
+        avg_gain: np.ndarray,
+    ) -> tuple[TrendL0FitsAccess, TrendL0FitsAccess]:
+        """
+        Process data for a single cs step, beam, and modstate.
+
+        This involves doing dark and gain correction before passing the result to the instrument-defined methods used to
+        extract global and local PAC input data.
+
+        If more than one file is found for the given ``(cs_step, beam, modstate)`` tuple then they are averaged together.
+        In this case, the header in the returned `~dkist_processing_trend.parsers.trend_l0_fits_access.TrendL0FitsAccess`
+        objects is randomly chosen from the input frames.
+        """
+        tags = [
+            TrendTag.task_polcal(),
+            TrendTag.arm_id(self.arm_id),
+            TrendTag.cs_step(cs_step),
+            TrendTag.modstate(modstate),
+        ]
+        logger.info(f"Found {self.count(tags)} frame(s)")
+
+        arrays = self.read(tags=tags, decoder=fits_array_decoder)
+        avg_array = average_numpy_arrays(arrays)
+
+        beam_array = self.extract_beam(array=avg_array, beam=beam)
+
+        dark_corrected_array = subtract_array_from_arrays(
+            arrays=beam_array, array_to_subtract=avg_dark
+        )
+        gain_corrected_array = next(
+            divide_arrays_by_array(arrays=dark_corrected_array, array_to_divide_by=avg_gain)
+        )
+
+        global_array = self.apply_global_instrument_options(
+            array=gain_corrected_array, instrument_options=instrument_options
+        )
+        local_array = self.apply_local_instrument_options(
+            array=gain_corrected_array, instrument_options=instrument_options
+        )
+
+        # Any header from the set of input data will do
+        header = next(self.read(tags=tags, decoder=fits_header_decoder))
+
+        return TrendL0FitsAccess(header=header, data=global_array), TrendL0FitsAccess(
+            header=header, data=local_array
+        )
+
+    def write_pac_inputs(
+        self,
+        global_obj_dict: dict[int, list[TrendL0FitsAccess]],
+        local_obj_dict: dict[int, list[TrendL0FitsAccess]],
+        instrument_options: InstrumentOptionsBase,
+        beam: int,
+    ) -> None:
+        """
+        Write the dicts containing the global and local data structures to disk.
+
+        Each of these data structures is essentially a `~dkist_processing_pac.input_data.drawer.Drawer`, but saved as
+        dicts in an ASDF file for easier serialization. This method converts each
+        `~dkist_processing_trend.parsers.trend_l0_fits_access.TrendL0FitsAccess` object into a dict of "header" and
+        "data" prior to writing.
+        """
+        global_output_dict = {
+            cs_step: [
+                {"header": fits_obj.header_dict, "data": fits_obj.data}
+                for fits_obj in modstate_list
+            ]
+            for cs_step, modstate_list in global_obj_dict.items()
+        }
+        local_output_dict = {
+            cs_step: [
+                {"header": fits_obj.header_dict, "data": fits_obj.data}
+                for fits_obj in modstate_list
+            ]
+            for cs_step, modstate_list in local_obj_dict.items()
+        }
+
+        base_tags = [
+            TrendTag.intermediate(),
+            TrendTag.arm_id(self.arm_id),
+            TrendTag.instrument_processing_options(instrument_options.name),
+            TrendTag.beam(beam),
+        ]
+        self.write(
+            data=global_output_dict,
+            tags=base_tags + [TrendTag.task_global_pac_input()],
+            encoder=asdf_encoder,
+        )
+        self.write(
+            data=local_output_dict,
+            tags=base_tags + [TrendTag.task_local_pac_input()],
+            encoder=asdf_encoder,
+        )
+
+    @abstractmethod
+    def extract_beam(self, array: np.ndarray, beam: int) -> np.ndarray:
+        """Extract the given beam from the input array."""
+
+    @abstractmethod
+    def apply_global_instrument_options(
+        self, array: np.ndarray, instrument_options: InstrumentOptionsBase
+    ) -> np.ndarray:
+        """
+        Do whatever instrument-specific processing is needed to produce a global PAC data point.
+
+        The shape of the final output should be (1, 1).
+        """
+
+    @abstractmethod
+    def apply_local_instrument_options(
+        self, array: np.ndarray, instrument_options: InstrumentOptionsBase
+    ) -> np.ndarray:
+        """Do whatever instrument-specific processing is needed to produce a local PAC data point."""

dkist_processing_trend/tasks/run_pac_fitter.py

@@ -0,0 +1,392 @@
+"""Task for running processed POLCAL data through the `dkist_processing_pac` fitter."""
+
+import numpy as np
+from dkist_processing_common.codecs.asdf import asdf_decoder
+from dkist_processing_common.codecs.fits import fits_array_encoder
+from dkist_processing_pac.fitter.fitter_parameters import CU_PARAMS
+from dkist_processing_pac.fitter.fitting_core import compare_I
+from dkist_processing_pac.fitter.polcal_fitter import PolcalFitter
+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 dkist_processing_trend.models.tags import TrendTag
+from dkist_processing_trend.parsers.trend_l0_fits_access import TrendL0FitsAccess
+from dkist_processing_trend.tasks.trend_base import TrendArmTaskBase
+
+__all__ = ["RunPacFitter"]
+
+# The are the names of parameters as used by `dkist-processing-pac`, which are slightly different than their "common" names
+ORDERED_PARAMETER_NAMES = [
+    "x12",
+    "t12",
+    "x34",
+    "t34",
+    "x56",
+    "t56",
+    "Q_in",
+    "U_in",
+    "V_in",
+    "t_pol",
+    "t_ret",
+    "ret0r",
+    "ret045",
+    "ret0h",
+    "py",
+]
+
+
+class RunPacFitter(TrendArmTaskBase):
+    """
+    Run prepared POLCAL data through `dkist_processing_pac` to fit the CU parameters and produce demodulation matrices.
+
+    Parameters
+    ----------
+    arm_id
+        id of the instrument arm to operate on
+
+    recipe_run_id
+        id of the recipe run used to identify the workflow run this task is part of
+
+    workflow_name
+        name 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
+
+    def run(self):
+        """
+        Run all prepared POLCAL datasets through the `~dkist_processing_pac.fitter.polcal_fitter.PolcalFitter` and save the results.
+
+        Here is where we loop over all PA&C fitting options described in the
+        `~dkist_processing_trend.models.parameters.TrendParameters.fit_options_list`. Each run gets its own unique set of
+        outputs.
+        """
+        num_beams = 1 if self.arm_id == "CI" else 2
+        cs_config_saved = False
+
+        for inst_options in self.parameters.instrument_processing_options:
+            inst_option_name = inst_options.name
+            for beam in range(1, num_beams + 1):
+                logger.info(f"Loading PAC input data for {beam = }")
+                global_input_dict = next(
+                    self.read(
+                        tags=[
+                            TrendTag.intermediate(),
+                            TrendTag.arm_id(self.arm_id),
+                            TrendTag.instrument_processing_options(inst_option_name),
+                            TrendTag.task_global_pac_input(),
+                            TrendTag.beam(beam),
+                        ],
+                        decoder=asdf_decoder,
+                    )
+                )
+                local_input_dict = next(
+                    self.read(
+                        tags=[
+                            TrendTag.intermediate(),
+                            TrendTag.arm_id(self.arm_id),
+                            TrendTag.instrument_processing_options(inst_option_name),
+                            TrendTag.task_local_pac_input(),
+                            TrendTag.beam(beam),
+                        ],
+                        decoder=asdf_decoder,
+                    )
+                )
+
+                if not cs_config_saved:
+                    logger.info("Writing CS GOS configuration")
+                    self.write_calibration_sequence(global_input_dict)
+                    cs_config_saved = True
+
+                for fit_options in self.parameters.fit_options_list:
+                    with self.telemetry_span(
+                        f"Run PAC fit for inst processing option = {inst_option_name}, {beam = }, and fit options = {fit_options.name}"
+                    ):
+                        logger.info(
+                            f"Running fits for inst processing option = {inst_option_name}, {beam = }, and fit options = {fit_options.name}"
+                        )
+                        global_dresser = self.populate_dresser(
+                            global_input_dict, remove_I_trend=fit_options.remove_I_trend
+                        )
+                        local_dresser = self.populate_dresser(
+                            local_input_dict, remove_I_trend=fit_options.remove_I_trend
+                        )
+
+                        pac_fitter = PolcalFitter(
+                            local_dresser=local_dresser,
+                            global_dresser=global_dresser,
+                            fit_mode=fit_options.fit_mode_name,
+                            init_set=fit_options.init_set_name,
+                            inherit_global_vary_in_local_fit=True,
+                            suppress_local_starting_values=True,
+                            fit_TM=False,
+                        )
+
+                    with self.telemetry_span(
+                        f"Saving fit results for {beam = } and fit options = {fit_options.name}"
+                    ):
+                        common_kwargs = {
+                            "beam": beam,
+                            "inst_options_name": inst_option_name,
+                            "fit_options_name": fit_options.name,
+                        }
+                        logger.info("Writing best-fit parameters")
+                        self.write_best_fit_parameters(pac_fitter, **common_kwargs)
+
+                        logger.info("Writing best-fit demodulation matrices")
+                        self.write_best_fit_demodulation_matrices(pac_fitter, **common_kwargs)
+
+                        logger.info("Writing best-fit flux and residuals")
+                        self.write_best_fit_flux_and_residuals(pac_fitter, **common_kwargs)
+
+    def populate_dresser(
+        self,
+        pac_input_dict: dict[int, list[dict[str, dict | np.ndarray]]],
+        remove_I_trend: bool,
+        skip_darks: bool = True,
+    ) -> Dresser:
+        """
+        Convert a raw set of dicts that live on scratch as an ASDF file into a `~dkist_processing_pac.input_data.dresser.Dresser`.
+
+        `Drawers <dkist_processing_pac.input_data.drawer.Drawer>` expect to be instantiated with a dict containing lists
+        of `~dkist_processing_trend.parsers.trend_l0_fits_access.TrendL0FitsAccess` objects but we store these
+        "pac input data" as lists of dicts containing "header" and "data" keys. So the first step is to convert these
+        raw dictionaries into `~dkist_processing_trend.parsers.trend_l0_fits_access.TrendL0FitsAccess`  objects, then we
+        can use them to instantiate `Drawers <dkist_processing_pac.input_data.drawer.Drawer>` and finally a
+        `~dkist_processing_pac.input_data.dresser.Dresser`.
+        """
+        dresser = Dresser()
+        fits_access_dict = dict()
+
+        for cs_step in range(self.constants.num_cs_steps):
+            cs_step_dict_list = pac_input_dict[cs_step]
+            cs_step_fits_access_list = []
+
+            for cs_step_dict in cs_step_dict_list:
+                fits_access_obj = TrendL0FitsAccess(
+                    header=cs_step_dict["header"], data=cs_step_dict["data"]
+                )
+                cs_step_fits_access_list.append(fits_access_obj)
+
+            fits_access_dict[cs_step] = cs_step_fits_access_list
+
+        dresser.add_drawer(
+            Drawer(fits_access_dict, remove_I_trend=remove_I_trend, skip_darks=skip_darks)
+        )
+        return dresser
+
+    def write_calibration_sequence(
+        self, pac_input_dict: dict[int, list[dict[str, dict | np.ndarray]]]
+    ) -> None:
+        """
+        Write the Calibration Sequence configuration to scratch.
+
+        The result has shape ``(K, 8, N)``, where ``K`` is the number of polcal OPs/calibration sequences, and ``N`` is
+        the number of steps per OP/sequence. The length-8 dimension corresponds to the 8 optical parameters that describe the
+        calibration sequence.
+
+        If the different polcal OPs have a different number of steps then ``N`` is the length of the longest OP and the data
+        for shorter OPs is padded with NaNs.
+        """
+        dresser = self.populate_dresser(pac_input_dict, remove_I_trend=False, skip_darks=False)
+
+        longest_cs_num_steps = max(dresser.drawer_step_list)
+        full_data = np.empty((dresser.numdrawers, 8, longest_cs_num_steps))
+
+        for cs_num, drawer in enumerate(dresser.drawers):
+            drawer_data_stack = np.vstack(
+                [
+                    drawer.pol_in,
+                    drawer.theta_pol_steps,
+                    drawer.ret_in,
+                    drawer.theta_ret_steps,
+                    drawer.dark_in,
+                    drawer.azimuth,
+                    drawer.elevation,
+                    drawer.table_angle,
+                ]
+            )
+
+            if step_deficit := drawer.numsteps - longest_cs_num_steps > 0:
+                drawer_data_stack = np.pad(
+                    drawer_data_stack, ((0, 0), (0, step_deficit)), constant_values=np.nan
+                )
+
+            full_data[cs_num, :, :] = drawer_data_stack
+
+        self.write(
+            data=full_data,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.arm_id(self.arm_id),
+                TrendTag.task_calibration_sequence(),
+            ],
+            encoder=fits_array_encoder,
+        )
+
+    def write_best_fit_parameters(
+        self, fitter: PolcalFitter, beam: int, inst_options_name: str, fit_options_name: str
+    ):
+        """
+        Collect ALL best-fit parameter values (including those fixed in the fit) and write to a single array.
+
+        The full output shape is ``(*FOV_shape, K, 15 + N, 3)``, where FOV_shape is the shape of the input POLCAL data,
+        K is the number of polcal OPs/calibration sequences, and N is the number of steps in each sequence. The last
+        dimension contains the best-fit value in its 0th index, the initial value at index 1, and whether that parameter
+        varied in the fit at index 2. Note that many parameters are held to be the same across polcal OPs; these
+        parameters will have the same values for all slices of the "K" index.
+
+        If the different polcal OPs have a different number of steps then N is the length of the longest OP and the data
+        for shorter OPs is padded with NaNs.
+        """
+        fov_shape = fitter.local_objects.dresser.shape
+        num_cs = fitter.local_objects.dresser.numdrawers
+        steps_per_cs = fitter.local_objects.dresser.drawer_step_list
+        longest_cs_num_steps = max(steps_per_cs)
+        init_parameters = fitter.local_objects.init_parameters
+        fit_parameters = fitter.fit_parameters
+
+        full_output = np.empty(fov_shape + (num_cs, 15 + longest_cs_num_steps, 3))
+
+        num_points = np.prod(fov_shape)
+        for point in range(num_points):
+            idx = np.unravel_index(point, fov_shape)
+            point_parameters = fit_parameters[idx]
+            init_point_parameters = init_parameters[idx]
+
+            for cs in range(num_cs):
+                cs_data = np.empty((15 + steps_per_cs[cs], 3))
+
+                # These are all parameters except for the I_sys params, which we'll add in a moment
+                for p, param_name in enumerate(ORDERED_PARAMETER_NAMES):
+
+                    if param_name in CU_PARAMS:
+                        param_name = f"{param_name}_CS{cs:02n}"
+
+                    if param_name == "py":
+                        value = fitter.global_objects.calibration_unit.py
+                        vary = False
+                        init_value = value
+                    else:
+                        parameter = point_parameters[param_name]
+                        value = parameter.value
+                        vary = parameter.vary
+                        init_value = init_point_parameters[param_name].value
+
+                    cs_data[p] = np.array([value, init_value, vary])
+
+                # Add I_sys parameters, the number of which depends on the number of *total* CS steps (across all
+                # calibration sequences).
+                for p, s in enumerate(range(steps_per_cs[cs]), start=15):
+                    param_name = f"I_sys_CS{cs:02n}_step{s:02n}"
+                    parameter = point_parameters[param_name]
+                    value = parameter.value
+                    vary = parameter.vary
+                    init_value = init_point_parameters[param_name].value
+                    cs_data[p] = np.array([value, init_value, vary])
+
+                if step_deficit := steps_per_cs[cs] - longest_cs_num_steps > 0:
+                    cs_data = np.pad(cs_data, ((0, step_deficit), (0, 0)), constant_values=np.nan)
+
+                full_output[*idx, cs] = cs_data
+
+        self.write(
+            data=full_output,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.arm_id(self.arm_id),
+                TrendTag.beam(beam),
+                TrendTag.instrument_processing_options(inst_options_name),
+                TrendTag.pac_fit_options(fit_options_name),
+                TrendTag.task_best_fit_parameters(),
+            ],
+            encoder=fits_array_encoder,
+        )
+
+    def write_best_fit_demodulation_matrices(
+        self, fitter: PolcalFitter, beam: int, inst_options_name: str, fit_options_name: str
+    ):
+        """
+        Write the best-fit demodulation matrices to scratch.
+
+        The shape will be ``(*FOV_shape, 4, M)``, where FOV_shape is the shape of the input data and M is the number of
+        modulation states.
+        """
+        demod_matrices = fitter.demodulation_matrices
+
+        self.write(
+            data=demod_matrices,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.arm_id(self.arm_id),
+                TrendTag.beam(beam),
+                TrendTag.instrument_processing_options(inst_options_name),
+                TrendTag.pac_fit_options(fit_options_name),
+                TrendTag.task_best_fit_demodulation_matrices(),
+            ],
+            encoder=fits_array_encoder,
+        )
+
+    def write_best_fit_flux_and_residuals(
+        self, fitter: PolcalFitter, beam: int, inst_options_name: str, fit_options_name: str
+    ):
+        """Compute the best-fit flux and fit residuals and write them to scratch."""
+        fit_container = fitter.local_objects
+        TM = fit_container.telescope
+        CM = fit_container.calibration_unit
+        fov_shape = fit_container.dresser.shape
+        num_mod = fit_container.dresser.nummod
+        num_steps = fit_container.dresser.numsteps
+        num_points = np.prod(fov_shape)
+
+        flux_array = np.zeros(fov_shape + (num_mod, num_steps))
+        residual_array = np.zeros_like(flux_array)
+
+        for i in range(num_points):
+            idx = np.unravel_index(i, fov_shape)
+            I_cal, I_unc = fit_container.dresser[idx]
+            fit_params = fit_container.fit_parameters[idx]
+            modmat = np.zeros((I_cal.shape[0], 4), dtype=np.float64)
+            flat_residual = compare_I(
+                params=fit_params,
+                I_cal=I_cal,
+                I_unc=I_unc,
+                TM=TM,
+                CM=CM,
+                modmat=modmat,
+                use_M12=True,
+            )
+            diff = np.reshape(flat_residual, (num_mod, num_steps))
+            residual_array[*idx, :, :] = diff
+
+            flux = diff * I_unc + I_cal
+            flux_array[*idx, :, :] = flux
+
+        self.write(
+            data=flux_array,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.arm_id(self.arm_id),
+                TrendTag.beam(beam),
+                TrendTag.instrument_processing_options(inst_options_name),
+                TrendTag.pac_fit_options(fit_options_name),
+                TrendTag.task_best_fit_flux(),
+            ],
+            encoder=fits_array_encoder,
+        )
+        self.write(
+            data=residual_array,
+            tags=[
+                TrendTag.intermediate(),
+                TrendTag.arm_id(self.arm_id),
+                TrendTag.beam(beam),
+                TrendTag.instrument_processing_options(inst_options_name),
+                TrendTag.pac_fit_options(fit_options_name),
+                TrendTag.task_fit_residuals(),
+            ],
+            encoder=fits_array_encoder,
+        )