#include <PndLmdAlignManager.h>

Public Member Functions
	PndLmdAlignManager ()

virtual	~PndLmdAlignManager ()

void	init ()

bool	addPairAndStartAligner (PndLmdHitPair &pair)

bool	addFile (std::string filename)

void	readFilesAndAlign ()

void	waitForCompletion ()

bool	writePairsToBinaryFiles ()

bool	readPairsFromBinaryFiles ()

bool	checkForBinaryFiles ()

bool	checkForLmdMatrixFiles ()

void	clearPairs ()

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

void	validate ()

void	alignAllSensors ()

void	setMaxPairs (int maxPairs)

void	setSingleAligner (bool singleAligner)

void	setOutFilename (const std::string &filename)

void	setMatrixOutDir (std::string matrixOutDir)

void	setInCentimeters (bool inCentimeters)

void	setZasTimestamp (bool timestamp)

void	workerThread (boost::shared_ptr< boost::asio::io_service > io_service)

void	setBinaryPairFileDirectory (const std::string &binaryPairFileDirectory)

void	setStartAlignerWhenFull (bool value)

void	verboseLevel (int verbose)

Static Public Member Functions
static void	loadBar (int current, int total, int resolution, int width, std::string message="")

static Matrix	castTGeoHMatrixToMatrix (const TGeoHMatrix &matrix)

static Matrix	readMatrix (std::string filename)

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

static std::stringstream *	readFile (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
void	alignST ()

void	alignMT ()

void	alignOne (PndLmdSensorAligner &aligner)

void	resetMTLB (int n, int r, int w)

void	incrementMTLB ()

void	checkIOpaths ()

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

Static Private Member Functions
static void	readPairsFromChainMT (std::vector< std::string > files, std::map< int, PndLmdSensorAligner > &aligners, PndLmdAlignManager &manager)

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

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

Private Attributes
int	_i

int	_r

int	_w

int	_n

int	_verboseLevel

std::stringstream	_info

std::map< int, PndLmdSensorAligner >	aligners

std::map< int, bool >	alignersFull

bool	_allFilesAdded

bool	allAlignersDone

std::vector< std::string >	fileNames

bool	_singleAligner

bool	_inCentimeters

bool	_enableHelperMatrix

bool	_zIsTimestamp

bool	startAlignerWhenFull

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 34 of file PndLmdAlignManager.h.

Member Typedef Documentation

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

private

Definition at line 36 of file PndLmdAlignManager.h.

Constructor & Destructor Documentation

PndLmdAlignManager::PndLmdAlignManager ( )

Definition at line 96 of file PndLmdAlignManager.cxx.

References init().

                                        {
         init();
 }

PndLmdAlignManager::~PndLmdAlignManager ( )

virtual

Definition at line 141 of file PndLmdAlignManager.cxx.

141 {

142 }

Member Function Documentation

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

Definition at line 214 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 225 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 )

Definition at line 166 of file PndLmdAlignManager.cxx.

References aligners, alignersFull, alignerThreadGroup, alignOne(), allAlignersDone, PndLmdHitPair::check(), PndLmdHitPair::getOverlapId(), PndLmdHitPair::isSane(), and mrfdata_8b_error::success.

Referenced by readFilesAndAlign().

                                                                    {
 
         bool success = false;
 
         // 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[pair.getOverlapId()]) {
                 return false;
         }
 
         pair.check();
         if (pair.isSane()) {
                 success = aligners[pair.getOverlapId()].addSimplePair(pair);  //returns true if addPair succeeded
                 alignersFull[pair.getOverlapId()] = !success;           //if addPair failed, the aligner is full
         }
         else {
                 cout << "pair is not sane. processing failed.\n";
         }
 
         //if pair could not be added, aligner is full. start thread directly.
         if (!success) {
                 alignerThreadGroup.create_thread(
                     boost::bind(&PndLmdAlignManager::alignOne, this, boost::ref(aligners[pair.getOverlapId()])));
         }
 
         //check if all aligners are done
         allAlignersDone = true;
         for (map<int, bool>::iterator it = alignersFull.begin(); it != alignersFull.end(); it++) {
                 if (!(it->second)) {
                         allAlignersDone = false;
                         break;
                 }
         }
         if (allAlignersDone) {
                 cout << "all aligners are already full. no further files will be read.\n";
         }
 
         return success;
 }

void PndLmdAlignManager::alignAllSensors ( )

Definition at line 477 of file PndLmdAlignManager.cxx.

References _enableHelperMatrix, _inCentimeters, _info, _matrixOutDir, _multithreaded, alignMT(), alignST(), and checkIOpaths().

Referenced by runLumiPixel2fMatrixFinder().

                                          {
 
         if (!_inCentimeters && _enableHelperMatrix) {
                 _enableHelperMatrix = false;
                 cerr << "WARNING! You can't use rotation correction in pixel ICP mode!\n";
         }
 
         checkIOpaths();
         cout << "starting aligners...\n";
 
         if (_multithreaded) {
                 alignMT();
         }
         else {
                 alignST();
         }
 
         //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";
 }

void PndLmdAlignManager::alignMT ( )

private

Definition at line 405 of file PndLmdAlignManager.cxx.

References _inCentimeters, _info, _matrixOutDir, _verboseLevel, aligners, alignOne(), i, makeMatrixFileName(), resetMTLB(), WorkerThread(), and writeMatrix().

Referenced by alignAllSensors().

                                  {
 
         //new version, multi threaded using thread pool model and boost::asio implementation
 
         //shared pointer, since io_services can't be copied
         boost::shared_ptr<boost::asio::io_service> io_service(new boost::asio::io_service);
         boost::shared_ptr<boost::asio::io_service::work> work(new boost::asio::io_service::work(*io_service));
 
         //thread group
         boost::thread_group worker_threads;
 
         //make threads, n is number of threads:
         int nThreads;
         nThreads = boost::thread::hardware_concurrency();
 
         //sometimes hardware_concurrency returns 0 if it can't detect.
         if (nThreads < 1) {
                 cout << "INFO:: could not detect number of cores. assuming 4.\n";
                 nThreads = 4;
         }
 
         //create worker threads
         if (_verboseLevel >= 3) cout << "creating threads... ";
         for (int i = 0; i < nThreads; i++) {
                 worker_threads.create_thread(boost::bind(&WorkerThread, io_service));
                 if (_verboseLevel >= 3) cout << "[" << i << "] ";
         }
         if (_verboseLevel >= 3) cout << "done.\nposting work...\n";
 
         resetMTLB(aligners.size(), aligners.size(), 60);
 
         //post work for threads
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
 
                 /*
                  * when binding member classes, boost::bind needs the namespace AND the pointer to an object
                  * of that class (here: this-pointer). Also, when using references, use boost::ref()
                  */
                 if (_verboseLevel >= 3) cout << "posting work for aligner " << it->second.getOverlapId() << "... ";
                 io_service->post(boost::bind(&PndLmdAlignManager::alignOne, this, boost::ref(it->second)));
                 if (_verboseLevel >= 3) cout << "done.\n";
 
         }
 
         //wait for all threads to complete, then and only then write matrices to disk
         if (_verboseLevel >= 3) cout << "waiting for all threads to complete.\n";
         work.reset();
         worker_threads.join_all();
         if (_verboseLevel >= 3) cout << "all threads done. getting info.\n";
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                 if (it->second.successful()) {
                         if (_verboseLevel >= 3) cout << "gtting matrix from " << it->second.getOverlapId() << "\n";
                         Matrix result = it->second.getResultMatrix();
                         string matrixFilename = _matrixOutDir
                             + makeMatrixFileName(it->second.getOverlapId(), _inCentimeters);
 
                         if (!writeMatrix(result, matrixFilename)) {
                                 cout << "ERROR: could not write matrix " << matrixFilename << "\n";
                         }
 
                         _info << "aligner " << it->second.getOverlapId() << ":\n";
                         _info << "no of pairs: " << it->second.getNoOfPairs() << "\n";
                         _info << "\n";
 
                         if (_verboseLevel >= 3) cout << _info.str() << "\n";
                 }
                 else {
                         cout << "Error: aligner for " << it->second.getOverlapId() << " failed.\n";
                 }
         }
 }

void PndLmdAlignManager::alignOne ( PndLmdSensorAligner & aligner )

private

Definition at line 354 of file PndLmdAlignManager.cxx.

References _binaryPairFileDirectory, PndLmdSensorAligner::calculateMatrix(), checkForBinaryFiles(), PndLmdSensorAligner::clearPairs(), incrementMTLB(), and PndLmdSensorAligner::writePairsToBinary().

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

                                                               {
 
         //start aligner, this can be done concurrently
         aligner.calculateMatrix();
 
         //write binary file only if not already present
         if (!checkForBinaryFiles()) {
                 aligner.writePairsToBinary(_binaryPairFileDirectory);
         }
         //if binary files already present, then they have been read earlier and we can display a progress bar for the aliners
         else {
                 incrementMTLB();
         }
 
         //free memory
         aligner.clearPairs();
 }

void PndLmdAlignManager::alignST ( )

private

Definition at line 376 of file PndLmdAlignManager.cxx.

References _inCentimeters, _info, _matrixOutDir, aligners, loadBar(), makeMatrixFileName(), verbosePrint(), and writeMatrix().

Referenced by alignAllSensors().

                                  {
 
         int cur, tot;
         cur = 0;
         tot = aligners.size();
         verbosePrint("aligning single threaded.\n");
 
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                 loadBar(cur++, tot, 1000, 60);
                 verbosePrint("calculating matrix.\n");
                 it->second.calculateMatrix();
                 if (it->second.successful()) {
                         verbosePrint("success. getting matrix.\n");
                         Matrix result = it->second.getResultMatrix();
                         string matrixFilename = _matrixOutDir
                             + makeMatrixFileName(it->second.getOverlapId(), _inCentimeters);
                         writeMatrix(result, matrixFilename);
 
                         _info << "aligner " << it->second.getOverlapId() << ":\n";
                         _info << "no of pairs: " << it->second.getNoOfPairs() << "\n";
                         _info << "\n";
 
                 }
                 else {
                         cout << "Error: aligner for " << it->second.getOverlapId() << " failed.\n";
                 }
         }
 }

Matrix PndLmdAlignManager::castTGeoHMatrixToMatrix ( const TGeoHMatrix & matrix )

static

Definition at line 833 of file PndLmdAlignManager.cxx.

                                                                             {
 
         //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] = homogenousMatrix[15];
         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 903 of file PndLmdAlignManager.cxx.

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

Referenced by alignOne(), PndLmdAlignQA::histogramPairDistances(), and runLumiPixel2fMatrixFinder().

                                              {
 
         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 937 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
                                 //cout << "file: " << files[j] << ", id: " << availableIds[i] << "\n";
                                 tempfilefound = true;
                                 foundFiles++;
                         }
                 }
 
                 //file not found? then at least one is missing, return false
                 if (!tempfilefound) {
                         return tempfilefound;
                 }
         }
         //cout << "found " << foundFiles << "\n";
         return true;
 }

void PndLmdAlignManager::checkIOpaths ( )

private

Definition at line 605 of file PndLmdAlignManager.cxx.

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

Referenced by alignAllSensors(), and 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 1578 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 1396 of file PndLmdAlignManager.cxx.

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

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

static

Definition at line 761 of file PndLmdAlignManager.cxx.

Referenced by PndLmdPairFinderTask::Init().

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

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

static

Definition at line 770 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::incrementMTLB ( )

private

Definition at line 56 of file PndLmdAlignManager.cxx.

References _i, _n, _r, _w, c, incrementMutex, printf(), and x.

Referenced by alignOne().

                                        {
 
         incrementMutex.lock();
         _i++;
 
         // 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("] %d of %d \n\033[F\033[J", _i, _n);
         incrementMutex.unlock();
 }

void PndLmdAlignManager::init ( )

Definition at line 100 of file PndLmdAlignManager.cxx.

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

Referenced by PndLmdAlignQA::histogramPairDistances(), and PndLmdAlignManager().

                               {
 
         _info << "info for aligned areas\n";
 
         _zIsTimestamp = true;
         _allFilesAdded = false;
         _singleAligner = true;
         _inCentimeters = false;
         _enableHelperMatrix = false;
         _multithreaded = true;
 
         _verboseLevel = 0;
 
         //int overlapId=-1;
         fileNames.clear();
         aligners.clear();
 
         //FIXME: remove
         //helper = &PndLmdGeometryHelper::getInstance();
 
         overlapIDs = PndLmdGeometryHelper::getAvailableOverlapIDs();
         for (size_t i = 0; i < overlapIDs.size(); i++) {
                 int overlapId = overlapIDs[i];
 
                 PndLmdSensorAligner tempAligner;
                 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 = `""`
	)

static

Definition at line 568 of file PndLmdAlignManager.cxx.

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

Referenced by alignST(), readFilesAndAlign(), readPairsFromBinaryFiles(), and writePairsToBinaryFiles().

                                                                               {
 
         // 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 977 of file PndLmdAlignManager.cxx.

References filename.

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

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

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

staticprivate

Definition at line 996 of file PndLmdAlignManager.cxx.

Referenced by alignMT(), alignST(), checkForLmdMatrixFiles(), PndLmdAlignQA::checkForMatrixFiles(), PndLmdAlignQA::plotCMvsPXmatrices(), PndLmdAlignQA::plotMatrixresiduals(), PndLmdAlignQA::plotPXvsCMmatricesResiduals(), and waitForCompletion().

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

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

static

Definition at line 753 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 1540 of file PndLmdAlignManager.cxx.

References is.

Referenced by PndLmdPairFinderTask::Init().

                                                                              {
 
         //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;
 }

std::stringstream * PndLmdAlignManager::readFile ( std::string filename )

static

Definition at line 634 of file PndLmdAlignManager.cxx.

References filename.

Referenced by readFromCSVFile(), and PndLmdAlignQA::readMatrixInfo().

                                                                 {
 
         int lines = 0;
         stringstream *valueStream = new stringstream();
 
         ifstream ifs;
         ifs.open(filename.c_str());
         if (!ifs.is_open()) {
                 cout << "could not read ";
                 cout << filename;
                 cout << "! aborting." << "\n";
                 return NULL;
         }
         string linebuffer;      // = new string();
         while (std::getline(ifs, linebuffer)) {
                 *valueStream << linebuffer << "\n";
                 lines++;
         }
         ifs.close();
 
         return valueStream;
 }

void PndLmdAlignManager::readFilesAndAlign ( )

Definition at line 299 of file PndLmdAlignManager.cxx.

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

Referenced by runLumiPixel2fMatrixFinder().

                                            {
 
         _allFilesAdded = true;
 
         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);
                         totalPairs++;
                         if (allAlignersDone) {
                                 return;
                         }
                 }
         }
 
         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 708 of file PndLmdAlignManager.cxx.

References i, and readFile().

Referenced by readMatrix().

                                                                               {
         stringstream *ss;
         stringstream iss;
         int i = 0;
         ss = readFile(filename);
         string line, token;
         std::vector<std::vector<double> > data;
         while (getline(*ss, line)) {
                 iss << line;
                 std::vector<double> tempvec;
                 while (getline(iss, token, ',')) {
                         tempvec.push_back(boost::lexical_cast<double>(token));
                 }
                 data.push_back(tempvec);
                 ++i;
                 iss.clear();
         }
         ss->str("");
         delete ss;
         iss.str("");
         return data;
 }

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

static

Definition at line 657 of file PndLmdAlignManager.cxx.

References exit(), i, readFromCSVFile(), and Matrix::val.

Referenced by PndLmdAlignQA::plotCMvsPXmatrices(), PndLmdAlignQA::plotMatrixresiduals(), and PndLmdAlignQA::plotPXvsCMmatricesResiduals().

                                                         {
 
         vector<vector<double> > temp = readFromCSVFile(filename);
 
         if (temp.size() < 1) {
                 cout << "warning! can't read matrix from file " << filename << "\n";
                 exit(1);
         }
         if (temp[0].size() < 1) {
                 cout << "warning! can't read matrix from file " << filename << "\n";
                 exit(1);
         }
 
         int rows, columns;
         rows = temp.size();
         columns = temp[0].size();
         Matrix result(rows, columns);
 
         for (int i = 0; i < rows; i++) {
                 for (int j = 0; j < columns; j++) {
                         result.val[i][j] = temp[i][j];
                 }
         }
 
         return result;
 }

bool PndLmdAlignManager::readPairsFromBinaryFiles ( )

Definition at line 1506 of file PndLmdAlignManager.cxx.

References _binaryPairFileDirectory, aligners, loadBar(), and mrfdata_8b_error::success.

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

                                                   {
 
         bool success = false;
 
         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\n";
 
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                 loadBar(cur++, tot, 1000, 60);
                 if (!it->second.readPairsFromBinary(_binaryPairFileDirectory)) {
                         success = false;
                 }
                 else {
                         success = true;
                 }
         }
         return success;
 }

static void PndLmdAlignManager::readPairsFromChainMT	(	std::vector< std::string >	files,
		std::map< int, PndLmdSensorAligner > &	aligners,
		PndLmdAlignManager &	manager
	)

staticprivate

void PndLmdAlignManager::resetMTLB	(	int	n,
		int	r,
		int	w
	)

private

Definition at line 49 of file PndLmdAlignManager.cxx.

References _i, _n, _r, _w, n, and r.

Referenced by alignMT().

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

static

Definition at line 797 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) {
                 if (boost::filesystem::is_directory(iterator->path())) {
                         list.push_back(iterator->path().string());
 
                         //recursively call for sub directories
                         if (includeSubDirs) {
                                 searchDirectories(iterator->path().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 731 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) {
                 if (boost::filesystem::is_directory(iterator->path()) && includeSubDirs) {
                         list.push_back(iterator->path().string());
                         searchFiles(iterator->path().string(), list, detail, includeSubDirs);
                 }
                 else if (boost::filesystem::is_regular_file(iterator->path())) {
                         if (iterator->path().string().find(detail) != std::string::npos) {
                                 list.push_back(iterator->path().string());
                         }
                 }
         }
         sort(list.begin(), list.end());
         return list.size();
 }

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

inline

Definition at line 202 of file PndLmdAlignManager.h.

References _binaryPairFileDirectory.

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

                                                                                   {
                 _binaryPairFileDirectory = binaryPairFileDirectory;
         }

void PndLmdAlignManager::setInCentimeters ( bool inCentimeters )

Definition at line 819 of file PndLmdAlignManager.cxx.

References _inCentimeters, and aligners.

Referenced by PndLmdAlignQA::checkCombinedMatrices(), PndLmdAlignQA::checkCyclicMatrices(), PndLmdAlignQA::histogramPairDistances(), PndLmdAlignQA::plotMatrixresiduals(), and runLumiPixel2fMatrixFinder().

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

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

inline

Definition at line 178 of file PndLmdAlignManager.h.

References _matrixOutDir.

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

                                                      {
                 _matrixOutDir = matrixOutDir;
         }

void PndLmdAlignManager::setMaxPairs ( int maxPairs )

Definition at line 1381 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::setOutFilename ( const std::string & filename )

inline

Definition at line 152 of file PndLmdAlignManager.h.

References checkIOpaths(), filename, and outFilename.

                                                        {
                 outFilename = filename;
                 checkIOpaths();
         }

void PndLmdAlignManager::setSingleAligner ( bool singleAligner )

inline

Definition at line 148 of file PndLmdAlignManager.h.

References _singleAligner.

                                                   {
                 _singleAligner = singleAligner;
         }

void PndLmdAlignManager::setStartAlignerWhenFull ( bool value )

inline

Definition at line 206 of file PndLmdAlignManager.h.

References startAlignerWhenFull.

                                                  {
                 startAlignerWhenFull = value;
         }

void PndLmdAlignManager::setZasTimestamp ( bool timestamp )

Definition at line 826 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 206 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 210 of file PndLmdAlignManager.h.

References _verboseLevel, a, aligners, 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 1534 of file PndLmdAlignManager.cxx.

References _verboseLevel.

Referenced by alignST().

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

void PndLmdAlignManager::waitForCompletion ( )

Definition at line 1400 of file PndLmdAlignManager.cxx.

References _inCentimeters, _info, _matrixOutDir, aligners, alignersFull, alignerThreadGroup, alignOne(), makeMatrixFileName(), and writeMatrix().

Referenced by runLumiPixel2fMatrixFinder().

                                            {
 
         //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 (map<int, bool>::iterator it = alignersFull.begin(); it != alignersFull.end(); it++) {
                 if (!(it->second)) {
 
                         //cout << "starting aligner " << it->first << "\n";
                         //if pair could not be added, aligner is full. start thread directly.
                         alignerThreadGroup.create_thread(
                             boost::bind(&PndLmdAlignManager::alignOne, this, boost::ref(aligners[it->first])));
                         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();
         cout << "done!\n";
 
         for (mapIt it = aligners.begin(); it != aligners.end(); it++) {
                 if (it->second.successful()) {
 
                         Matrix result = it->second.getResultMatrix();
                         string matrixFilename = _matrixOutDir
                             + makeMatrixFileName(it->second.getOverlapId(), _inCentimeters);
 
                         if (!writeMatrix(result, matrixFilename)) {
                                 cout << "ERROR: could not write matrix " << matrixFilename << "\n";
                         }
 
                         _info << "aligner " << it->second.getOverlapId() << ":\n";
                         _info << "no of pairs: " << it->second.getNoOfPairs() << "\n";
                         _info << "\n";
                 }
                 else {
                         cout << "Error: aligner for " << it->second.getOverlapId() << " 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";
 }

void PndLmdAlignManager::workerThread ( boost::shared_ptr< boost::asio::io_service > io_service )

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

static

Definition at line 1558 of file PndLmdAlignManager.cxx.

Referenced by PndLmdPairFinderTask::FinishTask().

                           {
 
         //replace logic
 
         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 685 of file PndLmdAlignManager.cxx.

Referenced by alignMT(), alignST(), and 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 1481 of file PndLmdAlignManager.cxx.

References _binaryPairFileDirectory, aligners, 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;
 }