JMoveDetector.cc File Reference

Auxiliary program to modify detector calibration. More...

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JGeometry3D/JVector3D.hh"
#include "JIO/JByteArrayIO.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>     (setx|addx|subx|sety|addy|suby|setz|addz|subz) value"
    -(S|s) "<string number>         (setx|addx|subx|sety|addy|suby|setz|addz|subz) 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.

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

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

The units of all positions are m.

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

Author

mdejong

Definition in file JMoveDetector.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 209 of file JMoveDetector.cc.

{
  using namespace std;
  using namespace JPP;

  typedef pair<int, JModifier>  pair_type;

  string             detectorFile;
  vector<pair_type>  mod;
  vector<pair_type>  str;
  vector<pair_type>  dos;
  size_t             size;
  int                debug;
  
  try { 

    JParser<> zap("Auxiliary program to modify detector.");

    zap['a'] = make_field(detectorFile, "detector file I/O");
    zap['M'] = make_field(mod,          "module modification")                                    = JPARSER::initialised();
    zap['S'] = make_field(str,          "string modification (optical modules and base module")   = JPARSER::initialised();
    zap['s'] = make_field(dos,          "string modification (optical modules only)")             = JPARSER::initialised();
    zap['N'] = make_field(size,         "internal buffer size")                                   = 500000;
    zap['d'] = make_field(debug,        "debug level")                                            = 2;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }


  if (getFilenameExtension(detectorFile) != BINARY_DETECTOR_FILE_FORMAT[1]) {
    FATAL("Wrong file name extension - should be " << BINARY_DETECTOR_FILE_FORMAT[1] << endl);
  }

  JDetector detector;

  JByteArrayWriter buffer;

  buffer.resize(size);

  fstream io;

  io.open(detectorFile.c_str(), ios::binary | ios_base::in | ios_base::out);

  if (!io) {
    FATAL("Error opening file " << detectorFile << endl);
  }

  size_t len = 0;

  for ( ; ; ) {

    io.read(buffer.data() + len, buffer.size() - len);

    len += io.gcount();

    if (io.eof())
      break;
    else
      buffer.resize(2 * buffer.size());
  }

  buffer.resize(len);

  JByteArrayReader in(buffer.data(), buffer.size());

  detector.read(in);

  detector.comment.clear();
  detector.comment.add(argv[0]);

  for (vector<pair_type>::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_type>::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) {

        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_type>::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) {

          if (debug >= debug_t) {
            print(cout, *module, i->second);
          }
        
          if (!i->second.apply(*module)) {
            ERROR("No valid action: " << i->first << ' ' << i->second << endl);
          }
        }
      }
    }
  }

  buffer.clear();

  detector.write(buffer);

  io.clear();
  io.seekp(0, ios_base::beg);

  io.write(buffer.data(), buffer.size());

  io.close();
}