PndLmdSensorAligner.h

Go to the documentation of this file.

/*
 * PndLmdSensorAligner.h
 *
 *  Created on: May 6, 2015
 *      Author: Roman Klasen, roklasen@uni-mainz.de or klasen@kph.uni-mainz.de
 *
 *      This class gets HitPairs from PndLmdAlignManager and generates transformation matrices for ONE overlapping area.
 *      It works in cm and gives the matrix between sensors, so the hit pairs MUST have valid x, y and z coordinates
 *      in cm.
 *
 *      One SensorAligner is responsible for one overlapping area alone, so 360 aligners are needed for the entire detector.
 *      Therefore, only the PndLmdAlignManager should interact with this class.
 */

#ifndef LMD_LMDSENSORALIGNMENT_PNDLMDSENSORALIGNER_H_
#define LMD_LMDSENSORALIGNMENT_PNDLMDSENSORALIGNER_H_

#include "PndLmdHitPair.h"

#include <string>
#include <vector>

#include <matrix.h>

// forward declarations so we can use a reference to these objects here
class PndLmdAlignManager;

class PndLmdSensorAligner {

 private:
  friend class PndLmdAlignQA;
  friend class PndLmdAlignManager;

  bool forceInstant, debug;
  unsigned int maxNoOfPairs, numberOfPairs, lastNoOfPairs, dim;
  std::string inputFilename;
  int _moduleID, overlapID;
  unsigned int nonSanePairs, skippedPairs, swappedPairs, verbose;

  std::vector<std::vector<double>> simplePairs;

  bool inCentimeters, success, zIsTimestamp;

  void printPairSpread(int what = 0);
  void transformPair(Matrix &trafoMatrix, std::vector<double> &pair);
  std::vector<double> getPairSpread(int what = 0);

  bool zeroValCheck();

  // the manager which contains this SensorAligner
  PndLmdAlignManager *superManager;

  // FIXME: in the future, return a TGeoHMatrix
  Matrix resultMatrix;

 public:
  PndLmdSensorAligner();
  PndLmdSensorAligner(const PndLmdSensorAligner &other);
  virtual ~PndLmdSensorAligner();

  // every constructor should call this, also resets aligner (even though that never happens in normal use)
  void init();

  // add simplified pair, for size and performance reasons, return false if aligner has enough pairs, return true if successful
  bool addSimplePair(const PndLmdHitPair &pair);

  // TODO: these two functions belong in the manager, not the aligner
  bool writePairsToBinary(const std::string directory);
  bool readPairsFromBinary(const std::string directory);

  // set how many pairs the aligner should use, if higher than available in file, it will use all available
  // set 0 for all
  void setMaximumNumberOfHitPairs(Int_t maxPairs)
  {
    if (maxPairs > 0) {
      maxNoOfPairs = maxPairs;
      simplePairs.reserve(maxPairs);
    }
  }

  Matrix transformToLmdLocal();
  Matrix transformToSensorOne();

  bool check();

  void clearPairs();

  // deactivate iterative part
  void setForceInstant(Bool_t instant) { forceInstant = instant; }

  void setModuleID(Int_t ID) { _moduleID = ID; }
  int getModuleID() { return _moduleID; }
  int getNoOfPairs()
  {
    // usually, simplePairs contains all pairs, but if it gets cleared,
    // the info is lost, so we save the number of pairs somewhere else.
    int sPairs = simplePairs.size();
    if (sPairs > 0) {
      return sPairs;
    } else {
      return lastNoOfPairs;
    }
  }

  void applyDynamicCut(double percent = 5.0);

  void calculateMatrix();

  int getOverlapId() const { return overlapID; }

  void setOverlapId(Int_t overlapId) { overlapID = overlapId; }

  const Matrix &getResultMatrix() const { return resultMatrix; }

  // true in cm, false in pixels
  void setInCentimeters(bool value) { inCentimeters = value; }

  bool successful() { return success; }

  void setZasTimetamp(bool value) { zIsTimestamp = value; }

  void verboseLevel(int level) { verbose = level; }

  void setManager(PndLmdAlignManager *manager) { superManager = manager; }

  unsigned int getDim() const { return dim; }

  void setDim(unsigned int value) { dim = value; }
};

#endif /* LMD_LMDSENSORALIGNMENT_PNDLMDSENSORALIGNER_H_ */