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

imap_processing/tests/ultra/unit/conftest.py

@@ -1,4 +1,4 @@
-"""Pytest plugin module for test data paths"""
+"""Pytest plugin module for test data paths."""
 
 from unittest import mock
 
@@ -6,19 +6,24 @@ 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 (
@@ -31,7 +36,7 @@ def ccsds_path():
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def ccsds_path_events():
     """Returns the ccsds directory."""
     return (
@@ -44,7 +49,7 @@ def ccsds_path_events():
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def ccsds_path_theta_0():
     """Returns the ccsds directory."""
     return (
@@ -58,7 +63,7 @@ def ccsds_path_theta_0():
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def ccsds_path_tof():
     """Returns the ccsds directory."""
     return (
@@ -71,7 +76,7 @@ def ccsds_path_tof():
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def xtce_path():
     """Returns the xtce image rates directory."""
     return (
@@ -82,7 +87,7 @@ def xtce_path():
     )
 
 
-@pytest.fixture()
+@pytest.fixture
 def rates_test_path():
     """Returns the xtce image rates test data directory."""
     filename = (
@@ -92,17 +97,16 @@ def rates_test_path():
     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" / "data" / "l0" / filename
 
 
-@pytest.fixture()
+@pytest.fixture
 def events_test_path():
     """Returns the xtce auxiliary test data directory."""
     filename = (
@@ -112,7 +116,7 @@ def events_test_path():
     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 = (
@@ -122,21 +126,31 @@ def tof_test_path():
     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" / "data" / "l0" / filename
 
-    packets = decom.decom_packets(ccsds_path, xtce_path)
-    grouped_data = group_by_apid(packets)
+    datasets_by_apid = packet_file_to_datasets(ccsds_path, xtce_path)
+
+    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 = (
@@ -146,60 +160,28 @@ def events_fsw_comparison_theta_0():
     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]
-    )
-    de_dataset = ultra_l1a.create_dataset(
-        {
-            ULTRA_EVENTS.apid[0]: decom_ultra_events,
-            ULTRA_AUX.apid[0]: decom_ultra_aux,
-        }
-    )
-
-    return 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,
-        }
-    )
-    return l1a_aux_dataset
+    test_data = ultra_l1a(ccsds_path_theta_0, apid_input=ULTRA_AUX.apid[0])
+    return test_data[0]
 
 
-@pytest.fixture()
+@pytest.fixture
 def faux_aux_dataset():
     """Fixture to compute and return aux test data."""
 
@@ -229,7 +211,7 @@ def faux_aux_dataset():
     return test_aux_dataset
 
 
-@pytest.fixture()
+@pytest.fixture
 @mock.patch("imap_processing.ultra.l1b.de.get_annotated_particle_velocity")
 def l1b_de_dataset(
     mock_get_annotated_particle_velocity,
@@ -259,12 +241,12 @@ def l1b_de_dataset(
 
     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()
+@pytest.fixture
 def l1b_extendedspin_dataset(
     l1b_de_dataset,
     rates_dataset,
@@ -277,7 +259,8 @@ def l1b_extendedspin_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, data_version="001")
+    output_datasets = ultra_l1b(data_dict)
 
     return output_datasets

imap_processing/tests/ultra/unit/test_badtimes.py

@@ -32,6 +32,7 @@ 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"),
@@ -45,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

@@ -25,6 +25,7 @@ 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"),
@@ -38,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]))
 
@@ -78,14 +77,13 @@ def test_calculate_cullingmask_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)
@@ -22,7 +22,7 @@ def test_calculate_de(l1b_de_dataset, df_filt):
 
     l1b_de_dataset = l1b_de_dataset[0]
     l1b_de_dataset = l1b_de_dataset.where(
-        l1b_de_dataset["start_type"] != np.iinfo(np.int64).min, drop=True
+        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"))
@@ -63,7 +63,7 @@ def test_calculate_de(l1b_de_dataset, 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"]
@@ -113,10 +113,3 @@ def test_calculate_de(l1b_de_dataset, 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"])

imap_processing/tests/ultra/unit/test_decom_apid_881.py

@@ -14,8 +14,7 @@ from imap_processing.ultra.l0.ultra_utils import RATES_KEYS, ULTRA_RATES
         pytest.param(
             {
                 "apid": ULTRA_RATES.apid[0],
-                "filename": "Ultra45_EM_SwRI_Cal_Run7_"
-                "ThetaScan_20220530T225054.CCSDS",
+                "filename": "Ultra45_EM_SwRI_Cal_Run7_ThetaScan_20220530T225054.CCSDS",
             }
         )
     ],
@@ -24,27 +23,27 @@ from imap_processing.ultra.l0.ultra_utils import RATES_KEYS, ULTRA_RATES
 def test_image_rate_decom(decom_test_data, rates_test_path):
     """This function reads validation data and checks that decom data
     matches validation data for image rate packet"""
-    decom_ultra, _ = decom_test_data
+    decom_ultra = decom_test_data
 
     df = pd.read_csv(rates_test_path, index_col="MET")
     total_packets = 23
 
-    np.testing.assert_array_equal(df.SID, decom_ultra["SID"])
-    np.testing.assert_array_equal(df.Spin, decom_ultra["SPIN"])
-    np.testing.assert_array_equal(df.AbortFlag, decom_ultra["ABORTFLAG"])
-    np.testing.assert_array_equal(df.StartDelay, decom_ultra["STARTDELAY"])
+    np.testing.assert_array_equal(df.SID, decom_ultra["sid"])
+    np.testing.assert_array_equal(df.Spin, decom_ultra["spin"])
+    np.testing.assert_array_equal(df.AbortFlag, decom_ultra["abortflag"])
+    np.testing.assert_array_equal(df.StartDelay, decom_ultra["startdelay"])
 
     # Spot-check first packet
-    t0 = decom_ultra["SHCOARSE"][0]
-    expected_arr0 = json.loads(df.loc[t0].Counts)
+    t0 = decom_ultra["shcoarse"][0]
+    expected_arr0 = json.loads(df.loc[int(t0)].Counts)
     arr = []
     for name in RATES_KEYS:
         arr.append(decom_ultra[name][0])
     assert expected_arr0 == arr
 
     # Spot-check last packet
-    tn = decom_ultra["SHCOARSE"][total_packets - 1]
-    expected_arrn = json.loads(df.loc[tn].Counts)
+    tn = decom_ultra["shcoarse"][total_packets - 1]
+    expected_arrn = json.loads(df.loc[int(tn)].Counts)
     arr = []
     for name in RATES_KEYS:
         arr.append(decom_ultra[name][total_packets - 1])
@@ -75,15 +74,15 @@ def test_image_rate_decom_zero_width(decom_test_data):
         / "ultra45_raw_sc_ultraimgrates_20220530_00.csv"
     )
 
-    decom_ultra, _ = decom_test_data
+    decom_ultra = decom_test_data
 
     df = pd.read_csv(test_path, index_col="MET")
     total_packets = 163
 
-    np.testing.assert_array_equal(df.SID, decom_ultra["SID"])
-    np.testing.assert_array_equal(df.Spin, decom_ultra["SPIN"])
-    np.testing.assert_array_equal(df.AbortFlag, decom_ultra["ABORTFLAG"])
-    np.testing.assert_array_equal(df.StartDelay, decom_ultra["STARTDELAY"])
+    np.testing.assert_array_equal(df.SID, decom_ultra["sid"])
+    np.testing.assert_array_equal(df.Spin, decom_ultra["spin"])
+    np.testing.assert_array_equal(df.AbortFlag, decom_ultra["abortflag"])
+    np.testing.assert_array_equal(df.StartDelay, decom_ultra["startdelay"])
 
     for i in range(total_packets):
         t = int(df["SequenceCount"].iloc[i])  # Ensure we get an integer value

imap_processing/tests/ultra/unit/test_decom_apid_883.py

@@ -6,8 +6,6 @@ import pytest
 
 from imap_processing.ultra.l0.ultra_utils import ULTRA_TOF
 
-# TODO: discuss with instrument team incomplete set of SIDs
-
 
 @pytest.mark.parametrize(
     "decom_test_data",
@@ -15,7 +13,7 @@ from imap_processing.ultra.l0.ultra_utils import ULTRA_TOF
         pytest.param(
             {
                 "apid": ULTRA_TOF.apid[0],
-                "filename": "FM45_TV_Cycle6_Hot_Ops_" "Front212_20240124T063837.CCSDS",
+                "filename": "FM45_TV_Cycle6_Hot_Ops_Front212_20240124T063837.CCSDS",
             }
         )
     ],
@@ -25,20 +23,24 @@ def test_tof_decom(decom_test_data, tof_test_path):
     """This function reads validation data and checks that decom data
     matches validation data for image rate packet"""
 
-    decom_ultra, _ = decom_test_data
+    decom_ultra = decom_test_data
     df = pd.read_csv(tof_test_path, index_col="SequenceCount")
 
-    np.testing.assert_array_equal(df.Spin, decom_ultra["SPIN"].flatten())
-    np.testing.assert_array_equal(df.AbortFlag, decom_ultra["ABORTFLAG"].flatten())
-    np.testing.assert_array_equal(df.StartDelay, decom_ultra["STARTDELAY"].flatten())
-    assert json.loads(df["P00s"].values[0])[0] == decom_ultra["P00"][0][0]
+    np.testing.assert_array_equal(df.Spin, decom_ultra["spin"].values.flatten())
+    np.testing.assert_array_equal(
+        df.AbortFlag, decom_ultra["abortflag"].values.flatten()
+    )
+    np.testing.assert_array_equal(
+        df.StartDelay, decom_ultra["startdelay"].values.flatten()
+    )
+    assert json.loads(df["P00s"].values[0])[0] == decom_ultra["p00"][0][0]
 
     for count in df.index.get_level_values("SequenceCount").values:
         df_data = df[df.index.get_level_values("SequenceCount") == count].Images.values[
             0
         ]
-        rows, cols = np.where(decom_ultra["SRC_SEQ_CTR"] == count)
-        decom_data = decom_ultra["PACKETDATA"][rows[0]][cols[0]]
+        rows, cols = np.where(decom_ultra["src_seq_ctr"] == count)
+        decom_data = decom_ultra["packetdata"][rows[0]][cols[0]]
         df_data_array = np.array(json.loads(df_data)[0])
 
         np.testing.assert_array_equal(df_data_array, decom_data)