JCompareSummaryslice.cc

Go to the documentation of this file.

 
#include <string>
#include <iostream>
#include <iomanip>
#include <map>
 
#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.h"
 
#include "JDAQ/JDAQSummarysliceIO.hh"
 
#include "JSupport/JSummaryFileRouter.hh"
#include "JSupport/JSingleFileScanner.hh"
#include "JSupport/JSupportToolkit.hh"
#include "JSupport/JSupport.hh"
            
#include "JDetector/JPMTIdentifier.hh"
 
#include "JTools/JRange.hh"
 
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
 
namespace {
 
  using KM3NETDAQ::JDAQSummaryFrame;
 
  static const double factor  =  1.0e-3;   // conversion factor [kHz]
 
  /**
   * Write DAQ frame status to output stream.
   *
   * \param  out                  output stream
   * \param  status               DAQ frame status
   * \return                      output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const KM3NETDAQ::JDAQFrameStatus& status)
  {
    using namespace std;
 
    out << ' ' << setw(8)  << setfill('0') << hex << status.getStatus()     << dec << setfill(' ');
    out << '|' << setw(8)  << setfill('0') << hex << status.getFIFOStatus() << dec << setfill(' ');
    out << ' ' << setw(2)  << status.getUDPNumberOfReceivedPackets();
    out << ' ' << setw(2)  << status.getUDPMaximalSequenceNumber();
 
    return out;
  }
 
  /**
   * Auxiliary data structure for printing summary data.
   */
  struct printer {
    /**
     * Constructor.
     *
     * \param  frame             summary frame
     * \param  pmt               PMT
     */
    printer(const JDAQSummaryFrame& frame, const int pmt) :
      frame(frame),
      pmt   (pmt)
    {}
 
    /**
     * Write summary data to output stream.
     *
     * \param  out               output stream
     * \param  object            printer
     * \return                   output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const printer& object)
    {
      using namespace std;
 
      return out << SCIENTIFIC(9,3) << object.frame.getRate(object.pmt, factor)  << ' '
                 << object.frame.testHighRateVeto(object.pmt)    
                 << object.frame.testFIFOStatus  (object.pmt)                    << ' '
                 << setw(3) << object.frame.getUDPMaximalSequenceNumber()        << '/'
                 << setw(3) << object.frame.getUDPNumberOfReceivedPackets()      << ' '
                 << object.frame.hasUDPTrailer();
    }
    
  protected:
    const JDAQSummaryFrame& frame;
    const int pmt; 
  };
}
 
 
/**
 * \file
 * Auxiliary program to compare summary data.
 *
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;
 
  pair<string, string>   inputFile;
  string                 outputFile;
  JLimit_t               numberOfEvents;
  JRange<double>         rate_kHz;
  int                    debug;
 
  try { 
 
    JParser<> zap("Auxiliary program to compare summary data.");
    
    zap['f'] = make_field(inputFile,           "pair of input files");
    zap['o'] = make_field(outputFile,          "output file")            = "summary.root";
    zap['n'] = make_field(numberOfEvents)                                = JLimit::max();
    zap['R'] = make_field(rate_kHz,            "accepted range [kHz]")   = JRange<double>(-0.1, +0.1);
    zap['d'] = make_field(debug,               "debug")                  = 0;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
  JSummaryFileRouter router(inputFile.second);
 
  TFile out(outputFile.c_str(), "recreate");
 
  TH1D  h0("h0", NULL, 200, -2.0, +2.0);
  TH2D  h1("h1", NULL, JDAQRate::getN(), JDAQRate::getData(factor), JDAQRate::getN(), JDAQRate::getData(factor));
  TH2D  h2("h2", NULL,    2,   -0.5,   +1.5,    2,   -0.5,   +1.5);
  TH2D  h3("h3", NULL,    2,   -0.5,   +1.5,    2,   -0.5,   +1.5);
  TH2D  h4("h4", NULL,  100,    0.0,  100.0,  100,    0.0,  100.0);
  TH2D  h5("h5", NULL,  100,    0.0,  100.0,  100,    0.0,  100.0);
  TH2D  h6("h6", NULL,    2,   -0.5,   +1.5,    2,   -0.5,   +1.5);
 
  TH2D  ha("ha", NULL, JDAQRate::getN(), JDAQRate::getData(factor), 200,  -10.0,  +10.0);
  TH2D  hb("hb", NULL, JDAQRate::getN(), JDAQRate::getData(factor), 513, -256.5, +256.5);
 
  size_t counts = 0;
  size_t misses = 0;
 
  struct {
    map<int, size_t>  counts;
    map<int, size_t>  misses;
  } module;
 
  struct {
    map<JPMTIdentifier, size_t>  counts;
    map<JPMTIdentifier, size_t>  misses;
    map<JPMTIdentifier, size_t>  errors;
  } PMT;
 
 
  for (JSingleFileScanner<JDAQSummaryslice> in(inputFile.first, numberOfEvents); in.hasNext(); ) {
 
    STATUS("event: " << setw(10) << in.getCounter() << '\r'); DEBUG(endl);
 
    const JDAQSummaryslice* const p = in.next();
 
    router.update(*p);
 
    counts += 1;
 
    DEBUG("frame index: " << setw(6) << p->getFrameIndex() << ' ' << p->getTimesliceStart() << " / " << setw(6) << router.getFrameIndex() << ' ' << router.getTimesliceStart() << endl);
 
    if (p->getFrameIndex() == router.getFrameIndex()) {
 
      for (JDAQSummaryslice::const_iterator i = p->begin(); i != p->end(); ++i) {
 
        const JDAQSummaryFrame& f1 = *i;
 
        module.counts[f1.getModuleID()] += 1;
 
        if (router.hasSummaryFrame(f1.getModuleID())) {
 
          const JDAQSummaryFrame& f2 = router.getSummaryFrame(f1.getModuleID());
 
          for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
 
            const JPMTIdentifier id(f1.getModuleID(), pmt);
 
            if (debug >= debug_t || !rate_kHz(f2.getRate(pmt, factor) - f1.getRate(pmt, factor))) {
              cout << "PMT " << id << ' ' << printer(*i,pmt) << " -> " << printer(f2,pmt) << endl;
            }
 
            PMT.counts[id] += 1;
 
            if ((f2.testHighRateVeto(pmt) != f1.testHighRateVeto(pmt))  ||
                (f2.testFIFOStatus  (pmt) != f1.testFIFOStatus  (pmt))) {
              PMT.misses[id] += 1;
            }
 
            if (!rate_kHz(f2.getRate(pmt, factor) - f1.getRate(pmt, factor))) {
              PMT.errors[id] += 1;
            }
 
            ha.Fill(f1.getRate(pmt, factor), f1.getRate(pmt, factor) - f2.getRate(pmt, factor));
            hb.Fill(f1.getRate(pmt, factor), (int) f1.getValue(pmt)  - (int) f2.getValue(pmt));
            h0.Fill(f1.getRate         (pmt, factor) - f2.getRate         (pmt, factor));
            h1.Fill(f1.getRate         (pmt, factor),  f2.getRate         (pmt, factor));
            h2.Fill(f1.testHighRateVeto(pmt),          f2.testHighRateVeto(pmt));
            h3.Fill(f1.testFIFOStatus  (pmt),          f2.testFIFOStatus  (pmt));
          }
 
          h4.Fill(f1.getUDPMaximalSequenceNumber(),    f2.getUDPMaximalSequenceNumber());
          h5.Fill(f1.getUDPNumberOfReceivedPackets(),  f2.getUDPNumberOfReceivedPackets());
          h6.Fill(f1.hasUDPTrailer(),                  f2.hasUDPTrailer());
 
        } else {
 
          module.misses[f1.getModuleID()] += 1;
        }
      }
    } else {
 
      misses += 1;
    }
  }
  STATUS(endl);
 
  cout << "Number of slice misses "<< setw(6) << misses << '/' << setw(6) << counts << endl;
 
  for (const auto& i : module.misses) {
    cout << "Number of module misses " << setw(8) << i.first << ' ' << setw(6) << i.second << '/' << setw(6) << module.counts[i.first] << endl;
  }
 
  for (const auto& i : PMT.misses) {
    cout << "Number of PMT misses "    << i.first << ' ' << setw(6) << i.second << '/' << setw(6) << PMT.counts[i.first] << endl;
  }
 
  for (const auto& i : PMT.errors) {
    cout << "Number of PMT errors "    << i.first << ' ' << setw(6) << i.second << '/' << setw(6) << PMT.counts[i.first] << endl;
  }
 
  out.Write();
  out.Close();
}