imap-processing 0.6.0__py3-none-any.whl

imap_processing/tests/spice/test_data/naif0012.tls

@@ -0,0 +1,150 @@
+KPL/LSK
+
+
+LEAPSECONDS KERNEL FILE
+===========================================================================
+
+Modifications:
+--------------
+
+2016, Jul. 14   NJB  Modified file to account for the leapsecond that
+                     will occur on December 31, 2016.
+
+2015, Jan. 5    NJB  Modified file to account for the leapsecond that
+                     will occur on June 30, 2015.
+
+2012, Jan. 5    NJB  Modified file to account for the leapsecond that
+                     will occur on June 30, 2012.
+
+2008, Jul. 7    NJB  Modified file to account for the leapsecond that
+                     will occur on December 31, 2008.
+
+2005, Aug. 3    NJB  Modified file to account for the leapsecond that
+                     will occur on December 31, 2005.
+
+1998, Jul  17   WLT  Modified file to account for the leapsecond that
+                     will occur on December 31, 1998.
+
+1997, Feb  22   WLT  Modified file to account for the leapsecond that
+                     will occur on June 30, 1997.
+
+1995, Dec  14   KSZ  Corrected date of last leapsecond from 1-1-95
+                     to 1-1-96.
+
+1995, Oct  25   WLT  Modified file to account for the leapsecond that
+                     will occur on Dec 31, 1995.
+
+1994, Jun  16   WLT  Modified file to account for the leapsecond on
+                     June 30, 1994.
+
+1993, Feb. 22  CHA   Modified file to account for the leapsecond on
+                     June 30, 1993.
+
+1992, Mar. 6   HAN   Modified file to account for the leapsecond on
+                     June 30, 1992.
+
+1990, Oct. 8   HAN   Modified file to account for the leapsecond on
+                     Dec. 31, 1990.
+
+
+Explanation:
+------------
+
+The contents of this file are used by the routine DELTET to compute the
+time difference
+
+[1]       DELTA_ET  =  ET - UTC
+
+the increment to be applied to UTC to give ET.
+
+The difference between UTC and TAI,
+
+[2]       DELTA_AT  =  TAI - UTC
+
+is always an integral number of seconds. The value of DELTA_AT was 10
+seconds in January 1972, and increases by one each time a leap second
+is declared. Combining [1] and [2] gives
+
+[3]       DELTA_ET  =  ET - (TAI - DELTA_AT)
+
+                    =  (ET - TAI) + DELTA_AT
+
+The difference (ET - TAI) is periodic, and is given by
+
+[4]       ET - TAI  =  DELTA_T_A  + K sin E
+
+where DELTA_T_A and K are constant, and E is the eccentric anomaly of the
+heliocentric orbit of the Earth-Moon barycenter. Equation [4], which ignores
+small-period fluctuations, is accurate to about 0.000030 seconds.
+
+The eccentric anomaly E is given by
+
+[5]       E = M + EB sin M
+
+where M is the mean anomaly, which in turn is given by
+
+[6]       M = M  +  M t
+               0     1
+
+where t is the number of ephemeris seconds past J2000.
+
+Thus, in order to compute DELTA_ET, the following items are necessary.
+
+          DELTA_TA
+          K
+          EB
+          M0
+          M1
+          DELTA_AT      after each leap second.
+
+The numbers, and the formulation, are taken from the following sources.
+
+     1) Moyer, T.D., Transformation from Proper Time on Earth to
+        Coordinate Time in Solar System Barycentric Space-Time Frame
+        of Reference, Parts 1 and 2, Celestial Mechanics 23 (1981),
+        33-56 and 57-68.
+
+     2) Moyer, T.D., Effects of Conversion to the J2000 Astronomical
+        Reference System on Algorithms for Computing Time Differences
+        and Clock Rates, JPL IOM 314.5--942, 1 October 1985.
+
+The variable names used above are consistent with those used in the
+Astronomical Almanac.
+
+\begindata
+
+DELTET/DELTA_T_A       =   32.184
+DELTET/K               =    1.657D-3
+DELTET/EB              =    1.671D-2
+DELTET/M               = (  6.239996D0   1.99096871D-7 )
+
+DELTET/DELTA_AT        = ( 10,   @1972-JAN-1
+                           11,   @1972-JUL-1
+                           12,   @1973-JAN-1
+                           13,   @1974-JAN-1
+                           14,   @1975-JAN-1
+                           15,   @1976-JAN-1
+                           16,   @1977-JAN-1
+                           17,   @1978-JAN-1
+                           18,   @1979-JAN-1
+                           19,   @1980-JAN-1
+                           20,   @1981-JUL-1
+                           21,   @1982-JUL-1
+                           22,   @1983-JUL-1
+                           23,   @1985-JUL-1
+                           24,   @1988-JAN-1
+                           25,   @1990-JAN-1
+                           26,   @1991-JAN-1
+                           27,   @1992-JUL-1
+                           28,   @1993-JUL-1
+                           29,   @1994-JUL-1
+                           30,   @1996-JAN-1
+                           31,   @1997-JUL-1
+                           32,   @1999-JAN-1
+                           33,   @2006-JAN-1
+                           34,   @2009-JAN-1
+                           35,   @2012-JUL-1
+                           36,   @2015-JUL-1
+                           37,   @2017-JAN-1 )
+
+\begintext

imap_processing/tests/spice/test_geometry.py

@@ -0,0 +1,214 @@
+"""Tests coverage for imap_processing/spice/geometry.py"""
+
+import numpy as np
+import pandas as pd
+import pytest
+import spiceypy as spice
+
+from imap_processing.spice.geometry import (
+    SpiceBody,
+    SpiceFrame,
+    frame_transform,
+    get_rotation_matrix,
+    get_spacecraft_spin_phase,
+    get_spin_data,
+    imap_state,
+)
+
+
+@pytest.mark.parametrize(
+    "et",
+    [
+        798033670,
+        np.linspace(798033670, 798033770),
+    ],
+)
+def test_imap_state(et, use_test_metakernel):
+    """Test coverage for imap_state()"""
+    state = imap_state(et, observer=SpiceBody.EARTH)
+    if hasattr(et, "__len__"):
+        np.testing.assert_array_equal(state.shape, (len(et), 6))
+    else:
+        assert state.shape == (6,)
+
+
+@pytest.mark.external_kernel()
+@pytest.mark.metakernel("imap_ena_sim_metakernel.template")
+def test_imap_state_ecliptic(use_test_metakernel):
+    """Tests retrieving IMAP state in the ECLIPJ2000 frame"""
+    state = imap_state(798033670)
+    assert state.shape == (6,)
+
+
+@pytest.mark.usefixtures("_set_spin_data_filepath")
+@pytest.mark.parametrize(
+    "query_met_times, expected_type, expected_length",
+    [
+        (453051323.0, float, None),  # Scalar test
+        (np.array([453051323.0, 453051324.0]), float, 2),  # Array test
+        (np.array([]), None, 0),  # Empty array test
+        (np.array([453051323.0]), float, 1),  # Single element array test
+        # 452995203.0 is a midnight time which should have invalid spin
+        # phase and period flags on in the spin data file. The spin phase
+        # should be invalid.
+        (452995203.0, np.nan, None),
+        # Test that five minutes after midnight is also invalid since
+        # first 10 minutes after midnight are invalid.
+        (np.arange(452995203.0, 452995203.0 + 300), np.nan, 300),
+        (
+            [453011323.0],
+            np.nan,
+            1,
+        ),  # Test for spin phase that's outside of spin phase range
+        (
+            453011323.0,
+            np.nan,
+            None,
+        ),  # Test for spin phase that's outside of spin phase range
+    ],
+)
+def test_get_spacecraft_spin_phase(query_met_times, expected_type, expected_length):
+    """Test get_spacecraft_spin_phase() with generated spin data."""
+    # Call the function
+    spin_phases = get_spacecraft_spin_phase(query_met_times=query_met_times)
+
+    # Check the type of the result
+    if expected_type is np.nan:
+        assert np.isnan(spin_phases).all(), "Spin phase must be NaN."
+    elif isinstance(expected_type, float):
+        assert isinstance(spin_phases, float), "Spin phase must be a float."
+
+    # If the expected length is None, it means we're testing a scalar
+    if expected_length is None:
+        assert isinstance(spin_phases, float), "Spin phase must be a float."
+    else:
+        assert (
+            len(spin_phases) == expected_length
+        ), f"Spin phase must have length {expected_length} for array input."
+
+
+@pytest.mark.usefixtures("_set_spin_data_filepath")
+def test_get_spin_data():
+    """Test get_spin_data() with generated spin data."""
+
+    spin_data = get_spin_data()
+
+    (
+        np.testing.assert_array_equal(spin_data["spin_number"], np.arange(5761)),
+        "One day should have 5,761 records of 15 seconds when including end_met.",
+    )
+    assert isinstance(spin_data, pd.DataFrame), "Return type must be pandas.DataFrame."
+
+    assert set(spin_data.columns) == {
+        "spin_number",
+        "spin_start_sec",
+        "spin_start_subsec",
+        "spin_period_sec",
+        "spin_period_valid",
+        "spin_phase_valid",
+        "spin_period_source",
+        "thruster_firing",
+        "spin_start_time",
+    }, "Spin data must have the specified fields."
+
+
+def test_frame_transform(furnish_kernels):
+    """Test transformation of vectors from one frame to another, with the option
+    to normalize the result."""
+    # This test requires an IMAP attitude kernel and pointing (despun) kernel
+    kernels = [
+        "naif0012.tls",
+        "imap_wkcp.tf",
+        "imap_science_0001.tf",
+        "sim_1yr_imap_attitude.bc",
+        "sim_1yr_imap_pointing_frame.bc",
+    ]
+    with furnish_kernels(kernels):
+        # Test single et and position calculation
+        et_0 = spice.utc2et("2025-04-30T12:00:00.000")
+        position = np.arange(3) + 1
+        result_0 = frame_transform(
+            et_0, position, SpiceFrame.IMAP_ULTRA_45, SpiceFrame.IMAP_DPS
+        )
+        # compare against pure SPICE calculation
+        rotation_matrix = spice.pxform(
+            SpiceFrame.IMAP_ULTRA_45.name, SpiceFrame.IMAP_DPS.name, et_0
+        )
+        spice_result = spice.mxv(rotation_matrix, position)
+        np.testing.assert_allclose(result_0, spice_result, atol=1e-12)
+
+        # test multiple et and position calculation
+        ets = np.array([et_0, et_0 + 10])
+        positions = np.array([[1, 1, 1], [1, 2, 3]])
+        vec_result = frame_transform(
+            ets, positions, SpiceFrame.IMAP_HI_90, SpiceFrame.IMAP_DPS
+        )
+
+        assert vec_result.shape == (2, 3)
+        # compare with direct spice calculations
+        for et, pos, result in zip(ets, positions, vec_result):
+            rotation_matrix = spice.pxform(
+                SpiceFrame.IMAP_HI_90.name, SpiceFrame.IMAP_DPS.name, et
+            )
+            spice_result = spice.mxv(rotation_matrix, pos)
+            np.testing.assert_allclose(result, spice_result, atol=1e-12)
+
+
+def test_frame_transform_exceptions():
+    """Test that the proper exceptions get raised when input arguments are invalid."""
+    with pytest.raises(
+        ValueError, match="Position vectors with one dimension must have 3 elements."
+    ):
+        frame_transform(
+            0, np.arange(4), SpiceFrame.IMAP_SPACECRAFT, SpiceFrame.IMAP_CODICE
+        )
+    with pytest.raises(
+        ValueError,
+        match="Ephemeris time must be float when single position vector is provided.",
+    ):
+        frame_transform(
+            np.asarray(0),
+            np.array([1, 0, 0]),
+            SpiceFrame.ECLIPJ2000,
+            SpiceFrame.IMAP_HIT,
+        )
+    with pytest.raises(ValueError, match="Invalid position shape: "):
+        frame_transform(
+            np.arange(2),
+            np.arange(4).reshape((2, 2)),
+            SpiceFrame.ECLIPJ2000,
+            SpiceFrame.IMAP_HIT,
+        )
+    with pytest.raises(
+        ValueError,
+        match="Mismatch in number of position vectors and Ephemeris times provided.",
+    ):
+        frame_transform(
+            np.arange(2),
+            np.arange(9).reshape((3, 3)),
+            SpiceFrame.ECLIPJ2000,
+            SpiceFrame.IMAP_HIT,
+        )
+
+
+def test_get_rotation_matrix(furnish_kernels):
+    """Test coverage for get_rotation_matrix()."""
+    kernels = [
+        "naif0012.tls",
+        "imap_wkcp.tf",
+        "imap_science_0001.tf",
+        "sim_1yr_imap_attitude.bc",
+        "sim_1yr_imap_pointing_frame.bc",
+    ]
+    with furnish_kernels(kernels):
+        et = spice.utc2et("2025-09-30T12:00:00.000")
+        # test input of float
+        rotation = get_rotation_matrix(
+            et, SpiceFrame.IMAP_IDEX, SpiceFrame.IMAP_SPACECRAFT
+        )
+        assert rotation.shape == (3, 3)
+        # test array of et input
+        rotation = get_rotation_matrix(
+            np.arange(10) + et, SpiceFrame.IMAP_IDEX, SpiceFrame.IMAP_SPACECRAFT
+        )
+        assert rotation.shape == (10, 3, 3)

imap_processing/tests/spice/test_kernels.py

@@ -0,0 +1,272 @@
+"""Tests coverage for imap_processing/spice/kernels.py"""
+
+import numpy as np
+import pytest
+import spiceypy as spice
+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."""
+    spice.furnsh(pointing_frame_kernels)
+
+    ck_kernel, _, _, _ = spice.kdata(0, "ck")
+    ck_cover = spice.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
+    et_start, et_end = spice.wnfetd(ck_cover, 0)
+    et_times = _get_et_times(et_start, et_end)
+
+    return et_times
+
+
+@ensure_spice
+def single_wrap_et2utc(et, fmt, prec):
+    """Directly decorate a spice function with ensure_spice for use in tests"""
+    return spice.et2utc(et, fmt, prec)
+
+
+@ensure_spice
+def double_wrap_et2utc(et, fmt, prec):
+    """Decorate a spice function twice with ensure_spice for use in tests. This
+    simulates some decorated outer functions that call lower level functions
+    that are already decorated."""
+    return single_wrap_et2utc(et, fmt, prec)
+
+
+@ensure_spice(time_kernels_only=True)
+def single_wrap_et2utc_tk_only(et, fmt, prec):
+    """Directly wrap a spice function with optional time_kernels_only set True"""
+    return spice.et2utc(et, fmt, prec)
+
+
+@ensure_spice(time_kernels_only=True)
+def double_wrap_et2utc_tk_only(et, fmt, prec):
+    """Decorate a spice function twice with ensure_spice for use in tests. This
+    simulates some decorated outer functions that call lower level functions
+    that are already decorated."""
+    return single_wrap_et2utc(et, fmt, prec)
+
+
+@pytest.mark.parametrize(
+    "func",
+    [
+        single_wrap_et2utc,
+        single_wrap_et2utc_tk_only,
+        double_wrap_et2utc,
+        double_wrap_et2utc_tk_only,
+    ],
+)
+def test_ensure_spice_emus_mk_path(func, use_test_metakernel):
+    """Test functionality of ensure spice with SPICE_METAKERNEL set"""
+    assert func(577365941.184, "ISOC", 3) == "2018-04-18T23:24:31.998"
+
+
+@pytest.mark.xfail(reason="Fix this test once we add metakernel in the imap_cli")
+@pytest.mark.usefixtures("_unset_metakernel_path")
+def test_ensure_spice_time_kernels():
+    """Test functionality of ensure spice with timekernels set"""
+    wrapped = ensure_spice(spice.et2utc, time_kernels_only=True)
+    # TODO: Update/remove this test when a decision has been made about
+    #   whether IMAP will use the time_kernels_only functionality and the
+    #   ensure_spice decorator has been update.
+    with pytest.raises(NotImplementedError):
+        _ = wrapped(577365941.184, "ISOC", 3) == "2018-04-18T23:24:31.998"
+
+
+@pytest.mark.xfail(reason="Fix this test once we add metakernel in the imap_cli")
+@pytest.mark.usefixtures("_unset_metakernel_path")
+def test_ensure_spice_key_error():
+    """Test functionality of ensure spice when all branches fail"""
+    wrapped = ensure_spice(spice.et2utc)
+    # The ensure_spice decorator should raise a SpiceyError when all attempts to
+    # furnish a set of kernels with sufficient coverage for the spiceypy
+    # 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."""
+    spice.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."""
+    spice.furnsh(pointing_frame_kernels)
+    rotation_matrix = _create_rotation_matrix(et_times)
+    q_avg = _average_quaternions(et_times)
+    z_avg = spice.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."""
+    spice.kclear()
+    spice.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")
+
+    spice.furnsh(dps_kernel)
+    rotation_matrix_1 = spice.pxform("ECLIPJ2000", "IMAP_DPS", et_times[0] + 100)
+    rotation_matrix_2 = spice.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.
+    spice.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."""
+    spice.furnsh(pointing_frame_kernels)
+
+    ck_kernel, _, _, _ = spice.kdata(0, "ck")
+    ck_cover = spice.ckcov(ck_kernel, -43000, True, "INTERVAL", 0, "TDB")
+    et_start, et_end = spice.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."""
+    spice.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 = spice.ckcov(
+        str(tmp_path / "imap_dps.bc"), -43901, True, "INTERVAL", 0, "TDB"
+    )
+    num_intervals = spice.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 = spice.ckcov(
+        str(tmp_path / "imap_dps.bc"), -43901, True, "INTERVAL", 0, "TDB"
+    )
+    num_intervals = spice.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."""
+    spice.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 = spice.ckcov(
+        str(tmp_path / "imap_pointing_frame.bc"),
+        -43901,
+        True,
+        "INTERVAL",
+        0,
+        "TDB",
+    )
+    num_intervals = spice.wncard(ck_cover_pointing)
+    et_start_pointing, et_end_pointing = spice.wnfetd(ck_cover_pointing, 0)
+
+    ck_cover = spice.ckcov(
+        str(spice_test_data_path / "imap_sim_ck_2hr_2secsampling_with_nutation.bc"),
+        -43000,
+        True,
+        "INTERVAL",
+        0,
+        "TDB",
+    )
+    num_intervals_expected = spice.wncard(ck_cover)
+    et_start_expected, et_end_expected = spice.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)
+
+    spice.furnsh(str(tmp_path / "imap_pointing_frame.bc"))
+    rotation_matrix_1 = spice.pxform("ECLIPJ2000", "IMAP_DPS", et_times[100])
+    rotation_matrix_2 = spice.pxform("ECLIPJ2000", "IMAP_DPS", et_times[1000])
+
+    assert np.array_equal(rotation_matrix_1, rotation_matrix_2)

imap_processing/tests/spice/test_time.py

@@ -0,0 +1,35 @@
+"""Tests coverage for imap_processing/spice/time.py"""
+
+import numpy as np
+import pytest
+import spiceypy as spice
+
+from imap_processing.spice import IMAP_SC_ID
+from imap_processing.spice.time import _sct2e_wrapper, met_to_j2000ns
+
+
+def test_met_to_j2000ns(furnish_time_kernels):
+    """Test coverage for met_to_j2000ns function."""
+    utc = "2026-01-01T00:00:00.125"
+    et = spice.str2et(utc)
+    sclk_str = spice.sce2s(IMAP_SC_ID, et)
+    seconds, ticks = sclk_str.split("/")[1].split(":")
+    # There is some floating point error calculating tick duration from 1 clock
+    # tick so average over many clock ticks for better accuracy
+    spice_tick_duration = (
+        spice.sct2e(IMAP_SC_ID, 1e12) - spice.sct2e(IMAP_SC_ID, 0)
+    ) / 1e12
+    met = float(seconds) + float(ticks) * spice_tick_duration
+    j2000ns = met_to_j2000ns(met)
+    assert j2000ns.dtype == np.int64
+    np.testing.assert_array_equal(j2000ns, np.array(et * 1e9))
+
+
+@pytest.mark.parametrize("sclk_ticks", [0.0, np.arange(10)])
+def test_sct2e_wrapper(sclk_ticks):
+    """Test for `_sct2e_wrapper` function."""
+    et = _sct2e_wrapper(sclk_ticks)
+    if isinstance(sclk_ticks, float):
+        assert isinstance(et, float)
+    else:
+        assert len(et) == len(sclk_ticks)

imap_processing/tests/swapi/conftest.py

@@ -0,0 +1,16 @@
+import pytest
+
+
+@pytest.fixture(scope="session")
+def swapi_test_data_path(imap_tests_path):
+    return imap_tests_path / "swapi/"
+
+
+@pytest.fixture(scope="session")
+def swapi_l0_test_data_path(swapi_test_data_path):
+    return swapi_test_data_path / "l0_data/"
+
+
+@pytest.fixture(scope="session")
+def swapi_l0_validation_data_path(swapi_test_data_path):
+    return swapi_test_data_path / "l0_validation_data/"