dkist-processing-visp 4.0.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

dkist_processing_visp/tasks/solar.py

@@ -1,26 +1,124 @@
 """ViSP solar calibration task. See :doc:`this page </gain_correction>` for more information."""
 
+from __future__ import annotations
+
+from functools import partial
+from typing import Callable
+
+import astropy.units as u
 import numpy as np
 import scipy.ndimage as spnd
-import scipy.optimize as spo
+from astropy.time import Time
+from astropy.units import Quantity
+from astropy.wcs import WCS
+from dkist_processing_common.codecs.asdf import asdf_encoder
 from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.fits import fits_array_decoder
 from dkist_processing_common.codecs.fits import fits_array_encoder
+from dkist_processing_common.models.dkist_location import location_of_dkist
 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.statistics import average_numpy_arrays
 from dkist_service_configuration.logging import logger
-
+from lmfit.parameter import Parameters
+from sklearn.linear_model import RANSACRegressor
+from sklearn.pipeline import Pipeline
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.preprocessing import RobustScaler
+from solar_wavelength_calibration import AngleBoundRange
+from solar_wavelength_calibration import Atlas
+from solar_wavelength_calibration import BoundsModel
+from solar_wavelength_calibration import DispersionBoundRange
+from solar_wavelength_calibration import FitFlagsModel
+from solar_wavelength_calibration import LengthBoundRange
+from solar_wavelength_calibration import UnitlessBoundRange
+from solar_wavelength_calibration import WavelengthCalibrationFitter
+from solar_wavelength_calibration import WavelengthCalibrationParameters
+from solar_wavelength_calibration.fitter.wavelength_fitter import FitResult
+from solar_wavelength_calibration.fitter.wavelength_fitter import WavelengthParameters
+from solar_wavelength_calibration.fitter.wavelength_fitter import calculate_initial_crval_guess
+from sunpy.coordinates import HeliocentricInertial
+
+from dkist_processing_visp.models.metric_code import VispMetricCode
 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__ = ["SolarCalibration"]
+__all__ = [
+    "SolarCalibration",
+    "WavelengthCalibrationParametersWithContinuum",
+    "polynomial_continuum_model",
+    "compute_order",
+    "compute_initial_dispersion",
+    "compute_doppler_velocity",
+    "compute_input_wavelength_vector",
+]
+
+
+class WavelengthCalibrationParametersWithContinuum(WavelengthCalibrationParameters):
+    """
+    Subclass of `~solar_wavelength_calibration.WavelengthCalibrationParameters` that adds a polynomial continuum parameterization.
+
+    The order of the continuum polynomial is set with the new ``continuum_poly_fit_oder`` model field. The `lmfit_parameters`
+    property now adds a set of parameters that represent the polynomial coefficients.
+    """
+
+    continuum_poly_fit_order: int
+    normalized_abscissa: np.ndarray
+    zeroth_order_continuum_coefficient: float
+
+    @property
+    def continuum_function(self) -> Callable[[np.ndarray, Parameters], np.ndarray]:
+        """Return a partial function of `polynomial_continuum_model` pre-loaded with the fit order and normalized abscissa."""
+        return partial(
+            polynomial_continuum_model,
+            fit_order=self.continuum_poly_fit_order,
+            abscissa=self.normalized_abscissa,
+        )
+
+    @property
+    def lmfit_parameters(self) -> Parameters:
+        """
+        Add continuum polynomial coefficient parameters to the standard `~solar_wavelength_calibration.WavelengthCalibrationParameters.lmfit_parameters`.
+
+        Each coefficient gets its own parameter called ``poly_coeff_{o:02n}``. The 0th order (i.e., constant continuum
+        level) coefficient has bounds [0.7, 1.3] and all higher-order coefficients have bounds [-1, 1].
+        """
+        # NOTE: We set `vary=True` because otherwise we just wouldn't use this class
+        #       We set the bounds here because it's easier that defining a custom `BoundsModel` class that can
+        #       dynamically create the required number of "poly_coeff_{o:02n}" fields. Sorry if this bites you!
+        params = super().lmfit_parameters
+        for o in range(self.continuum_poly_fit_order + 1):
+            # `np.polyval` uses its input coefficient list "backwards", so `poly_coeff_{self.continuum_poly_fit_order}`
+            # is the 0th order polynomial term.
+            params.add(
+                f"poly_coeff_{o:02n}",
+                vary=True,
+                value=(
+                    self.zeroth_order_continuum_coefficient
+                    if o == self.continuum_poly_fit_order
+                    else 0
+                ),
+                min=-1,
+                max=1,
+            )
+
+        params[f"poly_coeff_{self.continuum_poly_fit_order:02n}"].min = (
+            self.zeroth_order_continuum_coefficient * 0.5
+        )
+        params[f"poly_coeff_{self.continuum_poly_fit_order:02n}"].max = (
+            self.zeroth_order_continuum_coefficient * 1.5
+        )
+
+        # Remove the default continuum parameterization
+        del params["continuum_level"]
+
+        return params
 
 
 class SolarCalibration(
@@ -28,18 +126,19 @@ class SolarCalibration(
     BeamAccessMixin,
     CorrectionsMixin,
     QualityMixin,
-    LineZonesMixin,
 ):
     """
     Task class for generating Solar Gain images for each beam/modstate.
 
     Parameters
     ----------
-    recipe_run_id : int
+    recipe_run_id
         id of the recipe run used to identify the workflow run this task is part of
-    workflow_name : str
+
+    workflow_name
         name of the workflow to which this instance of the task belongs
-    workflow_version : str
+
+    workflow_version
         version of the workflow to which this instance of the task belongs
 
     """
@@ -50,121 +149,160 @@ class SolarCalibration(
         """
         For each beam.
 
-            For each modstate:
-                - Do dark, background, lamp, and geometric corrections
-                - Compute the characteristic spectra
-                - Re-apply the spectral curvature to the characteristic spectra
-                - Re-apply angle and state offset distortions to the characteristic spectra
-                - Remove the distorted characteristic solar spectra from the original spectra
-                - Write master solar gain
-
-        Returns
-        -------
-        None
-
+        #. Do dark, background, lamp, and geometric corrections
+        #. Compute an initial separation of low-order spectral vignette signal from the true solar spectrum
+        #. Compute a 2D vignette signal by fitting solar spectrum residuals along the slit
+        #. Remove the 2D vignette signal from the averaged gain array
+        #. Compute the characteristic spectra
+        #. Re-apply the spectral curvature to the characteristic spectra
+        #. Re-apply angle and state offset distortions to the characteristic spectra
+        #. Remove the distorted characteristic solar spectra from the original, dark-corrected spectra
+        #. Write final gain to disk
         """
         for beam in range(1, self.constants.num_beams + 1):
 
-            pre_equalized_gain_dict = dict()
-
-            for modstate in range(1, self.constants.num_modstates + 1):
-                apm_str = f"{beam = } and {modstate = }"
-                with self.telemetry_span(f"Initial corrections for {apm_str}"):
-                    self.do_initial_corrections(beam=beam, modstate=modstate)
-
-                with self.telemetry_span(f"Computing characteristic spectra for {apm_str}"):
-                    char_spec = self.compute_characteristic_spectra(beam=beam, modstate=modstate)
-                    self.write(
-                        data=char_spec,
-                        encoder=fits_array_encoder,
-                        tags=[VispTag.debug(), VispTag.frame()],
-                        relative_path=f"DEBUG_SC_CHAR_SPEC_BEAM_{beam}_MODSTATE_{modstate}.dat",
-                        overwrite=True,
-                    )
+            apm_str = f"{beam = }"
+            with self.telemetry_span(f"Initial corrections for {apm_str}"):
+                self.do_initial_corrections(beam=beam)
 
-                with self.telemetry_span(f"Re-distorting characteristic spectra for {apm_str}"):
-                    spec_shift = next(
-                        self.read(
-                            tags=[
-                                VispTag.intermediate_frame(beam=beam),
-                                VispTag.task_geometric_spectral_shifts(),
-                            ],
-                            decoder=fits_array_decoder,
-                        )
-                    )
-                    redistorted_char_spec = next(
-                        self.corrections_remove_spec_geometry(
-                            arrays=char_spec, spec_shift=-1 * spec_shift
-                        )
-                    )
-                    self.write(
-                        data=redistorted_char_spec,
-                        encoder=fits_array_encoder,
-                        tags=[VispTag.debug(), VispTag.frame()],
-                        relative_path=f"DEBUG_SC_CHAR_DISTORT_BEAM_{beam}_MODSTATE_{modstate}.dat",
-                        overwrite=True,
-                    )
+            with self.telemetry_span(f"Fit atlas with continuum for {apm_str}"):
+                representative_spectrum = self.get_representative_spectrum(beam)
 
-                with self.telemetry_span(f"Re-shifting characteristic spectra for {apm_str}"):
-                    reshifted_char_spec = self.distort_characteristic_spectra(
-                        char_spec=redistorted_char_spec, beam=beam, modstate=modstate
-                    )
-                    self.write(
-                        data=reshifted_char_spec,
-                        encoder=fits_array_encoder,
+                self.write(
+                    data=representative_spectrum,
+                    tags=[VispTag.debug(), VispTag.beam(beam), VispTag.task("REP_SPEC")],
+                    encoder=fits_array_encoder,
+                )
+
+                logger.info("Deriving values from instrument configuration")
+                order = compute_order(
+                    central_wavelength=self.constants.wavelength * u.nm,
+                    incident_light_angle=self.constants.incident_light_angle_deg,
+                    reflected_light_angle=self.constants.reflected_light_angle_deg,
+                    grating_constant=self.constants.grating_constant_inverse_mm,
+                )
+
+                initial_dispersion = compute_initial_dispersion(
+                    central_wavelength=self.constants.wavelength * u.nm,
+                    incident_light_angle=self.constants.incident_light_angle_deg,
+                    reflected_light_angle=self.constants.reflected_light_angle_deg,
+                    lens_parameters=self.parameters.wavecal_camera_lens_parameters,
+                    pixel_pitch=self.parameters.wavecal_pixel_pitch_micron_per_pix,
+                )
+
+                doppler_velocity = compute_doppler_velocity(
+                    time_of_observation=self.constants.solar_gain_ip_start_time
+                )
+
+                self._log_wavecal_parameters(
+                    dispersion=initial_dispersion, order=order, doppler_velocity=doppler_velocity
+                )
+
+                fit_result = self.fit_initial_vignette(
+                    representative_spectrum=representative_spectrum,
+                    dispersion=initial_dispersion,
+                    spectral_order=order,
+                    doppler_velocity=doppler_velocity,
+                )
+
+                first_vignette_estimation = self.compute_initial_vignette_estimation(
+                    beam=beam,
+                    representative_spectrum=representative_spectrum,
+                    continuum=fit_result.best_fit_continuum,
+                )
+
+                self.write(
+                    data=first_vignette_estimation,
+                    tags=[VispTag.debug(), VispTag.beam(beam), VispTag.task("FIRST_VIGNETTE_EST")],
+                    encoder=fits_array_encoder,
+                )
+
+            with self.telemetry_span(f"Estimate 2D vignetting signature for {apm_str}"):
+                final_vignette = self.compute_final_vignette_estimate(
+                    init_vignette_correction=first_vignette_estimation
+                )
+                vignette_corrected_gain = self.geo_corrected_beam_data(beam=beam) / final_vignette
+
+                self.write(
+                    data=final_vignette,
+                    tags=[VispTag.debug(), VispTag.beam(beam), VispTag.task("FINAL_VIGNETTE")],
+                    encoder=fits_array_encoder,
+                )
+                self.write(
+                    data=vignette_corrected_gain,
+                    tags=[VispTag.debug(), VispTag.beam(beam), VispTag.task("VIGNETTE_CORR")],
+                    encoder=fits_array_encoder,
+                )
+
+            with self.telemetry_span(f"Save vignette quality metrics for {apm_str}"):
+                self.record_vignette_quality_metrics(
+                    beam=beam,
+                    representative_spectrum=representative_spectrum,
+                    fit_result=fit_result,
+                    vignette_corrected_gain=vignette_corrected_gain,
+                )
+
+            with self.telemetry_span(f"Compute characteristic spectra for {apm_str}"):
+                char_spec = self.compute_characteristic_spectra(vignette_corrected_gain)
+                self.write(
+                    data=char_spec,
+                    encoder=fits_array_encoder,
+                    tags=[VispTag.debug(), VispTag.frame()],
+                    relative_path=f"DEBUG_SC_CHAR_SPEC_BEAM_{beam}.dat",
+                    overwrite=True,
+                )
+
+            with self.telemetry_span(
+                f"Applying spectral shifts to characteristic spectra for {apm_str}"
+            ):
+                spec_shift = next(
+                    self.read(
                         tags=[
-                            VispTag.beam(beam),
-                            VispTag.modstate(modstate),
-                            VispTag.task("CHAR_SPEC_DISTORT_SHIFT"),
+                            VispTag.intermediate_frame(beam=beam),
+                            VispTag.task_geometric_spectral_shifts(),
                         ],
-                        relative_path=f"DEBUG_SC_CHAR_SPEC_DISTORT_SHIFT_BEAM_{beam}_MODSTATE_{modstate}.dat",
-                        overwrite=True,
-                    )
-
-                with self.telemetry_span(f"Refining characteristic spectral shifts for {apm_str}"):
-                    refined_char_spec = self.refine_gain_shifts(
-                        char_spec=reshifted_char_spec, beam=beam, modstate=modstate
-                    )
-                    self.write(
-                        data=refined_char_spec,
-                        encoder=fits_array_encoder,
-                        tags=[VispTag.debug(), VispTag.frame()],
-                        relative_path=f"DEBUG_SC_CHAR_SPEC_REFINE_BEAM_{beam}_MODSTATE_{modstate}.dat",
-                        overwrite=True,
+                        decoder=fits_array_decoder,
                     )
-
-                with self.telemetry_span(f"Removing solar signal from {apm_str}"):
-                    gain = self.remove_solar_signal(
-                        char_solar_spectra=refined_char_spec, beam=beam, modstate=modstate
+                )
+                redistorted_char_spec = next(
+                    self.corrections_remove_spec_geometry(
+                        arrays=char_spec, spec_shift=-1 * spec_shift
                     )
+                )
+                self.write(
+                    data=redistorted_char_spec,
+                    encoder=fits_array_encoder,
+                    tags=[VispTag.debug(), VispTag.frame()],
+                    relative_path=f"DEBUG_SC_CHAR_DISTORT_BEAM_{beam}.dat",
+                    overwrite=True,
+                )
 
-                with self.telemetry_span(f"Masking hairlines from {apm_str}"):
-                    gain = self.corrections_mask_hairlines(gain)
-
+            with self.telemetry_span(f"Re-distorting characteristic spectra for {apm_str}"):
+                reshifted_char_spec = self.distort_characteristic_spectra(
+                    char_spec=redistorted_char_spec, beam=beam
+                )
                 self.write(
-                    data=gain,
+                    data=reshifted_char_spec,
                     encoder=fits_array_encoder,
                     tags=[
-                        VispTag.debug(),
-                        VispTag.frame(),
+                        VispTag.beam(beam),
+                        VispTag.task("CHAR_SPEC_DISTORT_SHIFT"),
                     ],
-                    relative_path=f"DEBUG_SC_PRE_EQ_SOLAR_GAIN_BEAM_{beam}_MODSTATE_{modstate}.dat",
+                    relative_path=f"DEBUG_SC_CHAR_SPEC_DISTORT_SHIFT_BEAM_{beam}.dat",
                     overwrite=True,
                 )
 
-                pre_equalized_gain_dict[modstate] = gain
+            with self.telemetry_span(f"Removing solar signal from {apm_str}"):
+                gain = self.remove_solar_signal(char_solar_spectra=reshifted_char_spec, beam=beam)
 
-            with self.telemetry_span(f"Equalizing modstates for {beam = }"):
-                equalized_gain_dict = self.equalize_modstates(pre_equalized_gain_dict)
+            with self.telemetry_span(f"Masking hairlines from {apm_str}"):
+                final_gain = self.corrections_mask_hairlines(gain)
 
-            for modstate in range(1, self.constants.num_modstates + 1):
-
-                final_gain = equalized_gain_dict[modstate]
-
-                with self.telemetry_span(f"Writing solar gain for {beam = } and {modstate = }"):
-                    self.write_solar_gain_calibration(
-                        gain_array=final_gain, beam=beam, modstate=modstate
-                    )
+            with self.telemetry_span(f"Writing solar gain for {beam = }"):
+                self.write_solar_gain_calibration(
+                    gain_array=final_gain,
+                    beam=beam,
+                )
 
         with self.telemetry_span("Computing and logging quality metrics"):
             no_of_raw_solar_frames: int = self.scratch.count_all(
@@ -179,84 +317,36 @@ class SolarCalibration(
                 task_type=TaskName.solar_gain.value, total_frames=no_of_raw_solar_frames
             )
 
-    def unshifted_geo_corrected_modstate_data(self, beam: int, modstate: int) -> np.ndarray:
-        """
-        Array for a single beam/modstate that has dark, lamp, angle, and state offset corrections.
-
-        Parameters
-        ----------
-        beam : int
-            The beam number for this array
-
-        modstate : int
-            The modulator state for this array
-
-
-        Returns
-        -------
-        np.ndarray
-            Array with dark signal, lamp signal, angle and state offset removed
-
-        """
-        tags = [
-            VispTag.intermediate_frame(beam=beam, modstate=modstate),
-            VispTag.task("SC_GEO_NOSHIFT"),
-        ]
-        array_generator = self.read(tags=tags, decoder=fits_array_decoder)
-        return next(array_generator)
-
-    def geo_corrected_modstate_data(self, beam: int, modstate: int) -> np.ndarray:
+    def geo_corrected_beam_data(self, beam: int) -> np.ndarray:
         """
-        Array for a single beam/modstate that has dark, lamp, and ALL of the geometric corrects.
+        Array for a single beam that has dark, lamp, and ALL of the geometric corrects.
 
         Parameters
         ----------
-        beam : int
+        beam
             The beam number for this array
 
-        modstate : int
-            The modulator state for this array
-
-
         Returns
         -------
-        np.ndarray
+        Fully corrected array
             Array with dark signal, and lamp signal removed, and all geometric corrections made
         """
         tags = [
-            VispTag.intermediate_frame(beam=beam, modstate=modstate),
+            VispTag.intermediate_frame(beam=beam),
             VispTag.task("SC_GEO_ALL"),
         ]
         array_generator = self.read(tags=tags, decoder=fits_array_decoder)
         return next(array_generator)
 
-    def lamp_corrected_modstate_data(self, beam: int, modstate: int) -> np.ndarray:
-        """
-        Array for a single beam/modstate that has dark, background, and lamp gain applied.
-
-        This is used to refine the final shifts in the re-distorted characteristic spectra. Having the lamp gain applied
-        removes large optical features that would otherwise pollute the match to the characteristic spectra (which has
-        no optical features).
-        """
-        tags = [
-            VispTag.intermediate_frame(beam=beam, modstate=modstate),
-            VispTag.task("SC_LAMP_CORR"),
-        ]
-        array_generator = self.read(tags=tags, decoder=fits_array_decoder)
-        return next(array_generator)
-
-    def bg_corrected_modstate_data(self, beam: int, modstate: int) -> np.ndarray:
+    def bg_corrected_beam_data(self, beam: int) -> np.ndarray:
         """
-        Array for a single beam/modstate that has only has dark and background corrects applied.
+        Array for a single beam that has only has dark and background corrects applied.
 
         Parameters
         ----------
-        beam : int
+        beam
             The beam number for this array
 
-        modstate : int
-            The modulator state for this array
-
 
         Returns
         -------
@@ -264,37 +354,25 @@ class SolarCalibration(
             Array with dark and background signals removed
         """
         tags = [
-            VispTag.intermediate_frame(beam=beam, modstate=modstate),
+            VispTag.intermediate_frame(beam=beam),
             VispTag.task("SC_BG_ONLY"),
         ]
         array_generator = self.read(tags=tags, decoder=fits_array_decoder)
         return next(array_generator)
 
-    def do_initial_corrections(self, beam: int, modstate: int) -> None:
+    def do_initial_corrections(self, beam: int) -> None:
         """
         Do dark, lamp, and geometric corrections for all data that will be used.
 
-        At two intermediate points the current arrays are saved because they'll be needed by various helpers:
-
-        SC_BG_ONLY - The solar gain arrays with only a dark and background correction.
-
-        SC_GEO_NOSHIFT - The solar gain arrays after dark, lamp, angle, and state offset correction. In other words,
-                         they do not have spectral curvature removed. These are used to reshift the characteristic
-                         spectra to the original spectral curvature.
+        We also save an intermediate product of the average solar gain array with only dark and background corrections.
+        This array will later be used to produce the final solar gain. It's task tag is SC_BG_ONLY.
 
         Parameters
         ----------
-        beam : int
+        beam
             The beam number for this array
-
-        modstate : int
-            The modulator state for this array
-
-
-        Returns
-        -------
-        None
         """
+        all_exp_time_arrays = []
         for readout_exp_time in self.constants.solar_readout_exp_times:
             dark_array = next(
                 self.read(
@@ -314,15 +392,12 @@ class SolarCalibration(
                     )
                 )
 
-            logger.info(
-                f"Doing dark, background, lamp, and geo corrections for {beam=} and {modstate=}"
-            )
+            logger.info(f"Doing dark, background, lamp, and geo corrections for {beam=}")
             ## Load frames
             tags = [
                 VispTag.input(),
                 VispTag.frame(),
                 VispTag.task_solar_gain(),
-                VispTag.modstate(modstate),
                 VispTag.readout_exp_time(readout_exp_time),
             ]
             input_solar_gain_objs = self.read(
@@ -334,140 +409,120 @@ class SolarCalibration(
                 for o in input_solar_gain_objs
             )
 
-            ## Average
             avg_solar_array = average_numpy_arrays(readout_normalized_arrays)
 
-            ## Dark correction
             dark_corrected_solar_array = subtract_array_from_arrays(
                 arrays=avg_solar_array, array_to_subtract=dark_array
             )
 
-            ## Residual background correction
             background_corrected_solar_array = next(
                 subtract_array_from_arrays(dark_corrected_solar_array, background_array)
             )
 
-            # Save the only-dark-corr because this will be used to make the final Solar Gain object
-            self.write(
-                data=background_corrected_solar_array,
-                tags=[
-                    VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                    VispTag.task("SC_BG_ONLY"),
-                ],
-                encoder=fits_array_encoder,
-            )
+            all_exp_time_arrays.append(background_corrected_solar_array)
 
-            ## Lamp correction
-            lamp_array = next(
-                self.read(
-                    tags=[
-                        VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                        VispTag.task_lamp_gain(),
-                    ],
-                    decoder=fits_array_decoder,
-                )
-            )
-            lamp_corrected_solar_array = next(
-                divide_arrays_by_array(
-                    arrays=background_corrected_solar_array, array_to_divide_by=lamp_array
-                )
-            )
+        avg_dark_bg_corrected_array = average_numpy_arrays(all_exp_time_arrays)
 
-            self.write(
-                data=lamp_corrected_solar_array,
+        # Save the only-dark-corr because this will be used to make the final Solar Gain object
+        self.write(
+            data=avg_dark_bg_corrected_array,
+            tags=[
+                VispTag.intermediate_frame(beam=beam),
+                VispTag.task("SC_BG_ONLY"),
+            ],
+            encoder=fits_array_encoder,
+        )
+
+        ## Lamp correction
+        lamp_array = next(
+            self.read(
                 tags=[
-                    VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                    VispTag.task("SC_LAMP_CORR"),
+                    VispTag.intermediate_frame(beam=beam),
+                    VispTag.task_lamp_gain(),
                 ],
-                encoder=fits_array_encoder,
-            )
-
-            ## Geo correction
-            angle_array = next(
-                self.read(
-                    tags=[VispTag.intermediate_frame(beam=beam), VispTag.task_geometric_angle()],
-                    decoder=fits_array_decoder,
-                )
-            )
-            angle = angle_array[0]
-            state_offset = next(
-                self.read(
-                    tags=[
-                        VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                        VispTag.task_geometric_offset(),
-                    ],
-                    decoder=fits_array_decoder,
-                )
+                decoder=fits_array_decoder,
             )
-            spec_shift = next(
-                self.read(
-                    tags=[
-                        VispTag.intermediate_frame(beam=beam),
-                        VispTag.task_geometric_spectral_shifts(),
-                    ],
-                    decoder=fits_array_decoder,
-                )
+        )
+        lamp_corrected_solar_array = next(
+            divide_arrays_by_array(
+                arrays=avg_dark_bg_corrected_array, array_to_divide_by=lamp_array
             )
+        )
 
-            geo_corrected_array = next(
-                self.corrections_correct_geometry(lamp_corrected_solar_array, state_offset, angle)
-            )
-            # We need unshifted, but geo-corrected arrays for reshifting and normalization
-            self.write(
-                data=geo_corrected_array,
-                tags=[
-                    VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                    VispTag.task("SC_GEO_NOSHIFT"),
-                ],
-                encoder=fits_array_encoder,
-            )
+        self.write(
+            data=lamp_corrected_solar_array,
+            tags=[
+                VispTag.debug(),
+                VispTag.beam(beam),
+                VispTag.task("SC_LAMP_CORR"),
+            ],
+            encoder=fits_array_encoder,
+        )
 
-            # Now finish the spectral shift correction
-            spectral_corrected_array = next(
-                self.corrections_remove_spec_geometry(geo_corrected_array, spec_shift)
+        ## Geo correction
+        angle_array = next(
+            self.read(
+                tags=[VispTag.intermediate_frame(beam=beam), VispTag.task_geometric_angle()],
+                decoder=fits_array_decoder,
             )
-            self.write(
-                data=spectral_corrected_array,
+        )
+        angle = angle_array[0]
+
+        # Because we have averaged over all modstates, the per-modestate offsets don't matter. Also, we're going to
+        # undo these corrections to make the final gain, so the beam2 -> beam1 offset doesn't matter either.
+        state_offset = np.array([0.0, 0.0])
+        spec_shift = next(
+            self.read(
                 tags=[
-                    VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                    VispTag.task("SC_GEO_ALL"),
+                    VispTag.intermediate_frame(beam=beam),
+                    VispTag.task_geometric_spectral_shifts(),
                 ],
-                encoder=fits_array_encoder,
+                decoder=fits_array_decoder,
             )
+        )
 
-    def compute_characteristic_spectra(self, beam: int, modstate: int) -> np.ndarray:
-        """
-        Compute the 2D characteristic spectra via a Gaussian smooth in the spatial dimension.
-
-        A 2D characteristic spectra is needed because the line shape varys along the slit to the degree that a
-        single, 1D characteristic spectrum will not fully remove the solar lines for all positions in the final gain.
-
-        In this step we also normalize each spatial position to its median value. This removes low-order gradients in
-        the spatial direction that are known to be caused by imperfect illumination of the Lamp gains (which were used
-        to correct the data that will become the characteristic spectra).
-
-        Parameters
-        ----------
-        beam : int
-            The beam number for this array
+        geo_corrected_array = next(
+            self.corrections_correct_geometry(lamp_corrected_solar_array, state_offset, angle)
+        )
+        self.write(
+            data=geo_corrected_array,
+            tags=[
+                VispTag.debug(),
+                VispTag.beam(beam),
+                VispTag.task("SC_GEO_NOSHIFT"),
+            ],
+            encoder=fits_array_encoder,
+        )
 
-        modstate : int
-            The modulator state for this array
+        # Now finish the spectral shift correction
+        spectral_corrected_array = next(
+            self.corrections_remove_spec_geometry(geo_corrected_array, spec_shift)
+        )
+        self.write(
+            data=spectral_corrected_array,
+            tags=[
+                VispTag.intermediate_frame(beam=beam),
+                VispTag.task("SC_GEO_ALL"),
+            ],
+            encoder=fits_array_encoder,
+        )
 
+    def get_representative_spectrum(self, beam: int) -> np.ndarray:
+        """
+        Compute a representative spectrum that will be used for solar atlas and continuum fitting.
 
-        Returns
-        -------
-        np.ndarray
-            Characteristic spectra array
+        The spectrum is the spatial median of the lamp-and-spectral-shift corrected solar gain image for this beam.
+        Prior to computing the spatial median each spatial pixel is normalized by its continuum level so that variations
+        in overall scaling as a function of slit position don't skew the median line shapes. The continuum for each
+        spatial pixel is estimated from a percentage of the CDF; this percentage is a pipeline parameter.
         """
-        spectral_avg_window = self.parameters.solar_spectral_avg_window
         normalization_percentile = (
             self.parameters.solar_characteristic_spatial_normalization_percentile
         )
         logger.info(
-            f"Computing characteristic spectra for {beam = } and {modstate = } with {spectral_avg_window = } and {normalization_percentile = }"
+            f"Computing representative spectra for {beam = } with {normalization_percentile = }"
         )
-        full_spectra = self.geo_corrected_modstate_data(beam=beam, modstate=modstate)
+        full_spectra = self.geo_corrected_beam_data(beam=beam)
 
         full_spectra = self.corrections_mask_hairlines(full_spectra)
         # Normalize each spatial pixel by its own percentile. This removes large spatial gradients that are not solar
@@ -476,86 +531,315 @@ class SolarCalibration(
             full_spectra, normalization_percentile, axis=0
         )
 
-        # size = (1, window) means don't smooth in the spectra dimension
-        char_spec = spnd.median_filter(normed_spectra, size=(1, spectral_avg_window))
+        representative_spectrum = np.nanmedian(normed_spectra, axis=1)
 
-        return char_spec
+        return representative_spectrum
 
-    def refine_gain_shifts(self, char_spec: np.ndarray, beam: int, modstate: int) -> np.ndarray:
+    def fit_initial_vignette(
+        self,
+        representative_spectrum: np.ndarray,
+        dispersion: Quantity,
+        spectral_order: int,
+        doppler_velocity: Quantity,
+    ) -> FitResult:
         """
-        Refine the spectral shifts when matching characteristic spectra to the rectified input spectra.
+        Fit a global continuum to a single, representative spectrum.
 
-        An important detail of this functino is that the goodness of fit metric is the final gain image (i.e., raw
-        input with solar spectrum removed). We minimize the residuals in the gain image.
+        The representative spectrum's continuum is estimated by fitting the spectrum to a solar atlas. The continuum
+        is parameterized with a polynomial as seen in `WavelengthCalibrationParametersWithContinuum` and
+        `polynomial_continuum_model`.
+        """
+        atlas = Atlas(self.parameters.wavecal_atlas_download_config)
+
+        logger.info("Initializing wavecal fit parameters")
+        init_parameters = self.initialize_starting_fit_parameters(
+            representative_spectrum=representative_spectrum,
+            dispersion=dispersion,
+            spectral_order=spectral_order,
+            doppler_velocity=doppler_velocity,
+            atlas=atlas,
+        )
 
-        Parameters
-        ----------
-        char_spec : np.ndarray
-            Computed characteristic spectra
+        fitter = WavelengthCalibrationFitter(input_parameters=init_parameters, atlas=atlas)
+        with self.telemetry_span("Fit atlas and continuum"):
+            extra_kwargs = self.parameters.solar_vignette_wavecal_fit_kwargs
+            logger.info(f"Calling fitter with extra kwargs: {extra_kwargs}")
+            fit_result = fitter(
+                input_spectrum=representative_spectrum,
+                **extra_kwargs,
+            )
 
-        beam : int
-            The beam number for this array
+        return fit_result
 
-        modstate : int
-            The modulator state for this array
+    def compute_initial_vignette_estimation(
+        self, beam: int, representative_spectrum: np.ndarray, continuum: np.ndarray
+    ) -> np.ndarray:
+        """
+        Compute the initial, 1D estimate of the spectral vignette signal.
+
+        The continuum is first removed from the representative spectrum to make the first guess at a vignette-corrected
+        solar spectrum. Then this solar spectrum is divided from the 2D lamp-and-spectral-shift corrected solar gain data.
+
+        Because the continuum was fit for a single spectrum, the result is a 2D array that contains the *spatial*
+        variation in the vignetting signal.
+        """
+        first_vignette_array = (
+            self.geo_corrected_beam_data(beam=beam) / (representative_spectrum / continuum)[:, None]
+        )
+        return first_vignette_array
+
+    def initialize_starting_fit_parameters(
+        self,
+        representative_spectrum: np.ndarray,
+        dispersion: Quantity,
+        spectral_order: int,
+        doppler_velocity: Quantity,
+        atlas: Atlas,
+    ) -> WavelengthCalibrationParametersWithContinuum:
+        """
+        Construct a `WavelengthCalibrationParametersWithContinuum` object containing initial guesses, fit flags, and bounds.
+
+        A rough estimate of the initial CRVAL value is made using `solar_wavelength_calibration.calculate_initial_crval_guess`.
+        """
+        num_wave = representative_spectrum.size
+        normalized_abscissa = np.linspace(-1, 1, num_wave)
+
+        logger.info("Computing input wavelength vector")
+        input_wavelength_vector = compute_input_wavelength_vector(
+            central_wavelength=self.constants.wavelength * u.nm,
+            dispersion=dispersion,
+            grating_constant=self.constants.grating_constant_inverse_mm,
+            order=spectral_order,
+            incident_light_angle=self.constants.incident_light_angle_deg,
+            num_spec_px=representative_spectrum.size,
+        )
+        wavelength_range = input_wavelength_vector.max() - input_wavelength_vector.min()
+
+        logger.info("Computing initial CRVAL guess")
+        crval_init = calculate_initial_crval_guess(
+            input_wavelength_vector=input_wavelength_vector,
+            input_spectrum=representative_spectrum,
+            atlas=atlas,
+            negative_limit=-wavelength_range / 2,
+            positive_limit=wavelength_range / 2,
+            num_steps=500,
+            normalization_percentile=self.parameters.wavecal_init_crval_guess_normalization_percentile,
+        )
+
+        logger.info(f"{crval_init = !s}")
+
+        fit_flags = FitFlagsModel(
+            continuum_level=False,  # Because we're fitting the continuum with a function
+            incident_light_angle=False,
+            straylight_fraction=True,
+            resolving_power=True,
+            opacity_factor=True,
+        )
+
+        incident_light_angle = self.constants.incident_light_angle_deg
+        grating_constant = self.constants.grating_constant_inverse_mm
+        resolving_power = self.parameters.wavecal_init_resolving_power
+        opacity_factor = self.parameters.wavecal_init_opacity_factor
+        straylight_faction = self.parameters.wavecal_init_straylight_fraction
+        relative_atlas_scaling = self.estimate_relative_continuum_level(
+            crval_init=crval_init,
+            wavelength_range=wavelength_range,
+            atlas=atlas,
+            representative_spectrum=representative_spectrum,
+        )
+        logger.info(f"0th order coefficient initial guess: {relative_atlas_scaling}")
+
+        wavelength_search_width = dispersion * self.parameters.solar_vignette_crval_bounds_px
+        bounds = BoundsModel(
+            crval=LengthBoundRange(
+                min=crval_init - wavelength_search_width, max=crval_init + wavelength_search_width
+            ),
+            dispersion=DispersionBoundRange(
+                min=dispersion * (1 - self.parameters.solar_vignette_dispersion_bounds_fraction),
+                max=dispersion * (1 + self.parameters.solar_vignette_dispersion_bounds_fraction),
+            ),
+            incident_light_angle=AngleBoundRange(
+                min=incident_light_angle - 1 * u.deg, max=incident_light_angle + 1 * u.deg
+            ),
+            resolving_power=UnitlessBoundRange(min=1e5, max=5e5),
+            opacity_factor=UnitlessBoundRange(min=1.0, max=10),
+            straylight_fraction=UnitlessBoundRange(min=0.0, max=0.8),
+        )
+
+        init_params = WavelengthCalibrationParametersWithContinuum(
+            crval=crval_init,
+            dispersion=dispersion,
+            incident_light_angle=incident_light_angle,
+            grating_constant=grating_constant,
+            doppler_velocity=doppler_velocity,
+            order=spectral_order,
+            continuum_level=1,
+            resolving_power=resolving_power,
+            opacity_factor=opacity_factor,
+            straylight_fraction=straylight_faction,
+            fit_flags=fit_flags,
+            bounds=bounds,
+            continuum_poly_fit_order=self.parameters.solar_vignette_initial_continuum_poly_fit_order,
+            normalized_abscissa=normalized_abscissa,
+            zeroth_order_continuum_coefficient=relative_atlas_scaling,
+        )
 
+        return init_params
+
+    def estimate_relative_continuum_level(
+        self,
+        *,
+        crval_init: Quantity,
+        wavelength_range: Quantity,
+        atlas: Atlas,
+        representative_spectrum: np.ndarray,
+    ) -> float:
+        """
+        Estimate the multiplicative scaling between the representative spectrum and atlas solar transmission.
+
+        This scaling is used to set the initial guess of 0th-order polynomial fit coefficient. We estimate the scaling
+        factor by comparing the values of the two spectra at a given percent of the CDF. This percent is taken from
+        the `~dkist_processing_visp.models.parameters.VispParameters.wavecal_init_crval_guess_normalization_percentile`
+        pipeline parameter.
+        """
+        wave_min = crval_init - wavelength_range / 2
+        wave_max = crval_init + wavelength_range / 2
+
+        atlas_idx = np.where(
+            (atlas.solar_atlas_wavelength >= wave_min) & (atlas.solar_atlas_wavelength <= wave_max)
+        )
+        atlas_norm = np.nanpercentile(
+            atlas.solar_atlas_transmission[atlas_idx],
+            self.parameters.wavecal_init_crval_guess_normalization_percentile,
+        )
+        spec_norm = np.nanpercentile(
+            representative_spectrum,
+            self.parameters.wavecal_init_crval_guess_normalization_percentile,
+        )
+
+        return spec_norm / atlas_norm
+
+    def compute_final_vignette_estimate(self, init_vignette_correction: np.ndarray) -> np.ndarray:
+        """
+        Fit the spectral shape of continuum residuals for each spatial pixel.
+
+        The vignette estimation produced by `compute_initial_vignette_estimation` used a single continuum function for
+        the entire slit. This method fits the continuum for all pixels along the slit to build up a fully 2D estimate
+        of the vignette signal.
+
+        Each spatial pixel is fit separately with a polynomial via a RANSAC estimator.
+        """
+        model = self.build_RANSAC_model()
+        num_spectral, num_spatial = init_vignette_correction.shape
+        abscissa = np.arange(num_spectral)[
+            :, None
+        ]  # Add extra dimension because sklearn requires it
+
+        logger.info(f"Fitting spectral vignetting for {num_spatial} spatial pixels")
+        final_vignette = np.zeros_like(init_vignette_correction)
+        for spatial_px in range(num_spatial):
+            finite_idx = np.isfinite(init_vignette_correction[:, spatial_px])
+            model.fit(abscissa[finite_idx, :], init_vignette_correction[finite_idx, spatial_px])
+            final_vignette[:, spatial_px] = model.predict(abscissa)
+
+        return final_vignette
+
+    def build_RANSAC_model(self) -> Pipeline:
+        """
+        Build a scikit-learn pipeline from a set of estimators.
+
+        Namely, construct a `~sklearn.pipeline.Pipeline` built from
+
+        `~sklearn.preprocessing.PolynomialFeatures` -> `~sklearn.preprocessing.RobustScaler` -> `~sklearn.linear_model.RANSACRegressor`
+        """
+        fit_order = self.parameters.solar_vignette_spectral_poly_fit_order
+        min_samples = self.parameters.solar_vignette_min_samples
+        logger.info(f"Building RANSAC model with {fit_order = } and {min_samples = }")
+
+        # PolynomialFeatures casts the pipeline as a polynomial fit
+        # see https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html#sklearn.preprocessing.PolynomialFeatures
+        poly_feature = PolynomialFeatures(degree=fit_order)
+
+        # RobustScaler is a scale factor that is robust to outliers
+        # see https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html#sklearn.preprocessing.RobustScaler
+        scaler = RobustScaler()
+
+        # The RANSAC regressor iteratively sub-samples the input data and constructs a model with this sub-sample.
+        # The method used allows it to be robust to outliers.
+        # see https://scikit-learn.org/stable/modules/linear_model.html#ransac-regression
+        RANSAC = RANSACRegressor(min_samples=min_samples)
+
+        return make_pipeline(poly_feature, scaler, RANSAC)
+
+    def compute_characteristic_spectra(self, vignette_corrected_data: np.ndarray) -> np.ndarray:
+        """
+        Compute the 2D characteristic spectra via a median smooth in the spatial dimension.
+
+        A 2D characteristic spectra is needed because the line shape varys along the slit to the degree that a
+        single, 1D characteristic spectrum will not fully remove the solar lines for all positions in the final gain.
+
+        In this step we also normalize each spatial position by its continuum value. This removes low-order gradients in
+        the spatial direction that are known to be caused by imperfect illumination of the Lamp gains (which were used
+        to correct the data that will become the characteristic spectra).
+
+        Parameters
+        ----------
+        beam
+            The beam number for this array
 
         Returns
         -------
-        np.ndarray
-            Characteristic spectra array with refined spectral shifts
-        """
-        # Grab rectified input spectra that will be the shift target
-        target_spectra = self.lamp_corrected_modstate_data(beam=beam, modstate=modstate)
-        num_spec = target_spectra.shape[1]
-
-        logger.info(f"Computing line zones for {beam=} and {modstate=}")
-        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,
-        }
-        zones = self.compute_line_zones(char_spec, **zone_kwargs)
-        logger.info(f"Found {zones=} for {beam=} and {modstate=}")
-        if len(zones) == 0:
-            raise ValueError(f"No zones found for {beam=} and {modstate=}")
+        char_spec
+            2D characteristic spectra
+        """
+        spatial_median_window = self.parameters.solar_spatial_median_filter_width_px
+        normalization_percentile = (
+            self.parameters.solar_characteristic_spatial_normalization_percentile
+        )
+        logger.info(
+            f"Computing characteristic spectra for {spatial_median_window = } and {normalization_percentile = }"
+        )
+
+        masked_spectra = self.corrections_mask_hairlines(vignette_corrected_data)
+        # Normalize each spatial pixel by its own percentile. This removes large spatial gradients that are not solar
+        # signal.
+        normed_spectra = masked_spectra / np.nanpercentile(
+            masked_spectra, normalization_percentile, axis=0
+        )
 
-        reshift_char_spec = np.zeros(char_spec.shape)
-        logger.info(f"Refining shifts for {beam=} and {modstate=}")
-        for i in range(num_spec):
-            ref_spec = target_spectra[:, i] / np.nanmedian(target_spectra[:, i])
-            spec = char_spec[:, i] / np.nanmedian(char_spec[:, i])
-            shift = SolarCalibration.refine_shift(spec, ref_spec, zones=zones, x_init=0.0)
-            reshift_char_spec[:, i] = spnd.shift(char_spec[:, i], shift, mode="reflect")
+        # size = (1, window) means don't smooth in the spectral dimension
+        char_spec = spnd.median_filter(normed_spectra, size=(1, spatial_median_window))
 
-        return reshift_char_spec
+        normed_char_spec = char_spec / np.nanpercentile(char_spec, normalization_percentile, axis=0)
+
+        return normed_char_spec
 
     def distort_characteristic_spectra(
-        self, char_spec: np.ndarray, beam: int, modstate: int
+        self,
+        char_spec: np.ndarray,
+        beam: int,
     ) -> np.ndarray:
         """
         Re-apply angle and state offset distortions to the characteristic spectra.
 
         Parameters
         ----------
-        char_spec : np.ndarray
+        char_spec
             Computed characteristic spectra
 
-        beam : int
+        beam
             The beam number for this array
 
-        modstate : int
+        modstate
             The modulator state for this array
 
 
         Returns
         -------
-        np.ndarray
+        distorted characteristic array
             Characteristic spectra array with angle and offset distortions re-applied
         """
-        logger.info(f"Re-distorting characteristic spectra for {beam=} and {modstate=}")
+        logger.info(f"Re-distorting characteristic spectra for {beam=}")
         angle_array = next(
             self.read(
                 tags=[VispTag.intermediate_frame(beam=beam), VispTag.task_geometric_angle()],
@@ -563,15 +847,9 @@ class SolarCalibration(
             )
         )
         angle = angle_array[0]
-        state_offset = next(
-            self.read(
-                tags=[
-                    VispTag.intermediate_frame(beam=beam, modstate=modstate),
-                    VispTag.task_geometric_offset(),
-                ],
-                decoder=fits_array_decoder,
-            )
-        )
+
+        # See comment in `do_initial_corrections`; we don't care about the state_offset when making the solar gain
+        state_offset = np.array([0.0, 0.0])
 
         distorted_spec = next(
             self.corrections_correct_geometry(char_spec, -1 * state_offset, -1 * angle)
@@ -579,164 +857,329 @@ class SolarCalibration(
 
         return distorted_spec
 
-    def equalize_modstates(self, array_dict: dict[int, np.ndarray]) -> dict[int, np.ndarray]:
-        """Adjust the flux of all modstates for a single beam so they all have the same median.
-
-        That median is the global median over all modstates.
-        """
-        global_median_array = np.nanmedian(list(array_dict.values()), axis=0)
-        output_dict = dict()
-
-        for modstate, array in array_dict.items():
-            correction = np.nanmedian(global_median_array / array)
-            logger.info(f"Equalization correction for {modstate = } is {correction:.6f}")
-            final_gain = array * correction
-            output_dict[modstate] = final_gain
-
-        return output_dict
-
     def remove_solar_signal(
-        self, char_solar_spectra: np.ndarray, beam: int, modstate: int
+        self,
+        char_solar_spectra: np.ndarray,
+        beam: int,
     ) -> np.ndarray:
         """
         Remove the distorted characteristic solar spectra from the original spectra.
 
         Parameters
         ----------
-        char_solar_spectra : np.ndarray
+        char_solar_spectra
             Characteristic solar spectra
 
-        beam : int
+        beam
             The beam number for this array
 
-        modstate : int
-            The modulator state for this array
-
-
         Returns
         -------
-        np.ndarray
+        final gain
             Original spectral array with characteristic solar spectra removed
-
         """
-        logger.info(f"Removing characteristic solar spectra from {beam=} and {modstate=}")
-        input_gain = self.bg_corrected_modstate_data(beam=beam, modstate=modstate)
+        logger.info(f"Removing characteristic solar spectra from {beam=}")
+        input_gain = self.bg_corrected_beam_data(beam=beam)
 
         final_gain = input_gain / char_solar_spectra
 
         return final_gain
 
     def write_solar_gain_calibration(
-        self, gain_array: np.ndarray, beam: int, modstate: int
+        self,
+        gain_array: np.ndarray,
+        beam: int,
     ) -> None:
         """
-        Write a solar gain array for a single beam and modstate.
+        Write a solar gain array for a single beam.
 
         Parameters
         ----------
-        gain_array: np.ndarray
+        gain_array
             Solar gain array
 
-        beam : int
+        beam
             The beam number for this array
-
-        modstate : int
-            The modulator state for this array
-
-
-        Returns
-        -------
-        None
         """
-        logger.info(f"Writing final SolarGain for {beam=} and {modstate=}")
+        logger.info(f"Writing final SolarGain for {beam = }")
         self.write(
             data=gain_array,
             tags=[
-                VispTag.intermediate_frame(beam=beam, modstate=modstate),
+                VispTag.intermediate_frame(beam=beam),
                 VispTag.task_solar_gain(),
             ],
             encoder=fits_array_encoder,
         )
 
-    @staticmethod
-    def refine_shift(
-        spec: np.ndarray, target_spec: np.ndarray, zones: list[tuple[int, int]], x_init: float
-    ) -> float:
+    def record_vignette_quality_metrics(
+        self,
+        beam: int,
+        representative_spectrum: np.ndarray,
+        fit_result: FitResult,
+        vignette_corrected_gain: np.ndarray,
+    ) -> None:
         """
-        Refine the shift for a single spatial position back to the rectified input spectra.
+        Save vignette fit results to disk for later quality metric building.
 
-        Line zones are used to increase the SNR of the chisq and the final shift is the mean of the shifts computed
-        for each zone.
+        We save the atlas fit of the initial vignette estimation and the global solar spectrum derived from the
+        vignette-corrected 2D gain images.
+        """
+        logger.info(f"Recording initial vignette quality data for {beam = }")
+        first_vignette_quality_outputs = {
+            "output_wave_vec": fit_result.best_fit_wavelength_vector,
+            "input_spectrum": representative_spectrum,
+            "best_fit_atlas": fit_result.best_fit_atlas,
+            "best_fit_continuum": fit_result.best_fit_continuum,
+            "residuals": fit_result.minimizer_result.residual,
+        }
+        self.write(
+            data=first_vignette_quality_outputs,
+            tags=[VispTag.quality(VispMetricCode.solar_first_vignette), VispTag.beam(beam)],
+            encoder=asdf_encoder,
+        )
 
-        Parameters
-        ----------
-        spec : np.ndarray
-            The 1D spectrum to shift back
+        logger.info(f"Recording final vignette-correced gain quality data for {beam = }")
+        global_median = np.nanmedian(vignette_corrected_gain, axis=1)
+        low_deviation = np.nanpercentile(vignette_corrected_gain, 5, axis=1)
+        high_deviation = np.nanpercentile(vignette_corrected_gain, 95, axis=1)
+        final_correction_quality_outputs = {
+            "output_wave_vec": fit_result.best_fit_wavelength_vector,
+            "median_spec": global_median,
+            "low_deviation": low_deviation,
+            "high_deviation": high_deviation,
+        }
+        self.write(
+            data=final_correction_quality_outputs,
+            tags=[VispTag.quality(VispMetricCode.solar_final_vignette), VispTag.beam(beam)],
+            encoder=asdf_encoder,
+        )
 
-        target_spec : np.ndarray
-            The reference spectrum. This should be the un-shifted, raw spectrum at the same position as `spec`
+    def _log_wavecal_parameters(
+        self, dispersion: Quantity, order: int, doppler_velocity: Quantity
+    ) -> None:
+        """Log initial guess and instrument-derived wavecal parameters."""
+        logger.info(f"central wavelength = {self.constants.wavelength * u.nm !s}")
+        logger.info(f"{dispersion = !s}")
+        logger.info(f"{order = }")
+        logger.info(f"grating constant = {self.constants.grating_constant_inverse_mm !s}")
+        logger.info(f"incident light angle = {self.constants.incident_light_angle_deg !s}")
+        logger.info(f"reflected light angle = {self.constants.reflected_light_angle_deg !s}")
+        logger.info(f"{doppler_velocity = !s}")
+        logger.info(f"pixel pitch = {self.parameters.wavecal_pixel_pitch_micron_per_pix !s}")
+        logger.info(f"solar ip start time = {self.constants.solar_gain_ip_start_time}")
+
+
+def polynomial_continuum_model(
+    wavelength_vector: np.ndarray, fit_parameters: Parameters, fit_order: int, abscissa: np.ndarray
+) -> np.ndarray:
+    """
+    Parameterize the continuum as a polynomial.
 
-        zones : List
-            List of zone borders (in px coords)
+    Polynomial coefficients are taken from the input ``fit_parameters`` object. The ``wavelength_vector`` argument is not
+    used by required to conform to the signature expected by `WavelengthCalibrationFitter`.
 
-        x_init: float
-            Initial guess for the shift. This is used to shift the zones so it needs to be pretty good, but not perfect.
+    Parameters
+    ----------
+    wavelength_vector
+        Unused, but required by `WavelengthCalibrationFitter`
 
-        Returns
-        -------
-        float
-            The shift value
-        """
-        shifts = np.zeros(len(zones))
-        for i, z in enumerate(zones):
-            if z[1] + int(x_init) >= spec.size:
-                logger.info(f"Ignoring zone {z} with init {x_init} because it's out of range")
-                continue
-            idx = np.arange(z[0], z[1]) + int(x_init)
-            shift = spo.minimize(
-                SolarCalibration.shift_func,
-                np.array([x_init]),
-                args=(target_spec, spec, idx),
-                method="nelder-mead",
-            ).x[0]
-            shifts[i] = shift
-
-        return np.nanmedian(shifts)
-
-    @staticmethod
-    def shift_func(
-        par: list[float], ref_spec: np.ndarray, spec: np.ndarray, idx: np.ndarray
-    ) -> float:
-        """
-        Non-chisq based goodness of fit calculator for computing spectral shifts.
+    fit_parameters
+        Object containing the current fit parameters
 
-        Instead of chisq, the metric approximates the final Gain image.
+    fit_order
+        Polynomial order. This needs to match the number of polynomial coefficients in the ``fit_parameters`` argument.
+        Specifically, this method expects parameters called `[f"poly_coeff_{i:02n}" for i in range(fit_order + 1)]`.
 
-        Parameters
-        ----------
-        par : List
-            List of parameters for minimization
+    abscissa
+        Array of values used to compute the continuum. For the fit to be independent of wavelength these values should
+        be in the range [-1, 1].
+    """
+    coeffs = [fit_parameters[f"poly_coeff_{i:02n}"].value for i in range(fit_order + 1)]
+    return np.polyval(coeffs, abscissa)
 
-        ref_spec : np.ndarray
-            Reference spectra
 
-        spec : np.ndarray
-            Data
+##################################################################################
+# TODO: The following definitions should go in the wavecal module once it exists #
+##################################################################################
 
-        idx : np.ndarray
-            Range of wavelength pixels that will be compared in fit
 
-        Returns
-        -------
-        float
-            Goodness of fit metric
-
-        """
-        shift = par[0]
-        shifted_spec = spnd.shift(spec, shift, mode="constant", cval=np.nan)
-        final_gain = (ref_spec / shifted_spec)[idx]
-        slope = (final_gain[-1] - final_gain[0]) / final_gain.size
-        bg = slope * np.arange(final_gain.size) + final_gain[0]
-        subbed_gain = np.abs((final_gain) - bg)
-        fit_metric = np.nansum(subbed_gain[np.isfinite(subbed_gain)])
-        return fit_metric
+def compute_order(
+    central_wavelength: Quantity,
+    incident_light_angle: Quantity,
+    reflected_light_angle: Quantity,
+    grating_constant: Quantity,
+) -> int:
+    r"""
+    Compute the spectral order from the spectrograph setup.
+
+    From the grating equation, the spectral order, :math:`m`:, is
+
+    .. math::
+        m = \frac{\sin\alpha + \sin\beta}{G \lambda}
+
+    where :math:`\alpha` and :math:`\beta` are the incident and reflected light angles, respectively, :math:`G` is the
+    grating constant (lines per mm), and :math:`\lambda` is the central wavelength. All of these values come from the
+    input headers.
+
+    Parameters
+    ----------
+    central_wavelength
+        Wavelength of the center of the spectral window.
+
+    incident_light_angle
+        Angle of light incident to the spectrograph grating. Often called :math:`\alpha`.
+
+    reflected_light_angle
+        Angle of light reflected from spectrograph grating. Often called :math:`\beta`.
+
+    grating_constant
+        Grating constant of the spectrograph grating [lines per mm]
+
+    Returns
+    -------
+    spectral_order
+        The order of the given spectrograph configuration
+    """
+    return int(
+        (np.sin(incident_light_angle) + np.sin(reflected_light_angle))
+        / (grating_constant * central_wavelength)
+    )
+
+
+def compute_initial_dispersion(
+    central_wavelength: Quantity,
+    incident_light_angle: Quantity,
+    reflected_light_angle: Quantity,
+    lens_parameters: list[Quantity],
+    pixel_pitch: Quantity,
+) -> Quantity:
+    r"""
+    Compute the dispersion (:math:`d\,\lambda/d\, px`) given the spectrograph setup.
+
+    The dispersion is given via
+
+    .. math::
+        d\,\lambda / d\, px = \frac{p \lambda_0 \cos\beta}{f (\sin\alpha + \sin\beta)}
+
+    where :math:`p` is the pixel pitch (microns per pix), :math:`\lambda_0` is the central wavelength, :math:`f` is the
+    camera focal length, and :math:`\alpha` and :math:`\beta` are the incident and reflected light angles, respectively.
+    :math:`\lambda_0`, :math:`\alpha`, and :math:`\beta` are taken from input headers, while :math:`f` and :math:`p` are
+    pipeline parameters.
+
+    Parameters
+    ----------
+    central_wavelength
+        Wavelength of the center of the spectral window.
+
+    incident_light_angle
+        Angle of light incident to the spectrograph grating. Often called :math:`\alpha`.
+
+    reflected_light_angle
+        Angle of light reflected from spectrograph grating. Often called :math:`\beta`.
+
+    lens_parameters
+        Parameterization of lense focal length as zero, first, and second orders of wavelength. If the total focal
+        length of the lens is :math:`f = a_0 + a_1\lambda + a_2\lambda^2` then this list is :math:`[a_0, a_1, a_2]`.
+
+    pixel_pitch
+        The physical size of a single pixel
+
+    Returns
+    -------
+    dispersion
+       The computed dispersion in units of nm / px
+    """
+    camera_focal_length = lens_parameters[0] + central_wavelength * (
+        lens_parameters[1] + central_wavelength * lens_parameters[2]
+    )
+    logger.info(f"{camera_focal_length = !s}")
+
+    linear_dispersion = (
+        camera_focal_length
+        * (np.sin(incident_light_angle) + np.sin(reflected_light_angle))
+        / (np.cos(reflected_light_angle) * central_wavelength)
+    )
+
+    dispersion = pixel_pitch / linear_dispersion
+
+    return dispersion.to(u.nm / u.pix)
+
+
+def compute_doppler_velocity(time_of_observation: str) -> Quantity:
+    """Find the speed at which DKIST is moving relative to the Sun's center.
+
+    Positive values refer to when DKIST is moving away from the sun.
+
+    Parameters
+    ----------
+    time_of_observation
+        Time at which to compute the relative Dopper velocity. Any string that can be parsed by `astropy.time.Time` is
+        acceptable.
+
+    Returns
+    -------
+    doppler_velocity
+        The relative velocity between observer and the Sun with units of km / s
+    """
+    coord = location_of_dkist.get_gcrs(obstime=Time(time_of_observation))
+    heliocentric_coord = coord.transform_to(HeliocentricInertial(obstime=Time(time_of_observation)))
+    obs_vr_kms = heliocentric_coord.d_distance
+    return obs_vr_kms
+
+
+def compute_input_wavelength_vector(
+    *,
+    central_wavelength: Quantity,
+    dispersion: Quantity,
+    grating_constant: Quantity,
+    order: int,
+    incident_light_angle: Quantity,
+    num_spec_px: int,
+) -> u.Quantity:
+    r"""
+    Compute a wavelength vector based on information about the spectrograph setup.
+
+    The parameterization of the grating equation is via `astropy.wcs.WCS`, which follows section 5 of
+    `Greisen et al (2006) <https://ui.adsabs.harvard.edu/abs/2006A%26A...446..747G/abstract>`_.
+
+    Parameters
+    ----------
+    central_wavelength
+        Wavelength at the center of the spectral window. This function forces the value of the output vector to be
+        ``central_wavelength`` at index ``num_spec // 2 + 1``.
+
+    dispersion
+        Spectrograph dispersion [nm / px]
+
+    grating_constant
+        Grating constant of the spectrograph grating [lines per mm]
+
+    order
+        Spectrograph order
+
+    incident_light_angle
+        Angle of light incident to the spectrograph grating. Often called :math:`\alpha`.
+
+    num_spec_px
+        The length of the output wavelength vector. Defines size and physical limits of the output.
+
+    Returns
+    -------
+    wave_vec
+        1D array of length ``num_spec`` containing the wavelength values described by the input WCS parameterization.
+        The units of this array will be nanometers.
+    """
+    wavelength_parameters = WavelengthParameters(
+        crpix=num_spec_px // 2 + 1,
+        crval=central_wavelength.to_value(u.nm),
+        dispersion=dispersion.to_value(u.nm / u.pix),
+        grating_constant=grating_constant.to_value(1 / u.mm),
+        order=order,
+        incident_light_angle=incident_light_angle.to_value(u.deg),
+        cunit="nm",
+    )
+    header = wavelength_parameters.to_header(axis_num=1)
+    wcs = WCS(header)
+    input_wavelength_vector = wcs.spectral.pixel_to_world(np.arange(num_spec_px)).to(u.nm)
+
+    return input_wavelength_vector