JAcousticsMonitor.cc

Go to the documentation of this file.

#include <iostream>
#include <iomanip>
#include <limits>
#include <map>

#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TGraph.h"
#include "TGraphErrors.h"

#include "JTools/JHashCollection.hh"
#include "JTools/JHashMap.hh"
#include "JTools/JRange.hh"
#include "JTools/JQuantile.hh"

#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"

#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"

#include "JROOT/JRootToolkit.hh"
#include "JROOT/JManager.hh"

#include "JAcoustics/JEvent.hh"
#include "JAcoustics/JSupport.hh"
#include "JAcoustics/JTriggerParameters.hh"

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


/**
 * \file
 *
 * Example program to monitor acoustic events.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;

  JMultipleFileScanner<>   inputFile;
  JLimit_t&                numberOfEvents = inputFile.getLimit();
  string                   outputFile;
  string                   detectorFile;
  JTriggerParameters       parameters;
  int                      debug;

  try {

    JParser<> zap("Example program to monitor acoustic events.");

    zap['f'] = make_field(inputFile,       "output of JAcousticEventBuilder[.sh]");
    zap['n'] = make_field(numberOfEvents)   = JLimit::max();
    zap['o'] = make_field(outputFile)       = "monitor.root";
    zap['a'] = make_field(detectorFile);
    zap['@'] = make_field(parameters,   "trigger parameters")  =  JPARSER::initialised();
    zap['d'] = make_field(debug)            = 2;

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

  JDetector detector;

  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }

  JHashMap<int, JLocation>   receivers;

  for (JDetector::const_iterator i = detector.begin(); i != detector.end(); ++i) {
    receivers[i->getID()] = i->getLocation();
  }


  const JHashCollection<int> string(make_array(detector.begin(), detector.end(), &JModule::getString));
  const JRange         <int> floor (make_array(detector.begin(), detector.end(), &JModule::getFloor));


  JManager<int, TH1D> HA(new TH1D("H[%].size",         NULL, detector.size() + 1, -0.5, detector.size() + 0.5));
  JManager<int, TH1D> HB(new TH1D("H[%].overlays",     NULL, 101, -0.5, 100.5));
  JManager<int, TH1D> HC(new TH1D("H[%].time",         NULL, 800,  0.0,   4.0));
  JManager<int, TH1D> HD(new TH1D("H[%].rms",          NULL, 200,  0.0,   5.0e-3));
  JManager<int, TH1D> HE(new TH1D("H[%].deviation",    NULL, 200,  0.0,  50.0e-3));
  JManager<int, TH1D> HQ(new TH1D("H[%].quality",      NULL, 200,  0.0,   8.0));
  JManager<int, TH1D> H1(new TH1D("H[%].multiplicity", NULL, 101, -0.5, 100.5));
  JManager<int, TH2D> H2(new TH2D("H[%].event",        NULL,
                                  string.size(),              -0.5, string.size()         - 0.5, 
                                  floor.getUpperLimit() + 1, - 0.5, floor.getUpperLimit() + 0.5));
  JManager<int, TH2D> H3((TH2D*) H2->Clone("H[%].doubles"));

  JManager<int, TGraph> GA(new TGraph(), "G[%].size");
  JManager<int, TGraph> GD(new TGraph(), "G[%].rms");
  JManager<int, TGraph> GE(new TGraph(), "G[%].deviation");
  JManager<int, TGraph> GQ(new TGraph(), "G[%].quality");
  
  for (Int_t i = 1; i <= H2->GetXaxis()->GetNbins(); ++i) {
    H2->GetXaxis()->SetBinLabel(i, MAKE_CSTRING(string.at(i-1)));
    H3->GetXaxis()->SetBinLabel(i, MAKE_CSTRING(string.at(i-1)));
  }

  for (Int_t i = 1; i <= H2->GetYaxis()->GetNbins(); ++i) {
    H2->GetYaxis()->SetBinLabel(i, MAKE_CSTRING(i-1));
    H3->GetYaxis()->SetBinLabel(i, MAKE_CSTRING(i-1));
  }

  typedef JTreeScanner<JEvent, JEvent::JEvaluator>  JTreeScanner_t;

  JTreeScanner_t in(inputFile);

  JHashMap<int, double> toe;

  for (JTreeScanner_t::iterator event = in.begin(); event != in.end(); ++event) {

    STATUS("event " << setw(8) << event->getCounter() << '\r'); DEBUG(endl);
    
    JEvent evt = *event;

    evt.remove(parameters.numberOfOutliers, parameters.stdev);

    const double t1 = evt.begin()->getToE();

    JQuantile QD, QQ;

    for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
      QD.put(i->getToE() - t1);
      QQ.put(log10(i->getQ()));
    }

    HA[evt.getID()]->Fill((double) evt.size());
    HB[evt.getID()]->Fill((double) evt.getOverlays());

    if (toe.has(evt.getID())) {
      HC[evt.getID()]->Fill(log10(evt.begin()->getToE() - toe[evt.getID()]));
    }

    HD[evt.getID()]->Fill(QD.getSTDev());
    HE[evt.getID()]->Fill(QD.getDeviation());

    AddPoint(GA[evt.getID()], t1, evt.size());
    AddPoint(GD[evt.getID()], t1, QD.getSTDev());
    AddPoint(GE[evt.getID()], t1, QD.getDeviation());
    AddPoint(GQ[evt.getID()], t1, QQ.getMean());
    
    toe[evt.getID()] = evt.begin()->getToE();

    TH1D* h1 = H1[evt.getID()];
    TH1D* hq = HQ[evt.getID()];
    TH2D* h2 = H2[evt.getID()];
    TH2D* h3 = H3[evt.getID()];

    map<int, set<double> > buffer;

    for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
      buffer[i->getID()].insert(i->getQ());
    }
    
    for (map<int, set<double> >::const_iterator i = buffer.begin(); i != buffer.end(); ++i) {

      h1->Fill((double) i->second.size());

      hq->Fill(log10(*(i->second.rbegin())));

      if (receivers.has(i->first)) {

        const JLocation& location = receivers[i->first];

        h2->Fill((double) string.getIndex(location.getString()), (double) location.getFloor(), 1.0);

        if (i->second.size() > 1u) {
          h3->Fill((double) string.getIndex(location.getString()), (double) location.getFloor(), 1.0);
        }
      }
    }
  }
  STATUS(endl);


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

  out << HA << HB << HC << HD << HE << HQ << H1 << H2 << H3;
  out << GA << GD << GE << GQ;

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