JAcousticsMonitor_short.cc File Reference

Example program to monitor acoustic events rate per emitter and receiver and run. More...

#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 "JLang/JPredicate.hh"
#include "JAcoustics/JEvent.hh"
#include "JAcoustics/JSupport.hh"
#include "Jeep/JContainer.hh"
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Example program to monitor acoustic events rate per emitter and receiver and run.

Output: histogram of the acoustic event rate per emitter and run.

Author

mdejong, cgatius

Definition in file JAcousticsMonitor_short.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 45 of file JAcousticsMonitor_short.cc.

{
  using namespace std;
  using namespace JPP;
 
  JMultipleFileScanner<>  inputFile;
  JLimit_t&               numberOfEvents = inputFile.getLimit();
  string                  outputFile;
  string                  detectorFile;
  int                     debug;
  double                  lifetime_s;
 
  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['d'] = make_field(debug)            = 2;
    zap['l'] = make_field(lifetime_s, "run lifetime in seconds");
    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, TH2D> H2(new TH2D("H[%].event",        NULL,
                                  string.size(),              -0.5, string.size()         - 0.5, 
                                  floor.getUpperLimit() + 1, - 0.5, floor.getUpperLimit() + 0.5));
  
  for (Int_t i = 1; i <= H2->GetXaxis()->GetNbins(); ++i) {
    H2->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));
  }
 
  typedef JTreeScanner<JEvent, JEvent::JEvaluator>  JTreeScanner_t;
 
  JTreeScanner_t in(inputFile);
 
  for (JTreeScanner_t::iterator event = in.begin(); event != in.end(); ++event) {
 
    JQuantile QD("", true), QQ;
 
    TH2D* h2 = H2[event->getID()];
 
    map<int, set<double> > buffer;
 
    for (JEvent::const_iterator i = event->begin(); i != event->end(); ++i) {
      buffer[i->getID()].insert(i->getQ());
    }
    
    for (map<int, set<double> >::const_iterator i = buffer.begin(); i != buffer.end(); ++i) {
 
      if (receivers.has(i->first)) {
 
        const JLocation& location = receivers[i->first];
 
        h2->Fill((double) string.getIndex(location.getString()), (double) location.getFloor(), 1.0/lifetime_s);
      }
    }
  }
  STATUS(endl);
  
  TFile out(outputFile.c_str(), "recreate");
 
  out <<  H2;
 
  out.Write();
  out.Close();
}