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

imap_processing/tests/ultra/unit/test_decom_apid_881.py

@@ -4,6 +4,7 @@ import numpy as np
 import pandas as pd
 import pytest
 
+from imap_processing import imap_module_directory
 from imap_processing.ultra.l0.ultra_utils import RATES_KEYS, ULTRA_RATES
 
 
@@ -13,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",
             }
         )
     ],
@@ -23,28 +23,71 @@ 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])
     assert expected_arrn == arr
+
+
+@pytest.mark.parametrize(
+    "decom_test_data",
+    [
+        pytest.param(
+            {
+                "apid": ULTRA_RATES.apid[0],
+                "filename": "FM45_UltraFM45_Functional_2024-01-22T0105_"
+                "20240122T010548.CCSDS",
+            }
+        )
+    ],
+    indirect=True,
+)
+def test_image_rate_decom_zero_width(decom_test_data):
+    """This function tests for cases in which the width is zero within the packet."""
+    test_path = (
+        imap_module_directory
+        / "tests"
+        / "ultra"
+        / "data"
+        / "l0"
+        / "ultra45_raw_sc_ultraimgrates_20220530_00.csv"
+    )
+
+    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"])
+
+    for i in range(total_packets):
+        t = int(df["SequenceCount"].iloc[i])  # Ensure we get an integer value
+        expected_arr = json.loads(df.loc[df["SequenceCount"] == t, "Counts"].values[0])
+        arr = []
+        for name in RATES_KEYS:
+            arr.append(decom_ultra[name][i])
+        assert expected_arr == arr

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)

imap_processing/tests/ultra/unit/test_decom_apid_896.py

@@ -23,33 +23,92 @@ def test_image_raw_events_decom(
 ):
     """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(events_test_path, index_col="MET")
-    df.replace(-1, np.iinfo(np.int64).min, inplace=True)
 
-    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["Count"], decom_ultra["COUNT"])
-    np.testing.assert_array_equal(df["CoinType"], decom_ultra["COIN_TYPE"])
-    np.testing.assert_array_equal(df["StartType"], decom_ultra["START_TYPE"])
-    np.testing.assert_array_equal(df["StopType"], decom_ultra["STOP_TYPE"])
-    np.testing.assert_array_equal(df["StartPosTDC"], decom_ultra["START_POS_TDC"])
-    np.testing.assert_array_equal(df["StopNorthTDC"], decom_ultra["STOP_NORTH_TDC"])
-    np.testing.assert_array_equal(df["StopEastTDC"], decom_ultra["STOP_EAST_TDC"])
-    np.testing.assert_array_equal(df["StopSouthTDC"], decom_ultra["STOP_SOUTH_TDC"])
-    np.testing.assert_array_equal(df["StopWestTDC"], decom_ultra["STOP_WEST_TDC"])
-    np.testing.assert_array_equal(df["CoinNorthTDC"], decom_ultra["COIN_NORTH_TDC"])
-    np.testing.assert_array_equal(df["CoinSouthTDC"], decom_ultra["COIN_SOUTH_TDC"])
-    np.testing.assert_array_equal(
-        df["CoinDiscreteTDC"], decom_ultra["COIN_DISCRETE_TDC"]
-    )
-    np.testing.assert_array_equal(df["EnergyOrPH"], decom_ultra["ENERGY_PH"])
-    np.testing.assert_array_equal(df["PulseWidth"], decom_ultra["PULSE_WIDTH"])
-    np.testing.assert_array_equal(df["PhaseAngle"], decom_ultra["PHASE_ANGLE"])
-    np.testing.assert_array_equal(df["Bin"], decom_ultra["BIN"])
+    # # Check all values of each column are as expected,
+    # except for those set to fill value
+    np.testing.assert_array_equal(
+        df["SID"].values[df["SID"].values != -1],
+        decom_ultra["sid"].values[df["SID"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["Spin"].values[df["Spin"].values != -1],
+        decom_ultra["spin"].values[df["Spin"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["AbortFlag"].values[df["AbortFlag"].values != -1],
+        decom_ultra["abortflag"].values[df["AbortFlag"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["StartDelay"].values[df["StartDelay"].values != -1],
+        decom_ultra["startdelay"].values[df["StartDelay"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["Count"].values[df["Count"].values != -1],
+        decom_ultra["count"].values[df["Count"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CoinType"].values[df["CoinType"].values != -1],
+        decom_ultra["coin_type"].values[df["CoinType"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["StartType"].values[df["StartType"].values != -1],
+        decom_ultra["start_type"].values[df["StartType"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["StopType"].values[df["StopType"].values != -1],
+        decom_ultra["stop_type"].values[df["StopType"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["StartPosTDC"].values[df["StartPosTDC"].values != -1],
+        decom_ultra["start_pos_tdc"].values[df["StartPosTDC"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["StopNorthTDC"].values[df["StopNorthTDC"].values != -1],
+        decom_ultra["stop_north_tdc"].values[df["StopNorthTDC"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["StopEastTDC"].values[df["StopEastTDC"].values != -1],
+        decom_ultra["stop_east_tdc"].values[df["StopEastTDC"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["StopSouthTDC"].values[df["StopSouthTDC"].values != -1],
+        decom_ultra["stop_south_tdc"].values[df["StopSouthTDC"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["StopWestTDC"].values[df["StopWestTDC"].values != -1],
+        decom_ultra["stop_west_tdc"].values[df["StopWestTDC"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CoinNorthTDC"].values[df["CoinNorthTDC"].values != -1],
+        decom_ultra["coin_north_tdc"].values[df["CoinNorthTDC"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CoinSouthTDC"].values[df["CoinSouthTDC"].values != -1],
+        decom_ultra["coin_south_tdc"].values[df["CoinSouthTDC"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CoinDiscreteTDC"].values[df["CoinDiscreteTDC"].values != -1],
+        decom_ultra["coin_discrete_tdc"].values[df["CoinDiscreteTDC"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["EnergyOrPH"].values[df["EnergyOrPH"].values != -1],
+        decom_ultra["energy_ph"].values[df["EnergyOrPH"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["PulseWidth"].values[df["PulseWidth"].values != -1],
+        decom_ultra["pulse_width"].values[df["PulseWidth"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["PhaseAngle"].values[df["PhaseAngle"].values != -1],
+        decom_ultra["phase_angle"].values[df["PhaseAngle"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["Bin"].values[df["Bin"].values != -1],
+        decom_ultra["bin"].values[df["Bin"].values != -1],
+    )
 
 
 @pytest.mark.parametrize(
@@ -69,36 +128,124 @@ def test_image_raw_events_decom_flags(decom_test_data, events_test_path):
     """This function reads validation data and checks that decom data
     matches validation data for image rate packet"""
 
-    decom_ultra, _ = decom_test_data
+    # # Check all values of each column are as expected,
+    # except for those set to fill value
+    decom_ultra = decom_test_data
     df = pd.read_csv(events_test_path, index_col="MET")
-    df.replace(-1, np.iinfo(np.int64).min, inplace=True)
 
-    np.testing.assert_array_equal(df["CnT"], decom_ultra["EVENT_FLAG_CNT"])
-    np.testing.assert_array_equal(df["PHCmpSL"], decom_ultra["EVENT_FLAG_PHCMPSL"])
-    np.testing.assert_array_equal(df["PHCmpSR"], decom_ultra["EVENT_FLAG_PHCMPSR"])
-    np.testing.assert_array_equal(df["PHCmpCD"], decom_ultra["EVENT_FLAG_PHCMPCD"])
-    np.testing.assert_array_equal(df["SSDS7"], decom_ultra["SSD_FLAG_7"])
-    np.testing.assert_array_equal(df["SSDS6"], decom_ultra["SSD_FLAG_6"])
-    np.testing.assert_array_equal(df["SSDS5"], decom_ultra["SSD_FLAG_5"])
-    np.testing.assert_array_equal(df["SSDS4"], decom_ultra["SSD_FLAG_4"])
-    np.testing.assert_array_equal(df["SSDS3"], decom_ultra["SSD_FLAG_3"])
-    np.testing.assert_array_equal(df["SSDS2"], decom_ultra["SSD_FLAG_2"])
-    np.testing.assert_array_equal(df["SSDS1"], decom_ultra["SSD_FLAG_1"])
-    np.testing.assert_array_equal(df["SSDS0"], decom_ultra["SSD_FLAG_0"])
-    np.testing.assert_array_equal(df["CFDCoinTN"], decom_ultra["CFD_FLAG_COINTN"])
-    np.testing.assert_array_equal(df["CFDCoinBN"], decom_ultra["CFD_FLAG_COINBN"])
-    np.testing.assert_array_equal(df["CFDCoinTS"], decom_ultra["CFD_FLAG_COINTS"])
-    np.testing.assert_array_equal(df["CFDCoinBS"], decom_ultra["CFD_FLAG_COINBS"])
-    np.testing.assert_array_equal(df["CFDCoinD"], decom_ultra["CFD_FLAG_COIND"])
-    np.testing.assert_array_equal(df["CFDStartRF"], decom_ultra["CFD_FLAG_STARTRF"])
-    np.testing.assert_array_equal(df["CFDStartLF"], decom_ultra["CFD_FLAG_STARTLF"])
-    np.testing.assert_array_equal(df["CFDStartRP"], decom_ultra["CFD_FLAG_STARTRP"])
-    np.testing.assert_array_equal(df["CFDStartLP"], decom_ultra["CFD_FLAG_STARTLP"])
-    np.testing.assert_array_equal(df["CFDStopTN"], decom_ultra["CFD_FLAG_STOPTN"])
-    np.testing.assert_array_equal(df["CFDStopBN"], decom_ultra["CFD_FLAG_STOPBN"])
-    np.testing.assert_array_equal(df["CFDStopTE"], decom_ultra["CFD_FLAG_STOPTE"])
-    np.testing.assert_array_equal(df["CFDStopBE"], decom_ultra["CFD_FLAG_STOPBE"])
-    np.testing.assert_array_equal(df["CFDStopTS"], decom_ultra["CFD_FLAG_STOPTS"])
-    np.testing.assert_array_equal(df["CFDStopBS"], decom_ultra["CFD_FLAG_STOPBS"])
-    np.testing.assert_array_equal(df["CFDStopTW"], decom_ultra["CFD_FLAG_STOPTW"])
-    np.testing.assert_array_equal(df["CFDStopBW"], decom_ultra["CFD_FLAG_STOPBW"])
+    np.testing.assert_array_equal(
+        df["CnT"].values[df["CnT"].values != -1],
+        decom_ultra["event_flag_cnt"].values[df["CnT"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["PHCmpSL"].values[df["PHCmpSL"].values != -1],
+        decom_ultra["event_flag_phcmpsl"].values[df["PHCmpSL"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["PHCmpSR"].values[df["PHCmpSR"].values != -1],
+        decom_ultra["event_flag_phcmpsr"].values[df["PHCmpSR"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["PHCmpCD"].values[df["PHCmpCD"].values != -1],
+        decom_ultra["event_flag_phcmpcd"].values[df["PHCmpCD"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["SSDS7"].values[df["SSDS7"].values != -1],
+        decom_ultra["ssd_flag_7"].values[df["SSDS7"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["SSDS6"].values[df["SSDS6"].values != -1],
+        decom_ultra["ssd_flag_6"].values[df["SSDS6"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["SSDS5"].values[df["SSDS5"].values != -1],
+        decom_ultra["ssd_flag_5"].values[df["SSDS5"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["SSDS4"].values[df["SSDS4"].values != -1],
+        decom_ultra["ssd_flag_4"].values[df["SSDS4"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["SSDS3"].values[df["SSDS3"].values != -1],
+        decom_ultra["ssd_flag_3"].values[df["SSDS3"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["SSDS2"].values[df["SSDS2"].values != -1],
+        decom_ultra["ssd_flag_2"].values[df["SSDS2"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["SSDS1"].values[df["SSDS1"].values != -1],
+        decom_ultra["ssd_flag_1"].values[df["SSDS1"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["SSDS0"].values[df["SSDS0"].values != -1],
+        decom_ultra["ssd_flag_0"].values[df["SSDS0"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDCoinTN"].values[df["CFDCoinTN"].values != -1],
+        decom_ultra["cfd_flag_cointn"].values[df["CFDCoinTN"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDCoinBN"].values[df["CFDCoinBN"].values != -1],
+        decom_ultra["cfd_flag_coinbn"].values[df["CFDCoinBN"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDCoinTS"].values[df["CFDCoinTS"].values != -1],
+        decom_ultra["cfd_flag_coints"].values[df["CFDCoinTS"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDCoinBS"].values[df["CFDCoinBS"].values != -1],
+        decom_ultra["cfd_flag_coinbs"].values[df["CFDCoinBS"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDCoinD"].values[df["CFDCoinD"].values != -1],
+        decom_ultra["cfd_flag_coind"].values[df["CFDCoinD"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStartRF"].values[df["CFDStartRF"].values != -1],
+        decom_ultra["cfd_flag_startrf"].values[df["CFDStartRF"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStartLF"].values[df["CFDStartLF"].values != -1],
+        decom_ultra["cfd_flag_startlf"].values[df["CFDStartLF"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStartRP"].values[df["CFDStartRP"].values != -1],
+        decom_ultra["cfd_flag_startrp"].values[df["CFDStartRP"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStartLP"].values[df["CFDStartLP"].values != -1],
+        decom_ultra["cfd_flag_startlp"].values[df["CFDStartLP"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStopTN"].values[df["CFDStopTN"].values != -1],
+        decom_ultra["cfd_flag_stoptn"].values[df["CFDStopTN"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStopBN"].values[df["CFDStopBN"].values != -1],
+        decom_ultra["cfd_flag_stopbn"].values[df["CFDStopBN"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStopTE"].values[df["CFDStopTE"].values != -1],
+        decom_ultra["cfd_flag_stopte"].values[df["CFDStopTE"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStopBE"].values[df["CFDStopBE"].values != -1],
+        decom_ultra["cfd_flag_stopbe"].values[df["CFDStopBE"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStopTS"].values[df["CFDStopTS"].values != -1],
+        decom_ultra["cfd_flag_stopts"].values[df["CFDStopTS"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStopBS"].values[df["CFDStopBS"].values != -1],
+        decom_ultra["cfd_flag_stopbs"].values[df["CFDStopBS"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStopTW"].values[df["CFDStopTW"].values != -1],
+        decom_ultra["cfd_flag_stoptw"].values[df["CFDStopTW"].values != -1],
+    )
+    np.testing.assert_array_equal(
+        df["CFDStopBW"].values[df["CFDStopBW"].values != -1],
+        decom_ultra["cfd_flag_stopbw"].values[df["CFDStopBW"].values != -1],
+    )

imap_processing/tests/ultra/unit/test_lookup_utils.py

@@ -1,9 +1,12 @@
 import numpy as np
 import pandas as pd
+import pytest
 
 from imap_processing import imap_module_directory
 from imap_processing.ultra.l1b.lookup_utils import (
+    get_angular_profiles,
     get_back_position,
+    get_energy_efficiencies,
     get_energy_norm,
     get_image_params,
     get_norm,
@@ -63,6 +66,25 @@ def test_get_egy_norm():
 def test_get_image_params():
     """Tests function get_image_params."""
 
-    image_params = get_image_params("XFTLTOFF")
+    image_params = get_image_params("XFTLTOFF", "ultra45")
 
     assert image_params == 49.3
+
+
+def test_get_angular_profiles():
+    """Tests function get_image_params."""
+
+    u45_left = get_angular_profiles("left", "ultra45")
+    u45_right = get_angular_profiles("right", "ultra45")
+
+    assert u45_left.shape == (525, 7)
+    assert u45_right.shape == (525, 7)
+
+
+@pytest.mark.external_test_data
+def test_get_energy_efficiencies():
+    """Tests function get_get_energy_efficiencies."""
+
+    u45_efficiencies = get_energy_efficiencies()
+
+    assert u45_efficiencies.shape == (58081, 157)

imap_processing/tests/ultra/unit/test_spacecraft_pset.py

@@ -0,0 +1,77 @@
+"""Tests Spacecraft PSET for ULTRA L1c."""
+
+import numpy as np
+import pandas as pd
+import pytest
+import spiceypy
+import xarray as xr
+
+from imap_processing import imap_module_directory
+from imap_processing.spice.geometry import SpiceFrame
+from imap_processing.spice.kernels import ensure_spice
+from imap_processing.ultra.l1b.ultra_l1b_annotated import (
+    get_annotated_particle_velocity,
+)
+from imap_processing.ultra.l1b.ultra_l1b_extended import (
+    get_de_energy_kev,
+    get_de_velocity,
+)
+from imap_processing.ultra.l1c.spacecraft_pset import calculate_spacecraft_pset
+
+TEST_PATH = imap_module_directory / "tests" / "ultra" / "data" / "l1"
+
+
+@pytest.mark.external_test_data
+@pytest.mark.external_kernel
+@ensure_spice
+@pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
+def test_pset():
+    """Tests calculate_pset function."""
+    # This is just setting up the data so that it is in the format of l1b_de_dataset.
+    test_path = TEST_PATH / "ultra-90_raw_event_data_shortened.csv"
+    df = pd.read_csv(test_path)
+    instrument_velocity, _, _ = get_de_velocity(
+        (df["Xf"], df["Yf"]), (df["Xb"], df["Yb"]), df["d"], df["TOF"].values
+    )
+
+    et = spiceypy.str2et(df["Epoch"].values)
+    epoch = df["MET"].values
+
+    frame_velocities = get_annotated_particle_velocity(
+        et,
+        instrument_velocity,
+        SpiceFrame.IMAP_ULTRA_90,
+        SpiceFrame.IMAP_DPS,
+        SpiceFrame.IMAP_SPACECRAFT,
+    )
+
+    particle_velocity_dps_spacecraft = frame_velocities[1]
+
+    # Assume everything is Hydrogen
+    species = np.full(len(particle_velocity_dps_spacecraft), "H", dtype="<U1")
+    energy_dps_spacecraft = get_de_energy_kev(particle_velocity_dps_spacecraft, species)
+
+    test_l1b_de_dataset = xr.Dataset(
+        {
+            "species": (["epoch"], species),
+            "velocity_dps_sc": (
+                ["epoch", "component"],
+                particle_velocity_dps_spacecraft,
+            ),
+            "energy_spacecraft": (["epoch"], energy_dps_spacecraft),
+        },
+        coords={
+            "epoch": ("epoch", epoch),
+            "component": ("component", ["vx", "vy", "vz"]),
+        },
+    )
+
+    spacecraft_pset = calculate_spacecraft_pset(
+        test_l1b_de_dataset,
+        test_l1b_de_dataset,  # placeholder for extendedspin_dataset
+        test_l1b_de_dataset,  # placeholder for cullingmask_dataset
+        "imap_ultra_l1c_45sensor-spacecraftpset",
+    )
+    assert "healpix" in spacecraft_pset.coords
+    assert "epoch" in spacecraft_pset.coords
+    assert "energy_bin_geometric_mean" in spacecraft_pset.coords