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

imap_processing/tests/ultra/unit/conftest.py

@@ -1,76 +1,82 @@
-"""Pytest plugin module for test data paths"""
+"""Pytest plugin module for test data paths."""
 
 from unittest import mock
 
 import numpy as np
 import pytest
+import xarray as xr
 
-from imap_processing import decom, imap_module_directory
-from imap_processing.ultra.l0.decom_ultra import process_ultra_apids
+from imap_processing import imap_module_directory
+from imap_processing.ultra.l0.decom_ultra import (
+    process_ultra_events,
+    process_ultra_rates,
+    process_ultra_tof,
+)
 from imap_processing.ultra.l0.ultra_utils import (
     ULTRA_AUX,
     ULTRA_EVENTS,
     ULTRA_RATES,
+    ULTRA_TOF,
 )
-from imap_processing.ultra.l1a import ultra_l1a
+from imap_processing.ultra.l1a.ultra_l1a import ultra_l1a
 from imap_processing.ultra.l1b.ultra_l1b import ultra_l1b
-from imap_processing.utils import group_by_apid
+from imap_processing.utils import packet_file_to_datasets
 
 
-@pytest.fixture()
+@pytest.fixture
 def ccsds_path():
     """Returns the ccsds directory."""
     return (
         imap_module_directory
         / "tests"
         / "ultra"
-        / "test_data"
+        / "data"
         / "l0"
         / "Ultra45_EM_SwRI_Cal_Run7_ThetaScan_20220530T225054.CCSDS"
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def ccsds_path_events():
     """Returns the ccsds directory."""
     return (
         imap_module_directory
         / "tests"
         / "ultra"
-        / "test_data"
+        / "data"
         / "l0"
         / "FM45_7P_Phi0.0_BeamCal_LinearScan_phi0.04_theta-0.01_20230821T121304.CCSDS"
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def ccsds_path_theta_0():
     """Returns the ccsds directory."""
     return (
         imap_module_directory
         / "tests"
         / "ultra"
-        / "test_data"
+        / "data"
         / "l0"
         / "FM45_40P_Phi28p5_BeamCal_LinearScan_phi28.50_theta-0.00"
         "_20240207T102740.CCSDS"
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def ccsds_path_tof():
     """Returns the ccsds directory."""
     return (
         imap_module_directory
         / "tests"
         / "ultra"
-        / "test_data"
+        / "data"
         / "l0"
         / "FM45_TV_Cycle6_Hot_Ops_Front212_20240124T063837.CCSDS"
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def xtce_path():
     """Returns the xtce image rates directory."""
     return (
@@ -81,143 +87,143 @@ def xtce_path():
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def rates_test_path():
     """Returns the xtce image rates test data directory."""
     filename = (
         "ultra45_raw_sc_ultraimgrates_Ultra45_EM_SwRI_Cal_Run7_ThetaScan_"
         "20220530T225054.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
-@pytest.fixture()
+@pytest.fixture
 def aux_test_path():
     """Returns the xtce auxiliary test data directory."""
     filename = (
-        "ultra45_raw_sc_auxdata_Ultra45_EM_SwRI_Cal_Run7_ThetaScan_"
-        "20220530T225054.csv"
+        "ultra45_raw_sc_auxdata_Ultra45_EM_SwRI_Cal_Run7_ThetaScan_20220530T225054.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
-@pytest.fixture()
+@pytest.fixture
 def events_test_path():
     """Returns the xtce auxiliary test data directory."""
     filename = (
         "ultra45_raw_sc_ultrarawimgevent_FM45_7P_Phi00_BeamCal_"
         "LinearScan_phi004_theta-001_20230821T121304.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
-@pytest.fixture()
+@pytest.fixture
 def tof_test_path():
     """Returns the xtce auxiliary test data directory."""
     filename = (
         "ultra45_raw_sc_enaphxtofhangimg_FM45_TV_Cycle6_Hot_Ops_"
         "Front212_20240124T063837.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
-@pytest.fixture()
+@pytest.fixture
 def decom_test_data(request, xtce_path):
     """Read test data from file"""
     apid = request.param["apid"]
     filename = request.param["filename"]
-    ccsds_path = (
-        imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
-    )
+    ccsds_path = imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
+
+    datasets_by_apid = packet_file_to_datasets(ccsds_path, xtce_path)
 
-    packets = decom.decom_packets(ccsds_path, xtce_path)
-    grouped_data = group_by_apid(packets)
+    strategy_dict = {
+        ULTRA_TOF.apid[0]: process_ultra_tof,
+        ULTRA_EVENTS.apid[0]: process_ultra_events,
+        ULTRA_RATES.apid[0]: process_ultra_rates,
+        ULTRA_TOF.apid[1]: process_ultra_tof,
+        ULTRA_EVENTS.apid[1]: process_ultra_events,
+        ULTRA_RATES.apid[1]: process_ultra_rates,
+    }
 
-    data_packet_list = process_ultra_apids(grouped_data[apid], apid)
-    return data_packet_list, packets
+    process_function = strategy_dict.get(apid, lambda *args: False)
+    data_packet_xarray = process_function(datasets_by_apid[apid])
 
+    return data_packet_xarray
 
-@pytest.fixture()
+
+@pytest.fixture
 def events_fsw_comparison_theta_0():
     """FSW test data."""
     filename = (
         "ultra45_raw_sc_ultrarawimg_withFSWcalcs_FM45_40P_Phi28p5_"
         "BeamCal_LinearScan_phi2850_theta-000_20240207T102740.csv"
     )
-    return imap_module_directory / "tests" / "ultra" / "test_data" / "l0" / filename
+    return imap_module_directory / "tests" / "ultra" / "data" / "l0" / filename
 
 
-@pytest.fixture()
+@pytest.fixture
 def de_dataset(ccsds_path_theta_0, xtce_path):
     """L1A test data"""
-    packets = decom.decom_packets(ccsds_path_theta_0, xtce_path)
-    grouped_data = group_by_apid(packets)
-    decom_ultra_events = process_ultra_apids(
-        grouped_data[ULTRA_EVENTS.apid[0]], ULTRA_EVENTS.apid[0]
-    )
-    decom_ultra_aux = process_ultra_apids(
-        grouped_data[ULTRA_AUX.apid[0]], ULTRA_AUX.apid[0]
-    )
-    dataset = ultra_l1a.create_dataset(
-        {
-            ULTRA_EVENTS.apid[0]: decom_ultra_events,
-            ULTRA_AUX.apid[0]: decom_ultra_aux,
-        }
-    )
-    # Remove start_type with fill values
-    l1a_de_dataset = dataset.where(
-        dataset["START_TYPE"] != np.iinfo(np.int64).min, drop=True
-    )
-    return l1a_de_dataset
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_EVENTS.apid[0])
+    return test_data[0]
 
 
-@pytest.fixture()
-def rates_dataset(ccsds_path_theta_0, xtce_path):
+@pytest.fixture
+def rates_dataset(ccsds_path_theta_0):
     """L1A test data"""
-    packets = decom.decom_packets(ccsds_path_theta_0, xtce_path)
-    grouped_data = group_by_apid(packets)
-    decom_ultra_rates = process_ultra_apids(
-        grouped_data[ULTRA_RATES.apid[0]], ULTRA_RATES.apid[0]
-    )
-    l1a_rates_dataset = ultra_l1a.create_dataset(
-        {
-            ULTRA_RATES.apid[0]: decom_ultra_rates,
-        }
-    )
-    return l1a_rates_dataset
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_RATES.apid[0])
+    return test_data[0]
 
 
-@pytest.fixture()
-def aux_dataset(ccsds_path_theta_0, xtce_path):
+@pytest.fixture
+def aux_dataset(ccsds_path_theta_0):
     """L1A test data"""
-    packets = decom.decom_packets(ccsds_path_theta_0, xtce_path)
-    grouped_data = group_by_apid(packets)
-    decom_ultra_aux = process_ultra_apids(
-        grouped_data[ULTRA_AUX.apid[0]], ULTRA_AUX.apid[0]
-    )
-    l1a_aux_dataset = ultra_l1a.create_dataset(
-        {
-            ULTRA_AUX.apid[0]: decom_ultra_aux,
-        }
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_AUX.apid[0])
+    return test_data[0]
+
+
+@pytest.fixture
+def faux_aux_dataset():
+    """Fixture to compute and return aux test data."""
+
+    num_spins = 15
+    spin_duration = 15  # in seconds
+
+    epoch = np.arange(0, num_spins, 1)
+    spin_number = np.arange(127, 142)
+    spin_start_time = np.arange(1905, 2115 + spin_duration, spin_duration)
+    spin_period_sec = np.full(num_spins, 15)
+    spin_period_sec[-1] = 14
+    spin_start_sec = np.arange(1905, 2130, 15)
+    spin_start_subsec = np.zeros(num_spins)
+
+    test_aux_dataset = xr.Dataset(
+        data_vars={
+            "TIMESPINSTART": ("epoch", spin_start_sec),
+            "TIMESPINSTARTSUB": ("epoch", spin_start_subsec),
+            "DURATION": ("epoch", spin_period_sec),
+            "SPINNUMBER": ("epoch", spin_number),
+            "TIMESPINDATA": ("epoch", spin_start_time),
+            "SPINPERIOD": ("epoch", spin_period_sec),
+        },
+        coords={"epoch": ("epoch", epoch)},
     )
-    return l1a_aux_dataset
+
+    return test_aux_dataset
 
 
-@pytest.fixture()
+@pytest.fixture
 @mock.patch("imap_processing.ultra.l1b.de.get_annotated_particle_velocity")
-def l1b_datasets(
-    mock_get_annotated_particle_velocity, de_dataset, use_fake_spin_data_for_time
+def l1b_de_dataset(
+    mock_get_annotated_particle_velocity,
+    de_dataset,
+    use_fake_spin_data_for_time,
 ):
     """L1B test data"""
 
     data_dict = {}
     data_dict[de_dataset.attrs["Logical_source"]] = de_dataset
-    # TODO: this is a placeholder for the hk dataset.
-    data_dict["imap_ultra_l1a_45sensor-hk"] = aux_dataset
-    data_dict["imap_ultra_l1a_45sensor-rates"] = rates_dataset
-    use_fake_spin_data_for_time(
-        de_dataset["EVENTTIMES"][0], de_dataset["EVENTTIMES"][-1]
-    )
+    # Create a spin table that cover spin 0-141
+    use_fake_spin_data_for_time(0, 141 * 15)
 
     # Mock get_annotated_particle_velocity to avoid needing kernels
     def side_effect_func(event_times, position, ultra_frame, dps_frame, sc_frame):
@@ -235,6 +241,26 @@ def l1b_datasets(
 
     mock_get_annotated_particle_velocity.side_effect = side_effect_func
 
-    output_datasets = ultra_l1b(data_dict, data_version="001")
+    output_datasets = ultra_l1b(data_dict)
+
+    return output_datasets
+
+
+@pytest.fixture
+def l1b_extendedspin_dataset(
+    l1b_de_dataset,
+    rates_dataset,
+    faux_aux_dataset,
+):
+    """L1B de test data"""
+    data_dict = {}
+    data_dict["imap_ultra_l1b_45sensor-de"] = l1b_de_dataset[0]
+    data_dict["imap_ultra_l1a_45sensor-aux"] = faux_aux_dataset
+    # TODO: this is a placeholder for the hk dataset.
+    data_dict["imap_ultra_l1a_45sensor-hk"] = faux_aux_dataset
+    data_dict["imap_ultra_l1a_45sensor-rates"] = rates_dataset
+    data_dict["imap_ultra_l1a_45sensor-params"] = l1b_de_dataset[0]
+
+    output_datasets = ultra_l1b(data_dict)
 
     return output_datasets

imap_processing/tests/ultra/unit/test_badtimes.py

@@ -11,6 +11,7 @@ def test_calculate_badtimes():
 
     spin_numbers = np.array([0, 1, 2, 3])
     energy_bins = np.array([10, 20, 30, 40])
+    spin_start_time = np.array([0, 1, 2, 3])
 
     quality_attitude = np.full(
         spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
@@ -31,11 +32,13 @@ def test_calculate_badtimes():
 
     ds = xr.Dataset(
         {
+            "epoch": np.array([0, 1, 2, 3], dtype="datetime64[ns]"),
             "quality_attitude": (("spin_number",), quality_attitude),
             "quality_ena_rates": (
                 ("energy_bin_geometric_mean", "spin_number"),
                 quality_ena_rates,
             ),
+            "spin_start_time": (("spin_number",), spin_start_time),
         },
         coords={
             "spin_number": spin_numbers,
@@ -43,14 +46,11 @@ def test_calculate_badtimes():
         },
     )
 
-    culling_ds = calculate_cullingmask(
-        ds, name="imap_ultra_l1b_45sensor-badtimes", data_version="v1"
-    )
+    culling_ds = calculate_cullingmask(ds, name="imap_ultra_l1b_45sensor-badtimes")
     badtimes_ds = calculate_badtimes(
         ds,
         culling_ds["spin_number"].values,
         name="imap_ultra_l1b_45sensor-badtimes",
-        data_version="v1",
     )
 
     assert not np.any(

imap_processing/tests/ultra/unit/test_cullingmask.py

@@ -10,6 +10,7 @@ def test_calculate_cullingmask_attitude():
 
     spin_numbers = np.array([0, 1])
     energy_bins = np.array([10, 20, 30, 40])
+    spin_start_time = np.array([0, 1])
 
     quality_attitude = np.full(
         spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
@@ -24,11 +25,13 @@ def test_calculate_cullingmask_attitude():
 
     ds = xr.Dataset(
         {
+            "epoch": np.array([0, 1, 2, 3], dtype="datetime64[ns]"),
             "quality_attitude": (("spin_number",), quality_attitude),
             "quality_ena_rates": (
                 ("energy_bin_geometric_mean", "spin_number"),
                 quality_ena_rates,
             ),
+            "spin_start_time": (("spin_number",), spin_start_time),
         },
         coords={
             "spin_number": spin_numbers,
@@ -36,9 +39,7 @@ def test_calculate_cullingmask_attitude():
         },
     )
 
-    result_ds = calculate_cullingmask(
-        ds, name="imap_ultra_l1b_45sensor-cullingmask", data_version="v1"
-    )
+    result_ds = calculate_cullingmask(ds, name="imap_ultra_l1b_45sensor-cullingmask")
 
     np.testing.assert_array_equal(result_ds["spin_number"].values, np.array([0]))
 
@@ -47,6 +48,7 @@ def test_calculate_cullingmask_rates():
     """Test calculate_cullingmask for rates culling."""
     spin_numbers = np.array([0, 1, 2, 3])
     energy_bins = np.array([10, 20, 30, 40])
+    spin_start_time = np.array([0, 1, 2, 3])
 
     quality_attitude = np.full(
         spin_numbers.shape, ImapAttitudeUltraFlags.NONE.value, dtype=np.uint16
@@ -72,16 +74,16 @@ def test_calculate_cullingmask_rates():
                 ("energy_bin_geometric_mean", "spin_number"),
                 quality_ena_rates,
             ),
+            "spin_start_time": (("spin_number",), spin_start_time),
         },
         coords={
+            "epoch": np.array([0, 1, 2, 3], dtype="datetime64[ns]"),
             "spin_number": spin_numbers,
             "energy_bin_geometric_mean": energy_bins,
         },
     )
 
-    result_ds = calculate_cullingmask(
-        ds, name="imap_ultra_l1b_45sensor-cullingmask", data_version="v1"
-    )
+    result_ds = calculate_cullingmask(ds, name="imap_ultra_l1b_45sensor-cullingmask")
 
     expected_spins = np.array([0, 1])
     np.testing.assert_array_equal(result_ds["spin_number"].values, expected_spins)

imap_processing/tests/ultra/unit/test_de.py

@@ -7,7 +7,7 @@ import pytest
 from imap_processing.ultra.constants import UltraConstants
 
 
-@pytest.fixture()
+@pytest.fixture
 def df_filt(de_dataset, events_fsw_comparison_theta_0):
     """Fixture to import test dataset."""
     df = pd.read_csv(events_fsw_comparison_theta_0)
@@ -17,10 +17,13 @@ def df_filt(de_dataset, events_fsw_comparison_theta_0):
     return df_filt
 
 
-def test_calculate_de(l1b_datasets, df_filt):
+def test_calculate_de(l1b_de_dataset, df_filt):
     """Tests calculate_de function."""
 
-    l1b_de_dataset = l1b_datasets[0]
+    l1b_de_dataset = l1b_de_dataset[0]
+    l1b_de_dataset = l1b_de_dataset.where(
+        l1b_de_dataset["start_type"] != 255, drop=True
+    )
     # Front and back positions
     assert np.allclose(l1b_de_dataset["x_front"].data, df_filt["Xf"].astype("float"))
     assert np.allclose(l1b_de_dataset["y_front"], df_filt["Yf"].astype("float"))
@@ -60,7 +63,7 @@ def test_calculate_de(l1b_datasets, df_filt):
             & (l1b_de_dataset["tof_corrected"] < UltraConstants.CTOF_SPECIES_MAX)
         )[0]
     ]
-    assert np.all(species_array == "H")
+    assert np.all(species_array == 1)
 
     # Velocities in various frames
     test_tof = l1b_de_dataset["tof_start_stop"]
@@ -94,8 +97,13 @@ def test_calculate_de(l1b_datasets, df_filt):
         rtol=1e-2,
     )
     assert np.allclose(
-        l1b_de_dataset["azimuth"].values[condition],
-        df_filt["event_phi"].astype("float").values[condition] % (2 * np.pi),
+        l1b_de_dataset["phi"].values,
+        df_filt["phi"].astype("float").values,
+        rtol=1e-2,
+    )
+    assert np.allclose(
+        l1b_de_dataset["theta"].values,
+        df_filt["theta"].astype("float").values,
         rtol=1e-2,
     )
 
@@ -105,10 +113,3 @@ def test_calculate_de(l1b_datasets, df_filt):
         len(l1b_de_dataset["epoch"]),
         3,
     )
-
-    # Event efficiency
-    assert np.allclose(
-        l1b_de_dataset["event_efficiency"],
-        np.full(len(l1b_de_dataset["epoch"]), np.nan),
-        equal_nan=True,
-    )

imap_processing/tests/ultra/unit/test_decom_apid_880.py

@@ -3,96 +3,47 @@ import pandas as pd
 import pytest
 
 from imap_processing.ultra.l0.ultra_utils import ULTRA_AUX
-from imap_processing.utils import group_by_apid
+from imap_processing.utils import packet_file_to_datasets
 
 
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_AUX.apid[0],
-                "filename": "Ultra45_EM_SwRI_Cal_Run7_"
-                "ThetaScan_20220530T225054.CCSDS",
-            }
-        )
-    ],
-    indirect=True,
-)
-def test_aux_enumerated(decom_test_data):
-    """Test if enumerated values derived correctly"""
-
-    _, packets = decom_test_data
-
-    count = 0  # count number of packets with APID 880
-    total_packets = 23
-
-    grouped_data = group_by_apid(packets)
-    apid_data = grouped_data[880]
+@pytest.fixture
+def decom_ultra_aux_data(ccsds_path, xtce_path):
+    """Data for decom_ultra_aux"""
 
-    for packet in apid_data:
-        assert packet["SPINPERIODVALID"] == "INVALID"
-        assert packet["SPINPHASEVALID"] == "VALID"
-        assert packet["SPINPERIODSOURCE"] == "NOMINAL"
-        assert packet["CATBEDHEATERFLAG"] == "UNFLAGGED"
-        count += 1
+    datasets_by_apid = packet_file_to_datasets(ccsds_path, xtce_path)
+    decom_ultra_dataset = datasets_by_apid[ULTRA_AUX.apid[0]]
+    return decom_ultra_dataset
 
-    assert count == total_packets
 
-
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_AUX.apid[0],
-                "filename": "Ultra45_EM_SwRI_Cal_Run7_"
-                "ThetaScan_20220530T225054.CCSDS",
-            }
-        )
-    ],
-    indirect=True,
-)
-def test_aux_mode(decom_test_data):
+def test_aux_modes(decom_ultra_aux_data):
     """Test if enumerated values derived correctly"""
 
-    _, packets = decom_test_data
+    assert np.all(decom_ultra_aux_data["spinperiodvalid"] == 0)
+    assert np.all(decom_ultra_aux_data["spinphasevalid"] == 1)
+    assert np.all(decom_ultra_aux_data["spinperiodsource"] == 1)
+    assert np.all(decom_ultra_aux_data["catbedheaterflag"] == 0)
+    assert np.all(decom_ultra_aux_data["hwmode"] == 0)
+    assert np.all(decom_ultra_aux_data["imcenb"] == 0)
+    assert np.all(decom_ultra_aux_data["leftdeflectioncharge"] == 0)
+    assert np.all(decom_ultra_aux_data["rightdeflectioncharge"] == 0)
 
-    for packet in packets:
-        if packet["PKT_APID"] == 880:
-            assert packet["HWMODE"] == "MODE0"
-            assert packet["IMCENB"] == "MODE0"
-            assert packet["LEFTDEFLECTIONCHARGE"] == "MODE0"
-            assert packet["RIGHTDEFLECTIONCHARGE"] == "MODE0"
+    assert len(decom_ultra_aux_data["shcoarse"]) == 23
 
 
-@pytest.mark.parametrize(
-    "decom_test_data",
-    [
-        pytest.param(
-            {
-                "apid": ULTRA_AUX.apid[0],
-                "filename": "Ultra45_EM_SwRI_Cal_Run7_"
-                "ThetaScan_20220530T225054.CCSDS",
-            }
-        )
-    ],
-    indirect=True,
-)
-def test_aux_decom(decom_test_data, aux_test_path):
+def test_aux_decom(decom_ultra_aux_data, aux_test_path):
     """This function reads validation data and checks that
     decom data matches validation data for auxiliary packet"""
 
-    decom_ultra, _ = decom_test_data
-
     df = pd.read_csv(aux_test_path, index_col="MET")
 
-    np.testing.assert_array_equal(df.SpinStartSeconds, decom_ultra["TIMESPINSTART"])
     np.testing.assert_array_equal(
-        df.SpinStartSubseconds, decom_ultra["TIMESPINSTARTSUB"]
+        df.SpinStartSeconds, decom_ultra_aux_data["timespinstart"]
+    )
+    np.testing.assert_array_equal(
+        df.SpinStartSubseconds, decom_ultra_aux_data["timespinstartsub"]
     )
-    np.testing.assert_array_equal(df.SpinDuration, decom_ultra["DURATION"])
-    np.testing.assert_array_equal(df.SpinNumber, decom_ultra["SPINNUMBER"])
-    np.testing.assert_array_equal(df.SpinDataTime, decom_ultra["TIMESPINDATA"])
-    np.testing.assert_array_equal(df.SpinPeriod, decom_ultra["SPINPERIOD"])
-    np.testing.assert_array_equal(df.SpinPhase, decom_ultra["SPINPHASE"])
+    np.testing.assert_array_equal(df.SpinDuration, decom_ultra_aux_data["duration"])
+    np.testing.assert_array_equal(df.SpinNumber, decom_ultra_aux_data["spinnumber"])
+    np.testing.assert_array_equal(df.SpinDataTime, decom_ultra_aux_data["timespindata"])
+    np.testing.assert_array_equal(df.SpinPeriod, decom_ultra_aux_data["spinperiod"])
+    np.testing.assert_array_equal(df.SpinPhase, decom_ultra_aux_data["spinphase"])