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

imap_processing/tests/hit/test_hit_l1a.py

@@ -8,7 +8,16 @@ from imap_processing.hit.hit_utils import (
     HitAPID,
     get_datasets_by_apid,
 )
-from imap_processing.hit.l1a.hit_l1a import decom_hit, hit_l1a, subcom_sectorates
+from imap_processing.hit.l1a.hit_l1a import (
+    calculate_uncertainties,
+    decom_hit,
+    hit_l1a,
+    subcom_sectorates,
+)
+from imap_processing.tests.hit.helpers.l1_validation import (
+    compare_data,
+    prepare_counts_validation_data,
+)
 
 # TODO: Packet files are per apid at the moment so the tests currently
 #  reflect this. Eventually, HIT will provide a packet file with all apids
@@ -26,7 +35,97 @@ def hk_packet_filepath():
 @pytest.fixture(scope="module")
 def sci_packet_filepath():
     """Set path to test data file"""
-    return imap_module_directory / "tests/hit/test_data/sci_sample1.ccsds"
+    return imap_module_directory / "tests/hit/test_data/sci_sample.ccsds"
+
+
+@pytest.fixture(scope="module")
+def validation_data():
+    """Load validation data from CSV file."""
+    validation_file = (
+        imap_module_directory / "tests/hit/validation_data/sci_sample_raw.csv"
+    )
+    validation_data = pd.read_csv(validation_file)
+    return validation_data
+
+
+# <=== TESTS ===>
+
+
+def test_subcom_sectorates(sci_packet_filepath):
+    """Test the subcom_sectorates function.
+
+    This function organizes the sector rates data
+    by species and adds the data as new variables
+    to the dataset.
+    """
+
+    # Unpack and decompress ccsds file to xarray datasets
+    sci_dataset = get_datasets_by_apid(sci_packet_filepath)[HitAPID.HIT_SCIENCE]
+    sci_dataset = decom_hit(sci_dataset)
+
+    # Call the function to be tested
+    subcom_sectorates(sci_dataset)
+
+    # Number of science frames in the dataset
+    frames = sci_dataset["epoch"].shape[0]
+
+    # Check if the dataset has the expected new variables
+    for species in ["h", "he4", "cno", "nemgsi", "fe"]:
+        assert f"{species}_counts_sectored" 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 data variables
+        if species == "h":
+            assert sci_dataset[f"{species}_counts_sectored"].shape == (frames, 3, 8, 15)
+            assert sci_dataset[f"{species}_energy_min"].shape == (3,)
+        elif species in ("4he", "cno", "nemgsi"):
+            assert sci_dataset[f"{species}_counts_sectored"].shape == (frames, 2, 8, 15)
+            assert sci_dataset[f"{species}_energy_min"].shape == (2,)
+        elif species == "fe":
+            assert sci_dataset[f"{species}_counts_sectored"].shape == (frames, 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
+        )
+
+
+def test_calculate_uncertainties():
+    """Test the calculate_uncertainties function.
+
+    This function calculates the uncertainties for the counts data.
+    """
+
+    # Create a sample dataset
+    data = {
+        "counts": (("epoch", "index"), np.array([[10, 20], [0, 1]])),
+        "version": (("epoch",), np.array([1, 1])),
+    }
+    dataset = xr.Dataset(data)
+
+    # Calculate uncertainties
+    result = calculate_uncertainties(dataset)
+
+    # Expected uncertainties
+    #   DELTA_PLUS = sqrt(counts + 1) + 1
+    #   DELTA_MINUS = sqrt(counts)
+    expected_delta_plus = np.array(
+        [[np.sqrt(11) + 1, np.sqrt(21) + 1], [np.sqrt(1) + 1, np.sqrt(2) + 1]]
+    )
+    expected_delta_minus = np.array(
+        [[np.sqrt(10), np.sqrt(20)], [np.sqrt(0), np.sqrt(1)]]
+    )
+
+    # Assertions
+    np.testing.assert_array_almost_equal(
+        result["counts_delta_plus"].values, expected_delta_plus
+    )
+    np.testing.assert_array_almost_equal(
+        result["counts_delta_minus"].values, expected_delta_minus
+    )
+    assert "version_delta_plus" not in result
+    assert "version_delta_minus" not in result
 
 
 def test_validate_l1a_housekeeping_data(hk_packet_filepath):
@@ -107,191 +206,36 @@ def test_validate_l1a_housekeeping_data(hk_packet_filepath):
                 )
 
 
-def test_subcom_sectorates(sci_packet_filepath):
-    """Test the subcom_sectorates function.
-
-    This function organizes the sector rates data
-    by species and adds the data as new variables
-    to the dataset.
-    """
-
-    # Unpack and decompress ccsds file to xarray datasets
-    sci_dataset = get_datasets_by_apid(sci_packet_filepath)[HitAPID.HIT_SCIENCE]
-    sci_dataset = decom_hit(sci_dataset)
-
-    # Call the function to be tested
-    subcom_sectorates(sci_dataset)
-
-    # Number of science frames in the dataset
-    frames = sci_dataset["epoch"].shape[0]
-
-    # Check if the dataset has the expected new variables
-    for species in ["h", "he4", "cno", "nemgsi", "fe"]:
-        assert f"{species}_counts_sectored" 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 data variables
-        if species == "h":
-            assert sci_dataset[f"{species}_counts_sectored"].shape == (frames, 3, 8, 15)
-            assert sci_dataset[f"{species}_energy_min"].shape == (3,)
-        elif species in ("4he", "cno", "nemgsi"):
-            assert sci_dataset[f"{species}_counts_sectored"].shape == (frames, 2, 8, 15)
-            assert sci_dataset[f"{species}_energy_min"].shape == (2,)
-        elif species == "fe":
-            assert sci_dataset[f"{species}_counts_sectored"].shape == (frames, 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
-        )
-
-
-def test_validate_l1a_counts_data(sci_packet_filepath):
+def test_validate_l1a_counts_data(sci_packet_filepath, validation_data):
     """Compare the output of the L1A processing to the validation data.
 
     This test compares the counts data product with the validation data.
     The PHA data product is not validated since it's not being decommutated.
 
+    Since the validation data is structured differently than the processed data,
+    This test prepares the validation data for comparison by calling helper
+    functions to consolidate the data into arrays and rename columns to match
+    the processed data.
+
     Parameters
     ----------
     sci_packet_filepath : str
         Path to ccsds file for science data
+    validation_data : pd.DataFrame
+        Preloaded validation data
     """
+
     # Process the sample data
     processed_datasets = hit_l1a(sci_packet_filepath, "001")
     l1a_counts_data = processed_datasets[0]
 
-    # Read in the validation data
-    validation_data = pd.read_csv(
-        imap_module_directory / "tests/hit/validation_data/sci_sample_raw1.csv"
-    )
-
-    # Helper functions for this test
-    def consolidate_rate_columns(data, rate_columns):
-        # The validation data isn't organized by arrays.
-        # Each value is in a separate column.
-        # Aggregate related data into arrays.
-        for new_col, prefix in rate_columns.items():
-            columns = [col for col in data.columns if prefix in col]
-            data[new_col] = data[columns].apply(lambda row: row.values, axis=1)
-            if new_col == "sectorates":
-                # Differentiate between the sectorate columns with three and
-                # five digits in the name. Those with three digits contain the
-                # sectorate value for the science frame and those with five digits
-                # are the sectorate values with the mod value appended to the end.
-                # The mod value determines the species and energy range for that
-                # science frame
-                sectorates_three_digits = data.filter(
-                    regex=r"^SECTORATES_\d{3}$"
-                ).columns
-                sectorates_five_digits = data.filter(
-                    regex=r"^SECTORATES_\d{3}_\d{1}$"
-                ).columns
-                data["sectorates"] = data[sectorates_three_digits].apply(
-                    lambda row: row.values.reshape(8, 15), axis=1
-                )
-                data["sectorates_by_mod_val"] = data[sectorates_five_digits].apply(
-                    lambda row: row.values, axis=1
-                )
-            data.drop(columns=columns, inplace=True)
-        return data
-
-    def process_single_rates(data):
-        # Combine the single rates for high and low gain into a 2D array
-        data["sngrates"] = data.apply(
-            lambda row: np.array([row["sngrates_hg"], row["sngrates_lg"]]), axis=1
-        )
-        data.drop(columns=["sngrates_hg", "sngrates_lg"], inplace=True)
-        return data
-
-    def process_sectorates(data):
-        # Add species and energy index to the data frame for each science frame
-        # First find the mod value for each science frame which equals the first index
-        # in the sectorates_by_mod_val array that has a value instead of a blank space
-        data["mod_10"] = data["sectorates_by_mod_val"].apply(
-            lambda row: next((i for i, value in enumerate(row) if value != " "), None)
-        )
-        # Mapping of mod value to species and energy index
-        species_energy = {
-            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},
-        }
-        # Use the mod 10 value to determine the species and energy index
-        # for each science frame and add this information to the data frame
-        data["species"] = data["mod_10"].apply(
-            lambda row: species_energy[row]["species"].lower()
-            if row is not None
-            else None
-        )
-        data["energy_idx"] = data["mod_10"].apply(
-            lambda row: species_energy[row]["energy_idx"] if row is not None else None
-        )
-        data.drop(columns=["sectorates_by_mod_val", "mod_10"], inplace=True)
-        return data
-
-    def compare_data(expected_data, actual_data, skip):
-        # Compare the processed data to the validation data
-        for field in expected_data.columns:
-            if field not in [
-                "sc_tick",
-                "hdr_status_bits",
-                "species",
-                "energy_idx",
-            ]:
-                assert field in l1a_counts_data.data_vars.keys()
-            if field not in ignore:
-                for frame in range(expected_data.shape[0]):
-                    if field == "species":
-                        species = expected_data[field][frame]
-                        energy_idx = expected_data["energy_idx"][frame]
-                        assert np.array_equal(
-                            actual_data[f"{species}_counts_sectored"][frame][
-                                energy_idx
-                            ].data,
-                            expected_data["sectorates"][frame],
-                        )
-                    else:
-                        assert np.array_equal(
-                            actual_data[field][frame].data, expected_data[field][frame]
-                        )
-
-    rate_columns = {
-        "coinrates": "COINRATES_",
-        "bufrates": "BUFRATES_",
-        "l2fgrates": "L2FGRATES_",
-        "l2bgrates": "L2BGRATES_",
-        "l3fgrates": "L3FGRATES_",
-        "l3bgrates": "L3BGRATES_",
-        "penfgrates": "PENFGRATES_",
-        "penbgrates": "PENBGRATES_",
-        "sectorates": "SECTORATES_",
-        "l4fgrates": "L4FGRATES_",
-        "l4bgrates": "L4BGRATES_",
-        "ialirtrates": "IALIRTRATES_",
-        "sngrates_hg": "SNGRATES_HG_",
-        "sngrates_lg": "SNGRATES_LG_",
-    }
-
     # Prepare validation data for comparison with processed data
-    validation_data.columns = validation_data.columns.str.strip()
-    validation_data = consolidate_rate_columns(validation_data, rate_columns)
-    validation_data = process_single_rates(validation_data)
-    validation_data = process_sectorates(validation_data)
+    validation_data = prepare_counts_validation_data(validation_data)
 
-    # Fields to skip in comparison. CCSDS headers plus a few others that are not
-    # relevant to the comparison.
+    # Fields to skip in comparison. CCSDS headers plus a few others.
     # The CCSDS header fields contain data per packet in the dataset, but the
-    # validation data has a value per science frame so skipping comparison for now
-    ignore = [
+    # validation data has one value per science frame.
+    skip_fields = [
         "version",
         "type",
         "sec_hdr_flg",
@@ -299,20 +243,13 @@ def test_validate_l1a_counts_data(sci_packet_filepath):
         "seq_flgs",
         "src_seq_ctr",
         "pkt_len",
-        "sc_tick",
-        "hdr_status_bits",
         "energy_idx",
     ]
 
     # Compare processed data to validation data
-    validation_data.columns = validation_data.columns.str.lower()
-    compare_data(validation_data, l1a_counts_data, ignore)
-
-    # TODO: add validation for hdr_status_bits once validation data has been updated
-    #  to include this field broken out into its subfields
-
-    # TODO: add validation for CCSDS fields? currently validation data only has
-    #  one value per frame and the processed data has one value per packet.
+    compare_data(
+        expected_data=validation_data, actual_data=l1a_counts_data, skip=skip_fields
+    )
 
 
 def test_hit_l1a(hk_packet_filepath, sci_packet_filepath):

imap_processing/tests/hit/test_hit_l1b.py

@@ -1,3 +1,4 @@
+import numpy as np
 import pandas as pd
 import pytest
 import xarray as xr
@@ -5,30 +6,47 @@ import xarray as xr
 from imap_processing import imap_module_directory
 from imap_processing.hit.l1a import hit_l1a
 from imap_processing.hit.l1b import hit_l1b
+from imap_processing.tests.hit.helpers.l1_validation import (
+    prepare_standard_rates_validation_data,
+)
+
+# TODO: Packet files are per apid at the moment so the tests currently
+#  reflect this. Eventually, HIT will provide a packet file with all apids
+#  and the tests will need to be updated.
 
 
 @pytest.fixture(scope="module")
 def packet_filepath():
     """Set path to test data file"""
+    # TODO: Update this path when HIT provides a packet file with all apids.
+    #  Current test file only has the housekeeping apid is available.
     return (
         imap_module_directory / "tests/hit/test_data/imap_hit_l0_raw_20100105_v001.pkts"
     )
 
 
+@pytest.fixture(scope="module")
+def sci_packet_filepath():
+    """Set path to test data file"""
+    return imap_module_directory / "tests/hit/test_data/sci_sample.ccsds"
+
+
 @pytest.fixture()
-def dependencies(packet_filepath):
+def dependencies(packet_filepath, sci_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")
+    # TODO: Remove this when HIT provides a packet file with all apids.
+    l1a_datasets.extend(hit_l1a.hit_l1a(sci_packet_filepath, "001"))
     for dataset in l1a_datasets:
         data_dict[dataset.attrs["Logical_source"]] = dataset
     return data_dict
 
 
 @pytest.fixture()
-def hk_dataset(dependencies):
+def l1b_hk_dataset(dependencies):
     """Get the housekeeping dataset"""
     datasets = hit_l1b.hit_l1b(dependencies, "001")
     for dataset in datasets:
@@ -36,7 +54,100 @@ def hk_dataset(dependencies):
             return dataset
 
 
-def test_hit_l1b_hk_dataset_variables(hk_dataset):
+@pytest.fixture()
+def l1b_standard_rates_dataset(dependencies):
+    """Get the standard rates dataset"""
+    # TODO: use this fixture in future unit test to validate the standard rates dataset
+    datasets = hit_l1b.hit_l1b(dependencies, "001")
+    for dataset in datasets:
+        if dataset.attrs["Logical_source"] == "imap_hit_l1b_standard-rates":
+            return dataset
+
+
+@pytest.fixture()
+def l1a_counts_dataset(sci_packet_filepath):
+    """Get L1A counts dataset to test l1b processing functions"""
+    l1a_datasets = hit_l1a.hit_l1a(sci_packet_filepath, "001")
+    for dataset in l1a_datasets:
+        if dataset.attrs["Logical_source"] == "imap_hit_l1a_count-rates":
+            return dataset
+
+
+def test_process_standard_rates_data(l1a_counts_dataset):
+    """Test function for processing standard rates data"""
+    l1b_standard_rates_dataset = hit_l1b.process_standard_rates_data(l1a_counts_dataset)
+
+    # Check that a xarray dataset with the correct logical source is returned
+    assert isinstance(l1b_standard_rates_dataset, xr.Dataset)
+
+    # Define the data variables that should be present in the dataset
+    valid_data_vars = {
+        "sngrates",
+        "coinrates",
+        "pbufrates",
+        "l2fgrates",
+        "l2bgrates",
+        "l3fgrates",
+        "l3bgrates",
+        "penfgrates",
+        "penbgrates",
+        "ialirtrates",
+        "l4fgrates",
+        "l4bgrates",
+        "sngrates_delta_plus",
+        "coinrates_delta_plus",
+        "pbufrates_delta_plus",
+        "l2fgrates_delta_plus",
+        "l2bgrates_delta_plus",
+        "l3fgrates_delta_plus",
+        "l3bgrates_delta_plus",
+        "penfgrates_delta_plus",
+        "penbgrates_delta_plus",
+        "ialirtrates_delta_plus",
+        "l4fgrates_delta_plus",
+        "l4bgrates_delta_plus",
+        "sngrates_delta_minus",
+        "coinrates_delta_minus",
+        "pbufrates_delta_minus",
+        "l2fgrates_delta_minus",
+        "l2bgrates_delta_minus",
+        "l3fgrates_delta_minus",
+        "l3bgrates_delta_minus",
+        "penfgrates_delta_minus",
+        "penbgrates_delta_minus",
+        "ialirtrates_delta_minus",
+        "l4fgrates_delta_minus",
+        "l4bgrates_delta_minus",
+        "dynamic_threshold_state",
+    }
+
+    valid_coords = [
+        "epoch",
+        "gain",
+        "sngrates_index",
+        "coinrates_index",
+        "pbufrates_index",
+        "l2fgrates_index",
+        "l2bgrates_index",
+        "l3fgrates_index",
+        "l3bgrates_index",
+        "penfgrates_index",
+        "penbgrates_index",
+        "ialirtrates_index",
+        "l4fgrates_index",
+        "l4bgrates_index",
+    ]
+
+    # Check that the dataset has the correct variables
+    assert valid_data_vars == set(
+        l1b_standard_rates_dataset.data_vars.keys()
+    ), "Data variables mismatch"
+    assert valid_coords == list(
+        l1b_standard_rates_dataset.coords
+    ), "Coordinates mismatch"
+
+
+def test_hit_l1b_hk_dataset_variables(l1b_hk_dataset):
     """Test the variables in the housekeeping dataset"""
     # Define the keys that should have dropped from the housekeeping dataset
     dropped_keys = {
@@ -113,61 +224,18 @@ def test_hit_l1b_hk_dataset_variables(hk_dataset):
         "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()))
-
-
-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",
-    }
+    assert valid_keys == set(l1b_hk_dataset.data_vars.keys())
+    assert set(dropped_keys).isdisjoint(set(l1b_hk_dataset.data_vars.keys()))
 
     # 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
+    # Check that the dataset has the correct coordinates, and dimensions
+    assert l1b_hk_dataset.coords.keys() == dataset_coords_dims
 
 
-def test_validate_l1b_housekeeping_data(hk_dataset):
-    """Validate the housekeeping dataset created by the L1B processing.
+def test_validate_l1b_hk_data(l1b_hk_dataset):
+    """Test to validate the housekeeping dataset created by the L1B processing.
 
     Parameters
     ----------
@@ -214,7 +282,7 @@ def test_validate_l1b_housekeeping_data(hk_dataset):
     }
 
     # Check that dropped variables are not in the dataset
-    assert set(dropped_fields).isdisjoint(set(hk_dataset.data_vars.keys()))
+    assert set(dropped_fields).isdisjoint(set(l1b_hk_dataset.data_vars.keys()))
 
     # TODO: uncomment block after new validation data is provided
     # Define the keys that should be ignored in the validation
@@ -241,6 +309,30 @@ def test_validate_l1b_housekeeping_data(hk_dataset):
     #             )
 
 
+def test_validate_l1b_standard_rates_data(l1b_standard_rates_dataset):
+    """A test to validate the standard rates dataset created by the L1B processing."""
+
+    validation_data = pd.read_csv(
+        imap_module_directory
+        / "tests/hit/validation_data/hit_l1b_standard_sample2_nsrl_v4_3decimals.csv"
+    )
+
+    validation_data = prepare_standard_rates_validation_data(validation_data)
+
+    for field in validation_data.columns:
+        assert (
+            field in l1b_standard_rates_dataset.data_vars.keys()
+        ), f"Field {field} not found in actual data variables"
+        for frame in range(validation_data.shape[0]):
+            np.testing.assert_allclose(
+                l1b_standard_rates_dataset[field][frame].data,
+                validation_data[field][frame],
+                rtol=1e-7,
+                atol=1e-3,
+                err_msg=f"Mismatch in {field} at frame {frame}",
+            )
+
+
 def test_hit_l1b(dependencies):
     """Test creating L1B CDF files
 
@@ -254,6 +346,8 @@ def test_hit_l1b(dependencies):
     # 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 len(datasets) == 2
+    for dataset in datasets:
+        assert isinstance(dataset, xr.Dataset)
     assert datasets[0].attrs["Logical_source"] == "imap_hit_l1b_hk"
+    assert datasets[1].attrs["Logical_source"] == "imap_hit_l1b_standard-rates"