DAPHNEUnpacker.cpp

Go to the documentation of this file.

 
#include "fddetdataformats/DAPHNEFrame.hpp"
#include "fddetdataformats/DAPHNEStreamFrame.hpp"
#include "daqdataformats/Fragment.hpp"
 
#include <cstdint>
#include <pybind11/numpy.h>
 
namespace py = pybind11;
namespace dunedaq::rawdatautils::daphne {
 
uint32_t get_n_frames(daqdataformats::Fragment const& frag){
  return (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEFrame);
}
 
uint32_t get_n_frames_stream(daqdataformats::Fragment const& frag){
  return (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEStreamFrame);
}
 
 
py::array_t<uint8_t> np_array_channels_stream_data(void* data, int nframes){
 
  const auto channels_per_daphne  = fddetdataformats::DAPHNEStreamFrame::s_channels_per_frame;
  py::array_t<uint8_t> channels(channels_per_daphne * nframes);
  auto ptr = static_cast<uint8_t*>(channels.request().ptr);
 
  for (size_t i=0; i<(size_t)nframes; ++i) {
    auto fr = reinterpret_cast<fddetdataformats::DAPHNEStreamFrame*>(static_cast<char*>(data) + i * sizeof(fddetdataformats::DAPHNEStreamFrame));
 
    ptr[i*channels_per_daphne + 0] = fr->get_channel0();
    ptr[i*channels_per_daphne + 1] = fr->get_channel1();
    ptr[i*channels_per_daphne + 2] = fr->get_channel2();
    ptr[i*channels_per_daphne + 3] = fr->get_channel3();
 
  }   
  channels.resize({nframes, channels_per_daphne});
 
  return channels; 
}
 
py::array_t<uint8_t> np_array_channels_data(void* data, int nframes){
 
  py::array_t<uint8_t> channels(nframes);
  auto ptr = static_cast<uint8_t*>(channels.request().ptr);
 
  for (size_t i=0; i<(size_t)nframes; ++i) {
    auto fr = reinterpret_cast<fddetdataformats::DAPHNEFrame*>(static_cast<char*>(data) + i * sizeof(fddetdataformats::DAPHNEFrame));
    ptr[i] = fr->get_channel();
  }
 
  return channels;
}
 
py::array_t<uint8_t> np_array_channels(daqdataformats::Fragment& frag){
  return np_array_channels_data(frag.get_data(), (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEFrame));
}
 
py::array_t<uint8_t> np_array_channels_stream(daqdataformats::Fragment& frag){
  return np_array_channels_stream_data(frag.get_data(), (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEStreamFrame));
}
 
 
py::array_t<uint16_t> np_array_adc_data(void* data, int nframes){
  
  const auto adcs_per_channel     = fddetdataformats::DAPHNEFrame::s_num_adcs;
 
  py::array_t<uint16_t> ret(nframes * adcs_per_channel);
  auto ptr = static_cast<uint16_t*>(ret.request().ptr);
  for (size_t i=0; i<(size_t)nframes; ++i) {
    auto fr = reinterpret_cast<fddetdataformats::DAPHNEFrame*>(static_cast<char*>(data) + i * sizeof(fddetdataformats::DAPHNEFrame));
    //auto fr = reinterpret_cast<fddetdataformats::DAPHNEFrame*>(static_cast<char*>(data) + i * sizeof(fddetdataformats::DAPHNEFrame));
    for (size_t j=0; j<adcs_per_channel; ++j) {
      ptr[i*adcs_per_channel + j] = fr->get_adc(j);
    }
    //for (size_t j=0; j<channels_per_daphne; ++j)
    
  }
  ret.resize({nframes, adcs_per_channel});
 
  return ret;
}
 
py::array_t<uint16_t> np_array_adc_stream_data(void* data, int nframes){
 
  const auto channels_per_daphne  = fddetdataformats::DAPHNEStreamFrame::s_channels_per_frame;
  const auto adcs_per_channel     = fddetdataformats::DAPHNEStreamFrame::s_adcs_per_channel;
 
  
  py::array_t<uint16_t> ret(channels_per_daphne * nframes * adcs_per_channel);
  auto ptr = static_cast<uint16_t*>(ret.request().ptr);
  for (size_t i=0; i<(size_t)nframes; ++i) {
    auto fr = reinterpret_cast<fddetdataformats::DAPHNEStreamFrame*>(static_cast<char*>(data) + i * sizeof(fddetdataformats::DAPHNEStreamFrame));
    for (size_t j=0; j<adcs_per_channel; ++j)
      for (size_t k=0; k<channels_per_daphne; ++k)
        ptr[channels_per_daphne * (adcs_per_channel * i + j) + k] = fr->get_adc(j,k);
  }
  ret.resize({nframes*adcs_per_channel, channels_per_daphne});
 
  return ret;
}
 
py::array_t<uint64_t> np_array_timestamp_data(void* data, int nframes){
 
  py::array_t<uint64_t> ret(nframes);
  auto ptr = static_cast<uint64_t*>(ret.request().ptr);
  for (size_t i=0; i<(size_t)nframes; ++i) {
    auto fr = reinterpret_cast<fddetdataformats::DAPHNEFrame*>(static_cast<char*>(data) + i * sizeof(fddetdataformats::DAPHNEFrame));
    ptr[i] = fr->get_timestamp();
  }
 
  return ret;
}
 
py::array_t<uint64_t> np_array_timestamp_stream_data(void* data, int nframes) {
 
  const auto adcs_per_channel = fddetdataformats::DAPHNEStreamFrame::s_adcs_per_channel;
  const size_t ticks_per_adc = 1;
 
  py::array_t<uint64_t> ret(nframes*adcs_per_channel);
 
  auto ptr = static_cast<uint64_t*>(ret.request().ptr);
  for (size_t i=0; i<(size_t)nframes; ++i) {
    auto fr = reinterpret_cast<fddetdataformats::DAPHNEStreamFrame*>(static_cast<char*>(data) + i * sizeof(fddetdataformats::DAPHNEStreamFrame));
    for (size_t j=0; j<adcs_per_channel; ++j)
      ptr[i*adcs_per_channel+j] = fr->get_timestamp()+j*ticks_per_adc;
  }
 
  return ret;
}
 
 
py::array_t<uint16_t> np_array_adc(daqdataformats::Fragment& frag){
  return np_array_adc_data(frag.get_data(), (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEFrame));
}
 
py::array_t<uint16_t> np_array_adc_stream(daqdataformats::Fragment& frag){
  return np_array_adc_stream_data(frag.get_data(), (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEStreamFrame));
}
 
 
py::array_t<uint64_t> np_array_timestamp(daqdataformats::Fragment& frag){
  return np_array_timestamp_data(frag.get_data(), (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEFrame));
}
 
py::array_t<uint64_t> np_array_timestamp_stream(daqdataformats::Fragment& frag){
  return np_array_timestamp_stream_data(frag.get_data(), (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEStreamFrame));
}
 
 
} // namespace dunedaq::rawdatautils::daphne // NOLINT