JConstructDetector.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <map>
 
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorCalibration.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JDetectorSupportkit.hh"
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JPMTRouter.hh"
#include "JSupport/JMeta.hh"
 
#include "JSon/JSon.hh"
 
#include "JSystem/JDateAndTime.hh"
 
#include "Jeep/JeepToolkit.hh"
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
 
namespace {
 
  using namespace JPP;
  
  /**
   * Join UTC time range.
   *
   * \param  js             calibration input
   * \param  range          detector I/O
   */
  void from_json(const json& js, JUTCTimeRange& range)
  {
    using namespace std;
 
    time_t Tmin = (time_t) range.getLowerLimit();
    time_t Tmax = (time_t) range.getUpperLimit();
 
    if (js.contains(ValidFrom_t)    && !js[ValidFrom_t]   .is_null()) { Tmin = JDateAndTime(js[ValidFrom_t]   .get<string>()).getTime(); }
    if (js.contains(ValidThrough_t) && !js[ValidThrough_t].is_null()) { Tmax = JDateAndTime(js[ValidThrough_t].get<string>()).getTime(); }
 
    range.join(JUTCTimeRange(Tmin, Tmax));
  }
}
 
 
 
/**
 * \file
 *
 * Auxiliary program to compose detector from separate calibrations.\n
 * Note that the validity range as specified in the header of the detector data structure is determined by 
 * the maximal date and time value at JSON::ValidFrom_t and
 * the minimal date and time value at JSON::ValidThrough_t, respectively.
 *
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
 
  string          detectorFile;
  vector<string>  inputFile;
  string          outputFile;
  int             debug;
 
  try {
 
    JParser<> zap("Auxiliary program to compose detector from separate calibrations.");
 
    zap['a'] = make_field(detectorFile,  "detector file");
    zap['f'] = make_field(inputFile,     "detector calibration files in JSON format "\
                          "(wild card \'" << FILENAME_WILDCARD << "\' will be replaced by corresponding calibration set)");
    zap['o'] = make_field(outputFile,    "detector file")   = "";
    zap['d'] = make_field(debug)                            = 1;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  if (!hasDetectorAddressMap(detector.getID())) {
    FATAL("No detector address map for detector identier " << detector.getID() << endl);
  }
 
  const JDetectorBuilder& demo = getDetectorBuilder(detector.getID());
 
  const JModuleRouter moduleRouter(detector);
  const JPMTRouter    pmtRouter   (detector);
 
  detector.setUTCTimeRange(JUTCTimeRange());
 
 
  enum {
    UNDEFINED = 0,
    DEFINED   = 1
  };
 
  struct status_type {
 
    status_type() :
      value(UNDEFINED)
    {}
 
    operator int() const { return value; }
 
    status_type& operator=(const int value) 
    { 
      this->value = value;
 
      return *this;
    }
 
    int value;
  };
 
  typedef map<int, status_type>  map_type;
 
  map_type  tcal;
  map_type  pcal;
  map_type  rcal;
  map_type  acal;
  map_type  ccal;
  map_type  scal[2];
 
 
  for (const auto& file_name : inputFile) {
    
    vector<string> buffer;
 
    if (hasWildCard(file_name))
      buffer = { setWildCard(file_name, TCAL),
                 setWildCard(file_name, PCAL),
                 setWildCard(file_name, RCAL),
                 setWildCard(file_name, ACAL),
                 setWildCard(file_name, CCAL),
                 setWildCard(file_name, SCAL) };
    else
      buffer = { file_name };
 
    for (const auto& file_name : buffer) {
    
      const JSon js(file_name);
 
      json::const_iterator data;
 
      if (is_valid(js) && (data = js.find(Data_t)) != js.end()) {
 
        detector.comment.add(MAKE_STRING("calibration=" << (js.contains(Comment_t) ? js[Comment_t] : "?")));
 
        for (size_t i = 0; i != data->size(); ++i) {
 
          from_json(data->at(i), detector.getUTCTimeRange());
 
          if (data->at(i).contains(DetID_t)) {
            if (data->at(i)[DetID_t].get<int>() != detector.getID()) {
              FATAL("Detector identifier mismatch " << data->at(i)[DetID_t].get<int>() << " != " << detector.getID() << endl);
            }
          }
 
          if (data->at(i).contains(PMTT0s_t)) {
 
            for (const auto& element : data->at(i)[PMTT0s_t].get<JPMTCalibration>()) {
 
              if (pmtRouter.hasPMT(element.getID())) {
 
                JPMT& pmt = detector.getPMT(pmtRouter.getAddress(element.getID()));
              
                pmt.setCalibration(element.getCalibration());
 
                tcal[pmt.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(DOMPositions_t)) {
 
            for (const auto& element : data->at(i)[DOMPositions_t].get<JModulePosition>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
 
                module.set(element.getPosition());
 
                pcal[module.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(BasePositions_t)) {
 
            for (const auto& element : data->at(i)[BasePositions_t].get<JModulePosition>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
 
                module.set(element.getPosition());
 
                pcal[module.getID()] = DEFINED;
              }
            }
          }
  
          if (data->at(i).contains(DOMRotations_t)) {
 
            for (const auto& element : data->at(i)[DOMRotations_t].get<JModuleRotation>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
 
                const JModule buffer = demo.getModule(module.getID(), module.getLocation());
              
                if (module.size() != buffer.size()) {
                  FATAL("Module size " << module.size() << " != " << buffer.size() << endl);
                }
 
                const JPosition3D center = module.getCenter();
 
                for (size_t i = 0; i != module.size(); ++i) {
                  module.getPMT(i).setAxis(buffer.getPMT(i).getAxis());
                }
 
                module.rotate(element.getQuaternion());
 
                module.setPosition(module.getCenter());
                module.set(center);
 
                rcal[module.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(DOMAcousticT0_t)) {
 
            for (const auto& element : data->at(i)[DOMAcousticT0_t].get<JModuleCalibration>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
 
                module.setCalibration(element.getCalibration());
 
                acal[module.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(BaseAcousticT0_t)) {
 
            for (const auto& element : data->at(i)[BaseAcousticT0_t].get<JModuleCalibration>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
 
                module.setCalibration(element.getCalibration());
 
                acal[module.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(DOMCompassRotations_t)) {
 
            for (const auto& element : data->at(i)[DOMCompassRotations_t].get<JCompassRotation>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
 
                module.setQuaternion(element.getQuaternion());
 
                ccal[module.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(BaseCompassRotations_t)) {
 
            for (const auto& element : data->at(i)[BaseCompassRotations_t].get<JCompassRotation>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
 
                module.setQuaternion(element.getQuaternion());
 
                ccal[module.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(PMTStatusInfo_t)) {
 
            for (const auto& element : data->at(i)[PMTStatusInfo_t].get<JPMTStatus>()) {
 
              if (pmtRouter.hasPMT(element.getID())) {
 
                JPMT& pmt = detector.getPMT(pmtRouter.getAddress(element.getID()));
              
                pmt.setStatus(element.getStatus());
 
                scal[0][pmt.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(DOMStatusInfo_t)) {
 
            for (const auto& element : data->at(i)[DOMStatusInfo_t].get<JModuleStatus>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
                
                module.setStatus(element.getStatus());
 
                scal[1][module.getID()] = DEFINED;
              }
            }
          }
 
          if (data->at(i).contains(BaseStatusInfo_t)) {
 
            for (const auto& element : data->at(i)[BaseStatusInfo_t].get<JModuleStatus>()) {
 
              if (moduleRouter.hasModule(element.getID())) {
 
                JModule& module = detector.getModule(moduleRouter.getAddress(element.getID()));
                
                module.setStatus(element.getStatus());
 
                scal[1][module.getID()] = DEFINED;
              }
            }
          }
        }
      }
    }
  }
 
  for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module) {
 
    if (pcal   [module->getID()] != DEFINED) { ERROR("Module " << setw(10) << module->getID() << ' ' << getLabel(module->getLocation()) << " no position calibration."  << endl); }
    if (rcal   [module->getID()] != DEFINED &&
        module->getFloor() != 0)             { ERROR("Module " << setw(10) << module->getID() << ' ' << getLabel(module->getLocation()) << " no rotation calibration."  << endl); }
    if (acal   [module->getID()] != DEFINED) { ERROR("Module " << setw(10) << module->getID() << ' ' << getLabel(module->getLocation()) << " no acoustics calibration." << endl); }
    if (ccal   [module->getID()] != DEFINED) { ERROR("Module " << setw(10) << module->getID() << ' ' << getLabel(module->getLocation()) << " no compass calibration."   << endl); }
    if (scal[1][module->getID()] != DEFINED) { ERROR("Module " << setw(10) << module->getID() << ' ' << getLabel(module->getLocation()) << " no status calibration."    << endl); }
 
    for (JModule::const_iterator pmt = module->begin(); pmt != module->end(); ++pmt) {
      if (tcal   [pmt->getID()] != DEFINED) { ERROR("PMT " << setw(8) << pmt->getID() << " no time calibration."   << endl); }
      if (scal[0][pmt->getID()] != DEFINED) { ERROR("PMT " << setw(8) << pmt->getID() << " no status calibration." << endl); }
    }
  }
 
 
  detector.comment.add(JMeta(argc,argv));
 
  try {
    if (outputFile != "")
      store(outputFile, detector);
    else
      cout << detector << endl;
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  return 0;
}