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 16 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 25 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 25 of file daqheader.cpp.

{
 
  py::class_<DAQHeader>(m, "DAQHeader", py::buffer_protocol())
    .def(py::init<>())
    .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_property(
      "timestamp_1",
      [](DAQHeader&) -> uint32_t {
        throw std::runtime_error("Cannot directly read timestamp_1; use get_timestamp() instead");
      },
      [](DAQHeader& self, uint32_t timestamp_1) { self.timestamp_1 = timestamp_1; })
    .def_property(
      "timestamp_2",
      [](DAQHeader&) -> uint32_t {
        throw std::runtime_error("Cannot directly read timestamp_2; use get_timestamp() instead");
      },
      [](DAQHeader& self, uint32_t timestamp_2) { self.timestamp_2 = timestamp_2; })
    .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 22 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 " << DetID::subdetector_to_string(gid.subdetector) << ">";
           return oss.str();
         })
    .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("kVD_BernCRT", DetID::Subdetector::kVD_BernCRT)
    .value("kVD_GrenobleCRT", DetID::Subdetector::kVD_GrenobleCRT)
    .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("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 21 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 &

)