JDetectorDB.cc File Reference

Auxiliary program to download or update detector from database. More...

#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include "JDB/JDB.hh"
#include "JDB/JSelector.hh"
#include "JDB/JSelectorSupportkit.hh"
#include "JDB/JCLBMap.hh"
#include "JDB/JDetectorIntegration_t.hh"
#include "JDB/JPBSSequence.hh"
#include "JDB/JProductRouter.hh"
#include "JDB/JDBToolkit.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JDetectorSupportkit.hh"
#include "JDetector/JDetectorCalibration.hh"
#include "JLang/JEquation_t.hh"
#include "JLang/JComparator.hh"
#include "JLang/JPredicate.hh"
#include "JSupport/JMeta.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

Auxiliary program to download or update detector from database.

Author

mdejong

Definition in file JDetectorDB.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 73 of file JDetectorDB.cc.

{
  using namespace std;
  using namespace JPP;

  JServer  server;
  string   usr;
  string   pwd;
  string   cookie;
  string   id;
  vector<JEquation_t> calset;
  string   detectorFile;
  string   outputFile;
  int      run;
  string   variant;
  JCounter wizzard;
  int      debug;
  
  try {

    JParser<> zap("Auxiliary program to download or update detector from database.");
    
    zap['s'] = make_field(server)        = getServernames();
    zap['u'] = make_field(usr)           = "";
    zap['!'] = make_field(pwd)           = "";
    zap['C'] = make_field(cookie)        = "";
    zap['D'] = make_field(id,            "detector identifier")                                        = "";
    zap['r'] = make_field(run,           "run number")                                                 = -1;
    zap['@'] = make_field(calset,        "calibration sets \"<key> = <value>[; <key> = <value>]\"" << endl
                          << "possible keys: " << JEEPZ() << keys)                                      = JPARSER::initialised();
    zap['a'] = make_field(detectorFile)  = "";
    zap['o'] = make_field(outputFile)    = "";
    zap['V'] = make_field(variant,       "detector version")                                           = getDetectorVersions<string>(), "";
    zap['W'] = make_field(wizzard,       "-W add base modules; -WW set time offsets of acoustic sensors");
    zap['d'] = make_field(debug)         = 2;
    
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }


  map<string, string> calibration;

  for (vector<JEquation_t>::const_iterator i = calset.begin(); i != calset.end(); ++i) {

    if (keys.count(i->getKey()) == 0)
      FATAL("Invalid calibration set \"" << i->getKey() << "\"" << endl);
    else
      calibration[i->getKey()] = i->getValue();
  }

  if (calibration.size() != 0u &&
      calibration.size() != 3u &&
      calibration.size() != 6u) {
    FATAL("Inconsistent specificaton of calibration sets, either {}, {t,p,r}cal or {t,p,r,a,c,s}cal.");
  }

  const bool file   = (detectorFile != "");
  const bool tpr    = (calibration.count(TCAL) != 0 &&
                       calibration.count(PCAL) != 0 &&
                       calibration.count(RCAL) != 0 &&
                       calibration.count(ACAL) == 0 &&
                       calibration.count(CCAL) == 0 &&
                       calibration.count(SCAL) == 0);
  const bool tpracs = (calibration.count(TCAL) != 0 &&
                       calibration.count(PCAL) != 0 &&
                       calibration.count(RCAL) != 0 &&
                       calibration.count(ACAL) != 0 &&
                       calibration.count(CCAL) != 0 &&
                       calibration.count(SCAL) != 0);
  const bool daq    = (run != -1);

  if (file   && id      != "") { FATAL("Inconsistent specificaton of detector file and detector identifier."); }
  if (file   && tpr)           { FATAL("Inconsistent specificaton of detector file and {t,p,r}cal calibration sets."); }
  if (file   && tpracs)        { FATAL("Inconsistent specificaton of detector file and {t,p,r,a,c,s}cal calibration sets."); }
  if (file   && daq)           { FATAL("Inconsistent specificaton of detector file and run number."); }

  if (tpr    && id      == "") { FATAL("Inconsistent specificaton of {t,p,r}cal calibration sets and no detector identifier."); }
  if (tpr    && variant != "") { FATAL("Inconsistent specificaton of {t,p,r}cal calibration sets and variant."); }
  if (tpr    && daq)           { FATAL("Inconsistent specificaton of {t,p,r}cal calibration sets and run number."); }

  if (tpracs && id      == "") { FATAL("Inconsistent specificaton of {t,p,r,a,c,s}cal calibration sets and no detector identifier."); }
  if (tpracs && variant == "") { FATAL("Inconsistent specificaton of {t,p,r,a,c,s}cal calibration sets and no variant."); }
  if (tpracs && daq)           { FATAL("Inconsistent specificaton of {t,p,r,a,c,s}cal calibration sets and run number."); }

  if (daq    && id      == "") { FATAL("Inconsistent specificaton of run number and no detector identifier."); }

  if (wizzard       && 
      variant != "" && 
      getDetectorVersion(variant) < JDetectorVersion::V4) {
    FATAL("Inconsistent detector variant and option -W.");
  }

  try {
    JDB::reset(usr, pwd, cookie);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }

  JDetector detector;

  try {

    if      (file)
      load(detectorFile, detector);
    else if (tpr)
      *(JDB::get()->DetX)(id.c_str(), 
                          calibration[TCAL].c_str(),
                          calibration[PCAL].c_str(),
                          calibration[RCAL].c_str())                    >>  detector;
    else if (tpracs)
      *(JDB::get()->DetX)(id.c_str(),
                          calibration[TCAL].c_str(),
                          calibration[PCAL].c_str(),
                          calibration[RCAL].c_str(),
                          calibration[ACAL].c_str(),
                          calibration[CCAL].c_str(),
                          calibration[SCAL].c_str(),
                          getDetectorVersion(variant))                  >>  detector;
    else if (daq && variant == "")
      *(JDB::get()->DetX)(id.c_str(), run)                              >>  detector;
    else if (daq && variant != "")
      *(JDB::get()->DetX)(id.c_str(), run, getDetectorVersion(variant)) >>  detector;
    else
      FATAL("Invalid options.");
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }


  detector.comment.add(JMeta(argc,argv));

  if (detector.setToLatestVersion()) {
    NOTICE("Set detector version to " << detector.getVersion() << endl);
  }


  if (wizzard) {

    vector<JCLBMap> clbmap;

    try {

      JSelector selector = getSelector<JCLBMap>(getDetector(detector.getID()));

      selector.add(&JCLBMap::FLOORID, 0);

      ResultSet& rs  = getResultSet(getTable<JCLBMap>(), selector);

      rs >> clbmap;

      rs.Close();
    }
    catch(const exception& error) {
      FATAL(error.what() << endl);
    }

    map<int, map<int, JPosition3D> > zmap;

    for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module) {
      zmap[module->getString()][module->getFloor()] = module->getPosition();
    }

    for (vector<JCLBMap>::const_iterator i = clbmap.begin(); i != clbmap.end(); ++i) {

      if (i->FLOORID == 0) {

        JDetector::iterator p = find_if(detector.begin(), detector.end(), make_predicate(&JModule::getID, i->DOMID, JComparison::eq()));

        if (p == detector.end()) {

          JModule module(i->DOMID, JLocation(i->DUID, i->FLOORID));

          module.setPosition(JPosition3D(zmap[i->DUID].begin()->second.getX(),
                                         zmap[i->DUID].begin()->second.getY(),
                                         isARCADetector(detector) ? ARCA_TBARZ_M :
                                         isORCADetector(detector) ? ORCA_TBARZ_M :
                                         0.0));

          NOTICE("Adding module " << module << endl);

          detector.push_back(module);

        } else if (zmap[i->DUID].count(1) != 0) {

          if (p->getX() != zmap[i->DUID][1].getX() ||
              p->getY() != zmap[i->DUID][1].getY()) {

            NOTICE("Set module (x,y) position " << *p << endl);

            p->setPosition(JPosition3D(zmap[i->DUID][1].getX(),
                                       zmap[i->DUID][1].getY(),
                                       p->getZ()));
          }
        }
      }
    }
  }

  if (wizzard > 1) {

    try {

      JDetectorIntegration_t detector_t;

      ResultSet& rs  = getResultSet(getTable<JDetectorIntegration_t>());

      if (! (rs >> detector_t)) {
        THROW(JDatabaseException, "Error reading " << getTable<JDetectorIntegration_t>());
      }

      detector_t.configure(getDetector(detector.getID()));

      for (const JPBS_t& pbs : { PBS::ACOUSTIC_SENSOR, PBS::HYDROPHONE }) {

        const JProductRouter router(detector_t, getPBSSequences(pbs));

        JDetectorIntegration_t::range_type range = detector_t.find(pbs);

        for (JDetectorIntegration_t::range_const_iterator i = range.first; i != range.second; ++i) {

          const JLocation_t location = router.getLocation(i->first);

          JDetector::iterator p = find_if(detector.begin(), 
                                          detector.end(), 
                                          make_predicate(&JModule::getLocation, 
                                                         JLocation(location.string, (pbs != PBS::HYDROPHONE ? location.floor : 0)), 
                                                         JComparison::eq()));

          if (p != detector.end()) {

            const double t0 = getAverage(make_array(p->begin(), p->end(), &JPMT::getT0), 0.0)  -  getDelayTime(i->first);

            if (t0 != p->getT0()) {

              NOTICE("Set module time calibration " << p->getLocation() << ' ' << setw(10) << p->getID() << ' ' << FIXED(9,3) << t0 << endl);

              p->setCalibration(t0);
            }

          } else {

            ERROR("No module for UPI " << i->first << " at " << location << endl);
          }
        }
      }
    }
    catch(const exception& error) {
      FATAL(error.what() << endl);
    }
  }

  if (outputFile != "")
    store(outputFile, detector);
  else
    cout << detector;
}