daq_parser.cpp

Go to the documentation of this file.

#include <DataFormats/daq_common_header.hh>
#include <DataFormats/infoword.hh>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <cstring>
#include <sys/ioctl.h>
#include <signal.h>
#include <unistd.h>
#include <vector>
#include <cassert>
 
/**
 * \author cpellegrino
 */
 
const static unsigned int ttdc = 1414808643;
const static unsigned int taes = 1413563731;
 
static int terminal_width;
 
void sig_term_change(int /*signum*/)
{
  static bool const is_a_tty = isatty(1);
 
  if (!is_a_tty) {
    terminal_width = 80;
  } else {
    struct winsize sz;
 
    ioctl(1, TIOCGWINSZ, &sz);
    terminal_width = sz.ws_col;
  }
}
 
struct __attribute__((packed)) hit_t
{
  uint8_t channel;
  uint32_t timestamp;
  uint8_t ToT;
};
 
inline std::ostream& operator <<(std::ostream& stream, const hit_t& hit)
{
  return stream << "C: "
                << std::setfill(' ') << std::setw(2)
                << (unsigned int) hit.channel
 
                << ", T: "
                << std::setfill(' ') << std::setw(6)
                << ntohl(hit.timestamp)
 
                << ", ToT: "
                << std::setfill(' ') << std::setw(6)
                << (unsigned int) hit.ToT;
}
 
void print_acoustic_data(const char* const buffer, ssize_t buffer_size)
{
  if (is_infoword(buffer))
  {
    std::cout << "InfoWord: yes\n"
              << *static_cast<const InfoWord* const>(static_cast<const void* const>(
                  buffer))
              << '\n';
  }
  else
  {
    std::cout << "InfoWord: no\n";
  }
}
 
void print_summary(hit_t const* const hits, std::size_t nhits)
{
  int wrong = 0;
  std::vector<int> summary(31, 0);
  for (unsigned i = 0; i < nhits; ++i) {
    if (hits[i].channel < 0 || hits[i].channel > 30) {
      ++wrong;
    } else {
      ++summary[hits[i].channel];
    }
  }
 
  int const n = terminal_width > 11 ? terminal_width / 11 : 1;
 
  for (unsigned i = 0; i < summary.size(); ++i) {
    std::cout << "CH" << std::setfill('0') << std::setw(2) << i
              << ": " << std::setfill(' ') << std::setw(4) << summary[i] << ' ';
 
    if ((i + 1) % n == 0) {
      std::cout << '\n';
    }
  }
 
  std::cout << '\n';
 
  if (wrong) {
    std::cout << "wrong channels: " << wrong << '\n';
  }
}
 
void print_optical_data(const char* const buffer, ssize_t buffer_size)
{
  const unsigned int nhits = buffer_size / sizeof(hit_t);
 
  std::cout << "Number of hits: " << nhits << '\n';
 
  const hit_t* const hits = static_cast<const hit_t* const>(
      static_cast<const void* const>(buffer)
  );
 
  if (nhits) {
    const int printing = 20 > nhits ? nhits : 20;
    const unsigned int n = terminal_width > 37 ? terminal_width / 37 : 1;
 
    for (int i = 0; i < printing; ++i)
    {
      std::cout << "Hit"
                << std::setfill('0') << std::setw(2)
                << i
                << ": "
                << hits[i] << ' ';
 
      if ((i + 1) % n == 0)
      {
       std::cout << '\n';
      }
      else
      {
        std::cout << "| ";
      }
    }
  }
  std::cout << '\n';
 
  print_summary(hits, nhits);
}
 
void parseData(std::istream& stream)
{
  int count = 0;
  std::vector<char> payload;
 
  while (stream)
  {
    DAQCommonHeader header;
    stream.read((char*) &header, sizeof(header));
 
    if (stream.gcount() != sizeof(header))
    {
      return;
    }
 
    std::cout << "Counter: " << ++count << '\n';
    std::cout << DAQHeaderPrinter(&header) << '\n';
 
    assert(header.FrameLength - sizeof(header) >= 0 && "Wrong frame length.");
 
    std::size_t const payload_size = header.FrameLength - sizeof(header);
 
    if (payload.capacity() < payload_size)
    {
      payload.resize(payload_size);
    }
 
    stream.read((char*) payload.data(), payload_size);
 
    if (static_cast<std::size_t>(stream.gcount()) != payload_size)
    {
      return;
    }
 
    if (header.DataType == ttdc) {
      print_optical_data(payload.data(), payload_size);
    } else if (header.DataType == taes) {
      print_acoustic_data(payload.data(), payload_size);
    } else {
      std::cout << "Unknown data type\n";
    }
 
    std::cout << ' ' << std::string((terminal_width > 3 ? terminal_width - 2 : 1), '=') << " \n";
  }
}
 
int main(int argc, char* argv[])
{
  if (argc > 1)
  {
    if (strcmp(argv[1], "-h") == 0)
    {
      std::cout << "Usage: " << argv[0] << " [-h] [filename]\n"
                << "Options:\n"
                << "-h shows this help\n"
                << "filename: if specified reads from file, otherwise stdin is used\n";
      return 0;
    }
  }
 
  // Initialise the terminal_width global variable
  sig_term_change(0);
 
  // Set the signal callback funciton for signal 28 (SIGWINCH, window changed)
  signal(SIGWINCH, sig_term_change);
 
  if (argc == 1)
  {
    parseData(std::cin);
  }
  else
  {
    std::ifstream input_file(argv[1], std::ios::binary);
    parseData(input_file);
  }
}