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

daq2lh5/fc/fc_status_decoder.py

@@ -1,52 +1,145 @@
 from __future__ import annotations
 
-import fcutils
+import copy
+import logging
+from typing import Any
+
+import lgdo
+from fcio import FCIO
 
 from ..data_decoder import DataDecoder
-from ..raw_buffer import RawBuffer
+
+log = logging.getLogger(__name__)
+
+# status.data[i].reqid contains the card type in 0xff00 and the index within
+# a type group in 0xff
+# 0 is readout master
+# if bit 0x1000 is set: trigger card
+# if bit 0x2000 is set: adc card
+# if bit 0x4000 is set: submaster card
+
+fc_status_decoded_values = {
+    "packet_id": {"dtype": "uint32", "description": "Packet index in file."},
+    "status": {
+        "dtype": "bool",
+        "description": "True: Ok, False: Errors occurred, check card-wise status.",
+    },
+    "fpga_time": {
+        "dtype": "float32",
+        "units": "s",
+        "description": "The clock in the fpga of the highest-level card.",
+    },
+    "server_time": {
+        "dtype": "float64",
+        "units": "s",
+        "description": "The server time when the status was checked.",
+    },
+    "fpga_start_time": {
+        "dtype": "float64",
+        "units": "s",
+        "description": "The start time of the run.",
+    },
+    # FC card-wise list DAQ errors during data taking
+    "id": {
+        "dtype": "uint32",
+        "description": "The card id (reqid) when checking the status. Don't confuse with the card address.",
+    },
+    "eventnumber": {
+        "dtype": "uint32",
+        "description": "The eventcounter when the status was requested.",
+    },
+    "fpga_time_nsec": {
+        "dtype": "uint32",
+        "units": "ns",
+        "description": "The clock in the fpga of the highest-level card.",
+    },
+    "n_total_errors": {
+        "dtype": "uint32",
+        "description": "The sum of all error counter of all cards.",
+    },
+    "n_environment_errors": {
+        "dtype": "uint32",
+        "description": "The sum of all environment sensor errors.",
+    },
+    "n_cti_errors": {
+        "dtype": "uint32",
+        "description": "The sum of all CTI connection errors.",
+    },
+    "n_link_errors": {
+        "dtype": "uint32",
+        "description": "The sum of all trigger link errors.",
+    },
+    "n_other_errors": {
+        "dtype": "uint32",
+        "datatype": "array_of_equalsized_arrays<1,1>{real}",
+        "length": 5,
+        "description": "The sum of other errors.",
+    },
+    "mb_temps": {
+        "dtype": "int32",
+        "units": "mC",
+        "datatype": "array_of_equalsized_arrays<1,1>{real}",
+        "length": 5,
+        "description": "The temperatures measured by sensors on the motherboard.",
+    },
+    "mb_voltages": {
+        "dtype": "int32",
+        "units": "mV",
+        "datatype": "array_of_equalsized_arrays<1,1>{real}",
+        "length": 6,
+        "description": "The supply voltages of the motherboard.",
+    },
+    "mb_current": {
+        "dtype": "int32",
+        "units": "mA",
+        "description": "The current draw of the motherboard.",
+    },
+    "mb_humidity": {
+        "dtype": "int32",
+        "units": "o/oo",
+        "description": "The humidity in permille measured on the motherboard.",
+    },
+    "adc_temps": {
+        "dtype": "int32",
+        "units": "mC",
+        "datatype": "array<1>{array<1>{real}}",
+        "length_guess": 2,  # max number of daughter cards - only for adc cards
+        "description": "If the card has adc daughter (piggy) boards mounted, each daughter has a temperature sensor.",
+    },
+    "cti_links": {
+        "dtype": "uint32",
+        "datatype": "array<1>{array<1>{real}}",  # vector of vectors
+        "length_guess": 4,
+        "description": "CTI debugging values, for experts only.",
+    },
+    "link_states": {
+        "dtype": "uint32",
+        "datatype": "array<1>{array<1>{real}}",  # vector of vectors
+        "length_guess": 256,  # 256*max number of boards
+        "description": "Trigger link debugging values, for experts only.",
+    },
+}
+
+
+def get_key(streamid, reqid):
+    return (streamid & 0xFFFF) * 1000000 + (reqid & 0xFFFF)
+
+
+def get_fcid(key: int) -> int:
+    return int(key // 10000000)
+
+
+def get_reqid(key: int) -> int:
+    return int(key % 1000000)
 
 
 class FCStatusDecoder(DataDecoder):
     """Decode FlashCam digitizer status data."""
 
     def __init__(self, *args, **kwargs) -> None:
-        self.decoded_values = {
-            # 0: Errors occurred, 1: no errors
-            "status": {"dtype": "int32"},
-            # fc250 seconds, microseconds, dummy, startsec startusec
-            "statustime": {"dtype": "float32", "units": "s"},
-            # CPU seconds, microseconds, dummy, startsec startusec
-            "cputime": {"dtype": "float64", "units": "s"},
-            # fc250 seconds, microseconds, dummy, startsec startusec
-            "startoffset": {"dtype": "float32", "units": "s"},
-            # Total number of cards (number of status data to follow)
-            "cards": {"dtype": "int32"},
-            # Size of each status data
-            "size": {"dtype": "int32"},
-            # FC card-wise environment status
-            "environment": {
-                # Array contents:
-                # [0-4] Temps in mDeg
-                # [5-10] Voltages in mV
-                # 11 main current in mA
-                # 12 humidity in o/oo
-                # [13-14] Temps from adc cards in mDeg
-                # FIXME: change to a table?
-                "dtype": "uint32",
-                "datatype": "array_of_equalsized_arrays<1,1>{real}",
-                "length": 16,
-            },
-            # FC card-wise list DAQ errors during data taking
-            "totalerrors": {"dtype": "uint32"},
-            "enverrors": {"dtype": "uint32"},
-            "ctierrors": {"dtype": "uint32"},
-            "linkerrors": {"dtype": "uint32"},
-            "othererrors": {
-                "dtype": "uint32",
-                "datatype": "array_of_equalsized_arrays<1,1>{real}",
-                "length": 5,
-            },
-        }
+        self.key_list = []
+        self.max_rows_in_packet = 0
+        self.decoded_values = copy.deepcopy(fc_status_decoded_values)
         """Default FlashCam status decoded values.
 
         Warning
@@ -55,37 +148,112 @@ class FCStatusDecoder(DataDecoder):
         """
         super().__init__(*args, **kwargs)
 
+    def set_fcio_stream(self, fcio_stream: FCIO) -> None:
+        """Access ``FCIOConfig`` members once when each file is opened.
+
+        Parameters
+        ----------
+        fcio_stream
+            extracted via :meth:`~.fc_config_decoder.FCConfigDecoder.decode_config`.
+        """
+
+        n_cards = (
+            fcio_stream.config.mastercards
+            + fcio_stream.config.triggercards
+            + fcio_stream.config.adccards
+        )
+        self.max_rows_in_packet = n_cards
+
+        # the number of master cards is the sum of top and sub masters,
+        # if there is more than one, the first is the top master
+        # the rest is a sub master card.
+        for i in range(fcio_stream.config.mastercards):
+            if i == 0:
+                key = get_key(fcio_stream.config.streamid, 0)
+            else:
+                key = get_key(fcio_stream.config.streamid, 0x4000 + i - 1)
+            self.key_list.append(key)
+
+        for i in range(fcio_stream.config.triggercards):
+            key = get_key(fcio_stream.config.streamid, 0x1000 + i)
+            self.key_list.append(key)
+
+        for i in range(fcio_stream.config.adccards):
+            key = get_key(fcio_stream.config.streamid, 0x2000 + i)
+            self.key_list.append(key)
+
+    def get_key_lists(self) -> list[list[int | str]]:
+        return [copy.deepcopy(self.key_list)]
+
+    def get_decoded_values(self, key: int | str = None) -> dict[str, dict[str, Any]]:
+        # FC uses the same values for all channels
+        return self.decoded_values
+
+    def get_max_rows_in_packet(self) -> int:
+        return self.max_rows_in_packet
+
     def decode_packet(
-        self, fcio: fcutils.fcio, status_rb: RawBuffer, packet_id: int
+        self,
+        fcio: FCIO,
+        status_rbkd: lgdo.Table | dict[int, lgdo.Table],
+        packet_id: int,
     ) -> bool:
-        # aliases for brevity
-        tbl = status_rb.lgdo
-        ii = status_rb.loc
+        """Access ``FCIOStatus`` members for each status packet in the DAQ file.
 
-        # status -- 0: Errors occurred, 1: no errors
-        tbl["status"].nda[ii] = fcio.status
+        Parameters
+        ----------
+        fcio
+            The interface to the ``fcio`` data. Enters this function after a
+            call to ``fcio.get_record()`` so that data for `packet_id` ready to
+            be read out.
+        status_rbkd
+            A single table for reading out all data, or a dictionary of tables
+            keyed by card number.
+        packet_id
+            The index of the packet in the `fcio` stream. Incremented by
+            :class:`~.fc.fc_streamer.FCStreamer`.
 
-        # times
-        tbl["statustime"].nda[ii] = fcio.statustime[0] + fcio.statustime[1] / 1e6
-        tbl["cputime"].nda[ii] = fcio.statustime[2] + fcio.statustime[3] / 1e6
-        tbl["startoffset"].nda[ii] = fcio.statustime[5] + fcio.statustime[6] / 1e6
+        Returns
+        -------
+        any_full
+            TODO
+        """
+        any_full = False
+        for card_data in fcio.status.data:
+            key = get_key(fcio.config.streamid, card_data.reqid)
+            if key not in status_rbkd:
+                continue
 
-        # Total number of cards (number of status data to follow)
-        tbl["cards"].nda[ii] = fcio.cards
+            tbl = status_rbkd[key].lgdo
+            loc = status_rbkd[key].loc
 
-        # Size of each status data
-        tbl["size"].nda[ii] = fcio.size
+            tbl["packet_id"].nda[loc] = packet_id
+            tbl["status"].nda[loc] = fcio.status.status
 
-        # FC card-wise environment status (temp., volt., hum., ...)
-        tbl["environment"].nda[ii][:] = fcio.environment
+            # times
+            tbl["fpga_time"].nda[loc] = fcio.status.fpga_time_sec
+            tbl["server_time"].nda[loc] = fcio.status.unix_time_utc_sec
+            tbl["fpga_start_time"].nda[loc] = fcio.status.fpga_start_time_sec
 
-        # FC card-wise list DAQ errors during data taking
-        tbl["totalerrors"].nda[ii] = fcio.totalerrors
-        tbl["linkerrors"].nda[ii] = fcio.linkerrors
-        tbl["ctierrors"].nda[ii] = fcio.ctierrors
-        tbl["enverrors"].nda[ii] = fcio.enverrors
-        tbl["othererrors"].nda[ii][:] = fcio.othererrors
+            # per card information
+            tbl["id"].nda[loc] = card_data.reqid
+            tbl["eventnumber"].nda[loc] = card_data.eventno
+            tbl["fpga_time_nsec"].nda[loc] = card_data.fpga_time_nsec
+            tbl["n_total_errors"].nda[loc] = card_data.totalerrors
+            tbl["n_environment_errors"].nda[loc] = card_data.enverrors
+            tbl["n_cti_errors"].nda[loc] = card_data.ctierrors
+            tbl["n_other_errors"].nda[loc][:] = card_data.othererrors
+            tbl["mb_temps"].nda[loc][:] = card_data.mainboard_temperatures_mC
+            tbl["mb_voltages"].nda[loc][:] = card_data.mainboard_voltages_mV
+            tbl["mb_current"].nda[loc] = card_data.mainboard_current_mA
+            tbl["mb_humidity"].nda[loc] = card_data.mainboard_humiditiy_permille
+            tbl["adc_temps"]._set_vector_unsafe(
+                loc, card_data.daughterboard_temperatures_mC
+            )
+            tbl["cti_links"]._set_vector_unsafe(loc, card_data.ctilinks)
+            tbl["link_states"]._set_vector_unsafe(loc, card_data.linkstates)
 
-        status_rb.loc += 1
+            status_rbkd[key].loc += 1
+            any_full |= status_rbkd[key].is_full()
 
-        return status_rb.loc >= len(tbl)
+        return bool(any_full)

daq2lh5/fc/fc_streamer.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 import logging
 
-import fcutils
+import lgdo
+from fcio import FCIO, Tags
 
 from ..data_decoder import DataDecoder
 from ..data_streamer import DataStreamer
 from ..raw_buffer import RawBuffer, RawBufferLibrary
 from .fc_config_decoder import FCConfigDecoder
 from .fc_event_decoder import FCEventDecoder
+from .fc_eventheader_decoder import FCEventHeaderDecoder
+from .fc_fsp_decoder import FSPConfigDecoder, FSPEventDecoder, FSPStatusDecoder
 from .fc_status_decoder import FCStatusDecoder
 
 log = logging.getLogger(__name__)
@@ -16,30 +19,49 @@ log = logging.getLogger(__name__)
 
 class FCStreamer(DataStreamer):
     """
-    Decode FlashCam data, using the ``fcutils`` package to handle file access,
+    Decode FlashCam data, using the ``fcio`` package to handle file access,
     and the FlashCam data decoders to save the results and write to output.
     """
 
     def __init__(self) -> None:
         super().__init__()
-        self.fcio = None
+        self.fcio = FCIO()
         self.config_decoder = FCConfigDecoder()
         self.status_decoder = FCStatusDecoder()
         self.event_decoder = FCEventDecoder()
-        self.event_tables = {}
+        self.eventheader_decoder = FCEventHeaderDecoder()
+
+        self.fsp_config_decoder = FSPConfigDecoder()
+        self.fsp_event_decoder = FSPEventDecoder()
+        self.fsp_status_decoder = FSPStatusDecoder()
+
         self.event_rbkd = None
-        self.status_rb = None
+        self.eventheader_rbkd = None
+        self.status_rbkd = None
+
+        self.fsp_config_rbkd = None
+        self.fsp_event_rbkd = None
+        self.fsp_status_rbkd = None
+
+        self.fcio_bytes_read = 0
+        self.fcio_bytes_skipped = 0
 
     def get_decoder_list(self) -> list[DataDecoder]:
         dec_list = []
         dec_list.append(self.config_decoder)
         dec_list.append(self.status_decoder)
         dec_list.append(self.event_decoder)
+        dec_list.append(self.eventheader_decoder)
+
+        dec_list.append(self.fsp_config_decoder)
+        dec_list.append(self.fsp_event_decoder)
+        dec_list.append(self.fsp_status_decoder)
+
         return dec_list
 
     def open_stream(
         self,
-        fcio_filename: str,
+        fcio_peer: str,
         rb_lib: RawBufferLibrary = None,
         buffer_size: int = 8192,
         chunk_mode: str = "any_full",
@@ -54,22 +76,28 @@ class FCStreamer(DataStreamer):
         Returns
         -------
         header_data
-            a list of length 1 containing the raw buffer holding the
-            :class:`~.fc_config_decoder.FCConfig` table.
+            a list of length 2 containing the raw buffer holding the
+            :class:`~.fc_config_decoder.FCConfig` table and
+            optionally the :class:`~.fsp_decoder.FSPConfig` table.
         """
-        self.fcio = fcutils.fcio(fcio_filename)
-        self.n_bytes_read = 0
+        self.fcio.open(fcio_peer)  # using defaults
+        self.n_bytes_read = self.fcio.read_bytes() + self.fcio.skipped_bytes()
+
+        # read in file header (config) info, returns an lgdo.Struct
+        fc_config = self.config_decoder.decode_config(self.fcio)
+        config_lgdos = [fc_config]
+        if self.fcio.fsp:
+            config_lgdos.append(self.fsp_config_decoder.decode_config(self.fcio))
 
-        # read in file header (config) info
-        fc_config = self.config_decoder.decode_config(
-            self.fcio
-        )  # returns an lgdo.Struct
-        self.event_decoder.set_file_config(fc_config)
-        self.n_bytes_read += 11 * 4  # there are 11 ints in the fcio_config struct
+        self.status_decoder.set_fcio_stream(self.fcio)
+        self.event_decoder.set_fcio_stream(self.fcio)
+        self.eventheader_decoder.set_fcio_stream(self.fcio)
+        self.fsp_event_decoder.set_fcio_stream(self.fcio)
+        self.fsp_status_decoder.set_fcio_stream(self.fcio)
 
         # initialize the buffers in rb_lib. Store them for fast lookup
         super().open_stream(
-            fcio_filename,
+            fcio_peer,
             rb_lib,
             buffer_size=buffer_size,
             chunk_mode=chunk_mode,
@@ -78,91 +106,140 @@ class FCStreamer(DataStreamer):
         if rb_lib is None:
             rb_lib = self.rb_lib
 
-        # get the status rb_list and pull out its first element
-        status_rb_list = (
-            rb_lib["FCStatusDecoder"] if "FCStatusDecoder" in rb_lib else None
+        # event and status allow offer key_lists
+        self.status_rbkd = (
+            rb_lib["FCStatusDecoder"].get_keyed_dict()
+            if "FCStatusDecoder" in rb_lib
+            else None
         )
-        if status_rb_list is not None:
-            if len(status_rb_list) != 1:
-                log.warning(
-                    f"status_rb_list had length {len(status_rb_list)}, ignoring all but the first"
-                )
-            if len(status_rb_list) == 0:
-                self.status_rb = None
-            else:
-                self.status_rb = status_rb_list[0]
+
         self.event_rbkd = (
             rb_lib["FCEventDecoder"].get_keyed_dict()
             if "FCEventDecoder" in rb_lib
             else None
         )
 
+        self.eventheader_rbkd = (
+            rb_lib["FCEventHeaderDecoder"].get_keyed_dict()
+            if "FCEventHeaderDecoder" in rb_lib
+            else None
+        )
+
+        self.fsp_event_rbkd = (
+            rb_lib["FSPEventDecoder"].get_keyed_dict()
+            if "FSPEventDecoder" in rb_lib
+            else None
+        )
+
+        self.fsp_status_rbkd = (
+            rb_lib["FSPStatusDecoder"].get_keyed_dict()
+            if "FSPStatusDecoder" in rb_lib
+            else None
+        )
         # set up data loop variables
         self.packet_id = 0  # for storing packet order in output tables
 
-        if "FCConfigDecoder" in rb_lib:
-            config_rb_list = rb_lib["FCConfigDecoder"]
-            if len(config_rb_list) != 1:
-                log.warning(
-                    f"config_rb_list had length {len(config_rb_list)}, ignoring all but the first"
+        rbs = []
+        for config_decoder, config_lgdo in zip(
+            ["FCConfigDecoder", "FSPConfigDecoder"], config_lgdos
+        ):
+            if config_decoder in rb_lib:
+                config_rb_list = rb_lib[config_decoder]
+                if len(config_rb_list) != 1:
+                    log.warning(
+                        f"config_rb_list for {config_decoder} had length {len(config_rb_list)}, "
+                        "ignoring all but the first"
+                    )
+                rb = config_rb_list[0]
+            else:
+                rb = RawBuffer(lgdo=config_lgdo)
+
+            # TODO: not clear if this workaround is needed, or a bug:
+            # It seems like the `loc` of the RawBuffer is used as `len`
+            # for individual elements in a `lgdo.Struct` while writing.
+            # Search for longest and use as `loc` attr.
+            if isinstance(config_lgdo, lgdo.Struct):
+                max_length = max(
+                    [
+                        len(entry) if hasattr(entry, "__len__") else 1
+                        for entry in config_lgdo.values()
+                    ]
                 )
-            rb = config_rb_list[0]
-        else:
-            rb = RawBuffer(lgdo=fc_config)
-        rb.loc = 1  # we have filled this buffer
-        return [rb]
+                rb.loc = max_length
+            rbs.append(rb)
+        return rbs
 
     def close_stream(self) -> None:
-        self.fcio = None  # should cause close file in fcio.__dealloc__
+        self.fcio.close()
 
     def read_packet(self) -> bool:
-        rc = self.fcio.get_record()
-        if rc == 0:
-            return False  # no more data
-
-        self.packet_id += 1
 
-        if rc == 1:  # config (header) data
-            log.warning(
-                f"got a header after start of run? n_bytes_read = {self.n_bytes_read}"
-            )
-            self.n_bytes_read += 11 * 4  # there are 11 ints in the fcio_config struct
-            return True
+        if not self.fcio.get_record():
+            return False  # no more data
 
-        elif rc == 2:  # calib record -- no longer supported
-            log.warning(
-                f"warning: got a calib record? n_bytes_read = {self.n_bytes_read}"
-            )
-            return True
+        # The fcio stream processor (FSP) prepends records to the corresponding
+        # FCIO records. The fcio library parses these separate records,
+        # which requires an additional call to get_record().
+        # Both records are treated as one packet, so their packet_id is shared.
+        if self.fcio.tag in [Tags.FSPConfig, Tags.FSPEvent, Tags.FSPStatus]:
+            if not self.fcio.get_record():
+                self.n_bytes_read = self.fcio.read_bytes() + self.fcio.skipped_bytes()
+                log.error(
+                    f"FCIO stream ended early with a {Tags.str(self.fcio.tag)} and n_bytes_read = {self.n_bytes_read}"
+                )
+                return False
 
-        # FIXME: push to a buffer of skipped packets?
-        # FIXME: need to at least update n_bytes?
-        elif rc == 5:  # recevent
+        self.packet_id += 1
+        # records or fields in records unknown to fcio are read but not parsed,
+        # and tracked in skipped_bytes
+        self.n_bytes_read = self.fcio.read_bytes() + self.fcio.skipped_bytes()
+
+        # FCIOConfigs contains header data (lengths) required to access
+        # (Sparse)Event(Header) records.
+        # The protocol allows updates of these settings within a datastream.
+        # Concatenating of FCIO streams is supported here only if the FCIOConfig
+        # is the same.
+        if self.fcio.tag == Tags.Config or self.fcio.tag == Tags.FSPConfig:
             log.warning(
-                f"got a RecEvent packet -- skipping? n_bytes_read = {self.n_bytes_read}"
+                f"got an {Tags.str(self.fcio.tag)} after start of run? "
+                f"n_bytes_read = {self.n_bytes_read}"
             )
-            # sizeof(fcio_recevent): (6 + 3*10 + 1*2304 + 3*4000)*4
-            self.n_bytes_read += 57360
-            return True
 
-        # Status record
-        elif rc == 4:
-            if self.status_rb is not None:
+        elif self.fcio.tag == Tags.Status:
+            if self.status_rbkd is not None:
                 self.any_full |= self.status_decoder.decode_packet(
-                    self.fcio, self.status_rb, self.packet_id
+                    self.fcio, self.status_rbkd, self.packet_id
+                )
+            if self.fcio.fsp and self.fsp_status_rbkd is not None:
+                self.any_full |= self.fsp_status_decoder.decode_packet(
+                    self.fcio, self.fsp_status_rbkd, self.packet_id
                 )
-            # sizeof(fcio_status): (3 + 10 + 256*(10 + 9 + 16 + 4 + 256))*4
-            self.n_bytes_read += 302132
-            return True
 
-        # Event or SparseEvent record
-        elif rc == 3 or rc == 6:
+        elif self.fcio.tag == Tags.Event or self.fcio.tag == Tags.SparseEvent:
             if self.event_rbkd is not None:
                 self.any_full |= self.event_decoder.decode_packet(
                     self.fcio, self.event_rbkd, self.packet_id
                 )
-            # sizeof(fcio_event): (5 + 3*10 + 1)*4 + numtraces*(1 + nsamples+2)*2
-            self.n_bytes_read += (
-                144 + self.fcio.numtraces * (self.fcio.nsamples + 3) * 2
+            if self.fcio.fsp and self.fsp_event_rbkd is not None:
+                self.any_full |= self.fsp_event_decoder.decode_packet(
+                    self.fcio, self.fsp_event_rbkd, self.packet_id, False
+                )
+
+        elif self.fcio.tag == Tags.EventHeader:
+            if self.eventheader_rbkd is not None:
+                self.any_full |= self.eventheader_decoder.decode_packet(
+                    self.fcio, self.eventheader_rbkd, self.packet_id
+                )
+            if self.fcio.fsp and self.fsp_event_rbkd is not None:
+                self.any_full |= self.fsp_event_decoder.decode_packet(
+                    self.fcio, self.fsp_event_rbkd, self.packet_id, True
+                )
+
+        # FIXME: push to a buffer of skipped packets?
+        else:  # unknown record
+            log.warning(
+                f"skipping unsupported record {Tags.str(self.fcio.tag)}. "
+                f"n_bytes_read = {self.n_bytes_read}"
             )
-            return True
+
+        return True

daq2lh5/llama/llama_header_decoder.py

@@ -92,7 +92,6 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
         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"])
@@ -151,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/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: