imap-processing 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

imap_processing/mag/l1c/mag_l1c.py

@@ -63,17 +63,16 @@ def mag_l1c(
     )
 
     interp_function = InterpolationFunction[configuration.L1C_INTERPOLATION_METHOD]
-    if normal_mode_dataset and burst_mode_dataset:
-        full_interpolated_timeline = process_mag_l1c(
-            normal_mode_dataset, burst_mode_dataset, interp_function
+    if burst_mode_dataset is not None:
+        # Only use day_to_process if there is no norm data
+        day_to_process_arg = day_to_process if normal_mode_dataset is None else None
+        full_interpolated_timeline: np.ndarray = process_mag_l1c(
+            normal_mode_dataset, burst_mode_dataset, interp_function, day_to_process_arg
         )
     elif normal_mode_dataset is not None:
-        full_interpolated_timeline = fill_normal_data(
-            normal_mode_dataset, normal_mode_dataset["epoch"].data
-        )
+        full_interpolated_timeline = fill_normal_data(normal_mode_dataset)
     else:
-        # TODO: With only burst data, downsample by retrieving the timeline
-        raise NotImplementedError
+        raise ValueError("At least one of norm or burst dataset must be provided.")
 
     completed_timeline = remove_missing_data(full_interpolated_timeline)
 
@@ -127,12 +126,14 @@ def mag_l1c(
     global_attributes["missing_sequences"] = ""
 
     try:
-        global_attributes["is_mago"] = normal_mode_dataset.attrs["is_mago"]
-        global_attributes["is_active"] = normal_mode_dataset.attrs["is_active"]
+        active_dataset = normal_mode_dataset or burst_mode_dataset
+
+        global_attributes["is_mago"] = active_dataset.attrs["is_mago"]
+        global_attributes["is_active"] = active_dataset.attrs["is_active"]
 
         # Check if all vectors are primary in both normal and burst datasets
-        is_mago = normal_mode_dataset.attrs.get("is_mago", "False") == "True"
-        normal_all_primary = normal_mode_dataset.attrs.get("all_vectors_primary", False)
+        is_mago = active_dataset.attrs.get("is_mago", "False") == "True"
+        normal_all_primary = active_dataset.attrs.get("all_vectors_primary", False)
 
         # Default for missing burst dataset: 1 if MAGO (expected primary), 0 if MAGI
         burst_all_primary = is_mago
@@ -146,14 +147,14 @@ def mag_l1c(
             normal_all_primary and burst_all_primary
         )
 
-        global_attributes["missing_sequences"] = normal_mode_dataset.attrs[
+        global_attributes["missing_sequences"] = active_dataset.attrs[
             "missing_sequences"
         ]
     except KeyError as e:
         logger.info(
             f"Key error when assigning global attributes, attribute not found in "
             f"L1B file with logical source "
-            f"{normal_mode_dataset.attrs['Logical_source']}: {e}"
+            f"{active_dataset.attrs['Logical_source']}: {e}"
         )
 
     global_attributes["interpolation_method"] = interp_function.name
@@ -176,16 +177,24 @@ def mag_l1c(
         attrs=attribute_manager.get_variable_attributes("vector_attrs"),
     )
 
-    output_dataset["vector_magnitude"] = xr.apply_ufunc(
-        lambda x: np.linalg.norm(x[:4]),
-        output_dataset["vectors"],
-        input_core_dims=[["direction"]],
-        output_core_dims=[[]],
-        vectorize=True,
-    )
-    output_dataset[
-        "vector_magnitude"
-    ].attrs = attribute_manager.get_variable_attributes("vector_magnitude_attrs")
+    if len(output_dataset["vectors"]) > 0:
+        output_dataset["vector_magnitude"] = xr.apply_ufunc(
+            lambda x: np.linalg.norm(x[:4]),
+            output_dataset["vectors"],
+            input_core_dims=[["direction"]],
+            output_core_dims=[[]],
+            vectorize=True,
+        )
+        output_dataset[
+            "vector_magnitude"
+        ].attrs = attribute_manager.get_variable_attributes("vector_magnitude_attrs")
+    else:
+        output_dataset["vector_magnitude"] = xr.DataArray(
+            np.empty((0, 1)),
+            name="vector_magnitude",
+            dims=["epoch", "vector_magnitude"],
+            attrs=attribute_manager.get_variable_attributes("vector_magnitude_attrs"),
+        )
 
     output_dataset["compression_flags"] = xr.DataArray(
         completed_timeline[:, 6:8],
@@ -265,7 +274,7 @@ def select_datasets(
 
 
 def process_mag_l1c(
-    normal_mode_dataset: xr.Dataset,
+    normal_mode_dataset: xr.Dataset | None,
     burst_mode_dataset: xr.Dataset,
     interpolation_function: InterpolationFunction,
     day_to_process: np.datetime64 | None = None,
@@ -305,38 +314,51 @@ def process_mag_l1c(
     np.ndarray
         An (n, 8) shaped array containing the completed timeline.
     """
-    norm_epoch = normal_mode_dataset["epoch"].data
-    if "vectors_per_second" in normal_mode_dataset.attrs:
-        normal_vecsec_dict = vectors_per_second_from_string(
-            normal_mode_dataset.attrs["vectors_per_second"]
-        )
-    else:
-        normal_vecsec_dict = None
-
-    output_dataset = normal_mode_dataset.copy(deep=True)
-    output_dataset["sample_interpolated"] = xr.DataArray(
-        np.zeros(len(normal_mode_dataset))
-    )
     day_start_ns = None
     day_end_ns = None
 
     if day_to_process is not None:
-        day_start = day_to_process.astype("datetime64[s]") - np.timedelta64(15, "m")
+        day_start = day_to_process.astype("datetime64[s]") - np.timedelta64(30, "m")
 
-        # get the end of the day plus 15 minutes
+        # get the end of the day plus 30 minutes
         day_end = (
             day_to_process.astype("datetime64[s]")
             + np.timedelta64(1, "D")
-            + np.timedelta64(15, "m")
+            + np.timedelta64(30, "m")
         )
 
         day_start_ns = et_to_ttj2000ns(str_to_et(str(day_start)))
         day_end_ns = et_to_ttj2000ns(str_to_et(str(day_end)))
 
-    gaps = find_all_gaps(norm_epoch, normal_vecsec_dict, day_start_ns, day_end_ns)
+    if normal_mode_dataset:
+        norm_epoch = normal_mode_dataset["epoch"].data
+        if "vectors_per_second" in normal_mode_dataset.attrs:
+            normal_vecsec_dict = vectors_per_second_from_string(
+                normal_mode_dataset.attrs["vectors_per_second"]
+            )
+        else:
+            normal_vecsec_dict = None
+
+        gaps = find_all_gaps(norm_epoch, normal_vecsec_dict, day_start_ns, day_end_ns)
+    else:
+        norm_epoch = [day_start_ns, day_end_ns]
+        gaps = np.array(
+            [
+                [
+                    day_start_ns,
+                    day_end_ns,
+                    VecSec.TWO_VECS_PER_S.value,
+                ]
+            ]
+        )
 
     new_timeline = generate_timeline(norm_epoch, gaps)
-    norm_filled = fill_normal_data(normal_mode_dataset, new_timeline)
+
+    if normal_mode_dataset:
+        norm_filled: np.ndarray = fill_normal_data(normal_mode_dataset, new_timeline)
+    else:
+        norm_filled = generate_empty_norm_array(new_timeline)
+
     interpolated = interpolate_gaps(
         burst_mode_dataset, gaps, norm_filled, interpolation_function
     )
@@ -344,10 +366,32 @@ def process_mag_l1c(
     return interpolated
 
 
+def generate_empty_norm_array(new_timeline: np.ndarray) -> np.ndarray:
+    """
+    Generate an empty Normal mode array with the new timeline.
+
+    Parameters
+    ----------
+    new_timeline : np.ndarray
+        A 1D array of timestamps to fill.
+
+    Returns
+    -------
+    np.ndarray
+        An (n, 8) shaped array containing the timeline filled with `FILLVAL` data.
+    """
+    # TODO: fill with FILLVAL
+    norm_filled: np.ndarray = np.zeros((len(new_timeline), 8))
+    norm_filled[:, 0] = new_timeline
+    # Flags, will also indicate any missed timestamps
+    norm_filled[:, 5] = ModeFlags.MISSING.value
+
+    return norm_filled
+
+
 def fill_normal_data(
     normal_dataset: xr.Dataset,
-    new_timeline: np.ndarray,
-    day_to_process: np.datetime64 | None = None,
+    new_timeline: np.ndarray | None = None,
 ) -> np.ndarray:
     """
     Fill the new timeline with the normal mode data.
@@ -358,26 +402,23 @@ def fill_normal_data(
     ----------
     normal_dataset : xr.Dataset
         The normal mode dataset.
-    new_timeline : np.ndarray
-        A 1D array of timestamps to fill.
-    day_to_process : np.datetime64, optional
-        The day to process, in np.datetime64[D] format. This is used to fill
-        gaps at the beginning or end of the day if needed. If not included, these
-        gaps will not be filled.
+    new_timeline : np.ndarray, optional
+        A 1D array of timestamps to fill. If not provided, the normal mode timestamps
+        will be used.
 
     Returns
     -------
-    np.ndarray
+    filled_timeline : np.ndarray
         An (n, 8) shaped array containing the timeline filled with normal mode data.
         Gaps are marked as -1 in the generated flag column at index 5.
         Indices: 0 - epoch, 1-4 - vector x, y, z, and range, 5 - generated flag,
         6-7 - compression flags.
     """
-    # TODO: fill with FILLVAL
-    filled_timeline: np.ndarray = np.zeros((len(new_timeline), 8))
-    filled_timeline[:, 0] = new_timeline
-    # Flags, will also indicate any missed timestamps
-    filled_timeline[:, 5] = ModeFlags.MISSING.value
+    if new_timeline is None:
+        new_timeline = normal_dataset["epoch"].data
+
+    filled_timeline = generate_empty_norm_array(new_timeline)
+
     for index, timestamp in enumerate(normal_dataset["epoch"].data):
         timeline_index = np.searchsorted(new_timeline, timestamp)
         filled_timeline[timeline_index, 1:5] = normal_dataset["vectors"].data[index]
@@ -463,20 +504,17 @@ def interpolate_gaps(
         ]
 
         short = (gap_timeline >= burst_epochs[burst_start]) & (
-            gap_timeline <= burst_epochs[burst_gap_end]
+            gap_timeline <= burst_epochs[burst_end]
         )
-        if len(gap_timeline) != (short).sum():
-            print(f"Chopping timeline from {len(gap_timeline)} to {short.sum()}")
+        num_short = int(short.sum())
+
+        if len(gap_timeline) != num_short:
+            print(f"Chopping timeline from {len(gap_timeline)} to {num_short}")
 
         # Limit timestamps to only include the areas with burst data
-        gap_timeline = gap_timeline[
-            (
-                (gap_timeline >= burst_epochs[burst_start])
-                & (gap_timeline <= burst_epochs[burst_gap_end])
-            )
-        ]
+        gap_timeline = gap_timeline[short]
         # do not include range
-        gap_fill = interpolation_function(
+        adjusted_gap_timeline, gap_fill = interpolation_function(
             burst_vectors[burst_start:burst_end, :3],
             burst_epochs[burst_start:burst_end],
             gap_timeline,
@@ -485,7 +523,7 @@ def interpolate_gaps(
         )
 
         # gaps should not have data in timeline, still check it
-        for index, timestamp in enumerate(gap_timeline):
+        for index, timestamp in enumerate(adjusted_gap_timeline):
             timeline_index = np.searchsorted(filled_norm_timeline[:, 0], timestamp)
             if sum(
                 filled_norm_timeline[timeline_index, 1:4]
@@ -500,6 +538,18 @@ def interpolate_gaps(
                     "compression_flags"
                 ].data[burst_gap_start + index]
 
+        # for any timestamp that was not filled and is still missing, remove it
+        missing_timeline = np.setdiff1d(gap_timeline, adjusted_gap_timeline)
+
+        for timestamp in missing_timeline:
+            timeline_index = np.searchsorted(filled_norm_timeline[:, 0], timestamp)
+            if filled_norm_timeline[timeline_index, 5] != ModeFlags.MISSING.value:
+                raise RuntimeError(
+                    "Self-inconsistent data. "
+                    "Gaps not included in final timeline should be missing."
+                )
+            np.delete(filled_norm_timeline, timeline_index)
+
     return filled_norm_timeline
 
 

imap_processing/mag/l1d/mag_l1d_data.py

@@ -693,10 +693,12 @@ class MagL1d(MagL2L1dBase):  # type: ignore[misc]
             - gradiometer_offset_magnitude: magnitude of the offset vector
             - quality_flags: quality flags (1 if magnitude > threshold, 0 otherwise)
         """
-        aligned_magi = linear(
+        # TODO: should this extrapolate or should non-overlapping data be removed?
+        _, aligned_magi = linear(
             magi_vectors,
             magi_epoch,
             mago_epoch,
+            extrapolate=True,
         )
 
         diff = aligned_magi - mago_vectors

imap_processing/quality_flags.py

@@ -64,6 +64,7 @@ class ImapAttitudeUltraFlags(FlagNameMixin):
     AUXMISMATCH = 2**1  # bit 1 # aux packet does not match Universal Spin Table
     SPINPHASE = 2**2  # bit 2 # spin phase flagged by Universal Spin Table
     SPINPERIOD = 2**3  # bit 3 # spin period flagged by Universal Spin Table
+    DURINGREPOINT = 2**4  # bit 4 # spin during a repointing
 
 
 class ImapRatesUltraFlags(FlagNameMixin):

imap_processing/spice/geometry.py

@@ -129,7 +129,7 @@ def imap_state(
     -------
     state : np.ndarray
      The Cartesian state vector representing the position and velocity of the
-     IMAP spacecraft.
+     IMAP spacecraft. Units are km and km/s.
     """
     state, _ = spiceypy.spkezr(
         SpiceBody.IMAP.name, et, ref_frame.name, abcorr, observer.name
@@ -323,6 +323,7 @@ def frame_transform_az_el(
         Ephemeris time(s) corresponding to position(s).
     az_el :  np.ndarray
         <azimuth, elevation> vector or array of vectors in reference frame `from_frame`.
+        Azimuth and elevation pairs are always the final dimension of the array.
         There are several possible shapes for the input az_el and et:
         1. A single az_el vector may be provided for multiple `et` query times
         2. A single `et` may be provided for multiple az_el vectors,
@@ -340,15 +341,16 @@ def frame_transform_az_el(
     to_frame_az_el : np.ndarray
         Azimuth/elevation coordinates in reference frame `to_frame`. This
         output coordinate vector will have shape (2,) if a single `az_el` position
-        vector and single `et` time are input. Otherwise, it will have shape (n, 2)
-        where n is the number of input position vector or ephemeris times. The last
-        axis of the output vector contains azimuth in the 0th position and elevation
-        in the 1st position.
+        vector and single `et` time are input. Otherwise, it will have shape (..., 2)
+        where ... matches the leading dimensions of the input position vector or
+        ephemeris times. The last axis of the output vector contains azimuth in
+        the 0th position and elevation in the 1st position.
     """
     # Convert input az/el to Cartesian vectors
-    spherical_coords_in = np.array(
-        [np.ones_like(az_el[..., 0]), az_el[..., 0], az_el[..., 1]]
-    ).T
+    spherical_coords_in = np.stack(
+        [np.ones_like(az_el[..., 0]), az_el[..., 0], az_el[..., 1]],
+        axis=-1,
+    )
     from_frame_cartesian = spherical_to_cartesian(spherical_coords_in)
     # Transform to to_frame
     to_frame_cartesian = frame_transform(et, from_frame_cartesian, from_frame, to_frame)
@@ -531,7 +533,7 @@ def cartesian_to_spherical(
         az = np.degrees(az)
         el = np.degrees(el)
 
-    spherical_coords = np.stack((np.squeeze(magnitude_v), az, el), axis=-1)
+    spherical_coords = np.stack((np.squeeze(magnitude_v, -1), az, el), axis=-1)
 
     return spherical_coords
 

imap_processing/spice/pointing_frame.py

@@ -34,14 +34,14 @@ POINTING_SEGMENT_DTYPE = np.dtype(
 )
 
 
-def generate_pointing_attitude_kernel(imap_attitude_ck: Path) -> list[Path]:
+def generate_pointing_attitude_kernel(imap_attitude_cks: list[Path]) -> list[Path]:
     """
     Generate pointing attitude kernel from input IMAP CK kernel.
 
     Parameters
     ----------
-    imap_attitude_ck : Path
-        Location of the IMAP attitude kernel from which to generate pointing
+    imap_attitude_cks : list[Path]
+        List of the IMAP attitude kernels from which to generate pointing
         attitude.
 
     Returns
@@ -49,20 +49,29 @@ def generate_pointing_attitude_kernel(imap_attitude_ck: Path) -> list[Path]:
     pointing_kernel_path : list[Path]
         Location of the new pointing kernels.
     """
-    pointing_segments = calculate_pointing_attitude_segments(imap_attitude_ck)
+    pointing_segments = calculate_pointing_attitude_segments(imap_attitude_cks)
+    if len(pointing_segments) == 0:
+        raise ValueError("No Pointings covered by input dependencies.")
+
     # get the start and end yyyy_doy strings
-    # TODO: For now just use the input CK start/end dates. It is possible that
-    #    the end date is incorrect b/c the repoint table determines the last
-    #    segment in the pointing kernel.
-    spice_file = SPICEFilePath(imap_attitude_ck.name)
+    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"])
+    )
+    # Use the last ck from sorted list to get the version number. I
+    # don't think this will be anything but 1.
+    sorted_ck_paths = list(sorted(imap_attitude_cks, key=lambda x: x.name))
+    spice_file = SPICEFilePath(sorted_ck_paths[-1].name)
     pointing_kernel_path = (
-        imap_attitude_ck.parent / f"imap_dps_"
-        f"{spice_file.spice_metadata['start_date'].strftime('%Y_%j')}_"
-        f"{spice_file.spice_metadata['end_date'].strftime('%Y_%j')}_"
+        sorted_ck_paths[-1].parent / f"imap_dps_"
+        f"{start_datetime.strftime('%Y_%j')}_"
+        f"{end_datetime.strftime('%Y_%j')}_"
         f"{spice_file.spice_metadata['version']}.ah.bc"
     )
     write_pointing_frame_ck(
-        pointing_kernel_path, pointing_segments, imap_attitude_ck.name
+        pointing_kernel_path, pointing_segments, [p.name for p in imap_attitude_cks]
     )
     return [pointing_kernel_path]
 
@@ -93,7 +102,7 @@ def open_spice_ck_file(pointing_frame_path: Path) -> Generator[int, None, None]:
 
 
 def write_pointing_frame_ck(
-    pointing_kernel_path: Path, segment_data: np.ndarray, parent_ck: str
+    pointing_kernel_path: Path, segment_data: np.ndarray, parent_cks: list[str]
 ) -> None:
     """
     Write a Pointing Frame attitude kernel.
@@ -108,8 +117,8 @@ def write_pointing_frame_ck(
             ("end_sclk_ticks", np.float64),
             ("quaternion", np.float64, (4,)),
             ("pointing_id", np.uint32),
-    parent_ck : str
-        Filename of the CK kernel that the quaternion was derived from.
+    parent_cks : list[str]
+        Filenames of the CK kernels that the quaternions were derived from.
     """
     id_imap_dps = spiceypy.gipool("FRAME_IMAP_DPS", 0, 1)
 
@@ -119,10 +128,12 @@ def write_pointing_frame_ck(
         "",
         f"Original file name: {pointing_kernel_path.name}",
         f"Creation date: {datetime.now(timezone.utc).strftime('%Y-%m-%d')}",
-        f"Parent file: {parent_ck}",
+        f"Parent files: {parent_cks}",
         "",
     ]
 
+    logger.debug(f"Writing pointing attitude kernel: {pointing_kernel_path}")
+
     with open_spice_ck_file(pointing_kernel_path) as handle:
         # Write the comments to the file
         spiceypy.dafac(handle, comments)
@@ -161,9 +172,11 @@ def write_pointing_frame_ck(
                 np.array([TICK_DURATION]),
             )
 
+    logger.debug(f"Finished writing pointing attitude kernel: {pointing_kernel_path}")
+
 
 def calculate_pointing_attitude_segments(
-    ck_path: Path,
+    ck_paths: list[Path],
 ) -> NDArray:
     """
     Calculate the data for each segment of the DPS_FRAME attitude kernel.
@@ -177,8 +190,8 @@ def calculate_pointing_attitude_segments(
 
     Parameters
     ----------
-    ck_path : pathlib.Path
-        Location of the CK kernel.
+    ck_paths : list[pathlib.Path]
+        List of CK kernels to use to generate the pointing attitude kernel.
 
     Returns
     -------
@@ -200,36 +213,41 @@ def calculate_pointing_attitude_segments(
     - IMAP historical attitude kernel from which the pointing frame kernel will
     be generated.
     """
-    logger.info(f"Extracting mean spin axes from CK kernel {ck_path.name}")
+    logger.info(
+        f"Extracting mean spin axes for all Pointings that are"
+        f" fully covered by the CK files: {[p.name for p in ck_paths]}"
+    )
     # Get IDs.
     # https://spiceypy.readthedocs.io/en/main/documentation.html#spiceypy.spiceypy.gipool
     id_imap_sclk = spiceypy.gipool("CK_-43000_SCLK", 0, 1)
+    id_imap_spacecraft = spiceypy.gipool("FRAME_IMAP_SPACECRAFT", 0, 1)
 
-    # Check that the last loaded kernel matches it input kernel name. This ensures
-    # that this CK take priority when computing attitude for it's time coverage.
-    count = spiceypy.ktotal("ck")
-    loaded_ck_kernel, _, _, _ = spiceypy.kdata(count - 1, "ck")
-    if str(ck_path) != loaded_ck_kernel:
-        raise ValueError(
-            f"Error: Expected CK kernel {ck_path} but loaded {loaded_ck_kernel}"
+    # This job relies on the batch starter to provide all the correct CK kernels
+    # to cover the time range of the new repoint table.
+    # Get the coverage of the CK files storing the earliest start time and
+    # latest end time.
+    et_start = np.inf
+    et_end = -np.inf
+    for ck_path in ck_paths:
+        ck_cover = spiceypy.ckcov(
+            str(ck_path), int(id_imap_spacecraft), True, "INTERVAL", 0, "TDB"
         )
+        num_intervals = spiceypy.wncard(ck_cover)
+        individual_ck_start, _ = spiceypy.wnfetd(ck_cover, 0)
+        _, individual_ck_end = spiceypy.wnfetd(ck_cover, num_intervals - 1)
+        logger.debug(
+            f"{ck_path.name} covers time range: ({et_to_utc(individual_ck_start)}, "
+            f"{et_to_utc(individual_ck_end)}) in {num_intervals} intervals."
+        )
+        et_start = min(et_start, individual_ck_start)
+        et_end = max(et_end, individual_ck_end)
 
-    id_imap_spacecraft = spiceypy.gipool("FRAME_IMAP_SPACECRAFT", 0, 1)
-
-    # Select only the pointings within the attitude coverage.
-    ck_cover = spiceypy.ckcov(
-        str(ck_path), int(id_imap_spacecraft), True, "INTERVAL", 0, "TDB"
-    )
-    num_intervals = spiceypy.wncard(ck_cover)
-    et_start, _ = spiceypy.wnfetd(ck_cover, 0)
-    _, et_end = spiceypy.wnfetd(ck_cover, num_intervals - 1)
     logger.info(
-        f"{ck_path.name} contains {num_intervals} intervals with "
-        f"start time: {et_to_utc(et_start)}, and end time: {et_to_utc(et_end)}"
+        f"CK kernels combined coverage range: "
+        f"{(et_to_utc(et_start), et_to_utc(et_end))}, "
     )
 
-    # Get data from the repoint table and filter to only the pointings fully
-    # covered by this attitude kernel
+    # Get data from the repoint table and convert to Pointings
     repoint_df = get_repoint_data()
     repoint_df["repoint_start_et"] = sct_to_et(
         met_to_sclkticks(repoint_df["repoint_start_met"].values)
@@ -237,20 +255,29 @@ def calculate_pointing_attitude_segments(
     repoint_df["repoint_end_et"] = sct_to_et(
         met_to_sclkticks(repoint_df["repoint_end_met"].values)
     )
-    repoint_df = repoint_df[
-        (repoint_df["repoint_end_et"] >= et_start)
-        & (repoint_df["repoint_start_et"] <= et_end)
-    ]
-    n_pointings = len(repoint_df) - 1
+    pointing_ids = repoint_df["repoint_id"].values[:-1]
+    pointing_start_ets = repoint_df["repoint_end_et"].values[:-1]
+    pointing_end_ets = repoint_df["repoint_start_et"].values[1:]
+
+    # Keep only the pointings that are fully covered by the attitude kernels.
+    keep_mask = (pointing_start_ets >= et_start) & (pointing_end_ets <= et_end)
+    # Filter the pointing data.
+    pointing_ids = pointing_ids[keep_mask]
+    pointing_start_ets = pointing_start_ets[keep_mask]
+    pointing_end_ets = pointing_end_ets[keep_mask]
+
+    n_pointings = len(pointing_ids)
+    if n_pointings == 0:
+        logger.warning(
+            "No Pointings identified based on coverage of CK files. Skipping."
+        )
 
     pointing_segments = np.zeros(n_pointings, dtype=POINTING_SEGMENT_DTYPE)
 
     for i_pointing in range(n_pointings):
-        pointing_segments[i_pointing]["pointing_id"] = repoint_df.iloc[i_pointing][
-            "repoint_id"
-        ]
-        pointing_start_et = repoint_df.iloc[i_pointing]["repoint_end_et"]
-        pointing_end_et = repoint_df.iloc[i_pointing + 1]["repoint_start_et"]
+        pointing_segments[i_pointing]["pointing_id"] = pointing_ids[i_pointing]
+        pointing_start_et = pointing_start_ets[i_pointing]
+        pointing_end_et = pointing_end_ets[i_pointing]
         logger.debug(
             f"Calculating pointing attitude for pointing "
             f"{pointing_segments[i_pointing]['pointing_id']} with time "

imap_processing/swapi/constants.py

@@ -0,0 +1,4 @@
+"""Constants for SWAPI processing."""
+
+NUM_PACKETS_PER_SWEEP = 12
+NUM_ENERGY_STEPS = 72