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

daq2lh5/orca/orca_fcio.py

@@ -0,0 +1,405 @@
+from __future__ import annotations
+
+import copy
+import logging
+from typing import Any
+
+from fcio import FCIO, Tags
+
+from daq2lh5.fc.fc_config_decoder import FCConfigDecoder
+from daq2lh5.fc.fc_event_decoder import FCEventDecoder
+from daq2lh5.fc.fc_eventheader_decoder import FCEventHeaderDecoder, get_fcid, get_key
+from daq2lh5.fc.fc_fsp_decoder import (
+    FSPConfigDecoder,
+    FSPEventDecoder,
+    FSPStatusDecoder,
+)
+from daq2lh5.fc.fc_status_decoder import FCStatusDecoder
+from daq2lh5.fc.fc_status_decoder import get_key as get_status_key
+
+from ..raw_buffer import RawBufferList
+from .orca_base import OrcaDecoder
+from .orca_header import OrcaHeader
+from .orca_packet import OrcaPacket
+
+log = logging.getLogger(__name__)
+
+
+# FCIO streams are stateful and need to be accessible for all decoders.
+fcio_stream_library = dict()
+
+
+def get_fcio_stream(streamid):
+    if streamid in fcio_stream_library:
+        return fcio_stream_library[streamid]
+    else:
+        fcio_stream_library[streamid] = FCIO()
+        return fcio_stream_library[streamid]
+
+
+def extract_header_information(header: OrcaHeader):
+
+    fc_hdr_info = {
+        "key_list": {},
+        "n_adc": {},
+        "adc_card_layout": {},
+        "wf_len": {},
+        "fsp_enabled": {},
+        "n_card": {},
+    }
+
+    fc_card_info_dict = header.get_object_info(
+        [
+            "ORFlashCamGlobalTriggerModel",
+            "ORFlashCamTriggerModel",
+            "ORFlashCamADCModel",
+            "ORFlashCamADCStdModel",
+        ]
+    )
+
+    fc_listener_info_list = header.get_readout_info("ORFlashCamListenerModel")
+    for fc_listener_info in fc_listener_info_list:
+        fcid = fc_listener_info["uniqueID"]  # it should be called listener_id
+        if fcid == 0:
+            raise ValueError("got fcid=0 unexpectedly!")
+        aux_hw_info = header.get_auxhw_info("ORFlashCamListenerModel", fcid)
+        if "fspEnabled" in aux_hw_info:
+            fc_hdr_info["fsp_enabled"][fcid] = aux_hw_info["fspEnabled"]
+        else:
+            fc_hdr_info["fsp_enabled"][fcid] = False
+
+        fc_hdr_info["wf_len"][fcid] = header.get_auxhw_info(
+            "ORFlashCamListenerModel", fcid
+        )["eventSamples"]
+        fc_hdr_info["n_adc"][fcid] = 0
+        fc_hdr_info["n_card"][fcid] = 0
+        fc_hdr_info["key_list"][fcid] = []
+        fc_hdr_info["adc_card_layout"][fcid] = {}
+        for child in fc_listener_info["children"]:
+
+            crate = child["crate"]
+            card = child["station"]
+            card_address = fc_card_info_dict[crate][card]["CardAddress"]
+            fc_hdr_info["adc_card_layout"][fcid][card_address] = (
+                crate,
+                card,
+                card_address,
+            )
+            fc_hdr_info["n_card"][fcid] += 1
+
+            if crate not in fc_card_info_dict:
+                raise RuntimeError(f"no crate {crate} in fc_card_info_dict")
+            if card not in fc_card_info_dict[crate]:
+                raise RuntimeError(f"no card {card} in fc_card_info_dict[{crate}]")
+
+            for fc_input in range(len(fc_card_info_dict[crate][card]["Enabled"])):
+                if not fc_card_info_dict[crate][card]["Enabled"][fc_input]:
+                    continue
+
+                fc_hdr_info["n_adc"][fcid] += 1
+                key = get_key(fcid, card_address, fc_input)
+
+                if key in fc_hdr_info["key_list"][fcid]:
+                    log.warning(f"key {key} already in key_list...")
+                else:
+                    fc_hdr_info["key_list"][fcid].append(key)
+
+    return fc_hdr_info
+
+
+class ORFCIOConfigDecoder(OrcaDecoder):
+    def __init__(self, header: OrcaHeader = None, **kwargs) -> None:
+
+        self.decoder = FCConfigDecoder()
+        self.fsp_decoder = None
+        self.decoded_values = {}
+        self.key_list = {"fc_config": [], "fsp_config": []}
+        self.max_rows_in_packet = 0
+
+        super().__init__(header=header, **kwargs)
+
+        # The ConfigDecoder is always required for decoding fcio data.
+        # When OrcaStreamer.open_stream is called, we close any open fcio stream
+        for fcio_stream in fcio_stream_library.values():
+            fcio_stream.close()
+
+    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())
+
+        for fcid in self.fc_hdr_info["fsp_enabled"]:
+            key = get_key(fcid, 0, 0)
+            self.key_list["fc_config"].append(key)
+            if self.fc_hdr_info["fsp_enabled"][fcid]:
+                self.fsp_decoder = FSPConfigDecoder()
+                self.key_list["fsp_config"].append(f"fsp_config_{key}")
+        self.max_rows_in_packet = 1
+
+    def get_key_lists(self) -> list[list[int, 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
+        raise KeyError(f"no decoded values for key {key}")
+
+    def decode_packet(
+        self, packet: OrcaPacket, packet_id: int, rbl: RawBufferList
+    ) -> bool:
+
+        fcio_stream = get_fcio_stream(packet[2])
+        if fcio_stream.is_open():
+            raise NotImplementedError(
+                f"FCIO stream with stream id {packet[2]} already opened. Update of FCIOConfig is not supported."
+            )
+        else:
+            fcio_stream.open(memoryview(packet[3:]))
+
+        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}"
+            )
+
+        config_rbkd = rbl.get_keyed_dict()
+
+        # TODO: the decoders could fetch lgdo's using it's key_list
+        fc_key = get_key(fcio_stream.config.streamid, 0, 0)
+        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)}"
+            any_full |= self.fsp_decoder.decode_packet(
+                fcio_stream, config_rbkd[fsp_key], packet_id
+            )
+
+        return bool(any_full)
+
+
+class ORFCIOStatusDecoder(OrcaDecoder):
+    def __init__(self, header: OrcaHeader = None, **kwargs) -> None:
+
+        self.decoder = FCStatusDecoder()
+        self.fsp_decoder = None
+        self.decoded_values = {}
+        self.key_list = {"fc_status": [], "fsp_status": []}
+        self.max_rows_in_packet = 0
+        super().__init__(header=header, **kwargs)
+
+    def set_header(self, header: OrcaHeader) -> None:
+        """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)]
+            # ADC module keys
+            self.key_list["fc_status"] += [
+                get_status_key(fcid, 0x2000 + i)
+                for i in range(self.fc_hdr_info["n_card"][fcid])
+            ]
+
+            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.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_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")
+
+        if (
+            isinstance(key, str)
+            and key.startswith("fsp_status")
+            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())
+        else:
+            raise KeyError(f"no decoded values for key {key}")
+
+    def get_max_rows_in_packet(self) -> int:
+        return self.max_rows_in_packet
+
+    def decode_packet(
+        self, packet: OrcaPacket, packet_id: int, rbl: RawBufferList
+    ) -> bool:
+        status_rbkd = rbl.get_keyed_dict()
+
+        fcio_stream = get_fcio_stream(packet[2])
+        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(
+                    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
+                    )
+
+        return bool(any_full)
+
+
+class ORFCIOEventHeaderDecoder(OrcaDecoder):
+    def __init__(self, header: OrcaHeader = None, **kwargs) -> None:
+
+        self.decoder = FCEventHeaderDecoder()
+        self.fsp_decoder = None
+        self.decoded_values = {}
+        self.key_list = {"fc_eventheader": [], "fsp_eventheader": []}
+
+        super().__init__(header=header, **kwargs)
+
+    def set_header(self, header: OrcaHeader) -> None:
+        """Setter for headers. Overload to set card parameters, etc."""
+        self.header = header
+
+        self.fc_hdr_info = extract_header_information(header)
+
+        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())
+            if self.fc_hdr_info["fsp_enabled"][fcid]:
+                self.fsp_decoder = FSPEventDecoder()
+                self.key_list["fsp_eventheader"].append(f"fsp_eventheader_{key}")
+
+        self.max_rows_in_packet = 1
+
+    def get_key_lists(self) -> list[list[int | 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_eventheader_")
+            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")
+
+        raise KeyError(f"no decoded values for key {key}")
+
+    def decode_packet(
+        self, packet: OrcaPacket, packet_id: int, rbl: RawBufferList
+    ) -> bool:
+        evthdr_rbkd = rbl.get_keyed_dict()
+        fcio_stream = get_fcio_stream(packet[2])
+        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 self.fsp_decoder is not None:
+                    any_full |= self.fsp_decoder.decode_packet(
+                        fcio_stream, evthdr_rbkd, packet_id, True
+                    )
+
+        return bool(any_full)
+
+
+class ORFCIOEventDecoder(OrcaDecoder):
+    """Decoder for FlashCam FCIO stream data written by ORCA."""
+
+    def __init__(self, header: OrcaHeader = None, **kwargs) -> None:
+        self.decoder = FCEventDecoder()
+        self.fsp_decoder = None
+
+        self.key_list = {"event": [], "fsp_event": []}
+        self.decoded_values = {}
+        self.max_rows_in_packet = 0
+
+        super().__init__(header=header, **kwargs)
+
+    def set_header(self, header: OrcaHeader) -> None:
+        """Setter for headers. Overload to set card parameters, etc."""
+        self.header = header
+        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.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.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_max_rows_in_packet(self) -> int:
+        return self.max_rows_in_packet
+
+    def get_decoded_values(self, key: int = None) -> dict[str, Any]:
+        if key 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")
+
+        if (
+            isinstance(key, str)
+            and key.startswith("fsp_event_")
+            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]
+
+        raise KeyError(f"no decoded values for key {key}")
+
+    def decode_packet(
+        self, packet: OrcaPacket, packet_id: int, rbl: RawBufferList
+    ) -> bool:
+        """Decode the ORCA FlashCam ADC packet."""
+        evt_rbkd = rbl.get_keyed_dict()
+
+        fcio_stream = get_fcio_stream(packet[2])
+        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
+                    )
+
+        return bool(any_full)

daq2lh5/orca/orca_flashcam.py

@@ -5,7 +5,7 @@ from typing import Any
 
 import numpy as np
 
-from ..fc.fc_event_decoder import fc_decoded_values
+from ..fc.fc_event_decoder import fc_event_decoded_values
 from ..raw_buffer import RawBufferLibrary
 from .orca_base import OrcaDecoder
 from .orca_header import OrcaHeader
@@ -43,7 +43,7 @@ class ORFlashCamListenerConfigDecoder(OrcaDecoder):
             "packet_len": {"dtype": "uint32"},
             "readout_id": {"dtype": "uint16"},
             "fcid": {"dtype": "uint16"},
-            "telid": {"dtype": "int32"},
+            "streamid": {"dtype": "int32"},
             "nadcs": {"dtype": "int32"},
             "ntriggers": {"dtype": "int32"},
             "nsamples": {"dtype": "int32"},
@@ -458,8 +458,8 @@ class ORFlashCamWaveformDecoder(OrcaDecoder):
 
     def __init__(self, header: OrcaHeader = None, **kwargs) -> None:
         # start with the values defined in fcdaq
-        self.decoded_values_template = copy.deepcopy(fc_decoded_values)
-        """A custom copy of :obj:`.fc.fc_event_decoder.fc_decoded_values`."""
+        self.decoded_values_template = copy.deepcopy(fc_event_decoded_values)
+        """A custom copy of :obj:`.fc.fc_event_decoder.fc_event_decoded_values`."""
         # add header values from Orca
         self.decoded_values_template.update(
             {
@@ -737,6 +737,9 @@ class ORFlashCamWaveformDecoder(OrcaDecoder):
         tbl["waveform"]["values"].nda[ii][:wf_samples] = wf
 
         evt_rbkd[key].loc += 1
+        log.info(
+            f"-> {tbl['eventnumber'].nda[ii]} {channel} .. {evt_rbkd[key].loc}/{len(evt_rbkd[key])} {id(evt_rbkd[key])} {id(evt_rbkd[key].lgdo)}"
+        )
         return evt_rbkd[key].is_full()
 
 

daq2lh5/orca/orca_header.py

@@ -46,16 +46,21 @@ class OrcaHeader(dict):
                 return d["Run Control"]["RunNumber"]
         raise ValueError("No run number found in header!")
 
-    def get_object_info(self, orca_class_name: str) -> dict[int, dict[int, dict]]:
+    def get_object_info(
+        self, orca_class_name: str | list[str]
+    ) -> dict[int, dict[int, dict]]:
         """Returns a ``dict[crate][card]`` with all info from the header for
         each card with name `orca_class_name`.
         """
         object_info_dict = {}
 
+        if isinstance(orca_class_name, str):
+            orca_class_name = [orca_class_name]
+
         crates = self["ObjectInfo"]["Crates"]
         for crate in crates:
             for card in crate["Cards"]:
-                if card["Class Name"] == orca_class_name:
+                if card["Class Name"] in orca_class_name:
                     if crate["CrateNumber"] not in object_info_dict:
                         object_info_dict[crate["CrateNumber"]] = {}
                     object_info_dict[crate["CrateNumber"]][card["Card"]] = card

daq2lh5/orca/orca_packet.py

@@ -20,9 +20,19 @@ def is_short(packet: OrcaPacket) -> bool:
     return bool(packet[0] >> 31)
 
 
+def is_extended(packet: OrcaPacket) -> bool:
+    # if the packet is 0 size in default format
+    # the length if the packet is stored in the next uint32
+    return bool((packet[0] & 0x3FFFF) == 0)
+
+
 def get_n_words(packet: OrcaPacket) -> int:
     if is_short(packet):
         return 1
+    if is_extended(packet):
+        # we could check here if packet is actually long enough
+        # to return packet[1]
+        return packet[1]
     return packet[0] & 0x3FFFF
 
 

daq2lh5/orca/orca_run_decoder.py

@@ -18,12 +18,12 @@ class ORRunDecoderForRun(OrcaDecoder):
         # bit in data packet
         self.decoded_values = {
             "subrun_number": {"dtype": "uint16"},
-            "runstartorstop": {"dtype": "bool8"},
-            "quickstartrun": {"dtype": "bool8"},
-            "remotecontrolrun": {"dtype": "bool8"},
-            "heartbeatrecord": {"dtype": "bool8"},
-            "endsubrunrecord": {"dtype": "bool8"},
-            "startsubrunrecord": {"dtype": "bool8"},
+            "runstartorstop": {"dtype": "bool"},
+            "quickstartrun": {"dtype": "bool"},
+            "remotecontrolrun": {"dtype": "bool"},
+            "heartbeatrecord": {"dtype": "bool"},
+            "endsubrunrecord": {"dtype": "bool"},
+            "startsubrunrecord": {"dtype": "bool"},
             "run_number": {"dtype": "int32"},
             "time": {"dtype": "int32"},
         }

daq2lh5/orca/orca_streamer.py

@@ -15,6 +15,12 @@ from .orca_digitizers import (  # noqa: F401
     ORSIS3302DecoderForEnergy,
     ORSIS3316WaveformDecoder,
 )
+from .orca_fcio import (  # noqa: F401;
+    ORFCIOConfigDecoder,
+    ORFCIOEventDecoder,
+    ORFCIOEventHeaderDecoder,
+    ORFCIOStatusDecoder,
+)
 from .orca_flashcam import (  # noqa: F401;
     ORFlashCamADCWaveformDecoder,
     ORFlashCamListenerConfigDecoder,
@@ -41,18 +47,28 @@ class OrcaStreamer(DataStreamer):
         self.rbl_id_dict = {}  # dict of RawBufferLists for each data_id
         self.missing_decoders = []
 
-    def load_packet_header(self) -> np.uint32 | None:
+    def load_packet_header(self) -> np.ndarray | None:
         """Loads the packet header at the current read location into the buffer
 
         and updates internal variables.
         """
-        pkt_hdr = self.buffer[:1]
+        pkt_hdr = self.buffer[:2]
         n_bytes_read = self.in_stream.readinto(pkt_hdr)  # buffer is at least 4 kB long
         self.n_bytes_read += n_bytes_read
         if n_bytes_read == 0:  # EOF
             return None
-        if n_bytes_read != 4:
-            raise RuntimeError(f"only got {n_bytes_read} bytes for packet header")
+        if (n_bytes_read % 4) != 0:
+            raise RuntimeError(
+                f"got {n_bytes_read} bytes for packet header, expect 4 or 8."
+            )
+        if orca_packet.is_extended(pkt_hdr) and n_bytes_read < 8:
+            raise RuntimeError(
+                f"got {n_bytes_read} bytes for packet header, but require 8 for the extended header format."
+            )
+        if orca_packet.is_short(pkt_hdr) and n_bytes_read > 4:
+            # if more than 4 bytes were read but the packet is short, we reset the file stream
+            # so we can read the next uint32_t again. would not be necessary with a circular buffer
+            self.in_stream.seek(n_bytes_read - 4, 1)
 
         # packet is valid. Can set the packet_id and log its location
         self.packet_id += 1
@@ -90,7 +106,9 @@ class OrcaStreamer(DataStreamer):
             pkt_hdr = self.load_packet_header()
             if pkt_hdr is None:
                 return False
-            self.in_stream.seek((orca_packet.get_n_words(pkt_hdr) - 1) * 4, 1)
+            self.in_stream.seek(
+                (orca_packet.get_n_words(pkt_hdr) - len(pkt_hdr)) * 4, 1
+            )
             n -= 1
         return True
 
@@ -106,14 +124,14 @@ class OrcaStreamer(DataStreamer):
             self.in_stream.seek(loc)
             self.packet_id = pid
 
-    def count_packets(self, saveloc=True) -> None:
+    def count_packets(self, saveloc=True) -> int:
         self.build_packet_locs(saveloc=saveloc)
         return len(self.packet_locs)
 
     # TODO: need to correct for endianness?
     def load_packet(
         self, index: int = None, whence: int = 0, skip_unknown_ids: bool = False
-    ) -> np.uint32 | None:
+    ) -> np.ndarray | None:
         """Loads the next packet into the internal buffer.
 
         Returns packet as a :class:`numpy.uint32` view of the buffer (a slice),
@@ -177,15 +195,15 @@ class OrcaStreamer(DataStreamer):
             and orca_packet.get_data_id(pkt_hdr, shift=False)
             not in self.decoder_id_dict
         ):
-            self.in_stream.seek((n_words - 1) * 4, 1)
+            self.in_stream.seek((n_words - len(pkt_hdr)) * 4, 1)
             return pkt_hdr
 
         # load into buffer, resizing as necessary
         if len(self.buffer) < n_words:
             self.buffer.resize(n_words, refcheck=False)
-        n_bytes_read = self.in_stream.readinto(self.buffer[1:n_words])
+        n_bytes_read = self.in_stream.readinto(self.buffer[len(pkt_hdr) : n_words])
         self.n_bytes_read += n_bytes_read
-        if n_bytes_read != (n_words - 1) * 4:
+        if n_bytes_read != (n_words - len(pkt_hdr)) * 4:
             log.error(
                 f"only got {n_bytes_read} bytes for packet read when {(n_words-1)*4} were expected. Flushing all buffers and quitting..."
             )

daq2lh5/orca/skim_orca_file.py

@@ -0,0 +1,54 @@
+import argparse
+from pathlib import Path
+
+from .orca_streamer import OrcaStreamer
+
+
+def skim_orca_file() -> None:
+    parser = argparse.ArgumentParser(
+        prog="skim_orca_file",
+        description="Convert data into LEGEND HDF5 (LH5) raw format",
+    )
+    parser.add_argument("in_file", type=str, help="filename of orca file to skim")
+    parser.add_argument("n_packets", type=int, help="number of packets to skim")
+    parser.add_argument(
+        "--out-file", type=str, required=False, help="filename to write skimmed file to"
+    )
+    args = parser.parse_args()
+
+    if not Path(args.in_file).is_file():
+        print("file not found: {args.in_file}")  # noqa: T201
+        print(  # noqa: T201
+            "Usage: skim_orca_file [orca_file] [n_packets] (out_filename)"
+        )
+
+    elif args.n_packets == 0:
+        print("n_packets must be a positive integer")  # noqa: T201
+        print(  # noqa: T201
+            "Usage: skim_orca_file [orca_file] [n_packets] (out_filename)"
+        )
+    else:
+        if args.out_file:
+            out_filename = Path(args.out_file)
+        else:
+            out_filename = Path(f"{args.in_file}_first{args.n_packets}")
+        out_filename.parent.mkdir(parents=True, exist_ok=True)
+
+        or_streamer = OrcaStreamer()
+        or_streamer.open_stream(args.in_file)
+        header_packet = or_streamer.load_packet(0)
+
+        if out_filename.is_file():
+            out_filename.unlink()
+
+        with out_filename.open("ab") as out_file:
+            # always write header and first packet (run start)
+            header_packet.tofile(out_file)
+            packet = or_streamer.load_packet()
+            packet.tofile(out_file)
+            for _ in range(args.n_packets):
+                packet = or_streamer.load_packet()
+                packet.tofile(out_file)
+            # always write last packet (run end)
+            packet = or_streamer.load_packet(1, 2)
+            packet.tofile(out_file)