PndLmdAlignManager.h

Go to the documentation of this file.

/*
 * PndLmdAlignManager.h
 *
 *  Created on: May 26, 2015
 *      Author: Roman Klasen, roklasen@uni-mainz.de or klasen@kph.uni-mainz.de
 *
 *      This is a manager for all SensorAligner objects. It gathers all PndLmdHitPairs indiscriminately,
 *      and sorts them to 40 (depends on sensor geometry) SensorAligner Objects. It also stores the
 *      resultant matrices and writes them to disk (appropriate format is yet to come, for now just ascii).
 */

#ifndef LMD_LMDSENSORALIGNMENT_PNDLMDALIGNMANAGER_H_
#define LMD_LMDSENSORALIGNMENT_PNDLMDALIGNMANAGER_H_

#include "PndLmdHitPair.h"

#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>

#include <PndLmdAlignStructs.h>
#include <PndLmdGeometryHelper.h>
#include <PndLmdSensorAligner.h>
#include "PndLmdThreadPool.h"

#include <TGeoMatrix.h>

#include <matrix.h>
#include <string>
#include <sstream>

class PndLmdAlignManager {

  typedef std::map<int, PndLmdSensorAligner>::iterator mapIt;

 private:
  // PndLmdSensorAligner needs private functions from here
  friend class PndLmdSensorAligner;
  friend class PndLmdAlignQA;

  // loadBarMultiThreaded
  std::mutex MTLBmutex;
  std::mutex geometryHelperMutex;

  int _verboseLevel;
  unsigned int maxThreads;

  std::stringstream _info;

  std::map<int, PndLmdSensorAligner> aligners;
  std::map<int, bool> alignersFull;

  bool _allFilesAdded;
  std::vector<std::string> fileNames;
  bool _singleAligner, _inCentimeters, enableHelperMatrix, _zIsTimestamp;
  std::string outFilename, matrixOutDir, binaryPairFileDirectory;
  bool _firstInitDone;
  bool _multithreaded;

  vector<int> overlapIDs;

  bool allAlignersFull();

  // adds pairs just like the other function but starts an aligner if it is full
  bool addPairAndStartAligner(PndLmdHitPair &pair, PndLmdThreadPool &threadPool);

  void runSensorAligner(PndLmdSensorAligner &aligner);
  void checkIOpaths();

  // let all threads finish their work
  void waitForCompletion(PndLmdThreadPool &threadPool);

  // generate the file name of a matrix or pair file, so changes must only be made once
  static std::string makeBinaryPairFileName(int overlapId = 0, bool incentimeters = true);
  static std::string makeMatrixFileName(int overlapId = 0, bool incentimeters = true);

  void verbosePrint(std::string input, int level = 3);

 public:
  // An empty AlignManager will use standard values. If you want to reuse a manager, call Init() again and set values.
  PndLmdAlignManager();
  virtual ~PndLmdAlignManager();

  // initializes Manager on construction or resets every value to default
  void init();

  // add filename, so the aligner adds the pairs itself
  bool addFile(std::string filename);
  void readFilesAndAlign();

  bool writePairsToBinaryFiles();
  bool readPairsFromBinaryFilesAndAlign();
  bool checkForBinaryFiles();
  bool checkForLmdMatrixFiles();
  void clearPairs();

  // add all pair files that can be found in directory, up to a maximum of maxFiles
  // returns number of files found (including 0 for no files) or -1 if "pretend" option is set
  // set maxFiles=0 for all available files
  int addFilesFromDirectory(std::string directory, int maxFiles = 0);

  void validate();

  // perform last checks and run calculations on all aligners
  // void alignAllSensors();

  void loadBar(int current, int total, int resolution, int width, std::string message = "");

  void setMaxPairs(int maxPairs);

  static Matrix castTGeoHMatrixToMatrix(const TGeoHMatrix &matrix);

  // read and write matrix files to and from disk
  static Matrix readMatrix(std::string filename);
  static TGeoHMatrix readTGeoHMatrix(std::string filename);

  static bool writeMatrix(Matrix &mat, std::string filename);

  void setSingleAligner(bool singleAligner) { _singleAligner = singleAligner; }

  void setOutFilename(const std::string &filename)
  {
    outFilename = filename;
    checkIOpaths();
  }

  // static std::stringstream readFile(std::string filename);
  static std::vector<std::vector<double>> readFromCSVFile(std::string filename);

  /*
   * recursively searches files by extension in curr_directory and adds to list
   * finds all extensions by default, but you can specify which extension
   * (or part of filename) you want
   */
  static int searchFiles(std::string curr_directory, std::vector<std::string> &list, std::string extension = "", bool includeSubDirs = true);

  // clear console
  static void clearScreen();

  // searches directories in curr_directory, adds to list
  static int searchDirectories(std::string curr_directory, std::vector<std::string> &list, bool includeSubDirs = true);
  static bool mkdir(std::string path);
  static bool exists(std::string file);
  static std::vector<std::string> findRegex(std::string source, std::string regex);

  void setMatrixOutDir(std::string directory) { matrixOutDir = directory; }

  /*
   * set this BEFORE reading pair files. if inCentimeters==true, then hits will be decoded by PndLmdDim to centimeters
   * and all calculations will be done in cm. Misalginment matrices are close to identity matrix, which could introduce
   * numerical errors.
   * If inCentimeters==false, then the ICP will work directly on row/col values and matrix will be in pixels. AlignManager
   * converts matrix to cm, but the resultant matrix is the product of misalignment*ideal!
   */
  void setInCentimeters(bool inCentimeters);
  void setZasTimestamp(bool timestamp);

  // write config file
  static bool writeConfigFile(boost::property_tree::ptree configTree, std::string filename, bool replaceExisting = true);

  // read json config file
  static boost::property_tree::ptree readConfigFile(std::string filename);

  void setBinaryPairFileDirectory(const std::string &directory) { binaryPairFileDirectory = directory; }

  void verboseLevel(int verbose)
  {
    _verboseLevel = verbose;
    for (auto &a : aligners) {
      a.second.verboseLevel(_verboseLevel);
    }
  }

  void setMaxThreads(int NmaxThreads = 0)
  {
    if (NmaxThreads < 0 || NmaxThreads > 256) {
      // cerr << "Invalid number of threasds!\n";
    } else {
      maxThreads = NmaxThreads;
    }
  }
};

#endif /* LMD_LMDSENSORALIGNMENT_PNDLMDALIGNMANAGER_H_ */