JSydney.cc File Reference

Application to perform acoustic pre-calibration. More...

#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <algorithm>
#include <limits>
#include <sys/stat.h>
#include <type_traits>
#include <functional>
#include <future>
#include <mutex>
#include <thread>
#include <queue>
#include "TROOT.h"
#include "TFile.h"
#include "JLang/JPredicate.hh"
#include "JLang/JComparator.hh"
#include "JLang/JComparison.hh"
#include "JLang/JSTDObjectWriter.hh"
#include "JSystem/JStat.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JTripod.hh"
#include "JDetector/JTransmitter.hh"
#include "JDetector/JModule.hh"
#include "JDetector/JHydrophone.hh"
#include "JDetector/JLocationRouter.hh"
#include "JFit/JGradient.hh"
#include "JTools/JHashMap.hh"
#include "JTools/JRange.hh"
#include "JTools/JQuantile.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JAcoustics/JSoundVelocity.hh"
#include "JAcoustics/JEmitter.hh"
#include "JAcoustics/JAcousticsToolkit.hh"
#include "JAcoustics/JHit.hh"
#include "JAcoustics/JFitParameters.hh"
#include "JAcoustics/JKatoomba_t.hh"
#include "JAcoustics/JEvent.hh"
#include "JAcoustics/JSuperEvt.hh"
#include "JAcoustics/JSuperEvtToolkit.hh"
#include "JAcoustics/JSupport.hh"
#include "JAcoustics/JTransmission_t.hh"
#include "JAcoustics/JFremantle_t.hh"
#include "JAcoustics/JPlatypus_t.hh"
#include "Jeep/JTimer.hh"
#include "Jeep/JeepToolkit.hh"
#include "Jeep/JContainer.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Classes
struct	JACOUSTICS::JFilenames
	Auxiliary data structure for handling file names. More...
struct	JACOUSTICS::JSetup
	Auxiliary data structure for setup of complete system. More...
struct	JACOUSTICS::JSydney
	Main class for pre-calibration using acoustics data. More...
struct	JACOUSTICS::JSydney::ids_t
	List of identifiers. More...
struct	JACOUSTICS::JSydney::fits_t
	Auxiliary data structure for group of lists of identifiers of to-be-fitted objects. More...
struct	JACOUSTICS::JSydney::JModuleEditor
	Auxiliary class to edit (z) position of module. More...
struct	JACOUSTICS::JSydney::JStringEditor
	Auxiliary class to edit (x,y,z) position of string. More...
struct	JACOUSTICS::JSydney::JDyneemaEditor
	Auxiliary class to edit length of Dyneema ropes. More...
struct	JACOUSTICS::JSydney::JTripodEditor
	Auxiliary class to edit (x,y,z) position of tripod. More...
struct	JACOUSTICS::JSydney::JAnchorEditor
	Auxiliary class to edit rotation of anchor. More...
struct	JACOUSTICS::JSydney::JParameters_t
	Extended data structure for parameters of stage. More...

Namespaces
	JACOUSTICS
	Auxiliary classes and methods for acoustic position calibration.

Typedefs
typedef JContainer < std::vector< JTripod > >	JACOUSTICS::tripods_container
typedef JContainer < std::vector< JTransmitter > >	JACOUSTICS::transmitters_container
typedef JContainer < std::vector< JHydrophone > >	JACOUSTICS::hydrophones_container
typedef JContainer< std::set < JTransmission_t > >	JACOUSTICS::disable_container

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

Variables
static const std::string	JACOUSTICS::initialise_t = "initialise"
	initialise More...
static const std::string	JACOUSTICS::fix_t = "fix"
	fix objects More...
static const std::string	JACOUSTICS::string_t = "string"
	string More...
static const std::string	JACOUSTICS::tripod_t = "tripod"
	tripod More...
static const std::string	JACOUSTICS::stage_t = "stage"
	fit stage More...

Detailed Description

Application to perform acoustic pre-calibration.

Author

mdejong

Definition in file JSydney.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 1038 of file JSydney.cc.

{
  using namespace std;
  using namespace JPP;

  JMultipleFileScanner<JEvent>  inputFile;
  JLimit_t&               numberOfEvents = inputFile.getLimit();
  JFilenames              filenames;                            // file names
  JFitParameters          parameters;                           // fit parameters
  string                  script;                               // script file
  JSoundVelocity          V              = getSoundVelocity;    // default sound velocity
  disable_container       disable;                              // disable tansmissions
  size_t                  jobs;                                 // number of parallel jobs
  int                     debug;

  try {

    JParser<> zap("Application to perform acoustic pre-calibration.");

    zap['f'] = make_field(inputFile,              "output of JAcousticEventBuilder[.sh]");
    zap['n'] = make_field(numberOfEvents)                                           = JLimit::max();
    zap['a'] = make_field(filenames.detector);
    zap['@'] = make_field(parameters)                                               = JPARSER::initialised();
    zap['s'] = make_field(script,                 "steering script");
    zap['V'] = make_field(V,                      "sound velocity")                 = JPARSER::initialised();
    zap['T'] = make_field(filenames.tripod,       "tripod file");
    zap['Y'] = make_field(filenames.transmitter,  "transmitter file")               = JPARSER::initialised();
    zap['H'] = make_field(filenames.hydrophone,   "hydrophone file")                = JPARSER::initialised();
    zap['M'] = make_field(getMechanics,           "mechanics data")                 = JPARSER::initialised();
    zap['!'] = make_field(disable,                "disable transmission")           = JPARSER::initialised();
    zap['N'] = make_field(jobs,                   "number of parallel jobs")        = 1;
    zap['d'] = make_field(debug)                                                    = 1;

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

  if (jobs == 0) {
    FATAL("Invalid number of jobs " << jobs << endl);
  }

  JSydney   sydney(filenames, V, jobs, debug);

  set<int>  receivers;
  set<int>  emitters;

  for (JDetector::const_iterator              i = sydney.setup.detector    .begin(); i != sydney.setup.detector    .end(); ++i) {
    if (i->getFloor() != 0 || sydney.setup.hydrophones.hasString(i->getString())) {
      receivers.insert(i->getID());
    }
  }
  
  for (tripods_container::const_iterator      i = sydney.setup.tripods     .begin(); i != sydney.setup.tripods     .end(); ++i) {
    {
      emitters.insert(i->getID());
    }
  }

  for (transmitters_container::const_iterator i = sydney.setup.transmitters.begin(); i != sydney.setup.transmitters.end(); ++i) {
    if (sydney.setup.detector.hasModule(i->getLocation())) {
      emitters.insert(i->getID());
    }
  }

  typedef vector<JEvent> buffer_type;

  buffer_type zbuf;
  
  while (inputFile.hasNext()) {

    const JEvent* evt = inputFile.next();

    if (emitters.count(evt->getID())) {
      zbuf.push_back(*evt);
    }
  }

  const JRange<double> unit(0.0, 1.0);

  sort(zbuf.begin(), zbuf.end());                  // sort according first time-of-emission

  for (buffer_type::iterator p = zbuf.begin(), q; p != zbuf.end(); p = q) {
  
    for (q = p; ++q != zbuf.end() && q->begin()->getToE() <= p->rbegin()->getToE() + parameters.Tmax_s; ) {}

    JEvent::overlap(p, q, parameters.deadTime_s);  // empty overlapping events

    JSydney::ievt_type buffer;

    for (buffer_type::iterator evt = p; evt != q; ++evt) {

      sort(evt->begin(), evt->end(), JKatoomba<>::compare);

      JEvent::iterator __end  = unique(evt->begin(), evt->end(), make_comparator(&JTransmission::getID, JComparison::eq()));

      for (JEvent::iterator i = evt->begin(); i != __end; ) {

        if (disable.count(JTransmission_t(evt->getID(), i->getID())) == 0 &&
            disable.count(JTransmission_t(-1,           i->getID())) == 0) {

          if (receivers.count(i->getID()) && i->getQ() >= parameters.Qmin * (unit(parameters.Qmin) ? i->getW() : 1.0)) {
            ++i; continue;
          }
        }

        iter_swap(i, --__end);
      }

      buffer.push_back(JEvent(evt->getOID(), buffer.size(), evt->getID(), evt->begin(), __end));
    }

    if (getNumberOfEmitters(buffer.begin(), buffer.end()) >= parameters.Nmin) {
      sydney.idat.push_back(buffer);
    }
  }

  sydney.run(script);
}