imap-processing 0.6.0__py3-none-any.whl

imap_processing/tests/idex/test_idex_l0.py

@@ -0,0 +1,45 @@
+"""Tests the decommutation process for IDEX CCSDS Packets."""
+
+import numpy as np
+import xarray as xr
+
+from imap_processing import imap_module_directory
+
+
+def test_idex_decom_length(decom_test_data: xr.Dataset):
+    """Verify that there are 6 data variables in the output.
+
+    Parameters
+    ----------
+    decom_test_data : xarray.Dataset
+        The dataset to test with
+    """
+    assert len(decom_test_data) == 42
+
+
+def test_idex_decom_event_num(decom_test_data: xr.Dataset):
+    """Verify that 19 impacts were gathered by the test data.
+
+    Parameters
+    ----------
+    decom_test_data : xarray.Dataset
+        The dataset to test with
+    """
+    for var in decom_test_data:
+        assert len(decom_test_data[var]) == 19
+
+
+def test_idex_tof_high_data(decom_test_data: xr.Dataset):
+    """Verify that a sample of the data is correct.
+
+    ``impact_14_tof_high_data.txt`` has been verified correct by the IDEX team
+
+    Parameters
+    ----------
+    decom_test_data : xarray.Dataset
+        The dataset to test with
+    """
+
+    with open(f"{imap_module_directory}/tests/idex/impact_14_tof_high_data.txt") as f:
+        data = np.array([int(line.rstrip("\n")) for line in f])
+    assert (decom_test_data["TOF_High"][13].data == data).all()

imap_processing/tests/idex/test_idex_l1a.py

@@ -0,0 +1,91 @@
+"""Tests the L1 processing for decommutated IDEX data"""
+
+import numpy as np
+import pytest
+import xarray as xr
+from cdflib.xarray.xarray_to_cdf import ISTPError
+
+from imap_processing import imap_module_directory
+from imap_processing.cdf.utils import load_cdf, write_cdf
+
+
+def test_idex_cdf_file(decom_test_data: xr.Dataset):
+    """Verify the CDF file can be created with no errors.
+
+    Parameters
+    ----------
+    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_l1_sci_20230725_v001.cdf"
+
+
+def test_bad_cdf_attributes(decom_test_data: xr.Dataset):
+    """Ensure an ``ISTPError`` is raised when using bad CDF attributes.
+
+    Parameters
+    ----------
+    decom_test_data : xarray.Dataset
+        The dataset to test with
+    """
+    del decom_test_data["TOF_High"].attrs["DEPEND_1"]
+
+    with pytest.raises(ISTPError):
+        write_cdf(decom_test_data)
+
+
+def test_bad_cdf_file_data(decom_test_data: xr.Dataset):
+    """Ensure an ``ISTPError`` is raised when using bad data.
+
+    Parameters
+    ----------
+    decom_test_data : xarray.Dataset
+        The dataset to test with
+    """
+    bad_data_attrs = {
+        "CATDESC": "Bad_Data",
+        "DEPEND_0": "epoch",
+        "DISPLAY_TYPE": "no_plot",
+        "FIELDNAM": "Bad_Data",
+        "FILLVAL": "",
+        "FORMAT": "E12.2",
+        "LABLAXIS": "Bad_Data",
+        "UNITS": "",
+        "VALIDMIN": "1",
+        "VALIDMAX": "50",
+        "VAR_TYPE": "support_data",
+        "VAR_NOTES": """How did this data end up in here?
+                        The CDF creation better fail.""",
+    }
+    bad_data_xr = xr.DataArray(
+        name="bad_data",
+        data=np.linspace(1, 50, 50),
+        dims=("bad_data"),
+        attrs=bad_data_attrs,
+    )
+    decom_test_data["Bad_data"] = bad_data_xr
+
+    with pytest.raises(ISTPError):
+        write_cdf(decom_test_data)
+
+
+def test_idex_tof_high_data_from_cdf(decom_test_data: xr.Dataset):
+    """Verify that a sample of the data is correct inside the CDF file.
+
+    ``impact_14_tof_high_data.txt`` has been verified correct by the IDEX team
+
+    Parameters
+    ----------
+    decom_test_data : xarray.Dataset
+        The dataset to test with
+    """
+    with open(f"{imap_module_directory}/tests/idex/impact_14_tof_high_data.txt") as f:
+        data = np.array([int(line.rstrip()) for line in f])
+
+    file_name = write_cdf(decom_test_data)
+    l1_data = load_cdf(file_name)
+    assert (l1_data["TOF_High"][13].data == data).all()

imap_processing/tests/lo/test_binary_string.py

@@ -0,0 +1,21 @@
+from imap_processing.lo.l0.utils.binary_string import BinaryString
+
+
+def test_binary_string_init():
+    binary = "00101"
+
+    data = BinaryString(binary)
+
+    assert data.bin == "00101"
+    assert data.bit_pos == 0
+
+
+def test_get_bits():
+    binary = "0001110"
+    data = BinaryString(binary)
+
+    first_three_bits = data.next_bits(3)
+    next_four_bits = data.next_bits(4)
+
+    assert first_three_bits == "000"
+    assert next_four_bits == "1110"

imap_processing/tests/lo/test_bit_decompression.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pytest
+
+from imap_processing.lo.l0.utils.bit_decompression import (
+    DECOMPRESSION_TABLES,
+    Decompress,
+    decompress_int,
+)
+
+
+@pytest.mark.parametrize(
+    ("decompression", "compressed_value", "expected_decompressed_int"),
+    [
+        (Decompress.DECOMPRESS8TO16, [209, 250], [9537, 53016]),
+        (Decompress.DECOMPRESS8TO12, [205], [1229]),
+        (Decompress.DECOMPRESS12TO16, [4068], [62908]),
+    ],
+)
+def test_decompress_int(decompression, compressed_value, expected_decompressed_int):
+    """Test decompression for 8to16, 8to12, 12to16."""
+
+    ## Act
+    decompressed_int = decompress_int(
+        compressed_value, decompression, DECOMPRESSION_TABLES
+    )
+
+    ## Assert
+    np.testing.assert_equal(decompressed_int, expected_decompressed_int)
+
+
+def test_decompress_int_invalid_decompression():
+    """Test receiving an invalid decompression input."""
+    ## Arrange
+    decompression = "invalid decompression"
+    compressed_value = 4068
+
+    ## Act / Assert
+    with pytest.raises(ValueError, match="Invalid decompression method"):
+        decompress_int(compressed_value, decompression, DECOMPRESSION_TABLES)

imap_processing/tests/lo/test_lo_l1a.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from imap_processing import imap_module_directory
+from imap_processing.lo.l1a.lo_l1a import lo_l1a
+
+
+@pytest.mark.skip(reason="not implemented")
+@pytest.mark.parametrize(
+    ("dependency", "expected_logical_source"),
+    [
+        (Path("imap_lo_l0_de_20100101_v001.pkts"), "imap_lo_l1a_de"),
+        (
+            Path("imap_lo_l0_spin_20100101_v001.pkt"),
+            "imap_lo_l1a_spin",
+        ),
+    ],
+)
+def test_lo_l1a(dependency, expected_logical_source):
+    # Act
+    output_dataset = lo_l1a(dependency, "001")
+
+    # Assert
+    assert expected_logical_source == output_dataset.attrs["Logical_source"]
+
+
+def test_lo_l1a_dataset():
+    # Arrange
+    dependency = (
+        imap_module_directory / "tests/lo/test_cdfs/imap_lo_l0_raw_20240627_v001.pkts"
+    )
+
+    histogram_fields = [
+        "SHCOARSE",
+        "START_A",
+        "START_C",
+        "STOP_B0",
+        "STOP_B3",
+        "TOF0_COUNT",
+        "TOF1_COUNT",
+        "TOF2_COUNT",
+        "TOF3_COUNT",
+        "TOF0_TOF1",
+        "TOF0_TOF2",
+        "TOF1_TOF2",
+        "SILVER",
+        "DISC_TOF0",
+        "DISC_TOF1",
+        "DISC_TOF2",
+        "DISC_TOF3",
+        "POS0",
+        "POS1",
+        "POS2",
+        "POS3",
+        "HYDROGEN",
+        "OXYGEN",
+    ]
+    hist_fields_lower = [field.lower() for field in histogram_fields]
+
+    # Act
+    output_datasets = lo_l1a(dependency, "001")
+
+    # Assert
+    np.testing.assert_array_equal(hist_fields_lower, output_datasets[0].data_vars)

imap_processing/tests/lo/test_lo_l1b.py

@@ -0,0 +1,74 @@
+from collections import namedtuple
+
+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
+
+
+def test_lo_l1b():
+    # Arrange
+    de_file = (
+        imap_module_directory / "tests/lo/test_cdfs/imap_lo_l1a_de_20100101_v001.cdf"
+    )
+    spin_file = (
+        imap_module_directory / "tests/lo/test_cdfs/imap_lo_l1a_spin_20100101_v001.cdf"
+    )
+    data = {}
+    for file in [de_file, spin_file]:
+        dataset = load_cdf(file)
+        data[dataset.attrs["Logical_source"]] = dataset
+
+    expected_logical_source = "imap_lo_l1b_de"
+    # Act
+    output_file = lo_l1b(data, "001")
+
+    # Assert
+    assert expected_logical_source == output_file.attrs["Logical_source"]
+
+
+def test_create_datasets():
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs(instrument="lo")
+    attr_mgr.add_instrument_variable_attrs(instrument="lo", level="l1b")
+
+    logical_source = "imap_lo_l1b_de"
+
+    data_field_tup = namedtuple("data_field_tup", ["name"])
+    data_fields = [
+        data_field_tup("ESA_STEP"),
+        data_field_tup("MODE"),
+        data_field_tup("TOF0"),
+        data_field_tup("TOF1"),
+        data_field_tup("TOF2"),
+        data_field_tup("TOF3"),
+        data_field_tup("COINCIDENCE_TYPE"),
+        data_field_tup("POS"),
+        data_field_tup("COINCIDENCE"),
+        data_field_tup("BADTIME"),
+        data_field_tup("DIRECTION"),
+    ]
+
+    dataset = create_datasets(attr_mgr, logical_source, data_fields)
+
+    assert len(dataset.tof0.shape) == 1
+    assert dataset.tof0.shape[0] == 3
+    assert len(dataset.tof1.shape) == 1
+    assert dataset.tof1.shape[0] == 3
+    assert len(dataset.tof2.shape) == 1
+    assert dataset.tof2.shape[0] == 3
+    assert len(dataset.tof3.shape) == 1
+    assert dataset.tof3.shape[0] == 3
+    assert len(dataset.mode.shape) == 1
+    assert dataset.mode.shape[0] == 3
+    assert len(dataset.coincidence_type.shape) == 1
+    assert dataset.coincidence_type.shape[0] == 3
+    assert len(dataset.pos.shape) == 1
+    assert dataset.pos.shape[0] == 3
+    assert len(dataset.direction.shape) == 2
+    assert dataset.direction.shape[0] == 3
+    assert dataset.direction.shape[1] == 3
+    assert len(dataset.badtime.shape) == 1
+    assert dataset.badtime.shape[0] == 3
+    assert len(dataset.esa_step.shape) == 1
+    assert dataset.esa_step.shape[0] == 3

imap_processing/tests/lo/test_lo_l1c.py

@@ -0,0 +1,66 @@
+from collections import namedtuple
+
+import numpy as np
+
+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.l1c.lo_l1c import create_datasets, lo_l1c
+
+
+def test_lo_l1c():
+    # Arrange
+    de_file = (
+        imap_module_directory / "tests/lo/test_cdfs/imap_lo_l1b_de_20100101_v001.cdf"
+    )
+    data = {}
+    dataset = load_cdf(de_file)
+    data[dataset.attrs["Logical_source"]] = dataset
+
+    expected_logical_source = "imap_lo_l1c_pset"
+    # Act
+    output_dataset = lo_l1c(data, "001")
+
+    # Assert
+    assert expected_logical_source == output_dataset.attrs["Logical_source"]
+
+
+def test_create_dataset():
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs(instrument="lo")
+    attr_mgr.add_instrument_variable_attrs(instrument="lo", level="l1c")
+
+    logical_source = "imap_lo_l1c_pset"
+
+    data_field_tup = namedtuple("data_field_tup", ["name"])
+    data_fields = [
+        data_field_tup("POINTING_START"),
+        data_field_tup("POINTING_END"),
+        data_field_tup("MODE"),
+        data_field_tup("PIVOT_ANGLE"),
+        data_field_tup("TRIPLES_COUNTS"),
+        data_field_tup("TRIPLES_RATES"),
+        data_field_tup("DOUBLES_COUNTS"),
+        data_field_tup("DOUBLES_RATES"),
+        data_field_tup("HYDROGEN_COUNTS"),
+        data_field_tup("HYDROGEN_RATES"),
+        data_field_tup("OXYGEN_COUNTS"),
+        data_field_tup("OXYGEN_RATES"),
+        data_field_tup("EXPOSURE_TIME"),
+    ]
+
+    dataset = create_datasets(attr_mgr, logical_source, data_fields)
+
+    np.testing.assert_array_equal(dataset.pointing_start, np.ones(1))
+    np.testing.assert_array_equal(dataset.pointing_end, np.ones(1))
+    np.testing.assert_array_equal(dataset.mode, np.ones(1))
+    np.testing.assert_array_equal(dataset.pivot_angle, np.ones(1))
+    np.testing.assert_array_equal(dataset.triples_counts, np.ones((1, 3600, 7)))
+    np.testing.assert_array_equal(dataset.triples_rates, np.ones((1, 3600, 7)))
+    np.testing.assert_array_equal(dataset.doubles_counts, np.ones((1, 3600, 7)))
+    np.testing.assert_array_equal(dataset.doubles_rates, np.ones((1, 3600, 7)))
+    np.testing.assert_array_equal(dataset.hydrogen_counts, np.ones((1, 3600, 7)))
+    np.testing.assert_array_equal(dataset.hydrogen_rates, np.ones((1, 3600, 7)))
+    np.testing.assert_array_equal(dataset.oxygen_counts, np.ones((1, 3600, 7)))
+    np.testing.assert_array_equal(dataset.oxygen_rates, np.ones((1, 3600, 7)))
+    np.testing.assert_array_equal(dataset.exposure_time, np.ones((1, 7)))

imap_processing/tests/lo/test_science_counts.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+from imap_processing.lo.l0.lo_science import decompress
+
+
+def test_decompress_8_to_16_bit():
+    # Arrange
+    # 174 in binary (= 2206 decompressed)
+    idx0 = "10101110"
+    # 20 in binary (= 20 decompressed)
+    idx1 = "00010100"
+    bin_str = idx0 + idx1
+    bits_per_index = 8
+    section_start = 0
+    section_length = 16
+    expected = [2206, 20]
+
+    # Act
+    out = decompress(bin_str, bits_per_index, section_start, section_length)
+
+    # Assert
+    np.testing.assert_equal(out, expected)
+
+
+def test_decompress_12_to_16_bit():
+    # Arrange
+    # 3643 in binary (= 33400 decompressed)
+    idx0 = "111000111011"
+    # 20 in binary (= 20 decompressed
+    idx1 = "000000010100"
+    bin_str = idx0 + idx1
+    bits_per_index = 12
+    section_start = 0
+    section_length = 24
+    expected = [33400, 20]
+
+    # Act
+    out = decompress(bin_str, bits_per_index, section_start, section_length)
+
+    # Assert
+    np.testing.assert_equal(out, expected)

imap_processing/tests/lo/test_science_direct_events.py

@@ -0,0 +1,209 @@
+from collections import namedtuple
+
+import numpy as np
+import pytest
+
+from imap_processing.lo.l0.data_classes.science_direct_events import (
+    ScienceDirectEvents,
+)
+
+
+@pytest.fixture()
+def fake_packet_data():
+    fake_data_type = namedtuple("fake_data_cats", ["header", "data"])
+    fake_data_field = namedtuple("fake_packet", ["raw_value", "derived_value"])
+    return fake_data_type(
+        {
+            "VERSION": fake_data_field(0, 0),
+            "TYPE": fake_data_field(0, 0),
+            "SEC_HDR_FLG": fake_data_field(0, 0),
+            "PKT_APID": fake_data_field(0, 0),
+            "SEQ_FLGS": fake_data_field(0, 0),
+            "SRC_SEQ_CTR": fake_data_field(0, 0),
+            "PKT_LEN": fake_data_field(0, 0),
+        },
+        {
+            "SHCOARSE": fake_data_field(0, 0),
+            "DE_COUNT": fake_data_field(0, 0),
+            "DATA": fake_data_field("00", "00"),
+            "CHKSUM": fake_data_field(0, 0),
+        },
+    )
+
+
+@pytest.fixture()
+def single_de(fake_packet_data):
+    de = ScienceDirectEvents(fake_packet_data, "0", "fakepacketname")
+    de.DE_COUNT = 1
+    de.DE_TIME = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.ESA_STEP = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.MODE = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.TOF0 = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.TOF1 = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.TOF2 = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.TOF3 = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.CKSM = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.POS = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    return de
+
+
+@pytest.fixture()
+def multi_de(fake_packet_data):
+    de = ScienceDirectEvents(fake_packet_data, "0", "fakepacketname")
+    de.DE_COUNT = 2
+    de.DE_TIME = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.ESA_STEP = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.MODE = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.TOF0 = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.TOF1 = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.TOF2 = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.TOF3 = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.CKSM = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    de.POS = np.ones(de.DE_COUNT) * np.float64(-1.0e31)
+    return de
+
+
+def test_parse_data_case_0(single_de):
+    # Arrange
+    absent = "0000"  # case 0
+    time = "000001100100"  # 100
+    energy = "010"  # 2
+    mode = "1"
+    tof0 = "0000000000"
+    # TOF1 not transmitted
+    tof2 = "000000010"  # 2
+    tof3 = "000011"  # 3
+    cksm = "000"  # 0
+    # POS not transmitted
+    single_de.DATA = absent + time + energy + mode + tof0 + tof2 + tof3 + cksm
+
+    expected_time = np.array([100])
+    expected_energy = np.array([2])
+    expected_mode = np.array([1])
+    # tofs and cksm are bit shifted to the left by 1 during decompression
+    expected_tof0 = np.array([0 << 1])
+    expected_tof1 = np.array([np.float64(-1.0e31)])
+    expected_tof2 = np.array([2 << 1])
+    expected_tof3 = np.array([3 << 1])
+    expected_cksm = np.array([0 << 1])
+    expected_pos = np.array([np.float64(-1.0e31)])
+
+    # Act
+    single_de._decompress_data()
+
+    # Assert
+    np.testing.assert_array_equal(single_de.DE_TIME, expected_time)
+    np.testing.assert_array_equal(single_de.ESA_STEP, expected_energy)
+    np.testing.assert_array_equal(single_de.MODE, expected_mode)
+    np.testing.assert_array_equal(single_de.TOF0, expected_tof0)
+    np.testing.assert_array_equal(single_de.TOF1, expected_tof1)
+    np.testing.assert_array_equal(single_de.TOF2, expected_tof2)
+    np.testing.assert_array_equal(single_de.TOF3, expected_tof3)
+    np.testing.assert_array_equal(single_de.CKSM, expected_cksm)
+    np.testing.assert_array_equal(single_de.POS, expected_pos)
+
+
+def test_parse_data_case_10(single_de):
+    # Arrange
+    absent = "1010"  # case 10
+    time = "000001100100"  # 100
+    energy = "010"  # 2
+    mode = "1"
+    # TOF0 not transmitted
+    tof1 = "000000001"  # 1
+    # TOF2, TOF3, CKSM not transmitted
+    pos = "00"  # 0
+    single_de.DATA = absent + time + energy + mode + tof1 + pos
+
+    expected_time = np.array([100])
+    expected_energy = np.array([2])
+    expected_mode = np.array([1])
+    expected_tof0 = np.array([np.float64(-1.0e31)])
+    # tofs and cksm are bit shifted to the left by 1 during decompression
+    expected_tof1 = np.array([1 << 1])
+    expected_tof2 = np.array([np.float64(-1.0e31)])
+    expected_tof3 = np.array([np.float64(-1.0e31)])
+    expected_cksm = np.array([np.float64(-1.0e31)])
+    expected_pos = np.array([0])
+
+    # Act
+    single_de._decompress_data()
+
+    # Assert
+    np.testing.assert_array_equal(single_de.DE_TIME, expected_time)
+    np.testing.assert_array_equal(single_de.ESA_STEP, expected_energy)
+    np.testing.assert_array_equal(single_de.MODE, expected_mode)
+    np.testing.assert_array_equal(single_de.TOF0, expected_tof0)
+    np.testing.assert_array_equal(single_de.TOF1, expected_tof1)
+    np.testing.assert_array_equal(single_de.TOF2, expected_tof2)
+    np.testing.assert_array_equal(single_de.TOF3, expected_tof3)
+    np.testing.assert_array_equal(single_de.CKSM, expected_cksm)
+    np.testing.assert_array_equal(single_de.POS, expected_pos)
+
+
+def test_decompress_data_multi_de(multi_de):
+    # Arrange
+
+    # DE One
+    absent_1 = "0000"  # case 0
+    time_1 = "000001100100"  # 100
+    energy_1 = "010"  # 2
+    mode_1 = "1"
+    tof0_1 = "0000000000"
+    # TOF1 not transmitted
+    tof2_1 = "000000010"  # 2
+    tof3_1 = "000011"  # 3
+    cksm_1 = "000"  # 0
+    # POS not transmitted
+
+    # DE Two
+    absent_2 = "1010"  # case 10
+    time_2 = "000001100100"  # 100
+    energy_2 = "010"  # 2
+    mode_2 = "1"
+    # TOF0 not transmitted
+    tof1_2 = "000000001"  # 1
+    # TOF2, TOF3, CKSM not transmitted
+    pos_2 = "00"  # 0
+
+    multi_de.DATA = (
+        absent_1
+        + time_1
+        + energy_1
+        + mode_1
+        + tof0_1
+        + tof2_1
+        + tof3_1
+        + cksm_1
+        + absent_2
+        + time_2
+        + energy_2
+        + mode_2
+        + tof1_2
+        + pos_2
+    )
+
+    expected_time = np.array([100, 100])
+    expected_energy = np.array([2, 2])
+    expected_mode = np.array([1, 1])
+    # tofs and cksm are bit shifted to the left by 1 during decompression
+    expected_tof0 = np.array([0 << 1, np.float64(-1.0e31)])
+    expected_tof1 = np.array([np.float64(-1.0e31), 1 << 1])
+    expected_tof2 = np.array([2 << 1, np.float64(-1.0e31)])
+    expected_tof3 = np.array([3 << 1, np.float64(-1.0e31)])
+    expected_cksm = np.array([0 << 1, np.float64(-1.0e31)])
+    expected_pos = np.array([np.float64(-1.0e31), 0])
+
+    # Act
+    multi_de._decompress_data()
+
+    # Assert
+    np.testing.assert_array_equal(multi_de.DE_TIME, expected_time)
+    np.testing.assert_array_equal(multi_de.ESA_STEP, expected_energy)
+    np.testing.assert_array_equal(multi_de.MODE, expected_mode)
+    np.testing.assert_array_equal(multi_de.TOF0, expected_tof0)
+    np.testing.assert_array_equal(multi_de.TOF1, expected_tof1)
+    np.testing.assert_array_equal(multi_de.TOF2, expected_tof2)
+    np.testing.assert_array_equal(multi_de.TOF3, expected_tof3)
+    np.testing.assert_array_equal(multi_de.CKSM, expected_cksm)
+    np.testing.assert_array_equal(multi_de.POS, expected_pos)