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

imap_processing/tests/hi/test_hi_l1c.py

@@ -1,6 +1,8 @@
 """Test coverage for imap_processing.hi.l1c.hi_l1c.py"""
 
+from collections import namedtuple
 from unittest import mock
+from unittest.mock import MagicMock
 
 import numpy as np
 import pandas as pd
@@ -9,9 +11,10 @@ import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.cdf.utils import load_cdf, write_cdf
+from imap_processing.hi.l1a.science_direct_event import DE_CLOCK_TICK_S
 from imap_processing.hi.l1c import hi_l1c
 from imap_processing.hi.l1c.hi_l1c import CalibrationProductConfig
-from imap_processing.hi.utils import HIAPID
+from imap_processing.hi.utils import HIAPID, CoincidenceBitmap
 
 
 @pytest.fixture(scope="module")
@@ -37,10 +40,14 @@ def test_hi_l1c_not_implemented():
         hi_l1c.hi_l1c([None, None], "0")
 
 
+@pytest.mark.external_test_data()
 @pytest.mark.external_kernel()
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
-def test_generate_pset_dataset(hi_l1_test_data_path, hi_test_cal_prod_config_path):
+def test_generate_pset_dataset(
+    hi_l1_test_data_path, hi_test_cal_prod_config_path, use_fake_spin_data_for_time
+):
     """Test coverage for generate_pset_dataset function"""
+    use_fake_spin_data_for_time(482372987.999)
     l1b_de_path = hi_l1_test_data_path / "imap_hi_l1b_45sensor-de_20250415_v999.cdf"
     l1b_dataset = load_cdf(l1b_de_path)
     l1c_dataset = hi_l1c.generate_pset_dataset(
@@ -54,9 +61,9 @@ def test_generate_pset_dataset(hi_l1_test_data_path, hi_test_cal_prod_config_pat
     np.testing.assert_array_equal(l1c_dataset.despun_z.data.shape, (1, 3))
     np.testing.assert_array_equal(l1c_dataset.hae_latitude.data.shape, (1, 3600))
     np.testing.assert_array_equal(l1c_dataset.hae_longitude.data.shape, (1, 3600))
+    np.testing.assert_array_equal(l1c_dataset.exposure_times.data.shape, (1, 9, 3600))
     for var in [
         "counts",
-        "exposure_times",
         "background_rates",
         "background_rates_uncertainty",
     ]:
@@ -131,6 +138,218 @@ def test_pset_geometry(mock_frame_transform, mock_geom_frame_transform, sensor_s
     )
 
 
+@pytest.mark.external_test_data()
+def test_pset_counts(hi_l1_test_data_path, hi_test_cal_prod_config_path):
+    """Test coverage for pset_counts function."""
+    l1b_de_path = hi_l1_test_data_path / "imap_hi_l1b_45sensor-de_20250415_v999.cdf"
+    l1b_dataset = load_cdf(l1b_de_path)
+    cal_config_df = hi_l1c.CalibrationProductConfig.from_csv(
+        hi_test_cal_prod_config_path
+    )
+    empty_pset = hi_l1c.empty_pset_dataset(
+        l1b_dataset.esa_energy_step.data,
+        cal_config_df.cal_prod_config.number_of_products,
+        HIAPID.H90_SCI_DE.sensor,
+    )
+    counts_var = hi_l1c.pset_counts(empty_pset.coords, cal_config_df, l1b_dataset)
+    assert "counts" in counts_var
+
+
+def test_get_tof_window_mask():
+    """Test coverage for get_tof_window_mask function."""
+    # Create a synthetic dataframe with required columns containing data
+    # intended to test all aspects of the function.
+    fill_vals = {
+        "tof_ab": -11,
+        "tof_ac1": -12,
+        "tof_bc1": -13,
+        "tof_c1c2": -14,
+    }
+    Row = namedtuple(
+        "Row",
+        [
+            "Index",
+            "tof_ab_low",
+            "tof_ab_high",
+            "tof_ac1_low",
+            "tof_ac1_high",
+            "tof_bc1_low",
+            "tof_bc1_high",
+            "tof_c1c2_low",
+            "tof_c1c2_high",
+        ],
+    )
+    prod_config_row = Row((1, 0), 0, 1, -1, 2, 1, 5, 4, 6)
+    synth_df = pd.DataFrame(
+        {
+            "tof_ab": np.array(
+                [0, 2, 1, 0, -1, -5, -11], dtype=np.int32
+            ),  # T, F, T, T, F, F, FILL
+            "tof_ac1": np.array(
+                [-1, 2, -2, 0, 3, 0, -12], dtype=np.int32
+            ),  # T, T, F, T, F, T, FILL
+            "tof_bc1": np.array(
+                [1, 5, 3, 0, 6, 2, -13], dtype=np.int32
+            ),  # T, T, T, F, F, T, FILL
+            "tof_c1c2": np.array(
+                [4, 6, 5, 3, 7, -9, -14], dtype=np.int32
+            ),  # T, T, T, F, F, F, FILL
+        },
+    )
+    expected_mask = np.array([True, False, False, False, False, False, True])
+    window_mask = hi_l1c.get_tof_window_mask(synth_df, prod_config_row, fill_vals)
+    np.testing.assert_array_equal(expected_mask, window_mask)
+
+
+@mock.patch("imap_processing.hi.l1c.hi_l1c.get_spin_data", return_value=None)
+@mock.patch("imap_processing.hi.l1c.hi_l1c.get_instrument_spin_phase")
+@mock.patch("imap_processing.hi.l1c.hi_l1c.get_de_clock_ticks_for_esa_step")
+@mock.patch("imap_processing.hi.l1c.hi_l1c.find_second_de_packet_data")
+def test_pset_exposure(
+    mock_find_second_de_packet_data,
+    mock_de_clock_ticks,
+    mock_spin_phase,
+    mock_spin_data,
+):
+    """Test coverage for pset_exposure function"""
+    empty_pset = hi_l1c.empty_pset_dataset(
+        np.arange(2) + 1, 2, HIAPID.H90_SCI_DE.sensor
+    )
+    # Set the mock of find_second_de_packet_data to return a xr.Dataset
+    # with some dummy data. ESA 1 will get binned data once, ESA 2 will get
+    # binned data twice.
+    mock_find_second_de_packet_data.return_value = xr.Dataset(
+        coords={"epoch": xr.DataArray(np.arange(3), dims=["epoch"])},
+        data_vars={
+            "ccsds_met": xr.DataArray(np.arange(3), dims=["epoch"]),
+            "esa_energy_step": xr.DataArray(np.array([1, 2, 2]), dims=["epoch"]),
+        },
+    )
+    # Set mock of get_de_clock_ticks_for_esa_step and spin phase to generate
+    # deterministic histogram values.
+    # ESA step 1 should have repeating values of 3, 1.
+    # ESA step 2 should have repeating values of 6, 2
+    mock_spin_phase.return_value = np.concat(
+        [hi_l1c.SPIN_PHASE_BIN_CENTERS, hi_l1c.SPIN_PHASE_BIN_CENTERS[::2]]
+    )
+    mock_de_clock_ticks.return_value = (
+        np.zeros(hi_l1c.N_SPIN_BINS + hi_l1c.N_SPIN_BINS // 2),
+        np.concat([np.ones(hi_l1c.N_SPIN_BINS), np.ones(hi_l1c.N_SPIN_BINS // 2) * 2]),
+    )
+
+    # The above mocks mean no data needs to be in the l1b_dataset. It
+    # only needs to provide a logical source that contains "90sensor".
+    l1b_dataset = MagicMock()
+    l1b_dataset.attrs = {"Logical_source": "90sensor"}
+
+    # All the setup is done, call the pset_exposure function
+    exposure_dict = hi_l1c.pset_exposure(empty_pset.coords, l1b_dataset)
+
+    # Based on the spin phase and clock_tick mocks, the expected output is:
+    # - Repeated values of 3, 1 for the first half of the spin bins
+    # - Repeated values of 3, 2 for the second half of the spin bins
+    expected_values = np.stack(
+        [
+            np.tile([3, 1], hi_l1c.N_SPIN_BINS // 2),
+            np.tile([6, 2], hi_l1c.N_SPIN_BINS // 2),
+        ]
+    )[None, :, :]
+    np.testing.assert_array_equal(exposure_dict["exposure_times"].data, expected_values)
+
+
+def test_find_second_de_packet_data():
+    """Test coverage for find_second_de_packet_data function"""
+    # Create a test l1b_dataset
+    # Expect to remove index 0 and 5 due to missing esa_step pair
+    # Expect to remove index 11 due to 0 being a calibration step
+    # Expect to return indices 2, 4, 7, 9, 13
+    esa_steps = np.array([1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 0, 0, 7, 7])
+    l1b_dataset = xr.Dataset(
+        coords={
+            "epoch": xr.DataArray(
+                np.arange(esa_steps.size),
+                dims=["epoch"],
+            ),
+            "event_met": xr.DataArray(
+                np.arange(10),
+                dims=["event_met"],
+            ),
+        },
+        data_vars={
+            "esa_step": xr.DataArray(
+                esa_steps,
+                dims=["epoch"],
+            ),
+            "coincidence_type": xr.DataArray(
+                np.ones(10),
+                dims=["event_met"],
+            ),
+        },
+    )
+    subset = hi_l1c.find_second_de_packet_data(l1b_dataset)
+    np.testing.assert_array_equal(subset.epoch.data, np.array([2, 4, 7, 9, 13]))
+
+
+@pytest.fixture(scope="module")
+def fake_spin_df():
+    """Generate a synthetic spin dataframe"""
+    # Generate some spin periods that vary by a random fraction of a second
+    spin_period = np.full(10, 15) + np.random.randn(10) / 10
+    d = {
+        "spin_start_time": np.add.accumulate(spin_period),
+        "spin_period_sec": spin_period,
+    }
+    spin_df = pd.DataFrame.from_dict(d)
+    return spin_df
+
+
+def test_get_de_clock_ticks_for_esa_step(fake_spin_df):
+    """Test coverage for get_de_clock_ticks_for_esa_step function."""
+
+    # Test nominal cases where CCSDS met falls after 8th spin start and before
+    # the end spin in the table + 1/2 spin period
+    for _, spin_row in fake_spin_df.iloc[8:].iterrows():
+        for ccsds_met in np.linspace(
+            spin_row.spin_start_time,
+            spin_row.spin_start_time + np.floor(spin_row.spin_period_sec / 2),
+            10,
+        ):
+            clock_tick_mets, clock_tick_weights = (
+                hi_l1c.get_de_clock_ticks_for_esa_step(ccsds_met, fake_spin_df)
+            )
+            np.testing.assert_array_equal(clock_tick_mets.shape, clock_tick_mets.shape)
+            # Verify last weight entry
+            exp_final_weight = (
+                np.absolute(
+                    fake_spin_df.spin_start_time.to_numpy() - clock_tick_mets[-1]
+                ).min()
+                / DE_CLOCK_TICK_S
+            )
+            assert clock_tick_weights[-1] == exp_final_weight
+            assert np.all(clock_tick_weights[:-1] == 1)
+
+
+def test_get_de_clock_ticks_for_esa_step_exceptions(fake_spin_df):
+    """Test the exception logic in the get_de_clock_ticks_for_esa_step function."""
+    # Test the ccsds_met being > 1/2 spin period past the spin start
+    bad_ccsds_met = (
+        fake_spin_df.iloc[8].spin_start_time
+        + fake_spin_df.iloc[8].spin_period_sec / 2
+        + 0.1
+    )
+    with pytest.raises(
+        ValueError, match="The difference between ccsds_met and spin_start_met"
+    ):
+        hi_l1c.get_de_clock_ticks_for_esa_step(bad_ccsds_met, fake_spin_df)
+
+    # Test the ccsds_met being too close to the start of the spin table
+    bad_ccsds_met = fake_spin_df.iloc[7].spin_start_time
+    with pytest.raises(
+        ValueError, match="Error determining start/end time for exposure time"
+    ):
+        hi_l1c.get_de_clock_ticks_for_esa_step(bad_ccsds_met, fake_spin_df)
+
+
 class TestCalibrationProductConfig:
     """
     All test coverage for the pd.DataFrame accessor extension "cal_prod_config".
@@ -138,7 +357,7 @@ class TestCalibrationProductConfig:
 
     def test_wrong_columns(self):
         """Test coverage for a dataframe with the wrong columns."""
-        required_columns = CalibrationProductConfig.required_columns
+        required_columns = hi_l1c.CalibrationProductConfig.required_columns
         for exclude_column_name in required_columns:
             include_columns = set(required_columns) - {exclude_column_name}
             df = pd.DataFrame({col: [1, 2, 3] for col in include_columns})
@@ -147,10 +366,19 @@ class TestCalibrationProductConfig:
 
     def test_from_csv(self, hi_test_cal_prod_config_path):
         """Test coverage for read_csv function."""
+        df = hi_l1c.CalibrationProductConfig.from_csv(hi_test_cal_prod_config_path)
+        assert isinstance(df["coincidence_type_list"][0, 1], tuple)
+
+    def test_added_coincidence_type_values_column(self, hi_test_cal_prod_config_path):
         df = CalibrationProductConfig.from_csv(hi_test_cal_prod_config_path)
-        assert isinstance(df["coincidence_type_list"][0, 1], list)
+        assert "coincidence_type_values" in df.columns
+        for _, row in df.iterrows():
+            for detect_string, val in zip(
+                row["coincidence_type_list"], row["coincidence_type_values"]
+            ):
+                assert val == CoincidenceBitmap.detector_hit_str_to_int(detect_string)
 
     def test_number_of_products(self, hi_test_cal_prod_config_path):
         """Test coverage for number of products accessor."""
-        df = CalibrationProductConfig.from_csv(hi_test_cal_prod_config_path)
+        df = hi_l1c.CalibrationProductConfig.from_csv(hi_test_cal_prod_config_path)
         assert df.cal_prod_config.number_of_products == 2

imap_processing/tests/hi/test_l1a.py

@@ -1,4 +1,5 @@
 import numpy as np
+import pandas as pd
 
 from imap_processing.cdf.utils import write_cdf
 from imap_processing.hi.l1a.hi_l1a import hi_l1a
@@ -23,6 +24,35 @@ def test_sci_de_decom(hi_l0_test_data_path):
     assert cdf_filepath.name == cdf_filename
 
 
+def test_diag_fee_decom(hi_l0_test_data_path):
+    """Test diag_fee data"""
+    bin_data_path = hi_l0_test_data_path / "H45_diag_fee_20250208.bin"
+    processed_data = hi_l1a(packet_file_path=bin_data_path, data_version="001")
+    dataset = processed_data[0]
+    cdf_filepath = write_cdf(processed_data[0], istp=False)
+    assert cdf_filepath.name == "imap_hi_l1a_45sensor-diagfee_20250208_v001.cdf"
+
+    assert np.unique(processed_data[0]["pkt_apid"].values) == HIAPID.H45_DIAG_FEE.value
+
+    validation_df = pd.read_csv(
+        hi_l0_test_data_path / "H45_diag_fee_20250208_verify.csv"
+    )
+    val_to_test_map = {
+        "PHVERNO": "version",
+        "PHTYPE": "type",
+        "PHSHF": "sec_hdr_flg",
+        "PHAPID": "pkt_apid",
+        "PHGROUPF": "seq_flgs",
+        "PHSEQCNT": "src_seq_ctr",
+        "PHDLEN": "pkt_len",
+    }
+    for col_name, series in validation_df.items():
+        if col_name == "timestamp":
+            continue
+        ds_var_name = val_to_test_map.get(col_name, col_name.lower())
+        np.testing.assert_array_equal(series.values, dataset[ds_var_name].data)
+
+
 def test_app_nhk_decom(hi_l0_test_data_path):
     """Test housekeeping data"""
 

imap_processing/tests/hi/test_science_direct_event.py

@@ -21,8 +21,8 @@ def test_parse_direct_events():
     # Encode the random events data into a bit-string
     bin_str = ""
     for i in range(n_events):
-        bin_str += f"{exp_dict['trigger_id'][i]:02b}"  # 2-bits for trigger_id
         bin_str += f"{exp_dict['de_tag'][i]:016b}"  # 16-bits for de_tag
+        bin_str += f"{exp_dict['trigger_id'][i]:02b}"  # 2-bits for trigger_id
         bin_str += f"{exp_dict['tof_1'][i]:010b}"  # 10-bits for tof_1
         bin_str += f"{exp_dict['tof_2'][i]:010b}"  # 10-bits for tof_2
         bin_str += f"{exp_dict['tof_3'][i]:010b}"  # 10-bits for tof_3

imap_processing/tests/hi/test_utils.py

@@ -7,6 +7,7 @@ import xarray as xr
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.hi.utils import (
     HIAPID,
+    CoincidenceBitmap,
     create_dataset_variables,
     full_dataarray,
     parse_sensor_number,
@@ -74,13 +75,13 @@ def test_full_dataarray(name, shape, fill_value, expected_shape):
 @pytest.mark.parametrize(
     "var_names, shape, fill_value, lookup_str",
     [
-        (["delta_t_ab", "delta_t_ac1"], 5, None, "hi_de_{0}"),
+        (["tof_ab", "tof_ac1"], 5, None, "hi_de_{0}"),
         (["hae_latitude"], (3, 5), 0, "hi_pset_{0}"),
     ],
 )
 def test_create_dataset_variables(var_names, shape, fill_value, lookup_str):
     """Test coverage for `imap_processing.hi.utils.create_dataset_variables`"""
-    var_names = ["delta_t_ab", "delta_t_ac1", "delta_t_bc1"]
+    var_names = ["tof_ab", "tof_ac1", "tof_bc1"]
     l1b_de_vars = create_dataset_variables(
         var_names, shape, fill_value=fill_value, att_manager_lookup_str="hi_de_{0}"
     )
@@ -100,3 +101,24 @@ def test_create_dataset_variables(var_names, shape, fill_value, lookup_str):
             assert data_array.shape == shape
         expected_fill_value = fill_value if fill_value is not None else attrs["FILLVAL"]
         np.testing.assert_array_equal(data_array, expected_fill_value)
+
+
+@pytest.mark.parametrize(
+    "sensor_hit_str, expected_val",
+    [
+        ("ABC1C2", 15),
+        ("ABC1", 14),
+        ("AB", 12),
+        ("AC1C2", 11),
+        ("AC1", 10),
+        ("A", 8),
+        ("BC1C2", 7),
+        ("BC1", 6),
+        ("B", 4),
+        ("C1C2", 3),
+        ("C1", 2),
+    ],
+)
+def test_coincidence_type_string_to_int(sensor_hit_str, expected_val):
+    """Test coverage for coincidence_type_string_to_int function"""
+    assert CoincidenceBitmap.detector_hit_str_to_int(sensor_hit_str) == expected_val

imap_processing/tests/hit/helpers/l1_validation.py

@@ -48,16 +48,16 @@ RENAME_COLUMNS = {
 }
 
 MOD_VALUE_TO_SPECIES_ENERGY_MAP = {
-    0: {"species": "H", "energy_idx": 0},
-    1: {"species": "H", "energy_idx": 1},
-    2: {"species": "H", "energy_idx": 2},
-    3: {"species": "He4", "energy_idx": 0},
-    4: {"species": "He4", "energy_idx": 1},
-    5: {"species": "CNO", "energy_idx": 0},
-    6: {"species": "CNO", "energy_idx": 1},
-    7: {"species": "NeMgSi", "energy_idx": 0},
-    8: {"species": "NeMgSi", "energy_idx": 1},
-    9: {"species": "Fe", "energy_idx": 0},
+    0: {"species": "h", "energy_bin": 0},
+    1: {"species": "h", "energy_bin": 1},
+    2: {"species": "h", "energy_bin": 2},
+    3: {"species": "he4", "energy_bin": 0},
+    4: {"species": "he4", "energy_bin": 1},
+    5: {"species": "cno", "energy_bin": 0},
+    6: {"species": "cno", "energy_bin": 1},
+    7: {"species": "nemgsi", "energy_bin": 0},
+    8: {"species": "nemgsi", "energy_bin": 1},
+    9: {"species": "fe", "energy_bin": 0},
 }
 
 
@@ -170,7 +170,7 @@ def consolidate_rate_columns(
 def consolidate_sectorates(data: pd.DataFrame) -> pd.DataFrame:
     """Consolidate sector rate data into arrays.
 
-    This function distinguishes between sector rate columns with three digits
+    This function distinguishes between sectored rate columns with three digits
     and those with four digits in their names.
 
     SECTORATES_000 SECTORATES_000_0 SECTORATES_000_1 SECTORATES_000_2...SECTORATES_120_9
@@ -185,9 +185,9 @@ def consolidate_sectorates(data: pd.DataFrame) -> pd.DataFrame:
 
     Columns with four digits (e.g., SECTORATES_000_0) include the sectorate
     values with a mod 10 value appended (e.g., 0). The mod 10 value determines
-    the species and energy range the sector rates represent in the science frame.
+    the species and energy range the sectored rates represent in the science frame.
     There are 10 possible species and energy ranges, but only one has data per
-    science frame. The validation data has 10 columns per 120 sector rates,
+    science frame. The validation data has 10 columns per 120 sectored rates,
     totaling 1200 columns per science frame. Each set of 10 columns will have
     only one value, resulting in an array that looks like this:
 
@@ -215,13 +215,13 @@ def consolidate_sectorates(data: pd.DataFrame) -> pd.DataFrame:
     ).columns
 
     data["sectorates"] = data[sectorates_three_digits].apply(
-        lambda row: row.values.reshape(8, 15), axis=1
+        lambda row: row.values.reshape(15, 8), axis=1
     )
     data["sectorates_delta_plus"] = data[sectorates_delta_plus_three_digits].apply(
-        lambda row: row.values.reshape(8, 15), axis=1
+        lambda row: row.values.reshape(15, 8), axis=1
     )
     data["sectorates_delta_minus"] = data[sectorates_delta_minus_three_digits].apply(
-        lambda row: row.values.reshape(8, 15), axis=1
+        lambda row: row.values.reshape(15, 8), axis=1
     )
 
     sectorates_four_digits = data.filter(regex=r"^SECTORATES_\d{3}_\d{1}$").columns
@@ -279,7 +279,7 @@ def process_single_rates(data: pd.DataFrame) -> pd.DataFrame:
 def add_species_energy(data: pd.DataFrame) -> pd.DataFrame:
     """Add species and energy index to the validation data.
 
-    The sector rate data is organized by species and energy index
+    The sectored rate data is organized by species and energy index
     in the processed data so this function adds this information
     to each row (i.e. science frame) in the validation data.
 
@@ -304,12 +304,12 @@ def add_species_energy(data: pd.DataFrame) -> pd.DataFrame:
         )
     )
     data["species"] = data["mod_10"].apply(
-        lambda row: MOD_VALUE_TO_SPECIES_ENERGY_MAP[row]["species"].lower()
+        lambda row: MOD_VALUE_TO_SPECIES_ENERGY_MAP[row]["species"]
         if row is not None
         else None
     )
-    data["energy_idx"] = data["mod_10"].apply(
-        lambda row: MOD_VALUE_TO_SPECIES_ENERGY_MAP[row]["energy_idx"]
+    data["energy_bin"] = data["mod_10"].apply(
+        lambda row: MOD_VALUE_TO_SPECIES_ENERGY_MAP[row]["energy_bin"]
         if row is not None
         else None
     )
@@ -336,7 +336,7 @@ def compare_data(
         if field not in [
             "sc_tick_by_frame",
             "species",
-            "energy_idx",
+            "energy_bin",
         ]:
             assert (
                 field in actual_data.data_vars.keys()
@@ -344,47 +344,47 @@ def compare_data(
         if field not in skip:
             for frame in range(expected_data.shape[0]):
                 if field == "species":
-                    # Compare sector rates data using species and energy index.
+                    # Compare sectored rates data using species and energy index.
                     # which are only present in the validation data. In the actual
-                    # data, sector rates are organized by species in 4D arrays.
-                    #    i.e. h_counts_sectored has shape
-                    #         (epoch, h_energy_index, declination, azimuth).
+                    # data, sectored rates are organized by species in 4D arrays.
+                    #    i.e. h_sectored_counts has shape
+                    #         (epoch, h_energy_index, azimuth, declination).
                     # species and energy index are used to find the correct
-                    # array of sector rate data from the actual data for comparison.
+                    # array of sectored rate data from the actual data for comparison.
                     species = expected_data[field][frame]
-                    energy_idx = expected_data["energy_idx"][frame]
+                    energy_bin = expected_data["energy_bin"][frame]
                     if "sectorates_delta_plus" in expected_data.columns:
                         np.testing.assert_allclose(
-                            actual_data[f"{species}_counts_sectored_delta_plus"][frame][
-                                energy_idx
+                            actual_data[f"{species}_sectored_counts_delta_plus"][frame][
+                                energy_bin
                             ].data,
                             expected_data["sectorates_delta_plus"][frame],
                             rtol=1e-7,  # relative tolerance
                             atol=1e-8,  # absolute tolerance
-                            err_msg=f"Mismatch in {species}_counts_sectored_delta_"
-                            f"plus at frame {frame}, energy_idx {energy_idx}",
+                            err_msg=f"Mismatch in {species}_sectored_counts_delta_"
+                            f"plus at frame {frame}, energy_bin {energy_bin}",
                         )
                     if "sectorates_delta_minus" in expected_data.columns:
                         np.testing.assert_allclose(
-                            actual_data[f"{species}_counts_sectored_delta_minus"][
+                            actual_data[f"{species}_sectored_counts_delta_minus"][
                                 frame
-                            ][energy_idx].data,
+                            ][energy_bin].data,
                             expected_data["sectorates_delta_minus"][frame],
                             rtol=1e-7,
                             atol=1e-8,
-                            err_msg=f"Mismatch in {species}_counts_sectored_delta_"
-                            f"minus at frame {frame}, energy_idx {energy_idx}",
+                            err_msg=f"Mismatch in {species}_sectored_counts_delta_"
+                            f"minus at frame {frame}, energy_bin {energy_bin}",
                         )
                     else:
                         np.testing.assert_allclose(
-                            actual_data[f"{species}_counts_sectored"][frame][
-                                energy_idx
+                            actual_data[f"{species}_sectored_counts"][frame][
+                                energy_bin
                             ].data,
                             expected_data["sectorates"][frame],
                             rtol=1e-7,
                             atol=1e-8,
-                            err_msg=f"Mismatch in {species}_counts_sectored at"
-                            f"frame {frame}, energy_idx {energy_idx}",
+                            err_msg=f"Mismatch in {species}_sectored_counts at"
+                            f"frame {frame}, energy_bin {energy_bin}",
                         )
                 elif field == "sc_tick_by_frame":
                     # Get the sc_tick values for each frame in the actual data

imap_processing/tests/hit/test_decom_hit.py

@@ -7,6 +7,7 @@ from imap_processing import imap_module_directory
 from imap_processing.hit.hit_utils import (
     HitAPID,
 )
+from imap_processing.hit.l0.constants import AZIMUTH_ANGLES, DECLINATION_ANGLES
 from imap_processing.hit.l0.decom_hit import (
     assemble_science_frames,
     decom_hit,
@@ -122,6 +123,9 @@ def test_parse_count_rates(sci_dataset):
     if count_rate_vars in list(sci_dataset.keys()):
         assert True
 
+    assert np.allclose(sci_dataset["declination"].values, DECLINATION_ANGLES)
+    assert np.allclose(sci_dataset["azimuth"].values, AZIMUTH_ANGLES)
+
 
 def test_is_sequential():
     """Test the is_sequential function."""