dkist-processing-common 10.9.0__py3-none-any.whl → 11.0.0__py3-none-any.whl

dkist_processing_common/models/dkist_location.py

@@ -0,0 +1,27 @@
+"""Return hard-coded EarthLocation of the DKIST.
+
+Cartesian geocentric coordinates of DKIST on Earth as retrieved from
+https://github.com/astropy/astropy-data/blob/gh-pages/coordinates/sites.json#L838
+"""
+import astropy.units as u
+from astropy.coordinates import EarthLocation
+
+
+_dkist_site_info = {
+    "aliases": ["DKIST", "ATST"],
+    "name": "Daniel K. Inouye Solar Telescope",
+    "elevation": 3067,
+    "elevation_unit": "meter",
+    "latitude": 20.7067,
+    "latitude_unit": "degree",
+    "longitude": 203.7436,
+    "longitude_unit": "degree",
+    "timezone": "US/Hawaii",
+    "source": "DKIST website: https://www.nso.edu/telescopes/dki-solar-telescope/",
+}
+
+location_of_dkist: EarthLocation = EarthLocation.from_geodetic(
+    _dkist_site_info["longitude"] * u.Unit(_dkist_site_info["longitude_unit"]),
+    _dkist_site_info["latitude"] * u.Unit(_dkist_site_info["latitude_unit"]),
+    _dkist_site_info["elevation"] * u.Unit(_dkist_site_info["elevation_unit"]),
+)

dkist_processing_common/models/metric_code.py

@@ -23,3 +23,4 @@ class MetricCode(StrEnum):
     range = "RANGE"
     sensitivity = "SENSITIVITY"
     task_types = "TASK_TYPES"
+    wavecal_fit = "WAVECAL_FIT"

dkist_processing_common/models/quality.py

@@ -2,6 +2,9 @@
 from typing import Any
 
 from pydantic import BaseModel
+from pydantic import Field
+from pydantic import field_validator
+from pydantic_core.core_schema import ValidationInfo
 
 
 class Plot2D(BaseModel):
@@ -13,6 +16,50 @@ class Plot2D(BaseModel):
     series_name: str | None = None
     ylabel_horizontal: bool = False
     ylim: tuple[float, float] | None = None
+    plot_kwargs: dict[str, dict[str, Any]] = Field(default_factory=dict)
+    sort_series: bool = True
+
+
+class VerticalMultiPanePlot2D(BaseModel):
+    """
+    Support class to hold a multi-pane plot with plots stacked vertically.
+
+    This type of metric is really geared towards plots that share an X axis and have no gap between them. If you just
+    want two separate plots it's probably better to use a list of `Plot2D` objects.
+    """
+
+    top_to_bottom_plot_list: list[Plot2D]
+    match_x_axes: bool = True
+    no_gap: bool = True
+    top_to_bottom_height_ratios: list[float] | None = None
+
+    @field_validator("top_to_bottom_height_ratios")
+    @classmethod
+    def ensure_same_number_of_height_ratios_and_plots(
+        cls, height_ratios: list[float] | None, info: ValidationInfo
+    ) -> list[float]:
+        """
+        Make sure that the number of height ratios is the same as the number of plots.
+
+        Also populates default, same-size ratios if no ratios were given.
+        """
+        try:
+            plot_list = info.data["top_to_bottom_plot_list"]
+        except KeyError:
+            # The plot list didn't validate for some reason. We're about to error anyway.
+            return [1.0]
+
+        num_plots = len(plot_list)
+        if height_ratios is None:
+            return [1.0] * num_plots
+
+        if len(height_ratios) != num_plots:
+            raise ValueError(
+                f"The number of items in `top_to_bottom_height_ratios` list ({len(height_ratios)}) is not "
+                f"the same as the number of plots ({num_plots})"
+            )
+
+        return height_ratios
 
 
 class SimpleTable(BaseModel):
@@ -57,11 +104,7 @@ class PlotRaincloud(BaseModel):
 
 
 class ReportMetric(BaseModel):
-    """
-    A Quality Report is made up of a list of metrics with the schema defined by this class.
-
-    Additionally, this class can produce a Flowable or List of Flowables to be render the metric in the PDF Report
-    """
+    """A Quality Report is made up of a list of metrics with the schema defined by this class."""
 
     name: str
     description: str
@@ -69,6 +112,7 @@ class ReportMetric(BaseModel):
     facet: str | None = None
     statement: str | list[str] | None = None
     plot_data: Plot2D | list[Plot2D] | None = None
+    vertical_multi_pane_plot_data: VerticalMultiPanePlot2D | None = None
     histogram_data: PlotHistogram | list[PlotHistogram] | None = None
     table_data: SimpleTable | list[SimpleTable] | None = None
     modmat_data: ModulationMatrixHistograms | None = None

dkist_processing_common/parsers/dsps_repeat.py

@@ -17,7 +17,7 @@ class TotalDspsRepeatsBud(TaskUniqueBud):
         super().__init__(
             constant_name=BudName.num_dsps_repeats.value,
             metadata_key="num_dsps_repeats",
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )
 
 

dkist_processing_common/parsers/id_bud.py

@@ -15,7 +15,7 @@ class IdBud(TaskUniqueBud):
         super().__init__(
             constant_name=constant_name,
             metadata_key=metadata_key,
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )
 
 

dkist_processing_common/parsers/near_bud.py

@@ -74,7 +74,7 @@ class NearFloatBud(Stem):
 
 class TaskNearFloatBud(NearFloatBud):
     """
-    Subclass of `NearFloatBud` that only considers objects that have a specific task type.
+    Subclass of `NearFloatBud` that only considers objects that have specific task types.
 
     Parameters
     ----------
@@ -84,8 +84,8 @@ class TaskNearFloatBud(NearFloatBud):
     metadata_key
         The metadata key associated with the constant
 
-    ip_task_type
-        Only consider objects whose parsed header IP task type matches this string
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
 
     task_type_parsing_function
         The function used to convert a header into an IP task type
@@ -98,7 +98,7 @@ class TaskNearFloatBud(NearFloatBud):
         self,
         constant_name: str,
         metadata_key: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         tolerance: float,
         task_type_parsing_function: Callable = passthrough_header_ip_task,
     ):
@@ -106,14 +106,16 @@ class TaskNearFloatBud(NearFloatBud):
             constant_name=constant_name, metadata_key=metadata_key, tolerance=tolerance
         )
 
-        self.ip_task_type = ip_task_type.casefold()
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.parsing_function = task_type_parsing_function
 
     def setter(self, fits_obj: L0FitsAccess):
         """Ingest an object only if its parsed IP task type matches what's desired."""
         task = self.parsing_function(fits_obj)
 
-        if task.casefold() == self.ip_task_type:
+        if task.casefold() in self.ip_task_types:
             return super().setter(fits_obj)
 
         return SpilledDirt

dkist_processing_common/parsers/retarder.py

@@ -20,7 +20,7 @@ class RetarderNameBud(TaskUniqueBud):
         super().__init__(
             constant_name=BudName.retarder_name.value,
             metadata_key="gos_retarder_status",
-            ip_task_type=TaskName.polcal.value,
+            ip_task_types=TaskName.polcal.value,
         )
 
     def getter(self, key) -> str:

dkist_processing_common/parsers/time.py

@@ -29,7 +29,7 @@ class ObsIpStartTimeBud(TaskUniqueBud):
         super().__init__(
             constant_name=BudName.obs_ip_start_time.value,
             metadata_key="ip_start_time",
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )
 
 
@@ -187,31 +187,48 @@ class ReadoutExpTimeFlower(TimeFlowerBase):
 
 class TaskTimeBudBase(Stem):
     """
-    Base class for making time-related buds that are computed for a specific task type.
+    Base class for making time-related buds that are computed for specific task types.
 
     By "time-related" we mean values that generally need rounding when ingested into the database.
 
     Complicated parsing of the header into a task type can be achieved by passing in a different
     header task parsing function.
+
+    Parameters
+    ----------
+    constant_name
+        The name for the constant to be defined
+
+    metadata_key
+        The metadata key associated with the constant
+
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
+
+    header_task_parsing_func
+        The function used to convert a header into an IP task type
     """
 
     def __init__(
         self,
         stem_name: str,
         metadata_key: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(stem_name=stem_name)
+
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
         self.metadata_key = metadata_key
-        self.ip_task_type = ip_task_type
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.header_parsing_function = header_task_parsing_func
 
     def setter(self, fits_obj: L0FitsAccess):
         """Return the desired metadata key only if the parsed task type matches the Bud's task type."""
         task = self.header_parsing_function(fits_obj)
 
-        if task.casefold() == self.ip_task_type.casefold():
+        if task.casefold() in self.ip_task_types:
             raw_value = getattr(fits_obj, self.metadata_key)
             return round(raw_value, EXP_TIME_ROUND_DIGITS)
 
@@ -229,13 +246,13 @@ class TaskExposureTimesBud(TaskTimeBudBase):
     def __init__(
         self,
         stem_name: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(
             stem_name=stem_name,
             metadata_key="fpa_exposure_time_ms",
-            ip_task_type=ip_task_type,
+            ip_task_types=ip_task_types,
             header_task_parsing_func=header_task_parsing_func,
         )
 
@@ -246,12 +263,12 @@ class TaskReadoutExpTimesBud(TaskTimeBudBase):
     def __init__(
         self,
         stem_name: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         header_task_parsing_func: Callable = passthrough_header_ip_task,
     ):
         super().__init__(
             stem_name=stem_name,
             metadata_key="sensor_readout_exposure_time_ms",
-            ip_task_type=ip_task_type,
+            ip_task_types=ip_task_types,
             header_task_parsing_func=header_task_parsing_func,
         )

dkist_processing_common/parsers/unique_bud.py

@@ -64,7 +64,7 @@ class UniqueBud(Stem):
 
 class TaskUniqueBud(UniqueBud):
     """
-    Subclass of `UniqueBud` that only considers objects that have a specific task type.
+    Subclass of `UniqueBud` that only considers objects that have specific task types.
 
     Parameters
     ----------
@@ -74,8 +74,8 @@ class TaskUniqueBud(UniqueBud):
     metadata_key
         The metadata key associated with the constant
 
-    ip_task_type
-        Only consider objects whose parsed header IP task type matches this string
+    ip_task_types
+        Only consider objects whose parsed header IP task type matches a string in this list
 
     task_type_parsing_function
         The function used to convert a header into an IP task type
@@ -85,19 +85,21 @@ class TaskUniqueBud(UniqueBud):
         self,
         constant_name: str,
         metadata_key: str,
-        ip_task_type: str,
+        ip_task_types: str | list[str],
         task_type_parsing_function: Callable = passthrough_header_ip_task,
     ):
         super().__init__(constant_name=constant_name, metadata_key=metadata_key)
 
-        self.ip_task_type = ip_task_type.casefold()
+        if isinstance(ip_task_types, str):
+            ip_task_types = [ip_task_types]
+        self.ip_task_types = [task.casefold() for task in ip_task_types]
         self.parsing_function = task_type_parsing_function
 
     def setter(self, fits_obj: L0FitsAccess):
         """Ingest an object only if its parsed IP task type matches what's desired."""
         task = self.parsing_function(fits_obj)
 
-        if task.casefold() == self.ip_task_type:
+        if task.casefold() in self.ip_task_types:
             return super().setter(fits_obj)
 
         return SpilledDirt

dkist_processing_common/parsers/wavelength.py

@@ -11,5 +11,5 @@ class ObserveWavelengthBud(TaskUniqueBud):
         super().__init__(
             constant_name=BudName.wavelength.value,
             metadata_key="wavelength",
-            ip_task_type=TaskName.observe.value,
+            ip_task_types=TaskName.observe.value,
         )

dkist_processing_common/tasks/mixin/quality/_base.py

@@ -11,10 +11,15 @@ from dkist_processing_common.tasks.mixin.quality._metrics import _PolcalQualityM
 from dkist_processing_common.tasks.mixin.quality._metrics import _SimplePlotQualityMixin
 from dkist_processing_common.tasks.mixin.quality._metrics import _SimpleQualityMixin
 from dkist_processing_common.tasks.mixin.quality._metrics import _TableQualityMixin
+from dkist_processing_common.tasks.mixin.quality._metrics import _WavecalQualityMixin
 
 
 class QualityMixin(
-    _SimpleQualityMixin, _SimplePlotQualityMixin, _TableQualityMixin, _PolcalQualityMixin
+    _SimpleQualityMixin,
+    _SimplePlotQualityMixin,
+    _TableQualityMixin,
+    _PolcalQualityMixin,
+    _WavecalQualityMixin,
 ):
     """Mixin class supporting the generation of the quality reports."""
 
@@ -81,6 +86,7 @@ class QualityMixin(
             "HISTORICAL": self.quality_build_historical,
             "AO_STATUS": self.quality_build_ao_status,
             "RANGE": self.quality_build_range,
+            "WAVECAL_FIT": self.quality_build_wavecal_results,
         }
 
     @property

dkist_processing_common/tasks/mixin/quality/_metrics.py

@@ -12,14 +12,18 @@ from typing import Any
 from typing import Iterable
 from typing import Literal
 
+import astropy.units as u
 import numpy as np
+from astropy.wcs import WCS
 from dkist_processing_pac.fitter.fitter_parameters import CU_PARAMS
 from dkist_processing_pac.fitter.fitter_parameters import GLOBAL_PARAMS
 from dkist_processing_pac.fitter.fitter_parameters import TELESCOPE_PARAMS
 from dkist_processing_pac.fitter.fitting_core import compare_I
 from dkist_processing_pac.fitter.polcal_fitter import PolcalFitter
 from pandas import DataFrame
+from solar_wavelength_calibration.fitter.wavelength_fitter import FitResult
 
+from dkist_processing_common.codecs.json import json_decoder
 from dkist_processing_common.models.fried_parameter import r0_valid
 from dkist_processing_common.models.metric_code import MetricCode
 from dkist_processing_common.models.quality import EfficiencyHistograms
@@ -29,6 +33,7 @@ from dkist_processing_common.models.quality import PlotHistogram
 from dkist_processing_common.models.quality import PlotRaincloud
 from dkist_processing_common.models.quality import ReportMetric
 from dkist_processing_common.models.quality import SimpleTable
+from dkist_processing_common.models.quality import VerticalMultiPanePlot2D
 from dkist_processing_common.models.tags import Tag
 
 logger = logging.getLogger(__name__)
@@ -1324,3 +1329,127 @@ class _PolcalQualityMixin:
         base_str += " bins."
 
         return base_str
+
+
+class _WavecalQualityMixin:
+    """Mixin class supporting the recording and building of wavecal-related metrics."""
+
+    def quality_store_wavecal_results(
+        self,
+        *,
+        input_wavelength: u.Quantity,
+        input_spectrum: np.ndarray,
+        fit_result: FitResult,
+        weights: None | np.ndarray = None,
+    ):
+        """
+        Store the results of a wavelength solution fit.
+
+        Namely, save the:
+
+        * Input spectrum and wavelength
+        * Best-fit combined atlas spectrum
+        * Best-fit wavelength vector
+        * Fit residuals
+
+        Note that the residuals are the *unweighed* residuals.
+        """
+        weight_data = np.ones(input_wavelength.size) if weights is None else weights
+        prepared_weights = np.sqrt(weight_data / np.sum(weight_data))
+        residuals = fit_result.minimizer_result.residual / prepared_weights
+        residuals[~np.isfinite(residuals)] = 0.0
+        best_fit_atlas = input_spectrum - residuals
+        normalized_residuals = residuals / input_spectrum
+
+        best_fit_header = fit_result.wavelength_parameters.to_header(axis_num=1)
+        wcs = WCS(best_fit_header)
+        best_fit_wavelength = wcs.spectral.pixel_to_world(np.arange(input_spectrum.size))
+
+        data = {
+            "input_wavelength_nm": input_wavelength.to_value(u.nm).tolist(),
+            "input_spectrum": input_spectrum.tolist(),
+            "best_fit_wavelength_nm": best_fit_wavelength.to_value(u.nm).tolist(),
+            "best_fit_atlas": best_fit_atlas.tolist(),
+            "normalized_residuals": normalized_residuals.tolist(),
+            "weights": None if weights is None else weight_data.tolist(),
+        }
+
+        self._record_values(values=data, tags=[Tag.quality(MetricCode.wavecal_fit)])
+
+    def quality_build_wavecal_results(self) -> dict:
+        """Build a ReportMetric containing a multi-pane plot showing the fit spectra and residuals."""
+        data = next(self.read(tags=[Tag.quality(MetricCode.wavecal_fit)], decoder=json_decoder))
+
+        input_wave_list = data["input_wavelength_nm"]
+        input_spectrum_list = data["input_spectrum"]
+        best_fit_wave_list = data["best_fit_wavelength_nm"]
+        best_fit_atlas_list = data["best_fit_atlas"]
+        residuals_list = data["normalized_residuals"]
+        weights = data["weights"]
+
+        fit_series = {
+            "Best Fit Observations": [best_fit_wave_list, input_spectrum_list],
+            "Input Spectrum": [input_wave_list, input_spectrum_list],
+            "Best Fit Atlas": [best_fit_wave_list, best_fit_atlas_list],
+        }
+        fit_plot_kwargs = {
+            "Best Fit Observations": {"ls": "-", "lw": 4, "alpha": 0.8, "ms": 0},
+            "Input Spectrum": {"ls": "-", "alpha": 0.4, "ms": 0},
+            "Best Fit Atlas": {"color": "k", "ls": "-", "ms": 0},
+        }
+
+        fit_plot = Plot2D(
+            xlabel="Wavelength [nm]",
+            ylabel="Signal",
+            series_data=fit_series,
+            plot_kwargs=fit_plot_kwargs,
+            sort_series=False,
+        )
+
+        residuals_series = {"Residuals": [best_fit_wave_list, residuals_list]}
+        residuals_plot_kwargs = {"Residuals": {"ls": "-", "color": "k", "ms": 0}}
+
+        y_min = np.nanpercentile(residuals_list, 2)
+        y_max = np.nanpercentile(residuals_list, 98)
+        y_range = y_max - y_min
+        y_min -= 0.1 * y_range
+        y_max += 0.1 * y_range
+        residuals_plot = Plot2D(
+            xlabel="Wavelength [nm]",
+            ylabel=r"$\frac{\mathrm{Obs - Atlas}}{\mathrm{Obs}}$",
+            series_data=residuals_series,
+            plot_kwargs=residuals_plot_kwargs,
+            ylim=(y_min, y_max),
+        )
+
+        plot_list = [fit_plot, residuals_plot]
+        height_ratios = [1.5, 1.0]
+        if weights is not None:
+            weight_series = {"Weights": [best_fit_wave_list, weights]}
+            weight_plot_kwargs = {"Weights": {"ls": "-", "color": "k", "ms": 0}}
+            weight_plot = Plot2D(
+                xlabel="Wavelength [nm]",
+                ylabel="Fit Weights",
+                series_data=weight_series,
+                plot_kwargs=weight_plot_kwargs,
+            )
+            plot_list.append(weight_plot)
+            height_ratios.append(1.0)
+
+        full_plot = VerticalMultiPanePlot2D(
+            top_to_bottom_plot_list=plot_list,
+            match_x_axes=True,
+            no_gap=True,
+            top_to_bottom_height_ratios=height_ratios,
+        )
+
+        metric = ReportMetric(
+            name="Wavelength Calibration Results",
+            description="These plots show the wavelength solution computed based on fits to a Solar FTS atlas. "
+            "The top plot shows the input and best-fit spectra along with the best-fit atlas, which is "
+            "a combination of Solar and Telluric spectra. The bottom plot shows the fit residuals.",
+            metric_code=MetricCode.wavecal_fit,
+            vertical_multi_pane_plot_data=full_plot,
+        )
+
+        return metric.model_dump()

dkist_processing_common/tasks/parse_l0_input_data.py

@@ -20,7 +20,6 @@ that makes the rest of the pipeline easy to write.
 In other words, we can find exactly the frame we need (tags) and, once we have it, we never need to look
 at a different frame to get information (constants).
 """
-import json
 import logging
 from abc import ABC
 from abc import abstractmethod
@@ -70,8 +69,10 @@ def default_constant_bud_factory() -> list[S]:
         MaximumCadenceBud(),
         MinimumCadenceBud(),
         VarianceCadenceBud(),
-        TaskExposureTimesBud(stem_name=BudName.dark_exposure_times.value, ip_task_type="dark"),
-        TaskReadoutExpTimesBud(stem_name=BudName.dark_readout_exp_times.value, ip_task_type="dark"),
+        TaskExposureTimesBud(stem_name=BudName.dark_exposure_times.value, ip_task_types="dark"),
+        TaskReadoutExpTimesBud(
+            stem_name=BudName.dark_readout_exp_times.value, ip_task_types="dark"
+        ),
     ]
 
 

dkist_processing_common/tasks/write_l1.py

@@ -11,7 +11,6 @@ from typing import Literal
 
 import astropy.units as u
 import numpy as np
-from astropy.coordinates import EarthLocation
 from astropy.io import fits
 from astropy.time import Time
 from dkist_fits_specifications import __version__ as spec_version
@@ -29,6 +28,7 @@ from sunpy.coordinates import Helioprojective
 
 from dkist_processing_common.codecs.fits import fits_access_decoder
 from dkist_processing_common.codecs.fits import fits_hdulist_encoder
+from dkist_processing_common.models.dkist_location import location_of_dkist
 from dkist_processing_common.models.fried_parameter import r0_valid
 from dkist_processing_common.models.tags import Tag
 from dkist_processing_common.models.wavelength import WavelengthRange
@@ -251,45 +251,17 @@ class WriteL1Frame(WorkflowTaskBase, MetadataStoreMixin, ABC):
         For spectrographs, this is the wavelengths covered by the spectral axis of the data.
         """
 
-    @property
-    def location_of_dkist(self) -> EarthLocation:
-        """Return hard-coded EarthLocation of the DKIST.
-
-        Cartesian geocentric coordinates of DKIST on Earth as retrieved from
-        https://github.com/astropy/astropy-data/blob/gh-pages/coordinates/sites.json#L838
-        """
-        _dkist_site_info = {
-            "aliases": ["DKIST", "ATST"],
-            "name": "Daniel K. Inouye Solar Telescope",
-            "elevation": 3067,
-            "elevation_unit": "meter",
-            "latitude": 20.7067,
-            "latitude_unit": "degree",
-            "longitude": 203.7436,
-            "longitude_unit": "degree",
-            "timezone": "US/Hawaii",
-            "source": "DKIST website: https://www.nso.edu/telescopes/dki-solar-telescope/",
-        }
-        location_of_dkist = EarthLocation.from_geodetic(
-            _dkist_site_info["longitude"] * u.Unit(_dkist_site_info["longitude_unit"]),
-            _dkist_site_info["latitude"] * u.Unit(_dkist_site_info["latitude_unit"]),
-            _dkist_site_info["elevation"] * u.Unit(_dkist_site_info["elevation_unit"]),
-        )
-
-        return location_of_dkist
-
     def add_solarnet_headers(self, header: fits.Header) -> fits.Header:
         """Add headers recommended by solarnet that haven't already been added."""
         header["DATE-AVG"] = self.calculate_date_avg(header=header)
         header["TELAPSE"] = self.calculate_telapse(header=header)
         header["DATEREF"] = header["DATE-BEG"]
-        dkist_loc = self.location_of_dkist
-        header["OBSGEO-X"] = dkist_loc.x.to_value(unit=u.m)
-        header["OBSGEO-Y"] = dkist_loc.y.to_value(unit=u.m)
-        header["OBSGEO-Z"] = dkist_loc.z.to_value(unit=u.m)
+        header["OBSGEO-X"] = location_of_dkist.x.to_value(unit=u.m)
+        header["OBSGEO-Y"] = location_of_dkist.y.to_value(unit=u.m)
+        header["OBSGEO-Z"] = location_of_dkist.z.to_value(unit=u.m)
         obstime = Time(header["DATE-AVG"])
         header["OBS_VR"] = (
-            dkist_loc.get_gcrs(obstime=obstime)
+            location_of_dkist.get_gcrs(obstime=obstime)
             .transform_to(HeliocentricInertial(obstime=obstime))
             .d_distance.to_value(unit=u.m / u.s)
         )  # relative velocity of observer with respect to the sun in m/s
@@ -514,7 +486,7 @@ class WriteL1Frame(WorkflowTaskBase, MetadataStoreMixin, ABC):
         as seen by an observer located at the DKIST site at the given time of observation.
         """
         dummy_theta_coord = 0 * u.arcsec
-        dkist_at_obstime = self.location_of_dkist.get_itrs(obstime=obstime)
+        dkist_at_obstime = location_of_dkist.get_itrs(obstime=obstime)
         sun_coordinate = Helioprojective(
             Tx=dummy_theta_coord, Ty=dummy_theta_coord, observer=dkist_at_obstime
         )
@@ -535,7 +507,6 @@ class WriteL1Frame(WorkflowTaskBase, MetadataStoreMixin, ABC):
         If the spectral line rest wavelength in air does not fall in the wavelength range of the data,
         do not populate the keyword.
         """
-        print(wavelength_range)
         closest_line = get_closest_spectral_line(wavelength=wavelength)
         rest_wavelength = closest_line.rest_wavelength_in_air
         if rest_wavelength < wavelength_range.min or rest_wavelength > wavelength_range.max: