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

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_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,14 +4,18 @@ 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,
+    subcom_sectorates,
     update_ccsds_header_dims,
 )
 from imap_processing.utils import packet_file_to_datasets
@@ -30,9 +34,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 +63,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 +74,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 +134,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 +176,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 +197,67 @@ 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
+
+
+def test_subcom_sectorates(sci_dataset):
+    """Test the subcom_sectorates function.
+
+    This function organizes the sector rates data
+    into new variables for each species and adds
+    them to the dataset.
+    """
+
+    # Prepare the input needed for the function to be called
+    sci_dataset = update_ccsds_header_dims(sci_dataset)
+    sci_dataset = assemble_science_frames(sci_dataset)
+    parse_count_rates(sci_dataset)
+
+    # Call the function to be tested
+    subcom_sectorates(sci_dataset)
+
+    # Check if the dataset has the expected new variables
+    for species in ["H", "4He", "CNO", "NeMgSi", "Fe"]:
+        assert species in sci_dataset
+        assert f"{species}_energy_min" in sci_dataset
+        assert f"{species}_energy_max" in sci_dataset
+
+    # Check the shape of the new variables
+    for species in ["H", "4He", "CNO", "NeMgSi", "Fe"]:
+        if species == "H":
+            assert sci_dataset[species].shape == (86, 3, 8, 15)
+            assert sci_dataset[f"{species}_energy_min"].shape == (3,)
+        elif species in ("4He", "CNO", "NeMgSi"):
+            assert sci_dataset[species].shape == (86, 2, 8, 15)
+            assert sci_dataset[f"{species}_energy_min"].shape == (2,)
+        elif species == "Fe":
+            assert sci_dataset[species].shape == (86, 1, 8, 15)
+            assert sci_dataset[f"{species}_energy_min"].shape == (1,)
+        assert (
+            sci_dataset[f"{species}_energy_max"].shape
+            == sci_dataset[f"{species}_energy_min"].shape
+        )
+
+
+@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):
@@ -225,6 +268,12 @@ def test_decom_hit(sci_dataset):
     """
     # 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 new variables
+    # Check that binary science data exists
+    assert "count_rates_raw" in updated_dataset
+    assert "pha_raw" in updated_dataset
+    # Check that sector rates data has been organized
+    for species in ["H", "4He", "CNO", "NeMgSi", "Fe"]:
+        assert species in updated_dataset
+        assert f"{species}_energy_min" in updated_dataset
+        assert f"{species}_energy_max" in updated_dataset

imap_processing/tests/hit/test_hit_l1a.py

@@ -1,55 +1,18 @@
-import numpy as np
 import pytest
 import xarray as xr
 
 from imap_processing import imap_module_directory
-from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
-from imap_processing.hit.l1a.hit_l1a import (
-    HitAPID,
-    concatenate_leak_variables,
-    hit_l1a,
-    process_housekeeping,
-)
-from imap_processing.utils import packet_file_to_datasets
+from imap_processing.hit.l1a.hit_l1a import hit_l1a
 
 
 @pytest.fixture(scope="module")
 def packet_filepath():
     """Set path to test data file"""
     return (
-        imap_module_directory / "tests/hit/test_data/imap_hit_l0_hk_20100105_v001.pkts"
+        imap_module_directory / "tests/hit/test_data/imap_hit_l0_raw_20100105_v001.pkts"
     )
 
 
-@pytest.fixture(scope="module")
-def datasets(packet_filepath):
-    """Create datasets from packet file"""
-    packet_definition = (
-        imap_module_directory / "hit/packet_definitions/" "hit_packet_definitions.xml"
-    )
-    datasets_by_apid = packet_file_to_datasets(
-        packet_file=packet_filepath,
-        xtce_packet_definition=packet_definition,
-    )
-    return datasets_by_apid
-
-
-@pytest.fixture(scope="module")
-def attribute_manager():
-    """Create the attribute manager"""
-    attr_mgr = ImapCdfAttributes()
-    attr_mgr.add_instrument_global_attrs(instrument="hit")
-    attr_mgr.add_instrument_variable_attrs(instrument="hit", level="l1a")
-    attr_mgr.add_global_attribute("Data_version", "001")
-    return attr_mgr
-
-
-@pytest.fixture(scope="module")
-def housekeeping_dataset(datasets):
-    """Get the housekeeping dataset"""
-    return datasets[HitAPID.HIT_HSKP]
-
-
 def test_hit_l1a(packet_filepath):
     """Create L1A datasets from a packet file.
 
@@ -64,161 +27,3 @@ def test_hit_l1a(packet_filepath):
     assert len(processed_datasets) == 1
     assert isinstance(processed_datasets[0], xr.Dataset)
     assert processed_datasets[0].attrs["Logical_source"] == "imap_hit_l1a_hk"
-
-
-def test_concatenate_leak_variables(housekeeping_dataset):
-    """Test concatenation of leak_i variables"""
-
-    # Create data array for leak_i dependency
-    adc_channels = xr.DataArray(
-        np.arange(64, dtype=np.uint8),
-        name="adc_channels",
-        dims=["adc_channels"],
-    )
-
-    updated_dataset = concatenate_leak_variables(housekeeping_dataset, adc_channels)
-
-    # Assertions
-    # ----------------
-    assert "leak_i" in updated_dataset
-    assert updated_dataset["leak_i"].shape == (88, 64)
-    for i in range(64):
-        # Check if the values in the `leak_i` variable match the values in
-        # the original `leak_i_XX` variable.
-        #  - First access the `leak_i` variable in the `updated_dataset`.
-        #    The [:, i] selects all rows (`:`) and the `i`-th column of the `leak_i`
-        #    variable.
-        #  - Then access the `leak_i_XX` variable in the `housekeeping_dataset`.
-        #    The `f"leak_i_{i:02d}"` selects the variable with the name `leak_i_XX`
-        #    where `XX` is the `i`-th value.
-        #  - Compare values
-        np.testing.assert_array_equal(
-            updated_dataset["leak_i"][:, i], housekeeping_dataset[f"leak_i_{i:02d}"]
-        )
-
-
-def test_process_housekeeping(housekeeping_dataset, attribute_manager):
-    """Test processing of housekeeping dataset"""
-
-    # Call the function
-    processed_hskp_dataset = process_housekeeping(
-        housekeeping_dataset, attribute_manager
-    )
-
-    # Define the keys that should have dropped from the dataset
-    dropped_keys = {
-        "pkt_apid",
-        "sc_tick",
-        "version",
-        "type",
-        "sec_hdr_flg",
-        "seq_flgs",
-        "src_seq_ctr",
-        "pkt_len",
-        "hskp_spare1",
-        "hskp_spare2",
-        "hskp_spare3",
-        "hskp_spare4",
-        "hskp_spare5",
-    }
-    # Define the keys that should be present
-    valid_keys = {
-        "heater_on",
-        "fsw_version_b",
-        "ebox_m12va",
-        "phasic_stat",
-        "ebox_3d4vd",
-        "ebox_p2d0vd",
-        "temp1",
-        "last_bad_seq_num",
-        "ebox_m5d7va",
-        "ebox_p12va",
-        "table_status",
-        "enable_50khz",
-        "mram_disabled",
-        "temp3",
-        "preamp_l1a",
-        "l2ab_bias",
-        "l34b_bias",
-        "fsw_version_c",
-        "num_evnt_last_hk",
-        "dac1_enable",
-        "preamp_l234b",
-        "analog_temp",
-        "fee_running",
-        "fsw_version_a",
-        "num_errors",
-        "test_pulser_on",
-        "dac0_enable",
-        "preamp_l1b",
-        "l1ab_bias",
-        "l34a_bias",
-        "leak_i",
-        "last_good_cmd",
-        "lvps_temp",
-        "idpu_temp",
-        "temp2",
-        "preamp_l234a",
-        "last_good_seq_num",
-        "num_good_cmds",
-        "heater_control",
-        "hvps_temp",
-        "ebox_p5d7va",
-        "spin_period_long",
-        "enable_hvps",
-        "temp0",
-        "spin_period_short",
-        "dyn_thresh_lvl",
-        "num_bad_cmds",
-        "adc_mode",
-        "ebox_5d1vd",
-        "active_heater",
-        "last_error_num",
-        "last_bad_cmd",
-        "ref_p5v",
-        "code_checksum",
-        "mode",
-    }
-
-    # Define the dataset attributes
-    dataset_attrs = {
-        "Data_level": "1A",
-        "Data_type": "L1A_HK>Level-1A Housekeeping",
-        "Data_version": "001",
-        "Descriptor": "HIT>IMAP High-energy Ion Telescope",
-        "Discipline": "Solar Physics>Heliospheric Physics",
-        "File_naming_convention": "source_descriptor_datatype_yyyyMMdd_vNNN",
-        "HTTP_LINK": "https://imap.princeton.edu/",
-        "Instrument_type": "Particles (space)",
-        "LINK_TITLE": "IMAP The Interstellar Mapping and Acceleration Probe",
-        "Logical_file_id": None,
-        "Logical_source": "imap_hit_l1a_hk",
-        "Logical_source_description": "IMAP Mission HIT Instrument Level-1A "
-        "Housekeeping Data.",
-        "Mission_group": "IMAP",
-        "PI_affiliation": "Princeton University",
-        "PI_name": "Prof. David J. McComas",
-        "Project": "STP>Solar Terrestrial Probes",
-        "Source_name": "IMAP>Interstellar Mapping and Acceleration Probe",
-        "TEXT": "The High-energy Ion Telescope (HIT) measures the elemental "
-        "composition, energy spectra, angle distributions, and arrival "
-        "times of high-energy ions. HIT delivers full-sky coverage from "
-        "a wide instrument field-of-view (FOV) to enable a high resolution "
-        "of ion measurements, such as observing shock-accelerated ions, "
-        "determining the origin of the solar energetic particles (SEPs) "
-        "spectra, and resolving particle transport in the heliosphere. "
-        "See https://imap.princeton.edu/instruments/hit for more details.\n",
-    }
-
-    # Define the coordinates and dimensions. Both have equivalent values
-    dataset_coords_dims = {"epoch", "adc_channels", "adc_channels_label"}
-
-    # Assertions
-    # ----------------
-    # Check that the dataset has the correct variables
-    assert valid_keys == set(processed_hskp_dataset.data_vars.keys())
-    assert set(dropped_keys).isdisjoint(set(processed_hskp_dataset.data_vars.keys()))
-    # Check that the dataset has the correct attributes, coordinates, and dimensions
-    assert processed_hskp_dataset.attrs == dataset_attrs
-    assert processed_hskp_dataset.coords.keys() == dataset_coords_dims
-    assert processed_hskp_dataset.sizes.keys() == dataset_coords_dims

imap_processing/tests/hit/test_hit_l1b.py

@@ -2,51 +2,182 @@ import pytest
 import xarray as xr
 
 from imap_processing import imap_module_directory
-from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.hit.l1a import hit_l1a
 from imap_processing.hit.l1b import hit_l1b
 
 
+@pytest.fixture(scope="module")
+def packet_filepath():
+    """Set path to test data file"""
+    return (
+        imap_module_directory / "tests/hit/test_data/imap_hit_l0_raw_20100105_v001.pkts"
+    )
+
+
 @pytest.fixture()
-def dependency():
-    """Get L1A data from test packet file"""
+def dependencies(packet_filepath):
+    """Get dependencies for L1B processing"""
+    # Create dictionary of dependencies and add CCSDS packet file
+    data_dict = {"imap_hit_l0_raw": packet_filepath}
+    # Add L1A datasets
+    l1a_datasets = hit_l1a.hit_l1a(packet_filepath, "001")
+    for dataset in l1a_datasets:
+        data_dict[dataset.attrs["Logical_source"]] = dataset
+    return data_dict
 
-    packet_filepath = (
-        imap_module_directory / "tests/hit/test_data/imap_hit_l0_hk_20100105_v001.pkts"
-    )
-    l1a_data = hit_l1a.hit_l1a(packet_filepath, "001")[0]
 
-    return l1a_data
+@pytest.fixture()
+def hk_dataset(dependencies):
+    """Get the housekeeping dataset"""
+    datasets = hit_l1b.hit_l1b(dependencies, "001")
+    for dataset in datasets:
+        if dataset.attrs["Logical_source"] == "imap_hit_l1b_hk":
+            return dataset
 
 
-def test_create_hk_dataset():
-    """Test creating housekeeping L1B dataset
+def test_hit_l1b_hk_dataset_variables(hk_dataset):
+    """Test the variables in the housekeeping dataset"""
+    # Define the keys that should have dropped from the housekeeping dataset
+    dropped_keys = {
+        "pkt_apid",
+        "sc_tick",
+        "version",
+        "type",
+        "sec_hdr_flg",
+        "seq_flgs",
+        "src_seq_ctr",
+        "pkt_len",
+        "hskp_spare1",
+        "hskp_spare2",
+        "hskp_spare3",
+        "hskp_spare4",
+        "hskp_spare5",
+    }
+    # Define the keys that should be present in the housekeeping dataset
+    valid_keys = {
+        "heater_on",
+        "fsw_version_b",
+        "ebox_m12va",
+        "phasic_stat",
+        "ebox_3d4vd",
+        "ebox_p2d0vd",
+        "temp1",
+        "last_bad_seq_num",
+        "ebox_m5d7va",
+        "ebox_p12va",
+        "table_status",
+        "enable_50khz",
+        "mram_disabled",
+        "temp3",
+        "preamp_l1a",
+        "l2ab_bias",
+        "l34b_bias",
+        "fsw_version_c",
+        "num_evnt_last_hk",
+        "dac1_enable",
+        "preamp_l234b",
+        "analog_temp",
+        "fee_running",
+        "fsw_version_a",
+        "num_errors",
+        "test_pulser_on",
+        "dac0_enable",
+        "preamp_l1b",
+        "l1ab_bias",
+        "l34a_bias",
+        "leak_i",
+        "last_good_cmd",
+        "lvps_temp",
+        "idpu_temp",
+        "temp2",
+        "preamp_l234a",
+        "last_good_seq_num",
+        "num_good_cmds",
+        "heater_control",
+        "hvps_temp",
+        "ebox_p5d7va",
+        "spin_period_long",
+        "enable_hvps",
+        "temp0",
+        "spin_period_short",
+        "dyn_thresh_lvl",
+        "num_bad_cmds",
+        "adc_mode",
+        "ebox_5d1vd",
+        "active_heater",
+        "last_error_num",
+        "last_bad_cmd",
+        "ref_p5v",
+        "code_checksum",
+        "mode",
+    }
+    # Check that the dataset has the correct variables
+    assert valid_keys == set(hk_dataset.data_vars.keys())
+    assert set(dropped_keys).isdisjoint(set(hk_dataset.data_vars.keys()))
 
-    Creates a xarray dataset for housekeeping data
-    """
 
-    # create the attribute manager for this data level
-    attr_mgr = ImapCdfAttributes()
-    attr_mgr.add_instrument_global_attrs(instrument="hit")
-    attr_mgr.add_instrument_variable_attrs(instrument="hit", level="l1b")
-    attr_mgr.add_global_attribute("Data_version", "001")
+def test_hit_l1b_hk_dataset_attributes(hk_dataset):
+    """Test the attributes, dims, and coords in the housekeeping dataset"""
+    # TODO consider removing this test since it may be hard to upkeep if
+    #  attributes change
+    # Define the housekeeping dataset attributes
+    dataset_attrs = {
+        "Acknowledgement": "Please acknowledge the IMAP Mission Principal "
+        "Investigator, Prof. David J. McComas of Princeton "
+        "University.\n",
+        "Data_level": "1B",
+        "Data_type": "L1B_HK>Level-1B Housekeeping",
+        "Data_version": "001",
+        "Descriptor": "HIT>IMAP High-energy Ion Telescope",
+        "Discipline": "Solar Physics>Heliospheric Physics",
+        "File_naming_convention": "source_descriptor_datatype_yyyyMMdd_vNNN",
+        "HTTP_LINK": "https://imap.princeton.edu/",
+        "Instrument_type": "Particles (space)",
+        "LINK_TITLE": "IMAP The Interstellar Mapping and Acceleration Probe",
+        "Logical_file_id": None,
+        "Logical_source": "imap_hit_l1b_hk",
+        "Logical_source_description": "IMAP Mission HIT Instrument Level-1B "
+        "Housekeeping Data.",
+        "Mission_group": "IMAP",
+        "PI_affiliation": "Princeton University",
+        "PI_name": "Prof. David J. McComas",
+        "Project": "STP>Solar Terrestrial Probes",
+        "Rules_of_use": "All IMAP data products are publicly released and citable for "
+        "use in publications. Please consult the IMAP team "
+        "publications and personnel for further details on "
+        "production, processing, and usage of these data.\n",
+        "Source_name": "IMAP>Interstellar Mapping and Acceleration Probe",
+        "TEXT": "The High-energy Ion Telescope (HIT) measures the elemental "
+        "composition, energy spectra, angle distributions, and arrival "
+        "times of high-energy ions. HIT delivers full-sky coverage from "
+        "a wide instrument field-of-view (FOV) to enable a high resolution "
+        "of ion measurements, such as observing shock-accelerated ions, "
+        "determining the origin of the solar energetic particles (SEPs) "
+        "spectra, and resolving particle transport in the heliosphere. "
+        "See https://imap.princeton.edu/instruments/hit for more details.\n",
+    }
 
-    l1b_hk_dataset = hit_l1b.create_hk_dataset(attr_mgr)
-    assert isinstance(l1b_hk_dataset, xr.Dataset)
+    # Define the coordinates and dimensions. Both have equivalent values
+    dataset_coords_dims = {"epoch", "adc_channels", "adc_channels_label"}
 
+    # Check that the dataset has the correct attributes, coordinates, and dimensions
+    assert hk_dataset.attrs == dataset_attrs
+    assert hk_dataset.coords.keys() == dataset_coords_dims
 
-def test_hit_l1b(dependency):
+
+def test_hit_l1b(dependencies):
     """Test creating L1B CDF files
 
-    Creates a CDF file for each L1B product and stores
-    their filepaths in a list
+    Creates a list of xarray datasets for each L1B product
 
     Parameters
     ----------
-    dependency : xr.dataset
-        L1A data
+    dependencies : dict
+        Dictionary of L1A datasets and CCSDS packet file path
     """
-    datasets = hit_l1b.hit_l1b(dependency, "001")
+    # TODO: update assertions after science data processing is completed
+    datasets = hit_l1b.hit_l1b(dependencies, "001")
+
     assert len(datasets) == 1
     assert isinstance(datasets[0], xr.Dataset)
     assert datasets[0].attrs["Logical_source"] == "imap_hit_l1b_hk"