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

imap_processing/tests/ialirt/unit/test_grouping.py

@@ -0,0 +1,81 @@
+"""Tests grouping functions for I-ALiRT instruments."""
+
+import numpy as np
+import pytest
+import xarray as xr
+
+from imap_processing.ialirt.utils.grouping import filter_valid_groups, find_groups
+
+
+@pytest.fixture
+def test_data():
+    """Creates grouped data for filter_valid_groups test."""
+    epoch = np.arange(12)
+
+    # Example `src_seq_ctr` values for 3 groups:
+    # Group 0 - valid, all diffs = 1
+    # Group 1 - invalid, has a jump of 5
+    # Group 2 - valid, wraps at -16383
+    src_seq_ctr = np.concatenate(
+        [
+            np.arange(100, 104),
+            np.array([200, 205, 206, 207]),
+            np.array([16382, 16383, 0, 1]),
+        ],
+        dtype=np.int32,
+    )
+
+    test_data = xr.Dataset(
+        data_vars={
+            "src_seq_ctr": ("epoch", src_seq_ctr),
+            "sequence": ("epoch", np.tile(np.arange(4), 3)),
+            "time_seconds": ("epoch", np.arange(12)),
+        },
+        coords={
+            "epoch": epoch,
+        },
+    )
+
+    return test_data
+
+
+@pytest.fixture
+def grouped_data():
+    """Creates grouped data for filter_valid_groups test."""
+    epoch = np.arange(12)
+
+    # Example `src_seq_ctr` values for 3 groups:
+    # Group 0 - valid, all diffs = 1
+    # Group 1 - invalid, has a jump of 5
+    # Group 2 - valid, wraps at -16383
+    src_seq_ctr = np.concatenate(
+        [
+            np.arange(100, 104),
+            np.array([200, 205, 206, 207]),
+            np.array([16382, 16383, 0, 1]),
+        ],
+        dtype=np.int32,
+    )
+
+    group = np.tile(np.arange(3), 4).reshape(4, 3).T.ravel()
+
+    grouped_data = xr.Dataset(
+        data_vars={"src_seq_ctr": ("epoch", src_seq_ctr)},
+        coords={"epoch": epoch, "group": ("epoch", group)},
+    )
+
+    return grouped_data
+
+
+def test_filter_valid_groups(grouped_data):
+    """Tests filter_valid_groups function."""
+    filtered_data = filter_valid_groups(grouped_data)
+
+    assert np.all(np.unique(filtered_data["group"]) == np.array([0, 2]))
+
+
+def test_find_groups(test_data):
+    """Tests the find_groups function."""
+    grouped_data = find_groups(test_data, (0, 3), "sequence", "time_seconds")
+
+    assert np.all(np.unique(grouped_data["group"]) == np.array([1, 3]))

imap_processing/tests/ialirt/unit/test_parse_mag.py

@@ -0,0 +1,223 @@
+"""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,
+    process_packet,
+)
+from imap_processing.mag.l1b.mag_l1b import (
+    retrieve_matrix_from_l1b_calibration,
+)
+from imap_processing.utils import packet_file_to_datasets
+
+
+@pytest.fixture(scope="session")
+def xtce_mag_path():
+    """Returns the xtce directory."""
+    return imap_module_directory / "ialirt" / "packet_definitions" / "ialirt_mag.xml"
+
+
+@pytest.fixture(scope="session")
+def binary_packet_path():
+    """Returns the paths to the binary packets."""
+    directory = imap_module_directory / "tests" / "ialirt" / "data" / "l0"
+    filenames = [
+        "461971383-404.bin",
+        "461971384-405.bin",
+        "461971385-406.bin",
+        "461971386-407.bin",
+        "461971387-408.bin",
+        "461971388-409.bin",
+        "461971389-410.bin",
+        "461971390-411.bin",
+        "461971391-412.bin",
+    ]
+    return tuple(directory / fname for fname in filenames)
+
+
+@pytest.fixture(scope="session")
+def mag_test_data():
+    """Returns the test data directory."""
+    data_path = (
+        imap_module_directory
+        / "tests"
+        / "ialirt"
+        / "data"
+        / "l0"
+        / "sample_decoded_i-alirt_data.csv"
+    )
+    data = pd.read_csv(data_path)
+
+    return data
+
+
+@pytest.fixture
+def xarray_data(binary_packet_path, xtce_mag_path):
+    """Create xarray data for multiple packets."""
+    apid = 1001
+
+    xarray_data = tuple(
+        packet_file_to_datasets(packet, xtce_mag_path, use_derived_value=False)[apid]
+        for packet in binary_packet_path
+    )
+
+    merged_xarray_data = xr.concat(xarray_data, dim="epoch")
+    return merged_xarray_data
+
+
+@pytest.fixture
+def grouped_data():
+    """Creates grouped data for tests."""
+    epoch = np.arange(12)
+
+    # Example `src_seq_ctr` values for 3 groups:
+    # Group 0 - valid, all diffs = 1
+    # Group 1 - invalid, has a jump of 5
+    # Group 2 - valid, wraps at -16383
+    src_seq_ctr = np.concatenate(
+        [
+            np.arange(100, 104),
+            np.array([200, 205, 206, 207]),
+            np.array([16382, 16383, 0, 1]),
+        ],
+        dtype=np.int32,
+    )
+    mag_acq_tm_coarse = np.repeat(
+        np.array([461971382, 461971386, 461971390], dtype=np.uint32), repeats=4
+    )
+
+    mag_acq_tm_fine = np.array(
+        [1502, 1502, 1505, 1505, 1500, 1500, 1503, 1503, 1497, 1497, 1491, 1491]
+    )
+
+    group = np.tile(np.arange(3), 4).reshape(4, 3).T.ravel()
+
+    grouped_data = xr.Dataset(
+        data_vars={
+            "src_seq_ctr": ("epoch", src_seq_ctr),
+            "mag_acq_tm_coarse": ("epoch", mag_acq_tm_coarse),
+            "mag_acq_tm_fine": ("epoch", mag_acq_tm_fine),
+        },
+        coords={"epoch": epoch, "group": ("epoch", group)},
+    )
+
+    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
+    pkt_counter = get_pkt_counter(status_values)
+    assert np.array_equal(pkt_counter, np.array([0, 1, 2, 3, 0, 1, 2, 3, 0]))
+
+
+def test_get_status_data(xarray_data, mag_test_data):
+    """Tests the get_status_data function."""
+
+    status_data = get_status_data(
+        xarray_data["mag_status"].values[0:4], np.array([0, 1, 2, 3])
+    )
+    index = mag_test_data["PRI_COARSETM"] == 461971382
+    matching_row = mag_test_data[index]
+
+    for key in status_data.keys():
+        assert status_data[key] == matching_row[key.upper()].values[0]
+
+
+def test_get_time(grouped_data, calibration_dataset):
+    """Tests the get_time function."""
+
+    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():
+    """Tests the extract_magnetic_vectors function."""
+    science_values = xr.DataArray(
+        data=np.array([15797207, 5750698, 15921110, 2342918], dtype=np.uint32)
+    )
+
+    vectors = extract_magnetic_vectors(science_values)
+
+    assert vectors == {
+        "pri_x": 61707,
+        "pri_y": 55127,
+        "pri_z": 49066,
+        "sec_x": 62191,
+        "sec_y": 54819,
+        "sec_z": 49158,
+    }
+
+
+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 = 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():
+            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