legend-daq2lh5 1.6.1__tar.gz → 1.6.3__tar.gz

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: legend-daq2lh5
-Version: 1.6.1
+Version: 1.6.3
 Summary: Convert digitizer data to LH5
 Author-email: Jason Detwiler <jasondet@uw.edu>
 Maintainer: The LEGEND collaboration
@@ -23,7 +23,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dspeed>=1.3
-Requires-Dist: fcio>=0.7.8
+Requires-Dist: fcio>=0.7.9
 Requires-Dist: h5py>=3.2.0
 Requires-Dist: hdf5plugin
 Requires-Dist: legend-pydataobj>=1.6

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/pyproject.toml

@@ -32,7 +32,7 @@ classifiers = [
 requires-python = ">=3.9"
 dependencies = [
     "dspeed>=1.3",
-    "fcio>=0.7.8",
+    "fcio>=0.7.9",
     "h5py>=3.2.0",
     "hdf5plugin",
     "legend-pydataobj>=1.6",

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/src/daq2lh5/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.6.1'
-__version_tuple__ = version_tuple = (1, 6, 1)
+__version__ = version = '1.6.3'
+__version_tuple__ = version_tuple = (1, 6, 3)

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/src/daq2lh5/cli.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import sys
 
@@ -78,6 +79,13 @@ def daq2lh5_cli():
     parser.add_argument(
         "--overwrite", "-w", action="store_true", help="""Overwrite output files"""
     )
+    parser.add_argument(
+        "--kwargs",
+        "-k",
+        type=str,
+        default="{}",
+        help="""Any additional kwargs to pass to build_raw, will be parsed as a JSON string""",
+    )
 
     args = parser.parse_args()
 
@@ -92,6 +100,9 @@ def daq2lh5_cli():
         print(__version__)  # noqa: T201
         sys.exit()
 
+    if args.kwargs:
+        kwargs = json.loads(args.kwargs)
+
     for stream in args.in_stream:
         basename = os.path.splitext(os.path.basename(stream))[0]
         build_raw(
@@ -102,4 +113,5 @@ def daq2lh5_cli():
             n_max=args.max_rows,
             overwrite=args.overwrite,
             orig_basename=basename,
+            **kwargs,
         )

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/src/daq2lh5/compass/compass_event_decoder.py

@@ -25,8 +25,10 @@ compass_decoded_values = {
     "channel": {"dtype": "uint32"},
     # Timestamp of event
     "timestamp": {"dtype": "float64", "units": "ps"},
-    # Energy of event
+    # Energy of event in channels
     "energy": {"dtype": "uint32"},
+    # Energy of event, calibrated
+    "energy_calibrated": {"dtype": "float64"},
     # Energy short of event
     "energy_short": {"dtype": "uint32"},
     # Flags that the digitizer raised
@@ -153,50 +155,56 @@ class CompassEventDecoder(DataDecoder):
         # the time stamp also does not care about if we have an energy short present
         tbl["timestamp"].nda[ii] = np.frombuffer(packet[4:12], dtype=np.uint64)[0]
 
-        # get the rest of the values depending on if there is an energy_short present
-        if int(header["energy_short"].value) == 1:  # again, the header is a struct
+        # stumble our way through the energy, depending on what the header says
+        bytes_read = 12
+        if int(header["energy_channels"].value) == 1:
             tbl["energy"].nda[ii] = np.frombuffer(packet[12:14], dtype=np.uint16)[0]
-            tbl["energy_short"].nda[ii] = np.frombuffer(packet[14:16], dtype=np.uint16)[
-                0
-            ]
-            tbl["flags"].nda[ii] = np.frombuffer(packet[16:20], np.uint32)[0]
-            tbl["num_samples"].nda[ii] = np.frombuffer(packet[21:25], dtype=np.uint32)[
-                0
-            ]
-
-            if (
-                tbl["num_samples"].nda[ii]
-                != self.decoded_values[bc]["waveform"]["wf_len"]
-            ):  # make sure that the waveform we read in is the same length as in the config
-                raise RuntimeError(
-                    f"Waveform size {tbl['num_samples'].nda[ii]} doesn't match expected size {self.decoded_values[bc]['waveform']['wf_len']}. "
-                    "Skipping packet"
-                )
-
-            tbl["waveform"]["values"].nda[ii] = np.frombuffer(
-                packet[25:], dtype=np.uint16
-            )
-
+            bytes_read += 2
+            if int(header["energy_calibrated"].value) == 1:
+                tbl["energy_calibrated"].nda[ii] = None
+        elif (int(header["energy_calibrated"].value) == 1) and (
+            int(header["energy_channels"].value) == 0
+        ):
+            tbl["energy_calibrated"].nda[ii] = np.frombuffer(
+                packet[14:22], dtype=np.float64
+            )[0]
+            bytes_read += 8
+            tbl["energy"].nda[ii] = None
         else:
-            tbl["energy"].nda[ii] = np.frombuffer(packet[12:14], dtype=np.uint16)[0]
-            tbl["energy_short"].nda[ii] = None
-            tbl["flags"].nda[ii] = np.frombuffer(packet[14:18], np.uint32)[0]
-            tbl["num_samples"].nda[ii] = np.frombuffer(packet[19:23], dtype=np.uint32)[
-                0
-            ]
-
-            if (
-                tbl["num_samples"].nda[ii]
-                != self.decoded_values[bc]["waveform"]["wf_len"]
-            ):  # make sure that the waveform we read in is the same length as in the config
-                raise RuntimeError(
-                    f"Waveform size {tbl['num_samples'].nda[ii]} doesn't match expected size {self.decoded_values[bc]['waveform']['wf_len']}. "
-                    "Skipping packet"
-                )
-
-            tbl["waveform"]["values"].nda[ii] = np.frombuffer(
-                packet[23:], dtype=np.uint16
+            tbl["energy_calibrated"].nda[ii] = np.frombuffer(
+                packet[12:20], dtype=np.float64
+            )[0]
+            bytes_read += 8
+
+        # now handle the energy short
+        if int(header["energy_short"].value) == 1:
+            tbl["energy_short"].nda[ii] = np.frombuffer(
+                packet[bytes_read : bytes_read + 2], dtype=np.uint16
+            )[0]
+            bytes_read += 2
+        else:
+            tbl["energy_short"].nda[ii] = 0
+
+        tbl["flags"].nda[ii] = np.frombuffer(
+            packet[bytes_read : bytes_read + 4], np.uint32
+        )[0]
+        bytes_read += 5  # skip over the waveform code
+        tbl["num_samples"].nda[ii] = np.frombuffer(
+            packet[bytes_read : bytes_read + 4], dtype=np.uint32
+        )[0]
+        bytes_read += 4
+
+        if (
+            tbl["num_samples"].nda[ii] != self.decoded_values[bc]["waveform"]["wf_len"]
+        ):  # make sure that the waveform we read in is the same length as in the config
+            raise RuntimeError(
+                f"Waveform size {tbl['num_samples'].nda[ii]} doesn't match expected size {self.decoded_values[bc]['waveform']['wf_len']}. "
+                "Skipping packet"
             )
 
+        tbl["waveform"]["values"].nda[ii] = np.frombuffer(
+            packet[bytes_read:], dtype=np.uint16
+        )
+
         evt_rbkd[bc].loc += 1
         return evt_rbkd[bc].is_full()

legend_daq2lh5-1.6.3/src/daq2lh5/compass/compass_header_decoder.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import logging
+
+import lgdo
+import numpy as np
+
+from ..data_decoder import DataDecoder
+from .compass_config_parser import compass_config_to_struct
+
+log = logging.getLogger(__name__)
+
+
+class CompassHeaderDecoder(DataDecoder):
+    """
+    Decode CoMPASS header data. Also, read in CoMPASS config data if provided using the compass_config_parser
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.config = None  # initialize to none, because compass_config_to_struct always returns a struct
+
+    def decode_header(self, in_stream: bytes, config_file: str = None) -> dict:
+        """Decode the CoMPASS file header, and add CoMPASS config data to the header, if present.
+
+        Parameters
+        ----------
+        in_stream
+            The stream of data to have its header decoded
+        config_file
+            The config file for the CoMPASS data, if present
+
+        Returns
+        -------
+        config
+            A dict containing the header information, as well as the important config information
+            of wf_len and num_enabled_channels
+        """
+        wf_len = None
+        config_names = [
+            "energy_channels",  # energy is given in channels (0: false, 1: true)
+            "energy_calibrated",  # energy is given in keV/MeV, according to the calibration (0: false, 1: true)
+            "energy_short",  # energy short is present (0: false, 1: true)
+            "waveform_samples",  # waveform samples are present (0: false, 1: true)
+            "header_present",  # there is a 2 byte header present in the file (0: false, 1: true)
+        ]  # need to determine which of these are present in a file
+
+        # First need to check if the first two bytes are of the form 0xCAEx
+        # CoMPASS specs say that every file should start with this header, but if CoMPASS writes size-limited files, then this header may not be present in *all* files...
+        header_in_bytes = in_stream.read(2)
+
+        if header_in_bytes[-1] == int.from_bytes(b"\xca", byteorder="big"):
+            log.debug("header is present in file.")
+            header_in_binary = bin(int.from_bytes(header_in_bytes, byteorder="little"))
+            header_as_list = str(header_in_binary)[
+                ::-1
+            ]  # reverse it as we care about bit 0, bit 1, etc.
+            header_dict = dict(
+                {
+                    "energy_channels": int(header_as_list[0]) == 1,
+                    "energy_calibrated": int(header_as_list[1]) == 1,
+                    "energy_channels_calibrated": int(header_as_list[0])
+                    == 1 & int(header_as_list[1])
+                    == 1,
+                    "energy_short": int(header_as_list[2]) == 1,
+                    "waveform_samples": int(header_as_list[3]) == 1,
+                    "header_present": True,
+                }
+            )
+
+            # if we don't have the wf_len, get it now
+
+            if config_file is None:
+                if header_dict["waveform_samples"] == 0:
+                    wf_len = 0
+                else:
+                    wf_byte_len = 4
+                    bytes_to_read = (
+                        12  # covers 2-byte board, 2-byte channel, 8-byte time stamp
+                    )
+                    bytes_to_read += (
+                        2 * header_dict["energy_channels"]
+                        + 8 * header_dict["energy_calibrated"]
+                        + 2 * header_dict["energy_short"]
+                    )
+                    bytes_to_read += 4 + 1  # 4-byte flags, 1-byte waveform code
+                    first_bytes = in_stream.read(bytes_to_read + wf_byte_len)
+
+                    wf_len = np.frombuffer(
+                        first_bytes[bytes_to_read : bytes_to_read + wf_byte_len],
+                        dtype=np.uint32,
+                    )[0]
+
+        # if header is not present, we need to play some tricks
+        # either energy short is present or not
+        # and one of three options for energy (ADC, calibrated, both)
+        else:
+            # If the 2 byte header is not present, then we have read in the board by accident
+            header_in_bytes += in_stream.read(
+                10
+            )  # read in the 2-byte ch and 8-byte timestamp
+            bytes_read = 12
+            fixed_header_start_len = (
+                12  # always 12 bytes: 2-byte board, 2-byte channel, 8-byte timestamp
+            )
+            possible_energy_header_byte_lengths = [
+                2,
+                8,
+                10,
+            ]  # either ADC, Calibrated, or both
+            possible_energy_short_header_byte_lengths = [
+                0,
+                2,
+            ]  # energy short is present or not
+            fixed_header_part = 5  # 5 bytes from flags + code
+            wf_len_bytes = 4  # wf_len is 4 bytes long
+
+            for prefix in possible_energy_header_byte_lengths:
+                terminate = False
+                for suffix in possible_energy_short_header_byte_lengths:
+
+                    # ---- first packet -------
+                    # don't read more than we have to, check how many more bytes we need to read in
+                    difference = (
+                        fixed_header_start_len
+                        + prefix
+                        + suffix
+                        + fixed_header_part
+                        + wf_len_bytes
+                        - bytes_read
+                    )
+                    if difference > 0:
+                        # just read a bit more data
+                        header_in_bytes += in_stream.read(difference)
+                        bytes_read += difference
+
+                    wf_len_guess = np.frombuffer(
+                        header_in_bytes[
+                            fixed_header_start_len
+                            + prefix
+                            + suffix
+                            + fixed_header_part : fixed_header_start_len
+                            + prefix
+                            + suffix
+                            + fixed_header_part
+                            + wf_len_bytes
+                        ],
+                        dtype=np.uint32,
+                    )[0]
+
+                    # read in the first waveform data
+                    difference = (
+                        fixed_header_start_len
+                        + prefix
+                        + suffix
+                        + fixed_header_part
+                        + wf_len_bytes
+                        + 2 * wf_len_guess
+                        - bytes_read
+                    )
+                    if difference > 0:
+                        header_in_bytes += in_stream.read(2 * wf_len_guess)
+                        bytes_read += 2 * wf_len_guess
+
+                    # ------ second packet header ----------
+                    difference = (
+                        2
+                        * (
+                            fixed_header_start_len
+                            + prefix
+                            + suffix
+                            + fixed_header_part
+                            + wf_len_bytes
+                        )
+                        + 2 * wf_len_guess
+                        - bytes_read
+                    )
+                    if difference > 0:
+                        header_in_bytes += in_stream.read(difference)
+                        bytes_read += (
+                            fixed_header_start_len
+                            + prefix
+                            + suffix
+                            + fixed_header_part
+                            + wf_len_bytes
+                        )
+                    wf_len_guess_2 = np.frombuffer(
+                        header_in_bytes[
+                            2
+                            * (
+                                fixed_header_start_len
+                                + prefix
+                                + suffix
+                                + fixed_header_part
+                            )
+                            + wf_len_bytes
+                            + 2
+                            * wf_len_guess : 2
+                            * (
+                                fixed_header_start_len
+                                + prefix
+                                + suffix
+                                + fixed_header_part
+                                + wf_len_bytes
+                            )
+                            + 2 * wf_len_guess
+                        ],
+                        dtype=np.uint32,
+                    )[0]
+
+                    # if the waveform lengths agree, then we can stride packets correctly
+                    if wf_len_guess_2 == wf_len_guess:
+                        header_dict = dict(
+                            {
+                                "energy_channels": prefix == 2,
+                                "energy_calibrated": prefix == 8,
+                                "energy_channels_calibrated": prefix == 10,
+                                "energy_short": suffix == 2,
+                                "waveform_samples": wf_len != 0,
+                                "header_present": False,
+                            }
+                        )
+                        wf_len = wf_len_guess
+                        terminate = True
+                        break
+                if terminate:
+                    break
+
+        self.config = compass_config_to_struct(config_file, wf_len)
+
+        for name in config_names:
+            if name in self.config:
+                log.warning(f"{name} already in self.config. skipping...")
+                continue
+            value = int(header_dict[name])
+            self.config.add_field(
+                str(name), lgdo.Scalar(value)
+            )  # self.config is a struct
+
+        return self.config
+
+    def make_lgdo(self, key: int = None, size: int = None) -> lgdo.Struct:
+        if self.config is None:
+            raise RuntimeError(
+                "self.config still None, need to decode header before calling make_lgdo"
+            )
+        return self.config  # self.config is already an lgdo, namely it is a struct

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/src/daq2lh5/compass/compass_streamer.py

@@ -72,22 +72,6 @@ class CompassStreamer(DataStreamer):
         So, we must read this header once, and then proceed to read packets in.
         """
         # If a config file is not present, the wf_len can be determined by opening the first few bytes of the in_stream
-        wf_len = None
-        if self.compass_config_file is None:
-            self.set_in_stream(stream_name)
-
-            first_bytes = self.in_stream.read(27)
-
-            energy_short = str(
-                bin(int.from_bytes(first_bytes[:2], byteorder="little"))
-            )[::-1][2]
-
-            if int(energy_short) == 1:
-                [wf_len] = np.frombuffer(first_bytes[23:27], dtype=np.uint32)
-            else:
-                [wf_len] = np.frombuffer(first_bytes[21:25], dtype=np.uint32)
-
-            self.close_stream()
 
         # set the in_stream
         self.set_in_stream(stream_name)
@@ -95,11 +79,20 @@ class CompassStreamer(DataStreamer):
 
         # read in and decode the file header info, passing the compass_config_file, if present
         self.header = self.header_decoder.decode_header(
-            self.in_stream, self.compass_config_file, wf_len
+            self.in_stream, self.compass_config_file
         )  # returns an lgdo.Struct
-        self.n_bytes_read += (
-            2  # there are 2 bytes in the header, for a 16 bit number to read out
-        )
+        self.close_stream()
+
+        # Now we are ready to read the data
+        self.set_in_stream(stream_name)
+        self.n_bytes_read = 0
+
+        if int(self.header["header_present"].value) == 1:
+            # read 2 bytes if we need to
+            self.in_stream.read(2)
+            self.n_bytes_read += (
+                2  # there are 2 bytes in the header, for a 16 bit number to read out
+            )
 
         # set up data loop variables
         self.packet_id = 0
@@ -171,16 +164,34 @@ class CompassStreamer(DataStreamer):
         if self.in_stream is None:
             raise RuntimeError("self.in_stream is None")
 
-        if (self.packet_id == 0) and (self.n_bytes_read != 2):
+        if (
+            (self.packet_id == 0)
+            and (self.n_bytes_read != 2)
+            and (int(self.header["header_present"].value) == 1)
+        ):
             raise RuntimeError(
                 f"The 2 byte filer header was not converted, instead read in {self.n_bytes_read} for the file header"
             )
+        if (
+            (self.packet_id == 0)
+            and (self.n_bytes_read != 0)
+            and (int(self.header["header_present"].value) == 0)
+        ):
+            raise RuntimeError(
+                f"The header was not converted, instead read in {self.n_bytes_read} for the file header"
+            )
 
-        # packets have metadata of variable lengths, depending on if the header shows that energy_short is present in the metadata
+        # packets have metadata of variable lengths, depending on what the header shows
+        header_length = 12  # header always starts with 2-bytes of board, 2-bytes of channel, and 8-bytes of timestamp
+        if int(self.header["energy_channels"].value) == 1:
+            header_length += 2  # if the energy is recorded in ADC channels, then there are an extra 2 bytes in the metadata
+        if int(self.header["energy_calibrated"].value) == 1:
+            header_length += 8  # if the energy is recorded in keV/MeV, then there are an extra 8 bytes in the metadata
         if int(self.header["energy_short"].value) == 1:
-            header_length = 25  # if the energy short is present, then there are an extra 2 bytes in the metadata
-        else:
-            header_length = 23  # the normal packet metadata is 23 bytes long
+            header_length += 2  # if the energy short is present, then there are an extra 2 bytes in the metadata
+        header_length += (
+            4 + 1 + 4
+        )  # the flags, the waveform code bytes, and the waveform length
 
         # read the packet's metadata into the buffer
         pkt_hdr = self.buffer[:header_length]
@@ -190,16 +201,11 @@ class CompassStreamer(DataStreamer):
         # return None once we run out of file
         if n_bytes_read == 0:
             return None
-        if (n_bytes_read != 25) and (n_bytes_read != 23):
+        if n_bytes_read not in [23, 25, 29, 31, 33]:
             raise RuntimeError(f"only got {n_bytes_read} bytes for packet header")
 
-        # get the waveform length so we can read in the rest of the packet
-        if n_bytes_read == 25:
-            [num_samples] = np.frombuffer(pkt_hdr[21:25], dtype=np.uint32)
-            pkt_length = header_length + 2 * num_samples
-        if n_bytes_read == 23:
-            [num_samples] = np.frombuffer(pkt_hdr[19:23], dtype=np.uint32)
-            pkt_length = header_length + 2 * num_samples
+        [num_samples] = np.frombuffer(pkt_hdr[-4:], dtype=np.uint32)
+        pkt_length = header_length + 2 * num_samples
 
         # load into buffer, resizing as necessary
         if len(self.buffer) < pkt_length:

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/src/daq2lh5/fc/fc_config_decoder.py

@@ -66,6 +66,7 @@ class FCConfigDecoder(DataDecoder):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.decoded_values = copy.deepcopy(fc_config_decoded_values)
+        self.key_list = []
 
     def decode_packet(
         self,
@@ -126,7 +127,12 @@ class FCConfigDecoder(DataDecoder):
         ntraces = fcio.config.adcs + fcio.config.triggers
         tbl.add_field("tracemap", lgdo.Array(fcio.config.tracemap[:ntraces]))
 
+        self.key_list.append(f"fcid_{fcio.config.streamid & 0xFFFF}/config")
+
         return tbl
 
+    def get_key_lists(self) -> list[list[int | str]]:
+        return [copy.deepcopy(self.key_list)]
+
     def get_decoded_values(self, key: int | str = None) -> dict[str, dict[str, Any]]:
         return self.decoded_values

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/src/daq2lh5/fc/fc_event_decoder.py

@@ -152,24 +152,41 @@ class FCEventDecoder(DataDecoder):
             tbl["board_id"].nda[loc] = fcio.event.card_address[ii]
             tbl["fc_input"].nda[loc] = fcio.event.card_channel[ii]
             tbl["event_type"].nda[loc] = fcio.event.type
-            tbl["eventnumber"].nda[loc] = fcio.event.timestamp[0]
             tbl["numtraces"].nda[loc] = fcio.event.num_traces
-            tbl["ts_pps"].nda[loc] = fcio.event.timestamp[1]
-            tbl["ts_ticks"].nda[loc] = fcio.event.timestamp[2]
-            tbl["ts_maxticks"].nda[loc] = fcio.event.timestamp[3]
-            tbl["mu_offset_sec"].nda[loc] = fcio.event.timeoffset[0]
-            tbl["mu_offset_usec"].nda[loc] = fcio.event.timeoffset[1]
-            tbl["to_master_sec"].nda[loc] = fcio.event.timeoffset[2]
-            tbl["delta_mu_usec"].nda[loc] = fcio.event.timeoffset[3]
-            tbl["abs_delta_mu_usec"].nda[loc] = fcio.event.timeoffset[4]
-            tbl["to_start_sec"].nda[loc] = fcio.event.timeoffset[5]
-            tbl["to_start_usec"].nda[loc] = fcio.event.timeoffset[6]
-            tbl["dr_start_pps"].nda[loc] = fcio.event.deadregion[0]
-            tbl["dr_start_ticks"].nda[loc] = fcio.event.deadregion[1]
-            tbl["dr_stop_pps"].nda[loc] = fcio.event.deadregion[2]
-            tbl["dr_stop_ticks"].nda[loc] = fcio.event.deadregion[3]
-            tbl["dr_maxticks"].nda[loc] = fcio.event.deadregion[4]
-            # if event_type == 11: provides the same check
+
+            # the order of names is crucial here!
+            timestamp_names = [
+                "eventnumber",
+                "ts_pps",
+                "ts_ticks",
+                "ts_maxticks",
+            ]
+            for name, value in zip(timestamp_names, fcio.event.timestamp):
+                tbl[name].nda[loc] = value
+
+            timeoffset_names = [
+                "mu_offset_sec",
+                "mu_offset_usec",
+                "to_master_sec",
+                "delta_mu_usec",
+                "abs_delta_mu_usec",
+                "to_start_sec",
+                "to_start_usec",
+            ]
+            for name, value in zip(timeoffset_names, fcio.event.timeoffset):
+                tbl[name].nda[loc] = value
+
+            deadregion_names = [
+                "dr_start_pps",
+                "dr_start_ticks",
+                "dr_stop_pps",
+                "dr_stop_ticks",
+                "dr_maxticks",
+            ]
+            for name, value in zip(deadregion_names, fcio.event.deadregion[:5]):
+                tbl[name].nda[loc] = value
+
+            # if event_type == 11: would provide the same check
             # however, the usage of deadregion[5]/[6] must never change
             # and it will always be present if deadregion[7..] is ever used
             if fcio.event.deadregion_size >= 7:
@@ -179,7 +196,7 @@ class FCEventDecoder(DataDecoder):
                 tbl["dr_ch_idx"].nda[loc] = 0
                 tbl["dr_ch_len"].nda[loc] = fcio.config.adcs
 
-            # The following values are calculated values by fcio-py
+            # The following values are calculated by fcio-py, derived from fields above.
             tbl["timestamp"].nda[loc] = fcio.event.unix_time_utc_sec
             tbl["deadinterval_nsec"].nda[loc] = fcio.event.dead_interval_nsec[ii]
             tbl["deadtime"].nda[loc] = fcio.event.dead_time_sec[ii]

{legend_daq2lh5-1.6.1 → legend_daq2lh5-1.6.3}/src/daq2lh5/fc/fc_eventheader_decoder.py

@@ -14,9 +14,12 @@ log = logging.getLogger(__name__)
 
 def get_key(streamid: int, card_address: int, card_input: int, iwf: int = -1) -> int:
     if streamid > 0 or iwf < 0:
-        # For backwards compatibility only the lower 16-bit of the streamid are
-        # used.
-        return (streamid & 0xFFFF) * 1000000 + card_address * 100 + card_input
+        # For backwards compatibility only the lower 16-bit of the streamid are used.
+        return (
+            (int(streamid) & 0xFFFF) * 1000000
+            + int(card_address) * 100
+            + int(card_input)
+        )
     else:
         return iwf
 
@@ -212,7 +215,7 @@ class FCEventHeaderDecoder(DataDecoder):
         self.decoded_values["baseline"]["length_guess"] = n_traces
         self.decoded_values["daqenergy"]["length_guess"] = n_traces
 
-        self.key_list = [get_key(fcio_stream.config.streamid, 0, 0)]
+        self.key_list = [f"fcid_{fcio_stream.config.streamid & 0xFFFF}/evt_hdr"]
 
     def get_key_lists(self) -> list[list[int | str]]:
         return [copy.deepcopy(self.key_list)]
@@ -232,7 +235,7 @@ class FCEventHeaderDecoder(DataDecoder):
     ) -> bool:
 
         # only one key available: this streamid
-        key = get_key(fcio.config.streamid, 0, 0)
+        key = f"fcid_{fcio.config.streamid & 0xFFFF}/evt_hdr"
         if key not in evt_hdr_rbkd:
             return False