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 
225  static const int nHits = (PatternSize * 32) / HitSize;
226  bool hasMono[SubstrMask + 1][LayerMask + 1];
227  // printf("sizeof(hasMono) = %d\n", sizeof(hasMono));
228  memset(hasMono, 0, sizeof(hasMono));
229  bool hasStereo[SubstrMask + 1][LayerMask + 1];
230  memset(hasStereo, 0, sizeof(hasStereo));
231  // mark which layers have mono/stereo hits
232  for (int i = 0; i < nHits; i++) {
233  uint32_t pattern = getHitPattern(i);
234  if (pattern == 0) break;
235  if (validHitFilter(pattern) && stripHitFilter(pattern)) {
236  switch (getSide(pattern)) {
237  case 0: // mono
238  hasMono[getSubStructure(pattern)][getLayer(pattern)]
239  = true;
240  break;
241  case 1: // stereo
242  hasStereo[getSubStructure(pattern)][getLayer(pattern)]
243  = true;
244  break;
245  default:
246  break;
247  }
248  }
249 
250  }
251  // count how many layers have mono and stereo hits
252  int count = 0;
253  for (int i = 0; i < SubstrMask + 1; ++i)
254  for (int j = 0; j < LayerMask + 1; ++j)
255  if (hasMono[i][j] && hasStereo[i][j])
256  count++;
257  return count;
258 }
259 
260 uint32_t HitPattern::getTrackerLayerCase(uint32_t substr, uint32_t layer) const {
261  uint32_t tk_substr_layer =
262  (1 << SubDetectorOffset) +
263  ((substr & SubstrMask) << SubstrOffset) +
264  ((layer & LayerMask) << LayerOffset);
265 
266  uint32_t mask =
268  (SubstrMask << SubstrOffset) +
269  (LayerMask << LayerOffset);
270 
271  // crossed
272  // layer case 0: valid + (missing, off, bad) ==> with measurement
273  // layer case 1: missing + (off, bad) ==> without measurement
274  // layer case 2: off, bad ==> totally off or bad, cannot say much
275  // not crossed
276  // layer case 999999: track outside acceptance or in gap ==> null
277 
278  uint32_t layerCase = 999999;
279  for (int i=0; i<(PatternSize * 32) / HitSize; i++)
280  {
281  uint32_t pattern = getHitPattern(i);
282  if (pattern == 0) break;
283  if ((pattern & mask) == tk_substr_layer) {
284  uint32_t hitType = (pattern >> HitTypeOffset) & HitTypeMask; // 0,1,2,3
285  if (hitType < layerCase) {
286  layerCase = hitType;
287  if (hitType == 3) layerCase = 2;
288  }
289  }
290  }
291  return layerCase;
292 }
293 
294 uint32_t HitPattern::getTrackerMonoStereo (uint32_t substr, uint32_t layer) const
295 {
296  uint32_t tk_substr_layer =
297  (1 << SubDetectorOffset) +
298  ((substr & SubstrMask) << SubstrOffset) +
299  ((layer & LayerMask) << LayerOffset);
300 
301  uint32_t mask =
303  (SubstrMask << SubstrOffset) +
304  (LayerMask << LayerOffset);
305 
306  // 0: neither a valid mono nor a valid stereo hit
307  // MONO: valid mono hit
308  // STEREO: valid stereo hit
309  // MONO | STEREO: both
310  uint32_t monoStereo = 0;
311  for (int i=0; i<(PatternSize * 32) / HitSize; i++)
312  {
313  uint32_t pattern = getHitPattern(i);
314  if (pattern == 0) break;
315  if ((pattern & mask) == tk_substr_layer)
316  {
317  uint32_t hitType = (pattern >> HitTypeOffset) & HitTypeMask; // 0,1,2,3
318  if (hitType == 0) { // valid hit
319  switch (getSide(pattern)) {
320  case 0: // mono
321  monoStereo |= MONO;
322  break;
323  case 1: // stereo
324  monoStereo |= STEREO;
325  break;
326  default:
327  break;
328  }
329  }
330  }
331  }
332  return monoStereo;
333 }
334 
335 
336 
338  int count = 0;
339  uint32_t substr = PixelSubdetector::PixelBarrel;
340  uint32_t NPixBarrel = 4;
341  for (uint32_t layer=1; layer<=NPixBarrel; layer++) {
342  if (getTrackerLayerCase(substr, layer) == 0) count++;
343  }
344  return count;
345 }
346 
348  int count = 0;
349  uint32_t substr = PixelSubdetector::PixelEndcap;
350  uint32_t NPixForward = 3;
351  for (uint32_t layer=1; layer<=NPixForward; layer++) {
352  if (getTrackerLayerCase(substr, layer) == 0) count++;
353  }
354  return count;
355 }
356 
358  int count = 0;
359  uint32_t substr = StripSubdetector::TIB;
360  for (uint32_t layer=1; layer<=4; layer++) {
361  if (getTrackerLayerCase(substr, layer) == 0) count++;
362  }
363  return count;
364 }
365 
367  int count = 0;
368  uint32_t substr = StripSubdetector::TID;
369  for (uint32_t layer=1; layer<=3; layer++) {
370  if (getTrackerLayerCase(substr, layer) == 0) count++;
371  }
372  return count;
373 }
374 
376  int count = 0;
377  uint32_t substr = StripSubdetector::TOB;
378  for (uint32_t layer=1; layer<=6; layer++) {
379  if (getTrackerLayerCase(substr, layer) == 0) count++;
380  }
381  return count;
382 }
383 
385  int count = 0;
386  uint32_t substr = StripSubdetector::TEC;
387  for (uint32_t layer=1; layer<=9; layer++) {
388  if (getTrackerLayerCase(substr, layer) == 0) count++;
389  }
390  return count;
391 }
392 
393 
395  int count = 0;
396  uint32_t substr = PixelSubdetector::PixelBarrel;
397  uint32_t NPixBarrel = 4;
398  for (uint32_t layer=1; layer<=NPixBarrel; layer++) {
399  if (getTrackerLayerCase(substr, layer) == 1) count++;
400  }
401  return count;
402 }
403 
405  int count = 0;
406  uint32_t substr = PixelSubdetector::PixelEndcap;
407  uint32_t NPixForward = 3;
408  for (uint32_t layer=1; layer<=NPixForward; layer++) {
409  if (getTrackerLayerCase(substr, layer) == 1) count++;
410  }
411  return count;
412 }
413 
415  int count = 0;
416  uint32_t substr = StripSubdetector::TIB;
417  for (uint32_t layer=1; layer<=4; layer++) {
418  if (getTrackerLayerCase(substr, layer) == 1) count++;
419  }
420  return count;
421 }
422 
424  int count = 0;
425  uint32_t substr = StripSubdetector::TID;
426  for (uint32_t layer=1; layer<=3; layer++) {
427  if (getTrackerLayerCase(substr, layer) == 1) count++;
428  }
429  return count;
430 }
431 
433  int count = 0;
434  uint32_t substr = StripSubdetector::TOB;
435  for (uint32_t layer=1; layer<=6; layer++) {
436  if (getTrackerLayerCase(substr, layer) == 1) count++;
437  }
438  return count;
439 }
440 
442  int count = 0;
443  uint32_t substr = StripSubdetector::TEC;
444  for (uint32_t layer=1; layer<=9; layer++) {
445  if (getTrackerLayerCase(substr, layer) == 1) count++;
446  }
447  return count;
448 }
449 
450 
452  int count = 0;
453  uint32_t substr = PixelSubdetector::PixelBarrel;
454  uint32_t NPixBarrel = 4;
455  for (uint32_t layer=1; layer<=NPixBarrel; layer++) {
456  if (getTrackerLayerCase(substr, layer) == 2) count++;
457  }
458  return count;
459 }
460 
462  int count = 0;
463  uint32_t substr = PixelSubdetector::PixelEndcap;
464  uint32_t NPixForward = 3;
465  for (uint32_t layer=1; layer<=NPixForward; layer++) {
466  if (getTrackerLayerCase(substr, layer) == 2) count++;
467  }
468  return count;
469 }
470 
472  int count = 0;
473  uint32_t substr = StripSubdetector::TIB;
474  for (uint32_t layer=1; layer<=4; layer++) {
475  if (getTrackerLayerCase(substr, layer) == 2) count++;
476  }
477  return count;
478 }
479 
481  int count = 0;
482  uint32_t substr = StripSubdetector::TID;
483  for (uint32_t layer=1; layer<=3; layer++) {
484  if (getTrackerLayerCase(substr, layer) == 2) count++;
485  }
486  return count;
487 }
488 
490  int count = 0;
491  uint32_t substr = StripSubdetector::TOB;
492  for (uint32_t layer=1; layer<=6; layer++) {
493  if (getTrackerLayerCase(substr, layer) == 2) count++;
494  }
495  return count;
496 }
497 
499  int count = 0;
500  uint32_t substr = StripSubdetector::TEC;
501  for (uint32_t layer=1; layer<=9; layer++) {
502  if (getTrackerLayerCase(substr, layer) == 2) count++;
503  }
504  return count;
505 }
506 
507 
509  int count = 0;
510  uint32_t substr = PixelSubdetector::PixelBarrel;
511  uint32_t NPixBarrel = 4;
512  for (uint32_t layer=1; layer<=NPixBarrel; layer++) {
513  if (getTrackerLayerCase(substr, layer) == 999999) count++;
514  }
515  return count;
516 }
517 
519  int count = 0;
520  uint32_t substr = PixelSubdetector::PixelEndcap;
521  uint32_t NPixForward = 3;
522  for (uint32_t layer=1; layer<=NPixForward; layer++) {
523  if (getTrackerLayerCase(substr, layer) == 999999) count++;
524  }
525  return count;
526 }
527 
529  int count = 0;
530  uint32_t substr = StripSubdetector::TIB;
531  for (uint32_t layer=1; layer<=4; layer++) {
532  if (getTrackerLayerCase(substr, layer) == 999999) count++;
533  }
534  return count;
535 }
536 
538  int count = 0;
539  uint32_t substr = StripSubdetector::TID;
540  for (uint32_t layer=1; layer<=3; layer++) {
541  if (getTrackerLayerCase(substr, layer) == 999999) count++;
542  }
543  return count;
544 }
545 
547  int count = 0;
548  uint32_t substr = StripSubdetector::TOB;
549  for (uint32_t layer=1; layer<=6; layer++) {
550  if (getTrackerLayerCase(substr, layer) == 999999) count++;
551  }
552  return count;
553 }
554 
556  int count = 0;
557  uint32_t substr = StripSubdetector::TEC;
558  for (uint32_t layer=1; layer<=9; layer++) {
559  if (getTrackerLayerCase(substr, layer) == 999999) count++;
560  }
561  return count;
562 }
563 
564 void HitPattern::printHitPattern (int position, std::ostream &stream) const
565 {
566  uint32_t pattern = getHitPattern(position);
567  stream << "\t";
568  if (muonHitFilter(pattern))
569  stream << "muon";
570  if (trackerHitFilter(pattern))
571  stream << "tracker";
572  stream << "\tsubstructure " << getSubStructure(pattern);
573  if (muonHitFilter(pattern)) {
574  stream << "\tstation " << getMuonStation(pattern);
575  if (muonDTHitFilter(pattern)) {
576  stream << "\tdt superlayer " << getDTSuperLayer(pattern);
577  } else if (muonCSCHitFilter(pattern)) {
578  stream << "\tcsc ring " << getCSCRing(pattern);
579  } else if (muonRPCHitFilter(pattern)) {
580  stream << "\trpc " << (getRPCregion(pattern) ? "endcaps" : "barrel") << ", layer " << getRPCLayer(pattern);
581  } else {
582  stream << "(UNKNOWN Muon SubStructure!) \tsubsubstructure " << getSubStructure(pattern);
583  }
584  } else {
585  stream << "\tlayer " << getLayer(pattern);
586  }
587  stream << "\thit type " << getHitType(pattern);
588  stream << std::endl;
589 }
590 
591 void HitPattern::print (std::ostream &stream) const
592 {
593  stream << "HitPattern" << std::endl;
594  for (int i = 0; i < numberOfHits(); i++)
595  printHitPattern(i, stream);
596  std::ios_base::fmtflags flags = stream.flags();
597  stream.setf ( std::ios_base::hex, std::ios_base::basefield );
598  stream.setf ( std::ios_base::showbase );
599  for (int i = 0; i < numberOfHits(); i++) {
600  uint32_t pattern = getHitPattern(i);
601  stream << pattern << std::endl;
602  }
603  stream.flags(flags);
604 }
605 
607 {
608  switch (i.det()) {
609  case DetId::Tracker:
610  switch (i.subdetId()) {
613  return 0;
615  {
616  TIBDetId id = i;
617  return id.isStereo();
618  }
620  {
621  TIDDetId id = i;
622  return id.isStereo();
623  }
625  {
626  TOBDetId id = i;
627  return id.isStereo();
628  }
630  {
631  TECDetId id = i;
632  return id.isStereo();
633  }
634  default:
635  return 0;
636  }
637  break;
638  default:
639  return 0;
640  }
641 }
642 
643 int HitPattern::muonStations(int subdet, int hitType) const {
644  int stations[4] = { 0,0,0,0 };
645  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
646  uint32_t pattern = getHitPattern(i);
647  if (pattern == 0) break;
648  if (muonHitFilter(pattern) &&
649  (subdet == 0 || int(getSubStructure(pattern)) == subdet) &&
650  (hitType == -1 || int(getHitType(pattern)) == hitType)) {
651  stations[getMuonStation(pattern)-1] = 1;
652  }
653  }
654  return stations[0]+stations[1]+stations[2]+stations[3];
655 }
656 
657 
659  int ret = 0;
660  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
661  uint32_t pattern = getHitPattern(i);
662  if (pattern == 0) break;
663  if (muonHitFilter(pattern) &&
664  (hitType == -1 || int(getHitType(pattern)) == hitType)) {
665  int stat = getMuonStation(pattern);
666  if (ret == 0 || stat < ret) ret = stat;
667  }
668  }
669  return ret;
670 }
671 
673  int ret = 0;
674  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
675  uint32_t pattern = getHitPattern(i);
676  if (pattern == 0) break;
677  if (muonHitFilter(pattern) &&
678  (hitType == -1 || int(getHitType(pattern)) == hitType)) {
679  int stat = getMuonStation(pattern);
680  if (ret == 0 || stat > ret) ret = stat;
681  }
682  }
683  return ret;
684 }
685 
686 
688  int stations[4] = { 0,0,0,0 };
689  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
690  uint32_t pattern = getHitPattern(i);
691  if (pattern == 0) break;
692  if (muonDTHitFilter(pattern) && validHitFilter(pattern) && getDTSuperLayer(pattern) != 2) {
693  stations[getMuonStation(pattern)-1] = 1;
694  }
695  }
696  return stations[0]+stations[1]+stations[2]+stations[3];
697 }
698 
700  int stations[4] = { 0,0,0,0 };
701  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
702  uint32_t pattern = getHitPattern(i);
703  if (pattern == 0) break;
704  if (muonDTHitFilter(pattern) && validHitFilter(pattern) && getDTSuperLayer(pattern) == 2) {
705  stations[getMuonStation(pattern)-1] = 1;
706  }
707  }
708  return stations[0]+stations[1]+stations[2]+stations[3];
709 }
710 
712  int stations[4][2] = { {0,0}, {0,0}, {0,0}, {0,0} };
713  for (int i=0; i<(PatternSize * 32) / HitSize; i++) {
714  uint32_t pattern = getHitPattern(i);
715  if (pattern == 0) break;
716  if (muonDTHitFilter(pattern) && validHitFilter(pattern)) {
717  stations[getMuonStation(pattern)-1][getDTSuperLayer(pattern) == 2] = 1;
718  }
719  }
720  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];
721 }
722 
723 
724 
int stripTOBLayersWithMeasurement() const
Definition: HitPattern.cc:375
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:534
int outermostMuonStationWithHits(int hitType) const
hitType=-1(all), 0=valid, 3=bad; 0 = no stations at all
Definition: HitPattern.cc:672
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:526
int pixelBarrelLayersNull() const
Definition: HitPattern.cc:508
int stripTIBLayersNull() const
Definition: HitPattern.cc:528
unsigned int layer() const
layer id
Definition: TOBDetId.h:39
static uint32_t getLayer(uint32_t pattern)
Definition: HitPattern.h:501
void appendHit(const TrackingRecHit &hit)
Definition: HitPattern.cc:88
static uint32_t isStereo(DetId)
Definition: HitPattern.cc:606
static uint32_t getCSCRing(uint32_t pattern)
CSC ring (1-4). Only valid for muon CSC patterns, of course.
Definition: HitPattern.h:530
uint32_t hitPattern_[PatternSize]
Definition: HitPattern.h:383
int stripTIBLayersWithMeasurement() const
Definition: HitPattern.cc:357
int stripTECLayersNull() const
Definition: HitPattern.cc:555
static const unsigned short SideOffset
Definition: HitPattern.h:375
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:643
static bool muonDTHitFilter(uint32_t pattern)
Definition: HitPattern.h:460
static const unsigned short SubstrOffset
Definition: HitPattern.h:367
static bool trackerHitFilter(uint32_t pattern)
Definition: HitPattern.h:482
uint32_t getTrackerMonoStereo(uint32_t substr, uint32_t layer) const
Definition: HitPattern.cc:294
int numberOfDTStationsWithRPhiView() const
Definition: HitPattern.cc:687
#define abs(x)
Definition: mlp_lapack.h:159
static uint32_t getHitType(uint32_t pattern)
Definition: HitPattern.h:517
std::vector< Variable::Flags > flags
Definition: MVATrainer.cc:135
int stripTIDLayersWithoutMeasurement() const
Definition: HitPattern.cc:423
static uint32_t getMuonStation(uint32_t pattern)
Muon station (1-4). Only valid for muon patterns, of course.
Definition: HitPattern.h:522
void set(const I &begin, const I &end)
Definition: HitPattern.h:150
void print(std::ostream &stream=std::cout) const
Definition: HitPattern.cc:591
static const unsigned short PatternSize
Definition: HitPattern.h:127
int numberOfValidStripLayersWithMonoAndStereo() const
Definition: HitPattern.cc:224
int pixelBarrelLayersWithoutMeasurement() const
Definition: HitPattern.cc:394
static const unsigned short HitTypeMask
Definition: HitPattern.h:380
int pixelEndcapLayersWithMeasurement() const
Definition: HitPattern.cc:347
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:488
static const int CSC
Definition: MuonSubdetId.h:15
int stripTOBLayersTotallyOffOrBad() const
Definition: HitPattern.cc:489
int stripTIDLayersTotallyOffOrBad() const
Definition: HitPattern.cc:480
int stripTIDLayersWithMeasurement() const
Definition: HitPattern.cc:366
static const unsigned short SubDetectorMask
Definition: HitPattern.h:364
int stripTECLayersTotallyOffOrBad() const
Definition: HitPattern.cc:498
virtual std::vector< const TrackingRecHit * > recHits() const =0
Access to component RecHits (if any)
int numberOfHits() const
Definition: HitPattern.cc:213
static uint32_t getSubStructure(uint32_t pattern)
Definition: HitPattern.h:495
int j
Definition: DBlmapReader.cc:9
int stripTIBLayersWithoutMeasurement() const
Definition: HitPattern.cc:414
int numberOfDTStationsWithRZView() const
Definition: HitPattern.cc:699
static bool muonRPCHitFilter(uint32_t pattern)
Definition: HitPattern.h:474
static bool validHitFilter(uint32_t pattern)
Definition: HitPattern.h:545
int stripTIDLayersNull() const
Definition: HitPattern.cc:537
unsigned int offset(bool)
static const unsigned short HitTypeOffset
Definition: HitPattern.h:379
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:39
unsigned int disk() const
disk id
Definition: PXFDetId.h:43
int numberOfDTStationsWithBothViews() const
Definition: HitPattern.cc:711
static const unsigned short HitSize
Definition: HitPattern.h:130
static uint32_t getSide(uint32_t pattern)
Definition: HitPattern.h:512
int layer() const
Definition: RPCDetId.h:111
Definition: DetId.h:20
int innermostMuonStationWithHits(int hitType) const
hitType=-1(all), 0=valid, 3=bad; 0 = no stations at all
Definition: HitPattern.cc:658
Type getType() const
static const unsigned short SideMask
Definition: HitPattern.h:376
int pixelEndcapLayersWithoutMeasurement() const
Definition: HitPattern.cc:404
static const unsigned short SubDetectorOffset
Definition: HitPattern.h:363
int pixelBarrelLayersWithMeasurement() const
Definition: HitPattern.cc:337
static uint32_t getRPCregion(uint32_t pattern)
RPC region: 0 = barrel, 1 = endcap. Only valid for muon RPC patterns, of course.
Definition: HitPattern.h:540
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:546
uint32_t getTrackerLayerCase(uint32_t substr, uint32_t layer) const
Definition: HitPattern.cc:260
int pixelBarrelLayersTotallyOffOrBad() const
Definition: HitPattern.cc:451
static const unsigned short SubstrMask
Definition: HitPattern.h:368
static const int RPC
Definition: MuonSubdetId.h:16
static const unsigned short LayerOffset
Definition: HitPattern.h:371
int stripTECLayersWithoutMeasurement() const
Definition: HitPattern.cc:441
static bool stripHitFilter(uint32_t pattern)
Definition: HitPattern.h:422
int stripTECLayersWithMeasurement() const
Definition: HitPattern.cc:384
int stripTOBLayersWithoutMeasurement() const
Definition: HitPattern.cc:432
int pixelEndcapLayersTotallyOffOrBad() const
Definition: HitPattern.cc:461
static bool pixelEndcapHitFilter(uint32_t pattern)
Definition: HitPattern.h:415
static bool muonCSCHitFilter(uint32_t pattern)
Definition: HitPattern.h:467
static const int DT
Definition: MuonSubdetId.h:14
void printHitPattern(int position, std::ostream &stream) const
Definition: HitPattern.cc:564
bool hasValidHitInFirstPixelBarrel() const
Definition: HitPattern.cc:183
DetId geographicalId() const
int stripTIBLayersTotallyOffOrBad() const
Definition: HitPattern.cc:471
static const unsigned short LayerMask
Definition: HitPattern.h:372
Detector det() const
get the detector field from this detid
Definition: DetId.h:37
uint32_t getHitPattern(int position) const
Definition: HitPattern.cc:144
static bool pixelBarrelHitFilter(uint32_t pattern)
Definition: HitPattern.h:408
unsigned int wheel() const
wheel id
Definition: TIDDetId.h:50
int pixelEndcapLayersNull() const
Definition: HitPattern.cc:518
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:66
int station() const
Definition: RPCDetId.h:99