JAcousticsMonitor.cc File Reference

Example program to monitor acoustic events. More...

#include <iostream>
#include <iomanip>
#include <limits>
#include <map>
#include <algorithm>
#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.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 "JDetector/JTripod.hh"
#include "JDetector/JTransmitter.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"
#include "JROOT/JRootToolkit.hh"
#include "JROOT/JManager.hh"
#include "JLang/JComparator.hh"
#include "JAcoustics/JEmitter.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.

Author

mdejong

Definition in file JAcousticsMonitor.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 78 of file JAcousticsMonitor.cc.

{
  using namespace std;
  using namespace JPP;

  typedef JContainer< vector<JTripod> >      tripods_container;
  typedef JContainer< vector<JTransmitter> > transmitters_container;

  JMultipleFileScanner<>  inputFile;
  JLimit_t&               numberOfEvents = inputFile.getLimit();
  string                  outputFile;
  string                  detectorFile;
  tripods_container       tripods;                              // tripods
  transmitters_container  transmitters;                         // transmitters
  double                  Q;
  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['T'] = make_field(tripods,         "tripod data")                    = JPARSER::initialised();
    zap['Y'] = make_field(transmitters,    "transmitter data")               = JPARSER::initialised();
    zap['Q'] = make_field(Q)                = 0.9;
    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);
  }

  sort(detector.begin(), detector.end(), make_comparator(&JModule::getLocation));

  JHashMap<int, JModule_t>   receivers;
  JHashMap<int, JPosition3D> emitters;
  
  for (JDetector::const_iterator i = detector.begin(); i != detector.end(); ++i) {
    receivers[i->getID()] = JModule_t(i->getLocation(), i->getPosition());
  }

  for (tripods_container::const_iterator i = tripods.begin(); i != tripods.end(); ++i) {
    emitters[i->getID()]  = (i->getUTMPosition() - detector.getUTMPosition());
  }

  for (transmitters_container::const_iterator i = transmitters.begin(); i != transmitters.end(); ++i) {
    try {
      emitters[i->getID()]  = (i->getPosition() + detector.getModule(i->getLocation()).getPosition());
    }
    catch(const exception&) {
      continue;                                                       // if no module available, discard transmitter
    }
  }

  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, 201, -0.5, 200.5));
  JManager<int, TH1D> HC(new TH1D("H[%].time",         NULL, 800,  0.0,   4.0));
  JManager<int, TH1D> HD(new TH1D("H[%].rms",          NULL, 500,  0.0,   1.0e-1));
  JManager<int, TH1D> HE(new TH1D("H[%].quantile",     NULL, 500,  0.0,   1.0e-1));
  JManager<int, TH1D> HQ(new TH1D("H[%].quality",      NULL, 200,  0.0,   8.0));
  JManager<int, TH2D> HR(new TH2D("H[%].QR",           NULL, 40, 1.5, 3.5, 40, 3.0, 7.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));

  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));
  }

  JManager<int, TH2D> H3((TH2D*) H2->Clone("H[%].doubles"));


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

  counter_type counter = 0;
  
  for (JMultipleFileScanner<>::const_iterator i = inputFile.begin(); i != inputFile.end(); ++i) {

    JTreeScanner_t in(*i);

    JHashMap<int, double> toe;

    for (JTreeScanner_t::iterator event = in.begin(); event != in.end() && counter != inputFile.getLimit(); ++event, ++counter) {

      if (counter%1000 == 0) {
        STATUS("event " << setw(8) << counter << '\r'); DEBUG(endl);
      }

      const JEvent evt = *event;

      JQuantile Q1("", true);

      for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
        Q1.put(i->getToE());
      }

      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(Q1.getSTDev());
      HE[evt.getID()]->Fill(Q1.getQuantile(Q, JQuantile::symmetric_t));
    
      toe[evt.getID()] = evt.begin()->getToE();

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

      for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
        hq->Fill(log10(i->getQ()));
      }

      if (emitters.has(evt.getID())) {

        const JPosition3D& p0 = emitters[evt.getID()];
      
        for (JEvent::const_iterator i = evt.begin(); i != evt.end(); ++i) {
          if (receivers.has(i->getID())) {
            HR->Fill(log10(p0.getDistance(receivers[i->getID()])), log10(i->getQ()));
            hr->Fill(log10(p0.getDistance(receivers[i->getID()])), log10(i->getQ()));
          }
        }
      }
      
      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());

        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() >= 2u) {
            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 << HR << *HR << H1 << H2 << H3;

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