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