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();
    }
  }
}