dunedaq::rawdatautils::daphne Namespace Reference

Functions
uint32_t	get_n_frames (daqdataformats::Fragment const &frag)
	Gets number of DAPHNEFrames in a fragment.
uint32_t	get_n_frames_stream (daqdataformats::Fragment const &frag)
	Gets number of DAPHNEStreamFrames in a fragment.
py::array_t< uint8_t >	np_array_channels_stream_data (void *data, int nframes)
	Unpacks channel numbers for DAPHNEStreamFrames into a numpy array with dimensions (nframes, s_channels_per_frame).
py::array_t< uint8_t >	np_array_channels_data (void *data, int nframes)
	Unpacks channel numbers for DAPHNEFrames into a numpy array with dimensions (nframes).
py::array_t< uint8_t >	np_array_channels (daqdataformats::Fragment &frag)
	Unpacks channel numbers for Fragment that contains DAPHNEFrames into a numpy array with dimensions.
py::array_t< uint8_t >	np_array_channels_stream (daqdataformats::Fragment &frag)
	Unpacks channel numbers for Fragment that contains DAPHNEStreamFrames into a numpy array with dimensions.
py::array_t< uint16_t >	np_array_adc_data (void *data, int nframes)
	Unpacks data containing DAPHNEFrames into a numpy array with the ADC values and dimension (number of DAPHNEFrames, channels_per_daphne) Warning: It doesn't check that nframes is a sensible value (can read out of bounds).
py::array_t< uint16_t >	np_array_adc_stream_data (void *data, int nframes)
	Unpacks data containing DAPHNEStreamFrames into a numpy array with the ADC values and dimension (number of DAPHNEStreamFrames * adcs_per_channel (64), channels_per_frame (4)) Warning: It doesn't check that nframes is a sensible value (can read out of bounds).
py::array_t< uint64_t >	np_array_timestamp_data (void *data, int nframes)
	Unpacks data containing DAPHNEFrames into a numpy array with the timestamps with dimension (number of DAPHNEFrames) Warning: It doesn't check that nframes is a sensible value (can read out of bounds).
py::array_t< uint64_t >	np_array_timestamp_stream_data (void *data, int nframes)
	Unpacks data containing DAPHNEStreamFrames into a numpy array with the timestamps with dimension (number of DAPHNEStreamFrames) Warning: It doesn't check that nframes is a sensible value (can read out of bounds).
py::array_t< uint16_t >	np_array_adc (daqdataformats::Fragment &frag)
	Unpacks a Fragment containing DAPHNEFrames into a numpy array with the ADC values and dimension (number of DAPHNEFrames in the Fragment, 320).
py::array_t< uint16_t >	np_array_adc_stream (daqdataformats::Fragment &frag)
	Unpacks a Fragment containing DAPHNEStreamFrames into a numpy array with the ADC values and dimension (number of DAPHNEStreamFrames in the Fragment, 4).
py::array_t< uint64_t >	np_array_timestamp (daqdataformats::Fragment &frag)
	Unpacks the timestamps in a Fragment containing WIBFrames into a numpy array with dimension (number of DAPHNEFrames in the Fragment).
py::array_t< uint64_t >	np_array_timestamp_stream (daqdataformats::Fragment &frag)
	Unpacks the timestamps in a Fragment containing DAPHNEStreamFrames into a numpy array with dimension (number of DAPHNEStreamFrames in the Fragment).

Function Documentation

get_n_frames()

uint32_t dunedaq::rawdatautils::daphne::get_n_frames

(

daqdataformats::Fragment const &

frag

)

Gets number of DAPHNEFrames in a fragment.

Definition at line 23 of file DAPHNEUnpacker.cpp.

{
  return (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEFrame);
}

get_n_frames_stream()

uint32_t dunedaq::rawdatautils::daphne::get_n_frames_stream

(

daqdataformats::Fragment const &

frag

)

Gets number of DAPHNEStreamFrames in a fragment.

Definition at line 32 of file DAPHNEUnpacker.cpp.

{
  return (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) / sizeof(fddetdataformats::DAPHNEStreamFrame);
}

np_array_adc()

py::array_t< uint16_t > dunedaq::rawdatautils::daphne::np_array_adc

(

daqdataformats::Fragment &

frag

)

Unpacks a Fragment containing DAPHNEFrames into a numpy array with the ADC values and dimension (number of DAPHNEFrames in the Fragment, 320).

Definition at line 210 of file DAPHNEUnpacker.cpp.

{
  return np_array_adc_data(frag.get_data(),
                           (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) /
                             sizeof(fddetdataformats::DAPHNEFrame));
}

np_array_adc_data()

py::array_t< uint16_t > dunedaq::rawdatautils::daphne::np_array_adc_data	(	void *	data,
		int	nframes )

Unpacks data containing DAPHNEFrames into a numpy array with the ADC values and dimension (number of DAPHNEFrames, channels_per_daphne) Warning: It doesn't check that nframes is a sensible value (can read out of bounds).

Definition at line 111 of file DAPHNEUnpacker.cpp.

{
 
  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;
}

np_array_adc_stream()

py::array_t< uint16_t > dunedaq::rawdatautils::daphne::np_array_adc_stream

(

daqdataformats::Fragment &

frag

)

Unpacks a Fragment containing DAPHNEStreamFrames into a numpy array with the ADC values and dimension (number of DAPHNEStreamFrames in the Fragment, 4).

Definition at line 222 of file DAPHNEUnpacker.cpp.

{
  return np_array_adc_stream_data(frag.get_data(),
                                  (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) /
                                    sizeof(fddetdataformats::DAPHNEStreamFrame));
}

np_array_adc_stream_data()

py::array_t< uint16_t > dunedaq::rawdatautils::daphne::np_array_adc_stream_data	(	void *	data,
		int	nframes )

Unpacks data containing DAPHNEStreamFrames into a numpy array with the ADC values and dimension (number of DAPHNEStreamFrames * adcs_per_channel (64), channels_per_frame (4)) Warning: It doesn't check that nframes is a sensible value (can read out of bounds).

Definition at line 139 of file DAPHNEUnpacker.cpp.

{
 
  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;
}

np_array_channels()

py::array_t< uint8_t > dunedaq::rawdatautils::daphne::np_array_channels

(

daqdataformats::Fragment &

frag

)

Unpacks channel numbers for Fragment that contains DAPHNEFrames into a numpy array with dimensions.

Definition at line 87 of file DAPHNEUnpacker.cpp.

{
  return np_array_channels_data(frag.get_data(),
                                (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) /
                                  sizeof(fddetdataformats::DAPHNEFrame));
}

np_array_channels_data()

py::array_t< uint8_t > dunedaq::rawdatautils::daphne::np_array_channels_data	(	void *	data,
		int	nframes )

Unpacks channel numbers for DAPHNEFrames into a numpy array with dimensions (nframes).

Definition at line 69 of file DAPHNEUnpacker.cpp.

{
 
  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;
}

np_array_channels_stream()

py::array_t< uint8_t > dunedaq::rawdatautils::daphne::np_array_channels_stream

(

daqdataformats::Fragment &

frag

)

Unpacks channel numbers for Fragment that contains DAPHNEStreamFrames into a numpy array with dimensions.

Definition at line 98 of file DAPHNEUnpacker.cpp.

{
  return np_array_channels_stream_data(frag.get_data(),
                                       (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) /
                                         sizeof(fddetdataformats::DAPHNEStreamFrame));
}

np_array_channels_stream_data()

py::array_t< uint8_t > dunedaq::rawdatautils::daphne::np_array_channels_stream_data	(	void *	data,
		int	nframes )

Unpacks channel numbers for DAPHNEStreamFrames into a numpy array with dimensions (nframes, s_channels_per_frame).

Definition at line 43 of file DAPHNEUnpacker.cpp.

{
 
  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;
}

np_array_timestamp()

py::array_t< uint64_t > dunedaq::rawdatautils::daphne::np_array_timestamp

(

daqdataformats::Fragment &

frag

)

Unpacks the timestamps in a Fragment containing WIBFrames into a numpy array with dimension (number of DAPHNEFrames in the Fragment).

Definition at line 234 of file DAPHNEUnpacker.cpp.

{
  return np_array_timestamp_data(frag.get_data(),
                                 (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) /
                                   sizeof(fddetdataformats::DAPHNEFrame));
}

np_array_timestamp_data()

py::array_t< uint64_t > dunedaq::rawdatautils::daphne::np_array_timestamp_data	(	void *	data,
		int	nframes )

Unpacks data containing DAPHNEFrames into a numpy array with the timestamps with dimension (number of DAPHNEFrames) Warning: It doesn't check that nframes is a sensible value (can read out of bounds).

Definition at line 166 of file DAPHNEUnpacker.cpp.

{
 
  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;
}

np_array_timestamp_stream()

py::array_t< uint64_t > dunedaq::rawdatautils::daphne::np_array_timestamp_stream

(

daqdataformats::Fragment &

frag

)

Unpacks the timestamps in a Fragment containing DAPHNEStreamFrames into a numpy array with dimension (number of DAPHNEStreamFrames in the Fragment).

Definition at line 246 of file DAPHNEUnpacker.cpp.

{
  return np_array_timestamp_stream_data(frag.get_data(),
                                        (frag.get_size() - sizeof(daqdataformats::FragmentHeader)) /
                                          sizeof(fddetdataformats::DAPHNEStreamFrame));
}

np_array_timestamp_stream_data()

py::array_t< uint64_t > dunedaq::rawdatautils::daphne::np_array_timestamp_stream_data	(	void *	data,
		int	nframes )

Unpacks data containing DAPHNEStreamFrames into a numpy array with the timestamps with dimension (number of DAPHNEStreamFrames) Warning: It doesn't check that nframes is a sensible value (can read out of bounds).

Definition at line 186 of file DAPHNEUnpacker.cpp.

{
 
  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;
}