CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
HitPattern.cc
Go to the documentation of this file.
12 using namespace reco;
13 
14 
15 uint32_t HitPattern::encode(const TrackingRecHit & hit, unsigned int i){
16 
17  // ignore the rec hit if the number of hit is larger than the max
18  if (i >= 32 * PatternSize / HitSize) return 0;
19 
20  // get rec hit det id and rec hit type
21  DetId id = hit.geographicalId();
22  uint32_t detid = id.det();
23  uint32_t hitType = (uint32_t) hit.getType();
24 
25  // init pattern of this hit to 0
26  uint32_t pattern = 0;
27 
28  // adding tracker/muon detector bit
29  pattern += ((detid)&SubDetectorMask)<<SubDetectorOffset;
30 
31  // adding substructure (PXB,PXF,TIB,TID,TOB,TEC, or DT,CSC,RPC) bits
32  uint32_t subdet = id.subdetId();
33  pattern += ((subdet)&SubstrMask)<<SubstrOffset;
34 
35  // adding layer/disk/wheel bits
36  uint32_t layer = 0;
37  if (detid == DetId::Tracker) {
38  if (subdet == PixelSubdetector::PixelBarrel)
39  layer = PXBDetId(id).layer();
40  else if (subdet == PixelSubdetector::PixelEndcap)
41  layer = PXFDetId(id).disk();
42  else if (subdet == StripSubdetector::TIB)
43  layer = TIBDetId(id).layer();
44  else if (subdet == StripSubdetector::TID)
45  layer = TIDDetId(id).wheel();
46  else if (subdet == StripSubdetector::TOB)
47  layer = TOBDetId(id).layer();
48  else if (subdet == StripSubdetector::TEC)
49  layer = TECDetId(id).wheel();
50  } else if (detid == DetId::Muon) {
51  if (subdet == (uint32_t) MuonSubdetId::DT)
52  layer = ((DTLayerId(id.rawId()).station()-1)<<2) + DTLayerId(id.rawId()).superLayer();
53  else if (subdet == (uint32_t) MuonSubdetId::CSC)
54  layer = ((CSCDetId(id.rawId()).station()-1)<<2) + (CSCDetId(id.rawId()).ring()-1);
55  else if (subdet == (uint32_t) MuonSubdetId::RPC) {
56  RPCDetId rpcid(id.rawId());
57  layer = ((rpcid.station()-1)<<2) + abs(rpcid.region());
58  if (rpcid.station() <= 2) layer += 2*(rpcid.layer()-1);
59  }
60  }
61  pattern += (layer&LayerMask)<<LayerOffset;
62 
63  // adding mono/stereo bit
64  uint32_t side = 0;
65  if (detid == DetId::Tracker) {
66  side = isStereo(id);
67  } else if (detid == DetId::Muon) {
68  side = 0;
69  }
70  pattern += (side&SideMask)<<SideOffset;
71 
72  // adding hit type bits
73  pattern += (hitType&HitTypeMask)<<HitTypeOffset;
74 
75  return pattern;
76 }
77 
78 
80  int offset = position * HitSize;
81  for (int i=0; i<HitSize; i++) {
82  int pos = offset + i;
83  uint32_t bit = (pattern >> i) & 0x1;
84  hitPattern_[pos / 32] += bit << ((offset + i) % 32);
85  }
86 }
87 
89 
90  // get rec hit det id and rec hit type
91  DetId id = hit.geographicalId();
92  uint32_t detid = id.det();
93  uint32_t subdet = id.subdetId();
94 
95  std::vector<const TrackingRecHit*> hits;
96 
97 
98  if (detid == DetId::Tracker)
99  hits.push_back(&hit);
100 
101  if (detid == DetId::Muon) {
102 
103  if (subdet == (uint32_t) MuonSubdetId::DT){
104 
105  // DT rechit (granularity 2)
106  if(hit.dimension() == 1)
107  hits.push_back(&hit);
108 
109  // 4D segment (granularity 0)
110  else if(hit.dimension() > 1){ // Both 2 and 4 dim cases. MB4s have 2D, but formatted in 4D segments
111  std::vector<const TrackingRecHit*> seg2D = hit.recHits(); // 4D --> 2D
112  // load 1D hits (2D --> 1D)
113  for(std::vector<const TrackingRecHit*>::const_iterator it = seg2D.begin(); it != seg2D.end(); ++it){
114  std::vector<const TrackingRecHit*> hits1D = (*it)->recHits();
115  copy(hits1D.begin(),hits1D.end(),back_inserter(hits));
116  }
117  }
118  }
119 
120  else if (subdet == (uint32_t) MuonSubdetId::CSC){
121 
122  // CSC rechit (granularity 2)
123  if(hit.dimension() == 2)
124  hits.push_back(&hit);
125 
126  // 4D segment (granularity 0)
127  if(hit.dimension() == 4)
128  hits = hit.recHits(); // load 2D hits (4D --> 1D)
129  }
130 
131  else if (subdet == (uint32_t) MuonSubdetId::RPC) {
132  hits.push_back(&hit);
133  }
134  }
135 
136  unsigned int i = numberOfHits();
137  for(std::vector<const TrackingRecHit*>::const_iterator it = hits.begin(); it != hits.end(); ++it)
138  set(**it,i++);
139 
140 
141 }
142 
143 
144 uint32_t HitPattern::getHitPattern(int position) const {
145 /* Note: you are not taking a consecutive sequence of HitSize bits starting from position*HitSize
146  as the bit order in the words are reversed.
147  e.g. if position = 0 you take the lowest 10 bits of the first word.
148 
149  I hope this can clarify what is the memory layout of such thing
150 
151  straight 01234567890123456789012345678901 | 23456789012345678901234567890123 | 4567
152  (global) 0 1 2 3 | 3 4 5 6 | 6
153  words [--------------0---------------] | [--------------1---------------] | [---
154  word 01234567890123456789012345678901 | 01234567890123456789012345678901 | 0123
155  (str) 0 1 2 3 | 0 1 2 3 | 0
156  [--------------0---------------] | [--------------1---------------] | [---
157  word 10987654321098765432109876543210 | 10987654321098765432109876543210 | 1098
158  (rev) 32 21 10 0 | 32 21 10 0 | 32
159  reverse 10987654321098765432109876543210 | 32109876543210987654321098765432 | 5432
160  32 21 10 0 | 6 65 54 43 3 9
161 
162  ugly enough, but it's not my fault, I was not even in CMS at that time [gpetrucc] */
163  uint16_t bitEndOffset = (position+1) * HitSize;
164  uint8_t secondWord = (bitEndOffset >> 5);
165  uint8_t secondWordBits = bitEndOffset & (32-1); // that is, bitEndOffset % 32
166  if (secondWordBits >= HitSize) { // full block is in this word
167  uint8_t lowBitsToTrash = secondWordBits - HitSize;
168  uint32_t myResult = (hitPattern_[secondWord] >> lowBitsToTrash) & ((1 << HitSize)-1);
169  return myResult;
170  } else {
171  uint8_t firstWordBits = HitSize - secondWordBits;
172  uint32_t firstWordBlock = hitPattern_[secondWord-1] >> (32-firstWordBits);
173  uint32_t secondWordBlock = hitPattern_[secondWord] & ((1<<secondWordBits)-1);
174  uint32_t myResult = firstWordBlock + (secondWordBlock << firstWordBits);
175  return myResult;
176  }
177 }
178 
179 
180 
181 
182 
184  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
185  uint32_t pattern = getHitPattern(i);
186  if (pattern == 0) break;
187  if (pixelBarrelHitFilter(pattern)) {
188  if (getLayer(pattern) == 1) {
189  if (validHitFilter(pattern)) {
190  return true;
191  }
192  }
193  }
194  }
195  return false;
196 }
197 
199  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
200  uint32_t pattern = getHitPattern(i);
201  if (pattern == 0) break;
202  if (pixelEndcapHitFilter(pattern)) {
203  if (getLayer(pattern) == 1) {
204  if (validHitFilter(pattern)) {
205  return true;
206  }
207  }
208  }
209  }
210  return false;
211 }
212 
214  int count = 0;
215  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
216  uint32_t pattern = getHitPattern(i);
217  if (pattern == 0) break;
218  ++count;
219  }
220  return count;
221 }
222 
223 int HitPattern::numberOfValidStripLayersWithMonoAndStereo (uint32_t stripdet, uint32_t layer) const {
224  static const int nHits = (PatternSize * 32) / HitSize;
225  bool hasMono[SubstrMask + 1][LayerMask + 1];
226  // printf("sizeof(hasMono) = %d\n", sizeof(hasMono));
227  memset(hasMono, 0, sizeof(hasMono));
228  bool hasStereo[SubstrMask + 1][LayerMask + 1];
229  memset(hasStereo, 0, sizeof(hasStereo));
230  // mark which layers have mono/stereo hits
231  for (int i = 0; i < nHits; i++) {
232  uint32_t pattern = getHitPattern(i);
233  if (pattern == 0) break;
234  if (validHitFilter(pattern) && stripHitFilter(pattern)) {
235  if (stripdet!=0 && getSubStructure(pattern)!=stripdet) continue;
236  if (layer!=0 && getSubSubStructure(pattern)!=layer) continue;
237  switch (getSide(pattern)) {
238  case 0: // mono
239  hasMono[getSubStructure(pattern)][getLayer(pattern)]
240  = true;
241  break;
242  case 1: // stereo
243  hasStereo[getSubStructure(pattern)][getLayer(pattern)]
244  = true;
245  break;
246  default:
247  break;
248  }
249  }
250 
251  }
252  // count how many layers have mono and stereo hits
253  int count = 0;
254  for (int i = 0; i < SubstrMask + 1; ++i)
255  for (int j = 0; j < LayerMask + 1; ++j)
256  if (hasMono[i][j] && hasStereo[i][j])
257  count++;
258  return count;
259 }
260 
261 uint32_t HitPattern::getTrackerLayerCase(uint32_t substr, uint32_t layer) const {
262  uint32_t tk_substr_layer =
263  (1 << SubDetectorOffset) +
264  ((substr & SubstrMask) << SubstrOffset) +
265  ((layer & LayerMask) << LayerOffset);
266 
267  uint32_t mask =
269  (SubstrMask << SubstrOffset) +
270  (LayerMask << LayerOffset);
271 
272  // crossed
273  // layer case 0: valid + (missing, off, bad) ==> with measurement
274  // layer case 1: missing + (off, bad) ==> without measurement
275  // layer case 2: off, bad ==> totally off or bad, cannot say much
276  // not crossed
277  // layer case 999999: track outside acceptance or in gap ==> null
278 
279  uint32_t layerCase = 999999;
280  for (int i=0; i<(PatternSize * 32) / HitSize; i++)
281  {
282  uint32_t pattern = getHitPattern(i);
283  if (pattern == 0) break;
284  if ((pattern & mask) == tk_substr_layer) {
285  uint32_t hitType = (pattern >> HitTypeOffset) & HitTypeMask; // 0,1,2,3
286  if (hitType < layerCase) {
287  layerCase = hitType;
288  if (hitType == 3) layerCase = 2;
289  }
290  }
291  }
292  return layerCase;
293 }
294 
295 uint32_t HitPattern::getTrackerMonoStereo (uint32_t substr, uint32_t layer) const
296 {
297  uint32_t tk_substr_layer =
298  (1 << SubDetectorOffset) +
299  ((substr & SubstrMask) << SubstrOffset) +
300  ((layer & LayerMask) << LayerOffset);
301 
302  uint32_t mask =
304  (SubstrMask << SubstrOffset) +
305  (LayerMask << LayerOffset);
306 
307  // 0: neither a valid mono nor a valid stereo hit
308  // MONO: valid mono hit
309  // STEREO: valid stereo hit
310  // MONO | STEREO: both
311  uint32_t monoStereo = 0;
312  for (int i=0; i<(PatternSize * 32) / HitSize; i++)
313  {
314  uint32_t pattern = getHitPattern(i);
315  if (pattern == 0) break;
316  if ((pattern & mask) == tk_substr_layer)
317  {
318  uint32_t hitType = (pattern >> HitTypeOffset) & HitTypeMask; // 0,1,2,3
319  if (hitType == 0) { // valid hit
320  switch (getSide(pattern)) {
321  case 0: // mono
322  monoStereo |= MONO;
323  break;
324  case 1: // stereo
325  monoStereo |= STEREO;
326  break;
327  default:
328  break;
329  }
330  }
331  }
332  }
333  return monoStereo;
334 }
335 
336 
337 
339  int count = 0;
340  uint32_t substr = PixelSubdetector::PixelBarrel;
341  uint32_t NPixBarrel = 4;
342  for (uint32_t layer=1; layer<=NPixBarrel; layer++) {
343  if (getTrackerLayerCase(substr, layer) == 0) count++;
344  }
345  return count;
346 }
347 
349  int count = 0;
350  uint32_t substr = PixelSubdetector::PixelEndcap;
351  uint32_t NPixForward = 3;
352  for (uint32_t layer=1; layer<=NPixForward; layer++) {
353  if (getTrackerLayerCase(substr, layer) == 0) count++;
354  }
355  return count;
356 }
357 
359  int count = 0;
360  uint32_t substr = StripSubdetector::TIB;
361  for (uint32_t layer=1; layer<=4; layer++) {
362  if (getTrackerLayerCase(substr, layer) == 0) count++;
363  }
364  return count;
365 }
366 
368  int count = 0;
369  uint32_t substr = StripSubdetector::TID;
370  for (uint32_t layer=1; layer<=3; layer++) {
371  if (getTrackerLayerCase(substr, layer) == 0) count++;
372  }
373  return count;
374 }
375 
377  int count = 0;
378  uint32_t substr = StripSubdetector::TOB;
379  for (uint32_t layer=1; layer<=6; layer++) {
380  if (getTrackerLayerCase(substr, layer) == 0) count++;
381  }
382  return count;
383 }
384 
386  int count = 0;
387  uint32_t substr = StripSubdetector::TEC;
388  for (uint32_t layer=1; layer<=9; layer++) {
389  if (getTrackerLayerCase(substr, layer) == 0) count++;
390  }
391  return count;
392 }
393 
394 
396  int count = 0;
397  uint32_t substr = PixelSubdetector::PixelBarrel;
398  uint32_t NPixBarrel = 4;
399  for (uint32_t layer=1; layer<=NPixBarrel; layer++) {
400  if (getTrackerLayerCase(substr, layer) == 1) count++;
401  }
402  return count;
403 }
404 
406  int count = 0;
407  uint32_t substr = PixelSubdetector::PixelEndcap;
408  uint32_t NPixForward = 3;
409  for (uint32_t layer=1; layer<=NPixForward; layer++) {
410  if (getTrackerLayerCase(substr, layer) == 1) count++;
411  }
412  return count;
413 }
414 
416  int count = 0;
417  uint32_t substr = StripSubdetector::TIB;
418  for (uint32_t layer=1; layer<=4; layer++) {
419  if (getTrackerLayerCase(substr, layer) == 1) count++;
420  }
421  return count;
422 }
423 
425  int count = 0;
426  uint32_t substr = StripSubdetector::TID;
427  for (uint32_t layer=1; layer<=3; layer++) {
428  if (getTrackerLayerCase(substr, layer) == 1) count++;
429  }
430  return count;
431 }
432 
434  int count = 0;
435  uint32_t substr = StripSubdetector::TOB;
436  for (uint32_t layer=1; layer<=6; layer++) {
437  if (getTrackerLayerCase(substr, layer) == 1) count++;
438  }
439  return count;
440 }
441 
443  int count = 0;
444  uint32_t substr = StripSubdetector::TEC;
445  for (uint32_t layer=1; layer<=9; layer++) {
446  if (getTrackerLayerCase(substr, layer) == 1) count++;
447  }
448  return count;
449 }
450 
451 
453  int count = 0;
454  uint32_t substr = PixelSubdetector::PixelBarrel;
455  uint32_t NPixBarrel = 4;
456  for (uint32_t layer=1; layer<=NPixBarrel; layer++) {
457  if (getTrackerLayerCase(substr, layer) == 2) count++;
458  }
459  return count;
460 }
461 
463  int count = 0;
464  uint32_t substr = PixelSubdetector::PixelEndcap;
465  uint32_t NPixForward = 3;
466  for (uint32_t layer=1; layer<=NPixForward; layer++) {
467  if (getTrackerLayerCase(substr, layer) == 2) count++;
468  }
469  return count;
470 }
471 
473  int count = 0;
474  uint32_t substr = StripSubdetector::TIB;
475  for (uint32_t layer=1; layer<=4; layer++) {
476  if (getTrackerLayerCase(substr, layer) == 2) count++;
477  }
478  return count;
479 }
480 
482  int count = 0;
483  uint32_t substr = StripSubdetector::TID;
484  for (uint32_t layer=1; layer<=3; layer++) {
485  if (getTrackerLayerCase(substr, layer) == 2) count++;
486  }
487  return count;
488 }
489 
491  int count = 0;
492  uint32_t substr = StripSubdetector::TOB;
493  for (uint32_t layer=1; layer<=6; layer++) {
494  if (getTrackerLayerCase(substr, layer) == 2) count++;
495  }
496  return count;
497 }
498 
500  int count = 0;
501  uint32_t substr = StripSubdetector::TEC;
502  for (uint32_t layer=1; layer<=9; layer++) {
503  if (getTrackerLayerCase(substr, layer) == 2) count++;
504  }
505  return count;
506 }
507 
508 
510  int count = 0;
511  uint32_t substr = PixelSubdetector::PixelBarrel;
512  uint32_t NPixBarrel = 4;
513  for (uint32_t layer=1; layer<=NPixBarrel; layer++) {
514  if (getTrackerLayerCase(substr, layer) == 999999) count++;
515  }
516  return count;
517 }
518 
520  int count = 0;
521  uint32_t substr = PixelSubdetector::PixelEndcap;
522  uint32_t NPixForward = 3;
523  for (uint32_t layer=1; layer<=NPixForward; layer++) {
524  if (getTrackerLayerCase(substr, layer) == 999999) count++;
525  }
526  return count;
527 }
528 
530  int count = 0;
531  uint32_t substr = StripSubdetector::TIB;
532  for (uint32_t layer=1; layer<=4; layer++) {
533  if (getTrackerLayerCase(substr, layer) == 999999) count++;
534  }
535  return count;
536 }
537 
539  int count = 0;
540  uint32_t substr = StripSubdetector::TID;
541  for (uint32_t layer=1; layer<=3; layer++) {
542  if (getTrackerLayerCase(substr, layer) == 999999) count++;
543  }
544  return count;
545 }
546 
548  int count = 0;
549  uint32_t substr = StripSubdetector::TOB;
550  for (uint32_t layer=1; layer<=6; layer++) {
551  if (getTrackerLayerCase(substr, layer) == 999999) count++;
552  }
553  return count;
554 }
555 
557  int count = 0;
558  uint32_t substr = StripSubdetector::TEC;
559  for (uint32_t layer=1; layer<=9; layer++) {
560  if (getTrackerLayerCase(substr, layer) == 999999) count++;
561  }
562  return count;
563 }
564 
565 void HitPattern::printHitPattern (int position, std::ostream &stream) const
566 {
567  uint32_t pattern = getHitPattern(position);
568  stream << "\t";
569  if (muonHitFilter(pattern))
570  stream << "muon";
571  if (trackerHitFilter(pattern))
572  stream << "tracker";
573  stream << "\tsubstructure " << getSubStructure(pattern);
574  if (muonHitFilter(pattern)) {
575  stream << "\tstation " << getMuonStation(pattern);
576  if (muonDTHitFilter(pattern)) {
577  stream << "\tdt superlayer " << getDTSuperLayer(pattern);
578  } else if (muonCSCHitFilter(pattern)) {
579  stream << "\tcsc ring " << getCSCRing(pattern);
580  } else if (muonRPCHitFilter(pattern)) {
581  stream << "\trpc " << (getRPCregion(pattern) ? "endcaps" : "barrel") << ", layer " << getRPCLayer(pattern);
582  } else {
583  stream << "(UNKNOWN Muon SubStructure!) \tsubsubstructure " << getSubStructure(pattern);
584  }
585  } else {
586  stream << "\tlayer " << getLayer(pattern);
587  }
588  stream << "\thit type " << getHitType(pattern);
589  stream << std::endl;
590 }
591 
592 void HitPattern::print (std::ostream &stream) const
593 {
594  stream << "HitPattern" << std::endl;
595  for (int i = 0; i < numberOfHits(); i++)
596  printHitPattern(i, stream);
597  std::ios_base::fmtflags flags = stream.flags();
598  stream.setf ( std::ios_base::hex, std::ios_base::basefield );
599  stream.setf ( std::ios_base::showbase );
600  for (int i = 0; i < numberOfHits(); i++) {
601  uint32_t pattern = getHitPattern(i);
602  stream << pattern << std::endl;
603  }
604  stream.flags(flags);
605 }
606 
608 {
609  switch (i.det()) {
610  case DetId::Tracker:
611  switch (i.subdetId()) {
614  return 0;
616  {
617  TIBDetId id = i;
618  return id.isStereo();
619  }
621  {
622  TIDDetId id = i;
623  return id.isStereo();
624  }
626  {
627  TOBDetId id = i;
628  return id.isStereo();
629  }
631  {
632  TECDetId id = i;
633  return id.isStereo();
634  }
635  default:
636  return 0;
637  }
638  break;
639  default:
640  return 0;
641  }
642 }
643 
644 int HitPattern::muonStations(int subdet, int hitType) const {
645  int stations[4] = { 0,0,0,0 };
646  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
647  uint32_t pattern = getHitPattern(i);
648  if (pattern == 0) break;
649  if (muonHitFilter(pattern) &&
650  (subdet == 0 || int(getSubStructure(pattern)) == subdet) &&
651  (hitType == -1 || int(getHitType(pattern)) == hitType)) {
652  stations[getMuonStation(pattern)-1] = 1;
653  }
654  }
655  return stations[0]+stations[1]+stations[2]+stations[3];
656 }
657 
658 
660  int ret = 0;
661  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
662  uint32_t pattern = getHitPattern(i);
663  if (pattern == 0) break;
664  if (muonHitFilter(pattern) &&
665  (hitType == -1 || int(getHitType(pattern)) == hitType)) {
666  int stat = getMuonStation(pattern);
667  if (ret == 0 || stat < ret) ret = stat;
668  }
669  }
670  return ret;
671 }
672 
674  int ret = 0;
675  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
676  uint32_t pattern = getHitPattern(i);
677  if (pattern == 0) break;
678  if (muonHitFilter(pattern) &&
679  (hitType == -1 || int(getHitType(pattern)) == hitType)) {
680  int stat = getMuonStation(pattern);
681  if (ret == 0 || stat > ret) ret = stat;
682  }
683  }
684  return ret;
685 }
686 
687 
689  int stations[4] = { 0,0,0,0 };
690  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
691  uint32_t pattern = getHitPattern(i);
692  if (pattern == 0) break;
693  if (muonDTHitFilter(pattern) && validHitFilter(pattern) && getDTSuperLayer(pattern) != 2) {
694  stations[getMuonStation(pattern)-1] = 1;
695  }
696  }
697  return stations[0]+stations[1]+stations[2]+stations[3];
698 }
699 
701  int stations[4] = { 0,0,0,0 };
702  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
703  uint32_t pattern = getHitPattern(i);
704  if (pattern == 0) break;
705  if (muonDTHitFilter(pattern) && validHitFilter(pattern) && getDTSuperLayer(pattern) == 2) {
706  stations[getMuonStation(pattern)-1] = 1;
707  }
708  }
709  return stations[0]+stations[1]+stations[2]+stations[3];
710 }
711 
713  int stations[4][2] = { {0,0}, {0,0}, {0,0}, {0,0} };
714  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
715  uint32_t pattern = getHitPattern(i);
716  if (pattern == 0) break;
717  if (muonDTHitFilter(pattern) && validHitFilter(pattern)) {
718  stations[getMuonStation(pattern)-1][getDTSuperLayer(pattern) == 2] = 1;
719  }
720  }
721  return stations[0][0]*stations[0][1] + stations[1][0]*stations[1][1] + stations[2][0]*stations[2][1] + stations[3][0]*stations[3][1];
722 }
723 
724 
725 
int stripTOBLayersWithMeasurement() const
Definition: HitPattern.cc:376
int i
Definition: DBlmapReader.cc:9
virtual int dimension() const =0
static uint32_t getRPCLayer(uint32_t pattern)
RPC layer: for station 1 and 2, layer = 1(inner) or 2(outer); for station 3, 4 layer is always 0...
Definition: HitPattern.h:546
int outermostMuonStationWithHits(int hitType) const
hitType=-1(all), 0=valid, 3=bad; 0 = no stations at all
Definition: HitPattern.cc:673
static uint32_t getDTSuperLayer(uint32_t pattern)
DT superlayer (1-3). Where the &quot;hit&quot; was a DT segment, superlayer is 0. Only valid for muon DT patter...
Definition: HitPattern.h:538
int pixelBarrelLayersNull() const
Definition: HitPattern.cc:509
int stripTIBLayersNull() const
Definition: HitPattern.cc:529
unsigned int layer() const
layer id
Definition: TOBDetId.h:39
static uint32_t getLayer(uint32_t pattern)
Definition: HitPattern.h:513
void appendHit(const TrackingRecHit &hit)
Definition: HitPattern.cc:88
static uint32_t isStereo(DetId)
Definition: HitPattern.cc:607
static uint32_t getCSCRing(uint32_t pattern)
CSC ring (1-4). Only valid for muon CSC patterns, of course.
Definition: HitPattern.h:542
uint32_t hitPattern_[PatternSize]
Definition: HitPattern.h:395
int stripTIBLayersWithMeasurement() const
Definition: HitPattern.cc:358
int stripTECLayersNull() const
Definition: HitPattern.cc:556
static const unsigned short SideOffset
Definition: HitPattern.h:387
uint32_t encode(const TrackingRecHit &, unsigned int)
Definition: HitPattern.cc:15
int muonStations(int subdet, int hitType) const
subdet = 0(all), 1(DT), 2(CSC), 3(RPC); hitType=-1(all), 0=valid, 3=bad
Definition: HitPattern.cc:644
static uint32_t getSubSubStructure(uint32_t pattern)
Definition: HitPattern.h:518
static bool muonDTHitFilter(uint32_t pattern)
Definition: HitPattern.h:472
static const unsigned short SubstrOffset
Definition: HitPattern.h:379
static bool trackerHitFilter(uint32_t pattern)
Definition: HitPattern.h:494
uint32_t getTrackerMonoStereo(uint32_t substr, uint32_t layer) const
Definition: HitPattern.cc:295
int numberOfDTStationsWithRPhiView() const
Definition: HitPattern.cc:688
static uint32_t getHitType(uint32_t pattern)
Definition: HitPattern.h:529
std::vector< Variable::Flags > flags
Definition: MVATrainer.cc:135
int stripTIDLayersWithoutMeasurement() const
Definition: HitPattern.cc:424
static uint32_t getMuonStation(uint32_t pattern)
Muon station (1-4). Only valid for muon patterns, of course.
Definition: HitPattern.h:534
void set(const I &begin, const I &end)
Definition: HitPattern.h:151
void print(std::ostream &stream=std::cout) const
Definition: HitPattern.cc:592
static const unsigned short PatternSize
Definition: HitPattern.h:128
int pixelBarrelLayersWithoutMeasurement() const
Definition: HitPattern.cc:395
static const unsigned short HitTypeMask
Definition: HitPattern.h:392
int pixelEndcapLayersWithMeasurement() const
Definition: HitPattern.cc:348
static int position[TOTALCHAMBERS][3]
Definition: ReadPGInfo.cc:509
unsigned int layer() const
layer id
Definition: PXBDetId.h:35
bool hasValidHitInFirstPixelEndcap() const
Definition: HitPattern.cc:198
static bool muonHitFilter(uint32_t pattern)
Definition: HitPattern.h:500
static const int CSC
Definition: MuonSubdetId.h:13
int stripTOBLayersTotallyOffOrBad() const
Definition: HitPattern.cc:490
int stripTIDLayersTotallyOffOrBad() const
Definition: HitPattern.cc:481
int stripTIDLayersWithMeasurement() const
Definition: HitPattern.cc:367
static const unsigned short SubDetectorMask
Definition: HitPattern.h:376
int stripTECLayersTotallyOffOrBad() const
Definition: HitPattern.cc:499
virtual std::vector< const TrackingRecHit * > recHits() const =0
Access to component RecHits (if any)
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
int numberOfHits() const
Definition: HitPattern.cc:213
static uint32_t getSubStructure(uint32_t pattern)
Definition: HitPattern.h:507
int j
Definition: DBlmapReader.cc:9
int stripTIBLayersWithoutMeasurement() const
Definition: HitPattern.cc:415
int numberOfDTStationsWithRZView() const
Definition: HitPattern.cc:700
static bool muonRPCHitFilter(uint32_t pattern)
Definition: HitPattern.h:486
static bool validHitFilter(uint32_t pattern)
Definition: HitPattern.h:557
int stripTIDLayersNull() const
Definition: HitPattern.cc:538
unsigned int offset(bool)
static const unsigned short HitTypeOffset
Definition: HitPattern.h:391
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
unsigned int disk() const
disk id
Definition: PXFDetId.h:43
int numberOfDTStationsWithBothViews() const
Definition: HitPattern.cc:712
static const unsigned short HitSize
Definition: HitPattern.h:131
static uint32_t getSide(uint32_t pattern)
Definition: HitPattern.h:524
int layer() const
Definition: RPCDetId.h:108
Definition: DetId.h:18
int innermostMuonStationWithHits(int hitType) const
hitType=-1(all), 0=valid, 3=bad; 0 = no stations at all
Definition: HitPattern.cc:659
Type getType() const
static const unsigned short SideMask
Definition: HitPattern.h:388
int pixelEndcapLayersWithoutMeasurement() const
Definition: HitPattern.cc:405
static const unsigned short SubDetectorOffset
Definition: HitPattern.h:375
int pixelBarrelLayersWithMeasurement() const
Definition: HitPattern.cc:338
static uint32_t getRPCregion(uint32_t pattern)
RPC region: 0 = barrel, 1 = endcap. Only valid for muon RPC patterns, of course.
Definition: HitPattern.h:552
unsigned int wheel() const
wheel id
Definition: TECDetId.h:52
unsigned int layer() const
layer id
Definition: TIBDetId.h:41
int stripTOBLayersNull() const
Definition: HitPattern.cc:547
uint32_t getTrackerLayerCase(uint32_t substr, uint32_t layer) const
Definition: HitPattern.cc:261
int pixelBarrelLayersTotallyOffOrBad() const
Definition: HitPattern.cc:452
static const unsigned short SubstrMask
Definition: HitPattern.h:380
static const int RPC
Definition: MuonSubdetId.h:14
static const unsigned short LayerOffset
Definition: HitPattern.h:383
int stripTECLayersWithoutMeasurement() const
Definition: HitPattern.cc:442
static bool stripHitFilter(uint32_t pattern)
Definition: HitPattern.h:434
int stripTECLayersWithMeasurement() const
Definition: HitPattern.cc:385
int stripTOBLayersWithoutMeasurement() const
Definition: HitPattern.cc:433
int pixelEndcapLayersTotallyOffOrBad() const
Definition: HitPattern.cc:462
static bool pixelEndcapHitFilter(uint32_t pattern)
Definition: HitPattern.h:427
static bool muonCSCHitFilter(uint32_t pattern)
Definition: HitPattern.h:479
static const int DT
Definition: MuonSubdetId.h:12
void printHitPattern(int position, std::ostream &stream) const
Definition: HitPattern.cc:565
bool hasValidHitInFirstPixelBarrel() const
Definition: HitPattern.cc:183
DetId geographicalId() const
int stripTIBLayersTotallyOffOrBad() const
Definition: HitPattern.cc:472
static const unsigned short LayerMask
Definition: HitPattern.h:384
Detector det() const
get the detector field from this detid
Definition: DetId.h:35
uint32_t getHitPattern(int position) const
Definition: HitPattern.cc:144
int numberOfValidStripLayersWithMonoAndStereo() const
Definition: HitPattern.h:286
static bool pixelBarrelHitFilter(uint32_t pattern)
Definition: HitPattern.h:420
unsigned int wheel() const
wheel id
Definition: TIDDetId.h:50
int pixelEndcapLayersNull() const
Definition: HitPattern.cc:519
void setHitPattern(int position, uint32_t pattern)
Definition: HitPattern.cc:79
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:63
int station() const
Definition: RPCDetId.h:96