#include <PndLmdAlignManager.h>

Public Member Functions
	PndLmdAlignManager ()

virtual	~PndLmdAlignManager ()

void	init ()

bool	addFile (std::string filename)

void	readFilesAndAlign ()

bool	writePairsToBinaryFiles ()

bool	readPairsFromBinaryFilesAndAlign ()

bool	checkForBinaryFiles ()

bool	checkForLmdMatrixFiles ()

void	clearPairs ()

int	addFilesFromDirectory (std::string directory, int maxFiles=0)

void	validate ()

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

void	setMaxPairs (int maxPairs)

void	setSingleAligner (bool singleAligner)

void	setOutFilename (const std::string &filename)

void	setMatrixOutDir (std::string directory)

void	setInCentimeters (bool inCentimeters)

void	setZasTimestamp (bool timestamp)

void	setBinaryPairFileDirectory (const std::string &directory)

void	verboseLevel (int verbose)

void	setMaxThreads (int NmaxThreads=0)

Static Public Member Functions
static Matrix	castTGeoHMatrixToMatrix (const TGeoHMatrix &matrix)

static Matrix	readMatrix (std::string filename)

static TGeoHMatrix	readTGeoHMatrix (std::string filename)

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

static std::vector < std::vector< double > >	readFromCSVFile (std::string filename)

static int	searchFiles (std::string curr_directory, std::vector< std::string > &list, std::string extension="", bool includeSubDirs=true)

static void	clearScreen ()

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)

static bool	writeConfigFile (boost::property_tree::ptree configTree, std::string filename, bool replaceExisting=true)

static boost::property_tree::ptree	readConfigFile (std::string filename)

Private Types
typedef std::map< int, PndLmdSensorAligner > ::iterator	mapIt

Private Member Functions
bool	allAlignersFull ()

bool	addPairAndStartAligner (PndLmdHitPair &pair, PndLmdThreadPool &threadPool)

void	runSensorAligner (PndLmdSensorAligner &aligner)

void	checkIOpaths ()

void	waitForCompletion (PndLmdThreadPool &threadPool)

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

Static Private Member Functions
static std::string	makeBinaryPairFileName (int overlapId=0, bool incentimeters=true)

static std::string	makeMatrixFileName (int overlapId=0, bool incentimeters=true)

Private Attributes
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

bool	_inCentimeters

bool	enableHelperMatrix

bool	_zIsTimestamp

std::string	outFilename

std::string	matrixOutDir

std::string	binaryPairFileDirectory

bool	_firstInitDone

bool	_multithreaded

vector< int >	overlapIDs

Friends
class	PndLmdSensorAligner

class	PndLmdAlignQA

Detailed Description

Definition at line 31 of file PndLmdAlignManager.h.

Member Typedef Documentation

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

private

Definition at line 33 of file PndLmdAlignManager.h.

Constructor & Destructor Documentation

PndLmdAlignManager::PndLmdAlignManager ( )

Definition at line 41 of file PndLmdAlignManager.cxx.

References init().

                                        {
         init();
 }

PndLmdAlignManager::~PndLmdAlignManager ( )

virtual

Definition at line 84 of file PndLmdAlignManager.cxx.

84 {

85 }

Member Function Documentation

bool PndLmdAlignManager::addFile ( std::string filename )

Definition at line 95 of file PndLmdAlignManager.cxx.

References _allFilesAdded, and fileNames.

                                                    {
 
         if (_allFilesAdded) {
                 return false;
         }
         else {
                 fileNames.push_back(filename);
                 return true;
         }
 }

int PndLmdAlignManager::addFilesFromDirectory	(	std::string	directory,
		int	maxFiles = `0`
	)

Definition at line 106 of file PndLmdAlignManager.cxx.

References _allFilesAdded, fileNames, i, and searchFiles().

Referenced by runLumiPixel2fMatrixFinder().

                                                                                {
 
         if (_allFilesAdded) {
                 return fileNames.size();
         }
         else {
                 std::vector<string> list;
                 searchFiles(directory, list, ".root", false);
                 for (size_t i = 0; i < list.size(); i++) {
                         fileNames.push_back(list[i]);
                         if ((int) i == maxFiles - 1) {  //we use == instead of >= so that maxFiles=0 always chooses all files
                                 break;
                         }
                 }
                 _allFilesAdded = true;
                 cout << "looking for files in " << directory << ". choose " << fileNames.size()
                     << " files of maximum of " << maxFiles << ".\n";
                 return fileNames.size();
         }
 
 }

bool PndLmdAlignManager::addPairAndStartAligner	(	PndLmdHitPair &	pair,
		PndLmdThreadPool &	threadPool
	)

private

Definition at line 667 of file PndLmdAlignManager.cxx.

References aligners, alignersFull, PndLmdHitPair::check(), PndLmdThreadPool::enqueue(), PndLmdHitPair::getOverlapId(), PndLmdHitPair::isSane(), runSensorAligner(), and verbosePrint().

Referenced by readFilesAndAlign().

                                                                                                  {
 
         bool pairAdded = false;
 
         int thisID = pair.getOverlapId();
 
         // check if the aligner for that pair is full. if yes, skip this pair.
         // do this even before checking that pair, saves on cpu time.
         if (alignersFull[thisID]) {
                 return false;
         }
 
         pair.check();
         if (pair.isSane()) {
                 pairAdded = aligners[thisID].addSimplePair(pair);  //returns true if addPair succeeded
                 alignersFull[thisID] = !pairAdded;              //if addPair failed, the aligner is full
         }
         else {
                 verbosePrint("pair is not sane. processing failed.\n", 1);
         }
 
         //if aligner is full, start thread directly.
         if (alignersFull[thisID]) {
                 //alignerThreadGroup.create_thread(
                 threadPool.enqueue(
                     boost::bind(&PndLmdAlignManager::runSensorAligner, this, boost::ref(aligners[thisID])));
         }
         return true;
 }

bool PndLmdAlignManager::allAlignersFull ( )

private

Definition at line 697 of file PndLmdAlignManager.cxx.

References alignersFull, overlapIDs, and verbosePrint().

Referenced by readFilesAndAlign().

                                          {
         //check if all aligners are done
         for (auto &id : overlapIDs) {
                 if (!alignersFull[id]) {
                         return false;
                 }
         }
         verbosePrint("all aligners are already full. no further files will be read.\n", 1);
         return true;
 }

Matrix PndLmdAlignManager::castTGeoHMatrixToMatrix ( const TGeoHMatrix & matrix )

static

Definition at line 493 of file PndLmdAlignManager.cxx.

Referenced by readMatrix(), PndLmdSensorAligner::transformToLmdLocal(), and PndLmdSensorAligner::transformToSensorOne().

                                                                             {
 
         //allocate memory for matrix elements
         double* homogenousMatrix = new double[16];
         double* finalMatrix = new double[16];
         matrix.GetHomogenousMatrix(homogenousMatrix);
 
         /*
          * this code was tested on 2016-08-29 and works. The root implementation is still not
          * according to ROOT documentation, in that the translation parts of a matrix are not
          * where they should be and sometimes the homogenous coordinate is not set to 1.
          * This fixes that.
          *
          * DO NOT REMOVE THESE COMMENTS!
          *
          * When in doubt, refer to the
          * following code example, that shows where the translations (wrongfully) is:
          */
         /*
 
          //test tgeohmatrices
          TGeoHMatrix *h1 = new TGeoHMatrix(TGeoTranslation(1,2,3));
          TGeoHMatrix *h2 = new TGeoHMatrix();
          TGeoHMatrix *h3 = new TGeoHMatrix();
          TGeoHMatrix *h4 = new TGeoHMatrix();
 
          h2->SetDx(1.); h2->SetDy(2.); h2->SetDz(3.);
          double tr[3] = {1.,2.,3.};
          h3->SetTranslation(tr);
          const double rot[9] = {0,1,0,-1,0,0,0,0,0};
          h4->SetRotation(rot);
 
          Matrix m1 = castTGeoHMatrixToMatrix(*h1);
          Matrix m2 = castTGeoHMatrixToMatrix(*h2);
          Matrix m3 = castTGeoHMatrixToMatrix(*h3);
          Matrix m4 = castTGeoHMatrixToMatrix(*h4);
 
          cout << "m1:\n" << m1 << "\n";
          cout << "m2:\n" << m2 << "\n";
          cout << "m3:\n" << m3 << "\n";
          cout << "m4:\n" << m4 << "\n";
          */
 
         //copy values from the wrong to the correct positions
         finalMatrix[0] = homogenousMatrix[0];
         finalMatrix[1] = homogenousMatrix[1];
         finalMatrix[2] = homogenousMatrix[2];
         finalMatrix[3] = homogenousMatrix[12];
         finalMatrix[4] = homogenousMatrix[4];
         finalMatrix[5] = homogenousMatrix[5];
         finalMatrix[6] = homogenousMatrix[6];
         finalMatrix[7] = homogenousMatrix[13];
         finalMatrix[8] = homogenousMatrix[8];
         finalMatrix[9] = homogenousMatrix[9];
         finalMatrix[10] = homogenousMatrix[10];
         finalMatrix[11] = homogenousMatrix[14];
         finalMatrix[12] = homogenousMatrix[3];
         finalMatrix[13] = homogenousMatrix[7];
         finalMatrix[14] = homogenousMatrix[11];
         finalMatrix[15] = 1.0;
 
         //create matrix and clean up
         Matrix result(4, 4, finalMatrix);
         delete homogenousMatrix;
         delete finalMatrix;
         return result;
 
 }

bool PndLmdAlignManager::checkForBinaryFiles ( )

Definition at line 562 of file PndLmdAlignManager.cxx.

References _inCentimeters, binaryPairFileDirectory, files, i, makeBinaryPairFileName(), overlapIDs, and searchFiles().

Referenced by runLumiPixel2fMatrixFinder(), and runSensorAligner().

                                              {
 
         vector<string> files;
         searchFiles(binaryPairFileDirectory, files, "bin", false);
         int foundFiles = 0;
 
         //no binary files at all!
         if (files.size() == 0) {
                 return false;
         }
 
         string matrixName;
         bool tempfilefound = false;
 
         //check for every ID that should be there if there is a corresponding file
         for (size_t i = 0; i < overlapIDs.size(); i++) {
 
                 tempfilefound = false;
                 matrixName = makeBinaryPairFileName(overlapIDs[i], _inCentimeters);
                 for (size_t j = 0; j < files.size(); j++) {
                         if (files[j].find(matrixName) != string::npos) {
                                 tempfilefound = true;
                                 foundFiles++;
                         }
                 }
 
                 //file not found? then at least one is missing, return false
                 if (!tempfilefound) {
                         return tempfilefound;
                 }
         }
         return true;
 }

bool PndLmdAlignManager::checkForLmdMatrixFiles ( )

Definition at line 596 of file PndLmdAlignManager.cxx.

References binaryPairFileDirectory, files, i, makeMatrixFileName(), overlapIDs, and searchFiles().

Referenced by runLumiPixel2fMatrixFinder().

                                                 {
 
         vector<string> files;
         searchFiles(binaryPairFileDirectory, files, "mat", false);
         int foundFiles = 0;
 
         //no binary files at all!
         if (files.size() == 0) {
                 return false;
         }
 
         string matrixName1, matrixName2;
         bool tempfilefound = false;
 
         //check for every ID that should be there if there is a corresponding file
         for (size_t i = 0; i < overlapIDs.size(); i++) {
 
                 //reset counter
                 tempfilefound = false;
                 matrixName1 = makeMatrixFileName(overlapIDs[i], true);
                 matrixName1 = makeMatrixFileName(overlapIDs[i], false);
 
                 for (size_t j = 0; j < files.size(); j++) {
                         if (files[j].find(matrixName1) != string::npos) {
                                 //file is present
                                 tempfilefound = true;
                                 foundFiles++;
                         }
                 }
 
                 //file not found? then at least one is missing, return false
                 if (!tempfilefound) {
                         return tempfilefound;
                 }
         }
         return true;
 }

void PndLmdAlignManager::checkIOpaths ( )

private

Definition at line 256 of file PndLmdAlignManager.cxx.

References exit(), fileNames, matrixOutDir, and outFilename.

Referenced by setOutFilename().

                                       {
 
         if (fileNames.size() == 0) {
                 //cout << "no pair files specified, are we using binary data?\n";
         }
         for (size_t iFile = 0; iFile < fileNames.size(); iFile++) {
                 if (!boost::filesystem::exists(fileNames[iFile])) {
                         cout << "error opening file:";
                         cout << fileNames[iFile] << "\n";
                         exit(1);
                 }
         }
 
         if (!(outFilename == "")) {
                 boost::filesystem::path outPath(outFilename);
                 if (!boost::filesystem::exists(outPath.parent_path())) {
                         boost::filesystem::create_directories(outPath.parent_path());
                 }
         }
 
         if (!(matrixOutDir == "")) {
                 if (!boost::filesystem::exists(matrixOutDir)) {
                         boost::filesystem::create_directories(matrixOutDir);
                 }
         }
 }

void PndLmdAlignManager::clearPairs ( )

Definition at line 887 of file PndLmdAlignManager.cxx.

References aligners.

                                     {
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                 it->second.clearPairs();
         }
 }

void PndLmdAlignManager::clearScreen ( )

static

Definition at line 663 of file PndLmdAlignManager.cxx.

                                      {
         cout << "\x1B[2J\x1B[H";
 }

bool PndLmdAlignManager::exists ( std::string file )

static

Definition at line 424 of file PndLmdAlignManager.cxx.

                                               {
         return boost::filesystem::exists(boost::filesystem::path(path));
 }

vector< string > PndLmdAlignManager::findRegex	(	std::string	source,
		std::string	regex
	)

static

Definition at line 428 of file PndLmdAlignManager.cxx.

Referenced by PndLmdAlignQA::readMatrixInfo().

                                                                               {
 
         boost::regex expression(regex);
         std::string::const_iterator start, end;
         start = source.begin();
         end = source.end();
         boost::match_results<std::string::const_iterator> result;
         boost::match_flag_type flags = boost::match_default;
 
         vector<string> resultStrings;
 
         while (regex_search(start, end, result, expression, flags)) {
                 // update search position:
                 start = result[0].second;
 
                 for (size_t j = 0; j < result.size(); j++) {
                         resultStrings.push_back(boost::lexical_cast<string>(result[j]));
                 }
 
                 // update flags:
                 flags |= boost::match_prev_avail;
                 flags |= boost::match_not_bob;
         }
 
         return resultStrings;
 }

void PndLmdAlignManager::init ( )

Definition at line 45 of file PndLmdAlignManager.cxx.

References _allFilesAdded, _firstInitDone, _inCentimeters, _info, _multithreaded, _singleAligner, _verboseLevel, _zIsTimestamp, aligners, alignersFull, enableHelperMatrix, fileNames, PndLmdGeometryHelper::getAvailableOverlapIDs(), PndLmdGeometryHelper::getInstance(), helper, i, outFilename, overlapIDs, PndLmdSensorAligner::setInCentimeters(), PndLmdSensorAligner::setManager(), PndLmdSensorAligner::setOverlapId(), and PndLmdSensorAligner::setZasTimetamp().

Referenced by PndLmdAlignManager().

                               {
 
         _info << "info for aligned areas\n";
 
         _zIsTimestamp = true;
         _allFilesAdded = false;
         _singleAligner = true;
         _inCentimeters = false;
         enableHelperMatrix = false;
         _multithreaded = false;
         _verboseLevel = 0;
 
         //int overlapId=-1;
         fileNames.clear();
         aligners.clear();
 
         PndLmdGeometryHelper *helper = &PndLmdGeometryHelper::getInstance();
         overlapIDs = helper->getAvailableOverlapIDs();
         for (size_t i = 0; i < overlapIDs.size(); i++) {
                 int overlapId = overlapIDs[i];
 
                 PndLmdSensorAligner tempAligner;
                 tempAligner.setManager(this);
                 tempAligner.setOverlapId(overlapId);
                 tempAligner.setZasTimetamp(_zIsTimestamp);
                 tempAligner.setInCentimeters(_inCentimeters);
                 aligners[overlapId] = tempAligner;
         }
 
         // we just started, all aligners are empty
         for (size_t i = 0; i < overlapIDs.size(); i++) {
                 alignersFull[overlapIDs[i]] = false;
         }
 
         outFilename = "";
         _firstInitDone = true;
         std::cout << "PndLmdAlignManager::Init(): Initialization successful." << "\n";
 }

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

Definition at line 217 of file PndLmdAlignManager.cxx.

References c, i, MTLBmutex, n, printf(), and x.

Referenced by readFilesAndAlign(), readPairsFromBinaryFilesAndAlign(), and writePairsToBinaryFiles().

                                                                               {
 
         std::lock_guard<std::mutex> lock(MTLBmutex);
 
         // Only update r times.
         if (n == 0) return;
         if (n == 1) return;
 
         if (r > n) {
                 r = n;
         }
 
         //calculate ev / sec every 100000 iterations
         if (i % (n / r) != 0) {
                 return;
         }
 
         flush(cout);
 
         // Calculate the ratio of complete-to-incomplete.
         float ratio = i / (float) n;
         int c = ratio * w;
 
         // Show the percentage complete.
         printf("%3d%% [", (int) (ratio * 100));
 
         // Show the load bar.
         for (int x = 0; x < c; x++)
                 printf("=");
 
         for (int x = c; x < w; x++)
                 printf(" ");
 
         // ANSI Control codes to go back to the
         // previous line and clear it.
         printf("] %s %d of %d \n\033[F\033[J", message.c_str(), i, n);
 
 }

std::string PndLmdAlignManager::makeBinaryPairFileName	(	int	overlapId = `0`,
		bool	incentimeters = `true`
	)

staticprivate

Definition at line 634 of file PndLmdAlignManager.cxx.

References filename.

Referenced by checkForBinaryFiles(), PndLmdSensorAligner::readPairsFromBinary(), and PndLmdSensorAligner::writePairsToBinary().

                                                                                       {
         std::stringstream filename;
         filename << "/pairs-" << overlapId;
         incentimeters ? filename << "-cm.bin" : filename << "-px.bin";
         return filename.str();
 }

std::string PndLmdAlignManager::makeMatrixFileName	(	int	overlapId = `0`,
		bool	incentimeters = `true`
	)

staticprivate

Definition at line 641 of file PndLmdAlignManager.cxx.

Referenced by checkForLmdMatrixFiles(), PndLmdAlignQA::checkForMatrixFiles(), and waitForCompletion().

                                                                                   {
         stringstream matrixName;
         matrixName << "/m";
         incentimeters ? matrixName << overlapId << "cm.mat" : matrixName << overlapId << "px.mat";
         return matrixName.str();
 }

bool PndLmdAlignManager::mkdir ( std::string path )

static

Definition at line 416 of file PndLmdAlignManager.cxx.

Referenced by PndLmdAlignQA::createHist(), PndLmdSensorAligner::writePairsToBinary(), and writePairsToBinaryFiles().

                                              {
         boost::filesystem::path bpath(path);
         if (boost::filesystem::exists(bpath)) {
                 return true;
         }
         return boost::filesystem::create_directories(bpath);
 }

boost::property_tree::ptree PndLmdAlignManager::readConfigFile ( std::string filename )

static

Definition at line 851 of file PndLmdAlignManager.cxx.

References is.

                                                                              {
 
         //check if file exists
         if (!boost::filesystem::exists(filename)) {
                 cerr << "PndLmdAlignManager::readConfig: ERROR! File " << filename << " not found!\n";
         }
 
         std::ifstream is(filename);
         boost::property_tree::ptree root;
         try {
                 boost::property_tree::read_json(is, root);
         }
         catch (std::exception &e) {
                 cerr << "PndLmdAlignManager::readConfig: ERROR! Can't parse json file " << filename << ".\n";
         }
         return root;
 }

void PndLmdAlignManager::readFilesAndAlign ( )

Definition at line 128 of file PndLmdAlignManager.cxx.

References _allFilesAdded, addPairAndStartAligner(), allAlignersFull(), exit(), fileNames, i, loadBar(), and waitForCompletion().

Referenced by runLumiPixel2fMatrixFinder().

                                            {
 
         _allFilesAdded = true;
 
         PndLmdThreadPool threadPool;
 
         int noOfFiles = fileNames.size();
         if (noOfFiles > 0) {
                 cout << "found " << noOfFiles << " file(s). reading...\n";
         }
         else {
                 cout << "no files found. exiting.\n";
                 exit(0);
         }
 
         TChain* chainPairs = new TChain("pndsim");
         for (size_t i = 0; i < fileNames.size(); i++) {
                 //cout << files[i] << endl;
                 if (fileNames[i].find("Lumi_Pairs") != std::string::npos) {
                         chainPairs->Add(fileNames[i].c_str());
                 }
         }
 
         //pairs of sensors in LMD coordinates
         TClonesArray* hitPairs = new TClonesArray("PndLmdHitPair");
         chainPairs->SetBranchAddress("PndLmdHitPair", &hitPairs);
         int nEntries = chainPairs->GetEntries();
         cout << "HitPairs no of entries: " << nEntries << "\n";
 
         cout << "Sorting Pairs to Manager...\n";
         int totalPairs = 0;
         for (int i_event = 0; i_event < nEntries; i_event++) {
 
                 loadBar(i_event, nEntries, 1000, 60);
                 chainPairs->GetEntry(i_event);
                 int nPairs = hitPairs->GetEntries();
 
                 //loop over hitPairs per Event
                 for (int i_Pair = 0; i_Pair < nPairs; i_Pair++) {
                         PndLmdHitPair* currentPair = (PndLmdHitPair*) hitPairs->At(i_Pair);
                         addPairAndStartAligner(*currentPair, threadPool);
                         totalPairs++;
                 }
 
                 //should this be done at the end or the start of the for loop?
                 if (allAlignersFull()) {
                         break;
                 }
         }
 
         //save matrices to disk
         waitForCompletion(threadPool);
 
         cout << "================================ \n";
         cout << "total Pairs: " << totalPairs << "\n";
         cout << "All done. Running Align Manager. \n";
         cout << "================================ \n";
 
         delete chainPairs;
         delete hitPairs;
 }

vector< vector< double > > PndLmdAlignManager::readFromCSVFile ( std::string filename )

static

Definition at line 366 of file PndLmdAlignManager.cxx.

Referenced by readTGeoHMatrix().

                                                                               {
 
         std::vector<std::vector<double> > data;
         ifstream ifs;
         ifs.open(filename.c_str());
         if (ifs.is_open()) {
                 stringstream iss;
                 string line, token;
 
                 while (getline(ifs, line)) {
                         iss << line;
                         std::vector<double> tempvec;
                         while (getline(iss, token, ',')) {
                                 tempvec.push_back(boost::lexical_cast<double>(token));
                         }
                         data.push_back(tempvec);
                         iss.clear();
                 }
                 ifs.close();
         }
         else {
                 throw std::runtime_error("Unable to open file " + filename);
         }
 
         return data;
 }

Matrix PndLmdAlignManager::readMatrix ( std::string filename )

static

Definition at line 283 of file PndLmdAlignManager.cxx.

References castTGeoHMatrixToMatrix(), and readTGeoHMatrix().

                                                         {
         // avoid code duplication
         return castTGeoHMatrixToMatrix(readTGeoHMatrix(filename));
 }

bool PndLmdAlignManager::readPairsFromBinaryFilesAndAlign ( )

Definition at line 795 of file PndLmdAlignManager.cxx.

References aligners, alignersFull, binaryPairFileDirectory, PndLmdThreadPool::enqueue(), loadBar(), maxThreads, overlapIDs, PndLmdSensorAligner::readPairsFromBinary(), runSensorAligner(), mrfdata_8b_error::success, and waitForCompletion().

Referenced by runLumiPixel2fMatrixFinder().

                                                           {
 
         bool success = true;
 
         if (binaryPairFileDirectory == "") {
                 cout << "error: binary pair file directory not set.\n";
                 cout << "use PndLmdAlignManager::setBinaryPairFileDirectory()\n";
                 return false;
         }
 
         int cur, tot;
         cur = 0;
         tot = aligners.size();
 
         cout << "reading all pairs from binary files and starting aligners...\n";
 
         // use single thread as long as gGeoManger / GeometryHelper are not thread safe!
         bool mt = true;
         PndLmdThreadPool threadPool(maxThreads);
 
         for (auto &id : overlapIDs) {
 
                 if (!mt) {
                         // single threaded, low memory consumption version
                         loadBar(cur++, tot, 1000, 60);
                         PndLmdSensorAligner &thisAligner = aligners[id];
                         if (thisAligner.readPairsFromBinary(binaryPairFileDirectory)) {
                                 runSensorAligner(thisAligner);
                         }
                 }
                 else {
                         loadBar(cur++, tot, 1000, 60);
                         PndLmdSensorAligner &thisAligner = aligners[id];
 
                         if (thisAligner.readPairsFromBinary(binaryPairFileDirectory)) {
                                 alignersFull[id] = true;
                                 threadPool.enqueue(
                                     boost::bind(&PndLmdAlignManager::runSensorAligner, this, boost::ref(thisAligner)));
                         }
                         else {
                                 success = false;
                         }
                 }
         }
 
         // write matrices to disk etc
         waitForCompletion(threadPool);
         return success;
 }

TGeoHMatrix PndLmdAlignManager::readTGeoHMatrix ( std::string filename )

static

Definition at line 288 of file PndLmdAlignManager.cxx.

References i, Matrix::m, Matrix::n, readFromCSVFile(), rotation, and Matrix::val.

Referenced by PndLmdAlignQA::getMatrixDiffCM(), PndLmdAlignQA::getMisalignedOverlapFromICP(), and readMatrix().

                                                                   {
 
         vector<vector<double> > temp = readFromCSVFile(filename);
 
         if (temp.size() < 1) {
                 cout << "warning! can't read matrix from file " << filename << "\n";
                 return TGeoHMatrix();
         }
         if (temp[0].size() < 1) {
                 cout << "warning! can't read matrix from file " << filename << "\n";
                 return TGeoHMatrix();
         }
 
         int rows, columns;
         rows = temp.size();
         columns = temp[0].size();
         Matrix resultMat(rows, columns);
 
         double rotation[9];
         double translation[3];
         TGeoHMatrix result;
 
         for (int i = 0; i < rows; i++) {
                 for (int j = 0; j < columns; j++) {
                         resultMat.val[i][j] = temp[i][j];
                 }
         }
 
         // have we even read a real matrix?
         if (resultMat.m != 4 || resultMat.n != 4) {
                 cerr << "Error! Invalid matrix!\n";
                 return TGeoHMatrix();
         }
 
         // fuck it, we do it by hand
         rotation[0] = resultMat.val[0][0];
         rotation[1] = resultMat.val[0][1];
         rotation[2] = resultMat.val[0][2];
         rotation[3] = resultMat.val[1][0];
         rotation[4] = resultMat.val[1][1];
         rotation[5] = resultMat.val[1][2];
         rotation[6] = resultMat.val[2][0];
         rotation[7] = resultMat.val[2][1];
         rotation[8] = resultMat.val[2][2];
 
         translation[0] = resultMat.val[0][3];
         translation[1] = resultMat.val[1][3];
         translation[2] = resultMat.val[2][3];
 
         result.SetRotation(rotation);
         result.SetTranslation(translation);
 
         return result;
 }

void PndLmdAlignManager::runSensorAligner ( PndLmdSensorAligner & aligner )

private

Definition at line 191 of file PndLmdAlignManager.cxx.

References PndLmdSensorAligner::applyDynamicCut(), binaryPairFileDirectory, PndLmdSensorAligner::calculateMatrix(), PndLmdSensorAligner::check(), checkForBinaryFiles(), PndLmdSensorAligner::clearPairs(), PndLmdSensorAligner::transformToSensorOne(), and PndLmdSensorAligner::writePairsToBinary().

Referenced by addPairAndStartAligner(), readPairsFromBinaryFilesAndAlign(), and waitForCompletion().

                                                                       {
 
         //perform first checks
         if (!aligner.check()) {
                 return;
         }
 
         //write binary file only if not already present
         if (!checkForBinaryFiles()) {
                 aligner.writePairsToBinary(binaryPairFileDirectory);
         }
 
         // this must be done before dynamic cut!
         aligner.transformToSensorOne();
 
         // apply dynamic cut. this changes the amount of pairs the aligner has,
         // so don't re-save the pairs after that!
         aligner.applyDynamicCut();
 
         //calculate the matrix
         aligner.calculateMatrix();
 
         //free memory
         aligner.clearPairs();
 }

int PndLmdAlignManager::searchDirectories	(	std::string	curr_directory,
		std::vector< std::string > &	list,
		bool	includeSubDirs = `true`
	)

static

Definition at line 455 of file PndLmdAlignManager.cxx.

                          {
 
         if (!boost::filesystem::exists(curr_directory)) {
                 return 0;
         }
         boost::filesystem::directory_iterator iterator(curr_directory);
 
         for (; iterator != boost::filesystem::directory_iterator(); ++iterator) {
                 boost::filesystem::path thisPath = iterator->path();
                 if (boost::filesystem::is_directory(thisPath)) {
                         list.push_back(thisPath.string());
 
                         //recursively call for sub directories
                         if (includeSubDirs) {
                                 searchDirectories(thisPath.string(), list, includeSubDirs);
                         }
                 }
         }
         sort(list.begin(), list.end());
         return list.size();
 
 }

int PndLmdAlignManager::searchFiles	(	std::string	curr_directory,
		std::vector< std::string > &	list,
		std::string	extension = `""`,
		bool	includeSubDirs = `true`
	)

static

Definition at line 393 of file PndLmdAlignManager.cxx.

Referenced by addFilesFromDirectory(), checkForBinaryFiles(), checkForLmdMatrixFiles(), and PndLmdAlignQA::checkForMatrixFiles().

                          {
 
         if (!boost::filesystem::exists(path)) {
                 return 0;
         }
         boost::filesystem::directory_iterator iterator(path);
         for (; iterator != boost::filesystem::directory_iterator(); ++iterator) {
                 boost::filesystem::path thisPath = iterator->path();
                 if (boost::filesystem::is_directory(thisPath) && includeSubDirs) {
                         list.push_back(thisPath.string());
                         searchFiles(thisPath.string(), list, detail, includeSubDirs);
                 }
                 else if (boost::filesystem::is_regular_file(thisPath)) {
                         if (thisPath.string().find(detail) != std::string::npos) {
                                 list.push_back(thisPath.string());
                         }
                 }
         }
         sort(list.begin(), list.end());
         return list.size();
 }

void PndLmdAlignManager::setBinaryPairFileDirectory ( const std::string & directory )

inline

Definition at line 171 of file PndLmdAlignManager.h.

References directory.

Referenced by runLumiPixel2fMatrixFinder().

                                                                     {
                 binaryPairFileDirectory = directory;
         }

void PndLmdAlignManager::setInCentimeters ( bool inCentimeters )

Definition at line 479 of file PndLmdAlignManager.cxx.

References _inCentimeters, and aligners.

Referenced by PndLmdAlignQA::checkCyclicMatrices(), and runLumiPixel2fMatrixFinder().

                                                             {
         _inCentimeters = inCentimeters;
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                 it->second.setInCentimeters(_inCentimeters);
         }
 }

void PndLmdAlignManager::setMatrixOutDir ( std::string directory )

inline

Definition at line 150 of file PndLmdAlignManager.h.

References directory.

Referenced by PndLmdAlignQA::checkCombined(), PndLmdAlignQA::checkCyclicMatrices(), and runLumiPixel2fMatrixFinder().

                                                   {
                 matrixOutDir = directory;
         }

void PndLmdAlignManager::setMaxPairs ( int maxPairs )

Definition at line 648 of file PndLmdAlignManager.cxx.

References aligners.

Referenced by runLumiPixel2fMatrixFinder().

                                                  {
 
         if (maxPairs > 0) {
                 for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                         it->second.setMaximumNumberOfHitPairs(maxPairs);
                 }
                 return;
         }
         else {
                 cout << "warning. max pairs must be larger than 0!\n";
                 return;
         }
 
 }

void PndLmdAlignManager::setMaxThreads ( int NmaxThreads = 0 )

inline

Definition at line 182 of file PndLmdAlignManager.h.

Referenced by runLumiPixel2fMatrixFinder().

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

void PndLmdAlignManager::setOutFilename ( const std::string & filename )

inline

Definition at line 124 of file PndLmdAlignManager.h.

References checkIOpaths(), and filename.

                                                        {
                 outFilename = filename;
                 checkIOpaths();
         }

void PndLmdAlignManager::setSingleAligner ( bool singleAligner )

inline

Definition at line 120 of file PndLmdAlignManager.h.

                                                   {
                 _singleAligner = singleAligner;
         }

void PndLmdAlignManager::setZasTimestamp ( bool timestamp )

Definition at line 486 of file PndLmdAlignManager.cxx.

References _zIsTimestamp, and aligners.

                                                        {
         _zIsTimestamp = timestamp;
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                 it->second.setZasTimetamp(_zIsTimestamp);
         }
 }

void PndLmdAlignManager::validate ( )

Definition at line 87 of file PndLmdAlignManager.cxx.

References aligners.

                                   {
         std::cout << "using " << aligners.size() << " aligners, which have:\n";
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                 cout << "id: " << it->second.getModuleID() << " has " << it->second.getNoOfPairs() << " pairs."
                     << "\n";
         }
 }

void PndLmdAlignManager::verboseLevel ( int verbose )

inline

Definition at line 175 of file PndLmdAlignManager.h.

References a, and verbose.

Referenced by runLumiPixel2fMatrixFinder().

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

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

private

Definition at line 845 of file PndLmdAlignManager.cxx.

References _verboseLevel.

Referenced by addPairAndStartAligner(), and allAlignersFull().

                                                                 {
         if (_verboseLevel >= level) {
                 cout << input;
         }
 }

void PndLmdAlignManager::waitForCompletion ( PndLmdThreadPool & threadPool )

private

Definition at line 708 of file PndLmdAlignManager.cxx.

References _inCentimeters, _info, aligners, alignersFull, PndLmdThreadPool::enqueue(), makeMatrixFileName(), matrixOutDir, overlapIDs, runSensorAligner(), PndLmdThreadPool::wait(), and writeMatrix().

Referenced by readFilesAndAlign(), and readPairsFromBinaryFilesAndAlign().

                                                                        {
 
         //start all alignsers that have not already started (i.e. don't have required no of Pairs)
         int notStarted = 0;
 
         cout << "starting remaining aligners.\n";
         for (auto &id : overlapIDs) {
 
                 //onlt start aligners that have not already started
                 if (!(alignersFull[id])) {
 
                         //if pair could not be added, aligner is full. start thread directly.
                         //alignerThreadGroup.create_thread(
                         threadPool.enqueue(
                             boost::bind(&PndLmdAlignManager::runSensorAligner, this, boost::ref(aligners[id])));
                         notStarted++;
                 }
         }
         cout << notStarted << " aligners remained.\n";
         //cout << "jobs queue size : " << alignerThreadGroup.size() << "/360\n";
         cout << "waiting for all aligners to finish...";
 
         //wait for all threads to complete
         //alignerThreadGroup.join_all();
         flush(cout);
         threadPool.wait();
 
         cout << "done!\n";
 
         for (auto &id : overlapIDs) {
                 if (aligners[id].successful()) {
 
                         Matrix result = aligners[id].getResultMatrix();
                         string matrixFilename = matrixOutDir + makeMatrixFileName(id, _inCentimeters);
 
                         if (!writeMatrix(result, matrixFilename)) {
                                 cout << "ERROR: could not write matrix " << matrixFilename << "\n";
                         }
 
                         _info << "aligner " << id << ":\n";
                         _info << "no of pairs: " << aligners[id].getNoOfPairs() << "\n";
                         _info << "\n";
                 }
                 else {
                         cout << "Error: aligner for " << id << " failed.\n";
                 }
         }
 
         //write matrix info
         ofstream of;
         if (_inCentimeters) {
                 of.open((matrixOutDir + "/info-cm.txt").c_str());
         }
         else {
                 of.open((matrixOutDir + "/info-px.txt").c_str());
         }
 
         of << _info.str();
         of.close();
         cout << "all aligners done.\n";
 }

bool PndLmdAlignManager::writeConfigFile	(	boost::property_tree::ptree	configTree,
		std::string	filename,
		bool	replaceExisting = `true`
	)

static

Definition at line 869 of file PndLmdAlignManager.cxx.

                           {
 
         if (boost::filesystem::exists(filename) && !replaceExisting) {
                 cerr << "PndLmdAlignManager::writeConfig: Config already exists, will not be replaced.\n";
                 return false;
         }
 
         boost::filesystem::path outPath(filename);
         if (!boost::filesystem::exists(outPath.parent_path())) {
                 boost::filesystem::create_directories(outPath.parent_path());
         }
 
         std::ofstream os(filename);
         boost::property_tree::write_json(os, configTree);
         return true;
 }

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

static

Definition at line 343 of file PndLmdAlignManager.cxx.

Referenced by waitForCompletion().

                                                                     {
 
         if (!(filename == "")) {
                 boost::filesystem::path outPath(filename);
                 if (!boost::filesystem::exists(outPath.parent_path())) {
                         boost::filesystem::create_directories(outPath.parent_path());
                 }
         }
 
         //cout << "writing matrix " << filename << "\n";
         std::ofstream outFileStream;
         outFileStream.open(filename.c_str());
 
         if (outFileStream.fail()) {
                 return false;
         }
 
         outFileStream << std::setprecision(16);
         outFileStream << mat;
         outFileStream.close();
         return true;
 }

bool PndLmdAlignManager::writePairsToBinaryFiles ( )

Definition at line 770 of file PndLmdAlignManager.cxx.

References aligners, binaryPairFileDirectory, loadBar(), and mkdir().

                                                  {
 
         if (binaryPairFileDirectory == "") {
                 cout << "error: binary pair file directory not set.\n";
                 cout << "use PndLmdAlignManager::setBinaryPairFileDirectory()\n";
                 return false;
         }
 
         int cur, tot;
         cur = 0;
         tot = aligners.size();
 
         cout << "writing all pairs to binary files\n";
         mkdir(binaryPairFileDirectory);
 
         //maybe do this multithreaded?
         for (auto &aligner : aligners) {
                 loadBar(cur++, tot, 1000, 60);
                 if (!aligner.second.writePairsToBinary(binaryPairFileDirectory)) {
                         return false;
                 }
         }
         return true;
 }