JEditDetector.cc

Go to the documentation of this file.

#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 "JLang/JException.hh"
#include "JSupport/JMeta.hh"

#include "Jeep/JeepToolkit.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"


namespace {

  using namespace JPP;


  /**
   * Auxiliary class to apply detector modifications.
   *
   * Note that the internal identifier may apply to a module as well as a string.
   */
  class JModifier {
  public:
    /**
     * Wild card for module and string identifier.
     */
    static const int WILD_CARD = -1;
  

    /**
     * Default constructor.
     */
    JModifier()
    {}


    /**
     * Apply modification to given module.
     *
     * \param  module      module
     * \return             true if valid action; else false
     */
    bool apply(JModule& module) const
    {
      switch (data.size()) {

      case 1:
        return  apply(module, action, data[0]);                               // time/orientation/height calibration
          
      case 2:
        return  apply(module, action, JVector3D(data[0], data[1], 0.0));      // 2D position calibration
          
      case 3:
        return  apply(module, action, JVector3D(data[0], data[1], data[2]));  // 3D position calibration

      default:
        return false;
      }
    }      


    /**
     * Read modifier from input.
     *
     * \param  in          input stream
     * \param  modifier    modifier
     * \return             input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JModifier& modifier)
    {
      using namespace std;

      if (in >> modifier.id >> modifier.action) {
      
        modifier.data.clear();

        for (double x; in >> x; ) {
          modifier.data.push_back(x);
        }

        if (!modifier.data.empty())
          in.clear(ios_base::eofbit);
        else
          in.setstate(ios_base::badbit);
      }
      
      return in;
    }


    /**
     * Write modifier to output.
     *
     * \param  out         output stream
     * \param  modifier    modifier
     * \return             output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JModifier& modifier)
    {
      out << modifier.id;
      out << ' ';
      out << modifier.action;

      for (std::vector<double>::const_iterator i = modifier.data.begin(); i != modifier.data.end(); ++i) {
        out << ' ' << *i;
      }

      return out;
    }
  

    int                 id;
    std::string         action;
    std::vector<double> data;

  private:
    
    /**
     * Apply time/orientation calibration to given module.
     *
     * \param  module      module
     * \param  action      action
     * \param  value       value
     * \return             true if valid action; else false
     */
    static bool apply(JModule& module, const std::string& action, const double value)
    {
      if        (action == "set") {                          // actions with fixed values

        module.set(value);

      } else if (action == "add") {

        module.add(value);

      } else if (action == "sub") {

        module.sub(value);

      } else if (action == "rot") {

        const JVector3D center = module.getPosition();

        module.sub(center);
        
        module.rotate(JRotation3Z(value));

        module.add(center);

      } else if (action == "mul") {

        const JVector3D center(module.getPosition().getX(),
                               module.getPosition().getY(),
                               module.getPosition().getZ() * value);
        
        module.set(center);

      } else if (action == "randadd") {                      // actions with random values

        module.add(gRandom->Gaus(0.0, value));

      } else if (action == "randsub") {
        
        module.sub(gRandom->Gaus(0.0, value));

      } else if (action == "randrot"){

        const JVector3D center = module.getPosition();

        module.sub(center);

        module.rotate(JRotation3Z(gRandom->Gaus(0.0, value)));

        module.add(center);
      
      } else if (action == "randmul") {

        const JVector3D center(module.getPosition().getX(),
                               module.getPosition().getY(),
                               module.getPosition().getZ() * gRandom->Gaus(1.0, value));
        
        module.set(center);

      } else {
        
        return false;
      }
      
      return true;
    }


    /**
     * Apply position calibration to given module.
     *
     * \param  module      module
     * \param  action      action
     * \param  pos         pos
     * \return             true if valid action; else false
     */
    static bool apply(JModule& module, const std::string& action, const JVector3D& pos)
    {
      const JVector3D randpos(gRandom->Gaus(0.0, pos.getX()),
                              gRandom->Gaus(0.0, pos.getY()),
                              gRandom->Gaus(0.0, pos.getZ()));

      if      (action == "set")                          // actions with fixed values
        module.set(pos);
      else if (action == "add")
        module.add(pos);
      else if (action == "sub")
        module.sub(pos);
      else if (action == "randset")                      // actions with random values
        module.set(randpos);
      else if (action == "randadd")
        module.add(randpos);
      else if (action == "randsub")
        module.sub(randpos);
      else
        return false;

      return true;
    }
  };
  

  /**
   * Auxiliary class to apply PMT status modifications.
   */
  class JPMTModifier :
    public JPMTIdentifier
  {
  public:
    /**
     * Default constructor.
     */
    JPMTModifier()
    {}


    /**
     * Apply modification to given PMT.
     *
     * \param  pmt         PMT
     * \return             true if valid action; else false
     */
    bool apply(JPMT& pmt) const
    {
      try {

        if        (action == "set") {

          pmt.set(getPMTStatusBit(value));
          
        } else if (action == "reset") {
          
          pmt.reset(getPMTStatusBit(value));

        } else {
          
          return false;
        }

        return true;
      }
      catch(const std::exception&) {}

      return false;
    }
 

    /**
     * Read PMT modifier from input.
     *
     * \param  in          input stream
     * \param  modifier    modifier
     * \return             input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JPMTModifier& modifier)
    {
      return in >> static_cast<JPMTIdentifier&>(modifier) >> modifier.action >> modifier.value;
    }


    /**
     * Write modifier to output.
     *
     * \param  out         output stream
     * \param  modifier    modifier
     * \return             output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JPMTModifier& modifier)
    {
      out << static_cast<const JPMTIdentifier&>(modifier);
      out << ' ';
      out << modifier.action;
      out << ' ';
      out << modifier.value;

      return out;
    }
  

    int         id;
    std::string action;
    std::string value;
  };
}


/**
 * \file
 *
 * Auxiliary program to modify detector calibration.
 *
 * Syntax:
 * <pre>
 *     -M "<module identifier> (set|add|sub|randset|randadd|randsub) x0 [x1 [x2]]"
 *     -S "<string identifier> (set|add|sub|randset|randadd|randsub) x0 [x1 [x2]]"
 *     -M "<module identifier> (rot|randrot) phi"
 *     -S "<string identifier> (rot|randrot) phi"
 *     -M "<module identifier> (mul|randmul) factor"
 *     -S "<string identifier> (mul|randmul) factor"
 *     -P "<PMT identifier>    (set|reset)   PMT_STATUS"
 *     -\@ "<key>=<value>[;<key>=<value>"
 * </pre>
 * Options <tt>-M</tt> and <tt>-S</tt> refer to a module and a string, respectively.\n
 *
 * If module identifier or string identifier is -1, the action takes place on all modules or strings in the detector, respectively.\n 
 * The number of values apply to position or time calibration in the following way:
 *     -#  time calibration     <tt>(t = x0)</tt>
 *     -#  position calibration <tt>(x = x0, y = x1, z = 0)</tt>
 *     -#  position calibration <tt>(x = x0, y = x1, z = x2)</tt>
 *
 * The rotation is anti-clockwise around the z-axis.\n
 * The multiplication applies to the z-coordinates.
 *
 * Note that the angles are defined in radians.\n
 *
 * Option <tt>-\@</tt> refers to the header information.\n
 * The list of possible keys can be obtained using JPrintDetector.cc with option <tt>-O header</tt>.
 *
 * Multiple options <tt>-M</tt>, <tt>-S</tt> or <tt>-\@</tt> will be processed in order of appearance.
 *
 * Note that if the output file name is the same as the input file name,
 * the original file will be overwritten.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;

  string               inputFile;
  string               outputFile;
  vector<JModifier>    mod;
  vector<JModifier>    str;
  vector<string>       hdr;
  vector<JPMTModifier> pmt;
  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['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);


  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 (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 << 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) {

        DEBUG("Modifier"                                                                              << ' '
              << "(" << setw(3) << module->getString() << "," << setw(2) << module->getFloor() << ")" << ' '
              << setw(8) << module->getID()                                                           << ' '
              << "action" << ' ' << i->action << endl);
        
        if (!i->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);
  }
}