imap-processing 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

imap_processing/tests/spacecraft/test_quaternions.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+import xarray as xr
+
+from imap_processing.spacecraft import quaternions
+
+
+@pytest.fixture
+def l1a_quaternion_ds():
+    time = np.arange(100)
+    data = np.linspace(-0.1, 0.1, 100)
+    data_vars = {"SCIENCEDATA1HZ_QUAT_10_HZ_TIME".lower(): time}
+    for i in range(4):
+        for j in range(10):
+            index = i * 10 + j
+            # 0-0.1, 0.1-0.2, 0.2-0.3, ... for each variable
+            data_vars[f"FSW_ACS_QUAT_10_HZ_BUFFERED_{index}".lower()] = data * j
+
+    ds = xr.Dataset(data_vars=data_vars)
+    return ds
+
+
+def test_quaternion_packet_file():
+    # Single packet extracted with the following command:
+    # head --bytes 196 SSR_2024_190_20_08_12_0483851794_2_DA_apid0594.pkts > output.pkts
+    packet_file = (
+        Path(__file__).parent
+        / "data"
+        / "SSR_2024_190_20_08_12_0483851794_2_DA_apid0594_1packet.pkts"
+    )
+    l1a_ds = quaternions.load_quaternion_packets(packet_file)
+
+    # 1 packet
+    assert len(l1a_ds["epoch"]) == 1
+
+    # Make sure we have all of the expected variables
+    for i in range(40):
+        var = f"FSW_ACS_QUAT_10_HZ_BUFFERED_{i}".lower()
+        assert var in l1a_ds.data_vars
+        # Make sure it is a float32 between -1 and 1
+        assert l1a_ds[var].dtype == np.float32
+        assert -1 <= l1a_ds[var].values[0] <= 1
+
+
+def test_quaternion_unpacking(l1a_quaternion_ds):
+    l1b_ds = quaternions.assemble_quaternions(l1a_quaternion_ds)
+
+    # Should be 10x the amount of data we got from the input dataset
+    # input was 0, 1, 2, ...
+    # expected is 0, 0.1, 0.2, ...
+    np.testing.assert_allclose(l1b_ds["epoch"], np.arange(0, 100, 0.1))
+
+    data = np.linspace(-0.1, 0.1, 100)
+    for var in ["quat_x", "quat_y", "quat_z", "quat_s"]:
+        # 10 increasing values, then reset and shift right by 0.2 / 99 for the linspace
+        # -0., -0.1, -0.2, ..., -0.9, -0., -0.09, -0.19, -0.29, ...
+        expected = np.stack([data * i for i in range(10)], axis=1).ravel()
+        np.testing.assert_allclose(l1b_ds[var], expected)
+
+
+def test_process_quaternions():
+    packet_file = (
+        Path(__file__).parent
+        / "data"
+        / "SSR_2024_190_20_08_12_0483851794_2_DA_apid0594_1packet.pkts"
+    )
+    l1a_ds, l1b_ds = quaternions.process_quaternions(packet_file)
+    assert len(l1a_ds["epoch"]) == 1
+    assert len(l1b_ds["epoch"]) == 10

imap_processing/tests/spice/test_data/fake_repoint_data.csv

@@ -0,0 +1,5 @@
+# This is a fake csv file for the sole purpose of testing repoint module functions
+repoint_start_sec_sclk,repoint_start_subsec_sclk,repoint_end_sec_sclk,repoint_end_subsec_sclk,repoint_start_utc,repoint_end_utc,repoint_id
+0,100000,5,100000,2025-04-10 00:00:00.000000,2025-04-10T00:00:05.000000,0
+15,200000,20,200000,2025-04-10 00:00:15.000000,2025-04-10T00:00:20.000000,1
+25,300000,30,300000,2025-04-10 00:00:25.000000,2025-04-10T00:00:30.000000,2

imap_processing/tests/spice/test_data/fake_spin_data.csv

@@ -1,19 +1,19 @@
 # This is a fake csv file for the sole purpose of testing the get_spacecraft_spin_phase function
-spin_number,spin_start_sec,spin_start_subsec,spin_period_sec,spin_period_valid,spin_phase_valid,spin_period_source,thruster_firing
+spin_number,spin_start_sec_sclk,spin_start_subsec_sclk,spin_start_utc,spin_period_sec,spin_period_valid,spin_phase_valid,spin_period_source,thruster_firing
 # Start with thruster firing
-0,0,0,15.0,1,1,0,1
+0,0,0,2024-04-11 00:00:00.000000,15.0,1,1,0,1
 # Turn thruster firing off then 3 valid spins
-1,15,0,15.0,1,1,0,0
-2,30,0,15.0,1,1,0,0
-3,45,0,15.0,1,1,0,0
+1,15,0,2024-04-11 00:00:15.000000,15.0,1,1,0,0
+2,30,0,2024-04-11 00:00:30.000000,15.0,1,1,0,0
+3,45,0,2024-04-11 00:00:45.000000,15.0,1,1,0,0
 # Missing spin then 2 good spins
-5,75,0,15.0,1,1,0,0
-6,90,0,15.0,1,1,0,0
+5,75,0,2024-04-11 00:01:15.000000,15.0,1,1,0,0
+6,90,0,2024-04-11 00:01:30.000000,15.0,1,1,0,0
 # invalid spin period
-7,105,0,15.0,0,1,0,0
+7,105,0,2024-04-11 00:01:45.000000,15.0,0,1,0,0
 # invalid spin phase
-8,120,0,15.0,1,0,0,0
+8,120,0,2024-04-11 00:02:00.000000,15.0,1,0,0,0
 # 1 good spin
-9,135,0,15.0,1,1,0,0
+9,135,0,2024-04-11 00:02:15.000000,15.0,1,1,0,0
 # Thruster firing on
-10,150,0,15.0,1,1,0,1
+10,150,0,2024-04-11 00:02:30.000000,15.0,1,1,0,1

imap_processing/tests/spice/test_geometry.py

@@ -40,7 +40,7 @@ def test_imap_state(et, use_test_metakernel):
         assert state.shape == (6,)
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
 def test_imap_state_ecliptic():
     """Tests retrieving IMAP state in the ECLIPJ2000 frame"""
@@ -51,7 +51,7 @@ def test_imap_state_ecliptic():
 @pytest.mark.parametrize(
     "instrument, expected_offset",
     [
-        (SpiceFrame.IMAP_LO, 330 / 360),
+        (SpiceFrame.IMAP_LO_BASE, 330 / 360),
         (SpiceFrame.IMAP_HI_45, 255 / 360),
         (SpiceFrame.IMAP_HI_90, 285 / 360),
         (SpiceFrame.IMAP_ULTRA_45, 33 / 360),
@@ -208,8 +208,7 @@ def test_frame_transform_exceptions():
         SpiceFrame.ECLIPJ2000,
     ],
 )
-@pytest.mark.parametrize("degrees_bool", [True, False])
-def test_frame_transform_az_el_same_frame(spice_frame, degrees_bool):
+def test_frame_transform_az_el_same_frame(spice_frame):
     """Test that frame_transform returns az/el when input/output frames are same."""
     az_el_points = np.array(
         [
@@ -231,10 +230,8 @@ def test_frame_transform_az_el_same_frame(spice_frame, degrees_bool):
             [360, 90],
         ]
     )
-    if not degrees_bool:
-        az_el_points = np.deg2rad(az_el_points)
     result = frame_transform_az_el(
-        0, az_el_points, spice_frame, spice_frame, degrees=degrees_bool
+        0, az_el_points, spice_frame, spice_frame, degrees=True
     )
     np.testing.assert_allclose(result, az_el_points)
 
@@ -290,7 +287,7 @@ def test_instrument_pointing(furnish_kernels):
         assert ins_pointing.shape == (3, 3)
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
 def test_basis_vectors():
     """Test coverage for basis_vectors()."""
@@ -360,12 +357,12 @@ def test_spherical_to_cartesian():
     # Convert elevation to colatitude for SPICE
     colat = np.pi / 2 - spherical_points[:, 2]
 
-    cartesian_from_degrees = spherical_to_cartesian(
-        spherical_points_degrees, degrees=True
-    )
+    cartesian_from_degrees = spherical_to_cartesian(spherical_points_degrees)
 
     for i in range(len(colat)):
-        cartesian_coords = spherical_to_cartesian(np.array([spherical_points[i]]))
+        cartesian_coords = spherical_to_cartesian(
+            np.array([spherical_points_degrees[i]])
+        )
         spice_coords = spiceypy.sphrec(r, colat[i], spherical_points[i, 1])
 
         np.testing.assert_allclose(cartesian_coords[0], spice_coords, atol=1e-5)

imap_processing/tests/spice/test_kernels.py

@@ -1,58 +1,10 @@
 """Tests coverage for imap_processing/spice/kernels.py"""
 
-import numpy as np
 import pytest
 import spiceypy
 from spiceypy.utils.exceptions import SpiceyError
 
-from imap_processing.spice.kernels import (
-    _average_quaternions,
-    _create_rotation_matrix,
-    _get_et_times,
-    create_pointing_frame,
-    ensure_spice,
-)
-
-
-@pytest.fixture()
-def pointing_frame_kernels(spice_test_data_path):
-    """List SPICE kernels."""
-    required_kernels = [
-        "imap_science_0001.tf",
-        "imap_sclk_0000.tsc",
-        "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
-        "imap_wkcp.tf",
-        "naif0012.tls",
-    ]
-    kernels = [str(spice_test_data_path / kernel) for kernel in required_kernels]
-    return kernels
-
-
-@pytest.fixture()
-def multiple_pointing_kernels(spice_test_data_path):
-    """List SPICE kernels."""
-    required_kernels = [
-        "imap_science_0001.tf",
-        "imap_sclk_0000.tsc",
-        "sim_1yr_imap_attitude.bc",
-        "imap_wkcp.tf",
-        "naif0012.tls",
-    ]
-    kernels = [str(spice_test_data_path / kernel) for kernel in required_kernels]
-    return kernels
-
-
-@pytest.fixture()
-def et_times(pointing_frame_kernels):
-    """Tests get_et_times function."""
-    spiceypy.furnsh(pointing_frame_kernels)
-
-    ck_kernel, _, _, _ = spiceypy.kdata(0, "ck")
-    ck_cover = spiceypy.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
-    et_start, et_end = spiceypy.wnfetd(ck_cover, 0)
-    et_times = _get_et_times(et_start, et_end)
-
-    return et_times
+from imap_processing.spice.kernels import ensure_spice
 
 
 @ensure_spice
@@ -119,154 +71,3 @@ def test_ensure_spice_key_error():
     # functions that it decorates.
     with pytest.raises(SpiceyError):
         _ = wrapped(577365941.184, "ISOC", 3) == "2018-04-18T23:24:31.998"
-
-
-def test_average_quaternions(et_times, pointing_frame_kernels):
-    """Tests average_quaternions function."""
-    spiceypy.furnsh(pointing_frame_kernels)
-    q_avg = _average_quaternions(et_times)
-
-    # Generated from MATLAB code results
-    q_avg_expected = np.array([-0.6611, 0.4981, -0.5019, -0.2509])
-    np.testing.assert_allclose(q_avg, q_avg_expected, atol=1e-4)
-
-
-def test_create_rotation_matrix(et_times, pointing_frame_kernels):
-    """Tests create_rotation_matrix function."""
-    spiceypy.furnsh(pointing_frame_kernels)
-    rotation_matrix = _create_rotation_matrix(et_times)
-    q_avg = _average_quaternions(et_times)
-    z_avg = spiceypy.q2m(list(q_avg))[:, 2]
-
-    rotation_matrix_expected = np.array(
-        [[0.0000, 0.0000, 1.0000], [0.9104, -0.4136, 0.0000], [0.4136, 0.9104, 0.0000]]
-    )
-    z_avg_expected = np.array([0.4136, 0.9104, 0.0000])
-
-    np.testing.assert_allclose(z_avg, z_avg_expected, atol=1e-4)
-    np.testing.assert_allclose(rotation_matrix, rotation_matrix_expected, atol=1e-4)
-
-
-def test_create_pointing_frame(
-    spice_test_data_path, pointing_frame_kernels, tmp_path, et_times
-):
-    """Tests create_pointing_frame function."""
-    spiceypy.kclear()
-    spiceypy.furnsh(pointing_frame_kernels)
-    create_pointing_frame(
-        pointing_frame_path=tmp_path / "imap_dps.bc",
-        ck_path=spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
-    )
-
-    # After imap_dps.bc has been created.
-    dps_kernel = str(tmp_path / "imap_dps.bc")
-
-    spiceypy.furnsh(dps_kernel)
-    rotation_matrix_1 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 100)
-    rotation_matrix_2 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 1000)
-
-    # All the rotation matrices should be the same.
-    assert np.array_equal(rotation_matrix_1, rotation_matrix_2)
-
-    # Nick Dutton's MATLAB code result
-    rotation_matrix_expected = np.array(
-        [[0.0000, 0.0000, 1.0000], [0.9104, -0.4136, 0.0000], [0.4136, 0.9104, 0.0000]]
-    )
-    np.testing.assert_allclose(rotation_matrix_1, rotation_matrix_expected, atol=1e-4)
-
-    # Verify imap_dps.bc has been created.
-    assert (tmp_path / "imap_dps.bc").exists()
-
-    # Tests error handling when incorrect kernel is loaded.
-    spiceypy.furnsh(pointing_frame_kernels)
-    with pytest.raises(
-        ValueError, match="Error: Expected CK kernel badname_kernel.bc"
-    ):  # Replace match string with expected error message
-        create_pointing_frame(
-            pointing_frame_path=tmp_path / "imap_dps.bc", ck_path="badname_kernel.bc"
-        )
-
-
-def test_et_times(pointing_frame_kernels):
-    """Tests get_et_times function."""
-    spiceypy.furnsh(pointing_frame_kernels)
-
-    ck_kernel, _, _, _ = spiceypy.kdata(0, "ck")
-    ck_cover = spiceypy.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
-    et_start, et_end = spiceypy.wnfetd(ck_cover, 0)
-    et_times = _get_et_times(et_start, et_end)
-
-    assert et_times[0] == et_start
-    assert et_times[-1] == et_end
-
-    return et_times
-
-
-def test_multiple_attempts(pointing_frame_kernels, tmp_path, spice_test_data_path):
-    """Tests create_pointing_frame function with multiple pointing kernels."""
-    spiceypy.furnsh(pointing_frame_kernels)
-
-    # Check that a single segment is added regardless of how many times
-    # create_pointing_frame is called.
-    create_pointing_frame(
-        pointing_frame_path=tmp_path / "imap_dps.bc",
-        ck_path=spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
-    )
-    ck_cover = spiceypy.ckcov(
-        str(tmp_path / "imap_dps.bc"), -43901, True, "INTERVAL", 0, "TDB"
-    )
-    num_intervals = spiceypy.wncard(ck_cover)
-    assert num_intervals == 1
-
-    create_pointing_frame(
-        pointing_frame_path=tmp_path / "imap_dps.bc",
-        ck_path=spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
-    )
-    ck_cover = spiceypy.ckcov(
-        str(tmp_path / "imap_dps.bc"), -43901, True, "INTERVAL", 0, "TDB"
-    )
-    num_intervals = spiceypy.wncard(ck_cover)
-    assert num_intervals == 1
-
-
-def test_multiple_pointings(pointing_frame_kernels, spice_test_data_path, tmp_path):
-    """Tests create_pointing_frame function with multiple pointing kernels."""
-    spiceypy.furnsh(pointing_frame_kernels)
-
-    create_pointing_frame(
-        pointing_frame_path=tmp_path / "imap_pointing_frame.bc",
-        ck_path=spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
-    )
-    ck_cover_pointing = spiceypy.ckcov(
-        str(tmp_path / "imap_pointing_frame.bc"),
-        -43901,
-        True,
-        "INTERVAL",
-        0,
-        "TDB",
-    )
-    num_intervals = spiceypy.wncard(ck_cover_pointing)
-    et_start_pointing, et_end_pointing = spiceypy.wnfetd(ck_cover_pointing, 0)
-
-    ck_cover = spiceypy.ckcov(
-        str(spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc"),
-        -43000,
-        True,
-        "INTERVAL",
-        0,
-        "TDB",
-    )
-    num_intervals_expected = spiceypy.wncard(ck_cover)
-    et_start_expected, et_end_expected = spiceypy.wnfetd(ck_cover, 0)
-
-    assert num_intervals == num_intervals_expected
-    assert et_start_pointing == et_start_expected
-    assert et_end_pointing == et_end_expected
-
-    et_times = _get_et_times(et_start_pointing, et_end_pointing)
-
-    spiceypy.furnsh(str(tmp_path / "imap_pointing_frame.bc"))
-    rotation_matrix_1 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[100])
-    rotation_matrix_2 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[1000])
-
-    assert np.array_equal(rotation_matrix_1, rotation_matrix_2)

imap_processing/tests/spice/test_pointing_frame.py

@@ -0,0 +1,185 @@
+"""Test coverage for imap_processing.spice.repoint.py"""
+
+import numpy as np
+import pytest
+import spiceypy
+
+from imap_processing.spice.pointing_frame import (
+    _average_quaternions,
+    _create_rotation_matrix,
+    create_pointing_frame,
+)
+
+
+@pytest.fixture
+def pointing_frame_kernels(spice_test_data_path):
+    """List SPICE kernels."""
+    required_kernels = [
+        "imap_science_0001.tf",
+        "imap_sclk_0000.tsc",
+        "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
+        "imap_wkcp.tf",
+        "naif0012.tls",
+    ]
+    kernels = [str(spice_test_data_path / kernel) for kernel in required_kernels]
+    return kernels
+
+
+@pytest.fixture
+def et_times(pointing_frame_kernels):
+    """Tests get_et_times function."""
+    spiceypy.furnsh(pointing_frame_kernels)
+
+    ck_kernel, _, _, _ = spiceypy.kdata(0, "ck")
+    ck_cover = spiceypy.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
+    et_start, et_end = spiceypy.wnfetd(ck_cover, 0)
+
+    # 1 spin/15 seconds; 10 quaternions / spin.
+    num_samples = (et_end - et_start) / 15 * 10
+    # There were rounding errors when using spiceypy.pxform so np.ceil and np.floor
+    # were used to ensure the start and end times were within the ck range.
+    et_times = np.linspace(
+        np.ceil(et_start * 1e6) / 1e6, np.floor(et_end * 1e6) / 1e6, int(num_samples)
+    )
+
+    return et_times
+
+
+@pytest.fixture
+def fake_repoint_data(monkeypatch, spice_test_data_path):
+    """Generate fake spin dataframe for testing"""
+    fake_repoint_path = spice_test_data_path / "fake_repoint_data.csv"
+    monkeypatch.setenv("REPOINT_DATA_FILEPATH", str(fake_repoint_path))
+    return fake_repoint_path
+
+
+def test_average_quaternions(et_times, pointing_frame_kernels):
+    """Tests average_quaternions function."""
+    spiceypy.furnsh(pointing_frame_kernels)
+    q_avg = _average_quaternions(et_times)
+
+    # Generated from MATLAB code results
+    q_avg_expected = np.array([-0.6611, 0.4981, -0.5019, -0.2509])
+    np.testing.assert_allclose(q_avg, q_avg_expected, atol=1e-4)
+
+
+def test_create_rotation_matrix(et_times, pointing_frame_kernels):
+    """Tests create_rotation_matrix function."""
+    spiceypy.furnsh(pointing_frame_kernels)
+    rotation_matrix = _create_rotation_matrix(et_times)
+    q_avg = _average_quaternions(et_times)
+    z_avg = spiceypy.q2m(list(q_avg))[:, 2]
+
+    rotation_matrix_expected = np.array(
+        [[0.0000, 0.0000, 1.0000], [0.9104, -0.4136, 0.0000], [0.4136, 0.9104, 0.0000]]
+    )
+    z_avg_expected = np.array([0.4136, 0.9104, 0.0000])
+
+    np.testing.assert_allclose(z_avg, z_avg_expected, atol=1e-4)
+    np.testing.assert_allclose(rotation_matrix, rotation_matrix_expected, atol=1e-4)
+
+
+def test_create_pointing_frame(
+    spice_test_data_path, pointing_frame_kernels, tmp_path, et_times, fake_repoint_data
+):
+    """Tests create_pointing_frame function."""
+
+    # This is how the repoint data is generated.
+    # We will use fake data for now to match the coverage of the attitude kernel.
+    # repoint_df = get_repoint_data()
+    # repoint_start = repoint_df["repoint_end_met"].values[:-1]
+    # repoint_end_met = repoint_df["repoint_start_met"].values[1:]
+
+    spiceypy.kclear()
+    spiceypy.furnsh(pointing_frame_kernels)
+    create_pointing_frame(
+        tmp_path / "imap_dps.bc",
+        spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
+        np.array([486432004]),  # repoint_df["repoint_start_met"].values
+        np.array([486439201]),  # repoint_df["repoint_end_met"].values
+    )
+
+    # After imap_dps.bc has been created.
+    dps_kernel = str(tmp_path / "imap_dps.bc")
+
+    spiceypy.furnsh(dps_kernel)
+    rotation_matrix_1 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 100)
+    rotation_matrix_2 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 1000)
+
+    # All the rotation matrices should be the same.
+    assert np.array_equal(rotation_matrix_1, rotation_matrix_2)
+
+    # Nick Dutton's MATLAB code result
+    rotation_matrix_expected = np.array(
+        [[0.0000, 0.0000, 1.0000], [0.9104, -0.4136, 0.0000], [0.4136, 0.9104, 0.0000]]
+    )
+    np.testing.assert_allclose(rotation_matrix_1, rotation_matrix_expected, atol=1e-4)
+
+    # Verify imap_dps.bc has been created.
+    assert (tmp_path / "imap_dps.bc").exists()
+
+    # Tests error handling when incorrect kernel is loaded.
+    spiceypy.furnsh(pointing_frame_kernels)
+    with pytest.raises(
+        ValueError, match="Error: Expected CK kernel badname_kernel.bc"
+    ):  # Replace match string with expected error message
+        create_pointing_frame(
+            tmp_path / "imap_dps.bc",
+            "badname_kernel.bc",
+            np.array([486432004]),
+            np.array([486439201]),
+        )
+
+
+def test_multiple_pointings(pointing_frame_kernels, spice_test_data_path, tmp_path):
+    """Tests create_pointing_frame function with multiple pointing kernels."""
+    spiceypy.furnsh(pointing_frame_kernels)
+
+    create_pointing_frame(
+        tmp_path / "imap_pointing_frame.bc",
+        spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc",
+        np.array([486432003]),  # repoint_df["repoint_start_met"].values
+        np.array([486439201]),  # repoint_df["repoint_end_met"].values
+    )
+
+    ck_cover_pointing = spiceypy.ckcov(
+        str(tmp_path / "imap_pointing_frame.bc"),
+        -43901,
+        True,
+        "INTERVAL",
+        0,
+        "TDB",
+    )
+    num_intervals = spiceypy.wncard(ck_cover_pointing)
+    et_start_pointing, et_end_pointing = spiceypy.wnfetd(ck_cover_pointing, 0)
+
+    ck_cover = spiceypy.ckcov(
+        str(spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc"),
+        -43000,
+        True,
+        "INTERVAL",
+        0,
+        "TDB",
+    )
+    num_intervals_expected = spiceypy.wncard(ck_cover)
+    et_start_expected, et_end_expected = spiceypy.wnfetd(ck_cover, 0)
+
+    assert num_intervals == num_intervals_expected
+    np.testing.assert_allclose(et_start_pointing, et_start_expected, atol=1e-2)
+    np.testing.assert_allclose(et_end_pointing, et_end_expected, atol=1e-2)
+
+    # 1 spin/15 seconds; 10 quaternions / spin.
+    num_samples = (et_end_pointing - et_start_pointing) / 15 * 10
+    # There were rounding errors when using spiceypy.pxform so np.ceil and np.floor
+    # were used to ensure the start and end times were within the ck range.
+    et_times = np.linspace(
+        np.ceil(et_start_pointing * 1e6) / 1e6,
+        np.floor(et_end_pointing * 1e6) / 1e6,
+        int(num_samples),
+    )
+
+    spiceypy.furnsh(str(tmp_path / "imap_pointing_frame.bc"))
+    rotation_matrix_1 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[100])
+    rotation_matrix_2 = spiceypy.pxform("ECLIPJ2000", "IMAP_DPS", et_times[1000])
+
+    assert np.array_equal(rotation_matrix_1, rotation_matrix_2)