JTriggerMonitor.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <iomanip>

#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"

#include "JDAQ/JDAQ.hh"
#include "JDAQ/JDAQEvent.hh"
#include "JDAQ/JDAQTimeslice.hh"
#include "JDAQ/JDAQSummaryslice.hh"
#include "JDAQ/JDAQTriggerMask.hh"

#include "JTrigger/JTriggerParameters.hh"
#include "JTrigger/JTriggerBits.hh"

#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JSupport.hh"
#include "JROOT/JRootToolkit.hh"

#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"


static const int WIDTH = 20;


/**
 * Print histogram parameters.
 *
 * \param  h1       histogram
 * \param  out      output stream
 */
inline void print(const TH1& h1, std::ostream& out)
{
  using namespace std;

  out << setw(WIDTH) << left << h1.GetName() << ' '
      << FIXED(8,0)  << h1.GetEntries()      << ' '
      << FIXED(8,2)  << h1.GetMean()         << ' '
      << FIXED(8,2)  << h1.GetRMS()          << ' '
      << endl;
}


/**
 * \file
 *
 * Auxiliary program to histogram and print trigger statistics.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace KM3NETDAQ;
  using namespace JPP;

  JMultipleFileScanner<>     inputFile;
  JLimit_t& numberOfEvents = inputFile.getLimit();
  string                     outputFile;
  JDAQClock          clock;
  int                debug;

  try {

    JParser<> zap("Auxiliary program to histogram and print trigger statistics.");

    zap['f'] = make_field(inputFile);
    zap['o'] = make_field(outputFile)          = "monitor.root";
    zap['n'] = make_field(numberOfEvents)      = JLimit::max();
    zap['c'] = make_field(clock)               = JDAQClock::KM3NET, JDAQClock::PPM_DU, JDAQClock::ANTARES;
    zap['d'] = make_field(debug)               = 1;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }


  cout.tie(&cerr);


  TH1D h1("Timeslice", NULL, 100, 0.0, 1.0e3);
  TH1D h2("Event    ", NULL, 100, 0.0, 1.0e1);
  TH1D h3("Summary  ", NULL, 100, 0.0, 1.0e1);

  TH1D hm("Trigger  mask ", NULL, NUMBER_OF_TRIGGER_BITS, -0.5, NUMBER_OF_TRIGGER_BITS - 0.5);
  TH1D hn("Trigger  hits ", NULL, 1000, -0.5,  1000 - 0.5);
  TH1D hs("Snapshot hits ", NULL, 1000, -0.5, 10000 - 0.5);
  TH1D hr("PMT rate [kHz]", NULL,  100,  0.0,    50.0);


  JTriggerParameters trigger_parameters;
  long long int      numberOfTimeslices    = 0;
  long long int      numberOfSummaryslices = 0;


  for (JMultipleFileScanner<JTriggerParameters> input = inputFile; input.hasNext(); ) {

    trigger_parameters = *input.next();

    NOTICE(trigger_parameters << endl);
  }


  for (JMultipleFileScanner<JDAQTimeslice> input = inputFile; input.hasNext(); ++numberOfTimeslices) {

    STATUS("entry: " << setw(10) << input.getCounter() << '\r'); DEBUG(endl);

    const JDAQTimeslice* object = input.next();

    h1.Fill((Double_t) object->getSize() * 1e-6);
  }


  for (JMultipleFileScanner<JDAQEvent> input = inputFile; input.hasNext(); ) {

    STATUS("entry: " << setw(10) << input.getCounter() << '\r'); DEBUG(endl);

    const JDAQEvent* object = input.next();

    h2.Fill((Double_t) object->getSize() * 1e-6);

    hn.Fill((Double_t) object->size<JDAQTriggeredHit>());
    hs.Fill((Double_t) object->size<JDAQSnapshotHit> ());
    
    for (unsigned int i = 0; i != NUMBER_OF_TRIGGER_BITS; ++i) {
      if (object->hasTriggerBit(i)) {
        hm.Fill((Double_t) i);
      }
    }

    {
      unsigned int n = 0;

      typedef JDAQSnapshotHit JHit_t;
      
      for (JDAQEvent::const_iterator<JHit_t> i = object->begin<JHit_t>(); i != object->end<JHit_t>(); ++i) {
        
        if (object->getTriggerMask(*i) != 0) {
          ++n;
        }
      }
      
      if (object->size<JHit_t>() != 0 && n != object->size<JDAQTriggeredHit>()) {
        ERROR("Number of snapshot hits with trigger mask " << n << " != " << object->size<JDAQTriggeredHit>() << endl);
      }
    }
  }


  for (JMultipleFileScanner<JDAQSummaryslice> input = inputFile; input.hasNext(); ++numberOfSummaryslices) {

    STATUS("entry: " << setw(10) << input.getCounter() << '\r'); DEBUG(endl);

    const JDAQSummaryslice* object = input.next();

    h3.Fill((Double_t) object->getSize() * 1e-6);

    for (JDAQSummaryslice::const_iterator i = object->begin(); i != object->end(); ++i) {
      for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
        hr.Fill(i->getRate(pmt) * 1.0e-3);
      }
    }
  }


  if (debug >= JEEP::status_t) {
    print(h1, cout);
    print(h2, cout);
    print(h3, cout);
    print(hn, cout);
    print(hs, cout);
    print(hr, cout);
  }

  NOTICE(endl);
  NOTICE("Background rate estimate from snapshot hits " << setprecision(2) 
         << (hs.GetMean() - hn.GetMean()) * numberOfSummaryslices / (hr.GetEntries() * 2e-6 * trigger_parameters.TMaxEvent_ns)
         << " [kHz]" << endl);
  NOTICE(endl);
    
  long long int numberOfSlices = 0;


  if (numberOfSlices == 0) numberOfSlices = numberOfTimeslices    * trigger_parameters.writeTimeslices.prescale;
  if (numberOfSlices == 0) numberOfSlices = numberOfSummaryslices * trigger_parameters.writeSummary   .prescale;


  const double T = numberOfSlices * 1.0e-9 * getFrameTime();    // [s]

  NOTICE(setw(WIDTH) << left << "Total run duration (based on time slices) [s] " << FIXED(7,1) << T << endl);


  for (Int_t i = 1; i <= hm.GetNbinsX(); ++i) {

    const Double_t x = hm.GetBinCenter (i);
    const Double_t y = hm.GetBinContent(i);

    if (y != 0.0) {

      NOTICE("Trigger"
             << "[" << setw(2) << (int) x << "]"      << ' '
             << setw(16) << left << getTriggerName(x) << ' '
             << FIXED(7,0) << y);

      if (numberOfSlices != 0) {
        NOTICE(FIXED(7,2) << y / T << " [Hz]");
      }

      NOTICE(endl);
    }
  }
  
  NOTICE("Total  "
         << setw(4)  << " " << ' '
         << setw(16) << " " << ' '
         << FIXED(7,0) << h2.GetEntries());

  if (numberOfSlices != 0) {
    NOTICE(FIXED(7,2) << h2.GetEntries() / T << " [Hz]");
  }

  NOTICE(endl);

  TFile out(outputFile.c_str(), "recreate");

  out << h1 << h2 << h3;
  out << hm << hn << hs << hr;

  out.Write();
  out.Close();
}