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

daq2lh5/llama/llama_header_decoder.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+import datetime
 import io
 import logging
+import os
+import re
 from typing import Any, Dict
 
 import lgdo
@@ -15,6 +18,25 @@ log = logging.getLogger(__name__)
 LLAMA_Channel_Configs_t = Dict[int, Dict[str, Any]]
 
 
+def parse_filename_for_timestamp(f_in_name: str) -> float:
+    """take a filename; return the unixtime parsed from the filename; 0 if impossible."""
+    filename = os.path.basename(f_in_name)
+    if match := re.fullmatch(r".*(\d{8})[-T](\d{6})(Z?).*", filename):
+        tsymd = match.group(1)
+        tshms = match.group(2)
+        utc: bool = True if match.group(3) == "Z" else False
+        when_file: datetime.datetime = datetime.datetime.strptime(
+            tsymd + tshms, "%Y%m%d%H%M%S"
+        )  # naive datetime object
+        if utc:
+            when_file = when_file.replace(
+                tzinfo=datetime.timezone.utc
+            )  # make it aware; UTC. Naive is treated as local
+        return when_file.timestamp()
+    else:
+        return 0
+
+
 class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
     """Decode llamaDAQ header data.
 
@@ -31,7 +53,7 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
         self.config = lgdo.Struct()
         self.channel_configs = None
 
-    def decode_header(self, f_in: io.BufferedReader) -> lgdo.Struct:
+    def decode_header(self, f_in: io.BufferedReader, f_in_name: str) -> lgdo.Struct:
         n_bytes_read = 0
 
         f_in.seek(0)  # should be there anyhow, but re-set if not
@@ -55,13 +77,21 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
         self.length_econf = evt_data_16[5]
         self.number_chOpen = evt_data_32[3]
 
+        self.global_configs = {}
+
+        # currently pulled from filename with 1s precision.
+        # change if we have it in the llamaDAQ file's header
+        self.global_configs["initial_timestamp"] = parse_filename_for_timestamp(
+            f_in_name
+        )
+        self.global_configs["initial_timestamp_accuracy"] = 1.0  # in seconds
+
         log.debug(
             f"File version: {self.version_major}.{self.version_minor}.{self.version_patch}"
         )
         log.debug(
             f"{self.number_chOpen} channels open, each config {self.length_econf} bytes long"
         )
-
         n_bytes_read += self.__decode_channel_configs(f_in)
 
         # print(self.channel_configs[0]["maw3_offset"])
@@ -72,6 +102,13 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
         self.config.add_field("version_patch", lgdo.Scalar(self.version_patch))
         self.config.add_field("length_econf", lgdo.Scalar(self.length_econf))
         self.config.add_field("number_chOpen", lgdo.Scalar(self.number_chOpen))
+        self.config.add_field(
+            "initial_timestamp", lgdo.Scalar(self.global_configs["initial_timestamp"])
+        )
+        self.config.add_field(
+            "initial_timestamp_accuracy",
+            lgdo.Scalar(self.global_configs["initial_timestamp_accuracy"]),
+        )
 
         for fch_id, fch_content in self.channel_configs.items():
             fch_lgdo = lgdo.Struct()
@@ -88,6 +125,9 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
     def get_channel_configs(self) -> LLAMA_Channel_Configs_t:
         return self.channel_configs
 
+    def get_global_configs(self) -> dict[str, Any]:
+        return self.global_configs
+
     def __decode_channel_configs(self, f_in: io.BufferedReader) -> int:
         """Reads the metadata.
 
@@ -110,7 +150,7 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
             # print("reading in channel config {}".format(i))
 
             channel = f_in.read(self.length_econf)
-            n_bytes_read += self.length_econf
+            n_bytes_read += int(self.length_econf)
             ch_dpf = channel[16:32]
             evt_data_32 = np.frombuffer(channel, dtype=np.uint32)
             evt_data_dpf = np.frombuffer(ch_dpf, dtype=np.float64)

daq2lh5/llama/llama_streamer.py

@@ -53,12 +53,15 @@ class LLAMAStreamer(DataStreamer):
         self.packet_id = 0
 
         # read header info here
-        header, n_bytes_hdr = self.header_decoder.decode_header(self.in_stream)
+        header, n_bytes_hdr = self.header_decoder.decode_header(
+            self.in_stream, llama_filename
+        )
         self.n_bytes_read += n_bytes_hdr
 
         self.event_decoder.set_channel_configs(
             self.header_decoder.get_channel_configs()
         )
+        self.event_decoder.set_global_configs(self.header_decoder.get_global_configs())
 
         # as far as I can tell, this happens if a user does not specify output.
         # Then I can still get a rb_lib, but that misses keys entirely, which I need since channels can have different setups.

daq2lh5/orca/orca_digitizers.py

@@ -295,7 +295,7 @@ class ORSIS3316WaveformDecoder(OrcaDecoder):
         key_lists = []
         for key in self.decoded_values.keys():
             key_lists.append([key])
-        return [key_lists]
+        return key_lists
 
     def get_decoded_values(self, key: int = None) -> dict[str, Any]:
         if key is None:

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"},
         }