dunedaq::detdataformats::python Namespace Reference

Functions
void	register_daqethheader (py::module &m)
void	register_daqheader (py::module &m)
void	register_detid (py::module &m)
void	register_hsi (py::module &m)
	PYBIND11_MODULE (_daq_detdataformats_py, m)
void	register_detid (pybind11::module &)
void	register_daqheader (pybind11::module &)
void	register_daqethheader (pybind11::module &)
void	register_hsi (pybind11::module &)

Function Documentation

PYBIND11_MODULE()

dunedaq::detdataformats::python::PYBIND11_MODULE	(	_daq_detdataformats_py	,
		m	)

Definition at line 18 of file module.cpp.

                                           {
 
    m.doc() = "c++ implementation of the dunedaq detdataformats modules"; // optional module docstring
 
    register_detid(m);
    register_daqheader(m);
    register_daqethheader(m);
    register_hsi(m);
 
}

register_daqethheader() [1/2]

void dunedaq::detdataformats::python::register_daqethheader

(

py::module &

m

)

Definition at line 22 of file daqethheader.cpp.

{
 
  py::class_<DAQEthHeader>(m, "DAQEthHeader", py::buffer_protocol())
    .def(py::init([](py::capsule capsule) {
      auto hsfp = *static_cast<DAQEthHeader*>(capsule.get_pointer());
      return hsfp;
    }))
    .def(py::init([](py::bytes bytes) {
      py::buffer_info info(py::buffer(bytes).request());
      auto wfp = *static_cast<DAQEthHeader*>(info.ptr);
      return wfp;
    }))
    .def_property(
      "version",
      [](DAQEthHeader& self) -> uint32_t { return self.version; },
      [](DAQEthHeader& self, uint32_t version) { self.version = version; })
    .def_property(
      "det_id",
      [](DAQEthHeader& self) -> uint32_t { return self.det_id; },
      [](DAQEthHeader& self, uint32_t det_id) { self.det_id = det_id; })
    .def_property(
      "crate_id",
      [](DAQEthHeader& self) -> uint32_t { return self.crate_id; },
      [](DAQEthHeader& self, uint32_t crate_id) { self.crate_id = crate_id; })
    .def_property(
      "slot_id",
      [](DAQEthHeader& self) -> uint32_t { return self.slot_id; },
      [](DAQEthHeader& self, uint32_t slot_id) { self.slot_id = slot_id; })
    .def_property(
      "stream_id",
      [](DAQEthHeader& self) -> uint32_t { return self.stream_id; },
      [](DAQEthHeader& self, uint32_t stream_id) { self.stream_id = stream_id; })
    .def_property(
      "reserved",
      [](DAQEthHeader& self) -> uint32_t { return self.reserved; },
      [](DAQEthHeader& self, uint32_t reserved) { self.reserved = reserved; })
    .def_property(
      "seq_id",
      [](DAQEthHeader& self) -> uint32_t { return self.seq_id; },
      [](DAQEthHeader& self, uint32_t seq_id) { self.seq_id = seq_id; })
    .def_property(
      "block_length",
      [](DAQEthHeader& self) -> uint32_t { return self.block_length; },
      [](DAQEthHeader& self, uint32_t block_length) { self.block_length = block_length; })
    .def_property(
      "timestamp",
      [](DAQEthHeader& self) -> uint64_t { return self.timestamp; },
      [](DAQEthHeader& self, uint64_t timestamp) { self.timestamp = timestamp; })
    .def("get_timestamp", &DAQEthHeader::get_timestamp)
    .def_static("sizeof", []() { return sizeof(DAQEthHeader); });
}

register_daqethheader() [2/2]

void dunedaq::detdataformats::python::register_daqethheader

(

pybind11::module &

)

register_daqheader() [1/2]

void dunedaq::detdataformats::python::register_daqheader

(

py::module &

m

)

Definition at line 21 of file daqheader.cpp.

                                     {
 
  py::class_<DAQHeader>(m, "DAQHeader", py::buffer_protocol())
    .def_property("version", 
      [](DAQHeader& self) -> uint32_t { return self.version; }, 
      [](DAQHeader& self, uint32_t version) { self.version = version; } 
      )
    .def_property("det_id", 
      [](DAQHeader& self) -> uint32_t { return self.det_id; }, 
      [](DAQHeader& self, uint32_t det_id) { self.det_id = det_id; } 
      )
    .def_property("crate_id", 
      [](DAQHeader& self) -> uint32_t { return self.crate_id; }, 
      [](DAQHeader& self, uint32_t crate_id) { self.crate_id = crate_id; } 
      )
    .def_property("slot_id", 
      [](DAQHeader& self) -> uint32_t { return self.slot_id; }, 
      [](DAQHeader& self, uint32_t slot_id) { self.slot_id = slot_id; } 
      )
    .def_property("link_id", 
      [](DAQHeader& self) -> uint32_t { return self.link_id; }, 
      [](DAQHeader& self, uint32_t link_id) { self.link_id = link_id; } 
      )
    .def("get_timestamp", &DAQHeader::get_timestamp)
    ;
}

register_daqheader() [2/2]

void dunedaq::detdataformats::python::register_daqheader

(

pybind11::module &

)

register_detid() [1/2]

void dunedaq::detdataformats::python::register_detid

(

py::module &

m

)

Definition at line 21 of file detid.cpp.

                                 {
  py::class_<DetID> py_detid(m, "DetID");
  py_detid.def(py::init())
      .def(py::init<const DetID::Subdetector&>())
      .def("__repr__", [](const DetID& gid) {
        std::ostringstream oss;
        oss << "<detdataformats::DetID " << gid.to_string() << ">";
        return oss.str();
      })
      .def("to_string", &DetID::to_string)
      .def("is_in_valid_state", &DetID::is_in_valid_state)
      .def("subdetector_to_string", &DetID::subdetector_to_string)
      .def("string_to_subdetector", &DetID::string_to_subdetector);
 
  py::enum_<DetID::Subdetector>(py_detid, "Subdetector")
      .value("kUnknown", DetID::Subdetector::kUnknown)
      .value("kDAQ", DetID::Subdetector::kDAQ)
      .value("kHD_PDS", DetID::Subdetector::kHD_PDS)
      .value("kHD_TPC", DetID::Subdetector::kHD_TPC)
      .value("kHD_CRT", DetID::Subdetector::kHD_CRT)
      .value("kVD_CathodePDS", DetID::Subdetector::kVD_CathodePDS)
      .value("kVD_MembranePDS", DetID::Subdetector::kVD_MembranePDS)
      .value("kVD_BottomTPC", DetID::Subdetector::kVD_BottomTPC)
      .value("kVD_TopTPC", DetID::Subdetector::kVD_TopTPC)
      .value("kNDLAr_TPC", DetID::Subdetector::kNDLAr_TPC)
      .value("kNDLAr_PDS", DetID::Subdetector::kNDLAr_PDS)
      .value("kND_GAr", DetID::Subdetector::kND_GAr)
      .export_values();
 
  py_detid.def_readwrite("version", &DetID::version)
      .def_readwrite("subdetector", &DetID::subdetector);
}

register_detid() [2/2]

void dunedaq::detdataformats::python::register_detid

(

pybind11::module &

)

register_hsi() [1/2]

void dunedaq::detdataformats::python::register_hsi

(

py::module &

m

)

Definition at line 18 of file hsi.cpp.

{
 
  py::class_<HSIFrame> (m, "HSIFrame", py::buffer_protocol())
    .def(py::init())
    .def(py::init([](py::capsule capsule) {
        auto hsfp = *static_cast<HSIFrame*>(capsule.get_pointer());
        return hsfp;
    } ))
    .def(py::init([](py::bytes bytes){
      py::buffer_info info(py::buffer(bytes).request());
      auto wfp = *static_cast<HSIFrame*>(info.ptr);
      return wfp;
    }))
    .def("get_timestamp", &HSIFrame::get_timestamp)
    .def_property_readonly("version", [](const HSIFrame& self) -> uint64_t {return self.version;})
    .def_property_readonly("detector_id", [](const HSIFrame& self) -> uint64_t {return self.detector_id;})
    .def_property_readonly("crate", [](const HSIFrame& self) -> uint64_t {return self.crate;})
    .def_property_readonly("slot", [](const HSIFrame& self) -> uint64_t {return self.slot;})
    .def_property_readonly("link", [](const HSIFrame& self) -> uint64_t {return self.link;})
    .def_property_readonly("input_low", [](const HSIFrame& self) -> uint64_t {return self.input_low;})
    .def_property_readonly("input_high", [](const HSIFrame& self) -> uint64_t {return self.input_high;})
    .def_property_readonly("trigger", [](const HSIFrame& self) -> uint64_t {return self.trigger;})
    .def_property_readonly("sequence", [](const HSIFrame& self) -> uint64_t {return self.sequence;})
    .def_static("sizeof", [](){ return sizeof(HSIFrame); })
  ;
}

register_hsi() [2/2]

void dunedaq::detdataformats::python::register_hsi

(

pybind11::module &

)