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

imap_processing/ialirt/packet_definitions/ialirt_swapi.xml

@@ -99,28 +99,28 @@
 			<xtce:Parameter name="SWAPI_RESERVED" parameterTypeRef="uint15">
 				<xtce:LongDescription>SWAPI Instrument Reserved</xtce:LongDescription>
 			</xtce:Parameter>
-			<xtce:Parameter name="SWAPI_SEQ" parameterTypeRef="uint4">
+			<xtce:Parameter name="SWAPI_SEQ_NUMBER" parameterTypeRef="uint4">
 				<xtce:LongDescription>Sequence Number in Table</xtce:LongDescription>
 			</xtce:Parameter>
 			<xtce:Parameter name="SWAPI_VERSION" parameterTypeRef="uint4">
 				<xtce:LongDescription>Sweep Table Version Number</xtce:LongDescription>
 			</xtce:Parameter>
-			<xtce:Parameter name="SWAPI_COIN_1" parameterTypeRef="uint16">
+			<xtce:Parameter name="SWAPI_COIN_CNT0" parameterTypeRef="uint16">
 				<xtce:LongDescription>Coincidence Counts During the First 1/6 Sec</xtce:LongDescription>
 			</xtce:Parameter>
-			<xtce:Parameter name="SWAPI_COIN_2" parameterTypeRef="uint16">
+			<xtce:Parameter name="SWAPI_COIN_CNT1" parameterTypeRef="uint16">
 				<xtce:LongDescription>Coincidence Counts During the Second 1/6 Sec</xtce:LongDescription>
 			</xtce:Parameter>
-			<xtce:Parameter name="SWAPI_COIN_3" parameterTypeRef="uint16">
+			<xtce:Parameter name="SWAPI_COIN_CNT2" parameterTypeRef="uint16">
 				<xtce:LongDescription>Coincidence Counts During the Third 1/6 Sec</xtce:LongDescription>
 			</xtce:Parameter>
-			<xtce:Parameter name="SWAPI_COIN_4" parameterTypeRef="uint16">
+			<xtce:Parameter name="SWAPI_COIN_CNT3" parameterTypeRef="uint16">
 				<xtce:LongDescription>Coincidence Counts During the Fourth 1/6 Sec</xtce:LongDescription>
 			</xtce:Parameter>
-			<xtce:Parameter name="SWAPI_COIN_5" parameterTypeRef="uint16">
+			<xtce:Parameter name="SWAPI_COIN_CNT4" parameterTypeRef="uint16">
 				<xtce:LongDescription>Coincidence Counts During the Fifth 1/6 Sec</xtce:LongDescription>
 			</xtce:Parameter>
-			<xtce:Parameter name="SWAPI_COIN_6" parameterTypeRef="uint16">
+			<xtce:Parameter name="SWAPI_COIN_CNT5" parameterTypeRef="uint16">
 				<xtce:LongDescription>Coincidence Counts During the Sixth 1/6 Sec</xtce:LongDescription>
 			</xtce:Parameter>
 			<xtce:Parameter name="SWAPI_SPARE" parameterTypeRef="uint8">
@@ -153,14 +153,14 @@
 					<xtce:ParameterRefEntry parameterRef="SWAPI_ACQ"/>
 					<xtce:ParameterRefEntry parameterRef="SWAPI_FLAG"/>
 					<xtce:ParameterRefEntry parameterRef="SWAPI_RESERVED"/>
-					<xtce:ParameterRefEntry parameterRef="SWAPI_SEQ"/>
+					<xtce:ParameterRefEntry parameterRef="SWAPI_SEQ_NUMBER"/>
 					<xtce:ParameterRefEntry parameterRef="SWAPI_VERSION"/>
-					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_1"/>
-					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_2"/>
-					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_3"/>
-					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_4"/>
-					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_5"/>
-					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_6"/>
+					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_CNT0"/>
+					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_CNT1"/>
+					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_CNT2"/>
+					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_CNT3"/>
+					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_CNT4"/>
+					<xtce:ParameterRefEntry parameterRef="SWAPI_COIN_CNT5"/>
 					<xtce:ParameterRefEntry parameterRef="SWAPI_SPARE"/>
 					<!-- SWAPI -->
 				</xtce:EntryList>

imap_processing/ialirt/utils/grouping.py

@@ -0,0 +1,114 @@
+"""Common grouping functions for I-ALiRT instruments."""
+
+import logging
+
+import numpy as np
+import xarray as xr
+
+logger = logging.getLogger(__name__)
+
+
+def filter_valid_groups(grouped_data: xr.Dataset) -> xr.Dataset:
+    """
+    Filter out groups where `src_seq_ctr` diff are not 1.
+
+    Parameters
+    ----------
+    grouped_data : xr.Dataset
+        Dataset with a "group" coordinate.
+
+    Returns
+    -------
+    filtered_data : xr.Dataset
+        Filtered dataset with only valid groups remaining.
+    """
+    valid_groups = []
+    unique_groups = np.unique(grouped_data["group"].values)
+
+    for group in unique_groups:
+        src_seq_ctr = grouped_data["src_seq_ctr"][
+            (grouped_data["group"] == group).values
+        ]
+        src_seq_ctr_diff = np.diff(src_seq_ctr) % 16384
+
+        # Accept group only if all diffs are 1.
+        if np.all(src_seq_ctr_diff == 1):
+            valid_groups.append(group)
+        else:
+            logger.info(f"src_seq_ctr_diff != 1 for group {group}.")
+
+    filtered_data = grouped_data.where(
+        xr.DataArray(np.isin(grouped_data["group"], valid_groups), dims="epoch"),
+        drop=True,
+    )
+
+    return filtered_data
+
+
+def find_groups(
+    accumulated_data: xr.Dataset,
+    sequence_range: tuple,
+    sequence_name: str,
+    time_name: str,
+) -> xr.Dataset:
+    """
+    Group data based on time and sequence number values.
+
+    Parameters
+    ----------
+    accumulated_data : xr.Dataset
+        Packets dataset accumulated over 1 min.
+    sequence_range : tuple
+        Tuple of two integers defining the range of group values (inclusive endpoints).
+    sequence_name : str
+        Name of the sequence variable.
+    time_name : str
+        Name of the time variable.
+
+    Returns
+    -------
+    grouped_data : xr.Dataset
+        Filtered data with "group" coordinate.
+
+    Notes
+    -----
+    Filters data based on:
+    1. Time values between the first and last sequence_range values.
+    Take out time values before sequence_range[0] and after sequence_range[-1].
+    2. Sequence values src_seq_ctr between the first and
+    last sequence_range. These must be consecutive.
+    """
+    sorted_data = accumulated_data.sortby(time_name, ascending=True)
+
+    # Use sequence_range == 0 to define the beginning of the group.
+    # Find time at this index and use it as the beginning time for the group.
+    start_times = sorted_data[time_name][
+        (sorted_data[sequence_name] == sequence_range[0])
+    ]
+    start_time = start_times.min()
+    # Use max sequence_range to define the end of the group.
+    end_times = sorted_data[time_name][
+        ([sorted_data[sequence_name] == sequence_range[-1]][-1])
+    ]
+    end_time = end_times.max()
+
+    # Filter data before the sequence_range=0
+    # and after the last value of sequence_range.
+    grouped_data = sorted_data.where(
+        (sorted_data[time_name] >= start_time) & (sorted_data[time_name] <= end_time),
+        drop=True,
+    )
+
+    # Assign labels based on the start_times.
+    group_labels = np.searchsorted(start_times, grouped_data[time_name], side="right")
+    # Example:
+    # grouped_data.coords
+    # Coordinates:
+    #   * epoch    (epoch) int64 7kB 315922822184000000 ... 315923721184000000
+    #     group    (epoch) int64 7kB 1 1 1 1 1 1 1 1 1 ... 15 15 15 15 15 15 15 15 15
+    grouped_data = grouped_data.assign_coords(group=("epoch", group_labels))
+
+    # Filter out groups with non-sequential src_seq_ctr values.
+    filtered_data = filter_valid_groups(grouped_data)
+
+    return filtered_data

imap_processing/ialirt/utils/time.py

@@ -0,0 +1,29 @@
+"""Common time functions for I-ALiRT instruments."""
+
+import xarray as xr
+
+
+def calculate_time(
+    coarse_time: xr.DataArray, fine_time: xr.DataArray, conversion: int
+) -> xr.DataArray:
+    """
+    Calculate the time.
+
+    Parameters
+    ----------
+    coarse_time : xr.DataArray
+        Coarse time.
+    fine_time : xr.DataArray
+        Fine time.
+    conversion : int
+        Fine time units = 1 second.
+
+    Returns
+    -------
+    time_seconds: xr.DataArray
+        Calculated time.
+    """
+    fine_time_fraction = fine_time / conversion
+    time_seconds = coarse_time + fine_time_fraction
+
+    return time_seconds

imap_processing/idex/atomic_masses.csv

@@ -0,0 +1,22 @@
+Mass,Name
+1,H
+2,H2
+12,C
+16,O
+22,Na
+23,Mg24
+24,Mg25
+25,Mg26
+27,Si28
+28,Si29
+29,Si30
+39,K39
+39,Ca40
+40,K41
+41,Ca42
+43,Ca44
+53,Fe54
+55,Fe56
+56,Fe57
+57,Fe58
+196,Au197

imap_processing/idex/decode.py

@@ -174,7 +174,7 @@ def rice_decode(compressed_data: str, nbit10: bool, sample_count: int) -> list[i
 
     Returns
     -------
-    list
+    list[int]
         Decompressed data as a list of integers.
     """
     # Constants:
@@ -186,7 +186,7 @@ def rice_decode(compressed_data: str, nbit10: bool, sample_count: int) -> list[i
     sub_frame_per_frame = frame_size / SUB_FRAME_SIZE
 
     bits = compressed_data
-    out_data = []
+    out_data: list[int] = []
     sub_frame_count = 0
     bp = 0
     # Decode all subframes

imap_processing/idex/idex_constants.py

@@ -1,6 +1,15 @@
 """Contains dataclasses to support IDEX processing."""
 
 from dataclasses import dataclass
+from enum import Enum, IntEnum
+
+
+class IDEXAPID(IntEnum):
+    """Create ENUM for apid."""
+
+    IDEX_SCIENCE = 1424
+    IDEX_CATLST = 1419
+    IDEX_EVT = 1418
 
 
 @dataclass
@@ -25,3 +34,27 @@ class IdexConstants:
     DATA_MAX: int = 4096
     SAMPLE_RATE_MIN: int = -130
     SAMPLE_RATE_MAX: int = 130
+
+
+# FM sampling rate (quartz oscillator)
+# Seconds per sample.
+FM_SAMPLING_RATE = 0.0038466235767167234e-6
+# Nanoseconds to seconds conversion
+NS_TO_S = 1e-9
+# Microseconds to seconds conversion
+US_TO_S = 1e-6
+
+TARGET_HIGH_FREQUENCY_CUTOFF = 100
+
+TARGET_NOISE_FREQUENCY = 7000
+
+
+class ConversionFactors(float, Enum):
+    """Conversion factor values (DN to picocoulombs) for each of the six waveforms."""
+
+    TOF_High = 2.89e-4
+    TOF_Low = 5.14e-4
+    TOF_Mid = 1.13e-2
+    Target_Low = 1.58e1
+    Target_High = 1.63e-1
+    Ion_Grid = 7.46e-4

imap_processing/idex/idex_l0.py

@@ -2,14 +2,19 @@
 
 import logging
 from pathlib import Path
-from typing import Union
+from typing import Any, Union
+
+from xarray import Dataset
 
 from imap_processing import decom, imap_module_directory
+from imap_processing.utils import packet_file_to_datasets
 
 logger = logging.getLogger(__name__)
 
 
-def decom_packets(packet_file: Union[str, Path]) -> list:
+def decom_packets(
+    packet_file: Union[str, Path],
+) -> tuple[list[Any], dict[int, Dataset]]:
     """
     Decom IDEX data packets using IDEX packet definition.
 
@@ -20,12 +25,21 @@ def decom_packets(packet_file: Union[str, Path]) -> list:
 
     Returns
     -------
-    list
-        All the unpacked data.
+    Tuple[list, dict]
+        Returns a list of all unpacked science data and a dictionary of datasets
+        indexed by their APIDs.
+
+    Notes
+    -----
+    The function 'packet_file_to_dataset' does not work with IDEX science packets due to
+    branching logic within the science xml file. The science data and housekeeping data
+    will be decommed separately and both returned from this function.
     """
-    xtce_filename = "idex_packet_definition.xml"
-    xtce_file = f"{imap_module_directory}/idex/packet_definitions/{xtce_filename}"
+    xtce_base_path = f"{imap_module_directory}/idex/packet_definitions"
+    science_xtce_file = f"{xtce_base_path}/idex_science_packet_definition.xml"
+    hk_xtce_file = f"{xtce_base_path}/idex_housekeeping_packet_definition.xml"
 
-    decom_packet_list = decom.decom_packets(packet_file, xtce_file)
+    science_decom_packet_list = decom.decom_packets(packet_file, science_xtce_file)
+    datasets_by_apid = packet_file_to_datasets(packet_file, hk_xtce_file)
 
-    return list(decom_packet_list)
+    return list(science_decom_packet_list), datasets_by_apid

imap_processing/idex/idex_l1a.py

@@ -10,7 +10,7 @@ Examples
     from imap_processing.idex.idex_l1a import PacketParser
 
     l0_file = "imap_processing/tests/idex/imap_idex_l0_sci_20231214_v001.pkts"
-    l1a_data = PacketParser(l0_file, data_version)
+    l1a_data = PacketParser(l0_file)
     l1a_data.write_l1a_cdf()
 """
 
@@ -26,6 +26,7 @@ import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.idex.decode import rice_decode
+from imap_processing.idex.idex_constants import IDEXAPID
 from imap_processing.idex.idex_l0 import decom_packets
 from imap_processing.spice.time import met_to_ttj2000ns
 from imap_processing.utils import convert_to_binary_string
@@ -57,11 +58,9 @@ class PacketParser:
     ----------
     packet_file : str
         The path and filename to the L0 file to read.
-    data_version : str
-        The version of the data product being created.
     """
 
-    def __init__(self, packet_file: Union[str, Path], data_version: str) -> None:
+    def __init__(self, packet_file: Union[str, Path]) -> None:
         """
         Read a L0 pkts file and perform all of the decom work.
 
@@ -69,23 +68,62 @@ class PacketParser:
         ----------
         packet_file : pathlib.Path | str
           The path and filename to the L0 file to read.
-        data_version : str
-            The version of the data product being created.
 
         Notes
         -----
             Currently assumes one L0 file will generate exactly one L1a file.
         """
-        decom_packet_list = decom_packets(packet_file)
+        self.data = []
+        self.idex_attrs = get_idex_attrs()
+        epoch_attrs = self.idex_attrs.get_variable_attributes(
+            "epoch", check_schema=False
+        )
+
+        science_packets, datset_by_apid = decom_packets(packet_file)
+
+        if science_packets:
+            logger.info("Processing IDEX L1A Science data.")
+            self.data.append(self._create_science_dataset(science_packets))
+
+        if IDEXAPID.IDEX_EVT in datset_by_apid:
+            logger.info("Processing IDEX L1A Event Message data.")
+            data = datset_by_apid[IDEXAPID.IDEX_EVT]
+            data.attrs = self.idex_attrs.get_global_attributes("imap_idex_l1a_evt")
+            data["epoch"].attrs = epoch_attrs
+            self.data.append(data)
+
+        if IDEXAPID.IDEX_CATLST in datset_by_apid:
+            logger.info("Processing IDEX L1A Catalog List Summary data.")
+            data = datset_by_apid[IDEXAPID.IDEX_CATLST]
+            data.attrs = self.idex_attrs.get_global_attributes("imap_idex_l1a_catlst")
+            data["epoch"].attrs = epoch_attrs
+            self.data.append(data)
+
+        logger.info("IDEX L1A data processing completed.")
+
+    def _create_science_dataset(self, science_decom_packet_list: list) -> xr.Dataset:
+        """
+        Process IDEX science packets into an xarray Dataset.
+
+        Parameters
+        ----------
+        science_decom_packet_list : list
+            List of decommutated science packets.
+
+        Returns
+        -------
+        xarray.Dataset
+            Dataset containing processed dust events.
+        """
         dust_events = {}
-        for packet in decom_packet_list:
+        for packet in science_decom_packet_list:
             if "IDX__SCI0TYPE" in packet:
                 scitype = packet["IDX__SCI0TYPE"]
                 event_number = packet["IDX__SCI0EVTNUM"]
                 if scitype == Scitype.FIRST_PACKET:
                     # Initial packet for new dust event
                     # Further packets will fill in data
-                    dust_events[event_number] = RawDustEvent(packet, data_version)
+                    dust_events[event_number] = RawDustEvent(packet)
                 elif event_number not in dust_events:
                     raise KeyError(
                         f"Have not receive header information from event number\
@@ -101,40 +139,43 @@ class PacketParser:
             dust_event.process() for dust_event in dust_events.values()
         ]
 
-        self.data = xr.concat(processed_dust_impact_list, dim="epoch")
-        idex_attrs = get_idex_attrs(data_version)
-        self.data.attrs = idex_attrs.get_global_attributes("imap_idex_l1a_sci")
+        data = xr.concat(processed_dust_impact_list, dim="epoch")
+        data.attrs = self.idex_attrs.get_global_attributes("imap_idex_l1a_sci")
 
         # Add high and low sample rate coords
-        self.data["time_low_sample_rate_index"] = xr.DataArray(
-            np.arange(len(self.data["time_low_sample_rate"][0])),
+        data["time_low_sample_rate_index"] = xr.DataArray(
+            np.arange(len(data["time_low_sample_rate"][0])),
             name="time_low_sample_rate_index",
             dims=["time_low_sample_rate_index"],
-            attrs=idex_attrs.get_variable_attributes("time_low_sample_rate_index"),
+            attrs=self.idex_attrs.get_variable_attributes("time_low_sample_rate_index"),
         )
 
-        self.data["time_high_sample_rate_index"] = xr.DataArray(
-            np.arange(len(self.data["time_high_sample_rate"][0])),
+        data["time_high_sample_rate_index"] = xr.DataArray(
+            np.arange(len(data["time_high_sample_rate"][0])),
             name="time_high_sample_rate_index",
             dims=["time_high_sample_rate_index"],
-            attrs=idex_attrs.get_variable_attributes("time_high_sample_rate_index"),
+            attrs=self.idex_attrs.get_variable_attributes(
+                "time_high_sample_rate_index"
+            ),
         )
         # NOTE: LABL_PTR_1 should be CDF_CHAR.
-        self.data["time_low_sample_rate_label"] = xr.DataArray(
-            self.data.time_low_sample_rate_index.values.astype(str),
+        data["time_low_sample_rate_label"] = xr.DataArray(
+            data.time_low_sample_rate_index.values.astype(str),
             name="time_low_sample_rate_label",
             dims=["time_low_sample_rate_index"],
-            attrs=idex_attrs.get_variable_attributes("time_low_sample_rate_label"),
+            attrs=self.idex_attrs.get_variable_attributes("time_low_sample_rate_label"),
         )
 
-        self.data["time_high_sample_rate_label"] = xr.DataArray(
-            self.data.time_high_sample_rate_index.values.astype(str),
+        data["time_high_sample_rate_label"] = xr.DataArray(
+            data.time_high_sample_rate_index.values.astype(str),
             name="time_high_sample_rate_label",
             dims=["time_high_sample_rate_index"],
-            attrs=idex_attrs.get_variable_attributes("time_high_sample_rate_label"),
+            attrs=self.idex_attrs.get_variable_attributes(
+                "time_high_sample_rate_label"
+            ),
         )
 
-        logger.info("IDEX L1A science data processing completed.")
+        return data
 
 
 def _read_waveform_bits(waveform_raw: str, high_sample: bool = True) -> list[int]:
@@ -162,10 +203,10 @@ def _read_waveform_bits(waveform_raw: str, high_sample: bool = True) -> list[int
 
     Returns
     -------
-    ints : list
+    ints : list[int]
         List of the waveform.
     """
-    ints = []
+    ints: list[int] = []
     if high_sample:
         for i in range(0, len(waveform_raw), 32):
             # 32-bit chunks, divided up into 2, 10, 10, 10
@@ -198,8 +239,6 @@ class RawDustEvent:
     ----------
     header_packet : space_packet_parser.packets.CCSDSPacket
         The FPGA metadata event header.
-    data_version : str
-        The version of the data product being created.
 
     Attributes
     ----------
@@ -252,9 +291,7 @@ class RawDustEvent:
     MAX_HIGH_BLOCKS = 16
     MAX_LOW_BLOCKS = 64
 
-    def __init__(
-        self, header_packet: space_packet_parser.packets.CCSDSPacket, data_version: str
-    ) -> None:
+    def __init__(self, header_packet: space_packet_parser.packets.CCSDSPacket) -> None:
         """
         Initialize a raw dust event, with an FPGA Header Packet from IDEX.
 
@@ -268,8 +305,6 @@ class RawDustEvent:
         ----------
         header_packet : space_packet_parser.packets.CCSDSPacket
             The FPGA metadata event header.
-        data_version : str
-            Data version for CDF filename, in the format ``vXXX``.
         """
         # Calculate the impact time in seconds since epoch
         self.impact_time = 0
@@ -301,7 +336,7 @@ class RawDustEvent:
         self.Ion_Grid_bits = ""
 
         self.compressed = self.telemetry_items["idx__sci0comp"]
-        self.cdf_attrs = get_idex_attrs(data_version)
+        self.cdf_attrs = get_idex_attrs()
 
     def _append_raw_data(self, scitype: Scitype, bits: str) -> None:
         """
@@ -398,6 +433,7 @@ class RawDustEvent:
         # To extract the high gain bits, the bitwise right shift (>> 20) moves the bits
         # 20 positions to the right, and the mask (0b1111111111) keeps only the least
         # significant 10 bits.
+        # TODO use the delay corresponding to the trigger
         high_gain_delay = (packet["IDX__TXHDRSAMPDELAY"] >> 22) & 0b1111111111
         n_blocks = packet["IDX__TXHDRBLOCKS"]
 
@@ -410,22 +446,20 @@ class RawDustEvent:
         # Bits 13-16 represent the number of high sampling pre-trigger blocks.
         #   We can extract this by shifting right by 16 bits and applying a mask to keep
         #   the last 4 bits.
-
         num_low_sample_pretrigger_blocks = (n_blocks >> 6) & 0b111111
         num_high_sample_pretrigger_blocks = (n_blocks >> 16) & 0b1111
-
         # Calculate the low and high sample trigger times based on the high gain delay
         # and the number of high sample/low sample pretrigger blocks
         self.low_sample_trigger_time = (
             self.LOW_SAMPLE_RATE
             * (num_low_sample_pretrigger_blocks + 1)
             * self.NUMBER_SAMPLES_PER_LOW_SAMPLE_BLOCK
-            - self.HIGH_SAMPLE_RATE * high_gain_delay
         )
         self.high_sample_trigger_time = (
             self.HIGH_SAMPLE_RATE
             * (num_high_sample_pretrigger_blocks + 1)
             * self.NUMBER_SAMPLES_PER_HIGH_SAMPLE_BLOCK
+            - self.HIGH_SAMPLE_RATE * high_gain_delay
         )
 
     def _parse_high_sample_waveform(self, waveform_raw: str) -> list[int]:
@@ -442,15 +476,16 @@ class RawDustEvent:
 
         Returns
         -------
-        ints : list
+        ints : list[int]
             List of the high sample waveform.
         """
         samples = self.MAX_HIGH_BLOCKS * self.NUMBER_SAMPLES_PER_HIGH_SAMPLE_BLOCK
+        ints: list[int] = []
         if self.compressed.raw_value == 1:
-            ints = rice_decode(waveform_raw, nbit10=True, sample_count=samples)
+            ints.extend(rice_decode(waveform_raw, nbit10=True, sample_count=samples))
             ints = ints[:-3]
         else:
-            ints = _read_waveform_bits(waveform_raw, high_sample=True)
+            ints.extend(_read_waveform_bits(waveform_raw, high_sample=True))
         return ints
 
     def _parse_low_sample_waveform(self, waveform_raw: str) -> list[int]:
@@ -467,14 +502,15 @@ class RawDustEvent:
 
         Returns
         -------
-        ints : list
+        ints : list[int]
             List of processed low sample waveform.
         """
         samples = self.MAX_LOW_BLOCKS * self.NUMBER_SAMPLES_PER_LOW_SAMPLE_BLOCK
+        ints: list[int] = []
         if self.compressed.raw_value == 1:
-            ints = rice_decode(waveform_raw, nbit10=False, sample_count=samples)
+            ints.extend(rice_decode(waveform_raw, nbit10=False, sample_count=samples))
         else:
-            ints = _read_waveform_bits(waveform_raw, high_sample=False)
+            ints.extend(_read_waveform_bits(waveform_raw, high_sample=False))
         return ints
 
     def _calc_low_sample_resolution(self, num_samples: int) -> npt.NDArray:
@@ -652,15 +688,10 @@ class RawDustEvent:
         return dataset
 
 
-def get_idex_attrs(data_version: str) -> ImapCdfAttributes:
+def get_idex_attrs() -> ImapCdfAttributes:
     """
     Load in CDF attributes for IDEX instrument.
 
-    Parameters
-    ----------
-    data_version : str
-        Data version for CDF filename, in the format "vXXX".
-
     Returns
     -------
     idex_attrs : ImapCdfAttributes
@@ -669,5 +700,4 @@ def get_idex_attrs(data_version: str) -> ImapCdfAttributes:
     idex_attrs = ImapCdfAttributes()
     idex_attrs.add_instrument_global_attrs("idex")
     idex_attrs.add_instrument_variable_attrs("idex", "l1a")
-    idex_attrs.add_global_attribute("Data_version", data_version)
     return idex_attrs