legend-daq2lh5 1.6.1__py3-none-any.whl → 1.6.3__py3-none-any.whl

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)

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

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

daq2lh5/compass/compass_header_decoder.py

@@ -3,6 +3,7 @@ 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
@@ -19,9 +20,7 @@ class CompassHeaderDecoder(DataDecoder):
         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, wf_len: int = None
-    ) -> dict:
+    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
@@ -30,8 +29,6 @@ class CompassHeaderDecoder(DataDecoder):
             The stream of data to have its header decoded
         config_file
             The config file for the CoMPASS data, if present
-        wf_len
-            The length of the first waveform in the file, only pre-calculated when the config_file is none
 
         Returns
         -------
@@ -39,27 +36,203 @@ class CompassHeaderDecoder(DataDecoder):
             A dict containing the header information, as well as the important config information
             of wf_len and num_enabled_channels
         """
-        self.config = compass_config_to_struct(config_file, wf_len)
-
+        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_in_bytes = in_stream.read(
-            2
-        )  # we always have to read in the first 2 bytes of the header for CoMPASS v2 files
-        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.
-
-        for i, name in enumerate(config_names):
+            "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_as_list[i])
+            value = int(header_dict[name])
             self.config.add_field(
                 str(name), lgdo.Scalar(value)
             )  # self.config is a struct

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:

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

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]

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
 

daq2lh5/fc/fc_fsp_decoder.py

@@ -8,7 +8,6 @@ import numpy as np
 from fcio import FCIO, Limits
 
 from ..data_decoder import DataDecoder
-from .fc_eventheader_decoder import get_key
 
 fsp_config_decoded_values = {
     "packet_id": {
@@ -183,7 +182,7 @@ class FSPConfigDecoder(DataDecoder):
         self.key_list = []
 
     def set_fcio_stream(self, fcio_stream: FCIO) -> None:
-        self.key_list = [f"fsp_config_{get_key(fcio_stream.config.streamid, 0, 0)}"]
+        self.key_list = [f"swtid_{fcio_stream.config.streamid & 0xFFFF}/config"]
         if fcio_stream.fsp is not None:
             wps_n_traces = fcio_stream.fsp.config.wps["tracemap"]["n_mapped"]
             hwm_n_traces = fcio_stream.fsp.config.hwm["tracemap"]["n_mapped"]
@@ -229,6 +228,9 @@ class FSPConfigDecoder(DataDecoder):
     def get_decoded_values(self, key: int = None) -> dict[str, dict[str, Any]]:
         return self.decoded_values
 
+    def get_key_lists(self) -> list[list[int | str]]:
+        return [copy.deepcopy(self.key_list)]
+
     def decode_packet(
         self,
         fcio: FCIO,
@@ -659,6 +661,9 @@ class FSPConfigDecoder(DataDecoder):
             "dsp_ct_thresholds",
             lgdo.Array(np.array(ct["thresholds"], dtype="uint16")[:ct_n_traces]),
         )
+
+        self.key_list.append(f"swtid_{fcio.config.streamid & 0xFFFF}/config")
+
         return self.fsp_config
 
     def make_lgdo(self, key: int | str = None, size: int = None) -> lgdo.Struct:
@@ -694,7 +699,7 @@ class FSPStatusDecoder(DataDecoder):
         self.key_list = []
 
     def set_fcio_stream(self, fcio_stream: FCIO) -> None:
-        self.key_list = [f"fsp_status_{get_key(fcio_stream.config.streamid, 0, 0)}"]
+        self.key_list = [f"swtid_{fcio_stream.config.streamid & 0xFFFF}/status"]
 
     def get_key_lists(self) -> list[list[int | str]]:
         return [copy.deepcopy(self.key_list)]
@@ -709,7 +714,7 @@ class FSPStatusDecoder(DataDecoder):
         packet_id: int,
     ) -> bool:
 
-        key = f"fsp_status_{get_key(fcio.config.streamid, 0, 0)}"
+        key = f"swtid_{fcio.config.streamid & 0xFFFF}/status"
         if key not in fsp_status_rbkd:
             return False
         fsp_status_rb = fsp_status_rbkd[key]
@@ -796,8 +801,8 @@ class FSPEventDecoder(DataDecoder):
     def set_fcio_stream(self, fcio_stream: FCIO) -> None:
 
         self.key_list = [
-            f"fsp_event_{get_key(fcio_stream.config.streamid, 0, 0)}",
-            f"fsp_eventheader_{get_key(fcio_stream.config.streamid, 0, 0)}",
+            f"swtid_{fcio_stream.config.streamid & 0xFFFF}/event",
+            f"swtid_{fcio_stream.config.streamid & 0xFFFF}/evt_hdr",
         ]
 
     def get_decoded_values(self, key: int = None) -> dict[str, dict[str, Any]]:
@@ -815,9 +820,9 @@ class FSPEventDecoder(DataDecoder):
     ) -> bool:
 
         if is_header:
-            key = f"fsp_eventheader_{get_key(fcio.config.streamid, 0, 0)}"
+            key = f"swtid_{fcio.config.streamid & 0xFFFF}/evt_hdr"
         else:
-            key = f"fsp_event_{get_key(fcio.config.streamid, 0, 0)}"
+            key = f"swtid_{fcio.config.streamid & 0xFFFF}/event"
 
         if key not in fsp_evt_rbkd:
             return False
@@ -877,7 +882,7 @@ class FSPEventDecoder(DataDecoder):
         if lens > 0:
             tbl["obs_ps_hwm_prescaled_trace_idx"].flattened_data.nda[
                 start:end
-            ] = fcio.fsp.event.obs_ps_hwm_prescaled_trace_ix
+            ] = fcio.fsp.event.obs_ps_hwm_prescaled_trace_idx
         tbl["obs_ps_hwm_prescaled_trace_idx"].cumulative_length[loc] = end
 
         fsp_evt_rb.loc += 1

daq2lh5/fc/fc_status_decoder.py

@@ -122,7 +122,7 @@ fc_status_decoded_values = {
 
 
 def get_key(streamid, reqid):
-    return (streamid & 0xFFFF) * 1000000 + (reqid & 0xFFFF)
+    return f"fcid_{streamid & 0xFFFF}/status/card{(reqid & 0xFFFF)}"
 
 
 def get_fcid(key: int) -> int:

daq2lh5/fc/fc_streamer.py

@@ -148,7 +148,8 @@ class FCStreamer(DataStreamer):
                 if len(config_rb_list) != 1:
                     log.warning(
                         f"config_rb_list for {config_decoder} had length {len(config_rb_list)}, "
-                        "ignoring all but the first"
+                        "ignoring all but the first. "
+                        f"{config_rb_list}"
                     )
                 rb = config_rb_list[0]
             else:

daq2lh5/orca/orca_fcio.py

@@ -15,7 +15,7 @@ from daq2lh5.fc.fc_fsp_decoder import (
     FSPStatusDecoder,
 )
 from daq2lh5.fc.fc_status_decoder import FCStatusDecoder
-from daq2lh5.fc.fc_status_decoder import get_key as get_status_key
+from daq2lh5.fc.fc_status_decoder import get_key as get_fc_status_key
 
 from ..raw_buffer import RawBufferList
 from .orca_base import OrcaDecoder
@@ -126,23 +126,30 @@ class ORFCIOConfigDecoder(OrcaDecoder):
     def set_header(self, header: OrcaHeader) -> None:
         self.header = header
         self.fc_hdr_info = extract_header_information(header)
-        self.decoded_values = copy.deepcopy(self.decoder.get_decoded_values())
+        self.decoded_values["fcid"] = copy.deepcopy(self.decoder.get_decoded_values())
 
         for fcid in self.fc_hdr_info["fsp_enabled"]:
-            key = get_key(fcid, 0, 0)
-            self.key_list["fc_config"].append(key)
+            self.key_list["fc_config"].append(f"fcid_{fcid}/config")
             if self.fc_hdr_info["fsp_enabled"][fcid]:
                 self.fsp_decoder = FSPConfigDecoder()
-                self.key_list["fsp_config"].append(f"fsp_config_{key}")
+                self.key_list["fsp_config"].append(f"swtid_{fcid}/config")
+                self.decoded_values["swtid"] = copy.deepcopy(
+                    self.fsp_decoder.get_decoded_values()
+                )
         self.max_rows_in_packet = 1
 
-    def get_key_lists(self) -> list[list[int, str]]:
+    def get_key_lists(self) -> list[list[str]]:
         return list(self.key_list.values())
 
-    def get_decoded_values(self, key: int | str = None) -> dict[str, Any]:
-        if isinstance(key, str) and key.startswith("fsp_config"):
-            return copy.deepcopy(self.fsp_decoder.get_decoded_values())
-        return self.decoded_values
+    def get_decoded_values(self, key: str = None) -> dict[str, Any]:
+        if (
+            isinstance(key, str)
+            and key.startswith("swtid_")
+            and self.fsp_decoder is not None
+        ):
+            return self.decoded_values["swtid"]
+        elif (isinstance(key, str) and key.startswith("fcid_")) or key is None:
+            return self.decoded_values["fcid"]
         raise KeyError(f"no decoded values for key {key}")
 
     def decode_packet(
@@ -159,18 +166,21 @@ class ORFCIOConfigDecoder(OrcaDecoder):
 
         if fcio_stream.config.streamid != packet[2]:
             log.warning(
-                f"The expected stream id {packet[2]} does not match the contained stream id {fcio_stream.config.streamid}"
+                f"The expected stream id {packet[2]} does not match the contained stream id "
+                f"{fcio_stream.config.streamid}"
             )
 
         config_rbkd = rbl.get_keyed_dict()
 
+        fcid = fcio_stream.config.streamid & 0xFFFF
+
         # TODO: the decoders could fetch lgdo's using it's key_list
-        fc_key = get_key(fcio_stream.config.streamid, 0, 0)
+        fc_key = f"fcid_{fcid}/config"
         any_full = self.decoder.decode_packet(
             fcio_stream, config_rbkd[fc_key], packet_id
         )
-        if self.fsp_decoder is not None:
-            fsp_key = f"fsp_config_{get_key(fcio_stream.config.streamid, 0, 0)}"
+        if self.fsp_decoder is not None and self.fc_hdr_info["fsp_enabled"][fcid]:
+            fsp_key = f"swtid_{fcid}/config"
             any_full |= self.fsp_decoder.decode_packet(
                 fcio_stream, config_rbkd[fsp_key], packet_id
             )
@@ -184,7 +194,7 @@ class ORFCIOStatusDecoder(OrcaDecoder):
         self.decoder = FCStatusDecoder()
         self.fsp_decoder = None
         self.decoded_values = {}
-        self.key_list = {"fc_status": [], "fsp_status": []}
+        self.key_list = []
         self.max_rows_in_packet = 0
         super().__init__(header=header, **kwargs)
 
@@ -192,44 +202,43 @@ class ORFCIOStatusDecoder(OrcaDecoder):
         """Setter for headers. Overload to set card parameters, etc."""
         self.header = header
         self.fc_hdr_info = extract_header_information(header)
-        self.decoded_values = copy.deepcopy(self.decoder.get_decoded_values())
 
         for fcid in self.fc_hdr_info["n_card"]:
             # If the data was taken without a master distribution module,
             # i.e. only one ADC Module the decoder will just not write to the buffer.
 
             # MDB key
-            self.key_list["fc_status"] = [get_status_key(fcid, 0)]
+            key_list_fcid = [get_fc_status_key(fcid, 0)]
             # ADC module keys
-            self.key_list["fc_status"] += [
-                get_status_key(fcid, 0x2000 + i)
+            key_list_fcid += [
+                get_fc_status_key(fcid, 0x2000 + i)
                 for i in range(self.fc_hdr_info["n_card"][fcid])
             ]
-
+            self.key_list.append(key_list_fcid)
+            self.decoded_values["fcid"] = copy.deepcopy(
+                self.decoder.get_decoded_values()
+            )
             if self.fc_hdr_info["fsp_enabled"][fcid]:
-                key = get_key(fcid, 0, 0)
-                self.key_list["fsp_status"].append(f"fsp_status_{key}")
                 self.fsp_decoder = FSPStatusDecoder()
+                self.key_list.append([f"swtid_{fcid}/status"])
+                self.decoded_values["swtid"] = copy.deepcopy(
+                    self.fsp_decoder.get_decoded_values()
+                )
         self.max_rows_in_packet = max(self.fc_hdr_info["n_card"].values()) + 1
 
-    def get_key_lists(self) -> list[list[int | str]]:
-        return list(self.key_list.values())
+    def get_key_lists(self) -> list[list[str]]:
+        return copy.deepcopy(self.key_list)
 
-    def get_decoded_values(self, key: int | str = None) -> dict[str, Any]:
-        if key is None:
-            dec_vals_list = list(self.decoded_values)
-            if len(dec_vals_list) > 0:
-                return {dec_vals_list[0]: self.decoded_values[dec_vals_list[0]]}
-            raise RuntimeError("decoded_values not built")
+    def get_decoded_values(self, key: str = None) -> dict[str, Any]:
 
         if (
             isinstance(key, str)
-            and key.startswith("fsp_status")
+            and key.startswith("swtid_")
             and self.fsp_decoder is not None
         ):
-            return copy.deepcopy(self.fsp_decoder.get_decoded_values())
-        elif isinstance(key, int):
-            return copy.deepcopy(self.decoder.get_decoded_values())
+            return self.decoded_values["swtid"]
+        elif (isinstance(key, str) and key.startswith("fcid_")) or key is None:
+            return self.decoded_values["fcid"]
         else:
             raise KeyError(f"no decoded values for key {key}")
 
@@ -245,15 +254,25 @@ class ORFCIOStatusDecoder(OrcaDecoder):
         fcio_stream.set_mem_field(memoryview(packet[3:]))
 
         any_full = False
-        while fcio_stream.get_record():
-            if fcio_stream.tag == Tags.Status:
-                any_full |= self.decoder.decode_packet(
+
+        if not fcio_stream.get_record():
+            raise OSError(
+                f"Missing record in FCIO stream {fcio_stream.config.streamid & 0xFFFF}."
+            )
+
+        if fcio_stream.tag == Tags.FSPStatus:
+            if self.fsp_decoder is not None:
+                any_full |= self.fsp_decoder.decode_packet(
                     fcio_stream, status_rbkd, packet_id
                 )
-                if self.fsp_decoder is not None:
-                    any_full |= self.fsp_decoder.decode_packet(
-                        fcio_stream, status_rbkd, packet_id
-                    )
+
+            if not fcio_stream.get_record():
+                raise OSError(
+                    f"Missing record in FCIO stream {fcio_stream.config.streamid & 0xFFFF}."
+                )
+
+        if fcio_stream.tag == Tags.Status:
+            any_full |= self.decoder.decode_packet(fcio_stream, status_rbkd, packet_id)
 
         return bool(any_full)
 
@@ -276,35 +295,31 @@ class ORFCIOEventHeaderDecoder(OrcaDecoder):
 
         key_list = self.fc_hdr_info["key_list"]
         for fcid in key_list:
-            key = get_key(fcid, 0, 0)
-            self.key_list["fc_eventheader"].append(key)
-            self.decoded_values[fcid] = copy.deepcopy(self.decoder.get_decoded_values())
+            self.key_list["fc_eventheader"].append(f"fcid_{fcid}/evt_hdr")
+            self.decoded_values["fcid"] = copy.deepcopy(
+                self.decoder.get_decoded_values()
+            )
             if self.fc_hdr_info["fsp_enabled"][fcid]:
                 self.fsp_decoder = FSPEventDecoder()
-                self.key_list["fsp_eventheader"].append(f"fsp_eventheader_{key}")
+                self.key_list["fsp_eventheader"].append(f"swtid_{fcid}/evt_hdr")
+                self.decoded_values["swtid"] = copy.deepcopy(
+                    self.fsp_decoder.get_decoded_values()
+                )
 
         self.max_rows_in_packet = 1
 
-    def get_key_lists(self) -> list[list[int | str]]:
+    def get_key_lists(self) -> list[list[str]]:
         return list(self.key_list.values())
 
-    def get_decoded_values(self, key: int | str = None) -> dict[str, Any]:
+    def get_decoded_values(self, key: str = None) -> dict[str, Any]:
         if (
             isinstance(key, str)
-            and key.startswith("fsp_eventheader_")
+            and key.startswith("swtid_")
             and self.fsp_decoder is not None
         ):
-            return copy.deepcopy(self.fsp_decoder.get_decoded_values())
-        elif isinstance(key, int):
-            fcid = get_fcid(key)
-            if fcid in self.decoded_values:
-                return self.decoded_values[fcid]
-        elif key is None and self.fsp_decoder is None:
-            dec_vals_list = list(self.decoded_values.values())
-            if len(dec_vals_list) > 0:
-                return dec_vals_list[0]
-            raise RuntimeError("decoded_values not built")
-
+            return self.decoded_values["swtid"]
+        elif (isinstance(key, str) and key.startswith("fcid_")) or key is None:
+            return self.decoded_values["fcid"]
         raise KeyError(f"no decoded values for key {key}")
 
     def decode_packet(
@@ -315,15 +330,25 @@ class ORFCIOEventHeaderDecoder(OrcaDecoder):
         fcio_stream.set_mem_field(memoryview(packet[3:]))
 
         any_full = False
-        while fcio_stream.get_record():
-            if fcio_stream.tag == Tags.EventHeader:
-                any_full |= self.decoder.decode_packet(
-                    fcio_stream, evthdr_rbkd, packet_id
+
+        if not fcio_stream.get_record():
+            raise OSError(
+                f"Missing record in FCIO stream {fcio_stream.config.streamid & 0xFFFF}."
+            )
+
+        if fcio_stream.tag == Tags.FSPEvent:
+            if self.fsp_decoder is not None:
+                any_full |= self.fsp_decoder.decode_packet(
+                    fcio_stream, evthdr_rbkd, packet_id, is_header=True
                 )
-                if self.fsp_decoder is not None:
-                    any_full |= self.fsp_decoder.decode_packet(
-                        fcio_stream, evthdr_rbkd, packet_id, True
-                    )
+
+            if not fcio_stream.get_record():
+                raise OSError(
+                    f"Missing record in FCIO stream {fcio_stream.config.streamid & 0xFFFF}."
+                )
+
+        if fcio_stream.tag == Tags.EventHeader:
+            any_full |= self.decoder.decode_packet(fcio_stream, evthdr_rbkd, packet_id)
 
         return bool(any_full)
 
@@ -335,7 +360,7 @@ class ORFCIOEventDecoder(OrcaDecoder):
         self.decoder = FCEventDecoder()
         self.fsp_decoder = None
 
-        self.key_list = {"event": [], "fsp_event": []}
+        self.key_list = []
         self.decoded_values = {}
         self.max_rows_in_packet = 0
 
@@ -347,24 +372,26 @@ class ORFCIOEventDecoder(OrcaDecoder):
         self.fc_hdr_info = extract_header_information(header)
         key_list = self.fc_hdr_info["key_list"]
         for fcid in key_list:
-            self.key_list["event"] += key_list[fcid]
+            self.key_list.append(key_list[fcid])
             self.decoded_values[fcid] = copy.deepcopy(self.decoder.get_decoded_values())
             self.decoded_values[fcid]["waveform"]["wf_len"] = self.fc_hdr_info[
                 "wf_len"
             ][fcid]
             if self.fc_hdr_info["fsp_enabled"][fcid]:
-                key = get_key(fcid, 0, 0)
-                self.key_list["fsp_event"].append(f"fsp_event_{key}")
                 self.fsp_decoder = FSPEventDecoder()
+                self.key_list.append([f"swtid_{fcid}/event"])
+                self.decoded_values["swtid"] = copy.deepcopy(
+                    self.fsp_decoder.get_decoded_values()
+                )
         self.max_rows_in_packet = max(self.fc_hdr_info["n_adc"].values())
 
-    def get_key_lists(self) -> list[list[int]]:
-        return list(self.key_list.values())
+    def get_key_lists(self) -> list[list[int | str]]:
+        return copy.deepcopy(self.key_list)
 
     def get_max_rows_in_packet(self) -> int:
         return self.max_rows_in_packet
 
-    def get_decoded_values(self, key: int = None) -> dict[str, Any]:
+    def get_decoded_values(self, key: int | str = None) -> dict[str, Any]:
         if key is None:
             dec_vals_list = list(self.decoded_values.values())
             if len(dec_vals_list) > 0:
@@ -373,10 +400,10 @@ class ORFCIOEventDecoder(OrcaDecoder):
 
         if (
             isinstance(key, str)
-            and key.startswith("fsp_event_")
+            and key.startswith("swtid_")
             and self.fsp_decoder is not None
         ):
-            return copy.deepcopy(self.fsp_decoder.get_decoded_values())
+            return self.decoded_values["swtid"]
         elif isinstance(key, int):
             fcid = get_fcid(key)
             if fcid in self.decoded_values:
@@ -394,12 +421,24 @@ class ORFCIOEventDecoder(OrcaDecoder):
         fcio_stream.set_mem_field(memoryview(packet[3:]))
 
         any_full = False
-        while fcio_stream.get_record():
-            if fcio_stream.tag == Tags.Event or fcio_stream.tag == Tags.SparseEvent:
-                any_full |= self.decoder.decode_packet(fcio_stream, evt_rbkd, packet_id)
-                if self.fsp_decoder is not None:
-                    any_full |= self.fsp_decoder.decode_packet(
-                        fcio_stream, evt_rbkd, packet_id, False
-                    )
+
+        if not fcio_stream.get_record():
+            raise OSError(
+                f"Missing record in FCIO stream {fcio_stream.config.streamid & 0xFFFF}."
+            )
+
+        if fcio_stream.tag == Tags.FSPEvent:
+            if self.fsp_decoder is not None:
+                any_full |= self.fsp_decoder.decode_packet(
+                    fcio_stream, evt_rbkd, packet_id
+                )
+
+            if not fcio_stream.get_record():
+                raise OSError(
+                    f"Missing record in FCIO stream {fcio_stream.config.streamid & 0xFFFF}."
+                )
+
+        if fcio_stream.tag == Tags.Event or fcio_stream.tag == Tags.SparseEvent:
+            any_full |= self.decoder.decode_packet(fcio_stream, evt_rbkd, packet_id)
 
         return bool(any_full)

daq2lh5/orca/orca_streamer.py

@@ -8,7 +8,7 @@ import logging
 import numpy as np
 
 from ..data_streamer import DataStreamer
-from ..raw_buffer import RawBuffer, RawBufferLibrary
+from ..raw_buffer import RawBuffer, RawBufferLibrary, RawBufferList
 from . import orca_packet
 from .orca_base import OrcaDecoder
 from .orca_digitizers import (  # noqa: F401
@@ -351,6 +351,18 @@ class OrcaStreamer(DataStreamer):
         if rb_lib is not None and "*" not in rb_lib:
             keep_decoders = []
             for name in decoder_names:
+                # Decoding ORFCIO streams requires decoding ORFCIOConfig packets,
+                # as it opens the wrapped fcio stream (in orca_fcio.py) and decodes the fields
+                # required for the other FCIO packets.
+                # With `out_stream == ''` the lgdo buffer will be allocated, and the packet
+                # decoded, but not written to the out_stream the user defined.
+                if name == "ORFCIOConfigDecoder" and name not in rb_lib:
+                    rb_lib[name] = RawBufferList()
+                    rb_lib[name].append(
+                        RawBuffer(
+                            lgdo=None, key_list=["*"], out_name="{key}", out_stream=""
+                        )
+                    )
                 if name in rb_lib:
                     keep_decoders.append(name)
             decoder_names = keep_decoders
@@ -366,8 +378,7 @@ class OrcaStreamer(DataStreamer):
             shift_data_id=False
         )
         instantiated_decoders = {"OrcaHeaderDecoder": self.header_decoder}
-        for data_id in id_to_dec_name_dict.keys():
-            name = id_to_dec_name_dict[data_id]
+        for data_id, name in id_to_dec_name_dict.items():
             if name not in instantiated_decoders:
                 if name not in globals():
                     self.missing_decoders.append(data_id)
@@ -384,8 +395,6 @@ class OrcaStreamer(DataStreamer):
             chunk_mode=chunk_mode,
             out_stream=out_stream,
         )
-        if rb_lib is None:
-            rb_lib = self.rb_lib
         good_buffers = []
         for data_id in self.decoder_id_dict.keys():
             name = id_to_dec_name_dict[data_id]
@@ -401,8 +410,8 @@ class OrcaStreamer(DataStreamer):
         log.debug(f"rb_lib = {self.rb_lib}")
 
         # return header raw buffer
-        if "OrcaHeaderDecoder" in rb_lib:
-            header_rb_list = rb_lib["OrcaHeaderDecoder"]
+        if "OrcaHeaderDecoder" in self.rb_lib:
+            header_rb_list = self.rb_lib["OrcaHeaderDecoder"]
             if len(header_rb_list) != 1:
                 log.warning(
                     f"header_rb_list had length {len(header_rb_list)}, ignoring all but the first"

{legend_daq2lh5-1.6.1.dist-info → legend_daq2lh5-1.6.3.dist-info}/METADATA

@@ -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.dist-info → legend_daq2lh5-1.6.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 daq2lh5/__init__.py,sha256=VPmwKuZSA0icpce05ojhnsKWhR4_QUgD0oVXUoN9wks,975
-daq2lh5/_version.py,sha256=vFpyllSQPpQuwzP7Cf743S6HuWgZRMOD31pPfh-WoZM,511
+daq2lh5/_version.py,sha256=RrM0JkMSEquWJIGj8RCqoST__VpnXFzYf3k-uS1FCko,511
 daq2lh5/build_raw.py,sha256=wehR1jADL_ponguOMfAsMTxsebE-qdztFw4Txm76fpw,10716
-daq2lh5/cli.py,sha256=7bPfH1XbyAS48wZn_0unj4Y5MD5kF7V34Q5srn4jKVM,2913
+daq2lh5/cli.py,sha256=yCLshhXZdXpeaVElqLYwGHR1uN7fcPDRnsrFQgGdwYM,3210
 daq2lh5/data_decoder.py,sha256=45ckhpfqKh6_FfPUn_iETZLjRFd4VtvQhet4l2KvldA,10606
 daq2lh5/data_streamer.py,sha256=-uns1Y9iReVSJTXGCXD05QQLfqjbQn-VodEmDj7uSJo,16016
 daq2lh5/logging.py,sha256=rYNeToaZBTCaIiC42a4CUroAo1PCOreTXbpEZyMO8Fo,987
@@ -12,16 +12,16 @@ daq2lh5/buffer_processor/buffer_processor.py,sha256=mG4kJXt8V9Jji_UTBfllRffIVqLP
 daq2lh5/buffer_processor/lh5_buffer_processor.py,sha256=dKND-18TTPDZH8VxdEaQNZPK7w_G-dC4fsBns1NIjMY,8409
 daq2lh5/compass/__init__.py,sha256=mOXHWp7kRDgNTPQty3E8k2KPSy_vAzjneKfAcCVaPyE,132
 daq2lh5/compass/compass_config_parser.py,sha256=zeAsOo1dOJPGLL8-zkAcdYRkqt8BodtOPi96n7fWsl4,12300
-daq2lh5/compass/compass_event_decoder.py,sha256=kiPOaEu8SgLD2wbSPbBahcbTBBRAIw35wtVLBcwPcXY,7386
-daq2lh5/compass/compass_header_decoder.py,sha256=AA-Md2FIT3nD4mXX9CrWvbbfmKiA436-BTmzcU3_XOY,2823
-daq2lh5/compass/compass_streamer.py,sha256=zSl7IqO0ID0wcixkLE9QVEG3bF9hfGVITVPomCeOFTM,8841
+daq2lh5/compass/compass_event_decoder.py,sha256=hNEz4q45vDxsC6JnChW55rCsYaYtGaxZ4gXYrIEK8Iw,7463
+daq2lh5/compass/compass_header_decoder.py,sha256=e2uVnx6o36K-BzPTTpl2ot8r4rwZp-qLniTXee3q2aI,10251
+daq2lh5/compass/compass_streamer.py,sha256=JkR5HvX9_Vl0RgiTS26A4Ae0EelmrpbgG-GihDhUJ3w,9186
 daq2lh5/fc/__init__.py,sha256=bB1j6r-bDmylNi0iutQeAJGjsDSjLSoXMqFfXWwfb8I,141
-daq2lh5/fc/fc_config_decoder.py,sha256=Mlll1SI4HPmTo6EGubkyP-QcmEfmO-kWaiZCKDc4cxg,4448
-daq2lh5/fc/fc_event_decoder.py,sha256=c2CQSiNxlOEGOZNSgqM3eM-26EUW6MIfK48Am9CHfro,7887
-daq2lh5/fc/fc_eventheader_decoder.py,sha256=jAUxgWqgQmzNhAzMLubgFLMiGpxjqVIut6uhVS6JfyA,12313
-daq2lh5/fc/fc_fsp_decoder.py,sha256=-qQjDkXF7xjF3lYIp2085TY2hRrLwxzyXwQYAn1OAJw,34972
-daq2lh5/fc/fc_status_decoder.py,sha256=ChMxALx36caY7zfCOKozNgXYhLGX9HzBnkyOvQfiABk,8809
-daq2lh5/fc/fc_streamer.py,sha256=U1EPKr-xSlxTCqcgQL6SFlO11WDFT9kcna7gocDKLXo,9162
+daq2lh5/fc/fc_config_decoder.py,sha256=f-WqmvfDDDnx4ho2q4w5Hmzu55yvweHsi1hgM2X4RbM,4654
+daq2lh5/fc/fc_event_decoder.py,sha256=_g-bznhBHk8v-VSHYHJa5LlJYP69gWZ0LNXslYgEAlw,7897
+daq2lh5/fc/fc_eventheader_decoder.py,sha256=m9XLpLl52Set1ITpCLp9_0L6wS6AaAN8uDUdDdqYG5Y,12390
+daq2lh5/fc/fc_fsp_decoder.py,sha256=sCv3YfZ0QnN7LAS2msYo9XbMeEIFuKmyLp3SiB4fQ9M,35074
+daq2lh5/fc/fc_status_decoder.py,sha256=o3DjpXtx3VIk3hWrodWopYczfXiJr-ekSUx_HqW2cyc,8818
+daq2lh5/fc/fc_streamer.py,sha256=iJSd2OiOYAjFtBg-Yr9D64_kp3xO_9Jt5XpO9q0sFpE,9208
 daq2lh5/llama/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 daq2lh5/llama/llama_base.py,sha256=B-NCBjE_FQE1WxijWi4Z1XBy4rqLHm2XhkC40s7Sdms,290
 daq2lh5/llama/llama_event_decoder.py,sha256=DVULTX7JzlRe23HZYXn79VkoU2_z03o7nxWc33bGK8U,14981
@@ -30,17 +30,17 @@ daq2lh5/llama/llama_streamer.py,sha256=lrK73JIXjpogPrkP_tpFQQGSyWxFhivSpU1YEfRMH
 daq2lh5/orca/__init__.py,sha256=Xf6uOIOzk_QkKH_7VizGlCo3iuiAgLtUE3A07x_HXC0,175
 daq2lh5/orca/orca_base.py,sha256=-XIolXsHj-1EdewaGxyvJTZvRGZsDyZe-5PzVOd-LFY,1333
 daq2lh5/orca/orca_digitizers.py,sha256=Vu05xQO3XYqybjLhzk-XJG41wyeVFSIoXOjvdltDoUw,20865
-daq2lh5/orca/orca_fcio.py,sha256=v2kZWUmutd1HcWJW0h50zsVdAZorP8TG39PP9tf_GCg,15107
+daq2lh5/orca/orca_fcio.py,sha256=WDaWp4JkUDOUvrMCxKWI-kXXrZNQNAakDCdNyFaqL3k,16091
 daq2lh5/orca/orca_flashcam.py,sha256=klGWxME2QS3eOBgb5mD3IrPHXXzb1Zz4B7YDvZvaGD8,33291
 daq2lh5/orca/orca_header.py,sha256=2WlB8rFXwzD89lX51JXYiOlop0-C4pWEEsIWKq2ouDM,4403
 daq2lh5/orca/orca_header_decoder.py,sha256=ORIIyfx22ybyKc-uyWy5ER49-dl3BGpHdfV8OCDmjIw,1632
 daq2lh5/orca/orca_packet.py,sha256=LtKEAcH2VGzY8AQEqAokZTHonShACsKisGdQR0AMDAM,2835
 daq2lh5/orca/orca_run_decoder.py,sha256=61gghgjqD1ovH3KoHFJuKJp0GLJn4X0MIuoYrsIzMfQ,2059
-daq2lh5/orca/orca_streamer.py,sha256=sLM5PPLOxJ_aJckJOl9UCjyOaPmNxUKDnrLw22fSNbE,16622
+daq2lh5/orca/orca_streamer.py,sha256=a9iy1FfbN1niX4gcJQpPCwiv1fKLLEZMcaGs2lOnfFw,17284
 daq2lh5/orca/skim_orca_file.py,sha256=ESWfbv9yDRGaPf3Ptlw6Dxnc4uwhJoagb_aYlWNyrq0,1954
-legend_daq2lh5-1.6.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-legend_daq2lh5-1.6.1.dist-info/METADATA,sha256=UbfgLNJWCAl6CquW11JoohphH6-rre7kC4UjGcH-5Hs,4005
-legend_daq2lh5-1.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-legend_daq2lh5-1.6.1.dist-info/entry_points.txt,sha256=RPm2GPw2YADil9tWgvZsIysmJz9KuktBWH_1P38PWoc,119
-legend_daq2lh5-1.6.1.dist-info/top_level.txt,sha256=MJQVLyLqMgMKBdVfNXFaCKCjHKakAs19VLbC9ctXZ7A,8
-legend_daq2lh5-1.6.1.dist-info/RECORD,,
+legend_daq2lh5-1.6.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+legend_daq2lh5-1.6.3.dist-info/METADATA,sha256=NaUXE8unZmqIsT_akldDSofULeVX3L6TsQV4b9XIQfc,4005
+legend_daq2lh5-1.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+legend_daq2lh5-1.6.3.dist-info/entry_points.txt,sha256=RPm2GPw2YADil9tWgvZsIysmJz9KuktBWH_1P38PWoc,119
+legend_daq2lh5-1.6.3.dist-info/top_level.txt,sha256=MJQVLyLqMgMKBdVfNXFaCKCjHKakAs19VLbC9ctXZ7A,8
+legend_daq2lh5-1.6.3.dist-info/RECORD,,