JHydrophone.cc

Go to the documentation of this file.

#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"

namespace {

  /**
   * Auxiliary data structure for organistation of histograms.
   */
  struct key_type :
    public std::pair<int, int>
  {
    /**
     * Constructor.
     *
     * \param  first    first  value
     * \param  second   second value
     */
    key_type(const int first,
             const int second) :
      std::pair<int, int>(first, second)
    {}


    /**
     * Read key from input.
     *
     * \param  in       input stream
     * \param  key      key
     * \return          input stream
     */
    friend inline std::istream& operator>>(std::istream& in, key_type& key)
    {
      in >> key.first;
      in >> key.second;

      return in;
    }


    /**
     * Write key to output.
     *
     * \param  out      output stream
     * \param  key      key
     * \return          output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const key_type& key)
    {
      out << key.first;
      out << '.';
      out << key.second;

      return out;
    }

    /**
     * Less=than operator.
     *
     * \param  first    first  key
     * \param  second   second key
     * \return          true if first key less than second key; else false
     */
    friend inline bool operator<(const key_type& first, const key_type& second)
    {
      if (first.first == second.first)
        return first.second < second.second;
      else
        return first.first  < second.first;
    }
  };
}


/**
 * \file
 *
 * Example program to plot hydrophone data.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  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);
}