raw_data_converter.cpp

Go to the documentation of this file.

/**
 
   Program name: RawDataConverter
 
   Description:
   This program converts dump raw data into the DAQ frame format.
 
   Use
   $ RawDataConverter -h
   for a detailed help.
 
   Author: Carmelo Pellegrino
   E-mail: carmelo.pellegrino@bo.infn.it
   Date:   29 April 2015
 
   \author  Carmelo Pellegrino
*/
 
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <fstream>
#include <list>
#include <cstring>
 
#include <DataFormats/daq_common_header.hh>
#include <DataFormats/clb_common_header.hh>
#include <FrameFactory/frame.hh>
#include <FrameFactory/input_buffer_collector.hh>
#include <FrameFactory/puzzled_frame.hh>
#include <external/dq_dump_file/dqdumpfile.hh>
 
#include <boost/program_options.hpp>
namespace po = boost::program_options;
 
inline
int64_t abs_time(Packet const& p)
{
  return p.CLBHeader()->timeStamp().tics() * 16 + p.CLBHeader()->timeStamp().sec() * 1000000000LL;
}
 
struct ID {
  int64_t abs_time;
  uint32_t domid;
};
 
bool operator ==(Packet const& p, ID const& id)
{
  int64_t const time = abs_time(p);
  uint32_t const domid = p.CLBHeader()->domIdentifier();
 
  return time == id.abs_time && domid == id.domid;
}
 
int main(int argc, char* argv[])
{
  std::string input_filename;
  std::string output_filename;
  uint64_t run_start_time = 0;
  int timeslice_duration = 100;
  unsigned int detector_id = 0;
 
  po::options_description desc("Options");
  desc.add_options()
    ("help,h",     "Print this help and exit.")
    ("input,i",
     po::value<std::string>(&input_filename)->required(),
     "Set the name of the dump data file.")
    ("output,o",
     po::value<std::string>(&output_filename)->required(),
     "Set the name of the output DAQ file.")
    ("runstart,s",
     po::value<uint64_t>(&run_start_time)->default_value(run_start_time),
     "Set the run start time.")
    ("timeslice,t",
     po::value<int>(&timeslice_duration)->default_value(timeslice_duration),
     "Set the value of the time slice duration in milliseconds.")
    ("detector-id,",
     po::value<unsigned int>(&detector_id)->default_value(detector_id),
     "Set the detector id.");
 
  try {
    po::variables_map vm;
    po::store(
              po::command_line_parser(argc, argv).options(desc).run(),
              vm);
 
    if (vm.count("help")) {
      std::cout << desc << std::endl;
      return EXIT_SUCCESS;
    }
 
    po::notify(vm);
  } catch (const po::error& e) {
    std::cerr << "RawDataConverter: Error: " << e.what() << '\n'
              << desc << std::endl;
    return EXIT_FAILURE;
  } catch (const std::runtime_error& e) {
    std::cerr << "RawDataConverter: Error: " << e.what() << '\n'
              << desc << std::endl;
    return EXIT_FAILURE;
  }
 
  DumpFile df(input_filename);
 
  assert(df.size() && "It seems that the file that you provided is empty");
 
  std::list<Packet> all_data;
 
  std::set<uint32_t> dom_ids;
  std::set<int64_t> times;
 
  for (DumpFile::iterator it = df.begin(), et = df.end(); it != et; ++it) {
    Packet const p = *it;
 
    dom_ids.insert(p.CLBHeader()->domIdentifier());
 
    int64_t const time = abs_time(p);
    times.insert(time);
 
    all_data.push_back(*it);
  }
 
  std::cout << all_data.size() << " datagrams found\n";
 
  std::ofstream outfile(output_filename.c_str());
 
  int const print_suppression_factor = all_data.size() > 50 ? all_data.size() / 50 : 1;
 
  Frame frame;
 
  PuzzledFrame pframe;
 
  ID id;
 
  for (std::set<int64_t>::const_iterator tit = times.begin(), tet = times.end(); tit != tet ; ++tit) {
    id.abs_time = *tit;
    for (std::set<uint32_t>::const_iterator it = dom_ids.begin(), et = dom_ids.end(); it != et; ++it) {
      id.domid = *it;
 
      std::list<Packet>::iterator dg = all_data.begin();
      bool found = false;
 
      while (true) {
        dg = std::find(dg, all_data.end(), id);
 
        if (dg == all_data.end()) {
          break;
        }
 
        found = true;
        Packet const& p = *dg;
 
        CLBDataGram* const datagram = InBufferCollector::getCollector().getEmptyDataGram();
 
        std::memcpy(datagram->raw(), p.data(), p.size());
        datagram->resize(p.size());
 
        pframe.setDataType(p.CLBHeader()->dataType());
        pframe.setDetectorId(detector_id);
 
        std::pair<uint32_t, bool> const seq_num = seq_number(
                                                             *p.CLBHeader(),
                                                             run_start_time,
                                                             timeslice_duration
                                                             );
 
        if (seq_num.second) {
          pframe.setSeqNumber(seq_num.first);
 
          pframe.setFrameIndex(
                               data2idx(
                                        *p.CLBHeader(),
                                        run_start_time,
                                        timeslice_duration
                                        )
                               );
 
          pframe.insert(datagram);
        } else {
          std::cerr
            << "Datagram timestamp before the start of the run:\n"
            << *p.CLBHeader() << '\n';
        }
 
        all_data.erase(dg++);
      }
 
      if (all_data.size() % print_suppression_factor == 0)
        std::cout << std::setfill(' ')
                  << std::setw(3)
                  << 100 - static_cast<int>(all_data.size() * 100. / df.size())
                  << "%\r" << std::flush;
 
      if (found) {
        pframe.getFrame(frame);
        if (frame.size() && frame.getNItems()) outfile.write(frame.data(), frame.size());
      }
      pframe.reset();
    }
  }
}