CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Static Public Attributes
HGCalWaferMask Class Reference

#include <HGCalWaferMask.h>

Public Member Functions

 HGCalWaferMask ()=default
 

Static Public Member Functions

static int getRotation (int zside, int type, int rotn)
 
static std::pair< int, int > getTypeMode (const double &xpos, const double &ypos, const double &delX, const double &delY, const double &rin, const double &rout, const int &waferType, const int &mode, bool deug=false)
 
static bool goodCell (int u, int v, int N, int type, int rotn)
 
static bool goodTypeMode (double xpos, double ypos, double delX, double delY, double rin, double rout, int part, int rotn, bool debug)
 
static bool maskCell (int u, int v, int N, int ncor, int fcor, int corners)
 
static std::vector< std::pair< double, double > > waferXY (int part, int orient, int zside, double delX, double delY, double xpos, double ypos)
 

Static Public Attributes

static constexpr int k_OffsetRotation = 10
 

Detailed Description

this class determines the masking of wafers to mimic partial wafers

Date
2019/01/15 00:06:50
Author
Sunanda Banerjee, Fermilab sunan.nosp@m.da.b.nosp@m.anerj.nosp@m.ee@c.nosp@m.ern.c.nosp@m.h

Definition at line 16 of file HGCalWaferMask.h.

Constructor & Destructor Documentation

◆ HGCalWaferMask()

HGCalWaferMask::HGCalWaferMask ( )
default

Member Function Documentation

◆ getRotation()

int HGCalWaferMask::getRotation ( int  zside,
int  type,
int  rotn 
)
static

Definition at line 339 of file HGCalWaferMask.cc.

339  {
340  if (rotn >= HGCalTypes::WaferCornerMax)
341  rotn = HGCalTypes::WaferCorner0;
342  int newrotn(rotn);
343  if ((zside < 0) && (type != HGCalTypes::WaferFull)) {
344  if (type == HGCalTypes::WaferFive) { //WaferFive
345  static constexpr int rot1[HGCalTypes::WaferCornerMax] = {HGCalTypes::WaferCorner4,
346  HGCalTypes::WaferCorner3,
347  HGCalTypes::WaferCorner2,
348  HGCalTypes::WaferCorner1,
349  HGCalTypes::WaferCorner0,
350  HGCalTypes::WaferCorner5};
351  newrotn = rot1[rotn];
352  } else if ((type == HGCalTypes::WaferThree) || (type == HGCalTypes::WaferSemi) ||
353  (type == HGCalTypes::WaferSemi2)) { //WaferThree/WaferSemi/WaferSemi2
354  static constexpr int rot2[HGCalTypes::WaferCornerMax] = {HGCalTypes::WaferCorner2,
355  HGCalTypes::WaferCorner1,
356  HGCalTypes::WaferCorner0,
357  HGCalTypes::WaferCorner5,
358  HGCalTypes::WaferCorner4,
359  HGCalTypes::WaferCorner3};
360  newrotn = rot2[rotn];
361  } else { //WaferHalf/WaferChopTwo/WaferChopTwoM
362  static constexpr int rot3[HGCalTypes::WaferCornerMax] = {HGCalTypes::WaferCorner3,
363  HGCalTypes::WaferCorner2,
364  HGCalTypes::WaferCorner1,
365  HGCalTypes::WaferCorner0,
366  HGCalTypes::WaferCorner5,
367  HGCalTypes::WaferCorner4};
368  newrotn = rot3[rotn];
369  }
370  }
371 #ifdef EDM_ML_DEBUG
372  edm::LogVerbatim("HGCalGeom") << "zside " << zside << " type " << type << " rotn " << rotn << ":" << newrotn;
373 #endif
374  return newrotn;
375 }

References HGCalTypes::WaferCorner0, HGCalTypes::WaferCorner1, HGCalTypes::WaferCorner2, HGCalTypes::WaferCorner3, HGCalTypes::WaferCorner4, HGCalTypes::WaferCorner5, HGCalTypes::WaferCornerMax, HGCalTypes::WaferFive, HGCalTypes::WaferFull, HGCalTypes::WaferSemi, HGCalTypes::WaferSemi2, HGCalTypes::WaferThree, and ecaldqm::zside().

Referenced by HGCalGeomParameters::loadSpecParsHexagon8(), and waferXY().

◆ getTypeMode()

std::pair< int, int > HGCalWaferMask::getTypeMode ( const double &  xpos,
const double &  ypos,
const double &  delX,
const double &  delY,
const double &  rin,
const double &  rout,
const int &  waferType,
const int &  mode,
bool  deug = false 
)
static

Definition at line 377 of file HGCalWaferMask.cc.

385  {
386  int ncor(0), iok(0);
387  int type(HGCalTypes::WaferFull), rotn(HGCalTypes::WaferCorner0);
388 
389  static constexpr int corners = 6;
390  static constexpr int base = 10;
391  double rin2 = rin * rin;
392  double rout2 = rout * rout;
393  double dx0[corners] = {
394  0.0, HGCalTypes::c10 * delX, HGCalTypes::c10 * delX, 0.0, -HGCalTypes::c10 * delX, -HGCalTypes::c10 * delX};
395  double dy0[corners] = {-HGCalTypes::c10 * delY,
396  -HGCalTypes::c50 * delY,
397  HGCalTypes::c50 * delY,
398  HGCalTypes::c10 * delY,
399  HGCalTypes::c50 * delY,
400  -HGCalTypes::c50 * delY};
401  double xc[corners], yc[corners];
402  for (int k = 0; k < corners; ++k) {
403  xc[k] = xpos + dx0[k];
404  yc[k] = ypos + dy0[k];
405  double rpos2 = (xc[k] * xc[k] + yc[k] * yc[k]);
406  if (rpos2 <= rout2 && rpos2 >= rin2) {
407  ++ncor;
408  iok = iok * base + 1;
409  } else {
410  iok *= base;
411  }
412  }
413  if (debug)
414  edm::LogVerbatim("HGCalGeom") << "I/p " << xpos << ":" << ypos << ":" << delX << ":" << delY << ":" << rin << ":"
415  << rout << ":" << wType << ":" << mode << " Corners " << ncor << " iok " << iok;
416 
417  static constexpr int ipat5[corners] = {101111, 110111, 111011, 111101, 111110, 11111};
418  static constexpr int ipat4[corners] = {100111, 110011, 111001, 111100, 11110, 1111};
419  static constexpr int ipat3[corners] = {100011, 110001, 111000, 11100, 1110, 111};
420  double dx1[corners] = {HGCalTypes::c50 * delX,
421  HGCalTypes::c10 * delX,
422  HGCalTypes::c50 * delX,
423  -HGCalTypes::c50 * delX,
424  -HGCalTypes::c10 * delX,
425  -HGCalTypes::c50 * delX};
426  double dy1[corners] = {
427  -HGCalTypes::c75 * delY, 0.0, HGCalTypes::c75 * delY, HGCalTypes::c75 * delY, 0.0, -HGCalTypes::c75 * delY};
428  double dx2[corners] = {HGCalTypes::c50 * delX,
429  -HGCalTypes::c50 * delX,
430  -HGCalTypes::c10 * delX,
431  -HGCalTypes::c50 * delX,
432  HGCalTypes::c50 * delX,
433  HGCalTypes::c10 * delX};
434  double dy2[corners] = {
435  HGCalTypes::c75 * delY, HGCalTypes::c75 * delY, 0.0, -HGCalTypes::c75 * delY, -HGCalTypes::c75 * delY, 0.0};
436  double dx3[corners] = {
437  HGCalTypes::c22 * delX, delX, HGCalTypes::c77 * delX, -HGCalTypes::c22 * delX, -delX, -HGCalTypes::c77 * delX};
438  double dy3[corners] = {-HGCalTypes::c88 * delY,
439  -HGCalTypes::c27 * delY,
440  HGCalTypes::c61 * delY,
441  HGCalTypes::c88 * delY,
442  HGCalTypes::c27 * delY,
443  -HGCalTypes::c61 * delY};
444  double dx4[corners] = {HGCalTypes::c22 * delX,
445  -HGCalTypes::c77 * delX,
446  -delX,
447  -HGCalTypes::c22 * delX,
448  HGCalTypes::c77 * delX,
449  HGCalTypes::c10 * delX};
450  double dy4[corners] = {HGCalTypes::c88 * delY,
451  HGCalTypes::c61 * delY,
452  -HGCalTypes::c27 * delY,
453  -HGCalTypes::c88 * delY,
454  -HGCalTypes::c61 * delY,
455  HGCalTypes::c27 * delY};
456  double dx5[corners] = {-HGCalTypes::c50 * delX,
457  -HGCalTypes::c10 * delX,
458  -HGCalTypes::c50 * delX,
459  HGCalTypes::c50 * delX,
460  HGCalTypes::c10 * delX,
461  HGCalTypes::c50 * delX};
462  double dy5[corners] = {
463  HGCalTypes::c75 * delY, 0.0, -HGCalTypes::c75 * delY, -HGCalTypes::c75 * delY, 0.0, HGCalTypes::c75 * delY};
464  double dx6[corners] = {-HGCalTypes::c77 * delX,
465  -HGCalTypes::c10 * delX,
466  -HGCalTypes::c22 * delX,
467  HGCalTypes::c77 * delX,
468  HGCalTypes::c10 * delX,
469  HGCalTypes::c22 * delX};
470  double dy6[corners] = {HGCalTypes::c61 * delY,
471  -HGCalTypes::c27 * delY,
472  -HGCalTypes::c88 * delY,
473  -HGCalTypes::c61 * delY,
474  HGCalTypes::c27 * delY,
475  HGCalTypes::c88 * delY};
476 
477  if (ncor == HGCalGeomTools::k_allCorners) {
478  } else if (ncor == HGCalGeomTools::k_fiveCorners) {
479  rotn = static_cast<int>(std::find(ipat5, ipat5 + 6, iok) - ipat5);
480  type = HGCalTypes::WaferFive;
481  } else if (ncor == HGCalGeomTools::k_fourCorners) {
482  rotn = static_cast<int>(std::find(ipat4, ipat4 + 6, iok) - ipat4);
483  type = HGCalTypes::WaferHalf;
484  double rpos12 = ((xpos + dx1[rotn]) * (xpos + dx1[rotn]) + (ypos + dy1[rotn]) * (ypos + dy1[rotn]));
485  double rpos22(0);
486  if (rpos12 <= rout2 && rpos12 >= rin2) {
487  rpos22 = ((xpos + dx2[rotn]) * (xpos + dx2[rotn]) + (ypos + dy2[rotn]) * (ypos + dy2[rotn]));
488  if (rpos22 <= rout2 && rpos22 >= rin2)
489  type = HGCalTypes::WaferChopTwo;
490  }
491  if (debug)
492  edm::LogVerbatim("HGCalGeom") << "Test for Chop2 " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
493  << type;
494  if ((type == HGCalTypes::WaferHalf) && (wType == 0)) {
495  rpos12 = ((xpos + dx3[rotn]) * (xpos + dx3[rotn]) + (ypos + dy3[rotn]) * (ypos + dy3[rotn]));
496  if (rpos12 <= rout2 && rpos12 >= rin2) {
497  rpos22 = ((xpos + dx4[rotn]) * (xpos + dx4[rotn]) + (ypos + dy4[rotn]) * (ypos + dy4[rotn]));
498  if (rpos22 <= rout2 && rpos22 >= rin2)
499  type = HGCalTypes::WaferChopTwoM;
500  }
501  if (debug)
502  edm::LogVerbatim("HGCalGeom") << "Test for Chop2M " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
503  << type;
504  }
505  } else if (ncor == HGCalGeomTools::k_threeCorners) {
506  rotn = static_cast<int>(std::find(ipat3, ipat3 + 6, iok) - ipat3);
507  type = HGCalTypes::WaferThree;
508  double rpos12 = ((xpos + dx1[rotn]) * (xpos + dx1[rotn]) + (ypos + dy1[rotn]) * (ypos + dy1[rotn]));
509  double rpos22(0);
510  if (rpos12 <= rout2 && rpos12 >= rin2) {
511  rpos22 = ((xpos + dx5[rotn]) * (xpos + dx5[rotn]) + (ypos + dy5[rotn]) * (ypos + dy5[rotn]));
512  if (rpos22 <= rout2 && rpos22 >= rin2)
513  type = HGCalTypes::WaferSemi;
514  }
515  if (debug)
516  edm::LogVerbatim("HGCalGeom") << "Test for Semi " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
517  << type;
518  if ((type == HGCalTypes::WaferThree) && (wType == 0)) {
519  rpos12 = ((xpos + dx3[rotn]) * (xpos + dx3[rotn]) + (ypos + dy3[rotn]) * (ypos + dy3[rotn]));
520  if (rpos12 <= rout2 && rpos12 >= rin2) {
521  rpos22 = ((xpos + dx6[rotn]) * (xpos + dx6[rotn]) + (ypos + dy6[rotn]) * (ypos + dy6[rotn]));
522  if (rpos22 <= rout2 && rpos22 >= rin2)
523  type = HGCalTypes::WaferSemi2;
524  }
525  if (debug)
526  edm::LogVerbatim("HGCalGeom") << "Test for SemiM " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
527  << type;
528  }
529  } else {
530  type = HGCalTypes::WaferOut;
531  }
532 
533  if (debug)
534  edm::LogVerbatim("HGCalGeom") << "I/p " << xpos << ":" << ypos << ":" << delX << ":" << delY << ":" << rin << ":"
535  << rout << ":" << wType << ":" << mode << " o/p " << iok << ":" << ncor << ":" << type
536  << ":" << rotn;
537  return ((mode == 0) ? std::make_pair(ncor, rotn) : std::make_pair(type, (rotn + HGCalWaferMask::k_OffsetRotation)));
538 }

References newFWLiteAna::base, HGCalTypes::c10, HGCalTypes::c22, HGCalTypes::c27, HGCalTypes::c50, HGCalTypes::c61, HGCalTypes::c75, HGCalTypes::c77, HGCalTypes::c88, debug, spr::find(), dqmdumpme::k, HGCalGeomTools::k_allCorners, HGCalGeomTools::k_fiveCorners, HGCalGeomTools::k_fourCorners, k_OffsetRotation, HGCalGeomTools::k_threeCorners, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, mathSSE::sqrt(), HGCalTypes::WaferChopTwo, HGCalTypes::WaferChopTwoM, HGCalTypes::WaferCorner0, HGCalTypes::WaferFive, HGCalTypes::WaferFull, HGCalTypes::WaferHalf, HGCalTypes::WaferOut, HGCalTypes::WaferSemi, HGCalTypes::WaferSemi2, and HGCalTypes::WaferThree.

Referenced by HGCalGeomParameters::loadWaferHexagon8().

◆ goodCell()

bool HGCalWaferMask::goodCell ( int  u,
int  v,
int  N,
int  type,
int  rotn 
)
static

Definition at line 108 of file HGCalWaferMask.cc.

108  {
109  bool good(false);
110  int n2 = n / 2;
111  int n4 = n / 4;
112  switch (type) {
113  case (HGCalTypes::WaferFull): { //WaferFull
114  good = true;
115  break;
116  }
117  case (HGCalTypes::WaferFive): { //WaferFive
118  switch (rotn) {
119  case (HGCalTypes::WaferCorner0): {
120  int u2 = u / 2;
121  good = ((v - u2) < n);
122  break;
123  }
124  case (HGCalTypes::WaferCorner1): {
125  good = ((v + u) < (3 * n - 1));
126  break;
127  }
128  case (HGCalTypes::WaferCorner2): {
129  int v2 = (v + 1) / 2;
130  good = ((u - v2) < n);
131  break;
132  }
133  case (HGCalTypes::WaferCorner3): {
134  int u2 = (u + 1) / 2;
135  good = (u2 <= v);
136  break;
137  }
138  case (HGCalTypes::WaferCorner4): {
139  good = ((v + u) >= n);
140  break;
141  }
142  default: {
143  int v2 = v / 2;
144  good = (u > v2);
145  break;
146  }
147  }
148  break;
149  }
150  case (HGCalTypes::WaferChopTwo): { //WaferChopTwo
151  switch (rotn) {
152  case (HGCalTypes::WaferCorner0): {
153  good = (v < (3 * n2));
154  break;
155  }
156  case (HGCalTypes::WaferCorner1): {
157  good = (u < (3 * n2));
158  break;
159  }
160  case (HGCalTypes::WaferCorner2): {
161  good = ((u - v) <= n2);
162  break;
163  }
164  case (HGCalTypes::WaferCorner3): {
165  good = (v >= n2);
166  break;
167  }
168  case (HGCalTypes::WaferCorner4): {
169  good = (u >= n2);
170  break;
171  }
172  default: {
173  good = ((v - u) < n2);
174  break;
175  }
176  }
177  break;
178  }
179  case (HGCalTypes::WaferChopTwoM): { //WaferChopTwoM
180  switch (rotn) {
181  case (HGCalTypes::WaferCorner0): {
182  good = (v < (5 * n4));
183  break;
184  }
185  case (HGCalTypes::WaferCorner1): {
186  good = (u < (5 * n4));
187  break;
188  }
189  case (HGCalTypes::WaferCorner2): {
190  good = ((u - v) <= n4);
191  break;
192  }
193  case (HGCalTypes::WaferCorner3): {
194  good = (v >= (3 * n4));
195  break;
196  }
197  case (HGCalTypes::WaferCorner4): {
198  good = (u >= (3 * n4));
199  break;
200  }
201  default: {
202  good = ((v - u) < n4);
203  break;
204  }
205  }
206  break;
207  }
208  case (HGCalTypes::WaferHalf): { //WaferHalf
209  switch (rotn) {
210  case (HGCalTypes::WaferCorner0): {
211  good = (v < n);
212  break;
213  }
214  case (HGCalTypes::WaferCorner1): {
215  good = (u < n);
216  break;
217  }
218  case (HGCalTypes::WaferCorner2): {
219  good = (v >= u);
220  break;
221  }
222  case (HGCalTypes::WaferCorner3): {
223  good = (v >= n);
224  break;
225  }
226  case (HGCalTypes::WaferCorner4): {
227  good = (u >= n);
228  break;
229  }
230  default: {
231  good = (u > v);
232  break;
233  }
234  }
235  break;
236  }
237  case (HGCalTypes::WaferSemi): { //WaferSemi
238  switch (rotn) {
239  case (HGCalTypes::WaferCorner0): {
240  good = ((u + v) < (2 * n));
241  break;
242  }
243  case (HGCalTypes::WaferCorner1): {
244  good = ((2 * u - v) < n);
245  break;
246  }
247  case (HGCalTypes::WaferCorner2): {
248  good = ((2 * v - u) >= n);
249  break;
250  }
251  case (HGCalTypes::WaferCorner3): {
252  good = ((u + v) >= (2 * n));
253  break;
254  }
255  case (HGCalTypes::WaferCorner4): {
256  good = ((2 * u - v) > n);
257  break;
258  }
259  default: {
260  good = ((2 * v - u) < n);
261  break;
262  }
263  }
264  break;
265  }
266  case (HGCalTypes::WaferThree): { //WaferThree
267  switch (rotn) {
268  case (HGCalTypes::WaferCorner0): {
269  good = ((v + u) < n);
270  break;
271  }
272  case (HGCalTypes::WaferCorner1): {
273  int v2 = v / 2;
274  good = (u <= v2);
275  break;
276  }
277  case (HGCalTypes::WaferCorner2): {
278  int u2 = (u / 2);
279  good = ((v - u2) >= n);
280  break;
281  }
282  case (HGCalTypes::WaferCorner3): {
283  good = ((v + u) >= (3 * n - 1));
284  break;
285  }
286  case (HGCalTypes::WaferCorner4): {
287  int v2 = ((v + 1) / 2);
288  good = ((u - v2) >= n);
289  break;
290  }
291  default: {
292  int u2 = ((u + 1) / 2);
293  good = (v < u2);
294  break;
295  }
296  }
297  break;
298  }
299  case (HGCalTypes::WaferSemi2): { //WaferSemi2
300  switch (rotn) {
301  case (HGCalTypes::WaferCorner0): {
302  int n3 = (n + 1) / 3;
303  good = ((u + v) < (4 * n3));
304  break;
305  }
306  case (HGCalTypes::WaferCorner1): {
307  good = ((2 * u - v) < n2);
308  break;
309  }
310  case (HGCalTypes::WaferCorner2): {
311  int u2 = ((u + 1) / 2);
312  good = ((v - u2) >= (3 * n4));
313  break;
314  }
315  case (HGCalTypes::WaferCorner3): {
316  good = ((u + v) >= (5 * n2));
317  break;
318  }
319  case (HGCalTypes::WaferCorner4): {
320  good = ((2 * u - v) > (3 * n2));
321  break;
322  }
323  default: {
324  int u2 = ((n == 8) ? ((u + 1) / 2) : (u / 2));
325  good = ((v - u2) < n4);
326  break;
327  }
328  }
329  break;
330  }
331  }
332 #ifdef EDM_ML_DEBUG
333  edm::LogVerbatim("HGCalGeom") << "u|v " << u << ":" << v << " N " << n << " type " << type << " rot " << rotn
334  << " good " << good;
335 #endif
336  return good;
337 }

References dqmiodumpmetadata::n, MetAnalyzer::u2, findQualityFiles::v, HGCalTypes::WaferChopTwo, HGCalTypes::WaferChopTwoM, HGCalTypes::WaferCorner0, HGCalTypes::WaferCorner1, HGCalTypes::WaferCorner2, HGCalTypes::WaferCorner3, HGCalTypes::WaferCorner4, HGCalTypes::WaferFive, HGCalTypes::WaferFull, HGCalTypes::WaferHalf, HGCalTypes::WaferSemi, HGCalTypes::WaferSemi2, and HGCalTypes::WaferThree.

Referenced by HGCalDDDConstants::isValidCell8(), and HGCalDDDConstants::maskCell().

◆ goodTypeMode()

bool HGCalWaferMask::goodTypeMode ( double  xpos,
double  ypos,
double  delX,
double  delY,
double  rin,
double  rout,
int  part,
int  rotn,
bool  debug 
)
static

Definition at line 540 of file HGCalWaferMask.cc.

541  {
542  if (part < 0 || part > HGCalTypes::WaferSizeMax)
543  return false;
544  if (rotn < 0 || rotn > HGCalTypes::WaferCornerMax)
545  return false;
546  double rin2 = rin * rin;
547  double rout2 = rout * rout;
548  static constexpr int corners = HGCalTypes::WaferCornerMax;
549  static constexpr int corner2 = 2 * HGCalTypes::WaferCornerMax;
550  static constexpr int base = 10;
551  static constexpr int base2 = 100;
552  double dx0[corners] = {
553  0.0, HGCalTypes::c10 * delX, HGCalTypes::c10 * delX, 0.0, -HGCalTypes::c10 * delX, -HGCalTypes::c10 * delX};
554  double dy0[corners] = {-HGCalTypes::c10 * delY,
555  -HGCalTypes::c50 * delY,
556  HGCalTypes::c50 * delY,
557  HGCalTypes::c10 * delY,
558  HGCalTypes::c50 * delY,
559  -HGCalTypes::c50 * delY};
560  double dx1[corners] = {HGCalTypes::c50 * delX,
561  HGCalTypes::c10 * delX,
562  HGCalTypes::c50 * delX,
563  -HGCalTypes::c50 * delX,
564  -HGCalTypes::c10 * delX,
565  -HGCalTypes::c50 * delX};
566  double dy1[corners] = {
567  -HGCalTypes::c75 * delY, 0.0, HGCalTypes::c75 * delY, HGCalTypes::c75 * delY, 0.0, -HGCalTypes::c75 * delY};
568  double dx2[corner2] = {HGCalTypes::c22 * delX,
569  HGCalTypes::c77 * delX,
570  HGCalTypes::c10 * delX,
571  HGCalTypes::c10 * delX,
572  HGCalTypes::c77 * delX,
573  HGCalTypes::c22 * delX,
574  -HGCalTypes::c22 * delX,
575  -HGCalTypes::c77 * delX,
576  -HGCalTypes::c10 * delX,
577  -HGCalTypes::c10 * delX,
578  -HGCalTypes::c77 * delX,
579  -HGCalTypes::c22 * delX};
580  double dy2[corner2] = {-HGCalTypes::c88 * delY,
581  -HGCalTypes::c61 * delY,
582  -HGCalTypes::c27 * delY,
583  HGCalTypes::c27 * delY,
584  HGCalTypes::c61 * delY,
585  HGCalTypes::c88 * delY,
586  HGCalTypes::c88 * delY,
587  HGCalTypes::c61 * delY,
588  HGCalTypes::c27 * delY,
589  -HGCalTypes::c27 * delY,
590  -HGCalTypes::c61 * delY,
591  -HGCalTypes::c88 * delY};
592  bool ok(true);
593  int ncf(-1);
594  switch (part) {
595  case (HGCalTypes::WaferThree): {
596  static constexpr int nc0[corners] = {450, 150, 201, 312, 423, 534};
597  int nc = nc0[rotn];
598  for (int k1 = 0; k1 < 3; ++k1) {
599  int k = nc % base;
600  double xc1 = xpos + dx0[k];
601  double yc1 = ypos + dy0[k];
602  double rpos2 = (xc1 * xc1 + yc1 * yc1);
603  if ((rpos2 > rout2) || (rpos2 < rin2)) {
604  ok = false;
605  ncf = k;
606  break;
607  }
608  nc /= base;
609  }
610  break;
611  }
612  case (HGCalTypes::WaferSemi2): {
613  static constexpr int nc10[corners] = {450, 150, 201, 312, 423, 534};
614  static constexpr int nc11[corners] = {700, 902, 1104, 106, 308, 510};
615  int nc = nc10[rotn];
616  for (int k1 = 0; k1 < 3; ++k1) {
617  int k = nc % base;
618  double xc1 = xpos + dx0[k];
619  double yc1 = ypos + dy0[k];
620  double rpos2 = (xc1 * xc1 + yc1 * yc1);
621  if ((rpos2 > rout2) || (rpos2 < rin2)) {
622  ok = false;
623  ncf = k;
624  break;
625  }
626  nc /= base;
627  }
628  nc = nc11[rotn];
629  for (int k1 = 0; k1 < 2; ++k1) {
630  int k = nc % base2;
631  double xc1 = xpos + dx2[k];
632  double yc1 = ypos + dy2[k];
633  double rpos2 = (xc1 * xc1 + yc1 * yc1);
634  if ((rpos2 > rout2) || (rpos2 < rin2)) {
635  ok = false;
636  ncf = k + base2;
637  break;
638  }
639  nc /= base2;
640  }
641  break;
642  }
643  case (HGCalTypes::WaferSemi): {
644  static constexpr int nc20[corners] = {450, 150, 201, 312, 423, 534};
645  static constexpr int nc21[corners] = {30, 14, 25, 30, 41, 52};
646  int nc = nc20[rotn];
647  for (int k1 = 0; k1 < 3; ++k1) {
648  int k = nc % base;
649  double xc1 = xpos + dx0[k];
650  double yc1 = ypos + dy0[k];
651  double rpos2 = (xc1 * xc1 + yc1 * yc1);
652  if ((rpos2 > rout2) || (rpos2 < rin2)) {
653  ok = false;
654  ncf = k;
655  break;
656  }
657  nc /= base;
658  }
659  nc = nc21[rotn];
660  for (int k1 = 0; k1 < 2; ++k1) {
661  int k = nc % base;
662  double xc1 = xpos + dx1[k];
663  double yc1 = ypos + dy1[k];
664  double rpos2 = (xc1 * xc1 + yc1 * yc1);
665  if ((rpos2 > rout2) || (rpos2 < rin2)) {
666  ok = false;
667  ncf = k + base2;
668  break;
669  }
670  nc /= base;
671  }
672  break;
673  }
674  case (HGCalTypes::WaferHalf): {
675  static constexpr int nc3[corners] = {3450, 1450, 2501, 3012, 4123, 5234};
676  int nc = nc3[rotn];
677  for (int k1 = 0; k1 < 4; ++k1) {
678  int k = nc % base;
679  double xc1 = xpos + dx0[k];
680  double yc1 = ypos + dy0[k];
681  double rpos2 = (xc1 * xc1 + yc1 * yc1);
682  if ((rpos2 > rout2) || (rpos2 < rin2)) {
683  ok = false;
684  ncf = k;
685  break;
686  }
687  nc /= base;
688  }
689  break;
690  }
691  case (HGCalTypes::WaferChopTwoM): {
692  static constexpr int nc40[corners] = {3450, 1450, 2501, 3012, 4123, 5234};
693  static constexpr int nc41[corners] = {500, 702, 904, 1106, 108, 310};
694  int nc = nc40[rotn];
695  for (int k1 = 0; k1 < 4; ++k1) {
696  int k = nc % base;
697  double xc1 = xpos + dx0[k];
698  double yc1 = ypos + dy0[k];
699  double rpos2 = (xc1 * xc1 + yc1 * yc1);
700  if ((rpos2 > rout2) || (rpos2 < rin2)) {
701  ok = false;
702  ncf = k;
703  break;
704  }
705  nc /= base;
706  }
707  nc = nc41[rotn];
708  for (int k1 = 0; k1 < 2; ++k1) {
709  int k = nc % base2;
710  double xc1 = xpos + dx2[k];
711  double yc1 = ypos + dy2[k];
712  double rpos2 = (xc1 * xc1 + yc1 * yc1);
713  if ((rpos2 > rout2) || (rpos2 < rin2)) {
714  ok = false;
715  ncf = k + base2;
716  break;
717  }
718  nc /= base2;
719  }
720  break;
721  }
722  case (HGCalTypes::WaferChopTwo): {
723  static constexpr int nc50[corners] = {3450, 1450, 2501, 3012, 4123, 5234};
724  static constexpr int nc51[corners] = {20, 13, 24, 35, 40, 51};
725  int nc = nc50[rotn];
726  for (int k1 = 0; k1 < 4; ++k1) {
727  int k = nc % base;
728  double xc1 = xpos + dx0[k];
729  double yc1 = ypos + dy0[k];
730  double rpos2 = (xc1 * xc1 + yc1 * yc1);
731  if ((rpos2 > rout2) || (rpos2 < rin2)) {
732  ok = false;
733  ncf = k;
734  break;
735  }
736  nc /= base;
737  }
738  nc = nc51[rotn];
739  for (int k1 = 0; k1 < 2; ++k1) {
740  int k = nc % base;
741  double xc1 = xpos + dx1[k];
742  double yc1 = ypos + dy1[k];
743  double rpos2 = (xc1 * xc1 + yc1 * yc1);
744  if ((rpos2 > rout2) || (rpos2 < rin2)) {
745  ok = false;
746  ncf = k + base2;
747  break;
748  }
749  nc /= base;
750  }
751  break;
752  }
753  case (HGCalTypes::WaferFive): {
754  static constexpr int nc6[corners] = {23450, 13450, 24501, 35012, 40123, 51234};
755  int nc = nc6[rotn];
756  for (int k1 = 0; k1 < 5; ++k1) {
757  int k = nc % base;
758  double xc1 = xpos + dx0[k];
759  double yc1 = ypos + dy0[k];
760  double rpos2 = (xc1 * xc1 + yc1 * yc1);
761  if ((rpos2 > rout2) || (rpos2 < rin2)) {
762  ok = false;
763  ncf = k;
764  break;
765  }
766  }
767  break;
768  }
769  default: {
770  for (int k = 0; k < corners; ++k) {
771  double xc1 = xpos + dx0[k];
772  double yc1 = ypos + dy0[k];
773  double rpos2 = (xc1 * xc1 + yc1 * yc1);
774  if ((rpos2 > rout2) || (rpos2 < rin2)) {
775  ok = false;
776  ncf = k;
777  break;
778  }
779  }
780  break;
781  }
782  }
783  if (debug)
784  edm::LogVerbatim("HGCalGeom") << "I/p "
785  << ":" << xpos << ":" << ypos << ":" << delX << ":" << delY << ":" << rin << ":"
786  << rout << ":" << part << ":" << rotn << " Results " << ok << ":" << ncf;
787  return ok;
788 }

References newFWLiteAna::base, compare_using_db::base2, HGCalTypes::c10, HGCalTypes::c22, HGCalTypes::c27, HGCalTypes::c50, HGCalTypes::c61, HGCalTypes::c75, HGCalTypes::c77, HGCalTypes::c88, debug, dqmdumpme::k, convertSQLiteXML::ok, HGCalTypes::WaferChopTwo, HGCalTypes::WaferChopTwoM, HGCalTypes::WaferCornerMax, HGCalTypes::WaferFive, HGCalTypes::WaferHalf, HGCalTypes::WaferSemi, HGCalTypes::WaferSemi2, HGCalTypes::WaferSizeMax, and HGCalTypes::WaferThree.

Referenced by HGCalGeomParameters::loadWaferHexagon8().

◆ maskCell()

bool HGCalWaferMask::maskCell ( int  u,
int  v,
int  N,
int  ncor,
int  fcor,
int  corners 
)
static

Definition at line 11 of file HGCalWaferMask.cc.

11  {
12  /*
13 Masks each cell (or not) according to its wafer and cell position (detId) and to the user needs (corners).
14 Each wafer has k_CornerSize corners which are defined in anti-clockwise order starting from the corner at the top, which is always #0. 'ncor' denotes the number of corners inside the physical region. 'fcor' is the defined to be the first corner that appears inside the detector's physical volume in anti-clockwise order.
15 The argument 'corners' controls the types of wafers the user wants: for instance, corners=3 masks all wafers that have at least 3 corners inside the physical region.
16  */
17  bool mask(false);
18  if (ncor < corners) {
19  mask = true;
20  } else {
21  if (ncor == HGCalGeomTools::k_fourCorners) {
22  switch (fcor) {
23  case (0): {
24  mask = (v >= n);
25  break;
26  }
27  case (1): {
28  mask = (u >= n);
29  break;
30  }
31  case (2): {
32  mask = (u > v);
33  break;
34  }
35  case (3): {
36  mask = (v < n);
37  break;
38  }
39  case (4): {
40  mask = (u < n);
41  break;
42  }
43  default: {
44  mask = (u <= v);
45  break;
46  }
47  }
48  } else {
49  switch (fcor) {
50  case (0): {
51  if (ncor == HGCalGeomTools::k_threeCorners) {
52  mask = !((u > 2 * v) && (v < n));
53  } else {
54  mask = ((u >= n) && (v >= n) && ((u + v) > (3 * n - 2)));
55  }
56  break;
57  }
58  case (1): {
59  if (ncor == HGCalGeomTools::k_threeCorners) {
60  mask = !((u + v) < n);
61  } else {
62  mask = ((u >= n) && (u > v) && ((2 * u - v) > 2 * n));
63  }
64  break;
65  }
66  case (2): {
67  if (ncor == HGCalGeomTools::k_threeCorners) {
68  mask = !((u < n) && (v > u) && (v > (2 * u - 1)));
69  } else {
70  mask = ((u > 2 * v) && (v < n));
71  }
72  break;
73  }
74  case (3): {
75  if (ncor == HGCalGeomTools::k_threeCorners) {
76  mask = !((v >= u) && ((2 * v - u) > (2 * n - 2)));
77  } else {
78  mask = ((u + v) < n);
79  }
80  break;
81  }
82  case (4): {
83  if (ncor == HGCalGeomTools::k_threeCorners) {
84  mask = !((u >= n) && (v >= n) && ((u + v) > (3 * n - 2)));
85  } else {
86  mask = ((u < n) && (v > u) && (v > (2 * u - 1)));
87  }
88  break;
89  }
90  default: {
91  if (ncor == HGCalGeomTools::k_threeCorners) {
92  mask = !((u >= n) && (u > v) && ((2 * u - v) > 2 * n));
93  } else {
94  mask = ((v >= u) && ((2 * v - u) > (2 * n - 2)));
95  }
96  break;
97  }
98  }
99  }
100  }
101 #ifdef EDM_ML_DEBUG
102  edm::LogVerbatim("HGCalGeom") << "Corners: " << ncor << ":" << fcor << " N " << n << " u " << u << " v " << v
103  << " Mask " << mask;
104 #endif
105  return mask;
106 }

References HGCalGeomTools::k_fourCorners, HGCalGeomTools::k_threeCorners, dqmiodumpmetadata::n, and findQualityFiles::v.

Referenced by HGCalDDDConstants::maskCell().

◆ waferXY()

std::vector< std::pair< double, double > > HGCalWaferMask::waferXY ( int  part,
int  orient,
int  zside,
double  delX,
double  delY,
double  xpos,
double  ypos 
)
static

Definition at line 790 of file HGCalWaferMask.cc.

791  {
792  std::vector<std::pair<double, double> > xy;
793  int orient = getRotation(-zside, part, ori);
794 #ifdef EDM_ML_DEBUG
795  edm::LogVerbatim("HGCalGeom") << "Part " << part << " zSide " << zside << " Orient " << ori << ":" << orient;
796 #endif
797  double dx[24] = {HGCalTypes::c00 * delX, HGCalTypes::c10 * delX, HGCalTypes::c10 * delX, HGCalTypes::c00 * delX,
798  -HGCalTypes::c10 * delX, -HGCalTypes::c10 * delX, HGCalTypes::c50 * delX, HGCalTypes::c10 * delX,
799  HGCalTypes::c50 * delX, -HGCalTypes::c50 * delX, -HGCalTypes::c10 * delX, -HGCalTypes::c50 * delX,
800  HGCalTypes::c22 * delX, HGCalTypes::c10 * delX, HGCalTypes::c77 * delX, -HGCalTypes::c22 * delX,
801  -HGCalTypes::c10 * delX, -HGCalTypes::c77 * delX, HGCalTypes::c22 * delX, -HGCalTypes::c77 * delX,
802  -HGCalTypes::c10 * delX, -HGCalTypes::c22 * delX, HGCalTypes::c77 * delX, HGCalTypes::c10 * delX};
803  double dy[24] = {-HGCalTypes::c10 * delY, -HGCalTypes::c50 * delY, HGCalTypes::c50 * delY, HGCalTypes::c10 * delY,
804  HGCalTypes::c50 * delY, -HGCalTypes::c50 * delY, -HGCalTypes::c75 * delY, HGCalTypes::c00 * delY,
805  HGCalTypes::c75 * delY, HGCalTypes::c75 * delY, HGCalTypes::c00 * delY, -HGCalTypes::c75 * delY,
806  -HGCalTypes::c88 * delY, -HGCalTypes::c27 * delY, HGCalTypes::c61 * delY, HGCalTypes::c88 * delY,
807  HGCalTypes::c27 * delY, -HGCalTypes::c61 * delY, HGCalTypes::c88 * delY, HGCalTypes::c61 * delY,
808  -HGCalTypes::c27 * delY, -HGCalTypes::c88 * delY, -HGCalTypes::c61 * delY, HGCalTypes::c27 * delY};
809  if (part == HGCalTypes::WaferFull) {
810  int np[7] = {0, 1, 2, 3, 4, 5, 0};
811  for (int k = 0; k < 7; ++k)
812  xy.push_back(std::make_pair((xpos + dx[np[k]]), (ypos + dy[np[k]])));
813  } else if (part == HGCalTypes::WaferFive) {
814  int np[6][6] = {{0, 2, 3, 4, 5, 0},
815  {1, 3, 4, 5, 0, 1},
816  {2, 4, 5, 0, 1, 2},
817  {3, 5, 0, 1, 2, 3},
818  {4, 0, 1, 2, 3, 4},
819  {5, 1, 2, 3, 4, 5}};
820  for (int k = 0; k < 6; ++k) {
821  xy.push_back(std::make_pair((xpos + dx[np[orient][k]]), (ypos + dy[np[orient][k]])));
822 #ifdef EDM_ML_DEBUG
823  edm::LogVerbatim("HGCalGeom") << k << ":" << np[orient][k] << ":" << dx[np[orient][k]] << ":"
824  << dy[np[orient][k]];
825 #endif
826  }
827  } else if (part == HGCalTypes::WaferHalf) {
828  int np[6][5] = {
829  {0, 3, 4, 5, 0}, {1, 4, 5, 0, 1}, {2, 5, 0, 1, 2}, {3, 0, 1, 2, 3}, {4, 1, 2, 3, 4}, {5, 2, 3, 4, 5}};
830  for (int k = 0; k < 5; ++k) {
831  xy.push_back(std::make_pair((xpos + dx[np[orient][k]]), (ypos + dy[np[orient][k]])));
832 #ifdef EDM_ML_DEBUG
833  edm::LogVerbatim("HGCalGeom") << k << ":" << np[orient][k] << ":" << dx[np[orient][k]] << ":"
834  << dy[np[orient][k]];
835 #endif
836  }
837  } else if (part == HGCalTypes::WaferThree) {
838  int np[6][4] = {{0, 4, 5, 0}, {1, 5, 0, 1}, {2, 0, 1, 2}, {3, 1, 2, 3}, {4, 2, 3, 4}, {5, 3, 4, 5}};
839  for (int k = 0; k < 4; ++k) {
840  xy.push_back(std::make_pair((xpos + dx[np[orient][k]]), (ypos + dy[np[orient][k]])));
841 #ifdef EDM_ML_DEBUG
842  edm::LogVerbatim("HGCalGeom") << k << ":" << np[orient][k] << ":" << dx[np[orient][k]] << ":"
843  << dy[np[orient][k]];
844 #endif
845  }
846  } else if (part == HGCalTypes::WaferChopTwo) {
847  int np[6][7] = {{6, 8, 3, 4, 5, 0, 6},
848  {7, 9, 4, 5, 0, 1, 7},
849  {8, 10, 5, 0, 1, 2, 8},
850  {9, 11, 0, 1, 2, 3, 9},
851  {10, 6, 1, 2, 3, 4, 10},
852  {11, 7, 2, 3, 4, 5, 11}};
853  for (int k = 0; k < 7; ++k) {
854  xy.push_back(std::make_pair((xpos + dx[np[orient][k]]), (ypos + dy[np[orient][k]])));
855 #ifdef EDM_ML_DEBUG
856  edm::LogVerbatim("HGCalGeom") << k << ":" << np[orient][k] << ":" << dx[np[orient][k]] << ":"
857  << dy[np[orient][k]];
858 #endif
859  }
860  } else if (part == HGCalTypes::WaferSemi) {
861  int np[6][6] = {{6, 9, 4, 5, 0, 6},
862  {7, 10, 5, 0, 1, 7},
863  {8, 11, 0, 1, 2, 8},
864  {9, 6, 1, 2, 3, 9},
865  {10, 7, 2, 3, 4, 10},
866  {11, 8, 3, 4, 5, 11}};
867  for (int k = 0; k < 6; ++k) {
868  xy.push_back(std::make_pair((xpos + dx[np[orient][k]]), (ypos + dy[np[orient][k]])));
869 #ifdef EDM_ML_DEBUG
870  edm::LogVerbatim("HGCalGeom") << k << ":" << np[orient][k] << ":" << dx[np[orient][k]] << ":"
871  << dy[np[orient][k]];
872 #endif
873  }
874  } else if (part == HGCalTypes::WaferChopTwoM) {
875  int np[6][7] = {{12, 18, 3, 4, 5, 0, 12},
876  {13, 19, 4, 5, 0, 1, 13},
877  {14, 20, 5, 0, 1, 2, 14},
878  {15, 21, 0, 1, 2, 3, 15},
879  {16, 22, 1, 2, 3, 4, 16},
880  {17, 23, 2, 3, 4, 5, 17}};
881  for (int k = 0; k < 7; ++k) {
882  xy.push_back(std::make_pair((xpos + dx[np[orient][k]]), (ypos + dy[np[orient][k]])));
883 #ifdef EDM_ML_DEBUG
884  edm::LogVerbatim("HGCalGeom") << k << ":" << np[orient][k] << ":" << dx[np[orient][k]] << ":"
885  << dy[np[orient][k]];
886 #endif
887  }
888  } else if (part == HGCalTypes::WaferSemi2) {
889  int np[6][6] = {{12, 19, 4, 5, 0, 12},
890  {13, 20, 5, 0, 1, 13},
891  {14, 21, 0, 1, 2, 14},
892  {15, 22, 1, 2, 3, 15},
893  {16, 23, 2, 3, 4, 16},
894  {17, 18, 3, 4, 5, 17}};
895  for (int k = 0; k < 6; ++k) {
896  xy.push_back(std::make_pair((xpos + dx[np[orient][k]]), (ypos + dy[np[orient][k]])));
897 #ifdef EDM_ML_DEBUG
898  edm::LogVerbatim("HGCalGeom") << k << ":" << np[orient][k] << ":" << dx[np[orient][k]] << ":"
899  << dy[np[orient][k]];
900 #endif
901  }
902  }
903 #ifdef EDM_ML_DEBUG
904  edm::LogVerbatim("HGCalGeom") << "I/p: " << part << ":" << ori << ":" << zside << ":" << delX << ":" << delY << ":"
905  << xpos << ":" << ypos << " O/p having " << xy.size() << " points:";
906  std::ostringstream st1;
907  for (unsigned int i = 0; i < xy.size(); ++i)
908  st1 << " [" << i << "] " << xy[i].first << ":" << xy[i].second;
909  edm::LogVerbatim("HGCalGeom") << st1.str();
910 #endif
911  return xy;
912 }

References HGCalTypes::c00, HGCalTypes::c10, HGCalTypes::c22, HGCalTypes::c27, HGCalTypes::c50, HGCalTypes::c61, HGCalTypes::c75, HGCalTypes::c77, HGCalTypes::c88, PVValHelper::dx, PVValHelper::dy, first, getRotation(), mps_fire::i, dqmdumpme::k, np, hgcalPerformanceValidation::orient, edm::second(), HGCalTypes::WaferChopTwo, HGCalTypes::WaferChopTwoM, HGCalTypes::WaferFive, HGCalTypes::WaferFull, HGCalTypes::WaferHalf, HGCalTypes::WaferSemi, HGCalTypes::WaferSemi2, HGCalTypes::WaferThree, geometryCSVtoXML::xy, and ecaldqm::zside().

Referenced by algorithm(), and DDHGCalWaferP::execute().

Member Data Documentation

◆ k_OffsetRotation

constexpr int HGCalWaferMask::k_OffsetRotation = 10
staticconstexpr

Definition at line 37 of file HGCalWaferMask.h.

Referenced by getTypeMode(), HGCalGeomParameters::loadWaferHexagon8(), HGCalDDDConstants::maskCell(), HGCalDDDConstants::waferType(), and HGCalDDDConstants::waferTypeRotation().

HGCalGeomTools::k_allCorners
static constexpr int k_allCorners
Definition: HGCalGeomTools.h:13
mps_fire.i
i
Definition: mps_fire.py:428
HGCalTypes::WaferChopTwo
Definition: HGCalTypes.h:52
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
HGCalTypes::WaferCornerMax
static constexpr int32_t WaferCornerMax
Definition: HGCalTypes.h:62
HGCalTypes::c00
static constexpr double c00
Definition: HGCalTypes.h:65
ecaldqm::zside
int zside(DetId const &)
Definition: EcalDQMCommonUtils.cc:189
HGCalTypes::WaferThree
Definition: HGCalTypes.h:57
HGCalTypes::WaferFull
Definition: HGCalTypes.h:50
np
int np
Definition: AMPTWrapper.h:43
ALCARECOPromptCalibProdSiPixelAli0T_cff.mode
mode
Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96
HGCalTypes::WaferCorner1
Definition: HGCalTypes.h:31
HGCalTypes::c75
static constexpr double c75
Definition: HGCalTypes.h:71
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
HGCalTypes::WaferOut
Definition: HGCalTypes.h:58
findQualityFiles.v
v
Definition: findQualityFiles.py:179
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
HGCalTypes::WaferFive
Definition: HGCalTypes.h:51
convertSQLiteXML.ok
bool ok
Definition: convertSQLiteXML.py:98
HGCalTypes::c77
static constexpr double c77
Definition: HGCalTypes.h:72
HGCalWaferMask::getRotation
static int getRotation(int zside, int type, int rotn)
Definition: HGCalWaferMask.cc:339
debug
#define debug
Definition: HDRShower.cc:19
part
part
Definition: HCALResponse.h:20
HGCalTypes::c22
static constexpr double c22
Definition: HGCalTypes.h:66
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
HGCalTypes::c61
static constexpr double c61
Definition: HGCalTypes.h:70
dqmdumpme.k
k
Definition: dqmdumpme.py:60
HGCalTypes::WaferSizeMax
static constexpr int32_t WaferSizeMax
Definition: HGCalTypes.h:63
first
auto first
Definition: CAHitNtupletGeneratorKernelsImpl.h:112
geometryCSVtoXML.xy
xy
Definition: geometryCSVtoXML.py:19
HGCalTypes::WaferCorner5
Definition: HGCalTypes.h:35
HGCalTypes::WaferSemi
Definition: HGCalTypes.h:55
HGCalTypes::WaferCorner2
Definition: HGCalTypes.h:32
HGCalTypes::WaferSemi2
Definition: HGCalTypes.h:56
type
type
Definition: SiPixelVCal_PayloadInspector.cc:37
gainCalibHelper::gainCalibPI::type
type
Definition: SiPixelGainCalibHelper.h:40
HGCalWaferMask::k_OffsetRotation
static constexpr int k_OffsetRotation
Definition: HGCalWaferMask.h:37
HGCalTypes::c50
static constexpr double c50
Definition: HGCalTypes.h:69
HGCalTypes::WaferCorner4
Definition: HGCalTypes.h:34
HGCalTypes::c88
static constexpr double c88
Definition: HGCalTypes.h:73
HGCalTypes::WaferChopTwoM
Definition: HGCalTypes.h:53
PVValHelper::dy
Definition: PVValidationHelpers.h:50
HGCalGeomTools::k_fiveCorners
static constexpr int k_fiveCorners
Definition: HGCalGeomTools.h:14
compare_using_db.base2
base2
Definition: compare_using_db.py:175
HGCalTypes::c10
static constexpr double c10
Definition: HGCalTypes.h:74
hgcalPerformanceValidation.orient
orient
Definition: hgcalPerformanceValidation.py:733
HGCalTypes::WaferCorner3
Definition: HGCalTypes.h:33
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:128
HGCalTypes::WaferHalf
Definition: HGCalTypes.h:54
HGCalTypes::c27
static constexpr double c27
Definition: HGCalTypes.h:68
MetAnalyzer.u2
u2
Definition: MetAnalyzer.py:61
newFWLiteAna.base
base
Definition: newFWLiteAna.py:92
HGCalGeomTools::k_fourCorners
static constexpr int k_fourCorners
Definition: HGCalGeomTools.h:15
PVValHelper::dx
Definition: PVValidationHelpers.h:49
HGCalGeomTools::k_threeCorners
static constexpr int k_threeCorners
Definition: HGCalGeomTools.h:16
HGCalTypes::WaferCorner0
Definition: HGCalTypes.h:30
Generated for CMSSW Reference Manual by doxygen 1.8.16