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

imap_processing/tests/ialirt/unit/test_decom_ialirt.py

@@ -1,94 +1,29 @@
 import pytest
 
 from imap_processing import imap_module_directory
-from imap_processing.decom import decom_packets
 from imap_processing.utils import packet_file_to_datasets
 
 IALIRT_PACKET_LENGTH = 1464
 
 
-@pytest.fixture(scope="session")
-def xtce_ialirt_path():
-    """Returns the xtce auxiliary directory."""
-    return imap_module_directory / "ialirt" / "packet_definitions" / "ialirt.xml"
+@pytest.mark.external_test_data
+def test_generate_xarray():
+    """Checks that xarray data is properly generated."""
 
-
-@pytest.fixture()
-def binary_packet_path(tmp_path):
-    """
-    Creates a binary file from the text packet data, which is more representative
-    of the actual operational environment. The binary file is deleted after the
-    test session.
-    """
+    apid = 478
     packet_path = (
-        imap_module_directory
-        / "tests"
-        / "ialirt"
-        / "test_data"
-        / "l0"
-        / "IALiRT Raw Packet Telemetry.txt"
+        imap_module_directory / "tests" / "ialirt" / "data" / "l0" / "apid_478.bin"
     )
-
-    binary_file_path = tmp_path / "file.ccsds"
-
-    with open(packet_path) as text_file, open(binary_file_path, "wb") as binary_file:
-        for line in text_file:
-            if not line.startswith("#"):
-                # Split the line by semicolons
-                # Discard the first value since it is only a counter
-                hex_values = line.strip().split(";")[1:]
-                # Convert hex to binary
-                binary_data = bytearray.fromhex("".join(hex_values))
-                binary_file.write(binary_data)
-                assert len(binary_data) * 8 == IALIRT_PACKET_LENGTH
-
-    return binary_file_path
-
-
-@pytest.fixture()
-def decom_packets_data(binary_packet_path, xtce_ialirt_path):
-    """Read packet data from file using decom_packets"""
-    data_packet_list = decom_packets(binary_packet_path, xtce_ialirt_path)
-    return data_packet_list
-
-
-def test_length(decom_packets_data):
-    """Test if total packets in data file is correct"""
-    total_packets = 32
-    assert len(decom_packets_data) == total_packets
-
-
-def test_enumerated(decom_packets_data):
-    """Test if enumerated values derived correctly"""
-
-    for packet in decom_packets_data:
-        assert packet["SC_SWAPI_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_MAG_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_HIT_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_CODICE_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_LO_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_HI_45_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_HI_90_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_ULTRA_45_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_ULTRA_90_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_SWE_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_IDEX_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_GLOWS_STATUS"] == "NOT_OPERATIONAL"
-        assert packet["SC_SPINPERIODVALID"] == "INVALID"
-        assert packet["SC_SPINPHASEVALID"] == "INVALID"
-        assert packet["SC_ATTITUDE"] == "SUNSENSOR"
-        assert packet["SC_CATBEDHEATERFLAG"] == "ON"
-        assert packet["SC_AUTONOMY"] == "OPERATIONAL"
-        assert packet["HIT_STATUS"] == "OFF-NOMINAL"
-        assert packet["SWE_NOM_FLAG"] == "OFF-NOMINAL"
-        assert packet["SWE_OPS_FLAG"] == "NON-HVSCI"
-
-
-def test_generate_xarray(binary_packet_path, xtce_ialirt_path, decom_packets_data):
-    """This function checks that all instrument parameters are correct length."""
-
-    apid = 478
-    xarray_data = packet_file_to_datasets(binary_packet_path, xtce_ialirt_path)[apid]
+    xtce_ialirt_path = (
+        imap_module_directory / "ialirt" / "packet_definitions" / "ialirt.xml"
+    )
+    xarray_data = packet_file_to_datasets(
+        packet_path, xtce_ialirt_path, use_derived_value=True
+    )[apid]
 
     for key in xarray_data.keys():
-        assert len(xarray_data[key]) == 32
+        assert len(xarray_data[key]) == 44429
+
+    total_packet_length = xarray_data["pkt_len"].values[0] + 7
+    # Convert to bytes
+    assert total_packet_length * 8 == IALIRT_PACKET_LENGTH

imap_processing/tests/ialirt/unit/test_grouping.py

@@ -7,7 +7,7 @@ import xarray as xr
 from imap_processing.ialirt.utils.grouping import filter_valid_groups, find_groups
 
 
-@pytest.fixture()
+@pytest.fixture
 def test_data():
     """Creates grouped data for filter_valid_groups test."""
     epoch = np.arange(12)
@@ -39,7 +39,7 @@ def test_data():
     return test_data
 
 
-@pytest.fixture()
+@pytest.fixture
 def grouped_data():
     """Creates grouped data for filter_valid_groups test."""
     epoch = np.arange(12)

imap_processing/tests/ialirt/unit/test_parse_mag.py

@@ -1,15 +1,22 @@
+"""Tests to support I-ALiRT MAG packet parsing."""
+
 import numpy as np
 import pandas as pd
 import pytest
 import xarray as xr
 
 from imap_processing import imap_module_directory
+from imap_processing.cdf.utils import load_cdf
 from imap_processing.ialirt.l0.parse_mag import (
+    calculate_l1b,
     extract_magnetic_vectors,
     get_pkt_counter,
     get_status_data,
     get_time,
-    parse_packet,
+    process_packet,
+)
+from imap_processing.mag.l1b.mag_l1b import (
+    retrieve_matrix_from_l1b_calibration,
 )
 from imap_processing.utils import packet_file_to_datasets
 
@@ -23,7 +30,7 @@ def xtce_mag_path():
 @pytest.fixture(scope="session")
 def binary_packet_path():
     """Returns the paths to the binary packets."""
-    directory = imap_module_directory / "tests" / "ialirt" / "test_data" / "l0"
+    directory = imap_module_directory / "tests" / "ialirt" / "data" / "l0"
     filenames = [
         "461971383-404.bin",
         "461971384-405.bin",
@@ -45,7 +52,7 @@ def mag_test_data():
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "sample_decoded_i-alirt_data.csv"
     )
@@ -54,7 +61,7 @@ def mag_test_data():
     return data
 
 
-@pytest.fixture()
+@pytest.fixture
 def xarray_data(binary_packet_path, xtce_mag_path):
     """Create xarray data for multiple packets."""
     apid = 1001
@@ -68,7 +75,7 @@ def xarray_data(binary_packet_path, xtce_mag_path):
     return merged_xarray_data
 
 
-@pytest.fixture()
+@pytest.fixture
 def grouped_data():
     """Creates grouped data for tests."""
     epoch = np.arange(12)
@@ -107,6 +114,15 @@ def grouped_data():
     return grouped_data
 
 
+@pytest.fixture
+def calibration_dataset():
+    """Returns the calibration data."""
+    calibration_dataset = load_cdf(
+        imap_module_directory / "mag" / "l1b" / "imap_calibration_mag_20240229_v01.cdf"
+    )
+    return calibration_dataset
+
+
 def test_get_pkt_counter(xarray_data):
     """Tests the get_pkt_counter function."""
     status_values = xarray_data["mag_status"].values
@@ -127,15 +143,24 @@ def test_get_status_data(xarray_data, mag_test_data):
         assert status_data[key] == matching_row[key.upper()].values[0]
 
 
-def test_get_time(grouped_data):
+def test_get_time(grouped_data, calibration_dataset):
     """Tests the get_time function."""
-    time_data = get_time(grouped_data, 1, np.array([0, 1, 2, 3]))
-    assert time_data == {
-        "pri_coarsetm": 461971386,
-        "pri_fintm": 1500,
-        "sec_coarsetm": 461971386,
-        "sec_fintm": 1503,
-    }
+
+    calibration_matrix_mago, time_shift_mago = retrieve_matrix_from_l1b_calibration(
+        calibration_dataset, is_mago=True
+    )
+    calibration_matrix_magi, time_shift_magi = retrieve_matrix_from_l1b_calibration(
+        calibration_dataset, is_mago=False
+    )
+
+    time_data = get_time(
+        grouped_data, 1, np.array([0, 1, 2, 3]), time_shift_mago, time_shift_magi
+    )
+
+    assert time_data["pri_coarsetm"] == 461971386
+    assert time_data["pri_fintm"] == 1500
+    assert time_data["sec_coarsetm"] == 461971386
+    assert time_data["sec_fintm"] == 1503
 
 
 def test_extract_magnetic_vectors():
@@ -156,13 +181,43 @@ def test_extract_magnetic_vectors():
     }
 
 
-def test_parse_packet(xarray_data, mag_test_data):
+def test_calculate_l1b(grouped_data, xarray_data, calibration_dataset):
+    """Tests the calculate_l1b function."""
+
+    pkt_counter = np.array([0.0, 1.0, 2.0, 3.0])
+
+    science_data = {
+        "pri_x": 1.0,
+        "pri_y": 2.0,
+        "pri_z": 3.0,
+        "sec_x": 4.0,
+        "sec_y": 5.0,
+        "sec_z": 6.0,
+    }
+
+    status_data = {
+        "fob_range": 1,
+        "fib_range": 1,
+    }
+
+    vec_mago, vec_magi, time_data = calculate_l1b(
+        grouped_data, 0, pkt_counter, science_data, status_data, calibration_dataset
+    )
+
+    assert vec_mago.shape == (4,)
+    assert vec_magi.shape == (4,)
+    assert "primary_epoch" in time_data
+    assert "secondary_epoch" in time_data
+
+
+def test_process_packet(xarray_data, mag_test_data, calibration_dataset):
     """Tests the parse_packet function."""
-    parsed_packets = parse_packet(xarray_data)
+    parsed_packets = process_packet(xarray_data, calibration_dataset)
 
     for packet in parsed_packets:
         index = packet["pri_coarsetm"] == mag_test_data["PRI_COARSETM"]
         matching_rows = mag_test_data[index]
 
         for key in packet.keys():
-            assert packet[key] == matching_rows[key.upper()].values[0]
+            if key.upper() in matching_rows.keys():
+                assert packet[key] == matching_rows[key.upper()].values[0]

imap_processing/tests/ialirt/unit/test_process_codicehi.py

@@ -26,7 +26,7 @@ def binary_packet_path():
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "hi_fsw_view_1_ccsds.bin"
     )
@@ -39,7 +39,7 @@ def codicehi_validation_data():
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "imap_codice_l1a_hi-ialirt_20240523200000_v0.0.0.cdf"
     )
@@ -48,7 +48,7 @@ def codicehi_validation_data():
     return data
 
 
-@pytest.fixture()
+@pytest.fixture
 def codicehi_test_data(binary_packet_path, xtce_codicehi_path):
     """Create xarray data"""
     apid = 1168

imap_processing/tests/ialirt/unit/test_process_codicelo.py

@@ -22,14 +22,7 @@ def xtce_codicelo_path():
 @pytest.fixture(scope="session")
 def binary_packet_path():
     """Returns the xtce directory."""
-    return (
-        imap_module_directory
-        / "tests"
-        / "ialirt"
-        / "test_data"
-        / "l0"
-        / "apid01152.tlm"
-    )
+    return imap_module_directory / "tests" / "ialirt" / "data" / "l0" / "apid01152.tlm"
 
 
 @pytest.fixture(scope="session")
@@ -39,7 +32,7 @@ def codicelo_validation_data():
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "imap_codice_l1a_lo-ialirt_20241110193700_v0.0.0.cdf"
     )
@@ -48,7 +41,7 @@ def codicelo_validation_data():
     return data
 
 
-@pytest.fixture()
+@pytest.fixture
 def codicelo_test_data(binary_packet_path, xtce_codicelo_path):
     """Create xarray data"""
     apid = 1152

imap_processing/tests/ialirt/unit/test_process_ephemeris.py

@@ -7,7 +7,7 @@ from imap_processing.ialirt import process_ephemeris
 from imap_processing.spice.time import str_to_et
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 def test_calculate_doppler(furnish_kernels):
     """
     Test the calculate_doppler() function.
@@ -43,7 +43,7 @@ def test_calculate_doppler(furnish_kernels):
     assert doppler_result is not None
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 def test_latitude_longitude_to_ecef(furnish_kernels):
     """
     Test the latitude_longitude_to_ecef() function.
@@ -63,7 +63,7 @@ def test_latitude_longitude_to_ecef(furnish_kernels):
     )
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 def test_calculate_azimuth_and_elevation(furnish_kernels):
     """
     Test the calculate_azimuth_and_elevation() function.
@@ -101,7 +101,7 @@ def test_calculate_azimuth_and_elevation(furnish_kernels):
     assert len(azimuth_result) == len(observation_time)
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 def test_build_output(furnish_kernels):
     """
     Test the build_output() function.

imap_processing/tests/ialirt/unit/test_process_hit.py

@@ -25,7 +25,7 @@ def binary_packet_path():
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "hit_ialirt_sample.ccsds"
     )
@@ -38,7 +38,7 @@ def hit_test_data():
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "hit_ialirt_sample.csv"
     )
@@ -47,7 +47,7 @@ def hit_test_data():
     return data
 
 
-@pytest.fixture()
+@pytest.fixture
 def xarray_data(binary_packet_path, xtce_hit_path):
     """Create xarray data"""
     apid = 1253

imap_processing/tests/ialirt/unit/test_process_swapi.py

@@ -3,6 +3,7 @@ import pandas as pd
 import pytest
 
 from imap_processing import imap_module_directory
+from imap_processing.ialirt.l0.process_swapi import process_swapi_ialirt
 from imap_processing.utils import packet_file_to_datasets
 
 
@@ -14,12 +15,12 @@ def xtce_swapi_path():
 
 @pytest.fixture(scope="session")
 def binary_packet_path():
-    """Returns the xtce directory."""
+    """Returns the binary packet path."""
     return (
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "BinLog CCSDS_FRAG_TLM_20240826_152323Z_IALIRT_data_for_SDC.bin"
     )
@@ -27,12 +28,12 @@ def binary_packet_path():
 
 @pytest.fixture(scope="session")
 def swapi_test_data():
-    """Returns the test data directory."""
+    """Returns the l0 validation dataframe."""
     data_path = (
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "eu_SWP_IAL_20240826_152033.csv"
     )
@@ -41,34 +42,34 @@ def swapi_test_data():
     return data
 
 
-@pytest.fixture()
+@pytest.fixture
 def xarray_data(binary_packet_path, xtce_swapi_path):
-    """Create xarray data"""
-    apid = 1187
+    """Create SWAPI xarray dataset for testing."""
 
     xarray_data = packet_file_to_datasets(
         binary_packet_path, xtce_swapi_path, use_derived_value=True
-    )[apid]
+    )[1187]
     return xarray_data
 
 
 def test_decom_packets(xarray_data, swapi_test_data):
-    """This function checks that all instrument parameters are accounted for."""
+    """Check that all instrument parameters are accounted for after decom."""
 
     # TODO: confirm w/ SWAPI team validity_enum flag can be
     #  consistent with other instruments.
     fields_to_test = {
         "swapi_flag": "I_ALIRT_STATUS",
         "swapi_reserved": "INST_RES_ST",
-        "swapi_seq": "SEQ_NUMBER",
+        "swapi_seq_number": "SEQ_NUMBER",
         "swapi_version": "SWEEP_TABLE",
-        "swapi_coin_1": "COIN_CNT0",
-        "swapi_coin_2": "COIN_CNT1",
-        "swapi_coin_3": "COIN_CNT2",
-        "swapi_coin_4": "COIN_CNT3",
-        "swapi_coin_5": "COIN_CNT4",
-        "swapi_coin_6": "COIN_CNT5",
+        "swapi_coin_cnt0": "COIN_CNT0",
+        "swapi_coin_cnt1": "COIN_CNT1",
+        "swapi_coin_cnt2": "COIN_CNT2",
+        "swapi_coin_cnt3": "COIN_CNT3",
+        "swapi_coin_cnt4": "COIN_CNT4",
+        "swapi_coin_cnt5": "COIN_CNT5",
         "swapi_spare": "SPARE",
+        "swapi_shcoarse": "SHCOARSE",
     }
     _, index, test_index = np.intersect1d(
         xarray_data["swapi_acq"], swapi_test_data["ACQ_TIME"], return_indices=True
@@ -83,3 +84,10 @@ def test_decom_packets(xarray_data, swapi_test_data):
             f"Mismatch found in {xarray_field}: "
             f"actual {actual_values}, expected {expected_values}"
         )
+
+
+def test_process_swapi_ialirt(xarray_data):
+    """Placeholder test for the process_swapi_ialirt function."""
+
+    swapi_result = process_swapi_ialirt(xarray_data)
+    assert swapi_result["met"] is not None

imap_processing/tests/ialirt/unit/test_process_swe.py

@@ -1,3 +1,5 @@
+"""Tests to support I-ALiRT SWE packet parsing."""
+
 from unittest.mock import patch
 
 import numpy as np
@@ -7,10 +9,17 @@ import xarray as xr
 
 from imap_processing import imap_module_directory
 from imap_processing.ialirt.l0.process_swe import (
+    average_counts,
+    azimuthal_check_counterstreaming,
+    compute_bidirectional,
     decompress_counts,
+    determine_streaming,
+    find_bin_offsets,
+    find_min_counts,
     get_ialirt_energies,
     normalize_counts,
     phi_to_bin,
+    polar_check_counterstreaming,
     prepare_raw_counts,
     process_swe,
 )
@@ -34,7 +43,7 @@ def binary_packet_path():
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "20240827095047_SWE_IALIRT_packet.bin"
     )
@@ -47,7 +56,7 @@ def swe_test_data():
         imap_module_directory
         / "tests"
         / "ialirt"
-        / "test_data"
+        / "data"
         / "l0"
         / "idle_export_eu.SWE_IALIRT_20240827_093852.csv"
     )
@@ -56,7 +65,7 @@ def swe_test_data():
     return data
 
 
-@pytest.fixture()
+@pytest.fixture
 def xarray_data(binary_packet_path, xtce_swe_path):
     """Create xarray data"""
     apid = 1360
@@ -67,7 +76,7 @@ def xarray_data(binary_packet_path, xtce_swe_path):
     return xarray_data
 
 
-@pytest.fixture()
+@pytest.fixture
 def fields_to_test():
     """Create a dictionary to convert names"""
     fields_to_test = {
@@ -109,6 +118,25 @@ def fields_to_test():
     return fields_to_test
 
 
+@pytest.fixture
+def summed_half_cycle():
+    """Create test set with known peaks"""
+
+    summed_half_cycle = np.zeros((8, 30))
+
+    for i in range(8):
+        peak = i + 5
+        summed_half_cycle[i, peak] = 100
+        summed_half_cycle[i, (peak + 6) % 30] = 60  # +90 offset
+        summed_half_cycle[i, (peak + 8) % 30] = 80  # +90 offset
+        summed_half_cycle[i, (peak + 14) % 30] = 20  # +180 offset
+        summed_half_cycle[i, (peak + 16) % 30] = 40  # +180 offset
+        summed_half_cycle[i, (peak - 6) % 30] = 5  # -90 offset
+        summed_half_cycle[i, (peak - 8) % 30] = 15  # -90 offset
+
+    return summed_half_cycle
+
+
 def test_get_energy():
     """Tests get_alirt_energies function."""
     energies = get_ialirt_energies()
@@ -225,7 +253,7 @@ def test_prepare_raw_counts():
     assert np.array_equal(raw_counts, expected)
 
 
-def test_norm_counts():
+def test_normalize_counts():
     """Tests normalize_counts function"""
 
     # Shape (2, 7, 3) for a small test case
@@ -283,6 +311,79 @@ def test_norm_counts():
     assert np.allclose(norm_counts, expected, atol=1e-9)
 
 
+def test_find_bin_offsets():
+    """Tests find_bin_offsets function"""
+
+    peak_bins = np.array([5, 6, 29])
+    bins = find_bin_offsets(peak_bins, (2, 3))
+    np.testing.assert_array_equal(bins, np.array([[7, 8, 1], [8, 9, 2]]))
+
+
+def test_average_counts(summed_half_cycle):
+    """Tests average_values_and_azimuth function"""
+
+    # Find the azimuth angle that corresponds to the maximum counts at each energy
+    peak_az_bin = np.argmax(summed_half_cycle, axis=1)
+
+    # Bins +6 and +8 correspond to +90 degrees.
+    counts_90 = average_counts(peak_az_bin, summed_half_cycle, (6, 8))
+
+    assert np.allclose(counts_90, np.full(8, 70), atol=1e-9)
+
+
+def test_find_min_counts(summed_half_cycle):
+    """Tests find_min_counts function"""
+
+    cpeak, cmin, counts = find_min_counts(summed_half_cycle)
+    np.testing.assert_array_equal(cpeak, np.full(8, 100))
+    np.testing.assert_array_equal(cmin, counts[0])
+
+
+def test_determine_streaming_summed_cems():
+    """Tests determine_streaming_summed_cems function."""
+
+    # Case where streaming should be True
+    cpeak = np.array([100, 80, 50, 60])
+    cmin = np.array([20, 70, 40, 60])
+    counts_180 = np.array([40, 60, 90, 110])
+    assert np.array_equal(
+        determine_streaming(cpeak, counts_180, cmin), np.array([1, 0, 0, 0])
+    )
+
+
+def test_compute_bidirectional():
+    """Tests compute_bidirectional function."""
+
+    first_half = np.array([1, 0, 0, 0, 1, 0, 0, 0])
+    second_half = np.array([1, 0, 0, 0, 1, 0, 0, 0])
+    assert compute_bidirectional(first_half, second_half) == (0, 0)
+
+    first_half = np.array([1, 1, 1, 0, 0, 0, 0, 0])
+    second_half = np.array([0, 0, 0, 0, 0, 0, 0, 0])
+    assert compute_bidirectional(first_half, second_half) == (1, 0)
+
+
+def test_azimuthal_check_counterstreaming(summed_half_cycle):
+    """Tests azimuthal_check_counterstreaming function."""
+
+    bde = azimuthal_check_counterstreaming(summed_half_cycle, summed_half_cycle)
+
+    assert bde == (1, 1)
+
+
+def test_polar_check_counterstreaming():
+    """Tests polar_check_counterstreaming function."""
+
+    # cem0 (cem1) and cem6 (cem7) have high values
+    # cem2, cem3, cem4 (cem3 to cem5) are low and used for cmin
+    row = np.array([100, 20, 5, 5, 5, 20, 100])
+    summed_half = np.tile(row, (8, 1))
+
+    bde = polar_check_counterstreaming(summed_half, summed_half)
+
+    assert bde == (1, 1)
+
+
 @patch(
     "imap_processing.ialirt.l0.process_swe.read_in_flight_cal_data",
     return_value=pd.DataFrame(
@@ -306,6 +407,13 @@ def test_process_swe(mock_read_cal, swe_test_data, fields_to_test):
     swe_test_data.index.name = "epoch"
     ds = swe_test_data.to_xarray()
     ds["src_seq_ctr"] = ("epoch", np.arange(len(ds["swe_shcoarse"])))
-    swe_data = process_swe(ds)
+    in_flight_cal_file = (
+        imap_module_directory
+        / "tests/swe/lut/imap_swe_l1b-in-flight-cal_20240510_20260716_v000.csv"
+    )
+    swe_data = process_swe(ds, [in_flight_cal_file])
+
+    # TODO: add tests with test data here.
 
-    assert swe_data == []
+    # Check that all groups in the data are accounted for.
+    assert len(swe_data) == 912 // 60