print.cpp

Go to the documentation of this file.

#include "print.hpp"

#include <iostream>
#include <iomanip>
#include <sstream>
#include <cctype>

#include <DataFormats/infoword.hh>
#include "structs.hpp"
#include "datatypes.hpp"

/**
 * \author cpellegrino
 */

struct DOMID_h
{
  uint32_t m_val;
  DOMID_h(uint32_t val)
  : m_val(val)
  {}
};

std::ostream& operator <<(std::ostream& stream, DOMID_h const& domid)
{
  /*
   * The MAC address of a WR node starts with 08:00:30.
   * The DOMID is defined by the MAC address removing the initial 08:00.
   */

  std::ostringstream oss("0800", std::ostringstream::ate);
  oss << std::hex << domid.m_val;
  if (oss.tellp() != 12) {
    return stream << "undefined";
  }

  std::string const no = oss.str();
  std::size_t const s = no.size();
  for (std::size_t i = 0; i < s; i += 2) {
    stream
      << char(std::toupper(no[i]))
      << char(std::toupper(no[i + 1]))
      << (i != s - 2 ? ":" : "");
  }

  return stream;
}

void print_header(
    CLBCommonHeader const& header
  , dom_map_type const& name_map
) {
  bool const valid = validTimeStamp(header);
  bool const trailer = isTrailer(header);

  std::string name("");
  if (! name_map.empty()) {
    dom_map_type::const_iterator const it
        = name_map.find(header.domIdentifier());

    if (it != name_map.end()) {
      name = " - " + it->second;
    } else {
      name = " - unknown";
    }
  }

  std::cout
      << "DataType:          " << header.dataType()           << '\n'
      << "RunNumber:         " << header.runNumber()          << '\n'
      << "UDPSequenceNumber: " << header.udpSequenceNumber()  << '\n'

      << "Timestamp:\n"
      << "          Seconds: " << header.timeStamp().sec()    << '\n'
      << "          Tics:    " << header.timeStamp().tics()   << '\n'
      << "          " << UTCTime_h(header.timeStamp(), valid) << '\n'

      << "DOMIdentifier:     " << header.domIdentifier()
      <<  " (MAC: " << DOMID_h(header.domIdentifier()) << name << ')' << '\n'
      << "DOMStatus 1:       " << header.domStatus(1) << '\n'
      << "DOMStatus 2:       " << header.domStatus(2);

  if (trailer && header.dataType() == ttdc) {
    std::cout << " (trailer)\n";
  } else {
    std::cout << '\n';
  }

  std::cout
      << "DOMStatus 3:       " << header.domStatus(3) << '\n'
      << "DOMStatus 4:       " << header.domStatus(4) << std::endl;
}

void print_optical_data(
    const char* const buffer,
    ssize_t buffer_size,
    int max_col
) {
  unsigned int const nhits =
      (buffer_size - sizeof(CLBCommonHeader)) / sizeof(hit_t);

  std::cout << "Number of hits: " << nhits << '\n';

  if (nhits) {
    const int printing = 20 > nhits ? nhits : 20;
    const unsigned int n = max_col > 37 ? max_col / 37 : 1;

    for (int i = 0; i < printing; ++i) {
      const hit_t* const hit = static_cast<const hit_t* const>(
          static_cast<const void* const>(buffer
            + sizeof(CLBCommonHeader)
            + i * sizeof(hit_t)));

      std::cout
        << "Hit"
        << std::setfill('0') << std::setw(2)
        << i
        << ": "
        << *hit << ' ';

      if ((i + 1) % n == 0) {
        std::cout << '\n';
      } else {
        std::cout << "| ";
      }
    }
  }

  std::cout << '\n';
}

void print_acoustic_data(
    const char* const buffer
  , ssize_t buffer_size
  , int max_col
) {
  CLBCommonHeader const* const header = static_cast<CLBCommonHeader const*>(
      static_cast<void const*>(buffer));

  if (
    !  header->udpSequenceNumber()
    && is_infoword(buffer + sizeof(CLBCommonHeader))
  ) {
    std::cout << "InfoWord: yes\n"
              << *static_cast<InfoWord const*>(static_cast<void const*>(
                     buffer + sizeof(CLBCommonHeader)
                 ))
              << '\n';
  } else {
    std::cout << "InfoWord: no\n";
  }
}

void print_monitoring_data(
    const char* const buffer
  , ssize_t buffer_size
  , int max_col
) {
  const unsigned int n = max_col > 14 ? max_col / 14 : 1;

  for (int i = 0; i < 31; ++i) {
    uint32_t const* const field = static_cast<uint32_t const*>(
        static_cast<void const*>(buffer + sizeof(CLBCommonHeader) + i * 4)
    );

    std::cout
      << "CH"
      << std::setfill('0') << std::setw(2)
      << i << ": "
      << std::setfill(' ') << std::setw(6)
      << htonl(*field) << "  ";

    if ((i + 1) % n == 0) {
      std::cout << '\n';
    }
  }

  std::cout << '\n';

  ssize_t const minimum_size = sizeof(CLBCommonHeader) + sizeof(int) * 31;

  if (buffer_size > minimum_size) {
    std::cout
      << "SlowControl data:\n"
      << *static_cast<SCData const*>(static_cast<void const*>(
             buffer + minimum_size
         ))
      << '\n';
  }
}