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

imap_processing/tests/spice/test_spin.py

@@ -0,0 +1,184 @@
+from contextlib import nullcontext as does_not_raise
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from imap_processing.spice.geometry import SpiceFrame
+from imap_processing.spice.spin import (
+    get_instrument_spin_phase,
+    get_spacecraft_spin_phase,
+    get_spin_angle,
+    get_spin_data,
+    interpolate_spin_data,
+)
+
+
+@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"
+    monkeypatch.setenv("SPIN_DATA_FILEPATH", str(fake_spin_path))
+    return fake_spin_path
+
+
+@pytest.mark.parametrize(
+    "query_met_times, expected",
+    [
+        (
+            15,
+            [[1, 15, 0, 15.0, 1, 1, 0, 0, 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],
+            ],
+        ),  # Array test
+    ],
+)
+def test_interpolate_spin_data(query_met_times, expected, fake_spin_data):
+    """Test interpolate_spin_data() with generated spin data."""
+    # Call the function
+    spin_df = interpolate_spin_data(query_met_times=query_met_times)
+
+    # Test the value
+    for i_row, row in enumerate(expected):
+        np.testing.assert_array_almost_equal(spin_df.iloc[i_row].tolist(), row)
+
+
+@pytest.mark.parametrize(
+    "query_met_times, expected",
+    [
+        (15, 0.0),  # Scalar test
+        (np.array([15.1, 30.1]), np.array([0.1 / 15, 0.1 / 15])),  # Array test
+        (np.array([50]), np.array([5 / 15])),  # Single element array test
+        # The first spin has thruster firing set, but should return valid value
+        (5.0, 5 / 15),
+        # Test invalid spin period flag causes nan
+        (106.0, np.nan),
+        # Test invalid spin phase flag causes nans
+        (np.array([121, 122, 123]), np.full(3, np.nan)),
+        # Test that invalid spin period causes nans
+        (np.array([110, 111]), np.full(2, np.nan)),
+        # Test for time in missing spin
+        (65, np.nan),
+        (np.array([65.1, 66]), np.full(2, np.nan)),
+        # Combined test
+        (
+            np.array([7.5, 30, 61, 75, 106, 121, 136]),
+            np.array([0.5, 0, np.nan, 0, np.nan, np.nan, 1 / 15]),
+        ),
+        # Test that this spin phase range [0, 1) is valid which
+        # is same as [0, 360) degree angle. At 15 seconds the spacecraft
+        # has completed a full spin
+        (np.array([0, 15]), np.zeros(2)),
+    ],
+)
+def test_get_spacecraft_spin_phase(query_met_times, expected, fake_spin_data):
+    """Test get_spacecraft_spin_phase() with generated spin data."""
+    # Call the function
+    spin_phases = get_spacecraft_spin_phase(query_met_times=query_met_times)
+
+    # Test the returned type
+    if isinstance(expected, float):
+        assert isinstance(spin_phases, float), "Spin phase must be a float."
+    elif expected is None:
+        assert len(spin_phases) == 0, "Spin phase must be empty."
+    else:
+        assert spin_phases.shape == expected.shape
+    # Test the value
+    np.testing.assert_array_almost_equal(spin_phases, expected)
+
+
+@pytest.mark.parametrize(
+    "spin_phases, degrees, expected, context",
+    [
+        (np.arange(0, 1, 0.1), True, np.arange(0, 1, 0.1) * 360, does_not_raise()),
+        (
+            np.arange(0, 1, 0.1),
+            False,
+            np.arange(0, 1, 0.1) * 2 * np.pi,
+            does_not_raise(),
+        ),
+        (
+            np.array([0, 1]),
+            True,
+            None,
+            pytest.raises(ValueError, match="Spin phases *"),
+        ),
+        (
+            np.array([-1, 0]),
+            False,
+            None,
+            pytest.raises(ValueError, match="Spin phases *"),
+        ),
+    ],
+)
+def test_get_spin_angle(spin_phases, degrees, expected, context):
+    """Test get_spin_angle() with fake spin phases."""
+    with context:
+        spin_angles = get_spin_angle(spin_phases, degrees=degrees)
+        np.testing.assert_array_equal(spin_angles, expected)
+
+
+@pytest.mark.parametrize("query_met_times", [-1, 165])
+def test_get_spacecraft_spin_phase_value_error(query_met_times, fake_spin_data):
+    """Test get_spacecraft_spin_phase() for raising ValueError."""
+    with pytest.raises(ValueError, match="Query times"):
+        _ = get_spacecraft_spin_phase(query_met_times)
+
+
+@pytest.mark.usefixtures("use_fake_spin_data_for_time")
+def test_get_spin_data(use_fake_spin_data_for_time):
+    """Test get_spin_data() with generated spin data."""
+    use_fake_spin_data_for_time(453051323.0 - 56120)
+    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."
+
+
+@pytest.mark.parametrize(
+    "instrument",
+    [
+        SpiceFrame.IMAP_LO,
+        SpiceFrame.IMAP_HI_45,
+        SpiceFrame.IMAP_HI_90,
+        SpiceFrame.IMAP_ULTRA_45,
+        SpiceFrame.IMAP_ULTRA_90,
+        SpiceFrame.IMAP_SWAPI,
+        SpiceFrame.IMAP_IDEX,
+        SpiceFrame.IMAP_CODICE,
+        SpiceFrame.IMAP_HIT,
+        SpiceFrame.IMAP_SWE,
+        SpiceFrame.IMAP_GLOWS,
+        SpiceFrame.IMAP_MAG,
+    ],
+)
+def test_get_instrument_spin_phase(instrument, fake_spin_data):
+    """Test coverage for get_instrument_spin_phase()"""
+    met_times = np.array([7.5, 30, 61, 75, 106, 121, 136])
+    expected_nan_mask = np.array([False, False, True, False, True, True, False])
+    inst_phase = get_instrument_spin_phase(met_times, instrument)
+    assert inst_phase.shape == met_times.shape
+    np.testing.assert_array_equal(np.isnan(inst_phase), expected_nan_mask)
+    assert np.logical_and(
+        0 <= inst_phase[~expected_nan_mask], inst_phase[~expected_nan_mask] < 1
+    ).all()

imap_processing/tests/spice/test_time.py

@@ -7,14 +7,15 @@ import spiceypy
 from imap_processing.spice import IMAP_SC_ID
 from imap_processing.spice.time import (
     TICK_DURATION,
-    _sct2e_wrapper,
     et_to_utc,
-    j2000ns_to_j2000s,
     met_to_datetime64,
-    met_to_j2000ns,
     met_to_sclkticks,
+    met_to_ttj2000ns,
     met_to_utc,
+    sct_to_et,
+    sct_to_ttj2000s,
     str_to_et,
+    ttj2000ns_to_et,
 )
 
 
@@ -27,10 +28,11 @@ def test_met_to_sclkticks(met):
     np.testing.assert_array_equal(ticks, expected)
 
 
-def test_met_to_j2000ns(furnish_time_kernels):
-    """Test coverage for met_to_j2000ns function."""
+def test_met_to_ttj2000ns(furnish_time_kernels):
+    """Test coverage for met_to_ttj2000ns function."""
     utc = "2026-01-01T00:00:00.125"
     et = spiceypy.str2et(utc)
+    spicey_tt = spiceypy.unitim(et, "ET", "TT")
     sclk_str = spiceypy.sce2s(IMAP_SC_ID, et)
     seconds, ticks = sclk_str.split("/")[1].split(":")
     # There is some floating point error calculating tick duration from 1 clock
@@ -39,26 +41,30 @@ def test_met_to_j2000ns(furnish_time_kernels):
         spiceypy.sct2e(IMAP_SC_ID, 1e12) - spiceypy.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))
+    tt = met_to_ttj2000ns(met)
+    assert tt.dtype == np.int64
+    np.testing.assert_array_equal(tt, np.array(spicey_tt * 1e9))
 
 
-def test_j2000ns_to_j2000s(furnish_time_kernels):
-    """Test coverage for j2000ns_to_j2000s function."""
+def test_ttj2000ns_to_et(furnish_time_kernels):
+    """Test coverage for ttj2000ns_to_et function."""
     # Use spice to come up with reasonable J2000 values
     utc = "2025-09-23T00:00:00.000"
     # Test single value input
     et = spiceypy.str2et(utc)
-    epoch = int(et * 1e9)
-    j2000s = j2000ns_to_j2000s(epoch)
+    epoch = int(spiceypy.unitim(et, "ET", "TT") * 1e9)
+    j2000s = ttj2000ns_to_et(epoch)
     assert j2000s == et
+    # Test for bug when spiceypy tries to iterate over 0-d array returned by
+    # np.vectorize for the scalar case
+    assert not spiceypy.support_types.is_iterable(et)
     # Test array input
-    epoch = (np.arange(et, et + 10000, 100) * 1e9).astype(np.int64)
-    j2000s = j2000ns_to_j2000s(epoch)
-    np.testing.assert_array_equal(
-        j2000s, np.arange(et, et + 10000, 100, dtype=np.float64)
+    ets = np.arange(et, et + 10000, 100)
+    epoch = np.array([spiceypy.unitim(et, "ET", "TT") * 1e9 for et in ets]).astype(
+        np.int64
     )
+    j2000s = ttj2000ns_to_et(epoch)
+    np.testing.assert_array_equal(j2000s, ets)
 
 
 @pytest.mark.parametrize(
@@ -106,26 +112,42 @@ def test_met_to_datetime64(furnish_time_kernels, utc):
         et_arr = spiceypy.str2et(utc)
         sclk_ticks = np.array([spiceypy.sce2c(IMAP_SC_ID, et) for et in et_arr])
     else:
-        expected_dt64 = np.asarray(np.datetime64(utc))
+        expected_dt64 = np.datetime64(utc)
         et = spiceypy.str2et(utc)
         sclk_ticks = spiceypy.sce2c(IMAP_SC_ID, et)
     met = sclk_ticks * TICK_DURATION
     dt64 = met_to_datetime64(met)
+
+    if isinstance(utc, list):
+        assert isinstance(dt64, np.ndarray)
+        assert dt64.dtype.name == "datetime64[ns]"
+    else:
+        assert isinstance(dt64, np.datetime64)
     np.testing.assert_array_equal(
         dt64.astype("datetime64[us]"), expected_dt64.astype("datetime64[us]")
     )
 
 
 @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)
+def test_sct_to_et(sclk_ticks):
+    """Test for `sct_to_et` function."""
+    et = sct_to_et(sclk_ticks)
     if isinstance(sclk_ticks, float):
         assert isinstance(et, float)
     else:
         assert len(et) == len(sclk_ticks)
 
 
+@pytest.mark.parametrize("sclk_ticks", [0.0, np.arange(10)])
+def test_sct_to_ttj2000s(sclk_ticks):
+    """Test for `sct_to_ttj2000s` function."""
+    tt = sct_to_ttj2000s(sclk_ticks)
+    if isinstance(sclk_ticks, float):
+        assert isinstance(tt, float)
+    else:
+        assert len(tt) == len(sclk_ticks)
+
+
 def test_str_to_et(furnish_time_kernels):
     """Test coverage for string to et conversion function."""
     utc = "2017-07-14T19:46:00"
@@ -133,6 +155,7 @@ def test_str_to_et(furnish_time_kernels):
     expected_et = 553333629.1837274
     actual_et = str_to_et(utc)
     assert expected_et == actual_et
+    assert isinstance(actual_et, float)
 
     # Test list input
     list_of_utc = [

imap_processing/tests/swapi/test_swapi_l1.py

@@ -4,7 +4,7 @@ import xarray as xr
 
 from imap_processing import imap_module_directory
 from imap_processing.cdf.utils import write_cdf
-from imap_processing.spice.time import met_to_j2000ns
+from imap_processing.spice.time import met_to_ttj2000ns
 from imap_processing.swapi.l1.swapi_l1 import (
     SWAPIAPID,
     decompress_count,
@@ -91,7 +91,7 @@ def test_find_sweep_starts():
     sequence_number = time % 12
     ds = xr.Dataset(
         {"seq_number": sequence_number, "shcoarse": np.arange(1, 27, 1)},
-        coords={"epoch": met_to_j2000ns(time)},
+        coords={"epoch": met_to_ttj2000ns(time)},
     )
 
     start_indices = find_sweep_starts(ds)
@@ -114,7 +114,7 @@ def test_get_full_indices():
     sequence_number = time % 12
     ds = xr.Dataset(
         {"seq_number": sequence_number, "shcoarse": np.arange(1, 27, 1)},
-        coords={"epoch": met_to_j2000ns(time)},
+        coords={"epoch": met_to_ttj2000ns(time)},
     )
 
     sweep_indices = get_indices_of_full_sweep(ds)
@@ -176,7 +176,14 @@ def test_process_swapi_science(decom_test_data):
 def test_swapi_l1_cdf(swapi_l0_test_data_path):
     """Test housekeeping processing and CDF file creation"""
     test_packet_file = swapi_l0_test_data_path / "imap_swapi_l0_raw_20240924_v001.pkts"
-    processed_data = swapi_l1(test_packet_file, data_version="v001")
+    processed_data = swapi_l1([test_packet_file], data_version="v001")
+    # hk cdf file
+    hk_cdf_filename = "imap_swapi_l1_hk_20240924_v001.cdf"
+    # TODO: how to add ignore ISTP checks for HK data to cli.py
+    hk_cdf_path = write_cdf(processed_data[0])
+    assert hk_cdf_path.name == hk_cdf_filename
+
+    processed_data = swapi_l1([test_packet_file, hk_cdf_path], data_version="v001")
 
     assert processed_data[0].attrs["Apid"] == f"{SWAPIAPID.SWP_SCI}"
 
@@ -184,9 +191,3 @@ def test_swapi_l1_cdf(swapi_l0_test_data_path):
     cdf_filename = "imap_swapi_l1_sci_20240924_v001.cdf"
     cdf_path = write_cdf(processed_data[0])
     assert cdf_path.name == cdf_filename
-
-    # hk cdf file
-    cdf_filename = "imap_swapi_l1_hk_20240924_v001.cdf"
-    # Ignore ISTP checks for HK data
-    cdf_path = write_cdf(processed_data[1], istp=False)
-    assert cdf_path.name == cdf_filename

imap_processing/tests/swapi/test_swapi_l2.py

@@ -7,10 +7,20 @@ from imap_processing.swapi.l2.swapi_l2 import TIME_PER_BIN, swapi_l2
 
 def test_swapi_l2_cdf(swapi_l0_test_data_path):
     """Test housekeeping processing and CDF file creation"""
-    l0_data_path = swapi_l0_test_data_path / "imap_swapi_l0_raw_20240924_v001.pkts"
-    processed_data = swapi_l1(l0_data_path, data_version="v001")
-    l1_dataset = processed_data[0]
+    test_packet_file = swapi_l0_test_data_path / "imap_swapi_l0_raw_20240924_v001.pkts"
+    # Create HK CDF File
+    processed_hk_data = swapi_l1([test_packet_file], data_version="v001")
+    hk_cdf_filename = "imap_swapi_l1_hk_20240924_v001.cdf"
+    hk_cdf_path = write_cdf(processed_hk_data[0])
+    assert hk_cdf_path.name == hk_cdf_filename
 
+    # Create L1 CDF File
+    processed_sci_data = swapi_l1([test_packet_file, hk_cdf_path], data_version="v001")
+    cdf_filename = "imap_swapi_l1_sci_20240924_v001.cdf"
+    cdf_path = write_cdf(processed_sci_data[0])
+    assert cdf_path.name == cdf_filename
+
+    l1_dataset = processed_sci_data[0]
     l2_dataset = swapi_l2(l1_dataset, data_version="v001")
     l2_cdf = write_cdf(l2_dataset)
     assert l2_cdf.name == "imap_swapi_l2_sci_20240924_v001.cdf"

imap_processing/tests/swe/test_swe_l1a.py

@@ -7,6 +7,6 @@ def test_cdf_creation():
     test_data_path = "tests/swe/l0_data/2024051010_SWE_SCIENCE_packet.bin"
     processed_data = swe_l1a(imap_module_directory / test_data_path, "001")
 
-    cem_raw_cdf_filepath = write_cdf(processed_data)
+    cem_raw_cdf_filepath = write_cdf(processed_data[0])
 
     assert cem_raw_cdf_filepath.name == "imap_swe_l1a_sci_20240510_v001.cdf"

imap_processing/tests/swe/test_swe_l1b.py

@@ -1,3 +1,5 @@
+from unittest.mock import patch
+
 import numpy as np
 import pandas as pd
 
@@ -45,14 +47,29 @@ def test_swe_l1b(decom_test_data_derived):
         )
 
 
-def test_cdf_creation(l1b_validation_df):
+@patch(
+    "imap_processing.swe.l1b.swe_l1b_science.read_in_flight_cal_data",
+    return_value=pd.DataFrame(
+        {
+            "met_time": [452051300, 454051900],
+            "cem1": [1, 1],
+            "cem2": [1, 1],
+            "cem3": [1, 1],
+            "cem4": [1, 1],
+            "cem5": [1, 1],
+            "cem6": [1, 1],
+            "cem7": [1, 1],
+        }
+    ),
+)
+def test_cdf_creation(mock_read_in_flight_cal_data, l1b_validation_df):
     """Test that CDF file is created and has the correct name."""
     test_data_path = "tests/swe/l0_data/2024051010_SWE_SCIENCE_packet.bin"
     l1a_datasets = swe_l1a(imap_module_directory / test_data_path, "002")
 
-    l1b_dataset = swe_l1b(l1a_datasets, "002")
+    l1b_dataset = swe_l1b(l1a_datasets[0], "002")
 
-    sci_l1b_filepath = write_cdf(l1b_dataset)
+    sci_l1b_filepath = write_cdf(l1b_dataset[0])
 
     assert sci_l1b_filepath.name == "imap_swe_l1b_sci_20240510_v002.cdf"
     # load the CDF file and compare the values

imap_processing/tests/swe/test_swe_l1b_science.py

@@ -1,47 +1,21 @@
+from unittest.mock import patch
+
 import numpy as np
+import pandas as pd
 import pytest
 
-from imap_processing import imap_module_directory
 from imap_processing.swe.l1a.swe_science import swe_science
 from imap_processing.swe.l1b.swe_l1b_science import (
+    apply_in_flight_calibration,
     get_indices_of_full_cycles,
 )
-from imap_processing.swe.utils.swe_utils import SWEAPID
-from imap_processing.utils import packet_file_to_datasets
 
 
 @pytest.fixture(scope="session")
-def l1a_test_data():
-    """Read test data from file"""
-    # NOTE: data was provided in this sequence in both bin and validation data
-    # from instrument team.
-    # Packet 1 has spin 4's data
-    # Packet 2 has spin 1's data
-    # Packet 3 has spin 2's data
-    # Packet 4 has spin 3's data
-    # moved packet 1 to bottom to show data in order.
-    packet_files = [
-        imap_module_directory
-        / "tests/swe/l0_data/20230927173253_SWE_SCIENCE_packet.bin",
-        imap_module_directory
-        / "tests/swe/l0_data/20230927173308_SWE_SCIENCE_packet.bin",
-        imap_module_directory
-        / "tests/swe/l0_data/20230927173323_SWE_SCIENCE_packet.bin",
-        imap_module_directory
-        / "tests/swe/l0_data/20230927173238_SWE_SCIENCE_packet.bin",
-    ]
-    dataset = packet_file_to_datasets(packet_files[0], use_derived_value=False)[
-        SWEAPID.SWE_SCIENCE
-    ]
-    for packet_file in packet_files[1:]:
-        dataset.merge(
-            packet_file_to_datasets(packet_file, use_derived_value=False)[
-                SWEAPID.SWE_SCIENCE
-            ]
-        )
-    # Get unpacked science data
-    unpacked_data = swe_science(dataset, "001")
-    return unpacked_data
+def l1a_test_data(decom_test_data):
+    """Read test data from file and process to l1a"""
+    processed_data = swe_science(decom_test_data, "001")
+    return processed_data
 
 
 def test_get_full_cycle_data_indices():
@@ -62,4 +36,49 @@ def test_get_full_cycle_data_indices():
     np.testing.assert_array_equal(filtered_q, np.array([]))
 
 
-# TODO: Add more tests
+@patch(
+    "imap_processing.swe.l1b.swe_l1b_science.read_in_flight_cal_data",
+    return_value=pd.DataFrame(
+        {
+            "met_time": [453051300, 453051900],
+            "cem1": [1, 2],
+            "cem2": [1, 2],
+            "cem3": [1, 2],
+            "cem4": [1, 2],
+            "cem5": [1, 2],
+            "cem6": [1, 2],
+            "cem7": [1, 2],
+        }
+    ),
+)
+def test_in_flight_calibration_factor(mock_read_in_flight_cal_data, l1a_test_data):
+    """Test that the L1B processing is working as expected."""
+    # create sample data
+
+    input_time = 453051355.0
+    input_count = 19967
+    one_full_cycle_data = np.full((24, 30, 7), input_count)
+    acquisition_time = np.full((24, 30), input_time)
+
+    # Test that calibration factor is within correct range given test data
+    expected_cal_factor = 1 + ((2 - 1) / (453051900 - 453051300)) * (
+        input_time - 453051300
+    )
+
+    calibrated_count = apply_in_flight_calibration(
+        one_full_cycle_data,
+        acquisition_time,
+    )
+
+    np.testing.assert_allclose(
+        calibrated_count,
+        np.full((24, 30, 7), input_count * expected_cal_factor),
+        rtol=1e-9,
+    )
+
+    # Check for value outside of calibration time range
+    input_time = 1.0
+    acquisition_time = np.full((24, 30), input_time)
+
+    with pytest.raises(ValueError, match="Acquisition min/max times: "):
+        apply_in_flight_calibration(one_full_cycle_data, acquisition_time)