#include <PndLmdSensorAligner.h>

Public Member Functions
	PndLmdSensorAligner ()

	PndLmdSensorAligner (const PndLmdSensorAligner &other)

virtual	~PndLmdSensorAligner ()

void	init ()

bool	addSimplePair (const PndLmdHitPair &pair)

bool	writePairsToBinary (const std::string directory)

bool	readPairsFromBinary (const std::string directory)

void	setMaximumNumberOfHitPairs (Int_t maxPairs)

Matrix	transformToLmdLocal ()

Matrix	transformToSensorOne ()

bool	check ()

void	clearPairs ()

void	setForceInstant (Bool_t instant)

void	setModuleID (Int_t ID)

int	getModuleID ()

int	getNoOfPairs ()

void	applyDynamicCut (double percent=5.0)

void	calculateMatrix ()

int	getOverlapId () const

void	setOverlapId (Int_t overlapId)

const Matrix &	getResultMatrix () const

void	setInCentimeters (bool value)

bool	successful ()

void	setZasTimetamp (bool value)

void	verboseLevel (int level)

void	setManager (PndLmdAlignManager *manager)

unsigned int	getDim () const

void	setDim (unsigned int value)

Private Member Functions
void	printPairSpread (int what=0)

void	transformPair (Matrix &trafoMatrix, std::vector< double > &pair)

std::vector< double >	getPairSpread (int what=0)

bool	zeroValCheck ()

Private Attributes
bool	forceInstant

bool	debug

unsigned int	maxNoOfPairs

unsigned int	numberOfPairs

unsigned int	lastNoOfPairs

unsigned int	dim

std::string	inputFilename

int	_moduleID

int	overlapID

unsigned int	nonSanePairs

unsigned int	skippedPairs

unsigned int	swappedPairs

unsigned int	verbose

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

bool	inCentimeters

bool	success

bool	zIsTimestamp

PndLmdAlignManager *	superManager

Matrix	resultMatrix

Friends
class	PndLmdAlignQA

class	PndLmdAlignManager

Detailed Description

Definition at line 28 of file PndLmdSensorAligner.h.

Constructor & Destructor Documentation

PndLmdSensorAligner::PndLmdSensorAligner ( )

Definition at line 47 of file PndLmdSensorAligner.cxx.

References init().

                                          {
         init();
 }

PndLmdSensorAligner::PndLmdSensorAligner ( const PndLmdSensorAligner & other )

Definition at line 55 of file PndLmdSensorAligner.cxx.

References init().

                                                                    {
         std::cerr
             << "PndLmdSensorAligner::Warning! Unnecessary copy-construction. These aligners should never be copied.\n";
         init();
 }

PndLmdSensorAligner::~PndLmdSensorAligner ( )

virtual

Definition at line 51 of file PndLmdSensorAligner.cxx.

                                           {
         //destroy everything. leave nothing standing.
 }

Member Function Documentation

bool PndLmdSensorAligner::addSimplePair ( const PndLmdHitPair & pair )

Definition at line 364 of file PndLmdSensorAligner.cxx.

References PndLmdHitPair::getCol1(), PndLmdHitPair::getCol2(), PndLmdHitPair::getDistance(), PndLmdHitPair::getHit1(), PndLmdHitPair::getHit2(), PndLmdHitPair::getRow1(), PndLmdHitPair::getRow2(), inCentimeters, maxNoOfPairs, and simplePairs.

Referenced by BOOST_AUTO_TEST_CASE().

                                                                  {
 
         if (simplePairs.size() >= maxNoOfPairs && maxNoOfPairs > 0) {
                 return false;
         }
 
         /*
          * add pair as follows:
          * vector<double> pair;
          *
          * [0]: oneX
          * [1]: oneY
          * [2]: oneZ
          * [3]: twoX
          * [4]: twoY
          * [5]: twoZ
          * [6]: distance
          */
 
         if (inCentimeters) {
                 vector<double> tempPair;
 
                 tempPair.push_back(pair.getHit1().x());
                 tempPair.push_back(pair.getHit1().y());
                 tempPair.push_back(pair.getHit1().z());
 
                 tempPair.push_back(pair.getHit2().x());
                 tempPair.push_back(pair.getHit2().y());
                 tempPair.push_back(pair.getHit2().z());
 
                 tempPair.push_back(pair.getDistance());
 
                 simplePairs.push_back(tempPair);
         }
         else {
                 vector<double> tempPair;
 
                 tempPair.push_back(pair.getCol1());
                 tempPair.push_back(pair.getRow1());
                 tempPair.push_back(simplePairs.size());
 
                 tempPair.push_back(pair.getCol2());
                 tempPair.push_back(pair.getRow2());
                 tempPair.push_back(simplePairs.size());
 
                 tempPair.push_back(pair.getDistance());
 
                 simplePairs.push_back(tempPair);
         }
         return true;
 }

void PndLmdSensorAligner::applyDynamicCut ( double percent = 5.0 )

Definition at line 114 of file PndLmdSensorAligner.cxx.

References a, b, and simplePairs.

Referenced by PndLmdAlignManager::runSensorAligner().

                                                         {
 
         if (simplePairs[0].size() < 7) {
                 cerr << "WARNING. Can't apply dynamic cut because distance information is not stored.\n";
                 cerr << "Did you read an old version of the binary pair files?\n";
                 return;
         }
 
         //sort pairs by distance, which is the 7th entry of the inner vector
   //std::sort(simplePairs.begin(), simplePairs.end(),
   //  [](const std::vector< double >& a, const std::vector< double >& b) {return a[6] < b[6];});
 
         //  sort by xy-distance, ignore z distance
         std::sort(simplePairs.begin(), simplePairs.end(),
                         [](const std::vector< double >& a, const std::vector< double >& b) {return
                                         (a[0]*a[0] + a[1]*a[1]) < (b[0]*b[0] + b[1]*b[1]) ;});
 
         int quantileMargin = simplePairs.size() * (percent/100);  // cut from back
 
         vector<vector<double> >::const_iterator first = simplePairs.begin();// + quantileMargin;        // KEEP smallest distances
         vector<vector<double> >::const_iterator last = simplePairs.end() - quantileMargin;
         vector<vector<double> > newSimplePairs(first, last);            // this creates a copy
 
         //overwrite simple pairs vector with new, reduced vector
         simplePairs = newSimplePairs;
 
         //remove possible bias from sorting
         std::random_shuffle(simplePairs.begin(), simplePairs.end());
 }

void PndLmdSensorAligner::calculateMatrix ( )

Definition at line 144 of file PndLmdSensorAligner.cxx.

References dim, Matrix::eye(), Icp::fit(), forceInstant, Icp::forceInstantResult(), Matrix::getData(), Icp::getInterations(), Icp::hasConverged(), lastNoOfPairs, maxNoOfPairs, numberOfPairs, overlapID, resultMatrix, Matrix::setVal(), simplePairs, skippedPairs, success, verbose, zeroValCheck(), and zIsTimestamp.

Referenced by BOOST_AUTO_TEST_CASE(), and PndLmdAlignManager::runSensorAligner().

                                           {
 
         unsigned int nPairs;
 
         nPairs = simplePairs.size();
 
         if (skippedPairs > 0) {
                 cout << "=====================================================\n";
                 cout << "WARNING! Invalid pairs in pair file, check your data!\n";
                 cout << "=====================================================\n";
         }
 
         //TODO: set from Manager or parameter file!
         bool eventTimeCheck = true;
         double minDelta = 1e-6;
         zIsTimestamp = true;
 
         // only allow max Pairs!
         if (nPairs > maxNoOfPairs && maxNoOfPairs > 0) {
                 nPairs = maxNoOfPairs;
         }
 
         //number of pairs used in this run can not change anymore
         lastNoOfPairs = nPairs;
 
         //check if nPairs > 0
         if (nPairs < 50) {
                 cerr << "PndLmdSensrAligner::Error: Trying to use less than 50 pairs!\n";
                 cerr << "(And that's not going to work.) Aborting.\n";
                 success = false;
                 return;
         }
 
         //check for zero values, largely not needed anymore, but keep it for now
         zeroValCheck();
 
         double* Model = new double[dim * nPairs];
         double* Template = new double[dim * nPairs];
 
         if (verbose == 3) {
                 cout << "arranging pairs...\n";
                 cout << "num pairs from bin: " << numberOfPairs << "\n";
                 cout << "num pairs from vec: " << simplePairs.size() << "\n";
                 cout << "num pairs from dec: " << nPairs << "\n";
         }
 
         if (dim == 2) {
                 for (unsigned int ipair = 0; ipair < nPairs; ipair++) {
                         Model[ipair * dim + 0] = simplePairs[ipair][0];
                         Model[ipair * dim + 1] = simplePairs[ipair][1];
                         Template[ipair * dim + 0] = simplePairs[ipair][3];
                         Template[ipair * dim + 1] = simplePairs[ipair][4];
                 }
         }
 
         else if (dim == 3) {
                 for (unsigned int ipair = 0; ipair < nPairs; ipair++) {
                         Model[ipair * dim + 0] = simplePairs[ipair][0];
                         Model[ipair * dim + 1] = simplePairs[ipair][1];
                         Model[ipair * dim + 2] = simplePairs[ipair][2];
                         Template[ipair * dim + 0] = simplePairs[ipair][3];
                         Template[ipair * dim + 1] = simplePairs[ipair][4];
                         Template[ipair * dim + 2] = simplePairs[ipair][5];
                 }
         }
 
         if (verbose == 3) {
                 cout << "creating ICP...\n";
         }
 
         // start with identity as initial transformation
         Matrix Rotation;
         Matrix translation;
 
         //perform ICP and store quality parameters
         //attention! dim * nPairs must equal size of model!
         IcpPointToPoint icp(Model, nPairs, dim);
 
         if (verbose == 3) cout << "ICP and model created...\n";
 
         //prepare Matrices
         if (dim == 2) {
                 Rotation = Matrix::eye(2);
                 translation = Matrix(2, 1);
         }
         else if (dim == 3) {
                 Rotation = Matrix::eye(3);
                 translation = Matrix(3, 1);
         }
 
         icp.forceInstantResult(forceInstant);
         icp.fit(Template, nPairs, Rotation, translation, -1);
 
         if (verbose == 3) cout << "ICP fit step done.\n";
 
         if (dim == 2) {
 
                 //make 4x4 matrix
                 double* tempR = new double[4];
                 double* tempT = new double[2];
 
                 Rotation.getData(tempR);
                 translation.getData(tempT);
 
                 double* finalMatrix = new double[16];
 
                 //okay, this is the version that FIRST rotates, THEN translates.
                 finalMatrix[0] = tempR[0];
                 finalMatrix[1] = tempR[1];
                 finalMatrix[2] = 0;
                 finalMatrix[3] = tempT[0];
                 finalMatrix[4] = tempR[2];
                 finalMatrix[5] = tempR[3];
                 finalMatrix[6] = 0;
                 finalMatrix[7] = tempT[1];
                 finalMatrix[8] = 0;
                 finalMatrix[9] = 0;
                 finalMatrix[10] = 1.0;
                 finalMatrix[11] = 0;
                 finalMatrix[12] = 0;
                 finalMatrix[13] = 0;
                 finalMatrix[14] = 0;
                 finalMatrix[15] = 1.0;
                 resultMatrix = Matrix(4, 4);
 
                 //save matrix!
                 resultMatrix.setVal(4, 4, finalMatrix);
 
                 delete tempR;
                 delete tempT;
                 delete finalMatrix;
 
         }
         else if (dim == 3) {
 
                 //make 4x4 matrix
                 double* tempR = new double[9];
                 double* tempT = new double[3];
 
                 Rotation.getData(tempR);
                 translation.getData(tempT);
 
                 double* finalMatrix = new double[16];
 
                 //TODO: check if this still works when we return TGeoHMatrix objects
                 //okay, this is the version that FIRST rotates, THEN translates.
                 finalMatrix[0] = tempR[0];
                 finalMatrix[1] = tempR[1];
                 finalMatrix[2] = tempR[2];
                 finalMatrix[3] = tempT[0];
                 finalMatrix[4] = tempR[3];
                 finalMatrix[5] = tempR[4];
                 finalMatrix[6] = tempR[5];
                 finalMatrix[7] = tempT[1];
                 finalMatrix[8] = tempR[6];
                 finalMatrix[9] = tempR[7];
                 finalMatrix[10] = tempR[8];
                 finalMatrix[11] = tempT[2];
                 finalMatrix[12] = 0;
                 finalMatrix[13] = 0;
                 finalMatrix[14] = 0;
                 finalMatrix[15] = 1;
 
                 resultMatrix = Matrix(4, 4);
 
                 //save matrix!
                 resultMatrix.setVal(4, 4, finalMatrix);
 
                 delete tempR;
                 delete tempT;
                 delete finalMatrix;
         }
 
         std::stringstream alignlog;
 
         if (icp.hasConverged()) {
                 if (verbose == 3) cout << "ICP convergence ok.\n";
                 success = true;
 
                 //and say a few words for the log
                 alignlog << "\n";
                 alignlog << "====================================================\n";
                 alignlog << "icp converged for overlapID " << overlapID << " in " << icp.getInterations()
                     << " iterations.\n";
 
                 alignlog << "pairs available: " << nPairs;
                 if (nPairs < 100000) {
                         alignlog << " (WARNING! This is not enough for accurate alignment!)\n";
                 }
                 else {
                         alignlog << "\n";
                 }
                 alignlog << "minDelta: " << minDelta << "\n";
 
                 alignlog << "EventTimeCheck: ";
                 eventTimeCheck ? alignlog << "on (and passed)\n" : alignlog << "off\n";
 
                 alignlog << "Force Instant: ";
                 forceInstant ? alignlog << "on\n" : alignlog << "off\n";
 
                 alignlog << "====================================================\n";
         }
         else {
                 alignlog << "\n";
                 alignlog << "====================================================\n";
                 alignlog << "CRITICAL ERROR:\n";
                 alignlog << "no convergence for overlapID " << overlapID << "." << "\n";
                 alignlog << "====================================================\n";
                 alignlog << "\n";
                 if (verbose == 3) cout << "ICP did not converge!\n";
                 success = false;
         }
         if (verbose == 3) cout << alignlog.str();
 
         delete[] Model;
         delete[] Template;
 
         return;
 }

bool PndLmdSensorAligner::check ( )

Definition at line 642 of file PndLmdSensorAligner.cxx.

References overlapID, and simplePairs.

Referenced by PndLmdAlignManager::runSensorAligner().

                                 {
 
         //check for number of pairs
         if (simplePairs.size() < 50) {
                 cerr << "PndLmdSensorAligner::check: ERROR! Aligner " << overlapID
                     << "doesn't have enough pairs! Aborting.\n";
                 return false;
         }
 
         //check if pair array is strictly rectangular
         unsigned int dimy = simplePairs[0].size();
         for (auto &pair : simplePairs) {
                 if (pair.size() != dimy) {
                         return false;
                 }
         }
 
         //check... I don't know, something.
         return true;
 
 }

void PndLmdSensorAligner::clearPairs ( )

Definition at line 634 of file PndLmdSensorAligner.cxx.

References lastNoOfPairs, and simplePairs.

Referenced by PndLmdAlignManager::runSensorAligner().

                                      {
         lastNoOfPairs = simplePairs.size();
         //call destructors of the member objects (well, they're doubles, so... yeah.)
         simplePairs.clear();
         //force release of allocated memory by vectors
         vector<vector<double> >().swap(simplePairs);
 }

unsigned int PndLmdSensorAligner::getDim ( ) const

inline

Definition at line 149 of file PndLmdSensorAligner.h.

References dim.

                                     {
                 return dim;
         }

int PndLmdSensorAligner::getModuleID ( )

inline

Definition at line 97 of file PndLmdSensorAligner.h.

References _moduleID.

                           {
                 return _moduleID;
         }

int PndLmdSensorAligner::getNoOfPairs ( )

inline

Definition at line 100 of file PndLmdSensorAligner.h.

References lastNoOfPairs.

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

int PndLmdSensorAligner::getOverlapId ( ) const

inline

Definition at line 116 of file PndLmdSensorAligner.h.

References overlapID.

                                  {
                 return overlapID;
         }

std::vector< double > PndLmdSensorAligner::getPairSpread ( int what = 0 )

private

Definition at line 664 of file PndLmdSensorAligner.cxx.

References i, max(), min(), simplePairs, xmax, and xmin.

Referenced by printPairSpread().

                                                              {
 
         double xcom, ycom, zcom, xspread, yspread, zspread, xmin, xmax, ymin, ymax, zmin, zmax, avgDist;
         unsigned int nPairs = 0;
         nPairs = simplePairs.size();
 
         xcom = ycom = zcom = xspread = yspread = zspread = xmin = xmax = ymin = ymax = zmin = zmax = avgDist =
             0.0;
 
         // set all values to first entry
         if (what == 0 || what == 1) {
                 xcom += simplePairs[0][0];
                 ycom += simplePairs[0][1];
                 zcom += simplePairs[0][2];
 
                 xmin = simplePairs[0][0];
                 xmax = simplePairs[0][0];
                 ymin = simplePairs[0][1];
                 ymax = simplePairs[0][1];
                 zmin = simplePairs[0][2];
                 zmax = simplePairs[0][2];
         }
 
         if (what == 0 || what == 2) {
                 xcom += simplePairs[0][3];
                 ycom += simplePairs[0][4];
                 zcom += simplePairs[0][5];
 
                 xmin = simplePairs[0][3];
                 xmax = simplePairs[0][3];
                 ymin = simplePairs[0][4];
                 ymax = simplePairs[0][4];
                 zmin = simplePairs[0][5];
                 zmax = simplePairs[0][5];
         }
 
         avgDist = simplePairs[0][6];
 
         // collect center of mass and spread in all coordinates
         for (unsigned int i = 1; i < simplePairs.size(); i++) {
                 auto &pair = simplePairs[i];
 
                 if (what == 0 || what == 1) {
                         xcom += pair[0];
                         ycom += pair[1];
                         zcom += pair[2];
 
                         xmin = std::min(xmin, pair[0]);
                         xmax = std::max(xmax, pair[0]);
                         ymin = std::min(ymin, pair[1]);
                         ymax = std::max(ymax, pair[1]);
                         zmin = std::min(zmin, pair[2]);
                         zmax = std::max(zmax, pair[2]);
                 }
 
                 if (what == 0 || what == 2) {
                         xcom += pair[3];
                         ycom += pair[4];
                         zcom += pair[5];
 
                         xmin = std::min(xmin, pair[3]);
                         xmax = std::max(xmax, pair[3]);
                         ymin = std::min(ymin, pair[4]);
                         ymax = std::max(ymax, pair[4]);
                         zmin = std::min(zmin, pair[5]);
                         zmax = std::max(zmax, pair[5]);
                 }
 
                 avgDist += pair[6];
         }
 
         // calculate center of mass and spread
         if (what == 1 || what == 2) {
                 xcom /= nPairs;
                 ycom /= nPairs;
                 zcom /= nPairs;
 
                 avgDist /= nPairs;
         }
         else if (what == 0) {
                 xcom /= 2.0 * nPairs;
                 ycom /= 2.0 * nPairs;
                 zcom /= 2.0 * nPairs;
 
                 avgDist /= 2.0 * nPairs;
         }
 
         xspread = std::abs(xmax - xmin);
         yspread = std::abs(ymax - ymin);
         zspread = std::abs(zmax - zmin);
 
         std::vector<double> spread;
 
         spread.push_back(xcom);
         spread.push_back(ycom);
         spread.push_back(zcom);
 
         spread.push_back(xspread);
         spread.push_back(yspread);
         spread.push_back(zspread);
 
         spread.push_back(avgDist);
 
         return spread;
 
 }

const Matrix& PndLmdSensorAligner::getResultMatrix ( ) const

inline

Definition at line 124 of file PndLmdSensorAligner.h.

References resultMatrix.

Referenced by BOOST_AUTO_TEST_CASE().

                                               {
                 return resultMatrix;
         }

void PndLmdSensorAligner::init ( )

Definition at line 30 of file PndLmdSensorAligner.cxx.

References _moduleID, debug, dim, forceInstant, inCentimeters, maxNoOfPairs, nonSanePairs, numberOfPairs, overlapID, skippedPairs, success, swappedPairs, verbose, and zIsTimestamp.

Referenced by PndLmdSensorAligner().

                                {
         maxNoOfPairs = 0;
         numberOfPairs = 0;
         forceInstant = true;
         _moduleID = -1;
         nonSanePairs = 0;
         skippedPairs = 0;
         swappedPairs = 0;
         verbose = 0;
         overlapID = -1;
         inCentimeters = true;
         success = false;
         zIsTimestamp = true;
         debug = false;
         dim = 2;
 }

void PndLmdSensorAligner::printPairSpread ( int what = 0 )

private

Definition at line 771 of file PndLmdSensorAligner.cxx.

References getPairSpread().

                                                   {
 
         auto spread = getPairSpread(what);
 
         cout << "x com: " << spread[0] << "\n";
         cout << "y com: " << spread[1] << "\n";
         cout << "z com: " << spread[2] << "\n";
 
         cout << "x spread: " << spread[3] << "\n";
         cout << "y spread: " << spread[4] << "\n";
         cout << "z spread: " << spread[5] << "\n";
 
         cout << "avg Dist: " << spread[6] << "\n";
 }

bool PndLmdSensorAligner::readPairsFromBinary ( const std::string directory )

Definition at line 486 of file PndLmdSensorAligner.cxx.

References directory, exit(), filename, inCentimeters, is, PndLmdAlignManager::makeBinaryPairFileName(), numberOfPairs, overlapID, simplePairs, and verbose.

Referenced by PndLmdAlignManager::readPairsFromBinaryFilesAndAlign().

                                                                        {
 
         string filename;                                //binary pair file
         //size_t length;                                //number of raw doubles, remember pairs have 6 doubles
         double* pdata;                                  //array with pairs
         size_t filesize;
         size_t doublesize = sizeof(double);
         unsigned int nPairs;
         unsigned int doublesPerPair;
         unsigned int noOfDoubles = 0;
 
         /*
          * read goes as follows:
          *
          * first, check file size.
          * file size is larger than one double (headersize is stored there)? -> read header only! else return false;
          * read header and interpret data from header.
          * is nPairs*doublesPerPair*sizeof(double) + headersize*sizeof(double) (header) == filezise?
          * is nPairs in header == headersize * sizeof(double) (filesize - header)
          * if so, file seems okay, read header + file. else return false;
          * when entire file is read, copy data without header to arrays for ICP  *
          */
 
         filename = directory;
         filename += PndLmdAlignManager::makeBinaryPairFileName(overlapID, inCentimeters);
 
         //check if file exists and file size
         std::fstream inStream(filename.c_str(), std::ios::binary | std::ios::in | std::ios::ate);
         if (inStream) {
                 std::fstream::pos_type size = inStream.tellg();
                 filesize = size;
         }
         else {
                 cout << filename.c_str() << " could not be read!\n";
                 return false;
         }
 
         double* headersizeD = new double[1];
         //read header size
         if (filesize >= sizeof(double)) {
                 //read header
                 std::ifstream is(filename.c_str(), std::ios::binary | std::ios::in);
                 if (!is.is_open()) return false;
                 is.read(reinterpret_cast<char*>(headersizeD), std::streamsize(sizeof(double)));
                 is.close();
         }
 
         int headersize;
         if (headersizeD[0] < 6) {
                 //cout << "headersize is " << headersizeD[0] << ", seems to be old format. using 6 for now.";
                 headersize = 6;
         }
         else {
                 headersize = headersizeD[0];
         }
 
         //read header
         if (filesize >= headersize * sizeof(double)) {
                 double* header = new double[headersize];
 
                 //read header
                 std::ifstream is(filename.c_str(), std::ios::binary | std::ios::in);
                 if (!is.is_open()) return false;
                 is.read(reinterpret_cast<char*>(header), std::streamsize(headersize * sizeof(double)));
                 is.close();
 
                 //check header
                 if (verbose == 3) {
                         cout << "header size: " << header[0] << "\n";
                         cout << "doubles / pair: " << header[1] << "\n";
                         cout << "no of pairs: " << header[2] << "\n";
                 }
 
                 //check header
                 doublesPerPair = header[1];
                 nPairs = std::round(header[2]);
                 numberOfPairs = nPairs;
                 noOfDoubles = nPairs * doublesPerPair + headersize;
                 size_t filesizeMust = sizeof(double) * (noOfDoubles);
 
                 if (doublesize != header[3]) {
                         cout
                             << "warning! sizeof(double) on this system is different than on the system that made this binary!\n";
                         //TODO: decide what to do in this case
                         exit(1);
                         doublesize = header[3];
                         return false;
                 }
 
                 if (overlapID != header[4]) {
                         cout << "error! file name and overlapID do not match! did you rename the file?\n";
                 }
 
                 if (filesizeMust != filesize) {
                         cout << "file is corrupt!\n";
                         return false;
                 }
 
                 //free allocated space!
                 delete[] header;
 
         }
         else {
                 cout << filename.c_str() << " is too small, file corrupt!\n";
                 return false;
         }
 
         //allocate double array for entire file
         pdata = new double[noOfDoubles];
 
         //actually read file
         std::ifstream is(filename.c_str(), std::ios::binary | std::ios::in);
         if (!is.is_open()) return false;
         is.read(reinterpret_cast<char*>(pdata), std::streamsize(noOfDoubles * sizeof(double)));
         is.close();
         // the entire file is now in memory. it's only about 30 MB, so this is okay
 
         //save data
         unsigned int currentIndex = headersize;                         //data starts here
         //bool error = false;
 
         for (unsigned int iPair = 0; iPair < nPairs; iPair++) {
 
                 vector<double> tempPair;
                 //assign pair data
                 for (unsigned int jPairIndex = 0; jPairIndex < doublesPerPair; jPairIndex++) {
                         double currentVal = pdata[currentIndex + jPairIndex];
                         //cout << "current val is: " << currentVal << "\n";
                         tempPair.push_back(currentVal);
                 }
                 simplePairs.push_back(tempPair);
 
                 //get next index, every pair has doublesPerPair doubles
                 currentIndex += doublesPerPair;
         }
 
         //check size one last time
         if (nPairs != simplePairs.size()) {
                 cerr << "Warning! Error while reading binary pair file!\n";
                 return false;
         }
 
         //delete array!
         delete[] pdata;
 
         return true;
 }

void PndLmdSensorAligner::setDim ( unsigned int value )

inline

Definition at line 153 of file PndLmdSensorAligner.h.

                                         {
                 dim = value;
         }

void PndLmdSensorAligner::setForceInstant ( Bool_t instant )

inline

Definition at line 90 of file PndLmdSensorAligner.h.

                                              {
                 forceInstant = instant;
         }

void PndLmdSensorAligner::setInCentimeters ( bool value )

inline

Definition at line 129 of file PndLmdSensorAligner.h.

Referenced by PndLmdAlignManager::init().

                                           {
                 inCentimeters = value;
         }

void PndLmdSensorAligner::setManager ( PndLmdAlignManager * manager )

inline

Definition at line 145 of file PndLmdSensorAligner.h.

Referenced by PndLmdAlignManager::init().

                                                      {
                 superManager = manager;
         }

void PndLmdSensorAligner::setMaximumNumberOfHitPairs ( Int_t maxPairs )

inline

Definition at line 75 of file PndLmdSensorAligner.h.

                                                         {
                 if (maxPairs > 0) {
                         maxNoOfPairs = maxPairs;
                         simplePairs.reserve(maxPairs);
                 }
         }

void PndLmdSensorAligner::setModuleID ( Int_t ID )

inline

Definition at line 94 of file PndLmdSensorAligner.h.

                                    {
                 _moduleID = ID;
         }

void PndLmdSensorAligner::setOverlapId ( Int_t overlapId )

inline

Definition at line 120 of file PndLmdSensorAligner.h.

Referenced by PndLmdAlignManager::init().

                                            {
                 overlapID = overlapId;
         }

void PndLmdSensorAligner::setZasTimetamp ( bool value )

inline

Definition at line 137 of file PndLmdSensorAligner.h.

Referenced by PndLmdAlignManager::init().

                                         {
                 zIsTimestamp = value;
         }

bool PndLmdSensorAligner::successful ( )

inline

Definition at line 133 of file PndLmdSensorAligner.h.

References success.

                           {
                 return success;
         }

void PndLmdSensorAligner::transformPair	(	Matrix &	trafoMatrix,
		std::vector< double > &	pair
	)

private

Definition at line 834 of file PndLmdSensorAligner.cxx.

References Matrix::m, Matrix::n, and Matrix::val.

Referenced by transformToLmdLocal(), and transformToSensorOne().

                                                                                     {
 
         if (trafoMatrix.m != 4 || trafoMatrix.n != 4 || pair.size() < 6) {
                 std::cerr << "ERROR. Matrix is not 4x4 or pair has less than 6 entries\n";
                 return;
         }
 
         Matrix pairVal1(4, 1);
         Matrix pairVal2(4, 1);
 
         pairVal1.val[0][0] = pair[0];
         pairVal1.val[1][0] = pair[1];
         pairVal1.val[2][0] = pair[2];
         pairVal1.val[3][0] = 1.0;
 
         pairVal2.val[0][0] = pair[3];
         pairVal2.val[1][0] = pair[4];
         pairVal2.val[2][0] = pair[5];
         pairVal2.val[3][0] = 1.0;
 
         pairVal1 = trafoMatrix * pairVal1;
         pairVal2 = trafoMatrix * pairVal2;
 
         // don't forget to de-homogenize
         pair[0] = pairVal1.val[0][0] / pairVal1.val[3][0];
         pair[1] = pairVal1.val[1][0] / pairVal1.val[3][0];
         pair[2] = pairVal1.val[2][0] / pairVal1.val[3][0];
 
         pair[3] = pairVal2.val[0][0] / pairVal2.val[3][0];
         pair[4] = pairVal2.val[1][0] / pairVal2.val[3][0];
         pair[5] = pairVal2.val[2][0] / pairVal2.val[3][0];
 
 }

Matrix PndLmdSensorAligner::transformToLmdLocal ( )

Definition at line 812 of file PndLmdSensorAligner.cxx.

References PndLmdAlignManager::castTGeoHMatrixToMatrix(), Matrix::eye(), PndLmdAlignManager::geometryHelperMutex, PndLmdGeometryHelper::getInstance(), PndLmdGeometryHelper::getMatrixPndGlobalToLmdLocal(), helper, Matrix::inv(), simplePairs, superManager, and transformPair().

                                                 {
 
         Matrix toLMD = Matrix::eye(4);
 
         // maybe this helps with thread safety
         superManager->geometryHelperMutex.lock();
 
         PndLmdGeometryHelper *helper = &PndLmdGeometryHelper::getInstance();
         TGeoHMatrix matrix = helper->getMatrixPndGlobalToLmdLocal();
         toLMD = superManager->castTGeoHMatrixToMatrix(matrix);
 
         // maybe this helps with thread safety
         superManager->geometryHelperMutex.unlock();
 
         // it appears we have to make an actrive trafo from a passive one
         toLMD.inv();
         for (auto &pair : simplePairs) {
                 transformPair(toLMD, pair);
         }
         return toLMD;
 }

Matrix PndLmdSensorAligner::transformToSensorOne ( )

Definition at line 786 of file PndLmdSensorAligner.cxx.

References PndLmdAlignManager::castTGeoHMatrixToMatrix(), Matrix::eye(), PndLmdAlignManager::geometryHelperMutex, PndLmdGeometryHelper::getInstance(), PndLmdGeometryHelper::getMatrixPndGlobalToSensor(), PndLmdGeometryHelper::getSensorOneFromOverlapID(), helper, Matrix::inv(), overlapID, simplePairs, superManager, and transformPair().

Referenced by PndLmdAlignManager::runSensorAligner().

                                                  {
 
         Matrix toLMD = Matrix::eye(4);
 
         // maybe this helps with thread safety | should be in geometryHelper now!
         superManager->geometryHelperMutex.lock();
 
         PndLmdGeometryHelper *helper = &PndLmdGeometryHelper::getInstance();
         int id1 = helper->getSensorOneFromOverlapID(overlapID);
         TGeoHMatrix matrix = helper->getMatrixPndGlobalToSensor(id1);
 
         // maybe this helps with thread safety | should be in geometryHelper now!
         superManager->geometryHelperMutex.unlock();
 
         toLMD = superManager->castTGeoHMatrixToMatrix(matrix);
 
         // it appears we have to make an actrive trafo from a passive one
         toLMD.inv();
 
         for (auto &pair : simplePairs) {
                 transformPair(toLMD, pair);
         }
 
         return toLMD;
 }

void PndLmdSensorAligner::verboseLevel ( int level )

inline

Definition at line 141 of file PndLmdSensorAligner.h.

                                      {
                 verbose = level;
         }

bool PndLmdSensorAligner::writePairsToBinary ( const std::string directory )

Definition at line 416 of file PndLmdSensorAligner.cxx.

References directory, filename, i, inCentimeters, PndLmdAlignManager::makeBinaryPairFileName(), PndLmdAlignManager::mkdir(), out, overlapID, and simplePairs.

Referenced by PndLmdAlignManager::runSensorAligner().

                                                                       {
 
         string filename;                                        //target directory
         double* pdata;                                          //array with pairs
 
         unsigned int nPairs = simplePairs.size();
         if (nPairs == 0) {
                 cout << "warning: attempting to write empty binary pair file! (no pairs in buffer for overlapID "
                     << overlapID << ")\n";
                 return false;
         }
 
         int doublesPerPair = simplePairs[0].size();             //well, doubles per Pair, this is determined by addPair()
 
         size_t length = nPairs * doublesPerPair + 6;    //number of raw doubles (including header), remember pairs have 6 doubles
 
         filename = directory;
         filename += PndLmdAlignManager::makeBinaryPairFileName(overlapID, inCentimeters);
 
         //construct header
         unsigned int headersize = 6;                                            //header size in number of doubles
 
         double* header = new double[headersize];
         header[0] = headersize;                                                         //header size in double fields
         header[1] = doublesPerPair;             //doubles per pair
         header[2] = nPairs;                                             //nPairs, read the correct vector!
         header[3] = sizeof(double);  //sizeof(double), check when reading files! might be different on other OSes.
         header[4] = overlapID;                          //overlapID
         header[5] = 2.1;                                                                //version, cant read older versions
 
         pdata = new double[length];
 
         //save header
         for (unsigned int i = 0; i < headersize; i++) {
                 pdata[i] = header[i];
         }
         //save data
         unsigned int currentIndex = headersize;                         //data starts here
 
         //iterate over all pairs
         for (unsigned int iPair = 0; iPair < nPairs; iPair++) {
 
                 //iterate over all entries of the pair
                 for (unsigned int jPairIndex = 0; jPairIndex < simplePairs[0].size(); jPairIndex++) {
                         pdata[currentIndex + jPairIndex] = simplePairs[iPair][jPairIndex];
                 }
                 currentIndex += doublesPerPair;
         }
 
         /*
          * the write part is easy, just dump everything. read part is more difficult,
          * need to check file first
          */
 
         //TODO: abstract this to Manager!
         //create directory if not already present
         PndLmdAlignManager::mkdir(directory);
         std::ofstream os(filename.c_str(), std::ios::binary | std::ios::out);
         if (!os.is_open()) {
                 cout << "ERROR! Could not write to " << filename << "!\n";
                 return false;
         }
 
         os.write(reinterpret_cast<const char*>(pdata), std::streamsize(length * sizeof(double)));
         os.close();
         delete[] pdata;
         delete[] header;
         return true;
 }

bool PndLmdSensorAligner::zeroValCheck ( )

private

Definition at line 61 of file PndLmdSensorAligner.cxx.

References overlapID, simplePairs, and verbose.

Referenced by calculateMatrix().

                                        {
 
         int zeroVals = 0;
         int modxinv = 0, modyinv = 0, modzinv = 0;
         int temxinv = 0, temyinv = 0, temzinv = 0;
 
         unsigned int nPairs = simplePairs.size();
 
         if (verbose == 3) cout << "checking for zero values...\n";
 
         for (auto &pair : simplePairs) {
                 std::abs(pair[0]) < 1e-15 ? modxinv++ : modxinv;
                 std::abs(pair[1]) < 1e-15 ? modyinv++ : modxinv;
                 std::abs(pair[2]) < 1e-15 ? modzinv++ : modxinv;
                 std::abs(pair[3]) < 1e-15 ? temxinv++ : modxinv;
                 std::abs(pair[4]) < 1e-15 ? temyinv++ : modxinv;
                 std::abs(pair[5]) < 1e-15 ? temzinv++ : modxinv;
         }
 
         zeroVals = modxinv + modyinv + modzinv + temxinv + temyinv + temzinv;
 
         // 3 dimension and 2 arrays = 6
         double zeroFactor = zeroVals / ((double) nPairs * 6.0);
         if (zeroFactor > 0.15 && zeroFactor <= 0.3) {
                 cout << "WARNING. More than 15 % of your entries is zero. That must be a mistake. \n";
                 cout << "Also, the kdtree creation could crash. Keep an eye out for that...\n";
                 cout << "Zero factor: " << zeroFactor << "\n";
                 cout << "model x vals invalid: " << modxinv / (double) nPairs << "\n";
                 cout << "model y vals invalid: " << modyinv / (double) nPairs << "\n";
                 cout << "model z vals invalid: " << modzinv / (double) nPairs << "\n";
                 cout << "templ x vals invalid: " << temxinv / (double) nPairs << "\n";
                 cout << "templ y vals invalid: " << temyinv / (double) nPairs << "\n";
                 cout << "templ z vals invalid: " << temzinv / (double) nPairs << "\n";
 
         }
         if (zeroFactor > 0.3) {
                 cout << "ERROR. More than 30 % of your entries is zero. That must be a mistake. \n";
                 cout << "Also, the kdtree creation will probably crash. Exiting.\n";
                 cout << "Zero factor: " << zeroFactor << "\n";
                 cout << "model x vals invalid: " << modxinv / (double) nPairs << "\n";
                 cout << "model y vals invalid: " << modyinv / (double) nPairs << "\n";
                 cout << "model z vals invalid: " << modzinv / (double) nPairs << "\n";
                 cout << "templ x vals invalid: " << temxinv / (double) nPairs << "\n";
                 cout << "templ y vals invalid: " << temyinv / (double) nPairs << "\n";
                 cout << "templ z vals invalid: " << temzinv / (double) nPairs << "\n";
                 cout << "=== additional data ===\n";
                 cout << "overlap id: " << overlapID << "\n";
                 cout << "no of Pairs: " << nPairs << "\n";
                 return false;
         }
         return true;
 }