CMS 3D CMS Logo
HGCalWaferMask.cc
Go to the documentation of this file.
1 #include "Geometry/HGCalCommonData/interface/HGCalWaferMask.h"
2 #include "Geometry/HGCalCommonData/interface/HGCalTypes.h"
3 #include "Geometry/HGCalCommonData/interface/HGCalGeomTools.h"
4 #include "FWCore/MessageLogger/interface/MessageLogger.h"
5 #include "Geometry/HGCalCommonData/interface/HGCalCell.h"
6 
7 #include <algorithm>
8 #include <array>
9 #include <sstream>
10 
11 //#define EDM_ML_DEBUG
12 
13 bool HGCalWaferMask::maskCell(int u, int v, int n, int ncor, int fcor, int corners) {
14  /*
15 Masks each cell (or not) according to its wafer and cell position (detId) and to the user needs (corners).
16 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.
17 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.
18  */
19  bool mask(false);
20  if (ncor < corners) {
21  mask = true;
22  } else {
23  if (ncor == HGCalGeomTools::k_fourCorners) {
24  switch (fcor) {
25  case (0): {
26  mask = (v >= n);
27  break;
28  }
29  case (1): {
30  mask = (u >= n);
31  break;
32  }
33  case (2): {
34  mask = (u > v);
35  break;
36  }
37  case (3): {
38  mask = (v < n);
39  break;
40  }
41  case (4): {
42  mask = (u < n);
43  break;
44  }
45  default: {
46  mask = (u <= v);
47  break;
48  }
49  }
50  } else {
51  switch (fcor) {
52  case (0): {
53  if (ncor == HGCalGeomTools::k_threeCorners) {
54  mask = !((u > 2 * v) && (v < n));
55  } else {
56  mask = ((u >= n) && (v >= n) && ((u + v) > (3 * n - 2)));
57  }
58  break;
59  }
60  case (1): {
61  if (ncor == HGCalGeomTools::k_threeCorners) {
62  mask = !((u + v) < n);
63  } else {
64  mask = ((u >= n) && (u > v) && ((2 * u - v) > 2 * n));
65  }
66  break;
67  }
68  case (2): {
69  if (ncor == HGCalGeomTools::k_threeCorners) {
70  mask = !((u < n) && (v > u) && (v > (2 * u - 1)));
71  } else {
72  mask = ((u > 2 * v) && (v < n));
73  }
74  break;
75  }
76  case (3): {
77  if (ncor == HGCalGeomTools::k_threeCorners) {
78  mask = !((v >= u) && ((2 * v - u) > (2 * n - 2)));
79  } else {
80  mask = ((u + v) < n);
81  }
82  break;
83  }
84  case (4): {
85  if (ncor == HGCalGeomTools::k_threeCorners) {
86  mask = !((u >= n) && (v >= n) && ((u + v) > (3 * n - 2)));
87  } else {
88  mask = ((u < n) && (v > u) && (v > (2 * u - 1)));
89  }
90  break;
91  }
92  default: {
93  if (ncor == HGCalGeomTools::k_threeCorners) {
94  mask = !((u >= n) && (u > v) && ((2 * u - v) > 2 * n));
95  } else {
96  mask = ((v >= u) && ((2 * v - u) > (2 * n - 2)));
97  }
98  break;
99  }
100  }
101  }
102  }
103 #ifdef EDM_ML_DEBUG
104  edm::LogVerbatim("HGCalGeom") << "Corners: " << ncor << ":" << fcor << " N " << n << " u " << u << " v " << v
105  << " Mask " << mask;
106 #endif
107  return mask;
108 }
109 
110 bool HGCalWaferMask::goodCell(int u, int v, int n, int type, int rotn) {
111  // for V15 and V16
112  bool good(false);
113  int n2 = n / 2;
114  int n4 = n / 4;
115  int n3 = (n + 1) / 3;
116  switch (type) {
117  case (HGCalTypes::WaferFull): { //WaferFull
118  good = true;
119  break;
120  }
121  case (HGCalTypes::WaferFive): { //WaferFive
122  switch (rotn) {
123  case (HGCalTypes::WaferCorner0): {
124  int u2 = u / 2;
125  good = ((v - u2) <= n);
126  break;
127  }
128  case (HGCalTypes::WaferCorner1): {
129  good = ((v + u) < (3 * n));
130  break;
131  }
132  case (HGCalTypes::WaferCorner2): {
133  int v2 = (v + 1) / 2;
134  good = ((u - v2) <= n);
135  break;
136  }
137  case (HGCalTypes::WaferCorner3): {
138  int u2 = (u - 1) / 2;
139  good = (u2 <= v);
140  break;
141  }
142  case (HGCalTypes::WaferCorner4): {
143  good = ((v + u) >= n - 1);
144  break;
145  }
146  default: {
147  int v2 = v / 2;
148  good = (u >= v2);
149  break;
150  }
151  }
152  break;
153  }
154  case (HGCalTypes::WaferChopTwo): { //WaferChopTwo
155  switch (rotn) {
156  case (HGCalTypes::WaferCorner0): {
157  good = (v < (3 * n2));
158  break;
159  }
160  case (HGCalTypes::WaferCorner1): {
161  good = (u < (3 * n2));
162  break;
163  }
164  case (HGCalTypes::WaferCorner2): {
165  good = ((u - v) <= n2);
166  break;
167  }
168  case (HGCalTypes::WaferCorner3): {
169  good = (v >= n2);
170  break;
171  }
172  case (HGCalTypes::WaferCorner4): {
173  good = (u >= n2 - 1);
174  break;
175  }
176  default: {
177  good = ((v - u) < n2);
178  break;
179  }
180  }
181  break;
182  }
183  case (HGCalTypes::WaferChopTwoM): { //WaferChopTwoM
184  switch (rotn) {
185  case (HGCalTypes::WaferCorner0): {
186  good = (v < (5 * n4));
187  break;
188  }
189  case (HGCalTypes::WaferCorner1): {
190  good = (u <= (5 * n4));
191  break;
192  }
193  case (HGCalTypes::WaferCorner2): {
194  good = ((u - v) <= n4);
195  break;
196  }
197  case (HGCalTypes::WaferCorner3): {
198  good = (v >= (3 * n4 - 1));
199  break;
200  }
201  case (HGCalTypes::WaferCorner4): {
202  good = (u >= (3 * n4));
203  break;
204  }
205  default: {
206  good = ((v - u) <= n4);
207  break;
208  }
209  }
210  break;
211  }
212  case (HGCalTypes::WaferHalf): { //WaferHalf
213  switch (rotn) {
214  case (HGCalTypes::WaferCorner0): {
215  good = (v < n);
216  break;
217  }
218  case (HGCalTypes::WaferCorner1): {
219  good = (u <= n);
220  break;
221  }
222  case (HGCalTypes::WaferCorner2): {
223  good = (v >= u);
224  break;
225  }
226  case (HGCalTypes::WaferCorner3): {
227  good = (v >= n - 1);
228  break;
229  }
230  case (HGCalTypes::WaferCorner4): {
231  good = (u >= n);
232  break;
233  }
234  default: {
235  good = (u >= v);
236  break;
237  }
238  }
239  break;
240  }
241  case (HGCalTypes::WaferSemi): { //WaferSemi
242  switch (rotn) {
243  case (HGCalTypes::WaferCorner0): {
244  good = ((u + v) <= (2 * n));
245  break;
246  }
247  case (HGCalTypes::WaferCorner1): {
248  good = ((2 * u - v) <= (n + 1));
249  break;
250  }
251  case (HGCalTypes::WaferCorner2): {
252  good = ((2 * v - u) >= (n - 2));
253  break;
254  }
255  case (HGCalTypes::WaferCorner3): {
256  good = ((u + v) >= (2 * n - 2));
257  break;
258  }
259  case (HGCalTypes::WaferCorner4): {
260  good = ((2 * u - v) >= (n - 1));
261  break;
262  }
263  default: {
264  good = ((2 * v - u) <= n);
265  break;
266  }
267  }
268  break;
269  }
270  case (HGCalTypes::WaferThree): { //WaferThree
271  switch (rotn) {
272  case (HGCalTypes::WaferCorner0): {
273  good = ((v + u) <= n);
274  break;
275  }
276  case (HGCalTypes::WaferCorner1): {
277  good = ((2 * u - v) <= 1);
278  break;
279  }
280  case (HGCalTypes::WaferCorner2): {
281  int u2 = ((u > 0) ? (u / 2) : 0);
282  int uv = v - u2;
283  good = (uv >= (n - 1));
284  break;
285  }
286  case (HGCalTypes::WaferCorner3): {
287  good = ((v + u) >= (3 * n - 2));
288  break;
289  }
290  case (HGCalTypes::WaferCorner4): {
291  int uv = 2 * u - v;
292  good = (uv >= (2 * n - 1));
293  break;
294  }
295  default: {
296  int uv = u - 2 * v;
297  good = (uv >= 0);
298  break;
299  }
300  }
301  break;
302  }
303  case (HGCalTypes::WaferSemi2): { //WaferSemi2
304  switch (rotn) {
305  case (HGCalTypes::WaferCorner0): {
306  good = ((u + v) <= (4 * n3 + 1));
307  break;
308  }
309  case (HGCalTypes::WaferCorner1): {
310  good = ((2 * u - v) <= n2);
311  break;
312  }
313  case (HGCalTypes::WaferCorner2): {
314  int u2 = ((u + 1) / 2);
315  good = ((v - u2) >= (3 * n4 - 1));
316  break;
317  }
318  case (HGCalTypes::WaferCorner3): {
319  good = ((u + v) >= (5 * n2 - 1));
320  break;
321  }
322  case (HGCalTypes::WaferCorner4): {
323  good = ((2 * u - v) >= (3 * n2));
324  break;
325  }
326  default: {
327  int u2 = (u + 1) / 2;
328  good = ((v - u2) < n4);
329  break;
330  }
331  }
332  break;
333  }
334  case (HGCalTypes::WaferFive2): { //WaferFive2
335  switch (rotn) {
336  case (HGCalTypes::WaferCorner0): {
337  good = ((2 * v - u) <= (3 * n2));
338  break;
339  }
340  case (HGCalTypes::WaferCorner1): {
341  good = ((u + v) < (5 * n2));
342  break;
343  }
344  case (HGCalTypes::WaferCorner2): {
345  good = ((2 * u - v) >= (3 * n2));
346  break;
347  }
348  case (HGCalTypes::WaferCorner3): {
349  good = ((2 * v - u) >= n3);
350  break;
351  }
352  case (HGCalTypes::WaferCorner4): {
353  good = ((u + v) > (4 * n3));
354  break;
355  }
356  default: {
357  good = ((2 * u - v) >= n2);
358  break;
359  }
360  }
361  break;
362  }
363  case (HGCalTypes::WaferHalf2): { //WaferHalf2
364  switch (rotn) {
365  case (HGCalTypes::WaferCorner0): {
366  good = (v <= (3 * n4));
367  break;
368  }
369  case (HGCalTypes::WaferCorner1): {
370  good = (u <= (3 * n4));
371  break;
372  }
373  case (HGCalTypes::WaferCorner2): {
374  good = ((v - u) >= n4 - 1);
375  break;
376  }
377  case (HGCalTypes::WaferCorner3): {
378  good = (v >= (5 * n4 - 1));
379  break;
380  }
381  case (HGCalTypes::WaferCorner4): {
382  good = (u >= (5 * n4 - 1));
383  break;
384  }
385  default: {
386  good = ((u - v) >= n4);
387  break;
388  }
389  }
390  break;
391  }
392  }
393 #ifdef EDM_ML_DEBUG
394  edm::LogVerbatim("HGCalGeom") << "u|v " << u << ":" << v << " N " << n << " type " << type << " rot " << rotn
395  << " good " << good;
396 #endif
397  return good;
398 }
399 
400 bool HGCalWaferMask::goodCell(int u, int v, int waferType) {
401  // for V17
402  bool good(false);
403  switch (waferType) {
404  case (HGCalTypes::WaferFull): { //WaferFull
405  good = true;
406  break;
407  }
408  case (HGCalTypes::WaferLDTop): {
409  good = (u * HGCalTypes::edgeWaferLDTop[0] + v * HGCalTypes::edgeWaferLDTop[1] <= HGCalTypes::edgeWaferLDTop[2]);
410  break;
411  }
412  case (HGCalTypes::WaferLDBottom): {
413  good = (u * HGCalTypes::edgeWaferLDBottom[0] + v * HGCalTypes::edgeWaferLDBottom[1] <=
414  HGCalTypes::edgeWaferLDBottom[2]);
415  break;
416  }
417  case (HGCalTypes::WaferLDLeft): {
418  good =
419  (u * HGCalTypes::edgeWaferLDLeft[0] + v * HGCalTypes::edgeWaferLDLeft[1] <= HGCalTypes::edgeWaferLDLeft[2]);
420  break;
421  }
422  case (HGCalTypes::WaferLDRight): {
423  good = (u * HGCalTypes::edgeWaferLDRight[0] + v * HGCalTypes::edgeWaferLDRight[1] <=
424  HGCalTypes::edgeWaferLDRight[2]);
425  break;
426  }
427  case (HGCalTypes::WaferLDFive): {
428  good =
429  (u * HGCalTypes::edgeWaferLDFive[0] + v * HGCalTypes::edgeWaferLDFive[1] <= HGCalTypes::edgeWaferLDFive[2]);
430  break;
431  }
432  case (HGCalTypes::WaferLDThree): {
433  good = (u * HGCalTypes::edgeWaferLDThree[0] + v * HGCalTypes::edgeWaferLDThree[1] <=
434  HGCalTypes::edgeWaferLDThree[2]);
435  break;
436  }
437  case (HGCalTypes::WaferHDTop): {
438  good = (u * HGCalTypes::edgeWaferHDTop[0] + v * HGCalTypes::edgeWaferHDTop[1] <= HGCalTypes::edgeWaferHDTop[2]);
439  break;
440  }
441  case (HGCalTypes::WaferHDBottom): {
442  good = (u * HGCalTypes::edgeWaferHDBottom[0] + v * HGCalTypes::edgeWaferHDBottom[1] <=
443  HGCalTypes::edgeWaferHDBottom[2]);
444  break;
445  }
446  case (HGCalTypes::WaferHDLeft): {
447  good =
448  (u * HGCalTypes::edgeWaferHDLeft[0] + v * HGCalTypes::edgeWaferHDLeft[1] <= HGCalTypes::edgeWaferHDLeft[2]);
449  break;
450  }
451  case (HGCalTypes::WaferHDRight): {
452  good = (u * HGCalTypes::edgeWaferHDRight[0] + v * HGCalTypes::edgeWaferHDRight[1] <=
453  HGCalTypes::edgeWaferHDRight[2]);
454  break;
455  }
456  case (HGCalTypes::WaferHDFive): {
457  good =
458  (u * HGCalTypes::edgeWaferHDFive[0] + v * HGCalTypes::edgeWaferHDFive[1] <= HGCalTypes::edgeWaferHDFive[2]);
459  break;
460  }
461  }
462 #ifdef EDM_ML_DEBUG
463  edm::LogVerbatim("HGCalGeom") << "u|v " << u << ":" << v << " WaferType " << waferType << " good " << good;
464 #endif
465  return good;
466 }
467 
468 int HGCalWaferMask::getRotation(int zside, int type, int rotn) {
469  // Needs extension for V17
470  if (rotn >= HGCalTypes::WaferCornerMax)
471  rotn = HGCalTypes::WaferCorner0;
472  int newrotn(rotn);
473  if ((zside < 0) && (type != HGCalTypes::WaferFull)) {
474  if ((type == HGCalTypes::WaferFive) || (type == HGCalTypes::WaferFive2)) { //WaferFive/WaferFive2
475  static constexpr int rot1[HGCalTypes::WaferCornerMax] = {HGCalTypes::WaferCorner4,
476  HGCalTypes::WaferCorner3,
477  HGCalTypes::WaferCorner2,
478  HGCalTypes::WaferCorner1,
479  HGCalTypes::WaferCorner0,
480  HGCalTypes::WaferCorner5};
481  newrotn = rot1[rotn];
482  } else if ((type == HGCalTypes::WaferThree) || (type == HGCalTypes::WaferSemi) ||
483  (type == HGCalTypes::WaferSemi2)) { //WaferThree/WaferSemi/WaferSemi2
484  static constexpr int rot2[HGCalTypes::WaferCornerMax] = {HGCalTypes::WaferCorner2,
485  HGCalTypes::WaferCorner1,
486  HGCalTypes::WaferCorner0,
487  HGCalTypes::WaferCorner5,
488  HGCalTypes::WaferCorner4,
489  HGCalTypes::WaferCorner3};
490  newrotn = rot2[rotn];
491  } else { //WaferHalf/WaferChopTwo/WaferChopTwoM/WaferHalf2
492  static constexpr int rot3[HGCalTypes::WaferCornerMax] = {HGCalTypes::WaferCorner3,
493  HGCalTypes::WaferCorner2,
494  HGCalTypes::WaferCorner1,
495  HGCalTypes::WaferCorner0,
496  HGCalTypes::WaferCorner5,
497  HGCalTypes::WaferCorner4};
498  newrotn = rot3[rotn];
499  }
500  }
501 #ifdef EDM_ML_DEBUG
502  edm::LogVerbatim("HGCalGeom") << "zside " << zside << " type " << type << " rotn " << rotn << ":" << newrotn;
503 #endif
504  return newrotn;
505 }
506 
507 std::pair<int, int> HGCalWaferMask::getTypeMode(const double& xpos,
508  const double& ypos,
509  const double& delX,
510  const double& delY,
511  const double& rin,
512  const double& rout,
513  const int& wType,
514  const int& mode,
515  const bool& v17OrLess,
516  const bool& debug) {
517  // No need to extend this for V17 -- use flat file information only
518  int ncor(0), iok(0);
519  int type(HGCalTypes::WaferFull), rotn(HGCalTypes::WaferCorner0);
520  double c22(HGCalTypes::c22), c27(HGCalTypes::c27), c61(HGCalTypes::c61);
521  double c77(HGCalTypes::c77), c88(HGCalTypes::c88);
522  if (v17OrLess) {
523  c22 = HGCalTypes::c22O;
524  c27 = HGCalTypes::c27O;
525  c61 = HGCalTypes::c61O;
526  c77 = HGCalTypes::c77O;
527  c88 = HGCalTypes::c88O;
528  }
529 
530  static constexpr int corners = 6;
531  static constexpr int base = 10;
532  double rin2 = rin * rin;
533  double rout2 = rout * rout;
534  double dx0[corners] = {HGCalTypes::c00 * delX,
535  HGCalTypes::c10 * delX,
536  HGCalTypes::c10 * delX,
537  HGCalTypes::c00 * delX,
538  -HGCalTypes::c10 * delX,
539  -HGCalTypes::c10 * delX};
540  double dy0[corners] = {-HGCalTypes::c10 * delY,
541  -HGCalTypes::c50 * delY,
542  HGCalTypes::c50 * delY,
543  HGCalTypes::c10 * delY,
544  HGCalTypes::c50 * delY,
545  -HGCalTypes::c50 * delY};
546  double xc[corners], yc[corners];
547  for (int k = 0; k < corners; ++k) {
548  xc[k] = xpos + dx0[k];
549  yc[k] = ypos + dy0[k];
550  double rpos2 = (xc[k] * xc[k] + yc[k] * yc[k]);
551  if (rpos2 <= rout2 && rpos2 >= rin2) {
552  ++ncor;
553  iok = iok * base + 1;
554  } else {
555  iok *= base;
556  }
557  }
558  if (debug)
559  edm::LogVerbatim("HGCalGeom") << "I/p: xp " << xpos << " yp " << ypos << " dX " << delX << " dY " << delY << " rin "
560  << rin << " rout " << rout << " wtype " << wType << " mode " << mode << " Corners "
561  << ncor << " iok " << iok;
562 
563  static constexpr int ipat5[corners] = {101111, 110111, 111011, 111101, 111110, 11111};
564  static constexpr int ipat4[corners] = {100111, 110011, 111001, 111100, 11110, 1111};
565  static constexpr int ipat3[corners] = {100011, 110001, 111000, 11100, 1110, 111};
566  static constexpr int ipat2[corners] = {11, 100001, 110000, 11000, 1100, 110};
567  double dx1[corners] = {HGCalTypes::c50 * delX,
568  HGCalTypes::c10 * delX,
569  HGCalTypes::c50 * delX,
570  -HGCalTypes::c50 * delX,
571  -HGCalTypes::c10 * delX,
572  -HGCalTypes::c50 * delX};
573  double dy1[corners] = {-HGCalTypes::c75 * delY,
574  HGCalTypes::c00 * delY,
575  HGCalTypes::c75 * delY,
576  HGCalTypes::c75 * delY,
577  HGCalTypes::c00 * delY,
578  -HGCalTypes::c75 * delY};
579  double dx2[corners] = {HGCalTypes::c50 * delX,
580  -HGCalTypes::c50 * delX,
581  -HGCalTypes::c10 * delX,
582  -HGCalTypes::c50 * delX,
583  HGCalTypes::c50 * delX,
584  HGCalTypes::c10 * delX};
585  double dy2[corners] = {HGCalTypes::c75 * delY,
586  HGCalTypes::c75 * delY,
587  HGCalTypes::c00 * delY,
588  -HGCalTypes::c75 * delY,
589  -HGCalTypes::c75 * delY,
590  HGCalTypes::c00 * delY};
591  double dx3[corners] = {
592  c22 * delX, HGCalTypes::c10 * delX, c77 * delX, -c22 * delX, -HGCalTypes::c10 * delX, -c77 * delX};
593  double dy3[corners] = {-c88 * delY, -c27 * delY, c61 * delY, c88 * delY, c27 * delY, -c61 * delY};
594  double dx4[corners] = {
595  c22 * delX, -c77 * delX, -HGCalTypes::c10 * delX, -c22 * delX, c77 * delX, HGCalTypes::c10 * delX};
596  double dy4[corners] = {c88 * delY, c61 * delY, -c27 * delY, -c88 * delY, -c61 * delY, c27 * delY};
597  double dx5[corners] = {-HGCalTypes::c50 * delX,
598  -HGCalTypes::c10 * delX,
599  -HGCalTypes::c50 * delX,
600  HGCalTypes::c50 * delX,
601  HGCalTypes::c10 * delX,
602  HGCalTypes::c50 * delX};
603  double dy5[corners] = {HGCalTypes::c75 * delY,
604  HGCalTypes::c00 * delY,
605  -HGCalTypes::c75 * delY,
606  -HGCalTypes::c75 * delY,
607  HGCalTypes::c00 * delY,
608  HGCalTypes::c75 * delY};
609  double dx6[corners] = {
610  -c77 * delX, -HGCalTypes::c10 * delX, -c22 * delX, c77 * delX, HGCalTypes::c10 * delX, c22 * delX};
611  double dy6[corners] = {c61 * delY, -c27 * delY, -c88 * delY, -c61 * delY, c27 * delY, c88 * delY};
612  double dx7[corners] = {
613  -c22 * delX, -HGCalTypes::c10 * delX, -c77 * delX, c22 * delX, HGCalTypes::c10 * delX, c77 * delX};
614  double dy7[corners] = {c88 * delY, c27 * delY, -c61 * delY, -c88 * delY, -c27 * delY, c61 * delY};
615  double dx8[corners] = {
616  c77 * delX, HGCalTypes::c10 * delX, c22 * delX, -c77 * delX, -HGCalTypes::c10 * delX, -c22 * delX};
617  double dy8[corners] = {-c61 * delY, c27 * delY, c88 * delY, c61 * delY, -c27 * delY, -c88 * delY};
618  double dx9[corners] = {
619  -c22 * delX, c77 * delX, HGCalTypes::c10 * delX, c22 * delX, -c77 * delX, -HGCalTypes::c10 * delX};
620  double dy9[corners] = {-c88 * delY, -c61 * delY, c27 * delY, c88 * delY, c61 * delY, -c27 * delY};
621 
622  if (ncor == HGCalGeomTools::k_allCorners) {
623  } else if (ncor == HGCalGeomTools::k_fiveCorners) {
624  rotn = static_cast<int>(std::find(ipat5, ipat5 + 6, iok) - ipat5);
625  type = HGCalTypes::WaferFive;
626  } else if (ncor == HGCalGeomTools::k_fourCorners) {
627  rotn = static_cast<int>(std::find(ipat4, ipat4 + 6, iok) - ipat4);
628  type = HGCalTypes::WaferHalf;
629  double rpos12 = ((xpos + dx1[rotn]) * (xpos + dx1[rotn]) + (ypos + dy1[rotn]) * (ypos + dy1[rotn]));
630  double rpos22(0);
631  if (rpos12 <= rout2 && rpos12 >= rin2) {
632  rpos22 = ((xpos + dx2[rotn]) * (xpos + dx2[rotn]) + (ypos + dy2[rotn]) * (ypos + dy2[rotn]));
633  if (rpos22 <= rout2 && rpos22 >= rin2)
634  type = HGCalTypes::WaferChopTwo;
635  }
636  if (debug)
637  edm::LogVerbatim("HGCalGeom") << "Test for Chop2 " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
638  << type;
639  if ((type == HGCalTypes::WaferHalf) && (wType == 0)) {
640  rpos12 = ((xpos + dx3[rotn]) * (xpos + dx3[rotn]) + (ypos + dy3[rotn]) * (ypos + dy3[rotn]));
641  if (rpos12 <= rout2 && rpos12 >= rin2) {
642  rpos22 = ((xpos + dx4[rotn]) * (xpos + dx4[rotn]) + (ypos + dy4[rotn]) * (ypos + dy4[rotn]));
643  if (rpos22 <= rout2 && rpos22 >= rin2)
644  type = HGCalTypes::WaferChopTwoM;
645  }
646  if (debug)
647  edm::LogVerbatim("HGCalGeom") << "Test for Chop2M " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
648  << type;
649  }
650  } else if (ncor == HGCalGeomTools::k_threeCorners) {
651  rotn = static_cast<int>(std::find(ipat3, ipat3 + 6, iok) - ipat3);
652  type = HGCalTypes::WaferThree;
653  double rpos12 = ((xpos + dx7[rotn]) * (xpos + dx7[rotn]) + (ypos + dy7[rotn]) * (ypos + dy7[rotn]));
654  double rpos22(0);
655  if (rpos12 <= rout2 && rpos12 >= rin2) {
656  rpos22 = ((xpos + dx8[rotn]) * (xpos + dx8[rotn]) + (ypos + dy8[rotn]) * (ypos + dy8[rotn]));
657  if (rpos22 <= rout2 && rpos22 >= rin2)
658  type = HGCalTypes::WaferFive2;
659  }
660  if (debug)
661  edm::LogVerbatim("HGCalGeom") << "Test for Five2 " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
662  << type;
663  if ((type == HGCalTypes::WaferThree) && (wType == 0)) {
664  rpos12 = ((xpos + dx1[rotn]) * (xpos + dx1[rotn]) + (ypos + dy1[rotn]) * (ypos + dy1[rotn]));
665  if (rpos12 <= rout2 && rpos12 >= rin2) {
666  rpos22 = ((xpos + dx5[rotn]) * (xpos + dx5[rotn]) + (ypos + dy5[rotn]) * (ypos + dy5[rotn]));
667  if (rpos22 <= rout2 && rpos22 >= rin2)
668  type = HGCalTypes::WaferSemi;
669  }
670  if (debug)
671  edm::LogVerbatim("HGCalGeom") << "Test for Semi " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
672  << type;
673  }
674  if ((type == HGCalTypes::WaferThree) && (wType == 0)) {
675  rpos12 = ((xpos + dx3[rotn]) * (xpos + dx3[rotn]) + (ypos + dy3[rotn]) * (ypos + dy3[rotn]));
676  if (rpos12 <= rout2 && rpos12 >= rin2) {
677  rpos22 = ((xpos + dx6[rotn]) * (xpos + dx6[rotn]) + (ypos + dy6[rotn]) * (ypos + dy6[rotn]));
678  if (rpos22 <= rout2 && rpos22 >= rin2)
679  type = HGCalTypes::WaferSemi2;
680  }
681  if (debug)
682  edm::LogVerbatim("HGCalGeom") << "Test for SemiM " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
683  << type;
684  }
685  } else if (ncor == HGCalGeomTools::k_twoCorners) {
686  rotn = static_cast<int>(std::find(ipat2, ipat2 + 6, iok) - ipat2);
687  type = HGCalTypes::WaferOut;
688  double rpos12 = ((xpos + dx7[rotn]) * (xpos + dx7[rotn]) + (ypos + dy7[rotn]) * (ypos + dy7[rotn]));
689  double rpos22(0);
690  if (rpos12 <= rout2 && rpos12 >= rin2) {
691  rpos22 = ((xpos + dx9[rotn]) * (xpos + dx9[rotn]) + (ypos + dy9[rotn]) * (ypos + dy9[rotn]));
692  if (rpos22 <= rout2 && rpos22 >= rin2)
693  type = HGCalTypes::WaferHalf2;
694  else
695  rotn = HGCalTypes::WaferCorner0;
696  }
697  if (debug)
698  edm::LogVerbatim("HGCalGeom") << "Test for Half2 " << std::sqrt(rpos12) << ":" << std::sqrt(rpos22) << " Type "
699  << type;
700  } else {
701  type = HGCalTypes::WaferOut;
702  }
703 
704  if (debug)
705  edm::LogVerbatim("HGCalGeom") << "I/p: xpos " << xpos << " ypos " << ypos << " dX " << delX << " dY " << delY
706  << " rin " << rin << " rout " << rout << " wType " << wType << " mode " << mode
707  << " O/p: ok " << iok << " ncor " << ncor << " type " << type << " rotn " << rotn;
708  return ((mode == 0) ? std::make_pair(ncor, rotn) : std::make_pair(type, (rotn + HGCalTypes::k_OffsetRotation)));
709 }
710 
711 bool HGCalWaferMask::goodTypeMode(const double& xpos,
712  const double& ypos,
713  const double& delX,
714  const double& delY,
715  const double& rin,
716  const double& rout,
717  const int& part,
718  const int& rotn,
719  const bool& v17OrLess,
720  const bool& debug) {
721  // Needs extension for V17 or above
722  double c22(HGCalTypes::c22), c27(HGCalTypes::c27), c61(HGCalTypes::c61);
723  double c77(HGCalTypes::c77), c88(HGCalTypes::c88);
724  if (v17OrLess) {
725  c22 = HGCalTypes::c22O;
726  c27 = HGCalTypes::c27O;
727  c61 = HGCalTypes::c61O;
728  c77 = HGCalTypes::c77O;
729  c88 = HGCalTypes::c88O;
730  }
731 
732  if (part < 0 || part > HGCalTypes::WaferSizeMax)
733  return false;
734  if (rotn < 0 || rotn > HGCalTypes::WaferCornerMax)
735  return false;
736  double rin2 = rin * rin;
737  double rout2 = rout * rout;
738  double rpos2(0);
739  static constexpr int corners = HGCalTypes::WaferCornerMax;
740  static constexpr int corner2 = 2 * HGCalTypes::WaferCornerMax;
741  static constexpr int base = 10;
742  static constexpr int base2 = 100;
743  double dx0[corners] = {HGCalTypes::c00 * delX,
744  HGCalTypes::c10 * delX,
745  HGCalTypes::c10 * delX,
746  HGCalTypes::c00 * delX,
747  -HGCalTypes::c10 * delX,
748  -HGCalTypes::c10 * delX};
749  double dy0[corners] = {-HGCalTypes::c10 * delY,
750  -HGCalTypes::c50 * delY,
751  HGCalTypes::c50 * delY,
752  HGCalTypes::c10 * delY,
753  HGCalTypes::c50 * delY,
754  -HGCalTypes::c50 * delY};
755  double dx1[corners] = {HGCalTypes::c50 * delX,
756  HGCalTypes::c10 * delX,
757  HGCalTypes::c50 * delX,
758  -HGCalTypes::c50 * delX,
759  -HGCalTypes::c10 * delX,
760  -HGCalTypes::c50 * delX};
761  double dy1[corners] = {-HGCalTypes::c75 * delY,
762  HGCalTypes::c00 * delY,
763  HGCalTypes::c75 * delY,
764  HGCalTypes::c75 * delY,
765  HGCalTypes::c00 * delY,
766  -HGCalTypes::c75 * delY};
767  double dx2[corner2] = {c22 * delX,
768  c77 * delX,
769  HGCalTypes::c10 * delX,
770  HGCalTypes::c10 * delX,
771  c77 * delX,
772  c22 * delX,
773  -c22 * delX,
774  -c77 * delX,
775  -HGCalTypes::c10 * delX,
776  -HGCalTypes::c10 * delX,
777  -c77 * delX,
778  -c22 * delX};
779  double dy2[corner2] = {-c88 * delY,
780  -c61 * delY,
781  -c27 * delY,
782  c27 * delY,
783  c61 * delY,
784  c88 * delY,
785  c88 * delY,
786  c61 * delY,
787  c27 * delY,
788  -c27 * delY,
789  -c61 * delY,
790  -c88 * delY};
791  bool ok(true);
792  int ncf(-1);
793  switch (part) {
794  case (HGCalTypes::WaferThree): {
795  static constexpr int nc0[corners] = {450, 150, 201, 312, 423, 534};
796  int nc = nc0[rotn];
797  for (int k1 = 0; k1 < 3; ++k1) {
798  int k = nc % base;
799  double xc1 = xpos + dx0[k];
800  double yc1 = ypos + dy0[k];
801  rpos2 = (xc1 * xc1 + yc1 * yc1);
802  if ((rpos2 > rout2) || (rpos2 < rin2)) {
803  ok = false;
804  ncf = k;
805  break;
806  }
807  nc /= base;
808  }
809  break;
810  }
811  case (HGCalTypes::WaferSemi2): {
812  static constexpr int nc10[corners] = {450, 150, 201, 312, 423, 534};
813  static constexpr int nc11[corners] = {700, 902, 1104, 106, 308, 510};
814  int nc = nc10[rotn];
815  for (int k1 = 0; k1 < 3; ++k1) {
816  int k = nc % base;
817  double xc1 = xpos + dx0[k];
818  double yc1 = ypos + dy0[k];
819  rpos2 = (xc1 * xc1 + yc1 * yc1);
820  if ((rpos2 > rout2) || (rpos2 < rin2)) {
821  ok = false;
822  ncf = k;
823  break;
824  }
825  nc /= base;
826  }
827  nc = nc11[rotn];
828  for (int k1 = 0; k1 < 2; ++k1) {
829  int k = nc % base2;
830  double xc1 = xpos + dx2[k];
831  double yc1 = ypos + dy2[k];
832  rpos2 = (xc1 * xc1 + yc1 * yc1);
833  if ((rpos2 > rout2) || (rpos2 < rin2)) {
834  ok = false;
835  ncf = k + base2;
836  break;
837  }
838  nc /= base2;
839  }
840  break;
841  }
842  case (HGCalTypes::WaferSemi): {
843  static constexpr int nc20[corners] = {450, 150, 201, 312, 423, 534};
844  static constexpr int nc21[corners] = {30, 14, 25, 30, 41, 52};
845  int nc = nc20[rotn];
846  for (int k1 = 0; k1 < 3; ++k1) {
847  int k = nc % base;
848  double xc1 = xpos + dx0[k];
849  double yc1 = ypos + dy0[k];
850  rpos2 = (xc1 * xc1 + yc1 * yc1);
851  if ((rpos2 > rout2) || (rpos2 < rin2)) {
852  ok = false;
853  ncf = k;
854  break;
855  }
856  nc /= base;
857  }
858  nc = nc21[rotn];
859  for (int k1 = 0; k1 < 2; ++k1) {
860  int k = nc % base;
861  double xc1 = xpos + dx1[k];
862  double yc1 = ypos + dy1[k];
863  rpos2 = (xc1 * xc1 + yc1 * yc1);
864  if ((rpos2 > rout2) || (rpos2 < rin2)) {
865  ok = false;
866  ncf = k + base2;
867  break;
868  }
869  nc /= base;
870  }
871  break;
872  }
873  case (HGCalTypes::WaferHalf): {
874  static constexpr int nc3[corners] = {3450, 1450, 2501, 3012, 4123, 5234};
875  int nc = nc3[rotn];
876  for (int k1 = 0; k1 < 4; ++k1) {
877  int k = nc % base;
878  double xc1 = xpos + dx0[k];
879  double yc1 = ypos + dy0[k];
880  rpos2 = (xc1 * xc1 + yc1 * yc1);
881  if ((rpos2 > rout2) || (rpos2 < rin2)) {
882  ok = false;
883  ncf = k;
884  break;
885  }
886  nc /= base;
887  }
888  break;
889  }
890  case (HGCalTypes::WaferChopTwoM): {
891  static constexpr int nc40[corners] = {3450, 1450, 2501, 3012, 4123, 5234};
892  static constexpr int nc41[corners] = {500, 702, 904, 1106, 108, 310};
893  int nc = nc40[rotn];
894  for (int k1 = 0; k1 < 4; ++k1) {
895  int k = nc % base;
896  double xc1 = xpos + dx0[k];
897  double yc1 = ypos + dy0[k];
898  rpos2 = (xc1 * xc1 + yc1 * yc1);
899  if ((rpos2 > rout2) || (rpos2 < rin2)) {
900  ok = false;
901  ncf = k;
902  break;
903  }
904  nc /= base;
905  }
906  nc = nc41[rotn];
907  for (int k1 = 0; k1 < 2; ++k1) {
908  int k = nc % base2;
909  double xc1 = xpos + dx2[k];
910  double yc1 = ypos + dy2[k];
911  rpos2 = (xc1 * xc1 + yc1 * yc1);
912  if ((rpos2 > rout2) || (rpos2 < rin2)) {
913  ok = false;
914  ncf = k + base2;
915  break;
916  }
917  nc /= base2;
918  }
919  break;
920  }
921  case (HGCalTypes::WaferChopTwo): {
922  static constexpr int nc50[corners] = {3450, 1450, 2501, 3012, 4123, 5234};
923  static constexpr int nc51[corners] = {20, 13, 24, 35, 40, 51};
924  int nc = nc50[rotn];
925  for (int k1 = 0; k1 < 4; ++k1) {
926  int k = nc % base;
927  double xc1 = xpos + dx0[k];
928  double yc1 = ypos + dy0[k];
929  rpos2 = (xc1 * xc1 + yc1 * yc1);
930  if ((rpos2 > rout2) || (rpos2 < rin2)) {
931  ok = false;
932  ncf = k;
933  break;
934  }
935  nc /= base;
936  }
937  nc = nc51[rotn];
938  for (int k1 = 0; k1 < 2; ++k1) {
939  int k = nc % base;
940  double xc1 = xpos + dx1[k];
941  double yc1 = ypos + dy1[k];
942  rpos2 = (xc1 * xc1 + yc1 * yc1);
943  if ((rpos2 > rout2) || (rpos2 < rin2)) {
944  ok = false;
945  ncf = k + base2;
946  break;
947  }
948  nc /= base;
949  }
950  break;
951  }
952  case (HGCalTypes::WaferFive): {
953  static constexpr int nc6[corners] = {23450, 13450, 24501, 35012, 40123, 51234};
954  int nc = nc6[rotn];
955  for (int k1 = 0; k1 < 5; ++k1) {
956  int k = nc % base;
957  double xc1 = xpos + dx0[k];
958  double yc1 = ypos + dy0[k];
959  rpos2 = (xc1 * xc1 + yc1 * yc1);
960  if ((rpos2 > rout2) || (rpos2 < rin2)) {
961  ok = false;
962  ncf = k;
963  break;
964  }
965  }
966  break;
967  }
968  case (HGCalTypes::WaferFive2): {
969  static constexpr int nc60[corners] = {450, 150, 201, 312, 423, 534};
970  static constexpr int nc61[corners] = {601, 803, 1005, 7, 209, 411};
971  int nc = nc60[rotn];
972  for (int k1 = 0; k1 < 3; ++k1) {
973  int k = nc % base;
974  double xc1 = xpos + dx0[k];
975  double yc1 = ypos + dy0[k];
976  rpos2 = (xc1 * xc1 + yc1 * yc1);
977  if ((rpos2 > rout2) || (rpos2 < rin2)) {
978  ok = false;
979  ncf = k;
980  break;
981  }
982  nc /= base;
983  }
984  nc = nc61[rotn];
985  for (int k1 = 0; k1 < 2; ++k1) {
986  int k = nc % base2;
987  double xc1 = xpos + dx2[k];
988  double yc1 = ypos + dy2[k];
989  rpos2 = (xc1 * xc1 + yc1 * yc1);
990  if ((rpos2 > rout2) || (rpos2 < rin2)) {
991  ok = false;
992  ncf = k + base2;
993  break;
994  }
995  nc /= base2;
996  }
997  break;
998  }
999  case (HGCalTypes::WaferHalf2): {
1000  static constexpr int nc70[corners] = {45, 50, 1, 12, 23, 34};
1001  static constexpr int nc71[corners] = {611, 801, 1003, 5, 207, 409};
1002  int nc = nc70[rotn];
1003  for (int k1 = 0; k1 < 2; ++k1) {
1004  int k = nc % base;
1005  double xc1 = xpos + dx0[k];
1006  double yc1 = ypos + dy0[k];
1007  rpos2 = (xc1 * xc1 + yc1 * yc1);
1008  if ((rpos2 > rout2) || (rpos2 < rin2)) {
1009  ok = false;
1010  ncf = k;
1011  break;
1012  }
1013  nc /= base;
1014  }
1015  nc = nc71[rotn];
1016  for (int k1 = 0; k1 < 2; ++k1) {
1017  int k = nc % base2;
1018  double xc1 = xpos + dx2[k];
1019  double yc1 = ypos + dy2[k];
1020  rpos2 = (xc1 * xc1 + yc1 * yc1);
1021  if ((rpos2 > rout2) || (rpos2 < rin2)) {
1022  ok = false;
1023  ncf = k + base2;
1024  break;
1025  }
1026  nc /= base2;
1027  }
1028  break;
1029  }
1030  default: {
1031  for (int k = 0; k < corners; ++k) {
1032  double xc1 = xpos + dx0[k];
1033  double yc1 = ypos + dy0[k];
1034  rpos2 = (xc1 * xc1 + yc1 * yc1);
1035  if ((rpos2 > rout2) || (rpos2 < rin2)) {
1036  ok = false;
1037  ncf = k;
1038  break;
1039  }
1040  }
1041  break;
1042  }
1043  }
1044  if (debug || (!ok))
1045  edm::LogVerbatim("HGCalGeom") << "I/p: xpos " << xpos << " ypos " << ypos << " dX " << delX << " dY " << delY
1046  << " rin " << rin << " rout " << rout << " part " << part << " rotn " << rotn
1047  << " Results: ok " << ok << " ncf " << ncf << " rin " << rin2 << " rout " << rout2
1048  << " rpos " << rpos2;
1049  return ok;
1050 }
1051 
1052 std::vector<std::pair<double, double> > HGCalWaferMask::waferXY(const int& part,
1053  const int& ori,
1054  const int& zside,
1055  const double& waferSize,
1056  const double& offset,
1057  const double& xpos,
1058  const double& ypos,
1059  const bool& v17OrLess) {
1060  // Good for V15 and V16 versions
1061  std::vector<std::pair<double, double> > xy;
1062  int orient = getRotation(-zside, part, ori);
1063 #ifdef EDM_ML_DEBUG
1064  edm::LogVerbatim("HGCalGeom") << "Part " << part << " zSide " << zside << " Orient " << ori << ":" << orient;
1065 #endif
1066  double c22(HGCalTypes::c22), c27(HGCalTypes::c27), c61(HGCalTypes::c61);
1067  double c77(HGCalTypes::c77), c88(HGCalTypes::c88);
1068  if (v17OrLess) {
1069  c22 = HGCalTypes::c22O;
1070  c27 = HGCalTypes::c27O;
1071  c61 = HGCalTypes::c61O;
1072  c77 = HGCalTypes::c77O;
1073  c88 = HGCalTypes::c88O;
1074  }
1075  /*
1076  The exact contour of partial wafers are obtained by joining points on
1077  the circumference of a full wafer.
1078  Numbering the points along the edges of a hexagonal wafer, starting from
1079  the bottom corner:
1080 
1081  3
1082  15 18
1083  9 8
1084  19 14
1085  4 2
1086  16 23
1087  10 7
1088  20 13
1089  5 1
1090  17 22
1091  11 6
1092  21 12
1093  0
1094 
1095  Depending on the wafer type and orientation index, the corners
1096  are chosen in the variable *np*
1097  */
1098  double delX = 0.5 * waferSize;
1099  double delY = delX / sin_60_;
1100  double dx[48] = {HGCalTypes::c00 * delX,
1101  HGCalTypes::c10 * delX,
1102  HGCalTypes::c10 * delX,
1103  HGCalTypes::c00 * delX,
1104  -HGCalTypes::c10 * delX,
1105  -HGCalTypes::c10 * delX,
1106  HGCalTypes::c50 * delX,
1107  HGCalTypes::c10 * delX,
1108  HGCalTypes::c50 * delX,
1109  -HGCalTypes::c50 * delX,
1110  -HGCalTypes::c10 * delX,
1111  -HGCalTypes::c50 * delX,
1112  c22 * delX,
1113  HGCalTypes::c10 * delX,
1114  c77 * delX,
1115  -c22 * delX,
1116  -HGCalTypes::c10 * delX,
1117  -c77 * delX,
1118  c22 * delX,
1119  -c77 * delX,
1120  -HGCalTypes::c10 * delX,
1121  -c22 * delX,
1122  c77 * delX,
1123  HGCalTypes::c10 * delX,
1124  HGCalTypes::c50 * delX,
1125  HGCalTypes::c10 * delX,
1126  HGCalTypes::c50 * delX,
1127  -HGCalTypes::c50 * delX,
1128  -HGCalTypes::c10 * delX,
1129  -HGCalTypes::c50 * delX,
1130  HGCalTypes::c50 * delX,
1131  HGCalTypes::c10 * delX,
1132  HGCalTypes::c50 * delX,
1133  -HGCalTypes::c50 * delX,
1134  -HGCalTypes::c10 * delX,
1135  -HGCalTypes::c50 * delX,
1136  c22 * delX,
1137  HGCalTypes::c10 * delX,
1138  c77 * delX,
1139  -c22 * delX,
1140  -HGCalTypes::c10 * delX,
1141  -c77 * delX,
1142  c22 * delX,
1143  -c77 * delX,
1144  -HGCalTypes::c10 * delX,
1145  -c22 * delX,
1146  c77 * delX,
1147  HGCalTypes::c10 * delX};
1148  double dy[48] = {-HGCalTypes::c10 * delY,
1149  -HGCalTypes::c50 * delY,
1150  HGCalTypes::c50 * delY,
1151  HGCalTypes::c10 * delY,
1152  HGCalTypes::c50 * delY,
1153  -HGCalTypes::c50 * delY,
1154  -HGCalTypes::c75 * delY,
1155  HGCalTypes::c00 * delY,
1156  HGCalTypes::c75 * delY,
1157  HGCalTypes::c75 * delY,
1158  HGCalTypes::c00 * delY,
1159  -HGCalTypes::c75 * delY,
1160  -c88 * delY,
1161  -c27 * delY,
1162  c61 * delY,
1163  c88 * delY,
1164  c27 * delY,
1165  -c61 * delY,
1166  c88 * delY,
1167  c61 * delY,
1168  -c27 * delY,
1169  -c88 * delY,
1170  -c61 * delY,
1171  c27 * delY,
1172  -HGCalTypes::c75 * delY,
1173  HGCalTypes::c00 * delY,
1174  -HGCalTypes::c75 * delY,
1175  HGCalTypes::c00 * delY,
1176  HGCalTypes::c75 * delY,
1177  HGCalTypes::c75 * delY,
1178  HGCalTypes::c00 * delY,
1179  -HGCalTypes::c75 * delY,
1180  HGCalTypes::c75 * delY,
1181  HGCalTypes::c75 * delY,
1182  HGCalTypes::c00 * delY,
1183  -HGCalTypes::c75 * delY,
1184  -c88 * delY,
1185  -c27 * delY,
1186  c61 * delY,
1187  c88 * delY,
1188  c27 * delY,
1189  -c61 * delY,
1190  c88 * delY,
1191  c61 * delY,
1192  -c27 * delY,
1193  -c88 * delY,
1194  -c61 * delY,
1195  c27 * delY};
1196 
1197  double offsetx[48] = {0.0,
1198  -offset,
1199  -offset,
1200  0.0,
1201  offset,
1202  offset,
1203  -offset * cos_60_,
1204  -offset,
1205  -offset * cos_60_,
1206  offset * cos_60_,
1207  offset,
1208  offset * cos_60_,
1209  -offset * cos_60_,
1210  -offset,
1211  -offset * cos_60_,
1212  offset * cos_60_,
1213  offset,
1214  offset * cos_60_,
1215  -offset * cos_60_,
1216  offset * cos_60_,
1217  offset,
1218  offset * cos_60_,
1219  -offset * cos_60_,
1220  -offset,
1221  0.0,
1222  -offset,
1223  -offset,
1224  0.0,
1225  offset,
1226  offset,
1227  0.0,
1228  offset,
1229  offset,
1230  0.0,
1231  -offset,
1232  -offset,
1233  0.0,
1234  -offset,
1235  -offset,
1236  0.0,
1237  offset,
1238  offset,
1239  0.0,
1240  offset,
1241  offset,
1242  0.0,
1243  -offset,
1244  -offset};
1245  double offsety[48] = {offset / sin_60_,
1246  offset / tan_60_,
1247  -offset / tan_60_,
1248  -offset / sin_60_,
1249  -offset / tan_60_,
1250  offset / tan_60_,
1251  offset * sin_60_,
1252  0.0,
1253  -offset * sin_60_,
1254  -offset * sin_60_,
1255  0.0,
1256  offset * sin_60_,
1257  offset * sin_60_,
1258  0.0,
1259  -offset * sin_60_,
1260  -offset * sin_60_,
1261  0.0,
1262  offset * sin_60_,
1263  -offset * sin_60_,
1264  -offset * sin_60_,
1265  0.0,
1266  offset * sin_60_,
1267  offset * sin_60_,
1268  0.0,
1269  offset / sin_60_,
1270  offset / tan_60_,
1271  -offset / tan_60_,
1272  -offset / sin_60_,
1273  -offset / tan_60_,
1274  -offset / sin_60_,
1275  -offset / tan_60_,
1276  offset / tan_60_,
1277  offset / sin_60_,
1278  offset / tan_60_,
1279  -offset / tan_60_,
1280  offset / tan_60_,
1281  offset / sin_60_,
1282  offset / tan_60_,
1283  -offset / tan_60_,
1284  -offset / sin_60_,
1285  -offset / tan_60_,
1286  offset / tan_60_,
1287  -offset / sin_60_,
1288  -offset / tan_60_,
1289  offset / tan_60_,
1290  offset / sin_60_,
1291  offset / tan_60_,
1292  -offset / tan_60_};
1293 
1294  if (part == HGCalTypes::WaferFull) {
1295  int np[7] = {0, 1, 2, 3, 4, 5, 0};
1296  for (int k = 0; k < 7; ++k)
1297  xy.push_back(std::make_pair((xpos + dx[np[k]] + offsetx[np[k]]), (ypos + dy[np[k]] + offsety[np[k]])));
1298  } else if (part == HGCalTypes::WaferFive) {
1299  int np[6][6] = {{0, 2, 3, 4, 5, 0},
1300  {1, 3, 4, 5, 0, 1},
1301  {2, 4, 5, 0, 1, 2},
1302  {3, 5, 0, 1, 2, 3},
1303  {4, 0, 1, 2, 3, 4},
1304  {5, 1, 2, 3, 4, 5}};
1305  for (int k = 0; k < 6; ++k) {
1306  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1307  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1308 #ifdef EDM_ML_DEBUG
1309  edm::LogVerbatim("HGCalGeom") << "WaferFull " << k << " np " << np[orient][k] << " dx "
1310  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1311  << dy[np[orient][k]] + offsety[np[orient][k]];
1312 #endif
1313  }
1314  } else if (part == HGCalTypes::WaferHalf) {
1315  int np[6][5] = {
1316  {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}};
1317  for (int k = 0; k < 5; ++k) {
1318  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1319  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1320 #ifdef EDM_ML_DEBUG
1321  edm::LogVerbatim("HGCalGeom") << "WaferHalf " << k << " np " << np[orient][k] << " dx "
1322  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1323  << dy[np[orient][k]] + offsety[np[orient][k]];
1324 #endif
1325  }
1326  } else if (part == HGCalTypes::WaferThree) {
1327  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}};
1328  for (int k = 0; k < 4; ++k) {
1329  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1330  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1331 #ifdef EDM_ML_DEBUG
1332  edm::LogVerbatim("HGCalGeom") << "WaferThree " << k << " np " << np[orient][k] << " dx "
1333  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1334  << dy[np[orient][k]] + offsety[np[orient][k]];
1335 #endif
1336  }
1337  } else if (part == HGCalTypes::WaferChopTwo) {
1338  int np[6][7] = {{24, 32, 3, 4, 5, 0, 24},
1339  {25, 33, 4, 5, 0, 1, 25},
1340  {26, 34, 5, 0, 1, 2, 26},
1341  {27, 35, 0, 1, 2, 3, 27},
1342  {28, 30, 1, 2, 3, 4, 28},
1343  {29, 31, 2, 3, 4, 5, 29}};
1344  for (int k = 0; k < 7; ++k) {
1345  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1346  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1347 #ifdef EDM_ML_DEBUG
1348  edm::LogVerbatim("HGCalGeom") << "WaferChopTwo " << k << " np " << np[orient][k] << " dx "
1349  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1350  << dy[np[orient][k]] + offsety[np[orient][k]];
1351 #endif
1352  }
1353  } else if (part == HGCalTypes::WaferSemi) {
1354  int np[6][6] = {{6, 9, 4, 5, 0, 6},
1355  {7, 10, 5, 0, 1, 7},
1356  {8, 11, 0, 1, 2, 8},
1357  {9, 6, 1, 2, 3, 9},
1358  {10, 7, 2, 3, 4, 10},
1359  {11, 8, 3, 4, 5, 11}};
1360  for (int k = 0; k < 6; ++k) {
1361  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1362  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1363 #ifdef EDM_ML_DEBUG
1364  edm::LogVerbatim("HGCalGeom") << "WaferSemi " << k << " np " << np[orient][k] << " dx "
1365  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1366  << dy[np[orient][k]] + offsety[np[orient][k]];
1367 #endif
1368  }
1369  } else if (part == HGCalTypes::WaferChopTwoM) {
1370  int np[6][7] = {{36, 42, 3, 4, 5, 0, 36},
1371  {37, 43, 4, 5, 0, 1, 37},
1372  {38, 44, 5, 0, 1, 2, 38},
1373  {39, 45, 0, 1, 2, 3, 39},
1374  {40, 46, 1, 2, 3, 4, 40},
1375  {41, 47, 2, 3, 4, 5, 41}};
1376  for (int k = 0; k < 7; ++k) {
1377  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1378  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1379 #ifdef EDM_ML_DEBUG
1380  edm::LogVerbatim("HGCalGeom") << " WaferChopTwoM " << k << " np " << np[orient][k] << " dx "
1381  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1382  << dy[np[orient][k]] + offsety[np[orient][k]];
1383 #endif
1384  }
1385  } else if (part == HGCalTypes::WaferSemi2) {
1386  int np[6][6] = {{12, 19, 4, 5, 0, 12},
1387  {13, 20, 5, 0, 1, 13},
1388  {14, 21, 0, 1, 2, 14},
1389  {15, 22, 1, 2, 3, 15},
1390  {16, 23, 2, 3, 4, 16},
1391  {17, 18, 3, 4, 5, 17}};
1392  for (int k = 0; k < 6; ++k) {
1393  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1394  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1395 #ifdef EDM_ML_DEBUG
1396  edm::LogVerbatim("HGCalGeom") << "WaferSemi2 " << k << " np " << np[orient][k] << " dx "
1397  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1398  << dy[np[orient][k]] + offsety[np[orient][k]];
1399 #endif
1400  }
1401  } else if (part == HGCalTypes::WaferFive2) {
1402  int np[6][6] = {{22, 15, 4, 5, 0, 22},
1403  {23, 16, 5, 0, 1, 23},
1404  {18, 17, 0, 1, 2, 18},
1405  {19, 12, 1, 2, 3, 19},
1406  {20, 13, 2, 3, 4, 20},
1407  {21, 14, 3, 4, 5, 21}};
1408  for (int k = 0; k < 6; ++k) {
1409  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1410  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1411 #ifdef EDM_ML_DEBUG
1412  edm::LogVerbatim("HGCalGeom") << "WaferFive2 " << k << " np " << np[orient][k] << " dx "
1413  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1414  << dy[np[orient][k]] + offsety[np[orient][k]];
1415 #endif
1416  }
1417  } else if (part == HGCalTypes::WaferHalf2) {
1418  int np[6][5] = {{45, 39, 4, 5, 45},
1419  {46, 40, 5, 0, 46},
1420  {47, 41, 0, 1, 47},
1421  {42, 36, 1, 2, 42},
1422  {43, 37, 2, 3, 43},
1423  {44, 38, 3, 4, 44}};
1424  for (int k = 0; k < 5; ++k) {
1425  xy.push_back(std::make_pair((xpos + dx[np[orient][k]] + offsetx[np[orient][k]]),
1426  (ypos + dy[np[orient][k]] + offsety[np[orient][k]])));
1427 #ifdef EDM_ML_DEBUG
1428  edm::LogVerbatim("HGCalGeom") << "WaferHalf2 " << k << " np " << np[orient][k] << " dx "
1429  << dx[np[orient][k]] + offsetx[np[orient][k]] << " dy "
1430  << dy[np[orient][k]] + offsety[np[orient][k]];
1431 #endif
1432  }
1433  }
1434 #ifdef EDM_ML_DEBUG
1435  edm::LogVerbatim("HGCalGeom") << "I/p: part " << part << " ori " << ori << " zside " << zside << " dX " << delX
1436  << " dY " << delY << " xpos " << xpos << " ypos " << ypos << " O/p having " << xy.size()
1437  << " points:";
1438  std::ostringstream st1;
1439  for (unsigned int i = 0; i < xy.size(); ++i)
1440  st1 << " [" << i << "] " << xy[i].first << ":" << xy[i].second;
1441  edm::LogVerbatim("HGCalGeom") << st1.str();
1442 #endif
1443  return xy;
1444 }
1445 
1446 std::vector<std::pair<double, double> > HGCalWaferMask::waferXY(const int& part,
1447  const int& place,
1448  const double& waferSize,
1449  const double& offset,
1450  const double& xpos,
1451  const double& ypos,
1452  const bool& v17OrLess) {
1453  std::vector<std::pair<double, double> > xy;
1454  // Good for V17 version and uses partial wafer type & placement index
1455 #ifdef EDM_ML_DEBUG
1456  edm::LogVerbatim("HGCalGeom") << "Part " << part << " Placement Index " << place;
1457 #endif
1458  double c22(HGCalTypes::c22), c27(HGCalTypes::c27), c61(HGCalTypes::c61);
1459  double c77(HGCalTypes::c77), c88(HGCalTypes::c88);
1460  if (v17OrLess) {
1461  c22 = HGCalTypes::c22O;
1462  c27 = HGCalTypes::c27O;
1463  c61 = HGCalTypes::c61O;
1464  c77 = HGCalTypes::c77O;
1465  c88 = HGCalTypes::c88O;
1466  }
1467  /*
1468  The exact contour of partial wafers are obtained by joining points on
1469  the circumference of a full wafer.
1470  Numbering the points along the edges of a hexagonal wafer, starting from
1471  the bottom corner:
1472  3
1473  15 18
1474  9 8
1475  19 14
1476  4 2
1477  16 23
1478  10 7
1479  20 13
1480  5 1
1481  17 22
1482  11 6
1483  21 12
1484  0
1485  Depending on the wafer type and placement index, the corners
1486  are chosen in the variable *np*
1487  The points 24-35 are the same as points 12-23 with different offset
1488  */
1489  double delX = 0.5 * waferSize;
1490  double delY = delX / sin_60_;
1491  double dx[60] = {
1492  HGCalTypes::c00 * delX,
1493  HGCalTypes::c10 * delX,
1494  HGCalTypes::c10 * delX,
1495  HGCalTypes::c00 * delX,
1496  -HGCalTypes::c10 * delX,
1497  -HGCalTypes::c10 * delX,
1498  HGCalTypes::c50 * delX,
1499  HGCalTypes::c10 * delX,
1500  HGCalTypes::c50 * delX,
1501  -HGCalTypes::c50 * delX,
1502  -HGCalTypes::c10 * delX,
1503  -HGCalTypes::c50 * delX,
1504  c22 * delX,
1505  HGCalTypes::c10 * delX,
1506  c77 * delX,
1507  -c22 * delX,
1508  -HGCalTypes::c10 * delX,
1509  -c77 * delX,
1510  c22 * delX,
1511  -c77 * delX,
1512  -HGCalTypes::c10 * delX,
1513  -c22 * delX,
1514  c77 * delX,
1515  HGCalTypes::c10 * delX,
1516  c22 * delX,
1517  HGCalTypes::c10 * delX,
1518  c77 * delX,
1519  -c22 * delX,
1520  -HGCalTypes::c10 * delX,
1521  -c77 * delX,
1522  c22 * delX,
1523  -c77 * delX,
1524  -HGCalTypes::c10 * delX,
1525  -c22 * delX,
1526  c77 * delX,
1527  HGCalTypes::c10 * delX,
1528  HGCalTypes::c00 * delX,
1529  HGCalTypes::c10 * delX,
1530  HGCalTypes::c10 * delX,
1531  HGCalTypes::c00 * delX,
1532  -HGCalTypes::c10 * delX,
1533  -HGCalTypes::c10 * delX,
1534  HGCalTypes::c00 * delX,
1535  HGCalTypes::c10 * delX,
1536  HGCalTypes::c10 * delX,
1537  HGCalTypes::c00 * delX,
1538  -HGCalTypes::c10 * delX,
1539  -HGCalTypes::c10 * delX,
1540  HGCalTypes::c00 * delX,
1541  HGCalTypes::c10 * delX,
1542  HGCalTypes::c10 * delX,
1543  HGCalTypes::c00 * delX,
1544  -HGCalTypes::c10 * delX,
1545  -HGCalTypes::c10 * delX,
1546  HGCalTypes::c00 * delX,
1547  HGCalTypes::c10 * delX,
1548  HGCalTypes::c10 * delX,
1549  HGCalTypes::c00 * delX,
1550  -HGCalTypes::c10 * delX,
1551  -HGCalTypes::c10 * delX,
1552  };
1553  double dy[60] = {
1554  -HGCalTypes::c10 * delY,
1555  -HGCalTypes::c50 * delY,
1556  HGCalTypes::c50 * delY,
1557  HGCalTypes::c10 * delY,
1558  HGCalTypes::c50 * delY,
1559  -HGCalTypes::c50 * delY,
1560  -HGCalTypes::c75 * delY,
1561  HGCalTypes::c00 * delY,
1562  HGCalTypes::c75 * delY,
1563  HGCalTypes::c75 * delY,
1564  HGCalTypes::c00 * delY,
1565  -HGCalTypes::c75 * delY,
1566  -c88 * delY,
1567  -c27 * delY,
1568  c61 * delY,
1569  c88 * delY,
1570  c27 * delY,
1571  -c61 * delY,
1572  c88 * delY,
1573  c61 * delY,
1574  -c27 * delY,
1575  -c88 * delY,
1576  -c61 * delY,
1577  c27 * delY,
1578  -c88 * delY,
1579  -c27 * delY,
1580  c61 * delY,
1581  c88 * delY,
1582  c27 * delY,
1583  -c61 * delY,
1584  c88 * delY,
1585  c61 * delY,
1586  -c27 * delY,
1587  -c88 * delY,
1588  -c61 * delY,
1589  c27 * delY,
1590  -HGCalTypes::c10 * delY,
1591  -HGCalTypes::c50 * delY,
1592  HGCalTypes::c50 * delY,
1593  HGCalTypes::c10 * delY,
1594  HGCalTypes::c50 * delY,
1595  -HGCalTypes::c50 * delY,
1596  -HGCalTypes::c10 * delY,
1597  -HGCalTypes::c50 * delY,
1598  HGCalTypes::c50 * delY,
1599  HGCalTypes::c10 * delY,
1600  HGCalTypes::c50 * delY,
1601  -HGCalTypes::c50 * delY,
1602  -HGCalTypes::c10 * delY,
1603  -HGCalTypes::c50 * delY,
1604  HGCalTypes::c50 * delY,
1605  HGCalTypes::c10 * delY,
1606  HGCalTypes::c50 * delY,
1607  -HGCalTypes::c50 * delY,
1608  -HGCalTypes::c10 * delY,
1609  -HGCalTypes::c50 * delY,
1610  HGCalTypes::c50 * delY,
1611  HGCalTypes::c10 * delY,
1612  HGCalTypes::c50 * delY,
1613  -HGCalTypes::c50 * delY,
1614  };
1615 
1616  double offsetx[60] = {0.0,
1617  -offset,
1618  -offset,
1619  0.0,
1620  offset,
1621  offset,
1622  -offset * cos_60_,
1623  -offset,
1624  -offset * cos_60_,
1625  offset * cos_60_,
1626  offset,
1627  offset * cos_60_,
1628  -offset * cos_60_,
1629  -offset,
1630  -offset * cos_60_,
1631  offset * cos_60_,
1632  offset,
1633  offset * cos_60_,
1634  -offset * cos_60_,
1635  offset * cos_60_,
1636  offset,
1637  offset * cos_60_,
1638  -offset * cos_60_,
1639  -offset,
1640  0.0,
1641  -offset,
1642  -offset,
1643  0.0,
1644  offset,
1645  offset,
1646  0.0,
1647  offset,
1648  offset,
1649  0.0,
1650  -offset,
1651  -offset,
1652  -offset,
1653  -offset / cos_60_,
1654  -offset,
1655  offset,
1656  offset / cos_60_,
1657  offset,
1658  offset,
1659  -offset,
1660  -offset / cos_60_,
1661  -offset,
1662  offset,
1663  offset / cos_60_,
1664  -offset * cos_60_,
1665  -offset,
1666  -offset * cos_60_,
1667  offset * cos_60_,
1668  offset,
1669  offset * cos_60_,
1670  offset * cos_60_,
1671  -offset * cos_60_,
1672  -offset,
1673  -offset * cos_60_,
1674  offset * cos_60_,
1675  offset};
1676  double offsety[60] = {offset / sin_60_,
1677  offset / tan_60_,
1678  -offset / tan_60_,
1679  -offset / sin_60_,
1680  -offset / tan_60_,
1681  offset / tan_60_,
1682  offset * sin_60_,
1683  0.0,
1684  -offset * sin_60_,
1685  -offset * sin_60_,
1686  0.0,
1687  offset * sin_60_,
1688  offset * sin_60_,
1689  0.0,
1690  -offset * sin_60_,
1691  -offset * sin_60_,
1692  0.0,
1693  offset * sin_60_,
1694  -offset * sin_60_,
1695  -offset * sin_60_,
1696  0.0,
1697  offset * sin_60_,
1698  offset * sin_60_,
1699  0.0,
1700  offset / sin_60_,
1701  offset / tan_60_,
1702  -offset / tan_60_,
1703  -offset / sin_60_,
1704  -offset / tan_60_,
1705  offset / tan_60_,
1706  -offset / sin_60_,
1707  -offset / tan_60_,
1708  offset / tan_60_,
1709  offset / sin_60_,
1710  offset / tan_60_,
1711  -offset / tan_60_,
1712  offset * tan_60_,
1713  0,
1714  -offset * tan_60_,
1715  -offset * tan_60_,
1716  0,
1717  offset * tan_60_,
1718  offset * tan_60_,
1719  offset * tan_60_,
1720  0,
1721  -offset * tan_60_,
1722  -offset * tan_60_,
1723  0,
1724  offset * sin_60_,
1725  0,
1726  -offset * sin_60_,
1727  -offset * sin_60_,
1728  0,
1729  offset * sin_60_,
1730  offset * sin_60_,
1731  offset * sin_60_,
1732  0,
1733  -offset * sin_60_,
1734  -offset * sin_60_,
1735  0};
1736 
1737  if (part == HGCalTypes::WaferFull) {
1738  int np[7] = {0, 1, 2, 3, 4, 5, 0};
1739  for (int k = 0; k < 7; ++k) {
1740  xy.push_back(std::make_pair((xpos + dx[np[k]] + offsetx[np[k]]), (ypos + dy[np[k]] + offsety[np[k]])));
1741 #ifdef EDM_ML_DEBUG
1742  edm::LogVerbatim("HGCalGeom") << "WaferFull " << k << " np 7 dx " << (dx[np[k]] + offsetx[np[k]]) << " dy "
1743  << (dy[np[k]] + offsety[np[k]]);
1744 #endif
1745  }
1746  } else if (part == HGCalTypes::WaferLDTop) {
1747  int np[12][5] = {{0, 1, 4, 5, 0},
1748  {1, 2, 5, 0, 1},
1749  {2, 3, 0, 1, 2},
1750  {3, 4, 1, 2, 3},
1751  {4, 5, 2, 3, 4},
1752  {5, 0, 3, 4, 5},
1753  {0, 1, 2, 5, 0},
1754  {5, 0, 1, 4, 5},
1755  {4, 5, 0, 3, 4},
1756  {3, 4, 5, 2, 3},
1757  {2, 3, 4, 1, 2},
1758  {1, 2, 3, 0, 1}};
1759  for (int k = 0; k < 5; ++k) {
1760  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1761  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1762 #ifdef EDM_ML_DEBUG
1763  edm::LogVerbatim("HGCalGeom") << "WaferLDTop " << k << " np " << np[place][k] << " dx "
1764  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1765  << dy[np[place][k]] + offsety[np[place][k]];
1766 #endif
1767  }
1768  } else if (part == HGCalTypes::WaferLDBottom) {
1769  int np[12][5] = {{1, 2, 3, 4, 1},
1770  {2, 3, 4, 5, 2},
1771  {3, 4, 5, 0, 3},
1772  {4, 5, 0, 1, 4},
1773  {5, 0, 1, 2, 5},
1774  {0, 1, 2, 3, 0},
1775  {5, 2, 3, 4, 5},
1776  {4, 1, 2, 3, 4},
1777  {3, 0, 1, 2, 3},
1778  {2, 5, 0, 1, 2},
1779  {1, 4, 5, 0, 1},
1780  {0, 3, 4, 5, 0}};
1781  for (int k = 0; k < 5; ++k) {
1782  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1783  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1784 #ifdef EDM_ML_DEBUG
1785  edm::LogVerbatim("HGCalGeom") << "WaferLDBottom " << k << " np " << np[place][k] << " dx "
1786  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1787  << dy[np[place][k]] + offsety[np[place][k]];
1788 #endif
1789  }
1790  } else if (part == HGCalTypes::WaferLDLeft) {
1791  int np[12][6] = {{0, 1, 2, 8, 11, 0},
1792  {1, 2, 3, 9, 6, 1},
1793  {2, 3, 4, 10, 7, 2},
1794  {3, 4, 5, 11, 8, 3},
1795  {4, 5, 0, 6, 9, 4},
1796  {5, 0, 1, 7, 10, 5},
1797  {0, 6, 9, 4, 5, 0},
1798  {5, 11, 8, 3, 4, 5},
1799  {4, 10, 7, 2, 3, 4},
1800  {3, 9, 6, 1, 2, 3},
1801  {2, 8, 11, 0, 1, 2},
1802  {1, 7, 10, 5, 0, 1}};
1803  for (int k = 0; k < 6; ++k) {
1804  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1805  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1806 #ifdef EDM_ML_DEBUG
1807  edm::LogVerbatim("HGCalGeom") << "WaferLDLeft " << k << " np " << np[place][k] << " dx "
1808  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1809  << dy[np[place][k]] + offsety[np[place][k]];
1810 #endif
1811  }
1812  } else if (part == HGCalTypes::WaferLDRight) {
1813  int np[12][6] = {{5, 11, 8, 3, 4, 5},
1814  {0, 6, 9, 4, 5, 0},
1815  {1, 7, 10, 5, 0, 1},
1816  {2, 8, 11, 0, 1, 2},
1817  {3, 9, 6, 1, 2, 3},
1818  {4, 10, 7, 2, 3, 4},
1819  {1, 2, 3, 9, 6, 1},
1820  {0, 1, 2, 8, 11, 0},
1821  {5, 0, 1, 7, 10, 5},
1822  {4, 5, 0, 6, 9, 4},
1823  {3, 4, 5, 11, 8, 3},
1824  {2, 3, 4, 10, 7, 2}};
1825  for (int k = 0; k < 6; ++k) {
1826  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1827  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1828 #ifdef EDM_ML_DEBUG
1829  edm::LogVerbatim("HGCalGeom") << "WaferLDRight " << k << " np " << np[place][k] << " dx "
1830  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1831  << dy[np[place][k]] + offsety[np[place][k]];
1832 #endif
1833  }
1834  } else if (part == HGCalTypes::WaferLDFive) {
1835  int np[12][6] = {{0, 1, 2, 57, 53, 0},
1836  {1, 2, 3, 58, 48, 1},
1837  {2, 3, 4, 59, 49, 2},
1838  {3, 4, 5, 54, 50, 3},
1839  {4, 5, 0, 55, 51, 4},
1840  {5, 0, 1, 56, 52, 5},
1841  {0, 1, 3, 58, 53, 0},
1842  {5, 0, 2, 57, 52, 5},
1843  {4, 5, 1, 56, 51, 4},
1844  {3, 4, 0, 55, 50, 3},
1845  {2, 3, 5, 54, 49, 2},
1846  {1, 2, 4, 59, 48, 1}};
1847  for (int k = 0; k < 6; ++k) {
1848  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1849  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1850 #ifdef EDM_ML_DEBUG
1851  edm::LogVerbatim("HGCalGeom") << "WaferLDFive " << k << " np " << np[place][k] << " dx "
1852  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1853  << dy[np[place][k]] + offsety[np[place][k]];
1854 #endif
1855  }
1856  } else if (part == HGCalTypes::WaferLDThree) {
1857  int np[12][4] = {{41, 45, 4, 41},
1858  {36, 46, 5, 36},
1859  {37, 47, 0, 37},
1860  {38, 42, 1, 38},
1861  {39, 43, 2, 39},
1862  {40, 44, 3, 40},
1863  {43, 2, 39, 43},
1864  {42, 1, 38, 42},
1865  {47, 0, 37, 47},
1866  {46, 5, 36, 46},
1867  {45, 4, 41, 45},
1868  {44, 3, 40, 44}};
1869  for (int k = 0; k < 4; ++k) {
1870  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1871  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1872 #ifdef EDM_ML_DEBUG
1873  edm::LogVerbatim("HGCalGeom") << "WaferLDThree " << k << " np " << np[place][k] << " dx "
1874  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1875  << dy[np[place][k]] + offsety[np[place][k]];
1876 #endif
1877  }
1878  } else if (part == HGCalTypes::WaferHDTop) {
1879  int np[12][5] = {{0, 34, 28, 5, 0},
1880  {1, 35, 29, 0, 1},
1881  {2, 30, 24, 1, 2},
1882  {3, 31, 25, 2, 3},
1883  {4, 32, 26, 3, 4},
1884  {5, 33, 27, 4, 5},
1885  {0, 1, 35, 29, 0},
1886  {5, 0, 34, 28, 5},
1887  {4, 5, 33, 27, 4},
1888  {3, 4, 32, 26, 3},
1889  {2, 3, 31, 25, 2},
1890  {1, 2, 30, 24, 1}};
1891  for (int k = 0; k < 5; ++k) {
1892  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1893  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1894 #ifdef EDM_ML_DEBUG
1895  edm::LogVerbatim("HGCalGeom") << "WaferHDTop " << k << " np " << np[place][k] << " dx "
1896  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1897  << dy[np[place][k]] + offsety[np[place][k]];
1898 #endif
1899  }
1900  } else if (part == HGCalTypes::WaferHDBottom) {
1901  int np[12][7] = {{1, 2, 3, 4, 28, 34, 1},
1902  {2, 3, 4, 5, 29, 35, 2},
1903  {3, 4, 5, 0, 24, 30, 3},
1904  {4, 5, 0, 1, 25, 31, 4},
1905  {5, 0, 1, 2, 26, 32, 5},
1906  {0, 1, 2, 3, 27, 33, 0},
1907  {5, 29, 35, 2, 3, 4, 5},
1908  {4, 28, 34, 1, 2, 3, 4},
1909  {3, 27, 33, 0, 1, 2, 3},
1910  {2, 26, 32, 5, 0, 1, 2},
1911  {1, 25, 31, 4, 5, 0, 1},
1912  {0, 24, 30, 3, 4, 5, 0}};
1913  for (int k = 0; k < 7; ++k) {
1914  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1915  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1916 #ifdef EDM_ML_DEBUG
1917  edm::LogVerbatim("HGCalGeom") << "WaferHDBottom " << k << " np " << np[place][k] << " dx "
1918  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1919  << dy[np[place][k]] + offsety[np[place][k]];
1920 #endif
1921  }
1922  } else if (part == HGCalTypes::WaferHDLeft) {
1923  int np[12][6] = {{0, 1, 2, 14, 21, 0},
1924  {1, 2, 3, 15, 22, 1},
1925  {2, 3, 4, 16, 23, 2},
1926  {3, 4, 5, 17, 18, 3},
1927  {4, 5, 0, 12, 19, 4},
1928  {5, 0, 1, 13, 20, 5},
1929  {0, 12, 19, 4, 5, 0},
1930  {5, 17, 18, 3, 4, 5},
1931  {4, 16, 23, 2, 3, 4},
1932  {3, 15, 22, 1, 2, 3},
1933  {2, 14, 21, 0, 1, 2},
1934  {1, 13, 20, 5, 0, 1}};
1935  for (int k = 0; k < 6; ++k) {
1936  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1937  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1938 #ifdef EDM_ML_DEBUG
1939  edm::LogVerbatim("HGCalGeom") << "WaferHDLeft " << k << " np " << np[place][k] << " dx "
1940  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1941  << dy[np[place][k]] + offsety[np[place][k]];
1942 #endif
1943  }
1944  } else if (part == HGCalTypes::WaferHDRight) {
1945  int np[12][6] = {{5, 17, 18, 3, 4, 5},
1946  {0, 12, 19, 4, 5, 0},
1947  {1, 13, 20, 5, 0, 1},
1948  {2, 14, 21, 0, 1, 2},
1949  {3, 15, 22, 1, 2, 3},
1950  {4, 16, 23, 2, 3, 4},
1951  {1, 2, 3, 15, 22, 1},
1952  {0, 1, 2, 14, 21, 0},
1953  {5, 0, 1, 13, 20, 5},
1954  {4, 5, 0, 12, 19, 4},
1955  {3, 4, 5, 17, 18, 3},
1956  {2, 3, 4, 16, 23, 2}};
1957  for (int k = 0; k < 6; ++k) {
1958  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1959  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1960 #ifdef EDM_ML_DEBUG
1961  edm::LogVerbatim("HGCalGeom") << "WaferHDRight " << k << " np " << np[place][k] << " dx "
1962  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1963  << dy[np[place][k]] + offsety[np[place][k]];
1964 #endif
1965  }
1966  } else if (part == HGCalTypes::WaferHDFive) {
1967  int np[12][6] = {{0, 1, 2, 18, 17, 0},
1968  {1, 2, 3, 19, 12, 1},
1969  {2, 3, 4, 20, 13, 2},
1970  {3, 4, 5, 21, 14, 3},
1971  {4, 5, 0, 22, 15, 4},
1972  {5, 0, 1, 23, 16, 5},
1973  {0, 22, 15, 4, 5, 0},
1974  {5, 21, 14, 3, 4, 5},
1975  {4, 20, 13, 2, 3, 4},
1976  {3, 19, 12, 1, 2, 3},
1977  {2, 18, 17, 0, 1, 2},
1978  {1, 23, 16, 5, 0, 1}};
1979  for (int k = 0; k < 6; ++k) {
1980  xy.push_back(std::make_pair((xpos + dx[np[place][k]] + offsetx[np[place][k]]),
1981  (ypos + dy[np[place][k]] + offsety[np[place][k]])));
1982 #ifdef EDM_ML_DEBUG
1983  edm::LogVerbatim("HGCalGeom") << "WaferHDFive " << k << " np " << np[place][k] << " dx "
1984  << dx[np[place][k]] + offsetx[np[place][k]] << " dy "
1985  << dy[np[place][k]] + offsety[np[place][k]];
1986 #endif
1987  }
1988  }
1989 #ifdef EDM_ML_DEBUG
1990  edm::LogVerbatim("HGCalGeom") << "I/p: part " << part << " place " << place << " dX " << delX << " dY " << delY
1991  << " xpos " << xpos << " ypos " << ypos << " O/p having " << xy.size() << " points:";
1992  std::ostringstream st1;
1993  for (unsigned int i = 0; i < xy.size(); ++i)
1994  st1 << " [" << i << "] " << xy[i].first << ":" << xy[i].second;
1995  edm::LogVerbatim("HGCalGeom") << st1.str();
1996 #endif
1997  return xy;
1998 }
1999 
2000 std::array<double, 4> HGCalWaferMask::maskCut(
2001  const int& part, const int& placement, const double& waferSize, const double& offset, const bool& v17OrLess) {
2002  double c22(HGCalTypes::c22), c27(HGCalTypes::c27);
2003  if (v17OrLess) {
2004  c22 = HGCalTypes::c22O;
2005  c27 = HGCalTypes::c27O;
2006  }
2007  double delX = 0.5 * waferSize;
2008  double delY = 2 * delX / sqrt3_;
2009  double tresh = std::abs(offset / cos_1[placement]);
2010  std::array<double, 4> criterion;
2011  switch (part) {
2012  case (HGCalTypes::WaferLDTop): {
2013  criterion[0] = tan_1[placement];
2014  criterion[1] = 1.0;
2015  criterion[2] = 0.0;
2016  criterion[3] = tresh;
2017  break;
2018  }
2019  case (HGCalTypes::WaferLDBottom): {
2020  criterion[0] = -tan_1[placement];
2021  criterion[1] = -1.0;
2022  criterion[2] = 0.0;
2023  criterion[3] = tresh;
2024  break;
2025  }
2026  case (HGCalTypes::WaferLDLeft): {
2027  criterion[0] = 1.0;
2028  criterion[1] = -tan_1[placement];
2029  criterion[2] = 0.0;
2030  criterion[3] = tresh;
2031  break;
2032  }
2033  case (HGCalTypes::WaferLDRight): {
2034  criterion[0] = -1.0;
2035  criterion[1] = tan_1[placement];
2036  criterion[2] = 0.0;
2037  criterion[3] = tresh;
2038  break;
2039  }
2040  case (HGCalTypes::WaferLDFive): {
2041  criterion[0] = 1;
2042  criterion[1] = -tan_1[placement];
2043  criterion[2] = ((HGCalTypes::c50 * delY) / cos_1[placement]);
2044  criterion[3] = tresh;
2045  break;
2046  }
2047  case (HGCalTypes::WaferLDThree): {
2048  criterion[0] = -1;
2049  criterion[1] = tan_1[placement];
2050  criterion[2] = -((HGCalTypes::c50 * delY) / cos_1[placement]);
2051  criterion[3] = tresh;
2052  break;
2053  }
2054  case (HGCalTypes::WaferHDTop): {
2055  criterion[0] = tan_1[placement];
2056  criterion[1] = 1;
2057  criterion[2] = ((c22 * delX) / cos_1[placement]);
2058  criterion[3] = tresh;
2059  break;
2060  }
2061  case (HGCalTypes::WaferHDBottom): {
2062  criterion[0] = -tan_1[placement];
2063  criterion[1] = -1;
2064  criterion[2] = -((c22 * delX) / cos_1[placement]);
2065  criterion[3] = tresh;
2066  break;
2067  }
2068  case (HGCalTypes::WaferHDLeft): {
2069  criterion[0] = 1.0;
2070  criterion[1] = -tan_1[placement];
2071  criterion[2] = ((c27 * delY) / cos_1[placement]);
2072  criterion[3] = tresh;
2073  break;
2074  }
2075  case (HGCalTypes::WaferHDRight): {
2076  criterion[0] = -1.0;
2077  criterion[1] = tan_1[placement];
2078  criterion[2] = -((c27 * delY) / cos_1[placement]);
2079  criterion[3] = tresh;
2080  break;
2081  }
2082  case (HGCalTypes::WaferHDFive): {
2083  criterion[0] = -1.0;
2084  criterion[1] = tan_1[placement];
2085  criterion[2] = ((c27 * delY) / cos_1[placement]);
2086  criterion[3] = tresh;
2087  break;
2088  }
2089  }
2090  criterion[1] = (placement > HGCalCell::cellPlacementExtra) ? criterion[1] : -criterion[1];
2091  return criterion;
2092 }
HGCalTypes::edgeWaferHDBottom
static constexpr std::array< int, 3 > edgeWaferHDBottom
Definition: HGCalTypes.h:88
HGCalTypes::edgeWaferLDFive
static constexpr std::array< int, 3 > edgeWaferLDFive
Definition: HGCalTypes.h:85
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:134
HGCalTypes::c27O
static constexpr double c27O
Definition: HGCalTypes.h:99
HGCalTypes::WaferHalf2
static constexpr int32_t WaferHalf2
Definition: HGCalTypes.h:43
HGCalTypes::edgeWaferLDLeft
static constexpr std::array< int, 3 > edgeWaferLDLeft
Definition: HGCalTypes.h:83
HGCalTypes::WaferFive2
static constexpr int32_t WaferFive2
Definition: HGCalTypes.h:44
HGCalTypes::edgeWaferLDTop
static constexpr std::array< int, 3 > edgeWaferLDTop
Definition: HGCalTypes.h:81
HGCalTypes::edgeWaferHDLeft
static constexpr std::array< int, 3 > edgeWaferHDLeft
Definition: HGCalTypes.h:89
HGCalTypes::c77O
static constexpr double c77O
Definition: HGCalTypes.h:105
HGCalTypes::k_OffsetRotation
static constexpr int k_OffsetRotation
Definition: HGCalTypes.h:93
mps_fire.i
i
Definition: mps_fire.py:429
HGCalTypes::WaferSizeMax
static constexpr int32_t WaferSizeMax
Definition: HGCalTypes.h:78
HGCalTypes::WaferLDThree
static constexpr int32_t WaferLDThree
Definition: HGCalTypes.h:50
HGCalGeomTools::k_fourCorners
static constexpr int k_fourCorners
Definition: HGCalGeomTools.h:15
HGCalTypes::edgeWaferLDThree
static constexpr std::array< int, 3 > edgeWaferLDThree
Definition: HGCalTypes.h:86
HGCalWaferMask::cos_1
static constexpr std::array< double, 12 > cos_1
Definition: HGCalWaferMask.h:82
HGCalWaferMask::goodCell
static bool goodCell(int u, int v, int N, int type, int rotn)
Definition: HGCalWaferMask.cc:110
HGCalTypes::WaferOut
static constexpr int32_t WaferOut
Definition: HGCalTypes.h:56
newFWLiteAna.base
base
Main Program
Definition: newFWLiteAna.py:92
HGCalGeomTools::k_twoCorners
static constexpr int k_twoCorners
Definition: HGCalGeomTools.h:17
HGCalTypes::WaferThree
static constexpr int32_t WaferThree
Definition: HGCalTypes.h:42
HGCalWaferMask::sqrt3_
static constexpr double sqrt3_
Definition: HGCalWaferMask.h:76
compare_using_db.base2
base2
Definition: compare_using_db.py:175
HGCalTypes::c50
static constexpr double c50
Definition: HGCalTypes.h:101
HGCalTypes::WaferHDFive
static constexpr int32_t WaferHDFive
Definition: HGCalTypes.h:55
HGCalTypes::c88
static constexpr double c88
Definition: HGCalTypes.h:108
ecaldqm::zside
int zside(DetId const &)
Definition: EcalDQMCommonUtils.cc:189
HGCalWaferMask::getRotation
static int getRotation(int zside, int type, int rotn)
Definition: HGCalWaferMask.cc:468
HGCalTypes::c27
static constexpr double c27
Definition: HGCalTypes.h:100
HGCalTypes::c10
static constexpr double c10
Definition: HGCalTypes.h:109
HGCalWaferMask::sin_60_
static constexpr double sin_60_
Definition: HGCalWaferMask.h:77
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
HGCalTypes::WaferSemi2
static constexpr int32_t WaferSemi2
Definition: HGCalTypes.h:41
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
HGCalWaferMask::waferXY
static std::vector< std::pair< double, double > > waferXY(const int &part, const int &orient, const int &zside, const double &waferSize, const double &offset, const double &xpos, const double &ypos, const bool &v17)
Definition: HGCalWaferMask.cc:1052
HGCalTypes::WaferHDLeft
static constexpr int32_t WaferHDLeft
Definition: HGCalTypes.h:53
gpuClustering::pixelStatus::mask
constexpr uint32_t mask
Definition: gpuClustering.h:26
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
HGCalTypes::WaferFull
static constexpr int32_t WaferFull
Definition: HGCalTypes.h:35
HGCalTypes::WaferHalf
static constexpr int32_t WaferHalf
Definition: HGCalTypes.h:39
HGCalTypes::WaferLDBottom
static constexpr int32_t WaferLDBottom
Definition: HGCalTypes.h:46
np
int np
Definition: AMPTWrapper.h:43
ALCARECOPromptCalibProdSiPixelAli0T_cff.mode
mode
Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96
HGCalWaferMask::tan_60_
static constexpr double tan_60_
Definition: HGCalWaferMask.h:79
HGCalTypes::WaferCorner1
static constexpr int32_t WaferCorner1
Definition: HGCalTypes.h:14
HGCalWaferMask::getTypeMode
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, const bool &v17, const bool &debug=false)
Definition: HGCalWaferMask.cc:507
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
HGCalWaferMask::maskCut
static std::array< double, 4 > maskCut(const int &part, const int &place, const double &waferSize, const double &offset, const bool &v17OrLess)
Definition: HGCalWaferMask.cc:2000
HGCalTypes::c22O
static constexpr double c22O
Definition: HGCalTypes.h:96
HGCalTypes::WaferCorner5
static constexpr int32_t WaferCorner5
Definition: HGCalTypes.h:18
HGCalTypes::WaferLDRight
static constexpr int32_t WaferLDRight
Definition: HGCalTypes.h:48
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
HGCalTypes::WaferCorner4
static constexpr int32_t WaferCorner4
Definition: HGCalTypes.h:17
HGCalTypes::WaferCornerMax
static constexpr int32_t WaferCornerMax
Definition: HGCalTypes.h:77
HGCalTypes::WaferCorner2
static constexpr int32_t WaferCorner2
Definition: HGCalTypes.h:15
HGCalTypes::WaferLDFive
static constexpr int32_t WaferLDFive
Definition: HGCalTypes.h:49
HGCalTypes::WaferCorner0
static constexpr int32_t WaferCorner0
Definition: HGCalTypes.h:13
HGCalTypes::WaferLDLeft
static constexpr int32_t WaferLDLeft
Definition: HGCalTypes.h:47
HGCalTypes::c00
static constexpr double c00
Definition: HGCalTypes.h:95
HGCalTypes::WaferHDBottom
static constexpr int32_t WaferHDBottom
Definition: HGCalTypes.h:52
HGCalTypes::WaferCorner3
static constexpr int32_t WaferCorner3
Definition: HGCalTypes.h:16
HGCalTypes::edgeWaferHDTop
static constexpr std::array< int, 3 > edgeWaferHDTop
Definition: HGCalTypes.h:87
HGCalTypes::c88O
static constexpr double c88O
Definition: HGCalTypes.h:107
HGCalWaferMask::goodTypeMode
static bool goodTypeMode(const double &xpos, const double &ypos, const double &delX, const double &delY, const double &rin, const double &rout, const int &part, const int &rotn, const bool &v17, const bool &debug=false)
Definition: HGCalWaferMask.cc:711
HGCalTypes::WaferHDRight
static constexpr int32_t WaferHDRight
Definition: HGCalTypes.h:54
debug
#define debug
Definition: HDRShower.cc:19
HGCalGeomTools::k_fiveCorners
static constexpr int k_fiveCorners
Definition: HGCalGeomTools.h:14
HGCalTypes::WaferChopTwoM
static constexpr int32_t WaferChopTwoM
Definition: HGCalTypes.h:38
HGCalTypes::edgeWaferLDRight
static constexpr std::array< int, 3 > edgeWaferLDRight
Definition: HGCalTypes.h:84
part
part
Definition: HCALResponse.h:20
HGCalTypes::c77
static constexpr double c77
Definition: HGCalTypes.h:106
HGCalTypes::c61
static constexpr double c61
Definition: HGCalTypes.h:103
HGCalWaferMask::cos_60_
static constexpr double cos_60_
Definition: HGCalWaferMask.h:78
HGCalTypes::c61O
static constexpr double c61O
Definition: HGCalTypes.h:102
HGCalGeomTools::k_threeCorners
static constexpr int k_threeCorners
Definition: HGCalGeomTools.h:16
HGCalTypes::WaferLDTop
static constexpr int32_t WaferLDTop
Definition: HGCalTypes.h:45
HGCalTypes::c75
static constexpr double c75
Definition: HGCalTypes.h:104
HGCalTypes::c22
static constexpr double c22
Definition: HGCalTypes.h:97
HGCalTypes::edgeWaferHDFive
static constexpr std::array< int, 3 > edgeWaferHDFive
Definition: HGCalTypes.h:91
HGCalTypes::WaferHDTop
static constexpr int32_t WaferHDTop
Definition: HGCalTypes.h:51
HGCalTypes::WaferFive
static constexpr int32_t WaferFive
Definition: HGCalTypes.h:36
HGCalTypes::WaferSemi
static constexpr int32_t WaferSemi
Definition: HGCalTypes.h:40
HGCalTypes::edgeWaferHDRight
static constexpr std::array< int, 3 > edgeWaferHDRight
Definition: HGCalTypes.h:90
HGCalGeomTools::k_allCorners
static constexpr int k_allCorners
Definition: HGCalGeomTools.h:13
HGCalTypes::edgeWaferLDBottom
static constexpr std::array< int, 3 > edgeWaferLDBottom
Definition: HGCalTypes.h:82
hltrates_dqm_sourceclient-live_cfg.offset
offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:83
HGCalWaferMask::tan_1
static constexpr std::array< double, 12 > tan_1
Definition: HGCalWaferMask.h:80
HGCalTypes::WaferChopTwo
static constexpr int32_t WaferChopTwo
Definition: HGCalTypes.h:37
HGCalCell::cellPlacementExtra
static constexpr int32_t cellPlacementExtra
Definition: HGCalCell.h:24
HGCalWaferMask::maskCell
static bool maskCell(int u, int v, int N, int ncor, int fcor, int corners)
Definition: HGCalWaferMask.cc:13
Generated for CMSSW Reference Manual by doxygen 1.8.14