imap-processing 1.0.37__tar.gz → 1.0.38__tar.gz

{imap_processing-1.0.37 → imap_processing-1.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imap-processing
-Version: 1.0.37
+Version: 1.0.38
 Summary: IMAP Science Operations Center Processing
 License-Expression: MIT
 License-File: LICENSE
@@ -31,7 +31,7 @@ Provides-Extra: tools
 Requires-Dist: astropy-healpix (>=1.0)
 Requires-Dist: cdflib (>=1.3.11)
 Requires-Dist: healpy (>=1.18.0,<2) ; extra == "map-visualization"
-Requires-Dist: imap-data-access (>=0.42.0)
+Requires-Dist: imap-data-access (>=1.3.0)
 Requires-Dist: mypy (==1.10.1) ; extra == "dev"
 Requires-Dist: netcdf4 (>=1.7.2,<2) ; extra == "test"
 Requires-Dist: numpy (>=2,<3)

{imap_processing-1.0.37 → imap_processing-1.0.38}/imap_processing/cdf/config/imap_mag_l2_variable_attrs.yaml

@@ -52,6 +52,8 @@ vector_attrs: &vectors_default
     FILLVAL: -1.0e31
     FORMAT: F13.5
     LABL_PTR_1: direction_label
+    SCALEMAX: 100.0
+    SCALEMIN: -100.0
     UNITS: nT
     VALIDMAX: 1.0e+5
     VALIDMIN: -1.0e+5

{imap_processing-1.0.37 → imap_processing-1.0.38}/imap_processing/cli.py

@@ -66,6 +66,7 @@ from imap_processing.idex.idex_l1a import idex_l1a
 from imap_processing.idex.idex_l1b import idex_l1b
 from imap_processing.idex.idex_l2a import idex_l2a
 from imap_processing.idex.idex_l2b import idex_l2b
+from imap_processing.lo import lo_pivot_kernel
 from imap_processing.lo.constants import LoConstants
 from imap_processing.lo.l1a import lo_l1a
 from imap_processing.lo.l1b import lo_l1b
@@ -473,6 +474,33 @@ class ProcessInstrument(ABC):
             logger.warning(msg)
         return self.version_map.get(descriptor, self._fallback_version)
 
+    def _resolve_kernel_minor_version(self, descriptor: str) -> int:
+        """
+        Return the minor version to use in the filename of a generated kernel.
+
+        Parameters
+        ----------
+        descriptor : str
+            The descriptor of the kernel job, e.g. "pointing-attitude".
+
+        Returns
+        -------
+        int
+            The minor version for the kernel filename.
+        """
+        resolved_version = self._resolve_version(descriptor)
+        if resolved_version is None:
+            raise ValueError(
+                f"No version provided for {descriptor} processing. "
+                f"Provide a version for the '{descriptor}' descriptor in "
+                "the dependency JSON's version block, or a fallback --version."
+            )
+        return (
+            resolved_version.minor
+            if isinstance(resolved_version, Version)
+            else int(resolved_version.lstrip("v"))
+        )
+
     def upload_products(self, products: list[Path]) -> None:
         """
         Upload data products to the IMAP SDC.
@@ -1430,9 +1458,48 @@ class Lo(ProcessInstrument):
 
         return filtered_dependencies
 
+    def _generate_pivot_kernel(
+        self, dependencies: ProcessingInputCollection
+    ) -> list[Path]:
+        """
+        Generate the Lo pivot platform CK for the pointing given by repointing.
+
+        Parameters
+        ----------
+        dependencies : ProcessingInputCollection
+            Object containing dependencies to process.
+
+        Returns
+        -------
+        list[Path]
+            The generated Lo pivot kernel.
+        """
+        if self.repointing is None:
+            raise ValueError(
+                "repointing must be provided for pivot-ckernel processing."
+            )
+        nhk_files = dependencies.get_file_paths(
+            source="lo", data_type="l1b", descriptor="nhk"
+        )
+        if len(nhk_files) != 1:
+            raise ValueError(
+                f"Unexpected dependencies found for IMAP-Lo pivot-ckernel: "
+                f"{nhk_files}. Expected exactly one L1B NHK file."
+            )
+        # The repoint table provides the pointing start and end times.
+        if not dependencies.get_file_paths(data_type=RepointInput.data_type):
+            raise ValueError(
+                "A repoint table dependency is required for IMAP-Lo pivot-ckernel "
+                "processing."
+            )
+        minor_version = self._resolve_kernel_minor_version(self.descriptor)
+        return lo_pivot_kernel.generate_lo_pivot_kernel(
+            nhk_files[0], self.repointing, minor_version
+        )
+
     def do_processing(
         self, dependencies: ProcessingInputCollection
-    ) -> list[xr.Dataset]:
+    ) -> list[xr.Dataset | Path]:
         """
         Perform IMAP-Lo specific processing.
 
@@ -1443,12 +1510,15 @@ class Lo(ProcessInstrument):
 
         Returns
         -------
-        dataset : xr.Dataset
-            Xr.Dataset of output files.
+        datasets : list[xarray.Dataset | Path]
+            The list of processed products.
         """
         print(f"Processing IMAP-Lo {self.data_level}")
-        datasets: list[xr.Dataset] = []
-        if self.data_level == "l1a":
+        datasets: list[xr.Dataset | Path] = []
+        if self.data_level == "l1b" and self.descriptor == "pivot-ckernel":
+            datasets.extend(self._generate_pivot_kernel(dependencies))
+
+        elif self.data_level == "l1a":
             # L1A packet / products are 1 to 1. Should only have
             # one dependency file
             science_files = dependencies.get_file_paths(source="lo", data_type="l0")
@@ -1859,18 +1929,7 @@ class Spacecraft(ProcessInstrument):
                 data_type=SPICESource.SPICE.value
             )
             ah_paths = [path for path in spice_inputs if ".ah" in path.suffixes]
-            resolved_version = self._resolve_version(self.descriptor)
-            if resolved_version is None:
-                raise ValueError(
-                    "No version provided for pointing-attitude processing. "
-                    "Provide a version for the 'pointing-attitude' descriptor in "
-                    "the dependency JSON's version block, or a fallback --version."
-                )
-            minor_version = (
-                resolved_version.minor
-                if isinstance(resolved_version, Version)
-                else int(resolved_version.lstrip("v"))
-            )
+            minor_version = self._resolve_kernel_minor_version(self.descriptor)
             pointing_kernel_paths = pointing_frame.generate_pointing_attitude_kernel(
                 ah_paths, self.start_date, minor_version
             )

{imap_processing-1.0.37 → imap_processing-1.0.38}/imap_processing/ialirt/l0/process_swe.py

@@ -110,10 +110,12 @@ def prepare_raw_counts(grouped: xr.Dataset, cem_number: int = N_CEMS) -> NDArray
     # Example: energy steps 0-1 have the same phi;
     # energy steps 2-3 have the same phi, etc.
     # A depiction of this is shown in Figure 7 of the SWE Algorithm Document.
+    # Cast to int64 so the phi calculation does not overflow uint8.
+    swe_seq = grouped["swe_seq"].values.astype(np.int64)
     phi_values = np.array(
         [
-            (12 + 24 * grouped["swe_seq"].values) % 360,  # Energy steps 0 and 1
-            (24 + 24 * grouped["swe_seq"].values) % 360,  # Energy steps 2 and 3
+            (12 + 24 * swe_seq) % 360,  # Energy steps 0 and 1
+            (24 + 24 * swe_seq) % 360,  # Energy steps 2 and 3
         ]
     )
     phi_bins = phi_to_bin(phi_values).astype(int)  # Get phi bin indices

{imap_processing-1.0.37 → imap_processing-1.0.38}/imap_processing/lo/l1b/lo_l1b.py

@@ -1862,6 +1862,44 @@ def get_pivot_angle_from_nhk(ds_nhk: xr.Dataset) -> float:
     return ds_nhk["pcc_cumulative_cnt_pri"].isel(epoch=nitems // 2).item()
 
 
+def get_median_pivot_angle(ds_nhk: xr.Dataset) -> float:
+    """
+    Get the median pivot angle from the NHK dataset.
+
+    The median of ``pcc_coarse_pot_pri`` is taken over the samples between
+    ``PIVOT_HK_HOUR_RANGE`` hours after the first NHK sample, which avoids the
+    pivot platform motion at the start of a pointing.
+
+    Parameters
+    ----------
+    ds_nhk : xr.Dataset
+        The NHK dataset containing pivot angle information.
+
+    Returns
+    -------
+    pivot_angle : float
+        The median pivot angle [degrees], or NaN if the dataset has no records
+        or there are no valid samples within the time range.
+    """
+    if ds_nhk.sizes.get("epoch", 0) == 0:
+        return np.nan
+
+    hk_epoch_ets = ttj2000ns_to_et(ds_nhk["epoch"])
+    start_et_hk = (
+        hk_epoch_ets[0] + timedelta(hours=c.PIVOT_HK_HOUR_RANGE[0]).total_seconds()
+    )
+    end_et_hk = (
+        hk_epoch_ets[0] + timedelta(hours=c.PIVOT_HK_HOUR_RANGE[1]).total_seconds()
+    )
+
+    coarse_pot_pri = ds_nhk["pcc_coarse_pot_pri"].values
+    return float(
+        np.nanmedian(
+            coarse_pot_pri[(hk_epoch_ets >= start_et_hk) & (hk_epoch_ets <= end_et_hk)]
+        )
+    )
+
+
 def _get_esa_level_indices(epochs: np.ndarray, anc_dependencies: list) -> np.ndarray:
     """
     Get the ESA level indices (reswept indices) for the given epochs.
@@ -2485,18 +2523,7 @@ def l1b_bgrates_and_goodtimes(  # noqa: PLR0912
     pivot: float = 90.0
     cdf_hk = sci_dependencies.get("imap_lo_l1b_nhk")
     if cdf_hk is not None and "pcc_coarse_pot_pri" in cdf_hk:
-        hk_epoch_ets = ttj2000ns_to_et(cdf_hk["epoch"])
-        start_et_hk = (
-            hk_epoch_ets[0] + timedelta(hours=c.PIVOT_HK_HOUR_RANGE[0]).total_seconds()
-        )
-        end_et_hk = (
-            hk_epoch_ets[0] + timedelta(hours=c.PIVOT_HK_HOUR_RANGE[1]).total_seconds()
-        )
-
-        coarse_pot_pri = cdf_hk["pcc_coarse_pot_pri"].values
-        pivot = np.nanmedian(  # type: ignore
-            coarse_pot_pri[(hk_epoch_ets >= start_et_hk) & (hk_epoch_ets <= end_et_hk)]
-        )
+        pivot = get_median_pivot_angle(cdf_hk)
         if np.isnan(pivot):
             pivot = 90.0
 

imap_processing-1.0.38/imap_processing/lo/lo_pivot_kernel.py

@@ -0,0 +1,227 @@
+"""Generate the IMAP-Lo pivot platform attitude kernel (CK)."""
+
+import logging
+import os
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+import imap_data_access
+import numpy as np
+import spiceypy
+
+from imap_processing.cdf.utils import load_cdf
+from imap_processing.lo.l1b.lo_l1b import get_median_pivot_angle
+from imap_processing.spice.geometry import SpiceFrame
+from imap_processing.spice.pointing_frame import (
+    POINTING_SEGMENT_DTYPE,
+    segment_ck_filename,
+    write_constant_attitude_ck,
+)
+from imap_processing.spice.repoint import get_pointing_times_from_id
+from imap_processing.spice.time import (
+    et_to_utc,
+    met_to_sclkticks,
+    met_to_utc,
+    sct_to_et,
+)
+
+logger = logging.getLogger(__name__)
+
+LO_PIVOT_KERNEL_PREFIX = "imap_lopivot"
+LO_PIVOT_KERNEL_EXTENSION = "bc"
+
+
+def generate_lo_pivot_kernel(
+    l1b_nhk_path: Path, repointing: str, minor_version: int
+) -> list[Path]:
+    """
+    Generate the IMAP-Lo pivot platform CK for a single pointing.
+
+    The kernel contains one constant-attitude segment covering the pointing,
+    from the end of its repoint maneuver to the start of the next repoint
+    maneuver. There is no coverage during repoint maneuvers, which is when
+    the pivot platform is moved.
+
+    Parameters
+    ----------
+    l1b_nhk_path : Path
+        Lo L1B NHK file for the pointing.
+    repointing : str
+        The pointing to generate the kernel for, in the format 'repoint#####'.
+    minor_version : int
+        Minor version, from the batch command, to use for the output
+        kernel filename.
+
+    Returns
+    -------
+    kernel_paths : list[Path]
+        Location of the new Lo pivot kernel.
+
+    Raises
+    ------
+    ValueError
+        If `l1b_nhk_path` is not an NHK file for `repointing`.
+    FileExistsError
+        If the output kernel already exists.
+
+    Notes
+    -----
+    Kernels required to be furnished:
+
+    - Latest NAIF leapseconds kernel (naif0012.tls)
+    - The latest IMAP sclk (imap_sclk_NNNN.tsc)
+    - The latest IMAP frame kernel (imap_###.tf), which defines IMAP_LO_BASE
+
+    The repoint table must also be set (`imap_processing.spice.repoint`), as it
+    gives the pointing start and end times.
+    """
+    repoint_id = imap_data_access.ScienceFilePath(l1b_nhk_path.name).repointing
+    if repoint_id is None or f"repoint{repoint_id:05d}" != repointing:
+        raise ValueError(f"{l1b_nhk_path.name} is not an NHK file for {repointing}.")
+
+    segment, pivot_angle = calculate_pivot_segment(l1b_nhk_path, repoint_id)
+
+    kernel_filename = segment_ck_filename(
+        f"{LO_PIVOT_KERNEL_PREFIX}-{repointing}",
+        segment,
+        minor_version,
+        LO_PIVOT_KERNEL_EXTENSION,
+    )
+    kernel_path = imap_data_access.SPICEFilePath(kernel_filename).construct_path()
+    # open_spice_ck_file would append a duplicate segment to an existing file.
+    if kernel_path.exists():
+        raise FileExistsError(f"Lo pivot kernel already exists: {kernel_path}")
+    kernel_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write the kernel in a temporary directory and only publish it once it is
+    # complete, so a failed write never leaves a partial kernel at the output
+    # path. os.link does not replace an existing file, preserving the
+    # no-overwrite behavior even if the kernel appeared during the write.
+    with tempfile.TemporaryDirectory(dir=kernel_path.parent) as tmp_dir:
+        tmp_kernel_path = Path(tmp_dir) / kernel_path.name
+        write_lo_pivot_ck(tmp_kernel_path, segment, pivot_angle, l1b_nhk_path.name)
+        os.link(tmp_kernel_path, kernel_path)
+    return [kernel_path]
+
+
+def calculate_pivot_segment(
+    l1b_nhk_path: Path, repoint_id: int
+) -> tuple[np.ndarray, float]:
+    """
+    Calculate the data for the single segment of a Lo pivot kernel.
+
+    Parameters
+    ----------
+    l1b_nhk_path : Path
+        Lo L1B NHK file for the pointing.
+    repoint_id : int
+        Repoint ID of the pointing.
+
+    Returns
+    -------
+    segment : numpy.ndarray
+        Structured array of POINTING_SEGMENT_DTYPE with one element. The
+        quaternion rotates vectors from the IMAP_LO_BASE frame into the
+        IMAP_LO frame.
+    pivot_angle : float
+        Pivot angle [degrees] of the pointing.
+
+    Raises
+    ------
+    ValueError
+        If the NHK file has no valid pivot angle samples.
+    """
+    pointing_start_met, pointing_end_met = get_pointing_times_from_id(repoint_id)
+    # Use the same pivot angle as the goodtimes product.
+    pivot_angle = get_median_pivot_angle(load_cdf(l1b_nhk_path))
+    if np.isnan(pivot_angle):
+        raise ValueError(f"No valid pivot angle samples in {l1b_nhk_path.name}.")
+    logger.info(
+        f"repoint{repoint_id:05d} ({met_to_utc(pointing_start_met)}, "
+        f"{met_to_utc(pointing_end_met)}): pivot angle {pivot_angle:.4f} deg"
+    )
+
+    segment = np.zeros(1, dtype=POINTING_SEGMENT_DTYPE)
+    segment[0]["pointing_id"] = repoint_id
+    segment[0]["start_sclk_ticks"] = met_to_sclkticks(pointing_start_met)
+    segment[0]["end_sclk_ticks"] = met_to_sclkticks(pointing_end_met)
+    segment[0]["quaternion"] = pivot_angle_to_quaternion(pivot_angle)
+    return segment, pivot_angle
+
+
+def pivot_angle_to_quaternion(pivot_angle: float) -> np.ndarray:
+    """
+    Get the SPICE quaternion rotating IMAP_LO_BASE vectors into IMAP_LO.
+
+    The IMAP_LO frame is the IMAP_LO_BASE frame rotated about its +X axis by
+    the pivot angle. The rotation is consistent with
+    `imap_processing.spice.geometry.get_lo_pivot_boresight`: the IMAP_LO
+    boresight, -Y, expressed in IMAP_LO_BASE is the pivot boresight.
+
+    Parameters
+    ----------
+    pivot_angle : float
+        The pivot angle [degrees].
+
+    Returns
+    -------
+    quaternion : numpy.ndarray
+        SPICE-style quaternion, shape (4,).
+    """
+    # spiceypy.rotate returns the matrix that rotates the coordinate frame by
+    # the angle about the axis, i.e. it maps IMAP_LO_BASE vectors into IMAP_LO.
+    rotation_matrix = spiceypy.rotate(np.deg2rad(pivot_angle), 1)
+    return np.asarray(spiceypy.m2q(rotation_matrix))
+
+
+def write_lo_pivot_ck(
+    kernel_path: Path,
+    segment_data: np.ndarray,
+    pivot_angle: float,
+    parent_file: str,
+) -> None:
+    """
+    Write the Lo pivot CK, recording the pivot angle in the comments.
+
+    Parameters
+    ----------
+    kernel_path : pathlib.Path
+        Location to write the CK kernel.
+    segment_data : numpy.ndarray
+        Structured array of POINTING_SEGMENT_DTYPE with one element.
+    pivot_angle : float
+        Pivot angle [degrees] of the pointing.
+    parent_file : str
+        Filename of the NHK file the pivot angle was derived from.
+    """
+    segment = segment_data[0]
+    start_utc = et_to_utc(sct_to_et(segment["start_sclk_ticks"]))
+    end_utc = et_to_utc(sct_to_et(segment["end_sclk_ticks"]))
+    comments = [
+        "CK FOR IMAP_LO FRAME (IMAP-LO PIVOT PLATFORM)",
+        "==================================================================",
+        "",
+        f"Original file name: {kernel_path.name}",
+        f"Creation date: {datetime.now(timezone.utc).strftime('%Y-%m-%d')}",
+        f"Parent files: {[parent_file]}",
+        "",
+        "The IMAP_LO frame is the IMAP_LO_BASE frame rotated about +X by the",
+        "pivot angle, constant over the pointing.",
+        "",
+        f"Repoint ID: repoint{segment['pointing_id']:05d}",
+        f"Pointing start (UTC): {start_utc}",
+        f"Pointing end (UTC): {end_utc}",
+        f"Pivot angle (deg): {pivot_angle:.4f}",
+        "",
+    ]
+
+    logger.debug(f"Writing Lo pivot kernel: {kernel_path}")
+    write_constant_attitude_ck(
+        kernel_path,
+        segment_data,
+        SpiceFrame.IMAP_LO,
+        SpiceFrame.IMAP_LO_BASE,
+        comments,
+    )
+    logger.debug(f"Finished writing Lo pivot kernel: {kernel_path}")

{imap_processing-1.0.37 → imap_processing-1.0.38}/imap_processing/mag/l2/mag_l2_data.py

@@ -243,7 +243,7 @@ class MagL2L1dBase:
         )
 
         quality_flags = xr.DataArray(
-            self.quality_flags,
+            self.quality_flags.astype(np.uint8),
             name="quality_flags",
             dims=["epoch"],
             attrs=attribute_manager.get_variable_attributes("qf"),

{imap_processing-1.0.37 → imap_processing-1.0.38}/imap_processing/quality_flags.py

@@ -47,6 +47,7 @@ class ImapDEOutliersUltraFlags(FlagNameMixin):
     INVALID_ENERGY = 2**3  # bit 3
     DURINGREPOINT = 2**4  # bit 4 # event during a repointing
     BACKTOF = 2**5  # bit 5 # Back TOF outlier
+    AUXOUTLIER = 2**6  # bit 6 # Event time is outside of aux dataset range.
 
 
 class ImapHkUltraFlags(FlagNameMixin):

{imap_processing-1.0.37 → imap_processing-1.0.38}/imap_processing/spice/pointing_frame.py

@@ -66,20 +66,9 @@ def generate_pointing_attitude_kernel(
     if len(pointing_segments) == 0:
         raise ValueError("No Pointings covered by input dependencies.")
 
-    # get the start and end yyyy_doy strings
-    start_datetime = spiceypy.et2datetime(
-        sct_to_et(pointing_segments[0]["start_sclk_ticks"])
-    )
-    end_datetime = spiceypy.et2datetime(
-        sct_to_et(pointing_segments[-1]["end_sclk_ticks"])
-    )
     sorted_ck_paths = list(sorted(imap_attitude_cks, key=lambda x: x.name))
-    version_str = str(Version(None, minor_version)).lstrip("v")
-    pointing_kernel_path = (
-        sorted_ck_paths[-1].parent / f"imap_dps_"
-        f"{start_datetime.strftime('%Y_%j')}_"
-        f"{end_datetime.strftime('%Y_%j')}_"
-        f"{version_str}.ah.bc"
+    pointing_kernel_path = sorted_ck_paths[-1].parent / segment_ck_filename(
+        "imap_dps", pointing_segments, minor_version, "ah.bc"
     )
     write_pointing_frame_ck(
         pointing_kernel_path, pointing_segments, [p.name for p in imap_attitude_cks]
@@ -87,6 +76,45 @@ def generate_pointing_attitude_kernel(
     return [pointing_kernel_path]
 
 
+def segment_ck_filename(
+    prefix: str, segment_data: np.ndarray, minor_version: int, extension: str
+) -> str:
+    """
+    Build a CK filename from the time coverage of its segments.
+
+    The filename has the form ``<prefix>_<YYYY_DOY>_<YYYY_DOY>_<NNN>.<extension>``
+    where the dates are the start of the first segment and the end of the
+    last segment.
+
+    Parameters
+    ----------
+    prefix : str
+        Leading portion of the filename, e.g. "imap_dps".
+    segment_data : np.ndarray
+        Numpy structured array of POINTING_SEGMENT_DTYPE, sorted by time.
+    minor_version : int
+        Minor version to use in the filename.
+    extension : str
+        Filename extension without the leading ".", e.g. "ah.bc".
+
+    Returns
+    -------
+    filename : str
+        The CK filename.
+    """
+    start_datetime = spiceypy.et2datetime(
+        sct_to_et(segment_data[0]["start_sclk_ticks"])
+    )
+    end_datetime = spiceypy.et2datetime(sct_to_et(segment_data[-1]["end_sclk_ticks"]))
+    version_str = str(Version(None, minor_version)).lstrip("v")
+    return (
+        f"{prefix}_"
+        f"{start_datetime.strftime('%Y_%j')}_"
+        f"{end_datetime.strftime('%Y_%j')}_"
+        f"{version_str}.{extension}"
+    )
+
+
 @contextmanager
 def open_spice_ck_file(pointing_frame_path: Path) -> Generator[int, None, None]:
     """
@@ -109,7 +137,10 @@ def open_spice_ck_file(pointing_frame_path: Path) -> Generator[int, None, None]:
     try:
         yield handle
     finally:
-        spiceypy.ckcls(handle)
+        # dafcls rather than ckcls: ckcls also raises SPICE(NOSEGMENTSFOUND)
+        # when no segment was written, which would leave the file open and
+        # replace the original error.
+        spiceypy.dafcls(handle)
 
 
 def write_pointing_frame_ck(
@@ -142,8 +173,54 @@ def write_pointing_frame_ck(
     ]
 
     logger.debug(f"Writing pointing attitude kernel: {pointing_kernel_path}")
+    write_constant_attitude_ck(
+        pointing_kernel_path,
+        segment_data,
+        SpiceFrame.IMAP_DPS,
+        SpiceFrame.ECLIPJ2000,
+        comments,
+    )
+    logger.debug(f"Finished writing pointing attitude kernel: {pointing_kernel_path}")
+
+
+def write_constant_attitude_ck(
+    kernel_path: Path,
+    segment_data: np.ndarray,
+    frame: SpiceFrame,
+    reference_frame: SpiceFrame,
+    comments: list[str],
+) -> None:
+    """
+    Write a CK with a single constant attitude record per segment.
+
+    Parameters
+    ----------
+    kernel_path : pathlib.Path
+        Location to write the CK kernel.
+    segment_data : np.ndarray
+        Numpy structured array with the following dtypes:
+            ("start_sclk_ticks", np.float64),
+            ("end_sclk_ticks", np.float64),
+            ("quaternion", np.float64, (4,)),
+            ("pointing_id", np.uint32),
+    frame : SpiceFrame
+        Frame whose orientation the CK defines. Also used as the segment
+        identifier.
+    reference_frame : SpiceFrame
+        Frame the orientation is relative to. The quaternion in each segment
+        rotates vectors from this frame into `frame`.
+    comments : list[str]
+        Lines to write to the comment area of the CK.
+
+    Raises
+    ------
+    ValueError
+        If `segment_data` is empty.
+    """
+    if len(segment_data) == 0:
+        raise ValueError(f"No segments to write to {kernel_path.name}.")
 
-    with open_spice_ck_file(pointing_kernel_path) as handle:
+    with open_spice_ck_file(kernel_path) as handle:
         # Write the comments to the file
         spiceypy.dafac(handle, comments)
 
@@ -157,12 +234,12 @@ def write_pointing_frame_ck(
                 segment["start_sclk_ticks"],
                 # End time of the segment.
                 segment["end_sclk_ticks"],
-                # Pointing frame ID.
-                SpiceFrame.IMAP_DPS.value,
+                # Frame ID.
+                frame.value,
                 # Reference frame.
-                SpiceFrame.ECLIPJ2000.name,  # Reference frame
+                reference_frame.name,
                 # Identifier.
-                SpiceFrame.IMAP_DPS.name,
+                frame.name,
                 # Number of pointing intervals.
                 1,
                 # Start times of individual pointing records within segment.
@@ -171,18 +248,16 @@ def write_pointing_frame_ck(
                 # End times of individual pointing records within segment.
                 # Since there is only a single record this is equal to sclk_endtim.
                 np.array([segment["end_sclk_ticks"]]),  # Single stop time
-                # Average quaternion.
+                # Constant quaternion for the segment.
                 segment["quaternion"],
-                # Angular velocity vectors. The IMAP_DPS frame is quasi-inertial
-                # for each pointing so each segment has zeros here.
+                # Angular velocity vectors. The attitude is constant over each
+                # segment so each segment has zeros here.
                 np.array([0.0, 0.0, 0.0]),
                 # The number of seconds per encoded spacecraft clock
                 # tick for each interval.
                 np.array([TICK_DURATION]),
             )
 
-    logger.debug(f"Finished writing pointing attitude kernel: {pointing_kernel_path}")
-
 
 def calculate_pointing_attitude_segments(
     ck_paths: list[Path],