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