Line data    Source code

       1              : /**
       2              :  * @file trigger_primitive.cpp Python bindings for the trigger primitive formats
       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 "trgdataformats/TriggerObjectOverlay.hpp"
      10              : 
      11              : #include <pybind11/pybind11.h>
      12              : #include <pybind11/stl.h>
      13              : #include <cstring>
      14              : 
      15              : namespace py = pybind11;
      16              : 
      17              : namespace dunedaq {
      18              : namespace trgdataformats {
      19              : namespace python {
      20              : 
      21              : /*
      22              :  Doesn't work
      23              : */
      24              : struct TriggerActivityHolder {
      25              : 
      26              : 
      27            0 :   TriggerActivityHolder(void* ptr, size_t size) {
      28            0 :     m_size = size;
      29            0 :     m_data.reset(new uint8_t[m_size]);
      30            0 :     std::memcpy(m_data.get(), ptr, size);
      31            0 :   }
      32              : 
      33            0 :   TriggerActivity* ptr() { return reinterpret_cast<TriggerActivity*>(m_data.get());  }
      34              : 
      35              :   size_t m_size;
      36              :   std::unique_ptr<uint8_t[]> m_data;
      37              :   
      38              : };
      39              : 
      40              : void
      41            0 : register_trigger_activity(py::module& m)
      42              : {
      43              : 
      44              : 
      45            0 :   py::class_<TriggerActivityData> trigger_activity_data(m, "TriggerActivityData", py::buffer_protocol());
      46            0 :   trigger_activity_data
      47            0 :     .def(py::init())
      48            0 :     .def(py::init([](py::capsule capsule) {
      49            0 :         auto tp = *static_cast<TriggerActivityData*>(capsule.get_pointer());
      50            0 :         return tp;
      51              :                   } ))
      52            0 :     .def(py::init([](py::bytes bytes){
      53            0 :       py::buffer_info info(py::buffer(bytes).request());
      54            0 :       auto tp = *static_cast<TriggerActivityData*>(info.ptr);
      55            0 :       return tp;
      56            0 :     }))
      57            0 :     .def_property_readonly("version", [](TriggerActivityData& self) -> uint16_t {return self.version;})
      58            0 :     .def_property_readonly("time_start", [](TriggerActivityData& self) -> uint64_t {return self.time_start;})
      59            0 :     .def_property_readonly("time_end", [](TriggerActivityData& self) -> uint64_t {return self.time_end;})
      60            0 :     .def_property_readonly("time_peak", [](TriggerActivityData& self) -> uint64_t {return self.time_peak;})
      61            0 :     .def_property_readonly("time_activity", [](TriggerActivityData& self) -> uint64_t {return self.time_activity;})
      62            0 :     .def_property_readonly("channel_start", [](TriggerActivityData& self) -> int32_t {return self.channel_start;})
      63            0 :     .def_property_readonly("channel_end", [](TriggerActivityData& self) -> int32_t {return self.channel_end;})
      64            0 :     .def_property_readonly("channel_peak", [](TriggerActivityData& self) -> int32_t {return self.channel_peak;})
      65            0 :     .def_property_readonly("adc_integral", [](TriggerActivityData& self) -> uint32_t {return self.adc_integral;})
      66            0 :     .def_property_readonly("adc_peak", [](TriggerActivityData& self) -> uint32_t {return self.adc_peak;})
      67            0 :     .def_property_readonly("detid", [](TriggerActivityData& self) -> uint16_t {return self.detid;})
      68            0 :     .def_property_readonly("type", [](TriggerActivityData& self) -> TriggerActivityData::Type {return self.type;})
      69            0 :     .def_property_readonly("algorithm", [](TriggerActivityData& self) -> TriggerActivityData::Algorithm {return self.algorithm;})
      70            0 :     .def_static("sizeof", [](){ return sizeof(TriggerActivityData); })
      71              :     ;
      72              : 
      73              : 
      74            0 :   py::enum_<TriggerActivityData::Type>(trigger_activity_data, "Type")
      75            0 :     .value("kUnknown", TriggerActivityData::Type::kUnknown)
      76            0 :     .value("kTPC", TriggerActivityData::Type::kTPC)
      77            0 :     .value("kPDS", TriggerActivityData::Type::kPDS);
      78              : 
      79            0 :   py::enum_<TriggerActivityData::Algorithm>(trigger_activity_data, "Algorithm")
      80            0 :     .value("kUnknown", TriggerActivityData::Algorithm::kUnknown)
      81            0 :     .value("kSupernova", TriggerActivityData::Algorithm::kSupernova)
      82            0 :     .value("kPrescale", TriggerActivityData::Algorithm::kPrescale)
      83            0 :     .value("kADCSimpleWindow", TriggerActivityData::Algorithm::kADCSimpleWindow)
      84            0 :     .value("kHorizontalMuon", TriggerActivityData::Algorithm::kHorizontalMuon)
      85            0 :     .value("kMichelElectron", TriggerActivityData::Algorithm::kMichelElectron)
      86            0 :     .value("kDBSCAN", TriggerActivityData::Algorithm::kDBSCAN)
      87            0 :     .value("kPlaneCoincidence", TriggerActivityData::Algorithm::kPlaneCoincidence)
      88            0 :     .value("kBundle", TriggerActivityData::Algorithm::kBundle)
      89            0 :     .value("kChannelDistance", TriggerActivityData::Algorithm::kChannelDistance)
      90            0 :     .value("kChannelAdjacency", TriggerActivityData::Algorithm::kChannelAdjacency);
      91              : 
      92            0 :   py::class_<TriggerActivity>(m, "TriggerActivityOverlay", py::buffer_protocol())
      93            0 :       .def(py::init())
      94            0 :       .def(py::init([](py::capsule capsule) {
      95            0 :         auto tp = *static_cast<TriggerActivity*>(capsule.get_pointer());
      96            0 :         return tp;
      97              :                   } ))
      98            0 :       .def_property_readonly("data", [](TriggerActivity& self) -> TriggerActivityData& {return self.data;})
      99            0 :       .def("__len__", [](TriggerActivity& self){ return self.n_inputs; })
     100            0 :       .def("sizeof", [](TriggerActivity& self){ return sizeof(TriggerActivity)+self.n_inputs*sizeof(TriggerPrimitive); })
     101              :     ;
     102              : 
     103              : 
     104            0 :     py::class_<TriggerActivityHolder>(m, "TriggerActivity", py::buffer_protocol())
     105              :       // .def(py::init())
     106            0 :       .def(py::init([](py::capsule capsule) {
     107            0 :           auto ta_ptr = static_cast<TriggerActivity*>(capsule.get_pointer());
     108            0 :           TriggerActivityHolder tah(ta_ptr, sizeof(TriggerActivity)+ta_ptr->n_inputs*sizeof(TriggerPrimitive));
     109            0 :           return tah;
     110              :         }))
     111            0 :       .def(py::init([](py::bytes bytes){
     112            0 :           py::buffer_info info(py::buffer(bytes).request());
     113            0 :           TriggerActivityHolder tah(info.ptr, info.size);
     114              : 
     115            0 :           return tah;
     116            0 :         }))
     117              : 
     118            0 :       .def("get_bytes",
     119            0 :           [](TriggerActivityHolder& tah) -> py::bytes {
     120            0 :             return py::bytes(reinterpret_cast<char*>(tah.ptr()), tah.m_size);
     121            0 :           }, py::return_value_policy::reference_internal
     122              :       )
     123            0 :       .def_property_readonly("data", [](TriggerActivityHolder& self) -> TriggerActivityData& {return self.ptr()->data;})
     124            0 :       .def("n_inputs", [](TriggerActivityHolder& self){ return self.ptr()->n_inputs; })
     125            0 :       .def("__len__", [](TriggerActivityHolder& self){ return self.ptr()->n_inputs; })
     126            0 :       .def("__getitem__",
     127            0 :             [](TriggerActivityHolder &self, size_t i) -> const TriggerPrimitive& {
     128            0 :                 if (i >= self.ptr()->n_inputs) {
     129            0 :                     throw py::index_error();
     130              :                 }
     131            0 :                 return self.ptr()->inputs[i];
     132            0 :             }, py::return_value_policy::reference_internal)
     133            0 :       .def("sizeof", [](TriggerActivityHolder& self){ return self.m_size; })
     134              :       
     135              :       ;
     136            0 : }
     137              : 
     138              : } // namespace python
     139              : } // namespace trgdataformats
     140              : } // namespace dunedaq