JEditDetector.cc File Reference

Auxiliary program to modify detector calibration. More...

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <cctype>
#include "TRandom3.h"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JDetectorHeader.hh"
#include "JDetector/JModuleStatus.hh"
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JPMTIdentifier.hh"
#include "JDetector/JPMTPhysicalAddress.hh"
#include "JDetector/JPMTStatus.hh"
#include "JDetector/JModuleAddressMap.hh"
#include "JDetector/JDetectorAddressMap.hh"
#include "JDetector/JDetectorSupportkit.hh"
#include "JGeometry3D/JVector3D.hh"
#include "JMath/JConstants.hh"
#include "JMath/JMath.hh"
#include "JTools/JRange.hh"
#include "JLang/JException.hh"
#include "JLang/JToken.hh"
#include "JLang/JComparator.hh"
#include "JLang/JComparison.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|s) "<string number>         (set|add|sub|randset|randadd|randsub) x0 [x1 x2]"
    -M     "<module identifier>     (setx|addx|subx|sety|addy|suby|setz|addz|subz) value"
    -(S|s) "<string number>         (setx|addx|subx|sety|addy|suby|setz|addz|subz) value"
    -M     "<module identifier>     (rot|randrot|lower|upper) phi"
    -(S|s) "<string number>         (rot|randrot) phi"
    -M     "<module identifier>     (mul|randmul) factor"
    -(S|s) "<string number>         (mul|randmul) factor"
    -M     "<module identifier>     (div|randdiv) factor"
    -(S|s) "<string number>         (div|randdiv) factor"
    -M     "<module identifier>     (reset)"
    -(S|s) "<string number>         (reset)"
    -M     "<module identifier>     (assign)  identifier"
    -M     "<module identifier>     (locate)  <string> <floor>"
    -M     "<module identifier>     (swap)    <PMT>    <PMT>"
    -M     "<module identifier>     (SET|ADD|SUB|) x0 [x1 x2 x3]"
    -(S|s) "<string number>         (SET|ADD|SUB|) x0 [x1 x2 x3]"
    -M     "<module identifier>     (ROT) phi"
    -(S|s) "<string number>         (ROT) phi"
    -(S|s) "<string number>         (tilt|randtilt) Tx Ty"
    -R     "<module identifier>     <PMT physical address>"
    -W     "<module identifier>     (set|reset)  (MODULE_DISABLE|COMPASS_DISABLE|HYDROPHONE_DISABLE|PIEZO_DISABLE|MODULE_OUT_OF_SYNC)"
    -P     "<PMT identifier>        (set|reset)  (PMT_DISABLE|HIGH_RATE_VETO_DISABLE|FIFO_FULL_DISABLE|UDP_COUNTER_DISABLE|UDP_TRAILER_DISABLE|OUT_OF_SYNC)"
    -p     "<PMT physical address>  (set|reset)  (PMT_DISABLE|HIGH_RATE_VETO_DISABLE|FIFO_FULL_DISABLE|UDP_COUNTER_DISABLE|UDP_TRAILER_DISABLE|OUT_OF_SYNC)"
    -k     "<string number>[-<string number>]"
    -r     "<string number>[-<string number>]"
    -m     "<module identifier>"
    -D     "<string number> <floor>"
    -@    "<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 modules of the specified string number.
The option -s is equivalent to option -S except that the action applies only to the optical modules in the string and not the base module.

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 and [rand]sub, the number of values apply to position or time calibration in the following way:

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

For options (set|add|sub)(x|y|z), the value corresponds to last character of the the quoted action.

For options [rand]rot, the angle phi refers to an anti-clockwise rotation around the z-axis.
The options upper and lower refer to a rotation of the PMTs in the upper and lower hemisphere of the module, respectively.
The rotation angle is defined in radians.

For options [rand]mul and [rand]div, the multiplication/division factor (a.k.a. "stretching") applies to the z-coordinates of the modules.
The factor is defined as a fraction; the actual multiplication/division factor is (1 + factor).

For options SET, ADD and SUB, the number of values apply to time or quaternion calibration of the module in the following way:

1. time calibration of piezo sensor or hydrophone (t = x0)
2. invalid
3. invalid
4. quaternion calibration of compass (qa = x0, qb = x1, qc = x2, qd = x3)

For options ROT, the angle phi refers to an anti-clockwise rotation around the z-axis of the quaternion calibration of the compass.
The rotation angle is defined in radians.

Note that to correct the time calibration for the delay time of the piezo sensor and hydrophone, application JDetectorDB.cc can be used (option -WW).

The units of all positions and time values are m and ns, respectively.

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.

The option -R can be used to rotate the positions of PMTs within a given ring.
In this, the position of the physical address of the PMT corresponds to the number of steps of the rotation.

The option -W can be used to modify the status of a module. The options -P and -p can be used to modify the status of PMTs.

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, -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.

The options -m and -D can be used to maintain a specific module (and remove all others) and to delete a floor from a string, respectively.

Note finally 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 945 of file JEditDetector.cc.

{
  using namespace std;
  using namespace JPP;
 
  typedef JToken<';'>  JToken_t;
 
  string                           inputFile;
  string                           outputFile;
  vector<JToken_t>                 hdr;
  vector< pair<int, JModifier> >   mod;
  vector< pair<int, JModifier> >   str;
  vector< pair<int, JModifier> >   dos;
  vector< pair<int, 
               JModuleModifier> >  wip;
  vector< pair<JPMTIdentifier,
               JPMTModifier> >     pmt;
  vector< pair<JPMTPhysicalAddress,
               JPMTModifier> >     alt;
  multimap<int, 
           JPMTPhysicalAddress>    ring;
  vector<JRange_t>                 keep;
  vector<JRange_t>                 rm;
  vector<int>                      id;
  multimap<int, int>               del;
  int                              option;
  bool                             squash;
  int                              debug;
  
  try { 
 
    JParser<> zap("Auxiliary program to modify detector.");
 
    zap['a'] = make_field(inputFile);
    zap['o'] = make_field(outputFile);
    zap['@'] = make_field(hdr,    "header modification")                                    = JPARSER::initialised();
    zap['M'] = make_field(mod,    "module modification")                                    = JPARSER::initialised();
    zap['S'] = make_field(str,    "string modification (optical modules and base modules)") = JPARSER::initialised();
    zap['s'] = make_field(dos,    "string modification (optical modules only)")             = JPARSER::initialised();
    zap['W'] = make_field(wip,    "module status modification")                             = JPARSER::initialised();
    zap['P'] = make_field(pmt,    "PMT status modification by PMT logical address")         = JPARSER::initialised();
    zap['p'] = make_field(alt,    "PMT status modification by PMT physical address")        = JPARSER::initialised();
    zap['R'] = make_field(ring,   "rotate positions of PMTs in ring")                       = JPARSER::initialised();
    zap['k'] = make_field(keep,   "keep string[s] by number")                               = JPARSER::initialised();
    zap['r'] = make_field(rm,     "remove string[s] by number")                             = JPARSER::initialised();
    zap['m'] = make_field(id,     "maintain module[s] by identifier")                       = JPARSER::initialised();
    zap['D'] = make_field(del,    "remove module[s] by location")                           = JPARSER::initialised();
    zap['O'] = make_field(option, "sort modules: "\
                          "0 -> no sort; 1 -> module identifier; 2 -> module location")     = 0, 1, 2;
    zap['q'] = make_field(squash, "squash meta data");
    zap['d'] = make_field(debug,  "debug level")                                            = 2;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
   
  gRandom->SetSeed(0);
 
  const int ns = ((keep.empty() ? 0 : 1)  +
                  (rm  .empty() ? 0 : 1)  +
                  (id  .empty() ? 0 : 1)  +
                  (del .empty() ? 0 : 1));
  
  if (ns > 1) {
    FATAL("Use either option -k, -r, -m or -D." << endl);
  }
 
  JDetector detector;
 
  try {
    load(inputFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  if (squash) {
    detector.comment.clear();
  }
 
  detector.comment.add(JMeta(argc,argv));
 
  if (detector.setToLatestVersion()) {
    NOTICE("Set detector version to " << detector.getVersion() << endl);
  }
 
 
  if (!hdr.empty()) {
 
    int id = -1;
 
    JProperties helper = detector.getProperties();
 
    helper["id"] = id;
    
    for (vector<JToken_t>::const_iterator i = hdr.begin(); i != hdr.end(); ++i) {
      
      istringstream is(*i);
      
      is >> helper;
    }
 
    if (id != -1) {
      detector.setID(id);
    }
  }
 
 
  if (ns != 0) {
 
    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 (!id.empty()) {
        __rm__ = find(id.begin(), id.end(), module->getID()) == id.end();
      }
 
      const auto range = del.equal_range(module->getString());
 
      for (auto i = range.first; i != range.second; ++i) {
        if (i->second == module->getFloor()) {
          __rm__ = true;
        }
      }
 
      if (__rm__)
        module = detector.erase(module);
      else
        ++module;
    }
  }
 
 
  for (vector< pair<int, JModifier> >::const_iterator i = mod.begin(); i != mod.end(); ++i) {
 
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      if (module->getID() == i->first || i->first == WILDCARD ){
 
        if (debug >= debug_t) {
          print(cout, *module, i->second);
        }
        
        if (!i->second.apply(*module)) {
          ERROR("No valid action: " << i->first << ' ' << i->second << endl);
        }
      }
    }
  }
 
 
  for (vector< pair<int, JModifier> >::const_iterator i = str.begin(); i != str.end(); ++i) {
 
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      if (module->getString() == i->first || i->first == WILDCARD) {
 
        const JModifier modifier = getModifier(module->getString(), i->second);
 
        if (debug >= debug_t) {
          print(cout, *module, i->second);
        }
        
        if (!modifier.apply(*module)) {
          ERROR("No valid action: " << i->first << ' ' << i->second << endl);
        }
      }
    }
  }
 
 
  for (vector< pair<int, JModifier> >::const_iterator i = dos.begin(); i != dos.end(); ++i) {
 
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      if (module->getFloor() != 0) {
 
        if (module->getString() == i->first || i->first == WILDCARD) {
 
          const JModifier modifier = getModifier(module->getString(), i->second);
 
          if (debug >= debug_t) {
            print(cout, *module, i->second);
          }
        
          if (!modifier.apply(*module)) {
            ERROR("No valid action: " << i->first << ' ' << i->second << endl);
          }
        }
      }
    }
  }
 
 
  for (vector< pair<int, JModuleModifier> >::const_iterator i = wip.begin(); i != wip.end(); ++i) {
 
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      if (module->getID() == i->first || i->first == WILDCARD ){
 
        if (debug >= debug_t) {
          print(cout, *module, i->second);
        }
        
        if (!i->second.apply(*module)) {
          ERROR("No valid action: " << i->first << ' ' << i->second << endl);
        }
      }
    }
  }
 
 
  for (vector< pair<JPMTIdentifier, JPMTModifier> >::const_iterator i = pmt.begin(); i != pmt.end(); ++i) {
  
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      if (module->getID() == i->first.getModuleID() || i->first.getModuleID() == WILDCARD) {
 
        if (debug >= debug_t) {
          print(cout, i->first, i->second);
        }
 
        if        (i->first.getPMTAddress() == WILDCARD) {
 
          for (int pmt = 0; pmt != getNumberOfPMTs(*module); ++pmt) {
            if (!i->second.apply(module->getPMT(pmt))) {
              ERROR("No valid action: " << i->first << ' ' << i->second << endl);
            }
          }
 
        } else if (i->first.getPMTAddress() >= 0                         &&
                   i->first.getPMTAddress() <  getNumberOfPMTs(*module)  &&
                   !i->second.apply(module->getPMT(i->first.getPMTAddress()))) {
          ERROR("No valid action: " << i->first << ' ' << i->second << endl);
        }
      }
    }
  }
 
 
  if (!alt.empty() || !ring.empty()) {
 
    if (!hasDetectorAddressMap(detector.getID())) {
      FATAL("Invalid detector identifier " << detector.getID() << endl);
    }
 
    const JDetectorAddressMap& demo = getDetectorAddressMap(detector.getID());
 
    for (JDetector::iterator module = detector.begin(); module != detector.end(); ++module) {
 
      const JModuleAddressMap memo = demo.get(module->getID());
 
      for (vector< pair<JPMTPhysicalAddress, JPMTModifier> >::const_iterator i = alt.begin(); i != alt.end(); ++i) {
 
        const JPMTIdentifier id(module->getID(), memo.getAddressTranslator(i->first).tdc);
 
        if (debug >= debug_t) {
          print(cout, id, i->second);
        }
 
        if (!i->second.apply(module->getPMT(id.getPMTAddress()))) {
          ERROR("No valid action: " << i->first << ' ' << i->second << endl);
        }
      }
 
      const auto range = ring.equal_range(module->getID());
 
      for (auto i = range.first; i != range.second; ++i) {
 
        JPMTPhysicalAddress modifier = i->second;
 
        modifier.ring = (char) toupper(modifier.ring);
 
        if (modifier.ring != 'A') {
 
          map<JPMTPhysicalAddress, JPMT> buffer;
 
          for (size_t i = 0; i != module->size(); ++i) {
 
            const JPMTPhysicalAddress& address = memo.getPMTPhysicalAddress(i);
 
            if (address.ring == modifier.ring) {
              buffer[address] = (*module)[i];
            }
          }
 
          for (size_t i = 0; i != module->size(); ++i) {
 
            const JPMTPhysicalAddress& address = memo.getPMTPhysicalAddress(i);
 
            if (address.ring == modifier.ring) {
 
              int position = address.position + modifier.position;
 
              while (position > 6) { position -= 6; }
              while (position < 1) { position += 6; }
 
              const JPMTPhysicalAddress source(modifier.ring, position);
 
              DEBUG("Module " << setw(10) << module->getID() << ' ' << address << " <= " << source << endl);
 
              (*module)[i] = buffer[source];
            }
          }
        }
      }
    }
  }
 
 
  switch (option) {
  case 1:
    sort(detector.begin(), detector.end(), make_comparator(&JModule::getID));
    break;
 
  case 2:
    sort(detector.begin(), detector.end(), make_comparator(&JModule::getLocation));
    break;
 
  default:
    break;
  };
 
 
  try {
    store(outputFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
}