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

imap_processing/tests/idex/test_idex_l1a.py

@@ -22,11 +22,10 @@ def test_idex_cdf_file(decom_test_data: xr.Dataset):
     decom_test_data : xarray.Dataset
         The dataset to test with
     """
-
     file_name = write_cdf(decom_test_data)
 
     assert file_name.exists()
-    assert file_name.name == "imap_idex_l1a_sci_20231214_v001.cdf"
+    assert file_name.name == "imap_idex_l1a_sci-1week_20231218_v001.cdf"
 
 
 def test_bad_cdf_attributes(decom_test_data: xr.Dataset):
@@ -41,7 +40,7 @@ def test_bad_cdf_attributes(decom_test_data: xr.Dataset):
     del decom_test_data["TOF_High"].attrs["CATDESC"]
 
     with pytest.raises(ISTPError):
-        write_cdf(decom_test_data)
+        write_cdf(decom_test_data, istp=True, terminate_on_warning=True)
 
     # Add attributes back so future tests do not fail
     decom_test_data["TOF_High"].attrs["CATDESC"] = tof_catdesc
@@ -79,7 +78,7 @@ def test_bad_cdf_file_data(decom_test_data: xr.Dataset):
     decom_test_data["Bad_data"] = bad_data_xr
 
     with pytest.raises(ISTPError):
-        write_cdf(decom_test_data)
+        write_cdf(decom_test_data, istp=True, terminate_on_warning=True)
 
     del decom_test_data["Bad_data"]
 
@@ -104,6 +103,51 @@ def test_idex_tof_high_data_from_cdf(decom_test_data: xr.Dataset):
     assert (l1_data["TOF_High"][13].data == data).all()
 
 
+def test_validate_l1a_idex_data_variables(
+    decom_test_data: xr.Dataset, l1a_example_data: xr.Dataset
+):
+    """
+    Verify that each of the 6 waveform and telemetry arrays are equal to the
+    corresponding array produced by the IDEX team using the same l0 file.
+
+
+    Parameters
+    ----------
+    decom_test_data : xarray.Dataset
+        The dataset to test with
+    l1a_example_data: xarray.Dataset
+        A dataset containing the 6 waveform and telemetry arrays
+    """
+    # Lookup table to match the SDS array names to the Idex Team array names
+    match_variables = {
+        "TOF L": "TOF_Low",
+        "TOF H": "TOF_High",
+        "TOF M": "TOF_Mid",
+        "Target H": "Target_High",
+        "Target L": "Target_Low",
+        "Ion Grid": "Ion_Grid",
+        "Time (high sampling)": "time_high_sample_rate",
+        "Time (low sampling)": "time_low_sample_rate",
+    }
+    # The Engineering data is converting to UTC, and the SDC is converting to J2000,
+    # for 'epoch' and 'Timestamp' so this test is using the raw time value 'SCHOARSE' to
+    # validate time
+    arrays_to_skip = ["Timestamp", "Epoch", "event"]
+
+    # loop through all keys from the l1a example dict
+    for var in l1a_example_data.variables:
+        if var not in arrays_to_skip:
+            # Find the corresponding array name
+            cdf_var = match_variables.get(var, var.lower())
+
+            np.testing.assert_array_equal(
+                decom_test_data[cdf_var],
+                l1a_example_data[var],
+                f"The array '{cdf_var}' does not equal the expected example "
+                f"array '{var}' produced by the IDEX team",
+            )
+
+
 def test_compressed_packet():
     """
     Test compressed data decompression against known non-compressed data.

imap_processing/tests/idex/test_idex_l1b.py

@@ -65,7 +65,7 @@ def test_l1b_cdf_filenames(l1b_dataset: xr.Dataset):
     l1b_dataset : xr.Dataset
         A ``xarray`` dataset containing the test data
     """
-    expected_src = "imap_idex_l1b_sci"
+    expected_src = "imap_idex_l1b_sci-1week"
     assert l1b_dataset.attrs["Logical_source"] == expected_src
 
 
@@ -81,7 +81,7 @@ def test_idex_cdf_file(l1b_dataset: xr.Dataset):
     file_name = write_cdf(l1b_dataset)
 
     assert file_name.exists()
-    assert file_name.name == "imap_idex_l1b_sci_20231214_v001.cdf"
+    assert file_name.name == "imap_idex_l1b_sci-1week_20231218_v001.cdf"
 
 
 def test_idex_waveform_units(l1b_dataset: xr.Dataset):
@@ -100,7 +100,7 @@ def test_idex_waveform_units(l1b_dataset: xr.Dataset):
     # Check instrument setting units
     for _, row in cdf_var_defs.iterrows():
         var_name = row["mnemonic"]
-        assert l1b_dataset[var_name].attrs["units"] == row["unit"]
+        assert l1b_dataset[var_name].attrs["UNITS"] == row["unit"]
 
     # Check waveform units
     waveform_var_names = [

imap_processing/tests/idex/test_idex_l2a.py

@@ -0,0 +1,383 @@
+"""Tests the L2a processing for IDEX data"""
+
+from unittest import mock
+
+import numpy as np
+import pytest
+import xarray as xr
+from scipy.stats import exponnorm
+
+from imap_processing.idex import idex_constants
+from imap_processing.idex.idex_l1b import idex_l1b
+from imap_processing.idex.idex_l2a import (
+    BaselineNoiseTime,
+    analyze_peaks,
+    butter_lowpass_filter,
+    calculate_kappa,
+    calculate_snr,
+    estimate_dust_mass,
+    fit_impact,
+    idex_l2a,
+    remove_signal_noise,
+    time_to_mass,
+)
+
+
+def mock_microphonics_noise(time: np.ndarray) -> np.ndarray:
+    """Function to mock signal noise (linear and sine wave) due to microphonics."""
+    noise_frequency = idex_constants.TARGET_NOISE_FREQUENCY
+    phase_shift = 45
+    amp = 10
+    # Create a sine wave signal
+    sine_signal = amp * np.sin(2 * np.pi * noise_frequency * time + phase_shift)
+    # Combine the sine wave signals with a linear signal to create noise
+    combined_sig = sine_signal + (time * 5)
+
+    return combined_sig
+
+
+@pytest.fixture(scope="module")
+def l2a_dataset(decom_test_data: xr.Dataset) -> xr.Dataset:
+    """Return a ``xarray`` dataset containing test data.
+
+    Returns
+    -------
+    dataset : xr.Dataset
+        A ``xarray`` dataset containing the test data
+    """
+    with mock.patch("imap_processing.idex.idex_l1b.get_spice_data", return_value={}):
+        dataset = idex_l2a(
+            idex_l1b(decom_test_data, data_version="001"), data_version="001"
+        )
+    return dataset
+
+
+def test_l2a_cdf_filenames(l2a_dataset: xr.Dataset):
+    """Tests that the ``idex_l2a`` function generates datasets
+    with the expected logical source.
+
+    Parameters
+    ----------
+    l2a_dataset : xr.Dataset
+        A ``xarray`` dataset containing the test data
+    """
+    expected_src = "imap_idex_l2a_sci-1week"
+    assert l2a_dataset.attrs["Logical_source"] == expected_src
+
+
+def test_l2a_cdf_variables(l2a_dataset: xr.Dataset):
+    """Tests that the ``idex_l2a`` function generates datasets
+    with the expected variables.
+
+    Parameters
+    ----------
+    l2a_dataset : xr.Dataset
+        A ``xarray`` dataset containing the test data
+    """
+    expected_vars = [
+        "mass",
+        "target_low_fit_parameters",
+        "target_low_fit_imapct_charge",
+        "target_low_fit_imapct_mass_estimate",
+        "target_low_chi_squared",
+        "target_low_reduced_chi_squared",
+        "target_low_fit_results",
+        "target_high_fit_parameters",
+        "target_high_fit_imapct_charge",
+        "target_high_fit_imapct_mass_estimate",
+        "target_high_chi_squared",
+        "target_high_reduced_chi_squared",
+        "target_high_fit_results",
+        "ion_grid_fit_parameters",
+        "ion_grid_fit_imapct_charge",
+        "ion_grid_fit_imapct_mass_estimate",
+        "ion_grid_chi_squared",
+        "ion_grid_reduced_chi_squared",
+        "ion_grid_fit_results",
+    ]
+
+    cdf_vars = l2a_dataset.variables
+    for var in expected_vars:
+        assert var in cdf_vars
+
+
+def test_time_to_mass_zero_lag():
+    """
+    Tests that the time_to_mass function correctly converts time-of-flight
+    to a mass scale using known peak positions.
+    """
+    carbon_mass = 12
+    masses = np.asarray([1, 4, 9])
+
+    expected_lag = 10
+    expected_stretch = 1500
+    # Create a 2d time of flight array exactly where we would expect the peaks to be
+    # Each mass should appear at time t = 1400 * sqrt(m) ns
+    tof = np.zeros((15, int(np.sqrt(masses[-1]) * expected_stretch + 1 + expected_lag)))
+    min_stretch = 1400
+    # Mass 1 expected tof
+    tof[:-1, min_stretch] = 1
+    # Mass 4 expected tof
+    tof[:-1, min_stretch * 2] = 1
+    # Mass 9 expected tof
+    tof[:-1, min_stretch * 3] = 1
+    # Change the last TOF array to be shifted and 'stretched'
+    # Mass 1 expected tof
+    tof[-1, expected_stretch + expected_lag] = 1
+    # Mass 4 expected tof
+    tof[-1, expected_stretch * 2 + expected_lag] = 1
+    # Mass 9 expected tof
+    tof[-1, expected_stretch * 3 + expected_lag] = 1
+
+    time = np.tile(np.arange(len(tof[0])), (15, 1))
+    stretch, shift, mass_scale = time_to_mass(tof, time, masses)
+
+    # Test with carbon mass
+    carbon_time = (stretch[0] * np.sqrt(carbon_mass)) / 1e-6  # Convert ms to s
+    mass = np.interp(carbon_time, time[0], mass_scale[0])
+    assert np.allclose(carbon_mass, mass, rtol=1e-2)
+
+    # Test shift is zero since peaks are aligned
+    assert np.all(shift[:-1] == 0)
+    # Test stretch factor matches expected 1400 ns in seconds
+    assert np.all(stretch[:-1] == 1400 * 1e-9)
+    # Test output shape
+    assert mass_scale.shape == time.shape
+    # Test that the last shift and stretch are the expected values
+    assert shift[-1] == -expected_lag * idex_constants.FM_SAMPLING_RATE
+    # Test stretch factor matches expected 1400 ns in seconds
+    assert stretch[-1] == expected_stretch * 1e-9
+
+    # Test with carbon mass
+    carbon_time = (stretch[-1] * np.sqrt(carbon_mass) + shift[-1]) / 1e-6
+    mass = np.interp(carbon_time, time[-1], mass_scale[-1])
+    assert np.allclose(carbon_mass, mass, rtol=1e-2)
+
+
+def test_time_to_mass_zero_correlation_warning(caplog):
+    """
+    Tests that the time_to_mass function correctly logs a warning if zero correlations
+    are found between the TOF and expected mass times array.
+    """
+    masses = np.asarray([1, 4, 9])
+    # Create a time of flight array that will result in no correlation between the
+    # Expected tof peaks.
+    tof = np.zeros((10, 8000))
+    time = np.tile(np.arange(len(tof[0])), (10, 1))
+    with caplog.at_level("WARNING"):
+        time_to_mass(tof, time, masses)
+
+    assert any(
+        "There are no correlations found between the"
+        " TOF array and the expected mass times array" in message
+        for message in caplog.text.splitlines()
+    )
+
+
+def test_calculate_kappa():
+    """Tests the functionality of calculate_kappa()."""
+    # Create a 2d list of peak indices
+    peaks = [[0, 1], [1, 2], [0, 1, 2]]
+
+    # Create mass_scales array
+    mass_scales = np.array(
+        [
+            [1.2, 2.2, 3.2],  # The kappa value for peaks 0,1 should be .2
+            [1.4, 2.4, 3.4],  # The kappa value for peaks 1,2 should be .4
+            [1.7, 2.7, 3.7],  # The kappa value for peaks 2,3,4 should be -0.3
+        ]
+    )
+    kappas = calculate_kappa(mass_scales, peaks)
+
+    assert np.allclose(list(kappas), [0.2, 0.4, -0.3], rtol=1e-12)
+
+
+def test_calculate_snr():
+    """Tests the functionality of calculate_snr()."""
+    step = 0.5
+    max_tof = 10
+    time = np.arange(BaselineNoiseTime.START, 5, step)
+
+    # Create a baseline noise array with an std of 1 and mean of 1
+    baseline_noise = np.asarray([0, 0, 1, 2, 2])
+    signal_length = len(time) - len(baseline_noise)
+    tof_signal = np.full(int(signal_length), max_tof)
+
+    tof = np.tile(np.append(baseline_noise, tof_signal), (3, 1))
+    time = np.tile(time, (3, 1))
+
+    snr = calculate_snr(tof, time)
+
+    # Since std=1 and mean=1, SNR should be (max_tof - mean)/std
+    assert np.all(snr == (max_tof - 1))
+
+
+def test_calculate_snr_warning(caplog):
+    """Tests that calculate_snr() throws warning if no baseline noise is found."""
+    time = np.tile(np.arange(10), (3, 1))
+    tof = np.ones_like(time)
+
+    with caplog.at_level("WARNING"):
+        calculate_snr(tof, time)
+    assert any(
+        "Unable to find baseline noise" in message
+        for message in caplog.text.splitlines()
+    )
+
+
+def test_analyze_peaks_warning(caplog):
+    """Tests that analyze_peaks() throws warning if the emg curve fit fails."""
+    # Create a 2d list of peak indices
+    peaks = [[2]]
+    time = xr.DataArray(np.arange(6))
+    # When there is a flat signal for TOF, we expect the fit to fail and a
+    # warning to be logged.
+    tof = np.ones_like(time)
+    mass_scale = np.ones_like(time)
+    with caplog.at_level("WARNING"):
+        fit_params, area_under_curve = analyze_peaks(tof, time, mass_scale, 0, peaks)
+    assert any(
+        "Failed to fit EMG curve" in message for message in caplog.text.splitlines()
+    )
+
+    # The fit_params and area_under_curve arrays should be zero
+    assert np.all(fit_params == 0)
+    assert np.all(area_under_curve == 0)
+
+
+def test_analyze_peaks_perfect_fits():
+    """Tests that analyze_peaks() returns the expected fit params and areas."""
+    event = 0
+    # Create a 2d list of peak indices
+    peak_1 = 7
+    peak_2 = 25
+    peak_3 = 80
+    # Create tof array of ones
+    time = xr.DataArray(np.arange(100))
+    tof = np.zeros(100)
+    mass_scale = np.arange(100) + 0.5
+    # Only test peaks[0] this function is not vectorized but we pass in the full 2d peak
+    # array.
+    peaks = [np.asarray([peak_1, peak_2, peak_3]), np.asarray([])]
+    sigma = 2.0
+    lam = 1.0
+    k = 1 / (lam * sigma)
+    # Create a tof array with an emg curve at each peak
+    for peak in peaks[event]:
+        # Create a perfect emg curve
+        mu = peak - 0.4
+        gauss = exponnorm.pdf(time.data, k, mu, sigma)
+        tof[peak - 5 : peak + 6] = gauss[peak - 5 : peak + 6]
+
+    fit_params, area_under_curve = analyze_peaks(tof, time, mass_scale, event, peaks)
+
+    for peak in peaks[event]:
+        mu = peak - 0.4
+        mass = round(mass_scale[round(mu)])
+        # Test that the fitted parameters at the mass index match our input parameters
+        assert np.allclose(fit_params[mass], np.asarray([mu, sigma, lam]), rtol=1e-12)
+        # Test that there is a value greater than zero at this index
+        assert area_under_curve[mass] > 0
+
+
+def test_estimate_dust_mass_no_noise_removal():
+    """
+    Test that estimate_dust_mass() is fitting the signal properly when there is no
+    noise removal.
+    """
+    # TODO: The IDEX team is iterating on this function and will provide more
+    #  information soon.
+    start_time = -60
+    total_low_sampling_microseconds = 126.03  # see algorithm document.
+    num_samples = 512
+
+    # Create realistic low sampling time
+    time = xr.DataArray(
+        np.linspace(
+            start_time, total_low_sampling_microseconds - start_time, num_samples
+        )
+    )
+    signal = xr.DataArray(
+        fit_impact(
+            time.data,
+            time_of_impact=0.0,
+            constant_offset=1.0,
+            amplitude=10.0,
+            rise_time=0.371,
+            discharge_time=0.371,
+        )
+    )
+    param, sig_amp, chisqr, redchi, result = estimate_dust_mass(
+        time, signal, remove_noise=False
+    )
+    # Assert that the chi square value indicates a very good fit
+    assert chisqr <= 1e-12
+
+    assert np.allclose(result, signal)
+
+
+def test_lowpass_filter():
+    """
+    Tests that the lowpass filter is filtering out high frequency signals.
+
+    Look at
+    https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.filtfilt.html#scipy.signal.filtfilt
+    for the source of the testing example.
+    """
+
+    time = np.linspace(-60, 60, 512)
+    # Calculate nyquist frequency to help get cutoff.
+    # This is the highest frequency that can be captured
+    time_between_samples = time[1] - time[0]
+    nqf = (1 / time_between_samples) / 2
+    # Choose cutoff of 0.125 times the Nyquist frequency
+    cutoff = nqf * 0.125
+    # Create two signals with different frequencies and combine them
+    low_freq = cutoff / 4  # Lower than cutoff
+    high_freq = nqf  # The nyquist frequency is much higher than the cutoff
+    # Create sine signals
+    signal_low = np.sin(2 * np.pi * low_freq * time)
+    signal_high = np.sin(2 * np.pi * high_freq * time)
+    combined_sig = signal_low + signal_high
+    # The filter should filter out the high frequency signal
+    filtered_sig = butter_lowpass_filter(time, combined_sig, cutoff)
+    # Assert that the filtered signal is relatively close to the original low
+    # frequency signal.
+    np.allclose(filtered_sig, signal_low)
+
+
+def test_remove_signal_noise():
+    """
+    Tests that remove_signal_noise() function is filtering out sine wave and linear
+    noise due to "microphonics"
+    """
+    start_time = -60
+    total_low_sampling_microseconds = 126.03  # see algorithm document.
+    num_samples = 512
+
+    # Create realistic low sampling time
+    time = np.linspace(
+        start_time, total_low_sampling_microseconds - start_time, num_samples
+    )
+
+    mask = time <= (start_time + total_low_sampling_microseconds) / 2
+    noisy_signal = mock_microphonics_noise(time)
+    # Filter signal
+    filtered_sig = remove_signal_noise(time, noisy_signal, mask)
+
+    np.allclose(filtered_sig, np.zeros_like(filtered_sig), atol=1e-2)
+
+
+def test_remove_signal_noise_no_sine_wave(caplog):
+    """
+    Tests that remove_signal_noise() function filters linear noise when there is no
+    sine wave.
+    """
+    time = np.linspace(-60, 60, 512)
+    # linear signal to create noise
+    signal = time * 10
+    mask = time <= 0.5
+    # Filter signal
+    filtered_sig = remove_signal_noise(time, signal, mask)
+    # Test that the filtered signal is close to zero
+    assert np.allclose(filtered_sig, np.zeros_like(filtered_sig), rtol=1e-24)

imap_processing/tests/lo/test_lo_l1b.py

@@ -1,18 +1,53 @@
 from collections import namedtuple
 
+import numpy as np
+import pytest
+import xarray as xr
+
 from imap_processing import imap_module_directory
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.cdf.utils import load_cdf
-from imap_processing.lo.l1b.lo_l1b import create_datasets, lo_l1b
+from imap_processing.lo.l1b.lo_l1b import (
+    convert_start_end_acq_times,
+    create_datasets,
+    get_avg_spin_durations,
+    get_spin_angle,
+    initialize_l1b_de,
+    lo_l1b,
+    set_spin_bin,
+)
+
+
+@pytest.fixture()
+def dependencies():
+    return {
+        "imap_lo_l1a_de": load_cdf(
+            imap_module_directory
+            / "tests/lo/test_cdfs/imap_lo_l1a_de_20241022_v002.cdf"
+        ),
+        "imap_lo_l1a_spin": load_cdf(
+            imap_module_directory
+            / "tests/lo/test_cdfs/imap_lo_l1a_spin_20241022_v002.cdf"
+        ),
+    }
+
+
+@pytest.fixture()
+def attr_mgr_l1b():
+    attr_mgr_l1b = ImapCdfAttributes()
+    attr_mgr_l1b.add_instrument_global_attrs(instrument="lo")
+    attr_mgr_l1b.add_instrument_variable_attrs(instrument="lo", level="l1b")
+    attr_mgr_l1b.add_global_attribute("Data_version", "000")
+    return attr_mgr_l1b
 
 
 def test_lo_l1b():
     # Arrange
     de_file = (
-        imap_module_directory / "tests/lo/test_cdfs/imap_lo_l1a_de_20100101_v001.cdf"
+        imap_module_directory / "tests/lo/test_cdfs/imap_lo_l1a_de_20241022_v002.cdf"
     )
     spin_file = (
-        imap_module_directory / "tests/lo/test_cdfs/imap_lo_l1a_spin_20100101_v001.cdf"
+        imap_module_directory / "tests/lo/test_cdfs/imap_lo_l1a_spin_20241022_v002.cdf"
     )
     data = {}
     for file in [de_file, spin_file]:
@@ -24,7 +59,7 @@ def test_lo_l1b():
     output_file = lo_l1b(data, "001")
 
     # Assert
-    assert expected_logical_source == output_file.attrs["Logical_source"]
+    assert expected_logical_source == output_file[0].attrs["Logical_source"]
 
 
 def test_create_datasets():
@@ -72,3 +107,112 @@ def test_create_datasets():
     assert dataset.badtime.shape[0] == 3
     assert len(dataset.esa_step.shape) == 1
     assert dataset.esa_step.shape[0] == 3
+
+
+def test_initialize_dataset(dependencies, attr_mgr_l1b):
+    # Arrange
+    l1a_de = dependencies["imap_lo_l1a_de"]
+    logical_source = "imap_lo_l1b_de"
+
+    # Act
+    l1b_de = initialize_l1b_de(l1a_de, attr_mgr_l1b, logical_source)
+
+    # Assert
+    assert l1b_de.attrs["Logical_source"] == logical_source
+    assert list(l1b_de.coords.keys()) == []
+    assert len(l1b_de.data_vars) == 4
+    assert len(l1b_de.coords) == 0
+    for l1b_name, l1a_name in {
+        "pos": "pos",
+        "mode": "mode",
+        "absent": "coincidence_type",
+        "esa_step": "esa_step",
+    }.items():
+        assert l1b_name in l1b_de.data_vars
+        np.testing.assert_array_equal(l1b_de[l1b_name], l1a_de[l1a_name])
+
+
+def test_convert_start_end_acq_times():
+    # Arrange
+    spin = xr.Dataset(
+        {
+            "acq_start_sec": ("epoch", [1, 2, 3]),
+            "acq_start_subsec": ("epoch", [4, 5, 6]),
+            "acq_end_sec": ("epoch", [7, 8, 9]),
+            "acq_end_subsec": ("epoch", [10, 11, 12]),
+        },
+        coords={"epoch": [0, 1, 2]},
+    )
+
+    acq_start_expected = xr.DataArray(
+        [
+            spin["acq_start_sec"][0] + spin["acq_start_subsec"][0] * 1e-6,
+            spin["acq_start_sec"][1] + spin["acq_start_subsec"][1] * 1e-6,
+            spin["acq_start_sec"][2] + spin["acq_start_subsec"][2] * 1e-6,
+        ],
+        dims="epoch",
+    )
+    acq_end_expected = xr.DataArray(
+        [
+            spin["acq_end_sec"][0] + spin["acq_end_subsec"][0] * 1e-6,
+            spin["acq_end_sec"][1] + spin["acq_end_subsec"][1] * 1e-6,
+            spin["acq_end_sec"][2] + spin["acq_end_subsec"][2] * 1e-6,
+        ],
+        dims="epoch",
+    )
+
+    # Act
+    acq_start, acq_end = convert_start_end_acq_times(spin)
+
+    # Assert
+    np.testing.assert_array_equal(acq_start.values, acq_start_expected.values)
+    np.testing.assert_array_equal(acq_end.values, acq_end_expected.values)
+
+
+def test_get_avg_spin_durations():
+    # Arrange
+    acq_start = xr.DataArray([0, 423, 846.2], dims="epoch")
+    acq_end = xr.DataArray([422.8, 846, 1269.7], dims="epoch")
+    expected_avg_spin_durations = np.array([422.8, 423, 423.5]) / 28
+
+    # Act
+    avg_spin_durations = get_avg_spin_durations(acq_start, acq_end)
+
+    # Assert
+    np.testing.assert_array_equal(avg_spin_durations, expected_avg_spin_durations)
+
+
+def test_get_spin_angle():
+    # Arrange
+    de = xr.Dataset(
+        {
+            "de_count": ("epoch", [2, 3]),
+            "de_time": ("direct_event", [0000, 1000, 2000, 3000, 4000]),
+        },
+        coords={"epoch": [0, 1], "direct_event": [0, 1, 2, 3, 4]},
+    )
+    spin_angle_expected = np.array([0, 87.89, 175.78, 263.67, 351.56])
+
+    # Act
+    spin_angle = get_spin_angle(de)
+
+    # Assert
+    np.testing.assert_allclose(
+        spin_angle,
+        spin_angle_expected,
+        atol=1e-2,
+        err_msg=f"Spin angle: {spin_angle} vs {spin_angle_expected}",
+    )
+
+
+def test_spin_bin():
+    # Arrange
+    l1b_de = xr.Dataset()
+    spin_angle = np.array([0, 50, 150, 250, 365])
+    expected_spin_bins = np.array([0, 8, 25, 41, 60])
+
+    # Act
+    l1b_de = set_spin_bin(l1b_de, spin_angle)
+
+    # Assert
+    np.testing.assert_array_equal(l1b_de["spin_bin"], expected_spin_bins)

imap_processing/tests/lo/test_lo_science.py

@@ -261,6 +261,7 @@ def test_combine_segmented_packets(segmented_pkts_fake_data):
         ),
     )
     np.testing.assert_array_equal(dataset["epoch"].values, np.array([0, 10, 30]))
+    np.testing.assert_array_equal(dataset["met"].values, np.array([0, 10, 30]))
 
 
 def test_validate_parse_events(sample_data, attr_mgr):