FairRoot/PandaRoot
PndLmdAlignQA.cxx
Go to the documentation of this file.
1 /*
2  * PndLmdAlignQA.cxx
3  *
4  * Created on: Jul 6, 2015
5  * Author: Roman Klasen, roklasen@uni-mainz.de or klasen@kph.uni-mainz.de
6  */
7 
8 #include <PndLmdAlignQA.h>
9 
10 #include <boost/filesystem.hpp>
11 
12 #include <fstream>
13 #include <iomanip>
14 #include <iostream>
15 #include <math.h>
16 #include <sstream>
17 #include <string>
18 #include <vector>
19 
20 #include <TCanvas.h>
21 #include <TH1D.h>
22 #include <TGraph.h>
23 #include <TChain.h>
24 #include <TClonesArray.h>
25 #include <TFile.h>
26 #include <TGeoManager.h>
27 
28 using std::make_pair;
29 using std::string;
30 using std::vector;
31 
32 PndLmdAlignQA::PndLmdAlignQA() {
33  init();
34 }
35 
36 PndLmdAlignQA::~PndLmdAlignQA() {
37 
38 }
39 
40 void PndLmdAlignQA::init() {
41  infoMomentum = -1;
42  infoAbsolute = false;
43  infoRelative = false;
44  byPlane = false;
45  _inCentimeters = false;
46 
47  helper = &PndLmdGeometryHelper::getInstance();
48 }
49 
50 void PndLmdAlignQA::calculateOverlapingAreas() {
51 
52  //get all available overlapping areas
53 
54  cout << "------------ TESTING --------------\n";
55  cout << "\\AtoB{4}{9} & " << calculateOverlappingArea(4, 9, false) << "\n";
56  cout << "\\AtoB{0}{1} & " << calculateOverlappingArea(0, 1, false) << "\n";
57  cout << "\\AtoB{0}{2} & " << calculateOverlappingArea(0, 2, false) << "\n";
58  cout << "\\AtoB{0}{9} & " << calculateOverlappingArea(0, 9, false) << "\n";
59  cout << "------------ DONE --------------\n";
60 
61  vector<int> overlapIDs = helper->getAvailableOverlapIDs();
62  int id1=0, id2=0; //[R.K. 9/2018] id1 & id2 were not initialised
63  double areaPercent = 0;
64 
65  //get id1 and id2 from them and calc
66  for (unsigned int i = 0; i < overlapIDs.size(); i++) {
67  //id1 = helper->getID1fromOverlapID(overlapIDs[i]);
68  //id2 = helper->getID2fromOverlapID(overlapIDs[i]);
69 
70  areaPercent = calculateOverlappingArea(id1, id2, false); //[R.K. 9/2018] id1 & id2 were not initialised
71  cout << "\\AtoB{" << id1 << "}{" << id2 << "} & " << areaPercent << "\n";
72  }
73  exit(0);
74 
75 }
76 
77 void PndLmdAlignQA::plotCMvsPXmatrices() {
78 
79  //data holds sets of entries. order is (id1, id2, alpha, dx, dy
80  std::vector<std::vector<double> > data;
81  readMatrixInfo();
82 
83  //iterate over all available id pairs and store them to vector of std::pairs
84  vector<std::pair<int, int>> idPairs;
85  for (int i = 0; i < 400; i += 10) {
86  idPairs.push_back(make_pair(0 + i, 5 + i));
87  idPairs.push_back(make_pair(1 + i, 8 + i));
88  idPairs.push_back(make_pair(2 + i, 8 + i));
89  idPairs.push_back(make_pair(2 + i, 9 + i));
90  idPairs.push_back(make_pair(3 + i, 6 + i));
91  idPairs.push_back(make_pair(3 + i, 7 + i));
92  idPairs.push_back(make_pair(3 + i, 8 + i));
93  idPairs.push_back(make_pair(4 + i, 7 + i));
94  idPairs.push_back(make_pair(4 + i, 9 + i));
95  }
96  //should now contain all available id pairs
97 
98  string pdfdir = pdfOutPath;
99 
100  for (size_t i = 0; i < idPairs.size(); i++) {
101 
102  int id1 = idPairs[i].first;
103  int id2 = idPairs[i].second;
104 
105  //only select overlap areas with more than 2e5 pairs
106  int overlapID = helper->getOverlapIdFromSensorIDs(id1, id2);
107  if (matrixInfo[overlapID] < pairsRequired) {
108  continue;
109  }
110 
111  //prepare
112  string matrixNameCM = manager.makeMatrixFileName(overlapID, true);
113  string matrixNamePX = manager.makeMatrixFileName(overlapID, false);
114  string path = LMDMatPath;
115  matrixNameCM = path + matrixNameCM;
116  matrixNamePX = path + matrixNamePX;
117 
118  //read matrices from disk
119  Matrix matrixCM = manager.readMatrix(matrixNameCM);
120  Matrix matrixPX = manager.readMatrix(matrixNamePX);
121  Matrix matrixDif;
122 
123  if (false) { //transform both to lmd local and compare there
124  //transform matrixPX to lmd local
125  //manager.transformFromSensorToLmdLocal(matrixPX, id1);
126 // Matrix senToSen = manager.getMatrixSensorToSensor(id1, id2);
127 // Matrix senToSenWithCorr = matrixCM * senToSen; //this is now the total matrix from sen1 to sen2
128 // matrixDif = senToSenWithCorr - matrixPX;
129  } else { //transform noth to sensor and compare there
130  //transform matrixPX to lmd local
131  //manager.transformFromSensorToLmdLocal(matrixPX, id1);
132  //Matrix senToSen = manager.getMatrixOfficialGeometry(overlapID, true);
133  //Matrix senToSenWithCorr = matrixCM * senToSen; //this is now the total matrix from sen1 to sen2
134 
135  //manager.transformFromLmdLocalToSensor(senToSenWithCorr, id1);
136 
137  //matrixDif = senToSenWithCorr - matrixPX;
138  }
139 
140  //store this residual tuple to data
141  std::vector<double> result;
142  result.push_back(id1);
143  result.push_back(id2);
144  result.push_back(matrixDif.val[0][1]); // sin(alpha)
145  result.push_back(matrixDif.val[0][3]); // tx
146  result.push_back(matrixDif.val[1][3]); // ty
147  data.push_back(result);
148  }
149 
150  histParams parameters;
151 
152  //for DX
153  parameters.path = pdfdir + "/PXvsCM/";
154  parameters.title = "matrixCM*matrixTarget - matrixPX(transformed), #DeltaX)";
155  parameters.xtitle = "dX [nm]";
156  parameters.ytitle = "entries";
157  parameters.scaleFactor = 1e4 * 1e3;
158  parameters.fileName = "dx.pdf";
159  parameters.vectorIndex = 3;
160  parameters.xMin = -1;
161  parameters.xMax = -1;
162  parameters.printCMPXinPathName = false;
163  createHist(data, parameters);
164 
165  //for DY
166  //parameters.path = pdfdir;
167  parameters.title = "matrixCM*matrixTarget - matrixPX(transformed), #DeltaY)";
168  parameters.xtitle = "dY [nm]";
169  parameters.ytitle = "entries";
170  parameters.scaleFactor = 1e4 * 1e3;
171  parameters.fileName = "dy.pdf";
172  parameters.vectorIndex = 4;
173  parameters.xMin = -1;
174  parameters.xMax = -1;
175  parameters.printCMPXinPathName = false;
176  createHist(data, parameters);
177 
178  //for DAlpha
179  //parameters.path = pdfdir;
180  parameters.title = "matrixCM*matrixTarget - matrixPX(transformed), #Delta#alpha";
181  parameters.xtitle = "d#alpha [nrad]";
182  parameters.ytitle = "entries";
183  parameters.scaleFactor = 1e9;
184  parameters.fileName = "dalpha.pdf";
185  parameters.vectorIndex = 2;
186  parameters.xMin = -1;
187  parameters.xMax = -1;
188  parameters.printCMPXinPathName = false;
189  createHist(data, parameters);
190 
191 }
192 
193 void PndLmdAlignQA::calculatePixelDistancesFrontToBack() {
194  histPixelDistances(0, 5);
195  histPixelDistances(1, 8);
196  histPixelDistances(2, 8);
197  histPixelDistances(2, 9);
198  histPixelDistances(3, 6);
199  histPixelDistances(3, 7);
200  histPixelDistances(3, 8);
201  histPixelDistances(4, 7);
202  histPixelDistances(4, 9);
203 }
204 
205 void PndLmdAlignQA::checkCombinedMatrices(bool inCentimeters) {
206 
207  if (inCentimeters) {
208  _inCentimeters = true;
209  manager.setInCentimeters(_inCentimeters);
210  } else {
211  _inCentimeters = false;
212  manager.setInCentimeters(_inCentimeters);
213  }
214 
215  //data holds sets of entries. order is (id1, id2, alpha, dx, dy
216  std::vector<std::vector<double> > data;
217  readMatrixInfo();
218 
219  //prepare
220  string path = LMDMatPath;
221  string pdfdir = pdfOutPath;
222  manager.setMatrixOutDir(path);
223 
224  for (auto id1 = 0; id1 < 400; id1 += 10) {
225 
226  for (auto id2 = id1 + 1; id2 < id1 + 10; id2++) {
227 
228  Matrix matrixDif;
229  if (inCentimeters) {
230  //Matrix mCombined = manager.combineMatrix(id1, id2);
231  //Matrix senToSenOneStep = manager.getMatrixOfficialGeometry(id1, id2);
232  //matrixDif = mCombined - senToSenOneStep;
233  } else {
234  //Matrix mCombined = manager.combineMatrix(id1, id2);
235  //manager.transformFromSensorToLmdLocal(mCombined, id1);
236  //Matrix senToSenOneStep = manager.getMatrixOfficialGeometry(id1, id2);
237  //matrixDif = mCombined - senToSenOneStep;
238  }
239 
240  //store this residual tuple to data
241  std::vector<double> result;
242  result.push_back(id1);
243  result.push_back(id2);
244  result.push_back(matrixDif.val[0][1]); // sin(alpha)
245  result.push_back(matrixDif.val[0][3]); // tx
246  result.push_back(matrixDif.val[1][3]); // ty
247  //result.push_back(matrixPX.val[2][3]); // tz
248  data.push_back(result);
249  }
250  }
251 
252  histParams parameters;
253  parameters.bins = 20;
254 
255  //for DX
256  parameters.path = pdfdir + "/residualsCombined/";
257  inCentimeters ? parameters.title = "matrix combined 0-9 CM - Target, #DeltaX" : parameters.title =
258  "matrix combined 0-9 PX - Target, #DeltaX";
259  parameters.xtitle = "dX [#mum]";
260  parameters.ytitle = "entries";
261  parameters.scaleFactor = 1e4;
262  parameters.fileName = "dx.pdf";
263  parameters.vectorIndex = 3;
264  parameters.xMin = -1;
265  parameters.xMax = -1;
266  parameters.printCMPXinPathName = true;
267  createHist(data, parameters);
268 
269  //for DY
270  //parameters.path = pdfdir;
271  inCentimeters ? parameters.title = "matrix combined 0-9 CM - Target, #DeltaY" : parameters.title =
272  "matrix combined 0-9 PX - Target, #DeltaY";
273  parameters.xtitle = "dY [#mum]";
274  parameters.ytitle = "entries";
275  parameters.scaleFactor = 1e4;
276  parameters.fileName = "dy.pdf";
277  parameters.vectorIndex = 4;
278  parameters.xMin = -1;
279  parameters.xMax = -1;
280  parameters.printCMPXinPathName = true;
281  createHist(data, parameters);
282 
283  //for DAlpha
284  //parameters.path = pdfdir;
285  inCentimeters ?
286  parameters.title = "matrix combined 0-9 CM - Target, #Delta#alpha" : parameters.title =
287  "matrix combined 0-9 PX - Target, #Delta#alpha";
288  parameters.xtitle = "d#alpha [#murad]";
289  parameters.ytitle = "entries";
290  parameters.scaleFactor = 1e6;
291  parameters.fileName = "dalpha.pdf";
292  parameters.vectorIndex = 2;
293  parameters.xMin = -1;
294  parameters.xMax = -1;
295  parameters.printCMPXinPathName = true;
296  createHist(data, parameters);
297 }
298 
299 void PndLmdAlignQA::checkCyclicMatrices(bool inCentimeters) {
300 
301  if (inCentimeters) {
302  _inCentimeters = true;
303  manager.setInCentimeters(_inCentimeters);
304  } else {
305  _inCentimeters = false;
306  manager.setInCentimeters(_inCentimeters);
307  }
308 
309  //data holds sets of entries. order is (id1, id2, alpha, dx, dy
310  std::vector<std::vector<double> > data;
311  readMatrixInfo();
312 
313  //prepare
314  string path = LMDMatPath;
315  string pdfdir = pdfOutPath;
316  manager.setMatrixOutDir(path);
317 
318  Matrix cycle;
319  for (int i = 0; i < 400; i++) {
320 
321  // does not matter if in LMC local or sensor local, should always be identity matrix!
322  //cycle = manager.combineCyclicMatrix(i);
323 
324  //store this residual tuple to data
325  std::vector<double> result;
326  result.push_back(0);
327  result.push_back(0);
328  result.push_back(cycle.val[0][1]); // sin(alpha)
329  result.push_back(cycle.val[0][3]); // tx
330  result.push_back(cycle.val[1][3]); // ty
331  data.push_back(result);
332  }
333 
334  histParams parameters;
335 
336  parameters.bins = 20;
337 
338  //for DX
339  parameters.path = pdfdir + "/cyclicChecks/";
340  inCentimeters ? parameters.title = "matrixCM cycle check, #DeltaX" : parameters.title =
341  "matrixPX cycle check, #DeltaX";
342  parameters.xtitle = "dX [#mum]";
343  parameters.ytitle = "entries";
344  parameters.scaleFactor = 1e4;
345  parameters.fileName = "dx.pdf";
346  parameters.vectorIndex = 3;
347  parameters.xMin = -1;
348  parameters.xMax = -1;
349  parameters.printCMPXinPathName = true;
350  createHist(data, parameters);
351 
352  //for DY
353  //parameters.path = pdfdir;
354  inCentimeters ? parameters.title = "matrixCM cycle check, #DeltaY" : parameters.title =
355  "matrixPX cycle check, #DeltaY";
356  parameters.xtitle = "dY [#mum]";
357  parameters.ytitle = "entries";
358  parameters.scaleFactor = 1e4;
359  parameters.fileName = "dy.pdf";
360  parameters.vectorIndex = 4;
361  parameters.xMin = -1;
362  parameters.xMax = -1;
363  parameters.printCMPXinPathName = true;
364  createHist(data, parameters);
365 
366  //for DAlpha
367  //parameters.path = pdfdir;
368  inCentimeters ? parameters.title = "matrixCM cycle check, #Delta#alpha" : parameters.title =
369  "matrixPX cycle check, #Delta#alpha";
370  parameters.xtitle = "d#alpha [#murad]";
371  parameters.ytitle = "entries";
372  parameters.scaleFactor = 1e6;
373  parameters.fileName = "dalpha.pdf";
374  parameters.vectorIndex = 2;
375  parameters.xMin = -1;
376  parameters.xMax = -1;
377  parameters.printCMPXinPathName = true;
378  createHist(data, parameters);
379 }
380 
381 void PndLmdAlignQA::histPixelDistances(int sensor1, int sensor2, bool /*aligned*/) { //[R.K. 9/2018] unused
382 
383  int sensorID1 = sensor1, sensorID2 = sensor2;
384 //
385 // Matrix PXtoCM = manager.getPixelToCentimeterTransformation();
386 // Matrix CMtoPX = Matrix::inv(PXtoCM);
387  //Matrix sen1ToSen2 = manager.getMatrixOfficialGeometry(sensorID1, sensorID2, aligned);
388  //manager.transformFromLmdLocalToSensor(sen1ToSen2, sensorID1, aligned);
389  //Matrix matSensorOneToSensorTwo = CMtoPX * sen1ToSen2 * PXtoCM;
390 
391  //histogram those distances
392  double colTest2 = 0, rowTest2 = 0;
393 
394  TH1D hist("Pixel Distances", "Pixel Distances", 300, -1, -1);
395 
396  int valid = 0;
397 
398  //for every sensor pair on ONE module (all modules are equal, none are more equal than others)
399 
400  //for every pixel (250*250) find all 4 overlap pixels (cutoff at 100 microns, pixels can't be that far away on perfect geometry)
401  for (int colTest1 = 0; colTest1 < 250; colTest1++) {
402  for (int rowTest1 = 0; rowTest1 < 250; rowTest1++) {
403 
404  //create hit on sensor1 and compute corresponding hit on sensor2
405  //Matrix hit1 = manager.makeFourVector(colTest1, rowTest1, 0);
406  //Matrix hit2 = matSensorOneToSensorTwo * hit1;
407 // colTest2 = hit2.val[0][0];
408 // rowTest2 = hit2.val[1][0];
409 
410  //also, check if overlap pixel even exists. must be row elem [0,250], col elem [0,250]
411  //are we still overlapping area?
412  if (colTest2 < 0 || colTest2 > 247) {
413  continue;
414  }
415  if (rowTest2 < 0 || rowTest2 > 242) {
416  continue;
417  }
418 
419  //count for statistics
420  valid++;
421 
422  //four possible neighbors
423  //double colTest2Floor = floor(colTest2); //[R.K. 9/2018] unused
424  //double colTest2Ceil = ceil(colTest2); //[R.K. 9/2018] unused
425  //double rowTest2Floor = floor(rowTest2); //[R.K. 9/2018] unused
426  //double rowTest2Ceil = ceil(rowTest2); //[R.K. 9/2018] unused
427 
428  //make all possible hit2's:
429  vector<Matrix> hit2Candidates;
430 // hit2Candidates.push_back(manager.makeFourVector(colTest2Floor, rowTest2Floor, -0.025));
431 // hit2Candidates.push_back(manager.makeFourVector(colTest2Ceil, rowTest2Floor, -0.025));
432 // hit2Candidates.push_back(manager.makeFourVector(colTest2Floor, rowTest2Ceil, -0.025));
433 // hit2Candidates.push_back(manager.makeFourVector(colTest2Ceil, rowTest2Ceil, -0.025));
434 
435  //OR use matrices directly. actually, maybe use matrix directly
436 
437  //now, transform everything to cm in sensor coordinate system
438  //hit1 = PXtoCM * hit1;
439 
440  //cout << "=== start ===\n";
441  for (size_t i = 0; i < hit2Candidates.size(); i++) {
442  double distance=0; //[R.K. 9/2018] was not initialised
443  //hit2Candidates[i] = PXtoCM * Matrix::inv(matSensorOneToSensorTwo) * hit2Candidates[i];
444  //distance = (hit1 - hit2Candidates[i]).l2norm() * 1e4; //convert to microns
445 
446  //if(distance > 100){
447  //continue;
448  //}
449  //else{
450  //fill already
451  //cout << "distance: " << distance << "\n";
452  hist.Fill(distance); //[R.K. 9/2018] distance was not initialised
453  //}
454  }
455  }
456  }
457  double coverage = (double) valid / (250.0 * 250.0) * 100;
458  cout << "overlap: " << coverage << "\n";
459 
460  std::stringstream ss;
461  ss << "Pixel Distances Area " << sensorID1 << " to " << sensorID2 << ", " << coverage
462  << "% coverage.";
463  hist.SetTitle(ss.str().c_str());
464  ss.str("");
465  ss << "d [#mum]";
466  hist.GetXaxis()->SetTitle(ss.str().c_str());
467  ss.str("");
468  ss << "Entries";
469  hist.GetYaxis()->SetTitle(ss.str().c_str());
470 
471  std::stringstream filename;
472  filename << pdfOutPath << "/AreaPixelDistances" << sensor1 << "to" << sensor2 << ".pdf";
473  TCanvas canvas;
474  canvas.cd();
475  hist.Draw();
476  canvas.Print(filename.str().c_str());
477 }
478 
479 double PndLmdAlignQA::calculateOverlappingArea(int /*sensor1*/, int /*sensor2*/, bool /*aligned*/) { //[R.K. 9/2018] unused
480 
481  //int sensorID1 = sensor1, sensorID2 = sensor2; //[R.K. 9/2018] unused
482 
483 // Matrix PXtoCM = manager.getPixelToCentimeterTransformation();
484 // Matrix CMtoPX = Matrix::inv(PXtoCM);
485  //Matrix sen1ToSen2 = manager.getMatrixOfficialGeometry(sensorID1, sensorID2, aligned);
486  //manager.transformFromLmdLocalToSensor(sen1ToSen2, sensorID1, aligned);
487  //Matrix matSensorOneToSensorTwo = CMtoPX * sen1ToSen2 * PXtoCM;
488 
489  //Matrix sen2toSen1 = PXtoCM * Matrix::inv(matSensorOneToSensorTwo);
490 
491  //histogram those distances
492  double colTest2 = 0, rowTest2 = 0;
493  int valid = 0;
494 
495  //for every pixel (250*250) find all 4 overlap pixels (cutoff at 100 microns, pixels can't be that far away on perfect geometry)
496  for (int colTest1 = 0; colTest1 < 247; colTest1++) {
497  for (int rowTest1 = 0; rowTest1 < 242; rowTest1++) {
498 
499  //create hit on sensor1 and compute corresponding hit on sensor2
500  //Matrix hit1 = manager.makeFourVector(colTest1, rowTest1, 0);
501  //Matrix hit2 = matSensorOneToSensorTwo * hit1;
502  //colTest2 = hit2.val[0][0];
503  //rowTest2 = hit2.val[1][0];
504 
505  //also, check if overlap pixel even exists. must be row elem [0,250], col elem [0,250]
506  //are we still overlapping area?
507  if (colTest2 < 0 || colTest2 > 247) { //to account for inactive area
508  continue;
509  }
510  if (rowTest2 < 0 || rowTest2 > 242) { //to account for inactive area
511  continue;
512  }
513 
514  //we are still on overlapping area
515  valid++;
516  }
517  }
518  double coverage = (double) valid / (250.0 * 250.0) * 100;
519 
520  return coverage;
521 }
522 
523 void PndLmdAlignQA::readMatrixInfo() {
524 
525  string filename;
526  if (_inCentimeters) {
527  filename = LMDMatPath + "/info-cm.txt";
528  } else {
529  filename = LMDMatPath + "/info-px.txt";
530  }
531 
532  std::stringstream *info = manager.readFile(filename);
533 
534  string line;
535  std::vector<string> values;
536  int overlapid, noPairs;
537  bool alignerComplete = true;
538 
539  while (std::getline(*info, line)) {
540  if (line.find("aligner") != std::string::npos && alignerComplete) {
541  //cout << "found aligner line\n";
542  values = manager.findRegex(line, "aligner (\\d{1,4})");
543  if (values.size() > 1) {
544  overlapid = std::stoi(values[1]);
545  //cout << "aligner: " << overlapid << endl;
546  alignerComplete = false;
547  }
548  } else if (line.find("no of pairs") != std::string::npos) {
549  //cout << "found pairs line\n";
550  values = manager.findRegex(line, "no of pairs. (\\d{1,6})");
551  if (values.size() > 1) {
552  noPairs = std::stoi(values[1]);
553  matrixInfo[overlapid] = noPairs;
554  alignerComplete = true;
555  }
556  }
557  }
558  delete info;
559 }
560 
561 int PndLmdAlignQA::noOfPairs(int overlapID) {
562  return matrixInfo[overlapID];
563 }
564 
565 bool PndLmdAlignQA::checkForMatrixFiles() {
566 
567  //list all IDs that SHOULD be there
568  vector<int> availableIds = helper->getAvailableOverlapIDs();
569 
570  vector<string> files;
571  manager.searchFiles(LMDMatPath, files, "mat", false);
572  int foundFiles = 0;
573 
574  //no matrix files at all!
575  if (files.size() == 0) {
576  return false;
577  }
578 
579  string matrixName;
580  bool tempfilefound = false;
581 
582  //check for every ID that should be there if there is a corresponding file
583  for (size_t i = 0; i < availableIds.size(); i++) {
584 
585  //reset counter
586  tempfilefound = false;
587  matrixName = manager.makeMatrixFileName(availableIds[i], _inCentimeters);
588 
589  for (size_t j = 0; j < files.size(); j++) {
590  if (files[j].find(matrixName) != string::npos) {
591  tempfilefound = true;
592  foundFiles++;
593  }
594  }
595  //file not found? at least one is missing, return false
596  if (!tempfilefound) {
597  return tempfilefound;
598  }
599  }
600  // if no file could not be found, everything is okay
601  return true;
602 }
603 
604 void PndLmdAlignQA::createHist(std::vector<std::vector<double> >& vec, histParams &parameters) {
605 
606  TH1D histogram(parameters.title.c_str(), parameters.title.c_str(), parameters.bins, parameters.xMin,
607  parameters.xMax);
608 
609  histogram.GetXaxis()->SetTitle(parameters.xtitle.c_str());
610  histogram.GetYaxis()->SetTitle(parameters.ytitle.c_str());
611 
612  if (vec.size() == 0) {
613  cout << "Error: nothing read, data empty! (maybe not enough pairs?) \n";
614  exit(1);
615  }
616 
617  //have all data now
618  double dataPoint = 0.0;
619  for (size_t iArea = 0; iArea < vec.size(); iArea++) {
620  dataPoint = vec[iArea][parameters.vectorIndex] * parameters.scaleFactor;
621  histogram.Fill(dataPoint);
622  }
623 
624  std::stringstream pathname;
625  pathname << parameters.path;
626 
627  if (parameters.printCMPXinPathName) {
628  _inCentimeters ? pathname << "/inCm/" : pathname << "/inPx/";
629  }
630 
631  PndLmdAlignManager::mkdir(pathname.str());
632 
633  TCanvas canvas("canvas", "canvas", 800, 600);
634  canvas.cd();
635  histogram.Draw();
636  histogram.Draw("HIST TEXT0 SAME");
637  canvas.Print((pathname.str() + parameters.fileName).c_str());
638 }
639 
640 void PndLmdAlignQA::plotPXvsCMmatricesResiduals() {
641 
642  //data holds sets of entries. order is (id1, id2, alpha, dx, dy
643  std::vector<std::vector<double> > data;
644  readMatrixInfo();
645 
646  //iterate over all available id pairs and store them to vector of std::pairs
647  vector<std::pair<int, int>> idPairs;
648  for (int i = 0; i < 400; i += 10) {
649  idPairs.push_back(make_pair(0 + i, 5 + i));
650  idPairs.push_back(make_pair(1 + i, 8 + i));
651  idPairs.push_back(make_pair(2 + i, 8 + i));
652  idPairs.push_back(make_pair(2 + i, 9 + i));
653  idPairs.push_back(make_pair(3 + i, 6 + i));
654  idPairs.push_back(make_pair(3 + i, 7 + i));
655  idPairs.push_back(make_pair(3 + i, 8 + i));
656  idPairs.push_back(make_pair(4 + i, 7 + i));
657  idPairs.push_back(make_pair(4 + i, 9 + i));
658  }
659  //should now contain all available id pairs
660 
661  //prepare some stuff for aligned/misaligned cases
662  string pdfdir = pdfOutPath;
663 
664  //remember, we want the difference between two residuals
665  // (matrixPX-matrixTarget) - (matrixCM-matrixtarget)
666 
667  // prepare data sets
668  std::vector<std::vector<double> > dataCM;
669  std::vector<std::vector<double> > dataPX;
670 
671  //so, gather all CMresiduals
672  for (size_t i = 0; i < idPairs.size(); i++) {
673 
674  int id1 = idPairs[i].first;
675  int id2 = idPairs[i].second;
676 
677  //only select overlap areas with more than 2e5 pairs
678  int overlapID = helper->getOverlapIdFromSensorIDs(id1, id2);
679  if (matrixInfo[overlapID] < pairsRequired) {
680  continue;
681  }
682 
683  //prepare
684  string matrixNameCM = manager.makeMatrixFileName(overlapID, true);
685  string path = LMDMatPath;
686  matrixNameCM = path + matrixNameCM;
687 
688  //read matrices from disk
689  Matrix matrixCM = manager.readMatrix(matrixNameCM);
690 
691  //the aligned case is special because the correction matrix is the identity
692  Matrix senToSenCorrTarget;
693  if (alignOptionBool) {
694  senToSenCorrTarget = Matrix::eye(4);
695  } else {
696  //senToSenCorrTarget = manager.getCorrectionMatrix(overlapID);
697  }
698 
699  //transform both correction matrices to full sensor to sensor matrices
700  //Matrix senToSenIdeal = manager.getMatrixSensorToSensor(overlapID)
701 
702  //Matrix matrixDif = (matrixCM * senToSenIdeal) - (senToSenCorrTarget * senToSenIdeal);
703 
704  //store this residual tuple to data
705  std::vector<double> resultCM;
706  resultCM.push_back(id1);
707  resultCM.push_back(id2);
708 // resultCM.push_back(matrixDif.val[0][1]); // sin(alpha)
709 // resultCM.push_back(matrixDif.val[0][3]); // tx
710 // resultCM.push_back(matrixDif.val[1][3]); // ty
711  dataCM.push_back(resultCM);
712  }
713 
714  //gather all PX residuals
715  for (size_t i = 0; i < idPairs.size(); i++) {
716 
717  int id1 = idPairs[i].first;
718  int id2 = idPairs[i].second;
719 
720  //only select overlap areas with more than 2e5 pairs
721  int overlapID = helper->getOverlapIdFromSensorIDs(id1, id2);
722  if (matrixInfo[overlapID] < pairsRequired) {
723  continue;
724  }
725 
726  //prepare
727  //Matrix target = manager.getMatrixSensorToSensor(overlapID) //true = aligned, false = misaligned
728  string matrixNamePX = manager.makeMatrixFileName(overlapID, false);
729  string path = LMDMatPath;
730  matrixNamePX = path + matrixNamePX;
731 
732  //read matrices from disk
733  Matrix matrixPX = manager.readMatrix(matrixNamePX);
734  //manager.transformFromSensorToLmdLocal(matrixPX, id1, alignOptionBool); // false = misaligned geometry
735  //Matrix matrixDif = matrixPX - target;
736 
737  //store this residual tuple to data
738  std::vector<double> resultPX;
739 // resultPX.push_back(id1);
740 // resultPX.push_back(id2);
741 // resultPX.push_back(matrixDif.val[0][1]); // sin(alpha)
742 // resultPX.push_back(matrixDif.val[0][3]); // tx
743 // resultPX.push_back(matrixDif.val[1][3]); // ty
744  dataPX.push_back(resultPX);
745  }
746 
747  //we now have two data sets, dataCM and dataPX. combine!
748  if (dataCM.size() != dataPX.size()) {
749  cout << "ERROR. the two data sets are not equally large! exiting!\n";
750  exit(1);
751  }
752 
753  data.reserve(dataCM.size());
754 
755  for (size_t i = 0; i < dataCM.size(); i++) {
756 
757  //check if ids match
758  if ((dataCM[i][0] != dataPX[i][0]) || (dataCM[i][1] != dataPX[i][1])) {
759  cout << "ERROR. vectors are not in the same order!\n";
760  }
761 
762  std::vector<double> interimData;
763  interimData.push_back(dataCM[i][0]);
764  interimData.push_back(dataCM[i][1]);
765  interimData.push_back(dataPX[i][2] - dataCM[i][2]); // sin(alpha)
766  interimData.push_back(dataPX[i][3] - dataCM[i][3]); // tx
767  interimData.push_back(dataPX[i][4] - dataCM[i][4]); // ty
768 
769  data.push_back(interimData);
770  }
771 
772  //plot difference
773  histParams parameters;
774  //parameters.bins=25;
775 
776  //for DX
777  parameters.path = pdfOutPath + "/PXvsCMresiduals/";
778  parameters.title = "PXresiduals - CMresiduals, #DeltaX (0u)";
779  parameters.xtitle = "dX [nm]";
780  parameters.ytitle = "entries";
781  parameters.scaleFactor = 1e7;
782  parameters.fileName = "dx.pdf";
783  parameters.vectorIndex = 3;
784  parameters.xMin = -1;
785  parameters.xMax = -1;
786  parameters.printCMPXinPathName = false;
787  createHist(data, parameters);
788 
789  //for DY
790  //parameters.path = pdfOutPath;
791  parameters.title = "PXresiduals - CMresiduals, #DeltaY (0u)";
792  parameters.xtitle = "dY [nm]";
793  parameters.ytitle = "entries";
794  parameters.scaleFactor = 1e7;
795  parameters.fileName = "dy.pdf";
796  parameters.vectorIndex = 4;
797  parameters.xMin = -1;
798  parameters.xMax = -1;
799  parameters.printCMPXinPathName = false;
800  createHist(data, parameters);
801 
802  //for DAlpha
803  //parameters.path = pdfOutPath;
804  parameters.title = "PXresiduals - CMresiduals, #Delta#alpha (0u)";
805  parameters.xtitle = "d#alpha [#murad]";
806  parameters.ytitle = "entries";
807  parameters.scaleFactor = 1e6;
808  parameters.fileName = "dalpha.pdf";
809  parameters.vectorIndex = 2;
810  parameters.xMin = -1;
811  parameters.xMax = -1;
812  parameters.printCMPXinPathName = false;
813  createHist(data, parameters);
814 
815 }
816 
817 void PndLmdAlignQA::plotMatrixresiduals(bool inCentimeters) {
818 
819  //data holds sets of entries. order is (id1, id2, alpha, dx, dy
820  std::vector<std::vector<double> > data;
821  readMatrixInfo();
822 
823  //iterate over all available id pairs and store them to vector of std::pairs
824  vector<std::pair<int, int>> idPairs;
825  for (int i = 0; i < 400; i += 10) {
826  idPairs.push_back(make_pair(0 + i, 5 + i));
827  idPairs.push_back(make_pair(1 + i, 8 + i));
828  idPairs.push_back(make_pair(2 + i, 8 + i));
829  idPairs.push_back(make_pair(2 + i, 9 + i));
830  idPairs.push_back(make_pair(3 + i, 6 + i));
831  idPairs.push_back(make_pair(3 + i, 7 + i));
832  idPairs.push_back(make_pair(3 + i, 8 + i));
833  idPairs.push_back(make_pair(4 + i, 7 + i));
834  idPairs.push_back(make_pair(4 + i, 9 + i));
835  }
836  //should now contain all available id pairs
837 
838  //prepare global settings
839  string pdfdir = pdfOutPath;
840  _inCentimeters = inCentimeters;
841  manager.setInCentimeters(inCentimeters);
842  Matrix matrixDif;
843 
844  for (size_t i = 0; i < idPairs.size(); i++) {
845 
846  int id1 = idPairs[i].first;
847  int id2 = idPairs[i].second;
848 
849  //only select overlap areas with more than 2e5 pairs
850  int overlapID = helper->getOverlapIdFromSensorIDs(id1, id2);
851  if (matrixInfo[overlapID] < pairsRequired) {
852  continue;
853  }
854 
855  //in CM
856  if (inCentimeters) {
857  //prepare
858  string matrixNameCM = manager.makeMatrixFileName(overlapID, true);
859  string path = LMDMatPath;
860  matrixNameCM = path + matrixNameCM;
861 
862  //read matrices from disk
863  Matrix matrixCM = manager.readMatrix(matrixNameCM);
864 
865  //transform both correction matrices to full sensor to sensor matrices
866  //Matrix senToSenIdeal = manager.getMatrixSensorToSensor(id1, id2);
867 
868  if (false) { //this one uses get Correction Matrix, tested and works
869 
870  Matrix senToSenCorrTarget;
871  if (alignOptionBool) {
872  senToSenCorrTarget = Matrix::eye(4);
873  } else {
874  //senToSenCorrTarget = manager.getCorrectionMatrix(id1, id2);
875  }
876  //matrixDif = (matrixCM * senToSenIdeal) - (senToSenCorrTarget * senToSenIdeal);
877  }
878 
879  else { //this one uses the complete matrix and works as well
880 
881  //Matrix senToSen = manager.getMatrixSensorToSensor(id1, id2);
882 
883  //next try, I think I'm onto it...
884  //manager.transformFromLmdLocalToSensor(senToSenIdeal, id1, true);// THIS IS THE MAGIC BEAN
885  //manager.transformFromSensorToLmdLocal(senToSenIdeal, id1, alignOptionBool);
886 
887  //Matrix ICPcomplete = matrixCM * senToSenIdeal;
888 
889  //matrixDif = ICPcomplete - senToSen;
890  }
891  }
892  // in PX
893  else {
894  //prepare
895  //Matrix target = manager.getMatrixSensorToSensor(overlapID) //true = aligned, false = misaligned
896 
897  string matrixNamePX = manager.makeMatrixFileName(overlapID, false);
898  string path = LMDMatPath;
899  matrixNamePX = path + matrixNamePX;
900 
901  //read matrices from disk
902  Matrix matrixPX = manager.readMatrix(matrixNamePX);
903  //manager.transformFromSensorToLmdLocal(matrixPX, id1, alignOptionBool); // false = misaligned geometry
904 
905  //matrixDif = matrixPX - target;
906  }
907  //store this residual tuple to data
908  std::vector<double> result;
909  result.push_back(id1);
910  result.push_back(id2);
911  result.push_back(matrixDif.val[0][1]); // sin(alpha)
912  result.push_back(matrixDif.val[0][3]); // tx
913  result.push_back(matrixDif.val[1][3]); // ty
914  result.push_back(matrixDif.val[2][3]); // tz
915  data.push_back(result);
916  }
917 
918  histParams parameters;
919 
920  //for DX
921  parameters.path = pdfdir + "/residuals/";
922  if (inCentimeters) {
923  parameters.title = "matrixCM - correctionTarget, #DeltaX";
924  } else {
925  parameters.title = "matrixPX(transformed) - senToSenTarget, #DeltaX";
926  }
927  parameters.xtitle = "dX [#mum]";
928  parameters.ytitle = "entries";
929  parameters.scaleFactor = 1e4;
930  parameters.fileName = "dx.pdf";
931  parameters.vectorIndex = 3;
932  parameters.xMin = -1;
933  parameters.xMax = -1;
934  parameters.printCMPXinPathName = true;
935  createHist(data, parameters);
936 
937  //for DY
938  //parameters.path = pdfdir;
939  if (inCentimeters) {
940  parameters.title = "matrixCM - correctionTarget, #DeltaY";
941  } else {
942  parameters.title = "matrixPX(transformed) - senToSenTarget, #DeltaY";
943  }
944  parameters.xtitle = "dY [#mum]";
945  parameters.ytitle = "entries";
946  parameters.scaleFactor = 1e4;
947  parameters.fileName = "dy.pdf";
948  parameters.vectorIndex = 4;
949  parameters.xMin = -1;
950  parameters.xMax = -1;
951  parameters.printCMPXinPathName = true;
952  createHist(data, parameters);
953 
954  //for DZ
955  //parameters.path = pdfdir;
956  if (inCentimeters) {
957  parameters.title = "#DeltaZ of HitPairs";
958  } else {
959  parameters.title = "#DeltaZ of HitPairs";
960  }
961  parameters.xtitle = "dZ [pair Steps]";
962  parameters.ytitle = "entries";
963  parameters.scaleFactor = 1.0;
964  parameters.fileName = "dz.pdf";
965  parameters.vectorIndex = 5;
966  parameters.xMin = -1;
967  parameters.xMax = -1;
968  parameters.printCMPXinPathName = true;
969  createHist(data, parameters);
970 
971  //for DAlpha
972  //parameters.path = pdfdir;
973  if (inCentimeters) {
974  parameters.title = "matrixCM - correctionTarget, #Delta#alpha";
975  } else {
976  parameters.title = "matrixPX(transformed) - senToSenTarget, #Delta#alpha";
977  }
978  parameters.xtitle = "d#alpha [#murad]";
979  parameters.ytitle = "entries";
980  parameters.scaleFactor = 1e6;
981  parameters.fileName = "dalpha.pdf";
982  parameters.vectorIndex = 2;
983  parameters.xMin = -1;
984  parameters.xMax = -1;
985  parameters.printCMPXinPathName = true;
986  createHist(data, parameters);
987 
988 }
989 
990 void PndLmdAlignQA::histogramPairDistances() {
991 
992  /*FIXME: this is bullshit. it reads all 360 binary pair files, each 28 MB and consumes
993  * 10 GB of RAM while doing mostly nothing.
994  * Change this to o the following:
995  *
996  * create one aligner
997  * have aligner read binary pair file
998  * read pairs and create histogram
999  * save histogram
1000  *
1001  * and this function can me multi-threaded to 4-8 threads.
1002  */
1003 
1004  //data holds sets of entries. order is (id1, id2, alpha, dx, dy
1005  std::vector<std::vector<double> > data;
1006  readMatrixInfo();
1007  string pdfdir = pdfOutPath;
1008 
1009  //reset the manager
1010  manager.init();
1011 
1012  // make manager read binary pair files
1013  manager.setInCentimeters(true);
1014  manager.setBinaryPairFileDirectory(binaryMatPath);
1015 
1016  bool allpresent = manager.checkForBinaryFiles();
1017 
1018  if (!allpresent) {
1019  cout << "Warning: Not all binary pair files are present. Aborting this run.\n";
1020  return;
1021  }
1022 
1023  // for every pair file, read all pairs (CM should suffice)
1024  manager.readPairsFromBinaryFiles();
1025 
1026  double x1, y1, x2, y2, distance;
1027 
1028  // the PairFinders now have all the binary pair loaded, ask them! (they are friends)
1029  for (auto &aligner : manager.aligners) {
1030  PndLmdSensorAligner &thisAligner = aligner.second;
1031  int overlapId = thisAligner.overlapID;
1032  int numberOfPairs = thisAligner.numberOfPairs; //[R.K. 9/2018] shadowed a member
1033 
1034  for (int i = 0; i < numberOfPairs; i++) {
1035  x1 = thisAligner.simpleSensorOneX[i];
1036  y1 = thisAligner.simpleSensorOneY[i];
1037  x2 = thisAligner.simpleSensorTwoX[i];
1038  y2 = thisAligner.simpleSensorTwoY[i];
1039 
1040  distance = std::sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
1041  vector<double> datum;
1042  datum.push_back(distance);
1043  data.push_back(datum);
1044  }
1045 
1046  histParams parameters;
1047 
1048  //for distance
1049  parameters.path = pdfdir + "/distHistograms/";
1050  std::stringstream titless;
1051  titless << "pair distance on area " << overlapId;
1052  parameters.title = titless.str();
1053  parameters.xtitle = "d [#mum]";
1054  parameters.ytitle = "entries";
1055  parameters.scaleFactor = 1e4;
1056  std::stringstream filenamess;
1057  filenamess << overlapId << ".pdf";
1058  parameters.fileName = filenamess.str();
1059  parameters.vectorIndex = 0;
1060  parameters.xMin = -1;
1061  parameters.xMax = -1;
1062  parameters.printCMPXinPathName = false;
1063  createHist(data, parameters);
1064 
1065  // clean up for next round
1066  data.clear();
1067  }
1068 }
1069 
PndLmdAlignQA::infoMomentum
double infoMomentum
Definition: PndLmdAlignQA.h:38
PndLmdSensorAligner::simpleSensorOneX
std::vector< double > simpleSensorOneX
Definition: PndLmdSensorAligner.h:37
PndLmdAlignQA::plotCMvsPXmatrices
void plotCMvsPXmatrices()
Definition: PndLmdAlignQA.cxx:77
PndLmdGeometryHelper::getAvailableOverlapIDs
static std::vector< int > getAvailableOverlapIDs()
Definition: PndLmdGeometryHelper.cxx:120
PndLmdAlignManager::setInCentimeters
void setInCentimeters(bool inCentimeters)
Definition: PndLmdAlignManager.cxx:819
i
Int_t i
Definition: run_full.C:25
exit
exit(0)
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
histParams::title
std::string title
Definition: PndLmdAlignQA.h:25
PndLmdGeometryHelper::getInstance
static PndLmdGeometryHelper & getInstance()
Definition: PndLmdGeometryHelper.h:75
PndLmdAlignQA::~PndLmdAlignQA
virtual ~PndLmdAlignQA()
Definition: PndLmdAlignQA.cxx:36
PndLmdAlignManager::searchFiles
static int searchFiles(std::string curr_directory, std::vector< std::string > &list, std::string extension="", bool includeSubDirs=true)
Definition: PndLmdAlignManager.cxx:731
PndLmdAlignManager::setBinaryPairFileDirectory
void setBinaryPairFileDirectory(const std::string &binaryPairFileDirectory)
Definition: PndLmdAlignManager.h:202
PndLmdAlignManager::aligners
std::map< int, PndLmdSensorAligner > aligners
Definition: PndLmdAlignManager.h:51
PndLmdAlignQA::checkForMatrixFiles
bool checkForMatrixFiles()
Definition: PndLmdAlignQA.cxx:565
PndLmdAlignQA::manager
PndLmdAlignManager manager
Definition: PndLmdAlignQA.h:42
files
std::map< int, TString > files
Definition: simubg.C:28
PndLmdAlignQA::calculateOverlapingAreas
void calculateOverlapingAreas()
Definition: PndLmdAlignQA.cxx:50
PndLmdAlignQA::calculateOverlappingArea
double calculateOverlappingArea(int id1, int id2, bool aligned=true)
Definition: PndLmdAlignQA.cxx:479
PndLmdAlignQA::LMDMatPath
std::string LMDMatPath
Definition: PndLmdAlignQA.h:37
histParams::scaleFactor
double scaleFactor
Definition: PndLmdAlignQA.h:24
PndLmdAlignManager::mkdir
static bool mkdir(std::string path)
Definition: PndLmdAlignManager.cxx:753
PndLmdAlignQA::noOfPairs
int noOfPairs(int overlapID)
Definition: PndLmdAlignQA.cxx:561
PndLmdAlignQA::matrixInfo
std::map< int, int > matrixInfo
Definition: PndLmdAlignQA.h:46
PndLmdAlignQA::plotPXvsCMmatricesResiduals
void plotPXvsCMmatricesResiduals()
Definition: PndLmdAlignQA.cxx:640
histParams::xMin
double xMin
Definition: PndLmdAlignQA.h:27
PndLmdAlignQA::calculatePixelDistancesFrontToBack
void calculatePixelDistancesFrontToBack()
Definition: PndLmdAlignQA.cxx:193
PndLmdSensorAligner::simpleSensorTwoY
std::vector< double > simpleSensorTwoY
Definition: PndLmdSensorAligner.h:38
PndLmdAlignManager::findRegex
static std::vector< std::string > findRegex(std::string source, std::string regex)
Definition: PndLmdAlignManager.cxx:770
PndLmdAlignQA::pdfOutPath
std::string pdfOutPath
Definition: PndLmdAlignQA.h:37
PndLmdAlignQA::checkCyclicMatrices
void checkCyclicMatrices(bool inCentimeters=true)
Definition: PndLmdAlignQA.cxx:299
PndLmdAlignManager::readFile
static std::stringstream * readFile(std::string filename)
Definition: PndLmdAlignManager.cxx:634
histParams::xMax
double xMax
Definition: PndLmdAlignQA.h:28
PndLmdSensorAligner::simpleSensorOneY
std::vector< double > simpleSensorOneY
Definition: PndLmdSensorAligner.h:37
Matrix
Definition: matrix.h:50
PndLmdAlignQA::histPixelDistances
void histPixelDistances(int sen1, int sen2, bool aligned=true)
Definition: PndLmdAlignQA.cxx:381
histParams::ytitle
std::string ytitle
Definition: PndLmdAlignQA.h:25
PndLmdAlignManager::setMatrixOutDir
void setMatrixOutDir(std::string matrixOutDir)
Definition: PndLmdAlignManager.h:178
PndLmdAlignQA::helper
PndLmdGeometryHelper * helper
Definition: PndLmdAlignQA.h:43
PndLmdAlignManager::makeMatrixFileName
static std::string makeMatrixFileName(int overlapId=0, bool incentimeters=true)
Definition: PndLmdAlignManager.cxx:996
sensor2
TGeoVolume * sensor2
Definition: createTestSensorsTGM.C:61
histParams::path
std::string path
Definition: PndLmdAlignQA.h:25
PndLmdAlignQA::alignOptionBool
bool alignOptionBool
Definition: PndLmdAlignQA.h:40
PndLmdSensorAligner::simpleSensorTwoX
std::vector< double > simpleSensorTwoX
Definition: PndLmdSensorAligner.h:38
histParams::xtitle
std::string xtitle
Definition: PndLmdAlignQA.h:25
PndLmdAlignManager::readMatrix
static Matrix readMatrix(std::string filename)
Definition: PndLmdAlignManager.cxx:657
PndLmdAlignQA::checkCombinedMatrices
void checkCombinedMatrices(bool inCentimeters=true)
Definition: PndLmdAlignQA.cxx:205
PndLmdAlignQA::createHist
void createHist(std::vector< std::vector< double > > &vec, histParams &parameters)
Definition: PndLmdAlignQA.cxx:604
PndLmdAlignQA::binaryMatPath
std::string binaryMatPath
Definition: PndLmdAlignQA.h:37
PndLmdGeometryHelper::getOverlapIdFromSensorIDs
int getOverlapIdFromSensorIDs(int id1, int id2)
Definition: PndLmdGeometryHelper.cxx:181
PndLmdAlignQA::plotMatrixresiduals
void plotMatrixresiduals(bool inCentimeters=true)
Definition: PndLmdAlignQA.cxx:817
hist
TH1F * hist
Definition: plot_acceptance_stt.C:243
PndLmdAlignQA::histogramPairDistances
void histogramPairDistances()
Definition: PndLmdAlignQA.cxx:990
histParams::printCMPXinPathName
bool printCMPXinPathName
Definition: PndLmdAlignQA.h:23
vec
dble_vec_t vec[12]
Definition: ranlxd.cxx:380
Matrix::eye
void eye()
histParams::fileName
std::string fileName
Definition: PndLmdAlignQA.h:25
Matrix::val
FLOAT ** val
Definition: matrix.h:138
filename
const string filename
Definition: Modify_root_geometry.C:23
Generated on Wed Apr 3 2019 10:02:53 for FairRoot/PandaRoot by   doxygen 1.8.5