JHydrophone.cc File Reference

Example program to plot hydrophone data. More...

#include <iostream>
#include <iomanip>
#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "JDB/JToAshort.hh"
#include "JDB/JSupport.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JTripod.hh"
#include "JDetector/JHydrophone.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"
#include "JTools/JHashMap.hh"
#include "JROOT/JManager.hh"
#include "JAcoustics/JEmitterID.hh"
#include "JAcoustics/JSoundVelocity.hh"
#include "JAcoustics/JEmitter.hh"
#include "JAcoustics/JReceiver.hh"
#include "JAcoustics/JTransceiver.hh"
#include "JAcoustics/JAcousticsToolkit.hh"
#include "JAcoustics/JAcousticsSupportkit.hh"
#include "JAcoustics/JHit.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 plot hydrophone data.

Author

mdejong

Definition in file JHydrophone.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 115 of file JHydrophone.cc.

{
  using namespace std;
  using namespace JPP;

  typedef JContainer< vector<JTripod> >      tripods_container;
  typedef JContainer< vector<JHydrophone> >  hydrophones_container;

  JMultipleFileScanner<JEvent>    inputFile;
  JMultipleFileScanner<JToAshort> toashortFile;
  string                  detectorFile;
  JLimit_t&               numberOfEvents = inputFile.getLimit();
  string                  outputFile;
  JSoundVelocity          V              = getSoundVelocity;    // default sound velocity
  tripods_container       tripods;                              // tripods
  hydrophones_container   hydrophones;                          // hydrophones
  int                     debug;

  try {

    JParser<> zap("Example program to plot hydrophone data.");

    zap['f'] = make_field(inputFile);
    zap['n'] = make_field(numberOfEvents)   = JLimit::max();
    zap['i'] = make_field(toashortFile);
    zap['o'] = make_field(outputFile)       = "hydrophone.root";
    zap['a'] = make_field(detectorFile);
    zap['V'] = make_field(V,            "sound velocity")                    = JPARSER::initialised();
    zap['T'] = make_field(tripods,      "tripod data");
    zap['H'] = make_field(hydrophones,  "hydrophone data")                   = JPARSER::initialised();
    zap['W'] = make_field(getEmitterID, "waveform identification data")      = 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);
  }

  V.set(detector.getUTMZ());

  JHashMap<int, JReceiver> receivers;
  JHashMap<int, JEmitter>  emitters;

  for (hydrophones_container::const_iterator i = hydrophones.begin(); i != hydrophones.end(); ++i) {

    for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module) {

      if (i->getLocation() == module->getLocation()) {

        receivers[module->getID()] = JReceiver(module->getID(),
                                               module->getPosition() + i->getPosition(),
                                               module->getT0() * 1.0e-9);
        break;
      }
    }
  }

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


  map<int, vector<double> > buffer;      // emitter identifier -> times-of-emission

  while (inputFile.hasNext()) {

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

    const JEvent* evt = inputFile.next();

    if (!evt->empty()) {
      buffer[evt->getID()].push_back((*evt)[0].getToE());
    }
  }
  STATUS(endl);


  JManager<key_type, TH1D> H1(new TH1D("[%]", NULL, 2000, -2.0e-3, +2.0e-3));

  for (int counter = 0; toashortFile.hasNext(); ++counter) {

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

    const JToAshort* parameters = toashortFile.next();

    const int id = getEmitterID(parameters->EMITTERID);

    if (emitters.has(id) && receivers.has(parameters->DOMID) && !buffer[id].empty()) {

      const JTransceiver  transceiver(emitters[id], receivers[parameters->DOMID]);

      const JTransmission transmission = transceiver.getTransmission(*parameters, V);

      double t1 = numeric_limits<double>::max();
      double w1 = 1.0 / (double) buffer[id].size();

      for (vector<double>::const_iterator i = buffer[id].begin(); i != buffer[id].end(); ++i) {

        const double ti = transmission.getToE() - *i;

        if (fabs(ti) < fabs(t1)) {
          t1 = ti;
        }
      }

      H1[key_type(parameters->DOMID, id)]->Fill(t1, w1);

      H1->Fill(t1);
    }
  }
  STATUS(endl);

  
  H1.Write(outputFile.c_str(), true);
}