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

imap_processing/tests/ultra/unit/test_ultra_l1c_pset_bins.py

@@ -1,30 +1,32 @@
 "Tests pointing sets"
 
-import cdflib
+import astropy_healpix.healpy as hp
 import numpy as np
+import pandas as pd
 import pytest
-from cdflib import CDF
 
 from imap_processing import imap_module_directory
-from imap_processing.ena_maps.utils.spatial_utils import build_spatial_bins
 from imap_processing.ultra.l1c.ultra_l1c_pset_bins import (
     build_energy_bins,
+    get_background_rates,
     get_helio_exposure_times,
-    get_histogram,
-    get_pointing_frame_exposure_times,
-    get_pointing_frame_sensitivity,
+    get_spacecraft_exposure_times,
+    get_spacecraft_histogram,
+    get_spacecraft_sensitivity,
+    grid_sensitivity,
 )
 
 BASE_PATH = imap_module_directory / "ultra" / "lookup_tables"
+TEST_PATH = imap_module_directory / "tests" / "ultra" / "data" / "l1"
 
 
-@pytest.fixture()
+@pytest.fixture
 def test_data():
     """Test data fixture."""
     vx_sc = np.array([-186.5575, 508.5697, 508.5697, 508.5697])
     vy_sc = np.array([-707.5707, -516.0282, -516.0282, -516.0282])
     vz_sc = np.array([618.0569, 892.6931, 892.6931, 892.6931])
-    energy = np.array([3.384, 3.385, 200, 200])
+    energy = np.array([3.384, 3.385, 4.138, 4.138])
     v = np.column_stack((vx_sc, vy_sc, vz_sc))
 
     return v, energy
@@ -32,13 +34,13 @@ def test_data():
 
 def test_build_energy_bins():
     """Tests build_energy_bins function."""
-    energy_bin_edges, energy_midpoints = build_energy_bins()
-    energy_bin_start = [interval[0] for interval in energy_bin_edges]
-    energy_bin_end = [interval[1] for interval in energy_bin_edges]
+    intervals, energy_midpoints, energy_bin_geometric_means = build_energy_bins()
+    energy_bin_start = [interval[0] for interval in intervals]
+    energy_bin_end = [interval[1] for interval in intervals]
 
     assert energy_bin_start[0] == 0
     assert energy_bin_start[1] == 3.385
-    assert len(energy_bin_edges) == 24
+    assert len(intervals) == 24
     assert energy_midpoints[0] == (energy_bin_start[0] + energy_bin_end[0]) / 2
 
     # Comparison to expected values.
@@ -46,107 +48,136 @@ def test_build_energy_bins():
     np.testing.assert_allclose(energy_bin_start[-1], 279.810, atol=1e-4)
     np.testing.assert_allclose(energy_bin_end[-1], 341.989, atol=1e-4)
 
+    expected_geometric_means = np.sqrt(
+        np.array(energy_bin_start) * np.array(energy_bin_end)
+    )
+    np.testing.assert_allclose(
+        energy_bin_geometric_means, expected_geometric_means, atol=1e-4
+    )
+
 
-def test_get_histogram(test_data):
+def test_get_spacecraft_histogram(test_data):
     """Tests get_histogram function."""
     v, energy = test_data
 
-    az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints = (
-        np.rad2deg(angle_radians) for angle_radians in (build_spatial_bins())
-    )
-    energy_bin_edges, _ = build_energy_bins()
-
-    hist = get_histogram(v, energy, az_bin_edges, el_bin_edges, energy_bin_edges)
+    energy_bin_edges, _, _ = build_energy_bins()
+    subset_energy_bin_edges = energy_bin_edges[:3]
 
-    assert hist.shape == (
-        len(az_bin_edges) - 1,
-        len(el_bin_edges) - 1,
-        len(energy_bin_edges),
+    hist, latitude, longitude, n_pix = get_spacecraft_histogram(
+        v, energy, subset_energy_bin_edges, nside=1
     )
-
-
-def test_get_pointing_frame_exposure_times():
-    """Tests get_pointing_frame_exposure_times function."""
-
-    constant_exposure = BASE_PATH / "dps_grid45_compressed.cdf"
-    spins_per_pointing = 5760
-    exposure = get_pointing_frame_exposure_times(
-        constant_exposure, spins_per_pointing, "45"
+    assert hist.shape == (len(subset_energy_bin_edges), hp.nside2npix(1))
+    assert n_pix == hp.nside2npix(1)
+    assert latitude.shape == (n_pix,)
+    assert longitude.shape == (n_pix,)
+
+    # Spot check that 2 counts are in the third energy bin
+    assert np.sum(hist[2, :]) == 2
+
+    # Test overlapping energy bins
+    overlapping_bins = [
+        (0.0, 3.385),
+        (2.5, 4.137),
+        (3.385, 5.057),
+    ]
+    hist, latitude, longitude, n_pix = get_spacecraft_histogram(
+        v, energy, overlapping_bins, nside=1
     )
-
-    assert exposure.shape == (720, 360)
-    # Assert that the exposure time at the highest azimuth is
-    # 15s x spins per pointing.
-    assert np.array_equal(
-        exposure[:, 359], np.full_like(exposure[:, 359], spins_per_pointing * 15)
+    # Spot check that 3 counts are in the third energy bin
+    assert np.sum(hist[2, :]) == 3
+    assert n_pix == hp.nside2npix(1)
+    assert latitude.shape == (n_pix,)
+    assert longitude.shape == (n_pix,)
+
+
+def test_get_background_rates():
+    """Tests get_background_rates function."""
+    background_rates = get_background_rates(nside=128)
+    assert background_rates.shape == hp.nside2npix(128)
+
+
+@pytest.mark.external_test_data
+def test_get_spacecraft_exposure_times():
+    """Test get_spacecraft_exposure_times function."""
+    constant_exposure = TEST_PATH / "ultra_90_dps_exposure.csv"
+    df_exposure = pd.read_csv(constant_exposure)
+    exposure_pointing = get_spacecraft_exposure_times(df_exposure)
+    assert exposure_pointing.shape == (196608,)
+
+    np.testing.assert_allclose(
+        exposure_pointing.values[22684:22686],
+        np.array([1.035, 1.035]) * 5760,
+        atol=1e-6,
     )
-    # Assert that the exposure time at the lowest azimuth is 0 (no exposure).
-    assert np.array_equal(exposure[:, 0], np.full_like(exposure[:, 359], 0.0))
 
 
-@pytest.mark.external_kernel()
+@pytest.mark.external_kernel
 @pytest.mark.use_test_metakernel("imap_ena_sim_metakernel.template")
 def test_get_helio_exposure_times():
     """Tests get_helio_exposure_times function."""
 
-    constant_exposure = BASE_PATH / "dps_grid45_compressed.cdf"
     start_time = 829485054.185627
     end_time = 829567884.185627
+
     mid_time = np.average([start_time, end_time])
 
-    with cdflib.CDF(constant_exposure) as cdf_file:
-        sc_exposure = cdf_file.varget("dps_grid45")
+    constant_exposure = TEST_PATH / "ultra_90_dps_exposure.csv"
+    df_exposure = pd.read_csv(constant_exposure)
 
-    exposure_3d = get_helio_exposure_times(mid_time, sc_exposure)
+    helio_exposure = get_helio_exposure_times(mid_time, df_exposure)
 
-    energy_bin_edges, energy_midpoints = build_energy_bins()
-    az_bin_edges, el_bin_edges, az_bin_midpoints, el_bin_midpoints = (
-        np.rad2deg(angle_radians) for angle_radians in (build_spatial_bins())
-    )
+    _, energy_midpoints, _ = build_energy_bins()
 
-    assert exposure_3d.shape == (
-        len(el_bin_midpoints),
-        len(az_bin_midpoints),
-        len(energy_midpoints),
-    )
+    nside = 128
+    npix = hp.nside2npix(nside)
+    assert helio_exposure.shape == (npix, len(energy_midpoints))
 
-    cdf_files = [
-        ("dps_exposure_helio_45_E1.cdf", "dps_exposure_helio_45_E1"),
-        ("dps_exposure_helio_45_E12.cdf", "dps_exposure_helio_45_E12"),
-        ("dps_exposure_helio_45_E24.cdf", "dps_exposure_helio_45_E24"),
-    ]
+    total_input = np.sum(df_exposure["Exposure Time"].values)
+    total_output = np.sum(helio_exposure[:, 23])
 
-    cdf_directory = imap_module_directory / "tests" / "ultra" / "test_data" / "l1"
+    assert np.allclose(total_input, total_output, atol=1e-6)
 
-    exposures = []
 
-    for file_name, var_name in cdf_files:
-        file_path = cdf_directory / file_name
-        with CDF(file_path) as cdf_file:
-            exposure_data = cdf_file.varget(var_name)
-            transposed_exposure = np.transpose(exposure_data, (2, 1, 0))
-            exposures.append(transposed_exposure)
+@pytest.mark.external_test_data
+def test_get_spacecraft_sensitivity():
+    """Tests get_spacecraft_sensitivity function."""
+    # TODO: remove below here with lookup table aux api
+    efficiencies = TEST_PATH / "Ultra_90_DPS_efficiencies_all.csv"
+    geometric_function = TEST_PATH / "ultra_90_dps_gf.csv"
 
-    assert np.array_equal(np.squeeze(exposures[0]), exposure_3d[:, :, 0])
-    assert np.array_equal(np.squeeze(exposures[1]), exposure_3d[:, :, 11])
-    assert np.array_equal(np.squeeze(exposures[2]), exposure_3d[:, :, 23])
+    df_efficiencies = pd.read_csv(efficiencies)
+    df_geometric_function = pd.read_csv(geometric_function)
 
+    sensitivity, energy_vals, right_ascension, declination = get_spacecraft_sensitivity(
+        df_efficiencies, df_geometric_function
+    )
+
+    assert sensitivity.shape == (df_efficiencies.shape[0], df_efficiencies.shape[1] - 2)
+    assert np.array_equal(energy_vals, np.arange(3.0, 80.5, 0.5))
 
-def test_get_pointing_frame_sensitivity():
-    """Tests get_pointing_frame_sensitivity function."""
+    df_efficiencies_test = pd.DataFrame(
+        {"3.0keV": [1.0, 2.0], "3.5keV": [3.0, 4.0], "4.0keV": [5.0, 6.0]}
+    )
+
+    df_geometric_function_test = pd.DataFrame({"Response": [0.1, 0.2]})
+
+    df_sensitivity_test = df_efficiencies_test.mul(
+        df_geometric_function_test["Response"], axis=0
+    )
+
+    expected_sensitivity = pd.DataFrame(
+        {"3.0keV": [0.1, 0.4], "3.5keV": [0.3, 0.8], "4.0keV": [0.5, 1.2]}
+    )
 
-    # TODO: energy bins need to be modified from N=90 to N=24.
-    constant_sensitivity = BASE_PATH / "dps_sensitivity45.cdf"
-    spins_per_pointing = 5760
-    sensitivity = get_pointing_frame_sensitivity(
-        constant_sensitivity,
-        spins_per_pointing,
-        "45",
+    assert np.allclose(
+        df_sensitivity_test.to_numpy(), expected_sensitivity.to_numpy(), atol=1e-6
     )
 
-    assert sensitivity.shape == (90, 720, 360)
+    expected_result = sensitivity["3.0keV"].values
+    result = grid_sensitivity(df_efficiencies, df_geometric_function, 3.0)
 
-    with cdflib.CDF(constant_sensitivity) as cdf_file:
-        expected_sensitivity = cdf_file.varget("dps_sensitivity45") * spins_per_pointing
+    assert np.allclose(result, expected_result, atol=1e-5)
 
-    assert np.array_equal(sensitivity, expected_sensitivity)
+    # Check that out-of-bounds energy returns all NaNs
+    result = grid_sensitivity(df_efficiencies, df_geometric_function, 2.5)
+    assert np.isnan(result).all()

imap_processing/tests/ultra/unit/test_ultra_l2.py

@@ -0,0 +1,230 @@
+from unittest.mock import patch
+
+import numpy as np
+import pytest
+
+from imap_processing.ena_maps import ena_maps
+from imap_processing.ena_maps.utils.coordinates import CoordNames
+from imap_processing.tests.ultra.data.mock_data import mock_l1c_pset_product_healpix
+from imap_processing.ultra.l2 import ultra_l2
+
+
+class TestUltraL2:
+    @pytest.fixture
+    def _setup_spice_kernels_list(self, spice_test_data_path, furnish_kernels):
+        self.required_kernel_names = [
+            "imap_science_0001.tf",
+            "imap_sclk_0000.tsc",
+            "sim_1yr_imap_attitude.bc",
+            "sim_1yr_imap_pointing_frame.bc",
+        ]
+
+    @pytest.fixture
+    def _mock_single_pset(self, _setup_spice_kernels_list, furnish_kernels):
+        with furnish_kernels(self.required_kernel_names):
+            self.ultra_pset = mock_l1c_pset_product_healpix(
+                nside=128, stripe_center_lat=0, timestr="2025-05-15T12:00:00"
+            )
+
+    @pytest.fixture
+    def _mock_multiple_psets(self, _setup_spice_kernels_list, furnish_kernels):
+        with furnish_kernels(self.required_kernel_names):
+            self.ultra_psets = [
+                mock_l1c_pset_product_healpix(
+                    nside=128,
+                    stripe_center_lat=mid_latitude,
+                    width_scale=5,
+                    counts_scaling_params=(50, 0.5),
+                    peak_exposure=1000,
+                    timestr=f"2025-05-{4 * i + 1:02d}T12:00:00",
+                    head=("90"),
+                )
+                for i, mid_latitude in enumerate(
+                    np.arange(
+                        22.5,
+                        180,
+                        45,
+                    )
+                )
+            ]
+
+        self.psets_total_counts = np.sum(
+            [pset["counts"].values.sum() for pset in self.ultra_psets]
+        )
+
+    @pytest.fixture
+    def mock_data_dict(self, _mock_multiple_psets):
+        return {pset.attrs["Logical_file_id"]: pset for pset in self.ultra_psets}
+
+    @pytest.mark.parametrize(
+        ["map_frame", "rtol"],
+        [
+            # Tight tolerance when 'projecting' to the same frame
+            ("IMAP_DPS", 1e-8),
+            # Loose tolerance of  30% error vs naive flux estimate with real projection.
+            # TODO: Ideally this tolerance will tighten if we can fix the issue with
+            # the exposure time for uneven numbers of pixels from each PointingSet.
+            ("ECLIPJ2000", 3e-1),
+        ],
+    )
+    @pytest.mark.usefixtures("_mock_single_pset", "_setup_spice_kernels_list")
+    def test_generate_ultra_healpix_skymap_single_pset(
+        self, map_frame, rtol, furnish_kernels
+    ):
+        # Avoid modifying the original pset
+        pset = self.ultra_pset.copy(deep=True)
+
+        # Set the values in the single input PSET for easy calculation
+        # of the expected flux and flux uncertainty
+        pset["counts"].values = np.full_like(pset["counts"].values, 10)
+        pset["exposure_factor"].values = np.ones_like(pset["exposure_factor"].values)
+        pset["background_rates"].values = np.ones_like(pset["background_rates"].values)
+        pset["sensitivity"].values = np.ones_like(pset["sensitivity"].values)
+        pset["energy_bin_delta"].values = np.ones_like(pset["energy_bin_delta"].values)
+
+        # Create the Healpix skymap in the desired frame.
+        with furnish_kernels(self.required_kernel_names):
+            hp_skymap = ultra_l2.generate_ultra_healpix_skymap(
+                ultra_l1c_psets=[
+                    pset,
+                ],
+                output_map_structure=ena_maps.AbstractSkyMap.from_dict(
+                    {
+                        "sky_tiling_type": "HEALPIX",
+                        "spice_reference_frame": map_frame,
+                        "projection_method_and_values": {
+                            "PUSH": [
+                                "counts",
+                                "exposure_factor",
+                                "sensitivity",
+                                "background_rates",
+                            ],
+                        },
+                        "nside": 32,
+                        "nested": False,
+                    }
+                ),
+            )
+
+        assert hp_skymap.nside == 32
+        assert hp_skymap.nested is False
+
+        # Check that required variables are present, and dropped variables are not
+        expected_vars = [
+            "flux",
+            "flux_uncertainty",
+            "exposure_factor",
+            "observation_time",
+        ]
+        for var in expected_vars:
+            assert var in hp_skymap.data_1d.data_vars
+        unexpected_vars = ultra_l2.VARIABLES_TO_DROP_AFTER_FLUX_CALCULATION
+        for var in unexpected_vars:
+            assert var not in hp_skymap.data_1d.data_vars
+
+        # The ratio of the solid angle of a map's pixel to the solid angle of a
+        # pointing set's pixel. Counts will scale up by this ratio.
+        solid_angle_ratio_map_to_pset = (
+            hp_skymap.solid_angle / ena_maps.UltraPointingSet(pset).solid_angle
+        )
+
+        # Estimate the expected flux and flux uncertainty
+        expected_flux = (
+            (10 * solid_angle_ratio_map_to_pset / 1) - 1 * solid_angle_ratio_map_to_pset
+        ) / (1 * hp_skymap.solid_angle * 1)
+        expected_flux_unc = ((10 * solid_angle_ratio_map_to_pset) ** 0.5 / 1) / (
+            1 * hp_skymap.solid_angle * 1
+        )
+
+        np.testing.assert_allclose(
+            hp_skymap.data_1d["flux"].values,
+            expected_flux,
+            rtol=rtol,
+        )
+        np.testing.assert_allclose(
+            hp_skymap.data_1d["flux_uncertainty"].values,
+            expected_flux_unc,
+            rtol=rtol,
+        )
+
+    @pytest.mark.usefixtures("_mock_multiple_psets", "_setup_spice_kernels_list")
+    def test_generate_ultra_healpix_skymap_multiple_psets(self, furnish_kernels):
+        with patch(
+            "imap_processing.ultra.l2.ultra_l2.VARIABLES_TO_DROP_AFTER_FLUX_CALCULATION",
+            [],
+        ):
+            with furnish_kernels(self.required_kernel_names):
+                hp_skymap = ultra_l2.generate_ultra_healpix_skymap(
+                    ultra_l1c_psets=self.ultra_psets,
+                    output_map_structure=ena_maps.AbstractSkyMap.from_dict(
+                        {
+                            "sky_tiling_type": "RECTANGULAR",
+                            "spice_reference_frame": "ECLIPJ2000",
+                            "projection_method_and_values": {
+                                "PUSH": [
+                                    "counts",
+                                    "exposure_factor",
+                                    "sensitivity",
+                                    "background_rates",
+                                ],
+                            },
+                            "spacing_deg": 2.0,
+                        }
+                    ),
+                )
+
+        assert hp_skymap.nside == ultra_l2.DEFAULT_L2_HEALPIX_NSIDE
+        assert hp_skymap.nested == ultra_l2.DEFAULT_L2_HEALPIX_NESTED
+
+        # The total counts in the skymap should be equal to the sum of the counts
+        # in the individual psets
+        np.testing.assert_allclose(
+            hp_skymap.data_1d["counts"].sum(),
+            self.psets_total_counts,
+        )
+
+        # The map should contain the following variables,
+        # because we did not drop any variables
+        expected_vars = (
+            ultra_l2.REQUIRED_L1C_VARIABLES
+            + ultra_l2.VARIABLES_TO_DROP_AFTER_FLUX_CALCULATION
+            + ["flux", "flux_uncertainty"]
+        )
+        for var in expected_vars:
+            assert var in hp_skymap.data_1d.data_vars
+
+        # Check the dims of the key variables
+        counts_dims = (
+            CoordNames.TIME.value,
+            CoordNames.ENERGY_ULTRA.value,
+            CoordNames.GENERIC_PIXEL.value,
+        )
+        assert hp_skymap.data_1d["counts"].dims == counts_dims
+        assert hp_skymap.data_1d["flux"].dims == counts_dims
+        assert hp_skymap.data_1d["flux_uncertainty"].dims == counts_dims
+        assert hp_skymap.data_1d["exposure_factor"].dims == counts_dims[-1:]
+
+    @pytest.mark.usefixtures("_setup_spice_kernels_list")
+    def test_ultra_l2_output_unbinned_healpix(self, mock_data_dict, furnish_kernels):
+        map_structure = ena_maps.AbstractSkyMap.from_dict(
+            {
+                "sky_tiling_type": "HEALPIX",
+                "spice_reference_frame": "ECLIPJ2000",
+                "projection_method_and_values": {
+                    "PUSH": ["counts", "exposure_factor", "sensitivity"],
+                },
+                "nside": 16,
+                "nested": True,
+            }
+        )
+        with furnish_kernels(self.required_kernel_names):
+            [
+                map_dataset,
+            ] = ultra_l2.ultra_l2(
+                data_dict=mock_data_dict,
+                data_version="001",
+                output_map_structure=map_structure,
+            )
+
+        assert map_dataset.attrs["HEALPix_nside"] == map_structure.nside
+        assert map_dataset.attrs["HEALPix_nest"] == map_structure.nested

imap_processing/ultra/constants.py

@@ -80,4 +80,4 @@ class UltraConstants:
     CULLING_RPM_MAX = 6.0
 
     # Thresholds for culling based on counts.
-    CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [-1e5, 0, 10, 20, 1e5]
+    CULLING_ENERGY_BIN_EDGES: ClassVar[list] = [0, 10, 20, 1e5]

imap_processing/ultra/l0/decom_tools.py

@@ -1,12 +1,9 @@
 """Ultra Decompression Tools."""
 
 import numpy as np
-import numpy.typing as npt
-import space_packet_parser
+from numpy.typing import NDArray
 
 from imap_processing.ultra.l0.ultra_utils import (
-    EVENT_FIELD_RANGES,
-    append_fillval,
     parse_event,
 )
 from imap_processing.utils import convert_to_binary_string
@@ -130,14 +127,15 @@ def decompress_binary(
     current_position = 0
     decompressed_values: list = []
 
-    while current_position < len(binary):
+    while current_position < len(binary) and len(decompressed_values) < array_length:
         # Read the width of the block
         width, current_position = read_and_advance(binary, width_bit, current_position)
-        # If width is 0 or None, we don't have enough bits left
-        if width is None or len(decompressed_values) >= array_length:
-            break
+        # If width is 0, add 'block' number of zeroes and continue
+        if width == 0:
+            decompressed_values.extend([0] * block)
+            continue
 
-        # For each block, read 16 values of the given width
+        # For each block, read 'block' values of the given width
         for _ in range(block):
             # Ensure there are enough bits left to read the width
             if len(binary) - current_position < width:
@@ -156,7 +154,7 @@ def decompress_image(
     binary_data: str,
     width_bit: int,
     mantissa_bit_length: int,
-) -> npt.NDArray:
+) -> NDArray:
     """
     Will decompress a binary string representing an image into a matrix of pixel values.
 
@@ -177,14 +175,14 @@ def decompress_image(
 
     Returns
     -------
-    p_decom : numpy.ndarray
+    p_decom : NDArray
         A 2D numpy array representing pixel values.
         Each pixel is stored as an unsigned 16-bit integer (uint16).
 
     Notes
     -----
     This process is described starting on page 168 in IMAP-Ultra Flight
-    Software Specification document (7523-9009_Rev_-.pdf).
+    Software Specification document.
     """
     rows = 54
     cols = 180
@@ -239,44 +237,34 @@ def decompress_image(
 
 
 def read_image_raw_events_binary(
-    packet: space_packet_parser.packets.CCSDSPacket, decom_data: dict
-) -> dict:
+    event_data: bytes,
+    count: int,
+) -> NDArray:
     """
     Convert contents of binary string 'EVENTDATA' into values.
 
     Parameters
     ----------
-    packet : space_packet_parser.packets.CCSDSPacket
-        Packet.
-    decom_data : dict
-        Parsed data.
+    event_data : bytes
+        Event data.
+    count : int
+        Number of events.
 
     Returns
     -------
-    decom_data : dict
-        Each for loop appends to the existing dictionary.
+    event_data : NDArray
+        Event data.
     """
-    binary = convert_to_binary_string(packet["EVENTDATA"])
-    count = packet["COUNT"]
+    binary = convert_to_binary_string(event_data)
     # 166 bits per event
     event_length = 166 if count else 0
-
-    # Uses fill value for all packets that do not contain event data.
-    if count == 0:
-        # if decom_data is empty, append fill values to all fields
-        if not decom_data:
-            for field in EVENT_FIELD_RANGES.keys():
-                decom_data[field] = []
-        append_fillval(decom_data, packet)
+    event_data_list = []
 
     # For all packets with event data, parses the binary string
-    else:
-        for i in range(count):
-            start_index = i * event_length
-            event_binary = binary[start_index : start_index + event_length]
-            event_data = parse_event(event_binary)
-
-            for key, value in event_data.items():
-                decom_data[key].append(value)
+    for i in range(count):
+        start_index = i * event_length
+        event_binary = binary[start_index : start_index + event_length]
+        parsed_event = parse_event(event_binary)
+        event_data_list.append(parsed_event)
 
-    return decom_data
+    return np.array(event_data_list)