Line data    Source code

       1              : /**
       2              :  * @file fragment.cpp
       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 "daqdataformats/Fragment.hpp"
      10              : #include "daqdataformats/FragmentHeader.hpp"
      11              : 
      12              : #include <pybind11/pybind11.h>
      13              : #include <pybind11/stl.h>
      14              : 
      15              : namespace py = pybind11;
      16              : using namespace pybind11::literals; // to bring in the `_a` literal
      17              : 
      18              : namespace dunedaq {
      19              : namespace daqdataformats {
      20              : namespace python {
      21              : 
      22              : void
      23            0 : register_fragment(py::module& m)
      24              : {
      25              : 
      26            0 :   py::class_<Fragment> py_fragment(m, "Fragment", py::buffer_protocol());
      27              : 
      28            0 :   py_fragment.def("get_header", &Fragment::get_header, py::return_value_policy::reference_internal)
      29            0 :     .def("get_storage_location", &Fragment::get_storage_location, py::return_value_policy::reference_internal)
      30            0 :     .def("get_trigger_number", &Fragment::get_trigger_number)
      31            0 :     .def("get_run_number", &Fragment::get_run_number)
      32            0 :     .def("get_trigger_timestamp", &Fragment::get_trigger_timestamp)
      33            0 :     .def("get_window_begin", &Fragment::get_window_begin)
      34            0 :     .def("get_window_end", &Fragment::get_window_end)
      35            0 :     .def("get_element_id", &Fragment::get_element_id)
      36            0 :     .def("get_detector_id", &Fragment::get_detector_id)
      37            0 :     .def("get_error_bits", [](Fragment& self) { return self.get_error_bits().to_ullong(); } )
      38            0 :     .def("get_error_bit", &Fragment::get_error_bit)
      39            0 :     .def("get_fragment_type_code", &Fragment::get_fragment_type_code)
      40            0 :     .def("get_fragment_type", &Fragment::get_fragment_type)
      41            0 :     .def("get_sequence_number", &Fragment::get_sequence_number)
      42            0 :     .def("get_size", &Fragment::get_size)
      43            0 :     .def("get_data_size", &Fragment::get_data_size)
      44            0 :     .def(
      45            0 :       "get_data", [](Fragment& self, size_t offset) { return static_cast<void*>(static_cast<char*>(self.get_data()) + offset); }, "offset"_a = 0, py::return_value_policy::reference_internal)
      46            0 :     .def(
      47              :       "get_data_bytes",
      48            0 :       [](Fragment* self, size_t offset) -> py::bytes {
      49            0 :         if (offset > self->get_data_size()) {
      50            0 :           throw std::runtime_error("Fragment.get_data_bytes: offset exceeds fragment size.");
      51              :         }
      52            0 :         size_t bytes_size = self->get_data_size() - offset;
      53            0 :         return py::bytes(reinterpret_cast<char*>(self->get_data()) + offset, bytes_size);
      54              :       },
      55            0 :       "offset"_a = 0,
      56            0 :       py::return_value_policy::reference_internal);
      57              : 
      58            0 :   py::enum_<Fragment::BufferAdoptionMode>(py_fragment, "BufferAdoptionMode")
      59            0 :     .value("kReadOnlyMode", Fragment::BufferAdoptionMode::kReadOnlyMode)
      60            0 :     .value("kTakeOverBuffer", Fragment::BufferAdoptionMode::kTakeOverBuffer)
      61            0 :     .value("kCopyFromBuffer", Fragment::BufferAdoptionMode::kCopyFromBuffer)
      62            0 :     .export_values();
      63              : 
      64            0 :   py::class_<FragmentHeader>(m, "FragmentHeader")
      65            0 :     .def_property_readonly(
      66              :       "fragment_header_marker",
      67            0 :       [](const FragmentHeader& self) -> uint32_t { return self.fragment_header_marker; }) // NOLINT(build/unsigned)
      68            0 :     .def_property_readonly(
      69            0 :       "version", [](const FragmentHeader& self) -> uint32_t { return self.version; }) // NOLINT(build/unsigned)
      70            0 :     .def_property_readonly("size", [](const FragmentHeader& self) -> fragment_size_t { return self.size; })
      71            0 :     .def_property_readonly("trigger_number",
      72            0 :                            [](const FragmentHeader& self) -> trigger_number_t { return self.trigger_number; })
      73            0 :     .def_property_readonly("trigger_timestamp",
      74            0 :                            [](const FragmentHeader& self) -> timestamp_t { return self.trigger_timestamp; })
      75            0 :     .def_property_readonly("window_begin", [](const FragmentHeader& self) -> timestamp_t { return self.window_begin; })
      76            0 :     .def_property_readonly("window_end", [](const FragmentHeader& self) -> timestamp_t { return self.window_end; })
      77            0 :     .def_property_readonly("run_number", [](const FragmentHeader& self) -> run_number_t { return self.run_number; })
      78            0 :     .def_property_readonly(
      79            0 :       "error_bits", [](const FragmentHeader& self) -> uint32_t { return self.error_bits; }) // NOLINT(build/unsigned)
      80            0 :     .def_property_readonly("fragment_type",
      81            0 :                            [](const FragmentHeader& self) -> fragment_type_t { return self.fragment_type; })
      82            0 :     .def_property_readonly("sequence_number",
      83            0 :                            [](const FragmentHeader& self) -> sequence_number_t { return self.sequence_number; })
      84            0 :     .def_property_readonly("detector_id", [](const FragmentHeader& self) -> uint16_t { return self.detector_id; })
      85            0 :     .def_property_readonly("element_id", [](const FragmentHeader& self) -> SourceID { return self.element_id; })
      86              : 
      87            0 :     .def_static("sizeof", []() { return sizeof(FragmentHeader); });
      88              : 
      89            0 :   py::enum_<FragmentErrorBits>(m, "FragmentErrorBits")
      90            0 :     .value("kDataNotFound", FragmentErrorBits::kDataNotFound)
      91            0 :     .value("kIncomplete", FragmentErrorBits::kIncomplete)
      92            0 :     .value("kInvalidWindow", FragmentErrorBits::kInvalidWindow)
      93              :     // TODO, Alessandro Thea <thea@github.com> Oct-31-2021:  Add unassigned
      94            0 :     .export_values();
      95              : 
      96            0 :   py::enum_<FragmentType>(m, "FragmentType")
      97            0 :     .value("kUnknown", FragmentType::kUnknown)
      98            0 :     .value("kProtoWIB", FragmentType::kProtoWIB)
      99            0 :     .value("kWIB", FragmentType::kWIB)
     100            0 :     .value("kDAPHNE", FragmentType::kDAPHNE)
     101            0 :     .value("kTDE_AMC", FragmentType::kTDE_AMC)
     102            0 :     .value("kFW_TriggerPrimitive", FragmentType::kFW_TriggerPrimitive)
     103            0 :     .value("kTriggerPrimitive", FragmentType::kTriggerPrimitive)
     104            0 :     .value("kTriggerActivity", FragmentType::kTriggerActivity)
     105            0 :     .value("kTriggerCandidate", FragmentType::kTriggerCandidate)
     106            0 :     .value("kHardwareSignal", FragmentType::kHardwareSignal)
     107            0 :     .value("kPACMAN", FragmentType::kPACMAN)
     108            0 :     .value("kWIBEth", FragmentType::kWIBEth)
     109            0 :     .value("kDAPHNEStream", FragmentType::kDAPHNEStream)
     110            0 :     .value("kCRT", FragmentType::kCRT)
     111            0 :     .value("kTDEEth", FragmentType::kTDEEth)
     112            0 :     .value("kCRTBern", FragmentType::kCRTBern)
     113            0 :     .value("kCRTGrenoble", FragmentType::kCRTGrenoble)
     114            0 :     .value("kDAPHNEEth", FragmentType::kDAPHNEEth)
     115            0 :     .value("kDAPHNEEthStream", FragmentType::kDAPHNEEthStream)
     116            0 :     .export_values();
     117              : 
     118            0 :     m.def("fragment_type_to_string", &fragment_type_to_string);
     119            0 :     m.def("string_to_fragment_type", &string_to_fragment_type);
     120            0 : }
     121              : 
     122              : } // namespace python
     123              : } // namespace daqdataformats
     124              : } // namespace dunedaq