CMS 3D CMS Logo
AlignmentPayloadInspectorHelper.h
Go to the documentation of this file.
1 #ifndef CONDCORE_ALIGNMENTPLUGINS_ALIGNMENTPAYLOADINSPECTORHELPER_H
2 #define CONDCORE_ALIGNMENTPLUGINS_ALIGNMENTPAYLOADINSPECTORHELPER_H
3 
4 #include <iostream>
5 #include <algorithm>
6 #include <vector>
7 #include <numeric>
8 #include <string>
9 #include "TH1.h"
10 #include "TCanvas.h"
11 #include "TPaveStats.h"
12 #include "TStyle.h"
13 #include "TList.h"
14 #include "Alignment/CommonAlignment/interface/Utilities.h"
15 #include "CondFormats/Alignment/interface/Alignments.h"
16 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"
17 #include "DataFormats/Math/interface/deltaPhi.h" // for deltaPhi
18 #include "DataFormats/Math/interface/Rounding.h" // for rounding
19 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
20 #include "FWCore/MessageLogger/interface/MessageLogger.h"
21 
22 //#define MMDEBUG // uncomment for debugging at compile time
23 #ifdef MMDEBUG
24 #include <iostream>
25 #define COUT std::cout << "MM "
26 #else
27 #define COUT edm::LogVerbatim("")
28 #endif
29 
30 namespace AlignmentPI {
31 
32  // size of the phase-I Tracker APE payload (including both SS + DS modules)
33  static const unsigned int phase0size = 19876;
34  static const float cmToUm = 10000.f;
35  static const float tomRad = 1000.f;
36 
37  // method to zero all elements whose difference from 2Pi
38  // is less than the tolerance (2*10e-7)
39  inline double returnZeroIfNear2PI(const double phi) {
40  const double tol = 2.e-7; // default tolerance 1.e-7 doesn't account for possible variations
41  if (cms_rounding::roundIfNear0(std::abs(phi) - 2 * M_PI, tol) == 0.f) {
42  return 0.f;
43  } else {
44  return phi;
45  }
46  }
47 
48  // method to bring back around 0 all elements whose difference
49  // frm 2Pi is is less than the tolerance (in micro-rad)
50  inline double trim2PIs(const double phi, const double tolerance = 1.f) {
51  if (std::abs((std::abs(phi) - 2 * M_PI) * tomRad) < tolerance) {
52  return (std::abs(phi) - 2 * M_PI);
53  } else {
54  return phi;
55  }
56  }
57 
58  enum coordinate {
59  t_x = 1,
60  t_y = 2,
61  t_z = 3,
62  rot_alpha = 4,
63  rot_beta = 5,
64  rot_gamma = 6,
65  };
66 
67  // M.M. 2017/09/12
68  // As the matrix is symmetric, we map only 6/9 terms
69  // More terms for the extended APE can be added to the following methods
70 
71  enum index { XX = 1, XY = 2, XZ = 3, YZ = 4, YY = 5, ZZ = 6 };
72 
73  enum partitions { INVALID = 0, BPix = 1, FPix = 2, TIB = 3, TID = 4, TOB = 5, TEC = 6 };
74 
75  enum class PARTITION {
76  BPIX, // 0 Barrel Pixel
77  FPIXp, // 1 Forward Pixel Plus
78  FPIXm, // 2 Forward Pixel Minus
79  TIB, // 3 Tracker Inner Barrel
80  TIDp, // 4 Tracker Inner Disks Plus
81  TIDm, // 5 Tracker Inner Disks Minus
82  TOB, // 6 Tracker Outer Barrel
83  TECp, // 7 Tracker Endcaps Plus
84  TECm, // 8 Tracker Endcaps Minus
85  LAST = TECm
86  };
87 
88  extern const PARTITION PARTITIONS[(int)PARTITION::LAST + 1];
89  const PARTITION PARTITIONS[] = {PARTITION::BPIX,
90  PARTITION::FPIXp,
91  PARTITION::FPIXm,
92  PARTITION::TIB,
93  PARTITION::TIDp,
94  PARTITION::TIDm,
95  PARTITION::TOB,
96  PARTITION::TECp,
97  PARTITION::TECm};
98 
99  inline std::ostream& operator<<(std::ostream& o, PARTITION x) {
100  return o << std::underlying_type<PARTITION>::type(x);
101  }
102 
103  enum regions {
104  BPixL1o, //0 Barrel Pixel Layer 1 outer
105  BPixL1i, //1 Barrel Pixel Layer 1 inner
106  BPixL2o, //2 Barrel Pixel Layer 2 outer
107  BPixL2i, //3 Barrel Pixel Layer 2 inner
108  BPixL3o, //4 Barrel Pixel Layer 3 outer
109  BPixL3i, //5 Barrel Pixel Layer 3 inner
110  BPixL4o, //6 Barrel Pixel Layer 4 outer
111  BPixL4i, //7 Barrel Pixel Layer 4 inner
112  FPixmL1, //8 Forward Pixel Minus side Disk 1
113  FPixmL2, //9 Forward Pixel Minus side Disk 2
114  FPixmL3, //10 Forward Pixel Minus side Disk 3
115  FPixpL1, //11 Forward Pixel Plus side Disk 1
116  FPixpL2, //12 Forward Pixel Plus side Disk 2
117  FPixpL3, //13 Forward Pixel Plus side Disk 3
118  TIBL1Ro, //14 Inner Barrel Layer 1 Rphi outer
119  TIBL1Ri, //15 Inner Barrel Layer 1 Rphi inner
120  TIBL1So, //16 Inner Barrel Layer 1 Stereo outer
121  TIBL1Si, //17 Inner Barrel Layer 1 Stereo inner
122  TIBL2Ro, //18 Inner Barrel Layer 2 Rphi outer
123  TIBL2Ri, //19 Inner Barrel Layer 2 Rphi inner
124  TIBL2So, //20 Inner Barrel Layer 2 Stereo outer
125  TIBL2Si, //21 Inner Barrel Layer 2 Stereo inner
126  TIBL3o, //22 Inner Barrel Layer 3 outer
127  TIBL3i, //23 Inner Barrel Layer 3 inner
128  TIBL4o, //24 Inner Barrel Layer 4 outer
129  TIBL4i, //25 Inner Barrel Layer 4 inner
130  TOBL1Ro, //26 Outer Barrel Layer 1 Rphi outer
131  TOBL1Ri, //27 Outer Barrel Layer 1 Rphi inner
132  TOBL1So, //28 Outer Barrel Layer 1 Stereo outer
133  TOBL1Si, //29 Outer Barrel Layer 1 Stereo inner
134  TOBL2Ro, //30 Outer Barrel Layer 2 Rphi outer
135  TOBL2Ri, //31 Outer Barrel Layer 2 Rphi inner
136  TOBL2So, //32 Outer Barrel Layer 2 Stereo outer
137  TOBL2Si, //33 Outer Barrel Layer 2 Stereo inner
138  TOBL3o, //34 Outer Barrel Layer 3 outer
139  TOBL3i, //35 Outer Barrel Layer 3 inner
140  TOBL4o, //36 Outer Barrel Layer 4 outer
141  TOBL4i, //37 Outer Barrel Layer 4 inner
142  TOBL5o, //38 Outer Barrel Layer 5 outer
143  TOBL5i, //39 Outer Barrel Layer 5 inner
144  TOBL6o, //40 Outer Barrel Layer 6 outer
145  TOBL6i, //41 Outer Barrel Layer 6 inner
146  TIDmR1R, //42 Inner Disk Minus side Ring 1 Rphi
147  TIDmR1S, //43 Inner Disk Minus side Ring 1 Stereo
148  TIDmR2R, //44 Inner Disk Minus side Ring 2 Rphi
149  TIDmR2S, //45 Inner Disk Minus side Ring 2 Stereo
150  TIDmR3, //46 Inner Disk Minus side Ring 3
151  TIDpR1R, //47 Inner Disk Plus side Ring 1 Rphi
152  TIDpR1S, //48 Inner Disk Plus side Ring 1 Stereo
153  TIDpR2R, //49 Inner Disk Plus side Ring 2 Rphi
154  TIDpR2S, //50 Inner Disk Plus side Ring 2 Stereo
155  TIDpR3, //51 Inner Disk Plus side Ring 3
156  TECmR1R, //52 Endcaps Minus side Ring 1 Rphi
157  TECmR1S, //53 Endcaps Minus side Ring 1 Stereo
158  TECmR2R, //54 Encdaps Minus side Ring 2 Rphi
159  TECmR2S, //55 Endcaps Minus side Ring 2 Stereo
160  TECmR3, //56 Endcaps Minus side Ring 3
161  TECmR4, //57 Endcaps Minus side Ring 4
162  TECmR5, //58 Endcaps Minus side Ring 5
163  TECmR6, //59 Endcaps Minus side Ring 6
164  TECmR7, //60 Endcaps Minus side Ring 7
165  TECpR1R, //61 Endcaps Plus side Ring 1 Rphi
166  TECpR1S, //62 Endcaps Plus side Ring 1 Stereo
167  TECpR2R, //63 Encdaps Plus side Ring 2 Rphi
168  TECpR2S, //64 Endcaps Plus side Ring 2 Stereo
169  TECpR3, //65 Endcaps Plus side Ring 3
170  TECpR4, //66 Endcaps Plus side Ring 4
171  TECpR5, //67 Endcaps Plus side Ring 5
172  TECpR6, //68 Endcaps Plus side Ring 6
173  TECpR7, //67 Endcaps Plus side Ring 7
174  StripDoubleSide, // 70 -- not to be considered
175  NUM_OF_REGIONS // 71 -- default
176  };
177 
178  /*--------------------------------------------------------------------*/
179  inline std::string getStringFromRegionEnum(AlignmentPI::regions e)
180  /*--------------------------------------------------------------------*/
181  {
182  switch (e) {
183  case AlignmentPI::BPixL1o:
184  return "BPixL1o";
185  case AlignmentPI::BPixL1i:
186  return "BPixL1i";
187  case AlignmentPI::BPixL2o:
188  return "BPixL2o";
189  case AlignmentPI::BPixL2i:
190  return "BPixL2i";
191  case AlignmentPI::BPixL3o:
192  return "BPixL3o";
193  case AlignmentPI::BPixL3i:
194  return "BPixL3i";
195  case AlignmentPI::BPixL4o:
196  return "BPixL4o";
197  case AlignmentPI::BPixL4i:
198  return "BPixL4i";
199  case AlignmentPI::FPixmL1:
200  return "FPixmL1";
201  case AlignmentPI::FPixmL2:
202  return "FPixmL2";
203  case AlignmentPI::FPixmL3:
204  return "FPixmL3";
205  case AlignmentPI::FPixpL1:
206  return "FPixpL1";
207  case AlignmentPI::FPixpL2:
208  return "FPixpL2";
209  case AlignmentPI::FPixpL3:
210  return "FPixpL3";
211  case AlignmentPI::TIBL1Ro:
212  return "TIBL1Ro";
213  case AlignmentPI::TIBL1Ri:
214  return "TIBL1Ri";
215  case AlignmentPI::TIBL1So:
216  return "TIBL1So";
217  case AlignmentPI::TIBL1Si:
218  return "TIBL1Si";
219  case AlignmentPI::TIBL2Ro:
220  return "TIBL2Ro";
221  case AlignmentPI::TIBL2Ri:
222  return "TIBL2Ri";
223  case AlignmentPI::TIBL2So:
224  return "TIBL2So";
225  case AlignmentPI::TIBL2Si:
226  return "TIBL2Si";
227  case AlignmentPI::TIBL3o:
228  return "TIBL3o";
229  case AlignmentPI::TIBL3i:
230  return "TIBL3i";
231  case AlignmentPI::TIBL4o:
232  return "TIBL4o";
233  case AlignmentPI::TIBL4i:
234  return "TIBL4i";
235  case AlignmentPI::TOBL1Ro:
236  return "TOBL1Ro";
237  case AlignmentPI::TOBL1Ri:
238  return "TOBL1Ri";
239  case AlignmentPI::TOBL1So:
240  return "TOBL1So";
241  case AlignmentPI::TOBL1Si:
242  return "TOBL1Si";
243  case AlignmentPI::TOBL2Ro:
244  return "TOBL2Ro";
245  case AlignmentPI::TOBL2Ri:
246  return "TOBL2Ri";
247  case AlignmentPI::TOBL2So:
248  return "TOBL2So";
249  case AlignmentPI::TOBL2Si:
250  return "TOBL2Si";
251  case AlignmentPI::TOBL3o:
252  return "TOBL3o";
253  case AlignmentPI::TOBL3i:
254  return "TOBL3i";
255  case AlignmentPI::TOBL4o:
256  return "TOBL4o";
257  case AlignmentPI::TOBL4i:
258  return "TOBL4i";
259  case AlignmentPI::TOBL5o:
260  return "TOBL5o";
261  case AlignmentPI::TOBL5i:
262  return "TOBL5i";
263  case AlignmentPI::TOBL6o:
264  return "TOBL6o";
265  case AlignmentPI::TOBL6i:
266  return "TOBL6i";
267  case AlignmentPI::TIDmR1R:
268  return "TIDmR1R";
269  case AlignmentPI::TIDmR1S:
270  return "TIDmR1S";
271  case AlignmentPI::TIDmR2R:
272  return "TIDmR2R";
273  case AlignmentPI::TIDmR2S:
274  return "TIDmR2S";
275  case AlignmentPI::TIDmR3:
276  return "TIDmR3";
277  case AlignmentPI::TIDpR1R:
278  return "TIDpR1R";
279  case AlignmentPI::TIDpR1S:
280  return "TIDpR1S";
281  case AlignmentPI::TIDpR2R:
282  return "TIDpR2R";
283  case AlignmentPI::TIDpR2S:
284  return "TIDpR2S";
285  case AlignmentPI::TIDpR3:
286  return "TIDpR3";
287  case AlignmentPI::TECmR1R:
288  return "TECmR1R";
289  case AlignmentPI::TECmR1S:
290  return "TECmR1S";
291  case AlignmentPI::TECmR2R:
292  return "TECmR2R";
293  case AlignmentPI::TECmR2S:
294  return "TECmR2S";
295  case AlignmentPI::TECmR3:
296  return "TECmR3";
297  case AlignmentPI::TECmR4:
298  return "TECmR4";
299  case AlignmentPI::TECmR5:
300  return "TECmR5";
301  case AlignmentPI::TECmR6:
302  return "TECmR6";
303  case AlignmentPI::TECmR7:
304  return "TECmR7";
305  case AlignmentPI::TECpR1R:
306  return "TECpR1R";
307  case AlignmentPI::TECpR1S:
308  return "TECpR1S";
309  case AlignmentPI::TECpR2R:
310  return "TECpR2R";
311  case AlignmentPI::TECpR2S:
312  return "TECpR2S";
313  case AlignmentPI::TECpR3:
314  return "TECpR3";
315  case AlignmentPI::TECpR4:
316  return "TECpR4";
317  case AlignmentPI::TECpR5:
318  return "TECpR5";
319  case AlignmentPI::TECpR6:
320  return "TECpR6";
321  case AlignmentPI::TECpR7:
322  return "TECpR7";
323  default:
324  edm::LogWarning("LogicError") << "Unknown partition: " << e;
325  return "";
326  }
327  }
328 
329  /*--------------------------------------------------------------------*/
330  inline bool isBPixOuterLadder(const DetId& detid, const TrackerTopology& tTopo, bool isPhase0)
331  /*--------------------------------------------------------------------*/
332  {
333  bool isOuter = false;
334  int layer = tTopo.pxbLayer(detid.rawId());
335  bool odd_ladder = tTopo.pxbLadder(detid.rawId()) % 2;
336  if (isPhase0) {
337  if (layer == 2)
338  isOuter = !odd_ladder;
339  else
340  isOuter = odd_ladder;
341  } else {
342  if (layer == 4)
343  isOuter = odd_ladder;
344  else
345  isOuter = !odd_ladder;
346  }
347  return isOuter;
348  }
349 
350  // ancillary struct to manage the topology
351  // info in a more compact way
352 
353  struct topolInfo {
354  private:
355  uint32_t m_rawid;
356  int m_subdetid;
357  int m_layer;
358  int m_side;
359  int m_ring;
360  bool m_isRphi;
361  bool m_isDoubleSide;
362  bool m_isInternal;
363 
364  public:
365  void init();
366  void fillGeometryInfo(const DetId& detId, const TrackerTopology& tTopo, bool isPhase0);
367  AlignmentPI::regions filterThePartition();
368  bool sanityCheck();
369  void printAll();
370  virtual ~topolInfo() {}
371  };
372 
373  /*--------------------------------------------------------------------*/
374  inline void topolInfo::printAll()
375  /*--------------------------------------------------------------------*/
376  {
377  std::cout << " detId:" << m_rawid << " subdetid: " << m_subdetid << " layer: " << m_layer << " side: " << m_side
378  << " ring: " << m_ring << " isRphi:" << m_isRphi << " isDoubleSide:" << m_isDoubleSide
379  << " isInternal:" << m_isInternal << std::endl;
380  }
381 
382  /*--------------------------------------------------------------------*/
383  inline void topolInfo::init()
384  /*--------------------------------------------------------------------*/
385  {
386  m_rawid = 0;
387  m_subdetid = -1;
388  m_layer = -1;
389  m_side = -1;
390  m_ring = -1;
391  m_isRphi = false;
392  m_isDoubleSide = false;
393  m_isInternal = false;
394  };
395 
396  /*--------------------------------------------------------------------*/
397  inline bool topolInfo::sanityCheck()
398  /*--------------------------------------------------------------------*/
399  {
400  if (m_layer == 0 || (m_subdetid == 1 && m_layer > 4) || (m_subdetid == 2 && m_layer > 3)) {
401  return false;
402  } else {
403  return true;
404  }
405  }
406  /*--------------------------------------------------------------------*/
407  inline void topolInfo::fillGeometryInfo(const DetId& detId, const TrackerTopology& tTopo, bool isPhase0)
408  /*--------------------------------------------------------------------*/
409  {
410  unsigned int subdetId = static_cast<unsigned int>(detId.subdetId());
411 
412  m_rawid = detId.rawId();
413  m_subdetid = subdetId;
414 
415  if (subdetId == StripSubdetector::TIB) {
416  m_layer = tTopo.tibLayer(detId.rawId());
417  m_side = tTopo.tibSide(detId.rawId());
418  m_isRphi = tTopo.isRPhi(detId.rawId());
419  m_isDoubleSide = tTopo.tibIsDoubleSide(detId.rawId());
420  m_isInternal = tTopo.tibIsInternalString(detId.rawId());
421  } else if (subdetId == StripSubdetector::TOB) {
422  m_layer = tTopo.tobLayer(detId.rawId());
423  m_side = tTopo.tobSide(detId.rawId());
424  m_isRphi = tTopo.isRPhi(detId.rawId());
425  m_isDoubleSide = tTopo.tobIsDoubleSide(detId.rawId());
426  m_isInternal = tTopo.tobModule(detId.rawId()) % 2;
427  } else if (subdetId == StripSubdetector::TID) {
428  m_layer = tTopo.tidWheel(detId.rawId());
429  m_side = tTopo.tidSide(detId.rawId());
430  m_isRphi = tTopo.isRPhi(detId.rawId());
431  m_ring = tTopo.tidRing(detId.rawId());
432  m_isDoubleSide = tTopo.tidIsDoubleSide(detId.rawId());
433  m_isInternal = tTopo.tidModuleInfo(detId.rawId())[0];
434  } else if (subdetId == StripSubdetector::TEC) {
435  m_layer = tTopo.tecWheel(detId.rawId());
436  m_side = tTopo.tecSide(detId.rawId());
437  m_isRphi = tTopo.isRPhi(detId.rawId());
438  m_ring = tTopo.tecRing(detId.rawId());
439  m_isDoubleSide = tTopo.tecIsDoubleSide(detId.rawId());
440  m_isInternal = tTopo.tecPetalInfo(detId.rawId())[0];
441  } else if (subdetId == PixelSubdetector::PixelBarrel) {
442  m_layer = tTopo.pxbLayer(detId.rawId());
443  m_isInternal = !AlignmentPI::isBPixOuterLadder(detId, tTopo, isPhase0);
444  } else if (subdetId == PixelSubdetector::PixelEndcap) {
445  m_layer = tTopo.pxfDisk(detId.rawId());
446  m_side = tTopo.pxfSide(detId.rawId());
447  } else
448  edm::LogWarning("LogicError") << "Unknown subdetid: " << subdetId;
449  }
450 
451  // ------------ method to assign a partition based on the topology struct info ---------------
452 
453  /*--------------------------------------------------------------------*/
454  inline AlignmentPI::regions topolInfo::filterThePartition()
455  /*--------------------------------------------------------------------*/
456  {
457  AlignmentPI::regions ret = AlignmentPI::NUM_OF_REGIONS;
458 
459  if (m_isDoubleSide) {
460  return AlignmentPI::StripDoubleSide;
461  }
462 
463  // BPix
464  if (m_subdetid == 1) {
465  switch (m_layer) {
466  case 1:
467  m_isInternal > 0 ? ret = AlignmentPI::BPixL1o : ret = AlignmentPI::BPixL1i;
468  break;
469  case 2:
470  m_isInternal > 0 ? ret = AlignmentPI::BPixL2o : ret = AlignmentPI::BPixL2i;
471  break;
472  case 3:
473  m_isInternal > 0 ? ret = AlignmentPI::BPixL3o : ret = AlignmentPI::BPixL3i;
474  break;
475  case 4:
476  m_isInternal > 0 ? ret = AlignmentPI::BPixL4o : ret = AlignmentPI::BPixL4i;
477  break;
478  default:
479  edm::LogWarning("LogicError") << "Unknow BPix layer: " << m_layer;
480  break;
481  }
482  // FPix
483  } else if (m_subdetid == 2) {
484  switch (m_layer) {
485  case 1:
486  m_side > 1 ? ret = AlignmentPI::FPixpL1 : ret = AlignmentPI::FPixmL1;
487  break;
488  case 2:
489  m_side > 1 ? ret = AlignmentPI::FPixpL2 : ret = AlignmentPI::FPixmL2;
490  break;
491  case 3:
492  m_side > 1 ? ret = AlignmentPI::FPixpL3 : ret = AlignmentPI::FPixmL3;
493  break;
494  default:
495  edm::LogWarning("LogicError") << "Unknow FPix disk: " << m_layer;
496  break;
497  }
498  // TIB
499  } else if (m_subdetid == 3) {
500  switch (m_layer) {
501  case 1:
502  if (m_isRphi) {
503  m_isInternal > 0 ? ret = AlignmentPI::TIBL1Ro : ret = AlignmentPI::TIBL1Ri;
504  } else {
505  m_isInternal > 0 ? ret = AlignmentPI::TIBL1So : ret = AlignmentPI::TIBL1Si;
506  }
507  break;
508  case 2:
509  if (m_isRphi) {
510  m_isInternal > 0 ? ret = AlignmentPI::TIBL2Ro : ret = AlignmentPI::TIBL2Ri;
511  } else {
512  m_isInternal > 0 ? ret = AlignmentPI::TIBL2So : ret = AlignmentPI::TIBL2Si;
513  }
514  break;
515  case 3:
516  m_isInternal > 0 ? ret = AlignmentPI::TIBL3o : ret = AlignmentPI::TIBL3i;
517  break;
518  case 4:
519  m_isInternal > 0 ? ret = AlignmentPI::TIBL4o : ret = AlignmentPI::TIBL4i;
520  break;
521  default:
522  edm::LogWarning("LogicError") << "Unknow TIB layer: " << m_layer;
523  break;
524  }
525  // TID
526  } else if (m_subdetid == 4) {
527  switch (m_ring) {
528  case 1:
529  if (m_isRphi) {
530  m_side > 1 ? ret = AlignmentPI::TIDpR1R : ret = AlignmentPI::TIDmR1R;
531  } else {
532  m_side > 1 ? ret = AlignmentPI::TIDpR1S : ret = AlignmentPI::TIDmR1S;
533  }
534  break;
535  case 2:
536  if (m_isRphi) {
537  m_side > 1 ? ret = AlignmentPI::TIDpR2R : ret = AlignmentPI::TIDmR2R;
538  } else {
539  m_side > 1 ? ret = AlignmentPI::TIDpR2S : ret = AlignmentPI::TIDmR2S;
540  }
541  break;
542  case 3:
543  m_side > 1 ? ret = AlignmentPI::TIDpR3 : ret = AlignmentPI::TIDmR3;
544  break;
545  default:
546  edm::LogWarning("LogicError") << "Unknow TID wheel: " << m_layer;
547  break;
548  }
549  // TOB
550  } else if (m_subdetid == 5) {
551  switch (m_layer) {
552  case 1:
553  if (m_isRphi) {
554  m_isInternal > 0 ? ret = AlignmentPI::TOBL1Ro : ret = AlignmentPI::TOBL1Ri;
555  } else {
556  m_isInternal > 0 ? ret = AlignmentPI::TOBL1So : ret = AlignmentPI::TOBL1Si;
557  }
558  break;
559  case 2:
560  if (m_isRphi) {
561  m_isInternal > 0 ? ret = AlignmentPI::TOBL2Ro : ret = AlignmentPI::TOBL2Ri;
562  } else {
563  m_isInternal > 0 ? ret = AlignmentPI::TOBL2So : ret = AlignmentPI::TOBL2Si;
564  }
565  break;
566  case 3:
567  m_isInternal > 0 ? ret = AlignmentPI::TOBL3o : ret = AlignmentPI::TOBL3i;
568  break;
569  case 4:
570  m_isInternal > 0 ? ret = AlignmentPI::TOBL4o : ret = AlignmentPI::TOBL4i;
571  break;
572  case 5:
573  m_isInternal > 0 ? ret = AlignmentPI::TOBL5o : ret = AlignmentPI::TOBL5i;
574  break;
575  case 6:
576  m_isInternal > 0 ? ret = AlignmentPI::TOBL6o : ret = AlignmentPI::TOBL6i;
577  break;
578  default:
579  edm::LogWarning("LogicError") << "Unknow TOB layer: " << m_layer;
580  break;
581  }
582  // TEC
583  } else if (m_subdetid == 6) {
584  switch (m_ring) {
585  case 1:
586  if (m_isRphi) {
587  m_side > 1 ? ret = AlignmentPI::TECpR1R : ret = AlignmentPI::TECmR1R;
588  } else {
589  m_side > 1 ? ret = AlignmentPI::TECpR1S : ret = AlignmentPI::TECmR1S;
590  }
591  break;
592  case 2:
593  if (m_isRphi) {
594  m_side > 1 ? ret = AlignmentPI::TECpR2R : ret = AlignmentPI::TECmR2R;
595  } else {
596  m_side > 1 ? ret = AlignmentPI::TECpR2S : ret = AlignmentPI::TECmR2S;
597  }
598  break;
599  case 3:
600  m_side > 1 ? ret = AlignmentPI::TECpR3 : ret = AlignmentPI::TECmR3;
601  break;
602  case 4:
603  m_side > 1 ? ret = AlignmentPI::TECpR4 : ret = AlignmentPI::TECmR4;
604  break;
605  case 5:
606  m_side > 1 ? ret = AlignmentPI::TECpR5 : ret = AlignmentPI::TECmR5;
607  break;
608  case 6:
609  m_side > 1 ? ret = AlignmentPI::TECpR6 : ret = AlignmentPI::TECmR6;
610  break;
611  case 7:
612  m_side > 1 ? ret = AlignmentPI::TECpR7 : ret = AlignmentPI::TECmR7;
613  break;
614  default:
615  edm::LogWarning("LogicError") << "Unknow TEC ring: " << m_ring;
616  break;
617  }
618  }
619 
620  return ret;
621  }
622 
623  /*--------------------------------------------------------------------*/
624  inline std::string getStringFromCoordinate(AlignmentPI::coordinate coord)
625  /*--------------------------------------------------------------------*/
626  {
627  switch (coord) {
628  case t_x:
629  return "x-translation";
630  case t_y:
631  return "y-translation";
632  case t_z:
633  return "z-translation";
634  case rot_alpha:
635  return "#alpha angle rotation";
636  case rot_beta:
637  return "#beta angle rotation";
638  case rot_gamma:
639  return "#gamma angle rotation";
640  default:
641  return "should never be here!";
642  }
643  }
644 
645  /*--------------------------------------------------------------------*/
646  inline std::string getStringFromIndex(AlignmentPI::index i)
647  /*--------------------------------------------------------------------*/
648  {
649  switch (i) {
650  case XX:
651  return "XX";
652  case XY:
653  return "XY";
654  case XZ:
655  return "XZ";
656  case YZ:
657  return "YX";
658  case YY:
659  return "YY";
660  case ZZ:
661  return "ZZ";
662  default:
663  return "should never be here!";
664  }
665  }
666 
667  /*--------------------------------------------------------------------*/
668  inline std::string getStringFromPart(AlignmentPI::partitions i)
669  /*--------------------------------------------------------------------*/
670  {
671  switch (i) {
672  case BPix:
673  return "BPix";
674  case FPix:
675  return "FPix";
676  case TIB:
677  return "TIB";
678  case TID:
679  return "TID";
680  case TOB:
681  return "TOB";
682  case TEC:
683  return "TEC";
684  default:
685  return "should never be here!";
686  }
687  }
688 
689  /*--------------------------------------------------------------------*/
690  inline std::pair<int, int> getIndices(AlignmentPI::index i)
691  /*--------------------------------------------------------------------*/
692  {
693  switch (i) {
694  case XX:
695  return std::make_pair(0, 0);
696  case XY:
697  return std::make_pair(0, 1);
698  case XZ:
699  return std::make_pair(0, 2);
700  case YZ:
701  return std::make_pair(1, 0);
702  case YY:
703  return std::make_pair(1, 1);
704  case ZZ:
705  return std::make_pair(2, 2);
706  default:
707  return std::make_pair(-1, -1);
708  }
709  }
710 
711  /*--------------------------------------------------------------------*/
712  inline void makeNicePlotStyle(TH1* hist, int color)
713  /*--------------------------------------------------------------------*/
714  {
715  hist->SetStats(kFALSE);
716 
717  hist->GetXaxis()->SetTitleColor(color);
718  hist->SetLineColor(color);
719  hist->SetTitleSize(0.08);
720  hist->SetLineWidth(2);
721  hist->GetXaxis()->CenterTitle(true);
722  hist->GetYaxis()->CenterTitle(true);
723  hist->GetXaxis()->SetTitleFont(42);
724  hist->GetYaxis()->SetTitleFont(42);
725  hist->GetXaxis()->SetNdivisions(505);
726  hist->GetXaxis()->SetTitleSize(0.06);
727  hist->GetYaxis()->SetTitleSize(0.06);
728  hist->GetXaxis()->SetTitleOffset(1.0);
729  hist->GetYaxis()->SetTitleOffset(1.3);
730  hist->GetXaxis()->SetLabelFont(42);
731  hist->GetYaxis()->SetLabelFont(42);
732  hist->GetYaxis()->SetLabelSize(.05);
733  hist->GetXaxis()->SetLabelSize(.05);
734  }
735 
736  /*--------------------------------------------------------------------*/
737  inline void makeNiceStats(TH1F* hist, AlignmentPI::partitions part, int color)
738  /*--------------------------------------------------------------------*/
739  {
740  char buffer[255];
741  TPaveText* stat = new TPaveText(0.60, 0.75, 0.95, 0.95, "NDC");
742  sprintf(buffer, "%s \n", AlignmentPI::getStringFromPart(part).c_str());
743  stat->AddText(buffer);
744 
745  sprintf(buffer, "Entries : %i\n", (int)hist->GetEntries());
746  stat->AddText(buffer);
747 
748  if (std::abs(hist->GetMean()) > 0.01) {
749  sprintf(buffer, "Mean : %6.2f\n", hist->GetMean());
750  } else {
751  sprintf(buffer, "Mean : %6.2f e-2\n", 100 * hist->GetMean());
752  }
753  stat->AddText(buffer);
754 
755  if (std::abs(hist->GetRMS()) > 0.01) {
756  sprintf(buffer, "RMS : %6.2f\n", hist->GetRMS());
757  } else {
758  sprintf(buffer, "RMS : %6.2f e-2\n", 100 * hist->GetRMS());
759  }
760  stat->AddText(buffer);
761 
762  stat->SetLineColor(color);
763  stat->SetTextColor(color);
764  stat->SetFillColor(10);
765  stat->SetShadowColor(10);
766  stat->Draw();
767  }
768 
769  /*--------------------------------------------------------------------*/
770  inline std::pair<float, float> getTheRange(std::map<uint32_t, float> values, const float nsigma)
771  /*--------------------------------------------------------------------*/
772  {
773  float sum = std::accumulate(
774  std::begin(values), std::end(values), 0.0, [](float value, const std::map<uint32_t, float>::value_type& p) {
775  return value + p.second;
776  });
777 
778  float m = sum / values.size();
779 
780  float accum = 0.0;
781  std::for_each(std::begin(values), std::end(values), [&](const std::map<uint32_t, float>::value_type& p) {
782  accum += (p.second - m) * (p.second - m);
783  });
784 
785  float stdev = sqrt(accum / (values.size() - 1));
786 
787  if (stdev != 0.) {
788  return std::make_pair(m - nsigma * stdev, m + nsigma * stdev);
789  } else {
790  return std::make_pair(m > 0. ? 0.95 * m : 1.05 * m, m > 0 ? 1.05 * m : 0.95 * m);
791  }
792  }
793 
794  /*--------------------------------------------------------------------*/
795  inline std::pair<double, double> calculatePosition(TVirtualPad* myPad, int boundary)
796  /*--------------------------------------------------------------------*/
797  {
798  int ix1;
799  int ix2;
800  int iw = myPad->GetWw();
801  int ih = myPad->GetWh();
802  double x1p, y1p, x2p, y2p;
803  myPad->GetPadPar(x1p, y1p, x2p, y2p);
804  ix1 = (int)(iw * x1p);
805  ix2 = (int)(iw * x2p);
806  double wndc = std::min(1., (double)iw / (double)ih);
807  double rw = wndc / (double)iw;
808  double x1ndc = (double)ix1 * rw;
809  double x2ndc = (double)ix2 * rw;
810  double rx1, ry1, rx2, ry2;
811  myPad->GetRange(rx1, ry1, rx2, ry2);
812  double rx = (x2ndc - x1ndc) / (rx2 - rx1);
813  double _sx;
814  _sx = rx * (boundary - rx1) + x1ndc;
815  double _dx = _sx + 0.05;
816 
817  return std::make_pair(_sx, _dx);
818  }
819 
820  // ancillary struct to manage the barycenters
821  // info in a more compact way
822 
823  struct TkAlBarycenters {
824  std::map<AlignmentPI::PARTITION, double> Xbarycenters;
825  std::map<AlignmentPI::PARTITION, double> Ybarycenters;
826  std::map<AlignmentPI::PARTITION, double> Zbarycenters;
827  std::map<AlignmentPI::PARTITION, double> nmodules;
828 
829  public:
830  void init();
831  GlobalPoint getPartitionAvg(AlignmentPI::PARTITION p);
832  void computeBarycenters(const std::vector<AlignTransform>& input,
833  const TrackerTopology& tTopo,
834  const std::map<AlignmentPI::coordinate, float>& GPR);
835  const double getNModules(AlignmentPI::PARTITION p) { return nmodules[p]; };
836 
837  // M.M. 2020/01/09
838  // introduce methods for entire partitions, summing up the two sides of the
839  // endcap detectors
840 
841  /*--------------------------------------------------------------------*/
842  const std::array<double, 6> getX()
843  /*--------------------------------------------------------------------*/
844  {
845  return {{Xbarycenters[PARTITION::BPIX],
846  (Xbarycenters[PARTITION::FPIXm] + Xbarycenters[PARTITION::FPIXp]) / 2.,
847  Xbarycenters[PARTITION::TIB],
848  (Xbarycenters[PARTITION::TIDm] + Xbarycenters[PARTITION::TIDp]) / 2,
849  Xbarycenters[PARTITION::TOB],
850  (Xbarycenters[PARTITION::TECm] + Xbarycenters[PARTITION::TECp]) / 2}};
851  };
852 
853  /*--------------------------------------------------------------------*/
854  const std::array<double, 6> getY()
855  /*--------------------------------------------------------------------*/
856  {
857  return {{Ybarycenters[PARTITION::BPIX],
858  (Ybarycenters[PARTITION::FPIXm] + Ybarycenters[PARTITION::FPIXp]) / 2.,
859  Ybarycenters[PARTITION::TIB],
860  (Ybarycenters[PARTITION::TIDm] + Ybarycenters[PARTITION::TIDp]) / 2,
861  Ybarycenters[PARTITION::TOB],
862  (Ybarycenters[PARTITION::TECm] + Ybarycenters[PARTITION::TECp]) / 2}};
863  };
864 
865  /*--------------------------------------------------------------------*/
866  const std::array<double, 6> getZ()
867  /*--------------------------------------------------------------------*/
868  {
869  return {{Zbarycenters[PARTITION::BPIX],
870  (Zbarycenters[PARTITION::FPIXm] + Zbarycenters[PARTITION::FPIXp]) / 2.,
871  Zbarycenters[PARTITION::TIB],
872  (Zbarycenters[PARTITION::TIDm] + Zbarycenters[PARTITION::TIDp]) / 2,
873  Zbarycenters[PARTITION::TOB],
874  (Zbarycenters[PARTITION::TECm] + Zbarycenters[PARTITION::TECp]) / 2}};
875  };
876  virtual ~TkAlBarycenters() {}
877  };
878 
879  /*--------------------------------------------------------------------*/
880  inline GlobalPoint TkAlBarycenters::getPartitionAvg(AlignmentPI::PARTITION p)
881  /*--------------------------------------------------------------------*/
882  {
883  return GlobalPoint(Xbarycenters[p], Ybarycenters[p], Zbarycenters[p]);
884  }
885 
886  /*--------------------------------------------------------------------*/
887  inline void TkAlBarycenters::computeBarycenters(const std::vector<AlignTransform>& input,
888  const TrackerTopology& tTopo,
889  const std::map<AlignmentPI::coordinate, float>& GPR)
890  /*--------------------------------------------------------------------*/
891  {
892  // zero in the n. modules per partition...
893  for (const auto& p : PARTITIONS) {
894  nmodules[p] = 0.;
895  }
896 
897  for (const auto& ali : input) {
898  if (DetId(ali.rawId()).det() != DetId::Tracker) {
899  edm::LogWarning("TkAlBarycenters::computeBarycenters")
900  << "Encountered invalid Tracker DetId:" << ali.rawId() << " " << DetId(ali.rawId()).det()
901  << " is different from " << DetId::Tracker << " - terminating ";
902  assert(DetId(ali.rawId()).det() != DetId::Tracker);
903  }
904 
905  int subid = DetId(ali.rawId()).subdetId();
906  switch (subid) {
907  case PixelSubdetector::PixelBarrel:
908  Xbarycenters[PARTITION::BPIX] += (ali.translation().x());
909  Ybarycenters[PARTITION::BPIX] += (ali.translation().y());
910  Zbarycenters[PARTITION::BPIX] += (ali.translation().z());
911  nmodules[PARTITION::BPIX]++;
912  break;
913  case PixelSubdetector::PixelEndcap:
914 
915  // minus side
916  if (tTopo.pxfSide(DetId(ali.rawId())) == 1) {
917  Xbarycenters[PARTITION::FPIXm] += (ali.translation().x());
918  Ybarycenters[PARTITION::FPIXm] += (ali.translation().y());
919  Zbarycenters[PARTITION::FPIXm] += (ali.translation().z());
920  nmodules[PARTITION::FPIXm]++;
921  } // plus side
922  else {
923  Xbarycenters[PARTITION::FPIXp] += (ali.translation().x());
924  Ybarycenters[PARTITION::FPIXp] += (ali.translation().y());
925  Zbarycenters[PARTITION::FPIXp] += (ali.translation().z());
926  nmodules[PARTITION::FPIXp]++;
927  }
928  break;
929  case StripSubdetector::TIB:
930  Xbarycenters[PARTITION::TIB] += (ali.translation().x());
931  Ybarycenters[PARTITION::TIB] += (ali.translation().y());
932  Zbarycenters[PARTITION::TIB] += (ali.translation().z());
933  nmodules[PARTITION::TIB]++;
934  break;
935  case StripSubdetector::TID:
936  // minus side
937  if (tTopo.tidSide(DetId(ali.rawId())) == 1) {
938  Xbarycenters[PARTITION::TIDm] += (ali.translation().x());
939  Ybarycenters[PARTITION::TIDm] += (ali.translation().y());
940  Zbarycenters[PARTITION::TIDm] += (ali.translation().z());
941  nmodules[PARTITION::TIDm]++;
942  } // plus side
943  else {
944  Xbarycenters[PARTITION::TIDp] += (ali.translation().x());
945  Ybarycenters[PARTITION::TIDp] += (ali.translation().y());
946  Zbarycenters[PARTITION::TIDp] += (ali.translation().z());
947  nmodules[PARTITION::TIDp]++;
948  }
949  break;
950  case StripSubdetector::TOB:
951  Xbarycenters[PARTITION::TOB] += (ali.translation().x());
952  Ybarycenters[PARTITION::TOB] += (ali.translation().y());
953  Zbarycenters[PARTITION::TOB] += (ali.translation().z());
954  nmodules[PARTITION::TOB]++;
955  break;
956  case StripSubdetector::TEC:
957  // minus side
958  if (tTopo.tecSide(DetId(ali.rawId())) == 1) {
959  Xbarycenters[PARTITION::TECm] += (ali.translation().x());
960  Ybarycenters[PARTITION::TECm] += (ali.translation().y());
961  Zbarycenters[PARTITION::TECm] += (ali.translation().z());
962  nmodules[PARTITION::TECm]++;
963  } // plus side
964  else {
965  Xbarycenters[PARTITION::TECp] += (ali.translation().x());
966  Ybarycenters[PARTITION::TECp] += (ali.translation().y());
967  Zbarycenters[PARTITION::TECp] += (ali.translation().z());
968  nmodules[PARTITION::TECp]++;
969  }
970  break;
971  default:
972  edm::LogError("TrackerAlignment_PayloadInspector") << "Unrecognized partition " << subid << std::endl;
973  break;
974  }
975  }
976 
977  for (const auto& p : PARTITIONS) {
978  // take the arithmetic mean
979  Xbarycenters[p] /= nmodules[p];
980  Ybarycenters[p] /= nmodules[p];
981  Zbarycenters[p] /= nmodules[p];
982 
983  // add the Tracker Global Position Record
984  Xbarycenters[p] += GPR.at(AlignmentPI::t_x);
985  Ybarycenters[p] += GPR.at(AlignmentPI::t_y);
986  Zbarycenters[p] += GPR.at(AlignmentPI::t_z);
987 
988  COUT << "Partition: " << p << " n. modules: " << nmodules[p] << "|"
989  << " X: " << std::right << std::setw(12) << Xbarycenters[p] << " Y: " << std::right << std::setw(12)
990  << Ybarycenters[p] << " Z: " << std::right << std::setw(12) << Zbarycenters[p] << std::endl;
991  }
992  }
993 
994  /*--------------------------------------------------------------------*/
995  inline void fillComparisonHistogram(const AlignmentPI::coordinate& coord,
996  std::vector<int>& boundaries,
997  const std::vector<AlignTransform>& ref_ali,
998  const std::vector<AlignTransform>& target_ali,
999  std::unique_ptr<TH1F>& compare)
1000  /*--------------------------------------------------------------------*/
1001  {
1002  int counter = 0; /* start the counter */
1003  AlignmentPI::partitions currentPart = AlignmentPI::BPix;
1004  for (unsigned int i = 0; i < ref_ali.size(); i++) {
1005  if (ref_ali[i].rawId() == target_ali[i].rawId()) {
1006  counter++;
1007  int subid = DetId(ref_ali[i].rawId()).subdetId();
1008 
1009  auto thePart = static_cast<AlignmentPI::partitions>(subid);
1010  if (thePart != currentPart) {
1011  currentPart = thePart;
1012  boundaries.push_back(counter);
1013  }
1014 
1015  CLHEP::HepRotation target_rot(target_ali[i].rotation());
1016  CLHEP::HepRotation ref_rot(ref_ali[i].rotation());
1017 
1018  align::RotationType target_ROT(target_rot.xx(),
1019  target_rot.xy(),
1020  target_rot.xz(),
1021  target_rot.yx(),
1022  target_rot.yy(),
1023  target_rot.yz(),
1024  target_rot.zx(),
1025  target_rot.zy(),
1026  target_rot.zz());
1027 
1028  align::RotationType ref_ROT(ref_rot.xx(),
1029  ref_rot.xy(),
1030  ref_rot.xz(),
1031  ref_rot.yx(),
1032  ref_rot.yy(),
1033  ref_rot.yz(),
1034  ref_rot.zx(),
1035  ref_rot.zy(),
1036  ref_rot.zz());
1037 
1038  const std::vector<double> deltaRot = {::deltaPhi(align::toAngles(target_ROT)[0], align::toAngles(ref_ROT)[0]),
1039  ::deltaPhi(align::toAngles(target_ROT)[1], align::toAngles(ref_ROT)[1]),
1040  ::deltaPhi(align::toAngles(target_ROT)[2], align::toAngles(ref_ROT)[2])};
1041 
1042  const auto& deltaTrans = target_ali[i].translation() - ref_ali[i].translation();
1043 
1044  switch (coord) {
1045  case AlignmentPI::t_x:
1046  compare->SetBinContent(i + 1, deltaTrans.x() * AlignmentPI::cmToUm);
1047  break;
1048  case AlignmentPI::t_y:
1049  compare->SetBinContent(i + 1, deltaTrans.y() * AlignmentPI::cmToUm);
1050  break;
1051  case AlignmentPI::t_z:
1052  compare->SetBinContent(i + 1, deltaTrans.z() * AlignmentPI::cmToUm);
1053  break;
1054  case AlignmentPI::rot_alpha:
1055  compare->SetBinContent(i + 1, deltaRot[0] * AlignmentPI::tomRad);
1056  break;
1057  case AlignmentPI::rot_beta:
1058  compare->SetBinContent(i + 1, deltaRot[1] * AlignmentPI::tomRad);
1059  break;
1060  case AlignmentPI::rot_gamma:
1061  compare->SetBinContent(i + 1, deltaRot[2] * AlignmentPI::tomRad);
1062  break;
1063  default:
1064  edm::LogError("TrackerAlignment_PayloadInspector") << "Unrecognized coordinate " << coord << std::endl;
1065  break;
1066  } // switch on the coordinate
1067  } // check on the same detID
1068  } // loop on the components
1069  }
1070 
1071  /*--------------------------------------------------------------------*/
1072  inline void fillComparisonHistograms(std::vector<int>& boundaries,
1073  const std::vector<AlignTransform>& ref_ali,
1074  const std::vector<AlignTransform>& target_ali,
1075  std::unordered_map<AlignmentPI::coordinate, std::unique_ptr<TH1F> >& compare,
1076  bool diff = false,
1077  AlignmentPI::partitions checkPart = AlignmentPI::INVALID)
1078  /*--------------------------------------------------------------------*/
1079  {
1080  int counter = 0; /* start the counter */
1081  AlignmentPI::partitions currentPart = AlignmentPI::BPix;
1082  for (unsigned int i = 0; i < ref_ali.size(); i++) {
1083  if (ref_ali[i].rawId() == target_ali[i].rawId()) {
1084  counter++;
1085  int subid = DetId(ref_ali[i].rawId()).subdetId();
1086 
1087  auto thePart = static_cast<AlignmentPI::partitions>(subid);
1088 
1089  // in case it has to be filtered
1090  if (checkPart > 0 && thePart != checkPart) {
1091  continue;
1092  }
1093 
1094  if (thePart != currentPart) {
1095  currentPart = thePart;
1096  boundaries.push_back(counter);
1097  }
1098 
1099  CLHEP::HepRotation target_rot(target_ali[i].rotation());
1100  CLHEP::HepRotation ref_rot(ref_ali[i].rotation());
1101 
1102  align::RotationType target_ROT(target_rot.xx(),
1103  target_rot.xy(),
1104  target_rot.xz(),
1105  target_rot.yx(),
1106  target_rot.yy(),
1107  target_rot.yz(),
1108  target_rot.zx(),
1109  target_rot.zy(),
1110  target_rot.zz());
1111 
1112  align::RotationType ref_ROT(ref_rot.xx(),
1113  ref_rot.xy(),
1114  ref_rot.xz(),
1115  ref_rot.yx(),
1116  ref_rot.yy(),
1117  ref_rot.yz(),
1118  ref_rot.zx(),
1119  ref_rot.zy(),
1120  ref_rot.zz());
1121 
1122  const std::vector<double> deltaRot = {::deltaPhi(align::toAngles(target_ROT)[0], align::toAngles(ref_ROT)[0]),
1123  ::deltaPhi(align::toAngles(target_ROT)[1], align::toAngles(ref_ROT)[1]),
1124  ::deltaPhi(align::toAngles(target_ROT)[2], align::toAngles(ref_ROT)[2])};
1125 
1126  const auto& deltaTrans = target_ali[i].translation() - ref_ali[i].translation();
1127 
1128  // fill the histograms
1129  if (diff) {
1130  compare[AlignmentPI::t_x]->Fill(deltaTrans.x() * AlignmentPI::cmToUm);
1131  compare[AlignmentPI::t_y]->Fill(deltaTrans.y() * AlignmentPI::cmToUm);
1132  compare[AlignmentPI::t_z]->Fill(deltaTrans.z() * AlignmentPI::cmToUm);
1133 
1134  compare[AlignmentPI::rot_alpha]->Fill(deltaRot[0] * AlignmentPI::tomRad);
1135  compare[AlignmentPI::rot_beta]->Fill(deltaRot[1] * AlignmentPI::tomRad);
1136  compare[AlignmentPI::rot_gamma]->Fill(deltaRot[2] * AlignmentPI::tomRad);
1137  } else {
1138  compare[AlignmentPI::t_x]->SetBinContent(i + 1, deltaTrans.x() * AlignmentPI::cmToUm);
1139  compare[AlignmentPI::t_y]->SetBinContent(i + 1, deltaTrans.y() * AlignmentPI::cmToUm);
1140  compare[AlignmentPI::t_z]->SetBinContent(i + 1, deltaTrans.z() * AlignmentPI::cmToUm);
1141 
1142  compare[AlignmentPI::rot_alpha]->SetBinContent(i + 1, deltaRot[0] * AlignmentPI::tomRad);
1143  compare[AlignmentPI::rot_beta]->SetBinContent(i + 1, deltaRot[1] * AlignmentPI::tomRad);
1144  compare[AlignmentPI::rot_gamma]->SetBinContent(i + 1, deltaRot[2] * AlignmentPI::tomRad);
1145  }
1146 
1147  } // if it's the same detid
1148  } // loop on detids
1149  }
1150 
1151 } // namespace AlignmentPI
1152 
1153 #endif
AlignmentPI::TkAlBarycenters::getY
const std::array< double, 6 > getY()
Definition: AlignmentPayloadInspectorHelper.h:854
AlignmentPI::TkAlBarycenters::getNModules
const double getNModules(AlignmentPI::PARTITION p)
Definition: AlignmentPayloadInspectorHelper.h:835
StripSubdetector::TEC
static constexpr auto TEC
Definition: StripSubdetector.h:19
TrackerTopology::tibIsDoubleSide
bool tibIsDoubleSide(const DetId &id) const
Definition: TrackerTopology.h:249
TrackerTopology::tecIsDoubleSide
bool tecIsDoubleSide(const DetId &id) const
Definition: TrackerTopology.h:246
TrackerTopology::tidIsDoubleSide
bool tidIsDoubleSide(const DetId &id) const
Definition: TrackerTopology.h:250
TrackerTopology::tobLayer
unsigned int tobLayer(const DetId &id) const
Definition: TrackerTopology.h:147
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
TrackerTopology::tibSide
unsigned int tibSide(const DetId &id) const
Definition: TrackerTopology.h:186
AlignmentPI::fillComparisonHistogram
void fillComparisonHistogram(const AlignmentPI::coordinate &coord, std::vector< int > &boundaries, const std::vector< AlignTransform > &ref_ali, const std::vector< AlignTransform > &target_ali, std::unique_ptr< TH1F > &compare)
Definition: AlignmentPayloadInspectorHelper.h:995
mps_fire.i
i
Definition: mps_fire.py:429
TrackerTopology::tobSide
unsigned int tobSide(const DetId &id) const
Definition: TrackerTopology.h:180
AlignmentPI::trim2PIs
double trim2PIs(const double phi, const double tolerance=1.f)
Definition: AlignmentPayloadInspectorHelper.h:50
AlignmentPI::operator<<
std::ostream & operator<<(std::ostream &o, PARTITION x)
Definition: AlignmentPayloadInspectorHelper.h:99
TrackerTopology::tidModuleInfo
std::vector< unsigned int > tidModuleInfo(const DetId &id) const
Definition: TrackerTopology.h:434
AlignmentPI::makeNicePlotStyle
void makeNicePlotStyle(TH1 *hist, int color)
Definition: AlignmentPayloadInspectorHelper.h:712
AlignmentPI::TkAlBarycenters::computeBarycenters
void computeBarycenters(const std::vector< AlignTransform > &input, const TrackerTopology &tTopo, const std::map< AlignmentPI::coordinate, float > &GPR)
Definition: AlignmentPayloadInspectorHelper.h:887
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:631
TrackerTopology::tidSide
unsigned int tidSide(const DetId &id) const
Definition: TrackerTopology.h:190
tolerance
const double tolerance
Definition: HGCalGeomParameters.cc:29
TrackerTopology::tecPetalInfo
std::vector< unsigned int > tecPetalInfo(const DetId &id) const
Definition: TrackerTopology.h:407
TrackerTopology::tidWheel
unsigned int tidWheel(const DetId &id) const
Definition: TrackerTopology.h:201
TrackerTopology::tecWheel
unsigned int tecWheel(const DetId &id) const
Definition: TrackerTopology.h:198
AlignmentPI::PARTITIONS
const PARTITION PARTITIONS[(int) PARTITION::LAST+1]
Definition: AlignmentPayloadInspectorHelper.h:89
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
SiPixelRawToDigiRegional_cfi.deltaPhi
deltaPhi
Definition: SiPixelRawToDigiRegional_cfi.py:9
AlignmentPI::getStringFromPart
std::string getStringFromPart(AlignmentPI::partitions i)
Definition: AlignmentPayloadInspectorHelper.h:668
AlignmentPI::isBPixOuterLadder
bool isBPixOuterLadder(const DetId &detid, const TrackerTopology &tTopo, bool isPhase0)
Definition: AlignmentPayloadInspectorHelper.h:330
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
TrackerTopology::isRPhi
bool isRPhi(const DetId &id) const
Definition: TrackerTopology.cc:177
TrackerTopology::pxbLadder
unsigned int pxbLadder(const DetId &id) const
Definition: TrackerTopology.h:155
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
cms::cuda::assert
assert(be >=bs)
TrackerTopology::tecRing
unsigned int tecRing(const DetId &id) const
ring id
Definition: TrackerTopology.h:217
TrackerTopology::tobIsDoubleSide
bool tobIsDoubleSide(const DetId &id) const
Definition: TrackerTopology.h:245
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
AlignmentPI::cmToUm
static const float cmToUm
Definition: AlignmentPayloadInspectorHelper.h:34
input
static std::string const input
Definition: EdmProvDump.cc:50
AlignmentPI::makeNiceStats
void makeNiceStats(TH1F *hist, AlignmentPI::partitions part, int color)
Definition: AlignmentPayloadInspectorHelper.h:737
AlignmentPI::fillComparisonHistograms
void fillComparisonHistograms(std::vector< int > &boundaries, const std::vector< AlignTransform > &ref_ali, const std::vector< AlignTransform > &target_ali, std::unordered_map< AlignmentPI::coordinate, std::unique_ptr< TH1F > > &compare, bool diff=false, AlignmentPI::partitions checkPart=AlignmentPI::INVALID)
Definition: AlignmentPayloadInspectorHelper.h:1072
AlignmentPI::TkAlBarycenters::getX
const std::array< double, 6 > getX()
Definition: AlignmentPayloadInspectorHelper.h:842
AlignmentPI::phase0size
static const unsigned int phase0size
Definition: AlignmentPayloadInspectorHelper.h:33
EcalTangentSkim_cfg.o
o
Definition: EcalTangentSkim_cfg.py:42
TrackerTopology::tecSide
unsigned int tecSide(const DetId &id) const
Definition: TrackerTopology.h:184
AlignmentPI::tomRad
static const float tomRad
Definition: AlignmentPayloadInspectorHelper.h:35
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:80
AlignmentPI::topolInfo::fillGeometryInfo
void fillGeometryInfo(const DetId &detId, const TrackerTopology &tTopo, bool isPhase0)
Definition: AlignmentPayloadInspectorHelper.h:407
TrackerTopology::pxfDisk
unsigned int pxfDisk(const DetId &id) const
Definition: TrackerTopology.h:446
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
AlignmentPI::returnZeroIfNear2PI
double returnZeroIfNear2PI(const double phi)
Definition: AlignmentPayloadInspectorHelper.h:39
f
double f[11][100]
Definition: MuScleFitUtils.cc:78
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:48
change_name.diff
diff
Definition: change_name.py:13
value
Definition: value.py:1
AlignmentPI::TkAlBarycenters::Zbarycenters
std::map< AlignmentPI::PARTITION, double > Zbarycenters
Definition: AlignmentPayloadInspectorHelper.h:826
align::toAngles
EulerAngles toAngles(const RotationType &)
Convert rotation matrix to angles about x-, y-, z-axes (frame rotation).
Definition: Utilities.cc:8
StripSubdetector::TOB
static constexpr auto TOB
Definition: StripSubdetector.h:18
AlignmentPI::getIndices
std::pair< int, int > getIndices(AlignmentPI::index i)
Definition: AlignmentPayloadInspectorHelper.h:690
cms_rounding::roundIfNear0
constexpr valType roundIfNear0(valType value, double tolerance=1.e-7)
Definition: Rounding.h:11
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50
AlignmentPI::getTheRange
std::pair< float, float > getTheRange(std::map< uint32_t, float > values, const float nsigma)
Definition: AlignmentPayloadInspectorHelper.h:770
AlignmentPI::TkAlBarycenters::getPartitionAvg
GlobalPoint getPartitionAvg(AlignmentPI::PARTITION p)
Definition: AlignmentPayloadInspectorHelper.h:880
DetId
Definition: DetId.h:17
TrackerTopology::pxfSide
unsigned int pxfSide(const DetId &id) const
Definition: TrackerTopology.h:192
StripSubdetector::TIB
static constexpr auto TIB
Definition: StripSubdetector.h:16
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
AlignmentPI::getStringFromCoordinate
std::string getStringFromCoordinate(AlignmentPI::coordinate coord)
Definition: AlignmentPayloadInspectorHelper.h:624
part
part
Definition: HCALResponse.h:20
AlignmentPI::topolInfo::filterThePartition
AlignmentPI::regions filterThePartition()
Definition: AlignmentPayloadInspectorHelper.h:454
TrackerTopology::tibIsInternalString
bool tibIsInternalString(const DetId &id) const
Definition: TrackerTopology.h:429
AlignmentPI::getStringFromIndex
std::string getStringFromIndex(AlignmentPI::index i)
Definition: AlignmentPayloadInspectorHelper.h:646
AlignmentPI::TkAlBarycenters::Ybarycenters
std::map< AlignmentPI::PARTITION, double > Ybarycenters
Definition: AlignmentPayloadInspectorHelper.h:825
AlignmentPI::calculatePosition
std::pair< double, double > calculatePosition(TVirtualPad *myPad, int boundary)
Definition: AlignmentPayloadInspectorHelper.h:795
AlignmentPI::TkAlBarycenters::nmodules
std::map< AlignmentPI::PARTITION, double > nmodules
Definition: AlignmentPayloadInspectorHelper.h:827
x
float x
Definition: beamSpotDipStandalone.cc:55
TrackerTopology::tidRing
unsigned int tidRing(const DetId &id) const
Definition: TrackerTopology.h:218
plotscripts.stdev
def stdev(xlist)
Definition: plotscripts.py:69
AlignmentPI::TkAlBarycenters::Xbarycenters
std::map< AlignmentPI::PARTITION, double > Xbarycenters
Definition: AlignmentPayloadInspectorHelper.h:824
gather_cfg.cout
cout
Definition: gather_cfg.py:144
TrackerTopology::tibLayer
unsigned int tibLayer(const DetId &id) const
Definition: TrackerTopology.h:150
AlignmentPI::getStringFromRegionEnum
std::string getStringFromRegionEnum(AlignmentPI::regions e)
Definition: AlignmentPayloadInspectorHelper.h:179
TrackerTopology::tobModule
unsigned int tobModule(const DetId &id) const
Definition: TrackerTopology.h:166
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
AlignmentPI::TkAlBarycenters::getZ
const std::array< double, 6 > getZ()
Definition: AlignmentPayloadInspectorHelper.h:866
StripSubdetector::TID
static constexpr auto TID
Definition: StripSubdetector.h:17
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
Generated for CMSSW Reference Manual by doxygen 1.8.14