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

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

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

{legend_daq2lh5-1.6.2 → 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.2 → 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.2 → 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.2 → 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
 

{legend_daq2lh5-1.6.2 → legend_daq2lh5-1.6.3}/src/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 → legend_daq2lh5-1.6.3}/src/legend_daq2lh5.egg-info/PKG-INFO

@@ -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 → legend_daq2lh5-1.6.3}/tests/compass/conftest.py

@@ -40,7 +40,6 @@ def compass_config_no_settings(lgnd_test_data):
     test_file = lgnd_test_data.get_path("compass/compass_test_data.BIN")
     in_stream = open(test_file, "rb")
     compass_config_file = None
-    wf_len = 1000
-    decoder.decode_header(in_stream, compass_config_file, wf_len)
+    decoder.decode_header(in_stream, compass_config_file)
     in_stream.close()
     return decoder.config

{legend_daq2lh5-1.6.2 → legend_daq2lh5-1.6.3}/tests/compass/test_compass_header_decoder.py

@@ -46,6 +46,7 @@ def test_values(compass_config):
         "energy_channels": 1,
         "energy_short": 1,
         "waveform_samples": 1,
+        "header_present": 1,
     }
     # We have a nested struct, so we need some nasty recursion
     for key in compass_config.keys():
@@ -136,6 +137,7 @@ def test_values_no_config(compass_config_no_settings):
         "energy_channels": 1,
         "energy_short": 1,
         "waveform_samples": 1,
+        "header_present": 1,
     }
     # We have a nested struct, so we need some nasty recursion
     for key in compass_config_no_settings.keys():

{legend_daq2lh5-1.6.2 → legend_daq2lh5-1.6.3}/tests/orca/test_orca_fcio.py

@@ -48,7 +48,7 @@ def test_orfcio_config_decoding_swt(orca_stream_fcio_swt, fcio_swt_packets):
     assert name == "ORFCIOConfigDecoder"
 
 
-def test_orfcio_waveform_decoding_swt(orca_stream_fcio_swt, fcio_swt_packets):
+def test_orfcio_eventheader_decoding_swt(orca_stream_fcio_swt, fcio_swt_packets):
     wf_packet = fcio_swt_packets[1]
     assert wf_packet is not None
 

{legend_daq2lh5-1.6.2 → legend_daq2lh5-1.6.3}/tests/orca/test_orca_to_raw.py

@@ -9,6 +9,7 @@ import lgdo.lh5 as lh5
 import numpy as np
 
 from daq2lh5 import build_raw
+from daq2lh5.fc.fc_event_decoder import get_key
 from daq2lh5.orca import orca_streamer
 from daq2lh5.orca.orca_flashcam import ORFlashCamListenerConfigDecoder
 from daq2lh5.orca.orca_run_decoder import ORRunDecoderForRun
@@ -265,3 +266,71 @@ def test_daq_to_raw(lgnd_test_data, tmptestdir):
     # assert the byte strings are the same
     assert len(rebuilt_orca_data) == len(orig_orca_data)
     assert rebuilt_orca_data == orig_orca_data
+
+
+def test_daq_to_raw_orfcio_outspec(lgnd_test_data, tmptestdir):
+    """Test function for the daq to raw validation."""
+
+    # open orca daq file and create LH5 file
+    orca_file = lgnd_test_data.get_path(
+        "orca/fcio/l200-p14-r004-cal-20250606T010224Z.orca"
+    )
+
+    filekey = f"{tmptestdir}/l200-p14-r004-cal-20250606T010224Z.lh5"
+
+    expected_top_level_keys = [
+        "ch1105600",
+        "ch1105604",
+        "ch1107202",
+        "ch1113600",
+        "ch1115200",
+        "ch1115205",
+    ]
+
+    # Test minimal waveform out_spec. Test ORFCIOConfigDecoder hidden auto-decoding in build_raw
+
+    out_spec = {
+        "ORFCIOEventDecoder": {
+            "ch{key:07d}/raw": {
+                "key_list": ["*"],
+                "out_stream": f"{filekey}",
+            }
+        }
+    }
+
+    build_raw(
+        orca_file,
+        in_stream_type="ORCA",
+        out_spec=out_spec,
+        overwrite=True,
+    )
+
+    top_level_keys = lh5.ls(filekey, "/")
+    assert top_level_keys == expected_top_level_keys
+
+    # Test default out_spec: filekey is out_stream, no spec given.
+
+    build_raw(
+        orca_file,
+        in_stream_type="ORCA",
+        out_spec=filekey,
+        overwrite=True,
+    )
+
+    top_level_keys = lh5.ls(filekey, "/")
+
+    rawid_components = lh5.read(
+        "ORFCIOEvent_0", filekey, field_mask=["board_id", "fc_input", "fcid"]
+    )
+    auto_decoded_keys = sorted(
+        {
+            f"ch{get_key(fcid, board_id, fc_input)}"
+            for fcid, board_id, fc_input in zip(
+                rawid_components["fcid"],
+                rawid_components["board_id"],
+                rawid_components["fc_input"],
+            )
+        }
+    )
+
+    assert auto_decoded_keys == expected_top_level_keys

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

@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-import lgdo
-
-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, wf_len: int = 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
-        wf_len
-            The length of the first waveform in the file, only pre-calculated when the config_file is none
-
-        Returns
-        -------
-        config
-            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)
-
-        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):
-            if name in self.config:
-                log.warning(f"{name} already in self.config. skipping...")
-                continue
-            value = int(header_as_list[i])
-            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