JEditDetector.cc File Reference

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include "TRandom3.h"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JDetectorHeader.hh"
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JPMTIdentifier.hh"
#include "JGeometry3D/JVector3D.hh"
#include "JTools/JConstants.hh"
#include "JTools/JRange.hh"
#include "JLang/JException.hh"
#include "JSupport/JMeta.hh"
#include "Jeep/JeepToolkit.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 modify detector calibration.

Syntax:

    -M "<module identifier> (set|add|sub|randset|randadd|randsub) x0 [x1 [x2]]"
    -S "<string number>     (set|add|sub|randset|randadd|randsub) x0 [x1 [x2]]"
    -M "<module identifier> (rot|randrot) phi"
    -S "<string number>     (rot|randrot) phi"
    -M "<module identifier> (mul|randmul) factor"
    -S "<string number>     (mul|randmul) factor"
    -M "<module identifier> (via|randvia) factor"
    -S "<string number>     (via|randvia) factor"
    -M "<module identifier> (reset)
    -S "<string number>="">     (reset)
    -P "<PMT identifier>    (set|reset)   PMT_STATUS"
    -k "<string number>[-<string number>"
    -r "<string number>[-<string number>"
    -@ "<key>=<value>[;<key>=<value>"

Options -M and -S refer to a module and a string, respectively.
The values provided for a string modification coherently apply to the specified string number.

The options randXXX correspond to a randomisation of the specified option.

If the module identifier or string number is -1, the action is applied to all modules or strings in the detector, respectively.

For options [rand]set [rand]add [rand]sub, the number of values apply to position or time calibration in the following way:

1. time calibration (t = x0)
2. position calibration (x = x0, y = x1, z = 0)
3. position calibration (x = x0, y = x1, z = x2)

For options [rand]rot, the angle phi refers to an anti-clockwise rotation around the z-axis.
The rotation angle is defined in radians.

For options [rand]mul, the multiplication factor applies to the z-coordinates.
This factor is defined as a fraction; the actual multiplication factor is (1 + factor).

For options [rand]via, The factor applies to the time calibration as a function of floor number.

Note that for string modifiers with option randxxx, the action is coherently applied to the modules in the specified string. Only one type of action (defined by xxx and the number of values) is then allowed per string.

Option -@ refers to the header information.
The list of possible keys can be obtained using JPrintDetector.cc with option -O header.

Multiple options -M, -S or -@ will be processed in order of appearance.

Options -k and -r can be used to keep and remove a range of string numbers, respectively.

Note that if the output file name is the same as the input file name, the original file will be overwritten.

Author

mdejong

Definition in file JEditDetector.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 536 of file JEditDetector.cc.

{
  using namespace std;
  using namespace JPP;
 
  string               inputFile;
  string               outputFile;
  vector<JModifier>    mod;
  vector<JModifier>    str;
  vector<string>       hdr;
  vector<JPMTModifier> pmt;
  vector<JRange_t>     keep;
  vector<JRange_t>     rm;
  int                  debug;
  
  try { 
 
    JParser<> zap("Auxiliary program to modify detector.");
 
    zap['a'] = make_field(inputFile);
    zap['M'] = make_field(mod)           = JPARSER::initialised();
    zap['S'] = make_field(str)           = JPARSER::initialised();
    zap['@'] = make_field(hdr)           = JPARSER::initialised();
    zap['P'] = make_field(pmt)           = JPARSER::initialised();
    zap['o'] = make_field(outputFile);
    zap['k'] = make_field(keep)          = JPARSER::initialised();
    zap['r'] = make_field(rm)            = JPARSER::initialised();
    zap['d'] = make_field(debug)         = 2;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
   
  JDetector detector;
 
  try {
    load(inputFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
 
  gRandom->SetSeed(0);
 
 
  if (!keep.empty() && !rm.empty()) {
    FATAL("Use either option -k or -r." << endl);
  }
 
 
  detector.comment.add(JMeta(argc,argv));
 
 
  if (!hdr.empty()) {
 
    JProperties helper = detector.getProperties();
    
    for (vector<string>::const_iterator i = hdr.begin(); i != hdr.end(); ++i) {
      
      istringstream is(*i);
      
      is >> helper;
    }
  }
 
 
  for (JDetector::iterator module = detector.begin(); module != detector.end(); ) {
 
    bool __rm__ = !keep.empty() && rm.empty();
 
    for (vector<JRange_t>::const_iterator i = keep.begin(); i != keep.end(); ++i) {
      if (module->getString() >= i->first && module->getString() <= i->second) {
        __rm__ = false;
      }
    }
 
    for (vector<JRange_t>::const_iterator i = rm.begin(); i != rm.end(); ++i) {
      if (module->getString() >= i->first && module->getString() <= i->second) {
        __rm__ = true;
      }
    }
 
    if (__rm__)
      module = detector.erase(module);
    else
      ++module;
  }
 
 
  for (vector<JModifier>::const_iterator i = mod.begin(); i != mod.end(); ++i) {
 
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      if (module->getID() == i->id || i->id == JModifier::WILD_CARD ){  
 
        DEBUG("Modifier"                                                                              << ' '
              << "(" << setw(3) << module->getString() << "," << setw(2) << module->getFloor() << ")" << ' '
              << setw(8) << module->getID()                                                           << ' '
              << "action" << ' ' << i->action << JEEPZ() << i->data << endl);
        
        if (!i->apply(*module)) {
          ERROR("No valid action: " << *i << endl);
        }
      }
    }
  }
 
 
  for (vector<JModifier>::const_iterator i = str.begin(); i != str.end(); ++i) {
 
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      if (module->getString() == i->id || i->id == JModifier::WILD_CARD) {
 
        const JModifier& modifier = getModifier(module->getString(), *i);
 
        DEBUG("Modifier"                                                                              << ' '
              << "(" << setw(3) << module->getString() << "," << setw(2) << module->getFloor() << ")" << ' '
              << setw(8) << module->getID()                                                           << ' '
              << "action" << ' ' << modifier.action << JEEPZ() << modifier.data << endl);
        
        if (!modifier.apply(*module)) {
          ERROR("No valid action: " << *i << endl);
        }
      }
    }
  }
 
 
  for (vector<JPMTModifier>::const_iterator i = pmt.begin(); i != pmt.end(); ++i) {
  
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      if (module->getID() == i->getModuleID() || i->getModuleID() == JModifier::WILD_CARD) {
 
        DEBUG("PMT modifier"                                                                      << ' '
              << "(" << setw(8) << module->getID() << "," << setw(2) << i->getPMTAddress() << ")" << ' '
              << "action" << ' ' << i->action << ' ' 
              << "value"  << ' ' << i->value  << endl);
        
        if (i->getPMTAddress() <  0                         ||
            i->getPMTAddress() >= getNumberOfPMTs(*module)  ||
            !i->apply(module->getPMT(i->getPMTAddress()))) {
          ERROR("No valid action: " << *i << endl);
        }
      }
    }
  }
 
  try {
    store(outputFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
}