Line data    Source code

       1              : /**
       2              :  * @file daphnestream.cpp Python bindings for the DAPHNEStreamFrame 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/DAPHNEStreamFrame.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_daphnestream(py::module& m)
      22              : {
      23              : 
      24            0 :   py::class_<DAPHNEStreamFrame::Header>(m, "DAPHNEStreamHeader")
      25            0 :     .def_property(
      26              :       "channel_0",
      27            0 :       [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_0; },
      28            0 :       [](DAPHNEStreamFrame::Header& self, uint32_t channel_0) { self.channel_0 = channel_0; })
      29            0 :     .def_property(
      30              :       "channel_1",
      31            0 :       [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_1; },
      32            0 :       [](DAPHNEStreamFrame::Header& self, uint32_t channel_1) { self.channel_1 = channel_1; })
      33            0 :     .def_property(
      34              :       "channel_2",
      35            0 :       [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_2; },
      36            0 :       [](DAPHNEStreamFrame::Header& self, uint32_t channel_2) { self.channel_2 = channel_2; })
      37            0 :     .def_property(
      38              :       "channel_3",
      39            0 :       [](DAPHNEStreamFrame::Header& self) -> uint32_t { return self.channel_3; },
      40            0 :       [](DAPHNEStreamFrame::Header& self, uint32_t channel_3) { self.channel_3 = channel_3; })
      41            0 :     .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) {
      42              :       return sizeof(DAPHNEStreamFrame::Header);
      43              :     });
      44              : 
      45            0 :   py::class_<DAPHNEStreamFrame>(m, "DAPHNEStreamFrame", py::buffer_protocol())
      46            0 :     .def(py::init())
      47            0 :     .def(py::init([](py::capsule capsule) {
      48            0 :       auto wfp = *static_cast<DAPHNEStreamFrame*>(capsule.get_pointer());
      49            0 :       return wfp;
      50              :     }))
      51            0 :     .def(py::init([](py::bytes bytes) {
      52            0 :       py::buffer_info info(py::buffer(bytes).request());
      53            0 :       auto wfp = *static_cast<DAPHNEStreamFrame*>(info.ptr);
      54            0 :       return wfp;
      55            0 :     }))
      56            0 :     .def_property_readonly(
      57              :       "daq_header",
      58            0 :       [](DAPHNEStreamFrame& self) -> detdataformats::DAQHeader& { return self.daq_header; },
      59            0 :       py::return_value_policy::reference_internal)
      60            0 :     .def_property_readonly(
      61              :       "header",
      62            0 :       [](DAPHNEStreamFrame& self) -> DAPHNEStreamFrame::Header& { return self.header; },
      63            0 :       py::return_value_policy::reference_internal)
      64            0 :     .def("get_timestamp", &DAPHNEStreamFrame::get_timestamp)
      65            0 :     .def("set_timestamp", &DAPHNEStreamFrame::set_timestamp)
      66            0 :     .def("get_adc", &DAPHNEStreamFrame::get_adc)
      67            0 :     .def("set_adc", &DAPHNEStreamFrame::set_adc)
      68            0 :     .def("__lt__", [](const DAPHNEStreamFrame& lhs, const DAPHNEStreamFrame& rhs) { return lhs < rhs; })
      69            0 :     .def_property_readonly_static("s_bits_per_adc", [](py::object /*self*/) {
      70              :       return DAPHNEStreamFrame::s_bits_per_adc;
      71              :     })
      72            0 :     .def_property_readonly_static("s_bits_per_word", [](py::object /*self*/) {
      73              :       return DAPHNEStreamFrame::s_bits_per_word;
      74              :     })
      75            0 :     .def_property_readonly_static("s_channels_per_frame", [](py::object /*self*/) {
      76              :       return DAPHNEStreamFrame::s_channels_per_frame;
      77              :     })
      78            0 :     .def_property_readonly_static("s_adcs_per_channel", [](py::object /*self*/) {
      79              :       return DAPHNEStreamFrame::s_adcs_per_channel;
      80              :     })
      81            0 :     .def_property_readonly_static("s_daphnes_per_frame", [](py::object /*self*/) {
      82              :       return DAPHNEStreamFrame::s_daphnes_per_frame;
      83              :     })
      84            0 :     .def_property_readonly_static("s_num_adc_words", [](py::object /*self*/) {
      85              :       return DAPHNEStreamFrame::s_num_adc_words;
      86              :     })
      87            0 :     .def_property_readonly_static("s_expected_bytes", [](py::object /*self*/) {
      88              :       return DAPHNEStreamFrame::s_expected_bytes;
      89              :     })
      90            0 :     .def("get_channel0", &DAPHNEStreamFrame::get_channel0)
      91            0 :     .def("get_channel1", &DAPHNEStreamFrame::get_channel1)
      92            0 :     .def("get_channel2", &DAPHNEStreamFrame::get_channel2)
      93            0 :     .def("get_channel3", &DAPHNEStreamFrame::get_channel3)
      94            0 :     .def_static("sizeof", []() { return sizeof(DAPHNEStreamFrame); })
      95            0 :     .def("get_bytes", [](DAPHNEStreamFrame* fr) -> py::bytes {
      96            0 :       return py::bytes(reinterpret_cast<char*>(fr), sizeof(DAPHNEStreamFrame)); // NOLINT
      97              :     });
      98            0 : }
      99              : 
     100              : // NOLINTEND(build/unsigned)
     101              : 
     102              : } // namespace dunedaq::fddetdataformats::python