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

imap_processing/tests/spacecraft/test_quaternions.py

@@ -7,7 +7,7 @@ import xarray as xr
 from imap_processing.spacecraft import quaternions
 
 
-@pytest.fixture()
+@pytest.fixture
 def l1a_quaternion_ds():
     time = np.arange(100)
     data = np.linspace(-0.1, 0.1, 100)

imap_processing/tests/spice/test_data/fake_repoint_data.csv

@@ -1,5 +1,5 @@
 # This is a fake csv file for the sole purpose of testing repoint module functions
-repoint_start_time,repoint_end_time,repoint_id
-0,5,0
-15,20,1
-25,30,2
+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),
@@ -287,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()."""

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)

imap_processing/tests/spice/test_repoint.py

@@ -7,7 +7,7 @@ import pytest
 from imap_processing.spice.repoint import get_repoint_data, interpolate_repoint_data
 
 
-@pytest.fixture()
+@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"
@@ -16,12 +16,18 @@ def fake_repoint_data(monkeypatch, spice_test_data_path):
 
 
 def test_get_repoint_data(fake_repoint_data):
-    """Test coverarge for get_repoint_data function."""
+    """Test coverage for get_repoint_data function."""
     repoint_df = get_repoint_data()
     assert isinstance(repoint_df, pd.DataFrame)
     assert set(repoint_df.columns) == {
-        "repoint_start_time",
-        "repoint_end_time",
+        "repoint_start_sec_sclk",
+        "repoint_start_subsec_sclk",
+        "repoint_start_met",
+        "repoint_start_utc",
+        "repoint_end_sec_sclk",
+        "repoint_end_subsec_sclk",
+        "repoint_end_met",
+        "repoint_end_utc",
         "repoint_id",
     }
 
@@ -36,10 +42,14 @@ def test_spin_data_no_table():
 
 def test_interpolate_repoint_data(fake_repoint_data):
     """Test coverage for get_repoint_data function."""
-    query_times = np.array([0, 6, 32])
+    query_times = np.array([0.1, 6, 32])
     expected_vals = {
-        "repoint_start_time": np.array([0, 0, 25]),
-        "repoint_end_time": np.array([5, 5, 30]),
+        "repoint_start_sec_sclk": np.array([0, 0, 25]),
+        "repoint_start_subsec_sclk": np.array([100000, 100000, 300000]),
+        "repoint_start_met": np.array([0.1, 0.1, 25.3]),
+        "repoint_end_sec_sclk": np.array([5, 5, 30]),
+        "repoint_end_subsec_sclk": np.array([100000, 100000, 300000]),
+        "repoint_end_met": np.array([5.1, 5.1, 30.3]),
         "repoint_id": np.array([0, 0, 2]),
         "repoint_in_progress": np.array([True, False, False]),
     }
@@ -57,7 +67,7 @@ def test_interpolate_repoint_data(fake_repoint_data):
             "1 query times are before",
         ),  # Query times before start of table
         (
-            np.array([0, 24 * 60 * 60 + 26]),
+            np.array([1, 24 * 60 * 60 + 26]),
             "1 query times are after",
         ),  # Query times after end of valid range
     ],
@@ -81,12 +91,12 @@ def test_interpolate_repoint_data_with_use_fake_fixture(use_fake_repoint_data_fo
 
     # Expected repoint_start_times are the seeded start times array repeated twice
     np.testing.assert_array_equal(
-        repoint_df["repoint_start_time"].values,
+        repoint_df["repoint_start_met"].values,
         np.concat([repoint_start_times, repoint_start_times]),
     )
     # Expected repoint_end_times are the seeded start times + 15 minutes
     np.testing.assert_array_equal(
-        repoint_df["repoint_end_time"].values,
+        repoint_df["repoint_end_met"].values,
         np.concat([repoint_start_times + 15 * 60, repoint_start_times + 15 * 60]),
     )
     # Expected repoint_id

imap_processing/tests/spice/test_spin.py

@@ -14,7 +14,7 @@ from imap_processing.spice.spin import (
 )
 
 
-@pytest.fixture()
+@pytest.fixture
 def fake_spin_data(monkeypatch, spice_test_data_path):
     """Generate fake spin dataframe for testing"""
     fake_spin_path = spice_test_data_path / "fake_spin_data.csv"
@@ -27,13 +27,51 @@ def fake_spin_data(monkeypatch, spice_test_data_path):
     [
         (
             15,
-            [[1, 15, 0, 15.0, 1, 1, 0, 0, 15.0, 0.0]],
+            [
+                [
+                    1,
+                    15,
+                    0,
+                    "2024-04-11 00:00:15.000000",
+                    15.0,
+                    True,
+                    1,
+                    0,
+                    False,
+                    15.0,
+                    0.0,
+                ]
+            ],
         ),  # Scalar test at spin start time
         (
             np.array([15.1, 30.2]),
             [
-                [1, 15, 0, 15.0, 1, 1, 0, 0, 15.0, 0.1 / 15],
-                [2, 30, 0, 15.0, 1, 1, 0, 0, 30.0, 0.2 / 15],
+                [
+                    1,
+                    15,
+                    0,
+                    "2024-04-11 00:00:15.000000",
+                    15.0,
+                    True,
+                    1,
+                    0,
+                    False,
+                    15.0,
+                    0.1 / 15,
+                ],
+                [
+                    2,
+                    30,
+                    0,
+                    "2024-04-11 00:00:30.000000",
+                    15.0,
+                    True,
+                    1,
+                    0,
+                    False,
+                    30.0,
+                    0.2 / 15,
+                ],
             ],
         ),  # Array test
     ],
@@ -45,7 +83,9 @@ def test_interpolate_spin_data(query_met_times, expected, fake_spin_data):
 
     # Test the value
     for i_row, row in enumerate(expected):
-        np.testing.assert_array_almost_equal(spin_df.iloc[i_row].tolist(), row)
+        pd.testing.assert_series_equal(
+            spin_df.iloc[i_row], pd.Series(row), check_index=False, check_names=False
+        )
 
 
 @pytest.mark.parametrize(
@@ -144,21 +184,22 @@ def test_get_spin_data(use_fake_spin_data_for_time):
 
     assert set(spin_data.columns) == {
         "spin_number",
-        "spin_start_sec",
-        "spin_start_subsec",
+        "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",
-        "spin_start_time",
+        "spin_start_met",
     }, "Spin data must have the specified fields."
 
 
 @pytest.mark.parametrize(
     "instrument",
     [
-        SpiceFrame.IMAP_LO,
+        SpiceFrame.IMAP_LO_BASE,
         SpiceFrame.IMAP_HI_45,
         SpiceFrame.IMAP_HI_90,
         SpiceFrame.IMAP_ULTRA_45,

imap_processing/tests/spice/test_time.py

@@ -7,6 +7,7 @@ import spiceypy
 from imap_processing.spice import IMAP_SC_ID
 from imap_processing.spice.time import (
     TICK_DURATION,
+    epoch_to_doy,
     et_to_utc,
     met_to_datetime64,
     met_to_sclkticks,
@@ -202,3 +203,16 @@ def test_et_to_utc(furnish_time_kernels):
     )
     actual_utc_array = et_to_utc(array_of_et)
     assert np.array_equal(expected_utc_array, actual_utc_array)
+
+
+def test_epoch_to_doy():
+    """Tests that epoch_to_doy() produces expected doys."""
+    epoch = 756196488384840064
+    et = epoch * 1e-9
+    # Extract DOY from output date string
+    expected_doy = int(et_to_utc(et, "D").split("//")[0].split("-")[1])
+    example_epoch = np.full(10, epoch)
+    doy = epoch_to_doy(example_epoch)
+
+    # Assert that every calculated DOY is equal to the DOY extracted from the string.
+    assert np.all(doy == expected_doy)