imap-processing 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

imap_processing/tests/glows/test_glows_l1b_data.py

@@ -102,24 +102,24 @@ def test_validation_data_histogram(l1a_dataset):
         # "imap_spin_angle_bin_cntr": "imap_spin_angle_bin_cntr",
         # "histogram_flag_array": "histogram_flag_array",
         "filter_temperature_average": "filter_temperature_average",
-        "filter_temperature_std_dev": "filter_temperature_variance",
+        "filter_temperature_std_dev": "filter_temperature_std_dev",
         "hv_voltage_average": "hv_voltage_average",
-        "hv_voltage_std_dev": "hv_voltage_variance",
+        "hv_voltage_std_dev": "hv_voltage_std_dev",
         "spin_period_average": "spin_period_average",
-        "spin_period_std_dev": "spin_period_variance",
+        "spin_period_std_dev": "spin_period_std_dev",
         "pulse_length_average": "pulse_length_average",
-        "pulse_length_std_dev": "pulse_length_variance",
+        "pulse_length_std_dev": "pulse_length_std_dev",
         # TODO uncomment when spice is complete
         # "spin_period_ground_average": "spin_period_ground_average",
-        # "spin_period_ground_std_dev": "spin_period_ground_variance",
+        # "spin_period_ground_std_dev": "spin_period_ground_std_dev",
         # "position_angle_offset_average": "position_angle_offset_average",
-        # "position_angle_offset_std_dev": "position_angle_offset_variance",
+        # "position_angle_offset_std_dev": "position_angle_offset_std_dev",
         # "spin_axis_orientation_average": "spin_axis_orientation_average",
-        # "spin_axis_orientation_std_dev": "spin_axis_orientation_variance",
+        # "spin_axis_orientation_std_dev": "spin_axis_orientation_std_dev",
         # "spacecraft_location_average": "spacecraft_location_average",
-        # "spacecraft_location_std_dev": "spacecraft_location_variance",
+        # "spacecraft_location_std_dev": "spacecraft_location_std_dev",
         # "spacecraft_velocity_average": "spacecraft_velocity_average",
-        # "spacecraft_velocity_std_dev": "spacecraft_velocity_variance",
+        # "spacecraft_velocity_std_dev": "spacecraft_velocity_std_dev",
     }
 
     for index, validation_output in enumerate(out["output"]):

imap_processing/tests/hi/test_hi_l1b.py

@@ -12,6 +12,8 @@ from imap_processing.hi.l1b.hi_l1b import (
     CoincidenceBitmap,
     compute_coincidence_type_and_time_deltas,
     compute_hae_coordinates,
+    de_esa_energy_step,
+    de_nominal_bin_and_spin_phase,
     hi_l1b,
 )
 from imap_processing.hi.utils import HiConstants
@@ -22,19 +24,23 @@ def test_hi_l1b_hk(hi_l0_test_data_path):
     """Test coverage for imap_processing.hi.hi_l1b.hi_l1b() with
     housekeeping L1A as input"""
     # TODO: once things are more stable, check in an L1A HK file as test data
-    bin_data_path = hi_l0_test_data_path / "20231030_H45_APP_NHK.bin"
+    bin_data_path = hi_l0_test_data_path / "H90_NHK_20241104.bin"
     data_version = "001"
     processed_data = hi_l1a(packet_file_path=bin_data_path, data_version=data_version)
 
     l1b_dataset = hi_l1b(processed_data[0], data_version=data_version)
-    assert l1b_dataset.attrs["Logical_source"] == "imap_hi_l1b_45sensor-hk"
+    assert l1b_dataset.attrs["Logical_source"] == "imap_hi_l1b_90sensor-hk"
 
 
 @pytest.mark.external_kernel()
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
-def test_hi_l1b_de(hi_l1a_test_data_path):
+def test_hi_l1b_de(
+    hi_l1a_test_data_path, spice_test_data_path, use_fake_spin_data_for_time
+):
     """Test coverage for imap_processing.hi.hi_l1b.hi_l1b() with
     direct events L1A as input"""
+    # Start MET time of spin for simulated input data is 482372988
+    use_fake_spin_data_for_time(482372988)
     l1a_test_file_path = (
         hi_l1a_test_data_path / "imap_hi_l1a_45sensor-de_20250415_v000.cdf"
     )
@@ -152,6 +158,53 @@ def test_compute_coincidence_type_and_time_deltas(synthetic_trigger_id_and_tof_d
     )
 
 
+@mock.patch("imap_processing.hi.l1b.hi_l1b.parse_sensor_number", return_value=90)
+@mock.patch("imap_processing.hi.l1b.hi_l1b.get_instrument_spin_phase")
+@mock.patch("imap_processing.hi.l1b.hi_l1b.get_spacecraft_spin_phase")
+def test_de_nominal_bin_and_spin_phase(
+    spacecraft_phase_moc, instrument_phase_mock, parse_sensor_number_mock
+):
+    """Test coverage for de_nominal_bin_and_spin_phase."""
+    # set the spacecraft_phase_mock to return an array of values between 0 and 1
+    # that is rolled 30 places for easy testing
+    spacecraft_phase_roll = 30
+    spacecraft_phase_moc.side_effect = lambda x: np.roll(
+        np.arange(0, 1, 1 / len(x)), spacecraft_phase_roll
+    )
+    # set the get_instrument_spin_phase mock to return an array of values between
+    # 0 and 1
+    instrument_phase_mock.side_effect = lambda x, y: np.arange(0, 1, 1 / len(x))
+    # generate a fake dataset with epoch coordinate and event_met variable
+    de_list_length = 720
+    synthetic_ds = xr.Dataset(
+        coords={
+            "epoch": xr.DataArray(
+                np.arange(de_list_length), name="epoch", dims=["epoch"]
+            )
+        },
+        data_vars={
+            "event_met": xr.DataArray(np.arange(de_list_length), dims=["epoch"])
+        },
+        attrs={"Logical_source": "foo_source"},
+    )
+
+    new_vars = de_nominal_bin_and_spin_phase(synthetic_ds)
+    # Check spin_phase
+    assert "spin_phase" in new_vars
+    assert new_vars["spin_phase"].shape == (de_list_length,)
+    np.testing.assert_array_equal(
+        new_vars["spin_phase"].values,
+        np.linspace(0, 1, de_list_length + 1, dtype=np.float32)[:-1],
+    )
+    # Check nominal_bin
+    assert "nominal_bin" in new_vars
+    expected_nominal_bin = np.roll(
+        np.digitize(np.arange(0, 360, 360 / de_list_length), np.arange(90) * 4) - 1,
+        spacecraft_phase_roll,
+    )
+    np.testing.assert_array_equal(new_vars["nominal_bin"].values, expected_nominal_bin)
+
+
 @pytest.mark.parametrize("sensor_number", [45, 90])
 @mock.patch("imap_processing.hi.l1b.hi_l1b.instrument_pointing")
 def test_compute_hae_coordinates(mock_instrument_pointing, sensor_number):
@@ -183,3 +236,20 @@ def test_compute_hae_coordinates(mock_instrument_pointing, sensor_number):
     assert "hae_longitude" in new_vars
     assert new_vars["hae_longitude"].shape == fake_dataset.epoch.shape
     np.testing.assert_allclose(new_vars["hae_longitude"].values, sensor_number)
+
+
+def test_de_esa_energy_step():
+    """Test coverage for de_esa_energy_step function."""
+    n_epoch = 20
+    fake_dataset = xr.Dataset(
+        coords={
+            "epoch": xr.DataArray(np.arange(n_epoch), name="epoch", dims=["epoch"])
+        },
+        data_vars={"esa_step": xr.DataArray(np.arange(n_epoch) % 9, dims=["epoch"])},
+    )
+    esa_energy_step_var = de_esa_energy_step(fake_dataset)
+    # TODO: The below check is for the temporary implementation and should be
+    #    removed when the function is update.
+    np.testing.assert_array_equal(
+        esa_energy_step_var["esa_energy_step"].values, fake_dataset.esa_step.values
+    )

imap_processing/tests/hi/test_hi_l1c.py

@@ -3,6 +3,7 @@
 import numpy as np
 import pytest
 
+from imap_processing.cdf.utils import write_cdf
 from imap_processing.hi.l1a.hi_l1a import hi_l1a
 from imap_processing.hi.l1b.hi_l1b import hi_l1b
 from imap_processing.hi.l1c import hi_l1c
@@ -30,19 +31,26 @@ def test_generate_pset_dataset(create_de_data):
 def test_allocate_pset_dataset():
     """Test coverage for allocate_pset_dataset function"""
     n_esa_steps = 10
+    n_calibration_prods = 5
     sensor_str = HIAPID.H90_SCI_DE.sensor
     dataset = hi_l1c.allocate_pset_dataset(n_esa_steps, sensor_str)
 
     assert dataset.epoch.size == 1
     assert dataset.spin_angle_bin.size == 3600
+    assert dataset.esa_energy_step.size == n_esa_steps
+    assert dataset.calibration_prod.size == n_calibration_prods
     np.testing.assert_array_equal(dataset.despun_z.data.shape, (1, 3))
     np.testing.assert_array_equal(dataset.hae_latitude.data.shape, (1, 3600))
     np.testing.assert_array_equal(dataset.hae_longitude.data.shape, (1, 3600))
-    n_esa_step = dataset.esa_energy_step.data.size
     for var in [
         "counts",
         "exposure_times",
         "background_rates",
         "background_rates_uncertainty",
     ]:
-        np.testing.assert_array_equal(dataset[var].data.shape, (1, n_esa_step, 3600))
+        np.testing.assert_array_equal(
+            dataset[var].data.shape, (1, n_esa_steps, n_calibration_prods, 3600)
+        )
+    # Verify resulting CDF is ISTP compliant by writing to disk
+    dataset.attrs["Data_version"] = 1
+    write_cdf(dataset)

imap_processing/tests/hi/test_l1a.py

@@ -1,43 +1,25 @@
 import numpy as np
-import pytest
 
 from imap_processing.cdf.utils import write_cdf
-from imap_processing.hi.l1a import histogram as hist
 from imap_processing.hi.l1a.hi_l1a import hi_l1a
+from imap_processing.hi.l1a.histogram import unpack_hist_counter
 from imap_processing.hi.utils import HIAPID
 
 
-def test_sci_de_decom(create_de_data):
+def test_sci_de_decom(hi_l0_test_data_path):
     """Test science direct event data"""
 
-    # Process using test data
-    processed_data = hi_l1a(
-        packet_file_path=create_de_data(HIAPID.H45_SCI_DE.value), data_version="001"
-    )
+    bin_data_path = hi_l0_test_data_path / "H90_sci_de_20241104.bin"
+    processed_data = hi_l1a(bin_data_path, data_version="001")
 
-    assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_45sensor-de"
+    assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_90sensor-de"
     assert processed_data[0].attrs["Data_version"] == "001"
 
-    # unique ESA steps should be [1, 2]
-    assert np.array_equal(
-        np.sort(np.unique(processed_data[0]["esa_step"].values)),
-        np.array([1, 2]),
-    )
-    # unique trigger_id should be [1, 2, 3]
-    assert np.array_equal(
-        np.sort(np.unique(processed_data[0]["trigger_id"].values)), np.array([1, 2, 3])
-    )
-    # tof_x should be in this range [0, 1023]
-    assert processed_data[0]["tof_1"].min() >= 0
-    assert processed_data[0]["tof_1"].max() <= 1023
-    assert processed_data[0]["tof_2"].min() >= 0
-    assert processed_data[0]["tof_2"].max() <= 1023
-    assert processed_data[0]["tof_3"].min() >= 0
-    assert processed_data[0]["tof_3"].max() <= 1023
+    # TODO: Verify correct unpacking of sample data. Issue: #1186
 
     # Write to CDF
-    cdf_filename = "imap_hi_l1a_45sensor-de_20230927_v001.cdf"
-    # TODO: Dropping duplicates to ignore ISTP for now. Need to update test data
+    cdf_filename = "imap_hi_l1a_90sensor-de_20241105_v001.cdf"
+    # TODO: Dropping duplicates to ignore ISTP for now. Should be fixed by #1186
     processed_data[0] = processed_data[0].sortby("epoch").groupby("epoch").first()
     cdf_filepath = write_cdf(processed_data[0])
     assert cdf_filepath.name == cdf_filename
@@ -47,54 +29,45 @@ def test_app_nhk_decom(hi_l0_test_data_path):
     """Test housekeeping data"""
 
     # Unpack housekeeping data
-    bin_data_path = hi_l0_test_data_path / "20231030_H45_APP_NHK.bin"
+    bin_data_path = hi_l0_test_data_path / "H90_NHK_20241104.bin"
     processed_data = hi_l1a(packet_file_path=bin_data_path, data_version="001")
 
-    assert np.unique(processed_data[0]["pkt_apid"].values) == HIAPID.H45_APP_NHK.value
-    assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_45sensor-hk"
+    assert np.unique(processed_data[0]["pkt_apid"].values) == HIAPID.H90_APP_NHK.value
+    assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_90sensor-hk"
     assert processed_data[0].attrs["Data_version"] == "001"
-    # TODO: compare with validation data once we have it
+    # TODO: compare with validation data once we have it. Issue: #1184
 
     # Write CDF
     cem_raw_cdf_filepath = write_cdf(processed_data[0], istp=False)
 
     # TODO: ask Vivek about this date mismatch between the file name
     # and the data. May get resolved when we have good sample data.
-    assert cem_raw_cdf_filepath.name == "imap_hi_l1a_45sensor-hk_20100313_v001.cdf"
+    assert cem_raw_cdf_filepath.name == "imap_hi_l1a_90sensor-hk_20241105_v001.cdf"
 
 
-@pytest.mark.skip(
-    reason="Need new test data with monotonically increasing epoch values"
-)
 def test_app_hist_decom(hi_l0_test_data_path):
     """Test histogram (SCI_CNT) data"""
-    bin_data_path = hi_l0_test_data_path / "20231030_H45_SCI_CNT.bin"
+    bin_data_path = hi_l0_test_data_path / "H90_sci_cnt_20241104.bin"
     processed_data = hi_l1a(packet_file_path=bin_data_path, data_version="001")
 
-    assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_45sensor-hist"
-    # TODO: compare with validation data once we have it
-    # TODO: Dropping duplicates to ignore ISTP for now. Need to update test data
-    processed_data[0] = processed_data[0].sortby("epoch").groupby("epoch").first()
+    assert processed_data[0].attrs["Logical_source"] == "imap_hi_l1a_90sensor-hist"
+    # TODO: compare with validation data once we have it. Issue: #1185
 
     # Write CDF
     cem_raw_cdf_filepath = write_cdf(processed_data[0])
 
-    assert cem_raw_cdf_filepath.name.startswith("imap_hi_l1a_45sensor-hist_")
-
-
-def test_allocate_histogram_dataset():
-    """Test hi.l1a.histogram.allocate_histogram_dataset()"""
-    n_packets = 5
-    dataset = hist.allocate_histogram_dataset(n_packets)
-
-    assert dataset.attrs["Data_type"] == "L1A_HIST>Level-1A Histogram"
-    assert dataset.sizes["epoch"] == n_packets
-    assert dataset.sizes["angle"] == 90
-    for var_name in (
-        "ccsds_met",
-        "esa_stepping_num",
-        *hist.QUALIFIED_COUNTERS,
-        *hist.LONG_COUNTERS,
-        *hist.TOTAL_COUNTERS,
-    ):
-        assert var_name in dataset
+    assert cem_raw_cdf_filepath.name.startswith("imap_hi_l1a_90sensor-hist_")
+
+
+def test_unpack_hist_counter():
+    """Test hi.l1a.histogram.unpack_hist_counter()"""
+    # To ensure correct unpacking, use expected values with ones in the upper
+    # and lower parts of the 12-bit numbers
+    expected = (np.arange(180).reshape((2, 90)) + 2**10).astype(">u2")
+    # convert each expected uint16 to a 12-bit bitstring and join
+    bin_str = "".join([f"{val:012b}" for val in expected.ravel()])
+    # convert the bitstring to a bytes object
+    bytes_array = int(bin_str, 2).to_bytes(len(bin_str) // 8, byteorder="big")
+    output_array = unpack_hist_counter(bytes_array)
+    np.testing.assert_array_equal(output_array, expected)
+    assert output_array.dtype == np.uint16

imap_processing/tests/hi/test_science_direct_event.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+from imap_processing.hi.l1a.science_direct_event import (
+    create_dataset,
+    parse_direct_events,
+)
+
+
+def test_parse_direct_events():
+    """Test coverage for parse_direct_events function."""
+    # Generate fake, binary blob using random numbers
+    np.random.seed(2)
+    n_events = 10_000
+    exp_dict = dict()
+    exp_dict["trigger_id"] = np.random.randint(1, 4, size=n_events, dtype=np.uint8)
+    exp_dict["de_tag"] = np.random.randint(0, 2**16, size=n_events, dtype=np.uint16)
+    exp_dict["tof_1"] = np.random.randint(0, 2**10, size=n_events, dtype=np.uint16)
+    exp_dict["tof_2"] = np.random.randint(0, 2**10, size=n_events, dtype=np.uint16)
+    exp_dict["tof_3"] = np.random.randint(0, 2**10, size=n_events, dtype=np.uint16)
+
+    # 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['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
+    # Convert the bit-string into a bytes object
+    bytes_obj = bytes([int(bin_str[i : i + 8], 2) for i in range(0, len(bin_str), 8)])
+    # Parse the fake events and check values
+    de_dict = parse_direct_events(bytes_obj)
+    for key in exp_dict.keys():
+        np.testing.assert_array_equal(de_dict[key], exp_dict[key])
+
+
+def test_create_dataset():
+    """Test create_dataset"""
+    # dummy data to test create_dataset
+    data_dict = {
+        "trigger_id": [1, 2, 3],
+        "tof_1": [512, 512, 512],
+        "tof_2": [512, 512, 512],
+        "tof_3": [512, 512, 512],
+        "de_tag": [1, 2, 3],
+        "meta_seconds": [433522962, 433522962, 433522962],
+        "meta_subseconds": [512, 512, 512],
+        "esa_step": [4, 4, 4],
+        "ccsds_met": [433522961, 433522961, 433522961],
+        "src_seq_ctr": [10, 10, 10],
+        "pkt_len": [146, 146, 146],
+        "last_spin_num": [4, 4, 4],
+        "spin_invalids": [0, 0, 0],
+    }
+
+    # Test for good data
+    dataset = create_dataset(data_dict)
+    assert dataset["epoch"].shape == (3,)

imap_processing/tests/hi/test_utils.py

@@ -48,7 +48,7 @@ def test_parse_sensor_number(test_str, expected):
     [
         ("despun_z", (1, 3), (1, 3)),
         ("hae_latitude", None, (1, 360)),
-        ("counts", None, (1, 10, 360)),
+        ("counts", None, (1, 10, 5, 360)),
     ],
 )
 def test_full_dataarray(name, shape, expected_shape):
@@ -56,10 +56,11 @@ def test_full_dataarray(name, shape, expected_shape):
     coords = {
         "epoch": xr.DataArray(np.array([0])),
         "esa_energy_step": xr.DataArray(np.arange(10)),
+        "calibration_prod": xr.DataArray(np.arange(5)),
         "spin_angle_bin": xr.DataArray(np.arange(360)),
     }
     cdf_manager = ImapCdfAttributes()
-    cdf_manager.load_variable_attributes("imap_hi_variable_attrs.yaml")
+    cdf_manager.add_instrument_variable_attrs(instrument="hi", level=None)
 
     dataarray = full_dataarray(
         name, cdf_manager.get_variable_attributes(f"hi_pset_{name}"), coords, shape
@@ -83,7 +84,7 @@ def test_create_dataset_variables(var_names, shape, lookup_str):
     assert len(l1b_de_vars) == len(var_names)
     attr_mgr = ImapCdfAttributes()
     attr_mgr.add_instrument_global_attrs("hi")
-    attr_mgr.load_variable_attributes("imap_hi_variable_attrs.yaml")
+    attr_mgr.add_instrument_variable_attrs(instrument="hi", level=None)
 
     for var_name, data_array in l1b_de_vars.items():
         attrs = attr_mgr.get_variable_attributes(

imap_processing/tests/hit/{test_hit_decom.py → test_decom_hit.py}

@@ -4,11 +4,14 @@ import numpy as np
 import pytest
 
 from imap_processing import imap_module_directory
+from imap_processing.hit.hit_utils import (
+    HitAPID,
+)
 from imap_processing.hit.l0.decom_hit import (
     assemble_science_frames,
     decom_hit,
-    find_valid_starting_indices,
-    get_valid_indices,
+    decompress_rates_16_to_32,
+    get_valid_starting_indices,
     is_sequential,
     parse_count_rates,
     parse_data,
@@ -30,9 +33,10 @@ def sci_dataset():
     datasets_by_apid = packet_file_to_datasets(
         packet_file=packet_file,
         xtce_packet_definition=packet_definition,
+        use_derived_value=False,
     )
 
-    science_dataset = datasets_by_apid[1252]
+    science_dataset = datasets_by_apid[HitAPID.HIT_SCIENCE]
     return science_dataset
 
 
@@ -58,8 +62,6 @@ def test_parse_data():
 def test_parse_count_rates(sci_dataset):
     """Test the parse_count_rates function."""
 
-    # TODO: complete this test once the function is complete
-
     # Update ccsds header fields to use sc_tick as dimension
     sci_dataset = update_ccsds_header_dims(sci_dataset)
 
@@ -71,7 +73,10 @@ def test_parse_count_rates(sci_dataset):
     count_rate_vars = [
         "hdr_unit_num",
         "hdr_frame_version",
-        "hdr_status_bits",
+        "hdr_dynamic_threshold_state",
+        "hdr_leak_conv",
+        "hdr_heater_duty_cycle",
+        "hdr_code_ok",
         "hdr_minute_cnt",
         "spare",
         "livetime",
@@ -128,7 +133,7 @@ def test_is_sequential():
         assert True
 
 
-def test_find_valid_starting_indices():
+def test_get_valid_starting_indices():
     """Test the find_valid_starting_indices function."""
     flags = np.array(
         [
@@ -170,35 +175,13 @@ def test_find_valid_starting_indices():
         ]
     )
     counters = np.arange(35)
-    result = find_valid_starting_indices(flags, counters)
+    result = get_valid_starting_indices(flags, counters)
     # The only valid starting index for a science frame
     # in the flags array is 15.
     assert len(result) == 1
     assert result[0] == 15
 
 
-def test_get_valid_indices():
-    """Test the get_valid_indices function."""
-    # Array of starting indices for science frames
-    # in the science data
-    indices = np.array([0, 20, 40])
-    # Array of counters
-    counters = np.arange(60)
-    # Array of valid indices where the packets in the science
-    # frame have corresponding counters in sequential order
-    result = get_valid_indices(indices, counters, 20)
-    # All indices are valid with sequential counters
-    assert len(result) == 3
-
-    # Test array with invalid indices (use smaller sample size)
-    indices = np.array([0, 5, 10])
-    # Array of counters (missing counters 6-8)
-    counters = np.array([0, 1, 2, 3, 4, 5, 9, 10, 11, 12, 13, 14, 15, 16, 17])
-    result = get_valid_indices(indices, counters, 5)
-    # Only indices 0 and 10 are valid with sequential counters
-    assert len(result) == 2
-
-
 def test_update_ccsds_header_dims(sci_dataset):
     """Test the update_ccsds_header_data function.
 
@@ -213,8 +196,28 @@ def test_assemble_science_frames(sci_dataset):
     """Test the assemble_science_frames function."""
     updated_dataset = update_ccsds_header_dims(sci_dataset)
     updated_dataset = assemble_science_frames(updated_dataset)
-    assert "count_rates_binary" in updated_dataset
-    assert "pha_binary" in updated_dataset
+    assert "count_rates_raw" in updated_dataset
+    assert "pha_raw" in updated_dataset
+
+
+@pytest.mark.parametrize(
+    "packed, expected",
+    [
+        (0, 0),  # Test with zero
+        (15, 15),  # Test with packed integer with no scaling
+        (4096, 4096),  # Test with packed integer with power = 1
+        (64188, 112132096),  # Test with packed integer requiring scaling
+        (65535, 134201344),  # Test with maximum 16-bit value
+        (62218, 79855616),  # Test with arbitrary packed integer
+    ],
+)
+def test_decompress_rates_16_to_32(packed, expected):
+    """Test the decompress_rates_16_to_32 function.
+
+    This function decompresses a 16-bit packed integer
+    to a 32-bit integer. Used to decompress rates data.
+    """
+    assert decompress_rates_16_to_32(packed) == expected
 
 
 def test_decom_hit(sci_dataset):
@@ -223,8 +226,64 @@ def test_decom_hit(sci_dataset):
     This function orchestrates the unpacking and decompression
     of the HIT science data.
     """
-    # TODO: complete this test once the function is complete
     updated_dataset = decom_hit(sci_dataset)
-    print(updated_dataset)
-    assert "count_rates_binary" in updated_dataset
-    assert "hdr_unit_num" in updated_dataset
+    # Check if the dataset has the expected data variables
+    sci_fields = [
+        "version",
+        "type",
+        "sec_hdr_flg",
+        "pkt_apid",
+        "seq_flgs",
+        "src_seq_ctr",
+        "pkt_len",
+        "pha_raw",
+        "hdr_unit_num",
+        "hdr_frame_version",
+        "hdr_dynamic_threshold_state",
+        "hdr_leak_conv",
+        "hdr_heater_duty_cycle",
+        "hdr_code_ok",
+        "hdr_minute_cnt",
+        "livetime",
+        "num_trig",
+        "num_reject",
+        "num_acc_w_pha",
+        "num_acc_no_pha",
+        "num_haz_trig",
+        "num_haz_reject",
+        "num_haz_acc_w_pha",
+        "num_haz_acc_no_pha",
+        "sngrates",
+        "nread",
+        "nhazard",
+        "nadcstim",
+        "nodd",
+        "noddfix",
+        "nmulti",
+        "nmultifix",
+        "nbadtraj",
+        "nl2",
+        "nl3",
+        "nl4",
+        "npen",
+        "nformat",
+        "naside",
+        "nbside",
+        "nerror",
+        "nbadtags",
+        "coinrates",
+        "bufrates",
+        "l2fgrates",
+        "l2bgrates",
+        "l3fgrates",
+        "l3bgrates",
+        "penfgrates",
+        "penbgrates",
+        "ialirtrates",
+        "sectorates",
+        "l4fgrates",
+        "l4bgrates",
+    ]
+
+    for field in sci_fields:
+        assert field in updated_dataset