legend-daq2lh5 1.6.2__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.2'
-__version_tuple__ = version_tuple = (1, 6, 2)
+__version__ = version = '1.6.3'
+__version_tuple__ = version_tuple = (1, 6, 3)

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_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
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: legend-daq2lh5
-Version: 1.6.2
+Version: 1.6.3
 Summary: Convert digitizer data to LH5
 Author-email: Jason Detwiler <jasondet@uw.edu>
 Maintainer: The LEGEND collaboration

{legend_daq2lh5-1.6.2.dist-info → legend_daq2lh5-1.6.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 daq2lh5/__init__.py,sha256=VPmwKuZSA0icpce05ojhnsKWhR4_QUgD0oVXUoN9wks,975
-daq2lh5/_version.py,sha256=0l_x32-zDcY9aQqQSs0LtsRx42EjkEfyXdUn9HtFgXU,511
+daq2lh5/_version.py,sha256=RrM0JkMSEquWJIGj8RCqoST__VpnXFzYf3k-uS1FCko,511
 daq2lh5/build_raw.py,sha256=wehR1jADL_ponguOMfAsMTxsebE-qdztFw4Txm76fpw,10716
 daq2lh5/cli.py,sha256=yCLshhXZdXpeaVElqLYwGHR1uN7fcPDRnsrFQgGdwYM,3210
 daq2lh5/data_decoder.py,sha256=45ckhpfqKh6_FfPUn_iETZLjRFd4VtvQhet4l2KvldA,10606
@@ -12,13 +12,13 @@ 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=f-WqmvfDDDnx4ho2q4w5Hmzu55yvweHsi1hgM2X4RbM,4654
-daq2lh5/fc/fc_event_decoder.py,sha256=c2CQSiNxlOEGOZNSgqM3eM-26EUW6MIfK48Am9CHfro,7887
-daq2lh5/fc/fc_eventheader_decoder.py,sha256=zY8uNVs16U6qu4_x9vD8850t031fy_py91kxXFoKY38,12337
+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
@@ -36,11 +36,11 @@ daq2lh5/orca/orca_header.py,sha256=2WlB8rFXwzD89lX51JXYiOlop0-C4pWEEsIWKq2ouDM,4
 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.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-legend_daq2lh5-1.6.2.dist-info/METADATA,sha256=mMmyM0yX1XPih67NgaGQab1q1z519EuA8BTqksnxDsM,4005
-legend_daq2lh5-1.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-legend_daq2lh5-1.6.2.dist-info/entry_points.txt,sha256=RPm2GPw2YADil9tWgvZsIysmJz9KuktBWH_1P38PWoc,119
-legend_daq2lh5-1.6.2.dist-info/top_level.txt,sha256=MJQVLyLqMgMKBdVfNXFaCKCjHKakAs19VLbC9ctXZ7A,8
-legend_daq2lh5-1.6.2.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,,