dunedaq::rawdatautils Namespace Reference

Namespaces
namespace	daphne
namespace	fc
namespace	python
namespace	tde
namespace	unpack
namespace	wib
namespace	wib2
namespace	wibeth

Functions
fddetdataformats::TDE16Frame	wibtotde (fddetdataformats::WIBFrame *fr, uint64_t timestamp, uint16_t ch)
void	wib_binary_to_tde_binary (std::string &filename, std::string &output)
void	wib_hdf5_to_tde_binary (std::string &, std::string &)
fddetdataformats::WIB2Frame	wibtowib2 (fddetdataformats::WIBFrame *fr, uint64_t timestamp=0)
void	wib_binary_to_wib2_binary (std::string &filename, std::string &output)
void	wib_hdf5_to_wib2_binary (std::string &, std::string &)
fddetdataformats::WIBEthFrame	wibtowibeth (fddetdataformats::WIBFrame *fr, uint64_t timestamp=0, int starting_channel=0)
void	wib_binary_to_wibeth_binary (std::string &filename, std::string &output)
void	wib_hdf5_to_wibeth_binary (std::string &, std::string &)
void	print_hex_fragment (daqdataformats::Fragment const &frag)

Function Documentation

print_hex_fragment()

void dunedaq::rawdatautils::print_hex_fragment

(

daqdataformats::Fragment const &

frag

)

Definition at line 27 of file unpack.cpp.

                                                            {
  uint64_t* data = static_cast<uint64_t*>(frag.get_data());
  size_t data_size = (frag.get_size() - sizeof(daqdataformats::FragmentHeader))/8;
 
  for ( size_t i(0); i<data_size; ++i) {
    fmt::print("{:06d} 0x{:016x}\n", i, data[i]);
  }
 
}

wib_binary_to_tde_binary()

void dunedaq::rawdatautils::wib_binary_to_tde_binary	(	std::string &	filename,
		std::string &	output )

Definition at line 44 of file WIBtoTDE.hpp.

                                                                 {
  //FIXME: this is temporary.... we take 1 WIB frame and invent TDE frames from it... ADC values not set
  std::ifstream file(filename.c_str(), std::ios::binary);
  std::ofstream out(output.c_str(), std::ios::binary);
  std::cout << "Transforming " << filename << " to " << output << '\n';
  auto size = std::filesystem::file_size(filename);
  std::vector<char> v(size);
  file.read(v.data(), size);
  file.close();
  int num_frames = size / sizeof(fddetdataformats::WIBFrame);
  if (num_frames > 10 ) num_frames = 10;
  std::cout << "Number of frames found: "<< num_frames << '\n';
  auto ptr = reinterpret_cast<fddetdataformats::WIBFrame*>(v.data());
  uint64_t timestamp = ptr->get_timestamp();
  while(num_frames--){
    for (uint16_t i = 0; i < dunedaq::fddetdataformats::n_channels_per_amc; i++) {    
       auto tdefr = wibtotde(ptr, timestamp, i);
       out.write(reinterpret_cast<char*>(&tdefr), sizeof(tdefr));
    }
    timestamp += (dunedaq::fddetdataformats::tot_adc16_samples * dunedaq::fddetdataformats::ticks_between_adc_samples);
    ptr++;
  }
  out.close();
}

wib_binary_to_wib2_binary()

void dunedaq::rawdatautils::wib_binary_to_wib2_binary	(	std::string &	filename,
		std::string &	output )

Definition at line 38 of file WIBtoWIB2.hpp.

                                                                  {
  std::ifstream file(filename.c_str(), std::ios::binary);
  std::ofstream out(output.c_str(), std::ios::binary);
  std::cout << "Transforming " << filename << " to " << output << '\n';
  auto size = std::filesystem::file_size(filename);
  std::vector<char> v(size);
  file.read(v.data(), size);
  file.close();
  int num_frames = size / sizeof(fddetdataformats::WIBFrame);
  std::cout << "Number of frames found: "<< num_frames << '\n';
  auto ptr = reinterpret_cast<fddetdataformats::WIBFrame*>(v.data());
  uint64_t timestamp = ptr->get_timestamp();
  while(num_frames--){
    auto wib2fr = wibtowib2(ptr, timestamp);
    timestamp += 32;
    ptr++;
    out.write(reinterpret_cast<char*>(&wib2fr), sizeof(wib2fr));
  }
  out.close();
}

wib_binary_to_wibeth_binary()

void dunedaq::rawdatautils::wib_binary_to_wibeth_binary	(	std::string &	filename,
		std::string &	output )

Definition at line 42 of file WIBtoWIBEth.hpp.

                                                                    {
  std::ifstream file(filename.c_str(), std::ios::binary);
  std::cout << "Transforming " << filename << " to " << output << '\n';
  auto size = std::filesystem::file_size(filename);
  std::vector<char> v(size);
  file.read(v.data(), size);
  file.close();
  std::cout << "Number of frames found: "<< size / sizeof(fddetdataformats::WIBFrame) << '\n';
 
  std::ofstream out(output.c_str(), std::ios::binary);
  std::vector<int> starting_channel {0, 64, 128, 192};
  for (auto& sc : starting_channel) {
    auto ptr = reinterpret_cast<fddetdataformats::WIBFrame*>(v.data());
    uint64_t timestamp = ptr->get_timestamp();
    int num_frames = size / sizeof(fddetdataformats::WIBFrame);
    while(num_frames >= 64){
      auto wibethfr = wibtowibeth(ptr, timestamp, sc);
      timestamp += 32 * 64;
      ptr += 64;
      num_frames -= 64;
      out.write(reinterpret_cast<char*>(&wibethfr), sizeof(wibethfr));
    }
    out.close();
  }
 
}

wib_hdf5_to_tde_binary()

void dunedaq::rawdatautils::wib_hdf5_to_tde_binary	(	std::string &	,
		std::string &	)

Definition at line 70 of file WIBtoTDE.hpp.

                                                   {
}

wib_hdf5_to_wib2_binary()

void dunedaq::rawdatautils::wib_hdf5_to_wib2_binary	(	std::string &	,
		std::string &	)

Definition at line 60 of file WIBtoWIB2.hpp.

                                                    {
}

wib_hdf5_to_wibeth_binary()

void dunedaq::rawdatautils::wib_hdf5_to_wibeth_binary	(	std::string &	,
		std::string &	)

Definition at line 70 of file WIBtoWIBEth.hpp.

                                                      {
}

wibtotde()

fddetdataformats::TDE16Frame dunedaq::rawdatautils::wibtotde	(	fddetdataformats::WIBFrame *	fr,
		uint64_t	timestamp,
		uint16_t	ch )

Definition at line 24 of file WIBtoTDE.hpp.

                                                                        {
  fddetdataformats::TDE16Frame res;
  // leave ADCs empty for now
  for (auto i=0; i < dunedaq::fddetdataformats::tot_adc16_samples; i++) {
    res.set_adc_sample(ch,i);
  }
 
  auto header = fr->get_wib_header();
  res.get_daq_header()->version = header->version;
  res.get_daq_header()->det_id = 11;
  res.get_daq_header()->crate_id = header->crate_no;
  res.get_daq_header()->slot_id = header->slot_no;
  res.get_daq_header()->stream_id = header->fiber_no;
  res.set_channel(ch);
  res.set_timestamp(timestamp);
  std::cout << " Generated frame with TS " << res.get_timestamp() << " for channel " << res.get_channel() << std::endl;
  return res;
}

wibtowib2()

fddetdataformats::WIB2Frame dunedaq::rawdatautils::wibtowib2	(	fddetdataformats::WIBFrame *	fr,
		uint64_t	timestamp = 0 )

Definition at line 23 of file WIBtoWIB2.hpp.

                                                              {
  fddetdataformats::WIB2Frame res;
  for (int i = 0; i < 256; ++i) {
    res.set_adc(i, fr->get_channel(i));
  }
  auto header = fr->get_wib_header();
  res.header.version = header->version;
  res.header.crate = header->crate_no;
  res.header.slot = header->slot_no;
  res.header.link = header->fiber_no;
  res.set_timestamp(timestamp);
  return res;
}

wibtowibeth()

fddetdataformats::WIBEthFrame dunedaq::rawdatautils::wibtowibeth	(	fddetdataformats::WIBFrame *	fr,
		uint64_t	timestamp = 0,
		int	starting_channel = 0 )

Definition at line 23 of file WIBtoWIBEth.hpp.

                                                                                        {
  fddetdataformats::WIBEthFrame res;
  for (int j = 0; j < 64; ++j) {
    for (int i = 0; i < 64; ++i) {
      res.set_adc(i, j, (fr + j)->get_channel(starting_channel + i));
    }
  }
  auto header = fr->get_wib_header();
  res.daq_header.version = header->version; //Warning, in WIBFrames version has 5 bits and here it has 4
  res.daq_header.crate_id = header->crate_no;
  res.daq_header.slot_id = header->slot_no;
  res.daq_header.stream_id = header->fiber_no;
  res.set_channel(starting_channel);
  res.set_timestamp(timestamp);
  res.header.extra_data = 0xdeadbeef0badface;
  return res;
}