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

imap_processing/swe/l2/swe_l2.py

@@ -1,9 +1,14 @@
-"""SWE L2 processing module."""
+"""
+SWE L2 processing module.
+
+This module contains functions to process L1B data to L2 data products.
+"""
 
 import numpy as np
 import numpy.typing as npt
 import xarray as xr
 
+from imap_processing.spice.geometry import get_spacecraft_spin_phase
 from imap_processing.swe.utils.swe_utils import read_lookup_table
 
 # TODO: add these to instrument status summary
@@ -22,6 +27,9 @@ GEOMETRIC_FACTORS = np.array(
 )
 ELECTRON_MASS = 9.10938356e-31  # kg
 
+# See doc string of calculate_phase_space_density() for more details.
+VELOCITY_CONVERSION_FACTOR = 1.237e31
+
 
 def get_particle_energy() -> npt.NDArray:
     """
@@ -44,11 +52,11 @@ def get_particle_energy() -> npt.NDArray:
     return lookup_table
 
 
-def calculate_phase_space_density(l1b_dataset: xr.Dataset) -> npt.NDArray:
+def calculate_phase_space_density(l1b_dataset: xr.Dataset) -> xr.Dataset:
     """
     Convert counts to phase space density.
 
-    Calculate phase space density, fv, in units of s^3/cm^6
+    Calculate phase space density, fv, in units of s^3/ (cm^6 * ster).
         fv = 2 * (C/tau) / (G * v^4)
         where:
             C / tau = corrected count rate. L1B science data.
@@ -56,12 +64,26 @@ def calculate_phase_space_density(l1b_dataset: xr.Dataset) -> npt.NDArray:
             v = electron speed, computed from energy, in cm/s.
                 We need to use this formula to convert energy to speed:
                     E = 0.5 * m * v^2
-                where E is electron energy, in eV
-                (result from get_particle_energy() function),
-                m is mass of electron (9.10938356e-31 kg),
-                and v is what we want to calculate. Reorganizing above
-                formula result in v = sqrt(2 * E / m). This will be used
-                to calculate electron speed.
+                    where E is electron energy, in eV
+                    (result from get_particle_energy() function),
+                    m is mass of electron (9.10938356e-31 kg),
+                    and v is what we want to calculate. Reorganizing above
+                    formula result in v = sqrt(2 * E / m). This will be used
+                    to calculate electron speed, v.
+
+                Now to convert electron speed units to cm/s:
+                    v = sqrt(2 * E / m)
+                      = sqrt(2 * E(eV) * 1.60219e-19(J/eV) / 9.10938e-31 kg)
+                        where J = kg * m^2 / s^2.
+                      = sqrt(2 * 1.60219 * 10e−19 m^2/s^2 * E(eV) / 9.10938e-31)
+                      = sqrt(2 * 1.60219 * 10e−19 * 10e4 cm^2/s^2 * E(eV) / 9.10938e-31)
+                      = sqrt(3.20438 * 10e-15 * E(eV) / 9.10938e-31) cm/s
+                      = sqrt( (3.20438 * 10e-15 / 9.10938e-31) * E(eV) ) cm/s
+        fv = 2 * (C/tau) / (G * v^4)
+           = 2 * (C/tau) / (G * (sqrt( (3.20438 * 10e-15 / 9.10938e-31) * E(eV) ))^4)
+           = 2 * (C/tau) / (G * (sqrt(3.5176e16)^4 * E(eV)^2)
+           = 2 * (C/tau) / (G * 1.237e31 * E(eV)^2)
+        Ruth Skoug also got the same result, 1.237e31.
 
     Parameters
     ----------
@@ -70,8 +92,9 @@ def calculate_phase_space_density(l1b_dataset: xr.Dataset) -> npt.NDArray:
 
     Returns
     -------
-    density : numpy.ndarray
-        Phase space density.
+    phase_space_density_dataset : xarray.Dataset
+        Phase space density. We need to call this phase space density because
+        there will be density in L3 processing.
     """
     # Get esa_table_num for each full sweep.
     esa_table_nums = l1b_dataset["esa_table_num"].values[:, 0]
@@ -87,13 +110,107 @@ def calculate_phase_space_density(l1b_dataset: xr.Dataset) -> npt.NDArray:
     )
     particle_energy_data = particle_energy_data.reshape(-1, 24, 30)
 
-    # Calculate electron speed.
-    electron_speed = np.sqrt(2 * particle_energy_data / ELECTRON_MASS)
-
-    # Calculate phase space density.
+    # Calculate phase space density using formula:
+    #   2 * (C/tau) / (G * 1.237e31 * E(eV)^2)
+    # See doc string for more details.
     density = (2 * l1b_dataset["science_data"]) / (
         GEOMETRIC_FACTORS[np.newaxis, np.newaxis, np.newaxis, :]
-        * electron_speed[:, :, :, np.newaxis] ** 4
+        * VELOCITY_CONVERSION_FACTOR
+        * particle_energy_data[:, :, :, np.newaxis] ** 2
+    )
+
+    # Return density as xr.dataset with phase space density and
+    # energy in eV value that flux calculation can use.
+    phase_space_density_dataset = xr.Dataset(
+        {
+            "phase_space_density": (["epoch", "energy", "angle", "cem"], density.data),
+            "energy_in_eV": (["epoch", "energy", "angle"], particle_energy_data),
+        },
+        coords=l1b_dataset.coords,
+    )
+
+    return phase_space_density_dataset
+
+
+def calculate_flux(l1b_dataset: xr.Dataset) -> npt.NDArray:
+    """
+    Calculate flux.
+
+    To get flux, j = 2 * m * E * f
+        where:
+        f = calculate_phase_space_density() result
+        m - mass of electron
+        E - energy in joules. E(eV) * 1.60219e-19(J/eV)
+
+    To convert flux units:
+        j = 2 * m * E * f
+          = 2 * 9.10938356e-31 kg * E(eV) * 1.60219e-19(J/eV) * (s^3/ (cm^6 * ster)
+          = 2 * 9.10938356e-31 kg * E(eV) * 1.60219e-19 (kg * m^2 / s^2) *
+            (s^3 / (cm^6 * ster)
+          = 2 * 9.10938356e-31 * E(eV) * 1.60219e-19  kg^2 * ( 10^4 cm^2 / s^2) *
+            (s^3 / (cm^6 * ster)
+          = 2 * 9.10938356e-31 * E(eV) * 1.60219e-19 * 10^4 ((kg^2 * cm^2 * s^3) /
+            (s^2 * cm^6 * ster))
+        TODO: ask Ruth Skoug what units to use for flux and work out remaining units.
+
+    Parameters
+    ----------
+    l1b_dataset : xarray.Dataset
+        The L1B dataset to process.
+
+    Returns
+    -------
+    flux : numpy.ndarray
+        Flux values.
+    """
+    phase_space_density_ds = calculate_phase_space_density(l1b_dataset)
+    # TODO: update this once Ruth sends the correct conversion factors.
+    flux = (
+        2
+        * ELECTRON_MASS
+        * phase_space_density_ds["energy_in_eV"].data[:, :, :, np.newaxis]
+        * 1.60219e-19
+        * 10e4
+        * phase_space_density_ds["phase_space_density"].data
     )
+    return flux
 
-    return density
+
+def swe_l2(l1b_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
+    """
+    Will process data to L2.
+
+    Parameters
+    ----------
+    l1b_dataset : xarray.Dataset
+        The L1B dataset to process.
+    data_version : str
+        Version of the data product being created.
+
+    Returns
+    -------
+    data : xarray.Dataset
+        Processed data to L2.
+    """
+    flux = calculate_flux(l1b_dataset)
+
+    # Calculate spin phase using SWE sci_step_acq_time_sec calculated in l1b.
+    # L1B dataset stores it by (epoch, energy, angle, cem).
+    data_acq_time = l1b_dataset["sci_step_acq_time_sec"].data.flatten()
+
+    # calculate spin phase
+    spin_phase = get_spacecraft_spin_phase(
+        query_met_times=data_acq_time,
+    ).reshape(-1, 24, 30, 7)
+    # TODO: organize flux data by energy and spin_phase.
+    # My understanding from conversation with Ruth is that this is the hardest part
+    # and last part of the L2 processing.
+
+    # TODO: Correct return value. This is just a placeholder.
+    return xr.Dataset(
+        {
+            "flux": (["epoch", "energy", "spin_phase", "cem"], flux),
+            "spin_phase": (["epoch", "energy", "spin_phase", "cem"], spin_phase),
+        },
+        coords=l1b_dataset.coords,
+    )

imap_processing/tests/ccsds/test_data/expected_output.xml

@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='utf-8'?>
 <xtce:SpaceSystem xmlns:xtce="http://www.omg.org/space/xtce" name="Test Instrument">
-	<xtce:Header date="2024-07-26 00:00:00" version="v1.2" author="IMAP SDC" />
+	<xtce:Header date="2024-07-26 00:00:00" version="v1.2" author="IMAP SDC" source_file="excel_to_xtce_test_file.xlsx" />
 	<xtce:TelemetryMetaData>
 		<xtce:ParameterTypeSet>
 			<xtce:IntegerParameterType name="VERSION" signed="false">

imap_processing/tests/codice/test_codice_l1a.py

@@ -18,14 +18,14 @@ EXPECTED_ARRAY_SHAPES = [
     (),  # hi-ialirt  # TODO: Need to implement
     (),  # lo-ialirt  # TODO: Need to implement
     (31778,),  # hskp
-    (77, 6, 6, 128),  # lo-counters-aggregated
-    (77, 24, 6, 128),  # lo-counters-singles
-    (77, 1, 12, 128),  # lo-sw-priority
-    (77, 1, 12, 128),  # lo-nsw-priority
-    (77, 1, 1, 128),  # lo-sw-species
-    (77, 1, 1, 128),  # lo-nsw-species
-    (77, 5, 12, 128),  # lo-sw-angular
-    (77, 19, 12, 128),  # lo-nsw-angular
+    (77, 128, 6, 6),  # lo-counters-aggregated
+    (77, 128, 24, 6),  # lo-counters-singles
+    (77, 128, 1, 12),  # lo-sw-priority
+    (77, 128, 1, 12),  # lo-nsw-priority
+    (77, 128, 1, 1),  # lo-sw-species
+    (77, 128, 1, 1),  # lo-nsw-species
+    (77, 128, 5, 12),  # lo-sw-angular
+    (77, 128, 19, 12),  # lo-nsw-angular
     (77, 1, 6, 1),  # hi-counters-aggregated
     (77, 1, 12, 1),  # hi-counters-singles
     (77, 15, 4, 1),  # hi-omni

imap_processing/tests/codice/test_decompress.py

@@ -13,11 +13,11 @@ lzma_bytes = lzma.compress((234).to_bytes(1, byteorder="big"))
 # LZMA_EXAMPLE = "".join(format(byte, "08b") for byte in lzma_bytes)
 TEST_DATA = [
     (b"\xea", CoDICECompression.NO_COMPRESSION, [234]),
-    (b"\xea", CoDICECompression.LOSSY_A, [221184]),
-    (b"\xea", CoDICECompression.LOSSY_B, [1441792]),
+    (b"\xea", CoDICECompression.LOSSY_A, [212992]),
+    (b"\xea", CoDICECompression.LOSSY_B, [1310720]),
     (lzma_bytes, CoDICECompression.LOSSLESS, [234]),
-    (lzma_bytes, CoDICECompression.LOSSY_A_LOSSLESS, [221184]),
-    (lzma_bytes, CoDICECompression.LOSSY_B_LOSSLESS, [1441792]),
+    (lzma_bytes, CoDICECompression.LOSSY_A_LOSSLESS, [212992]),
+    (lzma_bytes, CoDICECompression.LOSSY_B_LOSSLESS, [1310720]),
 ]
 
 

imap_processing/tests/conftest.py

@@ -46,45 +46,48 @@ def _autoclear_spice():
 
 
 @pytest.fixture(scope="session")
-def _download_de440s(spice_test_data_path):
-    """This fixture downloads the de440s.bsp kernel into the
-    tests/spice/test_data directory if it does not already exist there. The
+def _download_external_kernels(spice_test_data_path):
+    """This fixture downloads the de440s.bsp and pck00011.tpc kernels into the
+    tests/spice/test_data directory if they do not already exist there. The
     fixture is not intended to be used directly. It is automatically added to
     tests marked with "external_kernel" in the hook below."""
     logger = logging.getLogger(__name__)
-    kernel_url = (
-        "https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/de440s.bsp"
-    )
-    kernel_name = kernel_url.split("/")[-1]
-    local_filepath = spice_test_data_path / kernel_name
-
-    if local_filepath.exists():
-        return
-    allowed_attempts = 3
-    for attempt_number in range(allowed_attempts):
-        try:
-            with requests.get(kernel_url, stream=True, timeout=30) as r:
-                r.raise_for_status()
-                with open(local_filepath, "wb") as f:
-                    for chunk in r.iter_content(chunk_size=8192):
-                        f.write(chunk)
-            logger.info("Cached kernel file to %s", local_filepath)
-            break
-        except requests.exceptions.RequestException as error:
-            logger.info(f"Request failed. {error}")
-            if attempt_number < allowed_attempts:
-                logger.info(
-                    f"Trying again, retries left "
-                    f"{allowed_attempts - attempt_number}, "
-                    f"Exception: {error}"
-                )
-                time.sleep(1)
-            else:
-                logger.error(
-                    f"Failed to download file after {allowed_attempts} "
-                    f"attempts, Final Error: {error}"
-                )
-                raise
+    kernel_urls = [
+        "https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/de440s.bsp",
+        "https://naif.jpl.nasa.gov/pub/naif/generic_kernels/pck/pck00011.tpc",
+    ]
+
+    for kernel_url in kernel_urls:
+        kernel_name = kernel_url.split("/")[-1]
+        local_filepath = spice_test_data_path / kernel_name
+
+        if local_filepath.exists():
+            continue
+        allowed_attempts = 3
+        for attempt_number in range(allowed_attempts):
+            try:
+                with requests.get(kernel_url, stream=True, timeout=30) as r:
+                    r.raise_for_status()
+                    with open(local_filepath, "wb") as f:
+                        for chunk in r.iter_content(chunk_size=8192):
+                            f.write(chunk)
+                logger.info("Cached kernel file to %s", local_filepath)
+                continue
+            except requests.exceptions.RequestException as error:
+                logger.info(f"Request failed. {error}")
+                if attempt_number < allowed_attempts:
+                    logger.info(
+                        f"Trying again, retries left "
+                        f"{allowed_attempts - attempt_number}, "
+                        f"Exception: {error}"
+                    )
+                    time.sleep(1)
+                else:
+                    logger.error(
+                        f"Failed to download file {kernel_name} after "
+                        f"{allowed_attempts} attempts, Final Error: {error}"
+                    )
+                    raise
 
 
 def pytest_collection_modifyitems(items):
@@ -93,12 +96,12 @@ def pytest_collection_modifyitems(items):
     been collected. In this case, it automatically adds fixtures based on the
     following table:
 
-    +---------------------+---------------------+
-    | pytest mark         | fixture added       |
-    +=====================+=====================+
-    | external_kernel     | _download_de440s    |
-    | use_test_metakernel | use_test_metakernel |
-    +---------------------+---------------------+
+    +---------------------+----------------------------+
+    | pytest mark         | fixture added              |
+    +=====================+============================+
+    | external_kernel     | _download_external_kernels |
+    | use_test_metakernel | use_test_metakernel        |
+    +---------------------+----------------------------+
 
     Notes
     -----
@@ -108,7 +111,7 @@ def pytest_collection_modifyitems(items):
     """
     for item in items:
         if item.get_closest_marker("external_kernel") is not None:
-            item.fixturenames.append("_download_de440s")
+            item.fixturenames.append("_download_external_kernels")
         if item.get_closest_marker("use_test_metakernel") is not None:
             item.fixturenames.append("use_test_metakernel")
 

imap_processing/tests/hi/test_hi_l1b.py

@@ -24,12 +24,12 @@ 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()

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,)