Line data    Source code

       1              : /**
       2              :  * @file tdeeth.cpp Python bindings for the TDEEthFrame format
       3              :  *
       4              :  * This is part of the DUNE DAQ Software Suite, copyright 2020.
       5              :  * Licensing/copyright details are in the COPYING file that you should have
       6              :  * received with this code.
       7              :  */
       8              : 
       9              : #include "fddetdataformats/TDEEthFrame.hpp"
      10              : 
      11              : #include <pybind11/pybind11.h>
      12              : #include <pybind11/stl.h>
      13              : 
      14              : namespace py = pybind11;
      15              : 
      16              : namespace dunedaq::fddetdataformats::python {
      17              : 
      18              : // NOLINTBEGIN(build/unsigned)
      19              :   
      20              : void
      21            0 : register_tdeeth(py::module& m)
      22              : {
      23            0 :   py::class_<TDEEthFrame::TDEEthHeader>(m, "TDEEthHeader")
      24            0 :     .def_property(
      25              :       "channel",
      26            0 :       [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.channel; },
      27            0 :       [](TDEEthFrame::TDEEthHeader& self, uint16_t channel) { self.channel = channel; })
      28            0 :     .def_property(
      29              :       "version",
      30            0 :       [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.version; },
      31            0 :       [](TDEEthFrame::TDEEthHeader& self, uint16_t version) { self.version = version; })
      32            0 :     .def_property(
      33              :       "tde_header",
      34            0 :       [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.tde_header; },
      35            0 :       [](TDEEthFrame::TDEEthHeader& self, uint16_t tde_header) { self.tde_header = tde_header; })
      36            0 :     .def_property(
      37              :       "tde_errors",
      38            0 :       [](TDEEthFrame::TDEEthHeader& self) -> uint16_t { return self.tde_errors; },
      39            0 :       [](TDEEthFrame::TDEEthHeader& self, uint16_t tde_errors) { self.tde_errors = tde_errors; })
      40            0 :     .def_property(
      41              :       "TAItime",
      42            0 :       [](TDEEthFrame::TDEEthHeader& self) -> uint64_t { return self.TAItime; },
      43            0 :       [](TDEEthFrame::TDEEthHeader& self, uint64_t TAItime) { self.TAItime = TAItime; })
      44            0 :     .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) {
      45              :       return TDEEthFrame::TDEEthHeader::s_expected_bytes;
      46              :     });
      47              : 
      48            0 :   py::class_<TDEEthFrame>(m, "TDEEthFrame", py::buffer_protocol())
      49            0 :     .def(py::init())
      50            0 :     .def(py::init([](py::capsule capsule) {
      51            0 :       auto tfp = *static_cast<TDEEthFrame*>(capsule.get_pointer());
      52            0 :       return tfp;
      53              :     }))
      54            0 :     .def(py::init([](py::bytes bytes) {
      55            0 :       py::buffer_info info(py::buffer(bytes).request());
      56            0 :       auto tfp = *static_cast<TDEEthFrame*>(info.ptr);
      57            0 :       return tfp;
      58            0 :     }))
      59            0 :     .def(
      60              :       "get_daqheader",
      61            0 :       [](TDEEthFrame& self) -> const detdataformats::DAQEthHeader& { return self.daq_header; },
      62            0 :       py::return_value_policy::reference_internal)
      63            0 :     .def(
      64              :       "get_tdeheader",
      65            0 :       [](TDEEthFrame& self) -> const TDEEthFrame::TDEEthHeader& { return self.header; },
      66            0 :       py::return_value_policy::reference_internal)
      67            0 :     .def_property_readonly(
      68              :       "daq_header",
      69            0 :       [](TDEEthFrame& self) -> detdataformats::DAQEthHeader& { return self.daq_header; },
      70            0 :       py::return_value_policy::reference_internal)
      71            0 :     .def_property_readonly(
      72              :       "header",
      73            0 :       [](TDEEthFrame& self) -> TDEEthFrame::TDEEthHeader& { return self.header; },
      74            0 :       py::return_value_policy::reference_internal)
      75            0 :     .def("get_adc", &TDEEthFrame::get_adc)
      76            0 :     .def("set_adc", &TDEEthFrame::set_adc)
      77            0 :     .def("get_timestamp", &TDEEthFrame::get_timestamp)
      78            0 :     .def("set_timestamp", &TDEEthFrame::set_timestamp)
      79            0 :     .def("get_channel", &TDEEthFrame::get_channel)
      80            0 :     .def("set_channel", &TDEEthFrame::set_channel)
      81            0 :     .def("__lt__", [](const TDEEthFrame& lhs, const TDEEthFrame& rhs) { return lhs < rhs; })
      82            0 :     .def_property_readonly_static("s_bits_per_adc", [](py::object /*self*/) {
      83              :       return TDEEthFrame::s_bits_per_adc;
      84              :     })
      85            0 :     .def_property_readonly_static("s_bits_per_word", [](py::object /*self*/) {
      86              :       return TDEEthFrame::s_bits_per_word;
      87              :     })
      88            0 :     .def_property_readonly_static("s_time_samples_per_frame", [](py::object /*self*/) {
      89              :       return TDEEthFrame::s_time_samples_per_frame;
      90              :     })
      91            0 :     .def_property_readonly_static("s_channels_per_half_femb", [](py::object /*self*/) {
      92              :       return TDEEthFrame::s_channels_per_half_femb;
      93              :     })
      94            0 :     .def_property_readonly_static("s_half_fembs_per_frame", [](py::object /*self*/) {
      95              :       return TDEEthFrame::s_half_fembs_per_frame;
      96              :     })
      97            0 :     .def_property_readonly_static("s_num_channels", [](py::object /*self*/) {
      98              :       return TDEEthFrame::s_num_channels;
      99              :     })
     100            0 :     .def_property_readonly_static("s_num_adc_words_per_ts", [](py::object /*self*/) {
     101              :       return TDEEthFrame::s_num_adc_words_per_ts;
     102              :     })
     103            0 :     .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) {
     104              :       return TDEEthFrame::s_expected_bytes;
     105              :     })
     106            0 :     .def_static("sizeof", []() { return sizeof(TDEEthFrame); })
     107            0 :     .def("get_bytes", [](TDEEthFrame* fr) -> py::bytes {
     108            0 :       return py::bytes(reinterpret_cast<char*>(fr), sizeof(TDEEthFrame)); // NOLINT reinterpret_cast
     109              :     });
     110            0 : } // NOLINT (defensible use of "overly long" function)
     111              : 
     112              : // NOLINTEND(build/unsigned)
     113              : 
     114              : } // namespace dunedaq::fddetdataformats::python