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.
13 
15 
16 #include<bitset>
17 
18 using namespace reco;
19 
21  hitCount(0),
22  beginTrackHits(0),
23  endTrackHits(0),
24  beginInner(0),
25  endInner(0),
26  beginOuter(0),
27  endOuter(0)
28 {
30 }
31 
33  hitCount(other.hitCount),
34  beginTrackHits(other.beginTrackHits),
35  endTrackHits(other.endTrackHits),
36  beginInner(other.beginInner),
37  endInner(other.endInner),
38  beginOuter(other.beginOuter),
39  endOuter(other.endOuter)
40 {
41  memcpy(this->hitPattern, other.hitPattern, sizeof(uint16_t) * HitPattern::ARRAY_LENGTH);
42 }
43 
45 {
46  ;
47 }
48 
50 {
51  if (this == &other) {
52  return *this;
53  }
54 
55  this->hitCount = other.hitCount;
56 
57  this->beginTrackHits = other.beginTrackHits;
58  this->endTrackHits = other.endTrackHits;
59 
60  this->beginInner = other.beginInner;
61  this->endInner = other.endInner;
62 
63  this->beginOuter = other.beginOuter;
64  this->endOuter = other.endOuter;
65 
66  memcpy(this->hitPattern, other.hitPattern, sizeof(uint16_t) * HitPattern::ARRAY_LENGTH);
67 
68  return *this;
69 }
70 
72 {
73  this->hitCount = 0;
74  this->beginTrackHits = 0;
75  this->endTrackHits = 0;
76  this->beginInner = 0;
77  this->endInner = 0;
78  this->beginOuter = 0;
79  this->endOuter = 0;
80 
81  memset(this->hitPattern, EMPTY_PATTERN, sizeof(uint16_t) * HitPattern::ARRAY_LENGTH);
82 }
83 
85 {
86  return appendHit(*ref, ttopo);
87 }
88 
89 uint16_t HitPattern::encode(const TrackingRecHit &hit, const TrackerTopology& ttopo)
90 {
91  return encode(hit.geographicalId(), hit.getType(), ttopo);
92 }
93 
94 namespace {
95  uint16_t encodeMuonLayer(const DetId& id) {
96  uint16_t detid = id.det();
97  uint16_t subdet = id.subdetId();
98 
99  uint16_t layer = 0x0;
100  if (detid == DetId::Muon) {
101  switch (subdet) {
102  case MuonSubdetId::DT:
103  layer = ((DTLayerId(id.rawId()).station() - 1) << 2);
104  layer |= DTLayerId(id.rawId()).superLayer();
105  break;
106  case MuonSubdetId::CSC:
107  layer = ((CSCDetId(id.rawId()).station() - 1) << 2);
108  layer |= (CSCDetId(id.rawId()).ring() - 1);
109  break;
110  case MuonSubdetId::RPC:
111  {
112  RPCDetId rpcid(id.rawId());
113  layer = ((rpcid.station() - 1) << 2);
114  layer |= (rpcid.station() <= 2) ? ((rpcid.layer() - 1) << 1) : 0x0;
115  layer |= abs(rpcid.region());
116  }
117  break;
118  case MuonSubdetId::GEM:
119  {
120  GEMDetId gemid(id.rawId());
121  layer = ((gemid.station()-1)<<2);
122  layer |= abs(gemid.layer()-1);
123  }
124  break;
125  }
126  }
127  return layer;
128  }
129 }
130 
131 uint16_t HitPattern::encode(const DetId &id, TrackingRecHit::Type hitType, const TrackerTopology& ttopo)
132 {
133  uint16_t detid = id.det();
134  uint16_t subdet = id.subdetId();
135 
136  // adding layer/disk/wheel bits
137  uint16_t layer = 0x0;
138  if (detid == DetId::Tracker) {
139  layer = ttopo.layer(id);
140  } else if (detid == DetId::Muon) {
141  layer = encodeMuonLayer(id);
142  }
143 
144  // adding mono/stereo bit
145  uint16_t side = 0x0;
146  if (detid == DetId::Tracker) {
147  side = isStereo(id, ttopo);
148  } else if (detid == DetId::Muon) {
149  side = 0x0;
150  }
151 
152  return encode(detid, subdet, layer, side, hitType);
153 }
154 
155 uint16_t HitPattern::encode(uint16_t det, uint16_t subdet, uint16_t layer, uint16_t side, TrackingRecHit::Type hitType) {
157 
158  // adding tracker/muon detector bit
159  pattern |= (det & SubDetectorMask) << SubDetectorOffset;
160 
161  // adding substructure (PXB, PXF, TIB, TID, TOB, TEC, or DT, CSC, RPC,GEM) bits
162  pattern |= (subdet & SubstrMask) << SubstrOffset;
163 
164  // adding layer/disk/wheel bits
165  pattern |= (layer & LayerMask) << LayerOffset;
166 
167  // adding mono/stereo bit
168  pattern |= (side & SideMask) << SideOffset;
169 
170  TrackingRecHit::Type patternHitType = (hitType == TrackingRecHit::missing_inner ||
172 
173  pattern |= (patternHitType & HitTypeMask) << HitTypeOffset;
174 
175  return pattern;
176 }
177 
179 {
180  return appendHit(hit.geographicalId(), hit.getType(), ttopo);
181 }
182 
183 bool HitPattern::appendHit(const DetId &id, TrackingRecHit::Type hitType, const TrackerTopology& ttopo)
184 {
185  //if HitPattern is full, journey ends no matter what.
187  return false;
188  }
189 
190  uint16_t pattern = HitPattern::encode(id, hitType, ttopo);
191 
192  return appendHit(pattern, hitType);
193 }
194 
196 {
197  //if HitPattern is full, journey ends no matter what.
199  return false;
200  }
201 
202  switch (hitType) {
206  case TrackingRecHit::bad:
207  // hitCount != endT => we are not inserting T type of hits but of T'
208  // 0 != beginT || 0 != endT => we already have hits of T type
209  // so we already have hits of T in the vector and we don't want to
210  // mess them with T' hits.
211  if unlikely(((hitCount != endTrackHits) && (0 != beginTrackHits || 0 != endTrackHits))) {
212  cms::Exception("HitPattern")
213  << "TRACK_HITS"
214  << " were stored on this object before hits of some other category were inserted "
215  << "but hits of the same category should be inserted in a row. "
216  << "Please rework the code so it inserts all "
217  << "TRACK_HITS"
218  << " in a row.";
219  return false;
220  }
221  return insertTrackHit(pattern);
222  break;
224  if unlikely(((hitCount != endInner) && (0 != beginInner || 0 != endInner))) {
225  cms::Exception("HitPattern")
226  << "MISSING_INNER_HITS"
227  << " were stored on this object before hits of some other category were inserted "
228  << "but hits of the same category should be inserted in a row. "
229  << "Please rework the code so it inserts all "
230  << "MISSING_INNER_HITS"
231  << " in a row.";
232  return false;
233  }
234  return insertExpectedInnerHit(pattern);
235  break;
237  if unlikely(((hitCount != endOuter) && (0 != beginOuter || 0 != endOuter))) {
238  cms::Exception("HitPattern")
239  << "MISSING_OUTER_HITS"
240  << " were stored on this object before hits of some other category were inserted "
241  << "but hits of the same category should be inserted in a row. "
242  << "Please rework the code so it inserts all "
243  << "MISSING_OUTER_HITS"
244  << " in a row.";
245  return false;
246  }
247  return insertExpectedOuterHit(pattern);
248  break;
249  }
250 
251  return false;
252 }
253 
254 bool HitPattern::appendTrackerHit(uint16_t subdet, uint16_t layer, uint16_t stereo, TrackingRecHit::Type hitType) {
255  return appendHit(encode(DetId::Tracker, subdet, layer, stereo, hitType), hitType);
256 }
257 
259  //if HitPattern is full, journey ends no matter what.
261  return false;
262  }
263 
264  if unlikely(id.det() != DetId::Muon) {
265  throw cms::Exception("HitPattern") << "Got DetId from det " << id.det() << " that is not Muon in appendMuonHit(), which should only be used for muon hits in the HitPattern IO rule";
266  }
267 
268  uint16_t detid = id.det();
269  uint16_t subdet = id.subdetId();
270  return appendHit(encode(detid, subdet, encodeMuonLayer(id), 0, hitType), hitType);
271 }
272 
274 {
275  if unlikely((position < 0 || position >= hitCount)) {
277  }
278  /*
279  Note: you are not taking a consecutive sequence of HIT_LENGTH bits starting from position * HIT_LENGTH
280  as the bit order in the words are reversed.
281  e.g. if position = 0 you take the lowest 10 bits of the first word.
282 
283  I hope this can clarify what is the memory layout of such thing
284 
285  straight 01234567890123456789012345678901 | 23456789012345678901234567890123 | 4567
286  (global) 0 1 2 3 | 3 4 5 6 | 6
287  words [--------------0---------------] | [--------------1---------------] | [---
288  word 01234567890123456789012345678901 | 01234567890123456789012345678901 | 0123
289  (str) 0 1 2 3 | 0 1 2 3 | 0
290  [--------------0---------------] | [--------------1---------------] | [---
291  word 10987654321098765432109876543210 | 10987654321098765432109876543210 | 1098
292  (rev) 32 21 10 0 | 32 21 10 0 | 32
293  reverse 10987654321098765432109876543210 | 32109876543210987654321098765432 | 5432
294  32 21 10 0 | 6 65 54 43 3 9
295 
296  ugly enough, but it's not my fault, I was not even in CMS at that time [gpetrucc]
297  */
298 
299  uint16_t bitEndOffset = (position + 1) * HIT_LENGTH;
300  uint8_t secondWord = (bitEndOffset >> 4);
301  uint8_t secondWordBits = bitEndOffset & (16 - 1); // that is, bitEndOffset % 16
302  if (secondWordBits >= HIT_LENGTH) { // full block is in this word
303  uint8_t lowBitsToTrash = secondWordBits - HIT_LENGTH;
304  uint16_t myResult = (hitPattern[secondWord] >> lowBitsToTrash) & ((1 << HIT_LENGTH) - 1);
305  return myResult;
306  } else {
307  uint8_t firstWordBits = HIT_LENGTH - secondWordBits;
308  uint16_t firstWordBlock = hitPattern[secondWord - 1] >> (16 - firstWordBits);
309  uint16_t secondWordBlock = hitPattern[secondWord] & ((1 << secondWordBits) - 1);
310  uint16_t myResult = firstWordBlock + (secondWordBlock << firstWordBits);
311  return myResult;
312  }
313 }
314 
316 {
317  for (int i = beginTrackHits; i < endTrackHits; ++i) {
319  if (pixelBarrelHitFilter(pattern) && (getLayer(pattern) == 1)
320  && validHitFilter(pattern)) {
321  return true;
322  }
323  }
324  return false;
325 }
326 
328 {
329  for (int i = beginTrackHits; i < endTrackHits; ++i) {
331  if (pixelEndcapHitFilter(pattern) && (getLayer(pattern) == 1)
332  && validHitFilter(pattern)) {
333  return true;
334  }
335  }
336  return false;
337 }
338 
339 int HitPattern::numberOfValidStripLayersWithMonoAndStereo(uint16_t stripdet, uint16_t layer) const
340 {
341  bool hasMono[SubstrMask + 1][LayerMask + 1];
342  bool hasStereo[SubstrMask + 1][LayerMask + 1];
343  memset(hasMono, 0, sizeof(hasMono));
344  memset(hasStereo, 0, sizeof(hasStereo));
345 
346  // mark which layers have mono/stereo hits
347  for (int i = beginTrackHits; i < endTrackHits; ++i) {
349  uint16_t subStructure = getSubStructure(pattern);
350 
351  if (validHitFilter(pattern) && stripHitFilter(pattern)) {
352  if (stripdet != 0 && subStructure != stripdet) {
353  continue;
354  }
355 
356  if (layer != 0 && getSubSubStructure(pattern) != layer) {
357  continue;
358  }
359 
360  switch (getSide(pattern)) {
361  case 0: // mono
362  hasMono[subStructure][getLayer(pattern)] = true;
363  break;
364  case 1: // stereo
365  hasStereo[subStructure][getLayer(pattern)] = true;
366  break;
367  default:
368  ;
369  break;
370  }
371  }
372  }
373 
374  // count how many layers have mono and stereo hits
375  int count = 0;
376  for (int i = 0; i < SubstrMask + 1; ++i) {
377  for (int j = 0; j < LayerMask + 1; ++j) {
378  if (hasMono[i][j] && hasStereo[i][j]) {
379  count++;
380  }
381  }
382  }
383  return count;
384 }
385 
387 {
388  auto category = TRACK_HITS;
389  std::bitset<128> side[2];
390  std::pair<uint8_t, uint8_t> range = getCategoryIndexRange(category);
391  for (int i = range.first; i < range.second; ++i) {
393  if (pattern<minStripWord) continue;
394  uint16_t hitType = (pattern >> HitTypeOffset) & HitTypeMask;
395  if (hitType != HIT_TYPE::VALID) continue;
396  auto apattern = (pattern-minTrackerWord) >> LayerOffset;
397  // assert(apattern<128);
398  side[getSide(pattern)].set(apattern);
399  }
400  // assert(numberOfValidStripLayersWithMonoAndStereo(0, 0)==int((side[0]&side[1]).count()));
401  return (side[0]&side[1]).count();
402 
403 
404 }
405 
407 {
409 }
410 
412 {
414 }
415 
417 {
419 }
420 
422 {
424 }
425 
426 uint32_t HitPattern::getTrackerLayerCase(HitCategory category, uint16_t substr, uint16_t layer) const
427 {
428  uint16_t tk_substr_layer = (0x1 << SubDetectorOffset)
429  + ((substr & SubstrMask) << SubstrOffset)
430  + ((layer & LayerMask) << LayerOffset);
431 
432  uint16_t mask = (SubDetectorMask << SubDetectorOffset)
433  + (SubstrMask << SubstrOffset)
434  + (LayerMask << LayerOffset);
435 
436  // layer case 0: valid + (missing, off, bad) ==> with measurement
437  // layer case 1: missing + (off, bad) ==> without measurement
438  // layer case 2: off, bad ==> totally off or bad, cannot say much
439  // layer case NULL_RETURN: track outside acceptance or in gap ==> null
440  uint32_t layerCase = NULL_RETURN;
441  std::pair<uint8_t, uint8_t> range = getCategoryIndexRange(category);
442  for (int i = range.first; i < range.second; ++i) {
444  if ((pattern & mask) == tk_substr_layer) {
445  uint16_t hitType = (pattern >> HitTypeOffset) & HitTypeMask;
446  if (hitType < layerCase) {
447  // BAD and INACTIVE as the same type (as INACTIVE)
448  layerCase = (hitType == HIT_TYPE::BAD ? HIT_TYPE::INACTIVE : hitType);
449  if (layerCase == HIT_TYPE::VALID) {
450  break;
451  }
452  }
453  }
454  }
455  return layerCase;
456 }
457 
458 uint16_t HitPattern::getTrackerMonoStereo(HitCategory category, uint16_t substr, uint16_t layer) const
459 {
460  uint16_t tk_substr_layer = (0x1 << SubDetectorOffset)
461  + ((substr & SubstrMask) << SubstrOffset)
462  + ((layer & LayerMask) << LayerOffset);
463  uint16_t mask = (SubDetectorMask << SubDetectorOffset)
464  + (SubstrMask << SubstrOffset)
465  + (LayerMask << LayerOffset);
466 
467  // 0: neither a valid mono nor a valid stereo hit
468  // MONO: valid mono hit
469  // STEREO: valid stereo hit
470  // MONO | STEREO: both
471  uint16_t monoStereo = 0x0;
472  std::pair<uint8_t, uint8_t> range = getCategoryIndexRange(category);
473  for (int i = range.first; i < range.second; ++i) {
475  if ((pattern & mask) == tk_substr_layer) {
476  uint16_t hitType = (pattern >> HitTypeOffset) & HitTypeMask;
477  if (hitType == HIT_TYPE::VALID) {
478  switch (getSide(pattern)) {
479  case 0: // mono
480  monoStereo |= MONO;
481  break;
482  case 1: // stereo
483  monoStereo |= STEREO;
484  break;
485  }
486  }
487 
488  if (monoStereo == (MONO | STEREO)) {
489  break;
490  }
491  }
492  }
493  return monoStereo;
494 }
495 
496 
498  auto category = TRACK_HITS;
499  std::bitset<128> layerOk;
500  std::pair<uint8_t, uint8_t> range = getCategoryIndexRange(category);
501  for (int i = range.first; i < range.second; ++i) {
503  if unlikely(!trackerHitFilter(pattern)) continue;
504  if (pattern>minStripWord) continue;
505  uint16_t hitType = (pattern >> HitTypeOffset) & HitTypeMask;
506  if (hitType != HIT_TYPE::VALID) continue;
508  // assert(pattern<128);
509  layerOk.set(pattern);
510  }
511  // assert(pixelLayersWithMeasurementOld()==int(layerOk.count()));
512  return layerOk.count();
513 }
514 
515 
517  auto category = TRACK_HITS;
518  std::bitset<128> layerOk;
519  std::pair<uint8_t, uint8_t> range = getCategoryIndexRange(category);
520  for (int i = range.first; i < range.second; ++i) {
522  if unlikely(!trackerHitFilter(pattern)) continue;
523  uint16_t hitType = (pattern >> HitTypeOffset) & HitTypeMask;
524  if (hitType != HIT_TYPE::VALID) continue;
526  // assert(pattern<128);
527  layerOk.set(pattern);
528  }
529  // assert(trackerLayersWithMeasurementOld()==int(layerOk.count()));
530  return layerOk.count();
531 }
532 
534  std::bitset<128> layerOk;
535  std::bitset<128> layerMissed;
536  std::pair<uint8_t, uint8_t> range = getCategoryIndexRange(category);
537  for (int i = range.first; i < range.second; ++i) {
539  if unlikely(!trackerHitFilter(pattern)) continue;
540  uint16_t hitType = (pattern >> HitTypeOffset) & HitTypeMask;
542  // assert(pattern<128);
543  if (hitType == HIT_TYPE::VALID) layerOk.set(pattern);
544  if (hitType == HIT_TYPE::MISSING) layerMissed.set(pattern);
545  }
546  layerMissed &= ~layerOk;
547 
548  // assert(trackerLayersWithoutMeasurementOld(category)==int(layerMissed.count()));
549 
550  return layerMissed.count();
551 
552 
553 }
554 
555 
557 {
558  int count = 0;
559  uint16_t NPixBarrel = 4;
560  for (uint16_t layer = 1; layer <= NPixBarrel; layer++) {
561  if (getTrackerLayerCase(TRACK_HITS, PixelSubdetector::PixelBarrel, layer) == HIT_TYPE::VALID) {
562  count++;
563  }
564  }
565  return count;
566 }
567 
569 {
570  int count = 0;
571  uint16_t NPixForward = 3;
572  for (uint16_t layer = 1; layer <= NPixForward; layer++) {
573  if (getTrackerLayerCase(TRACK_HITS, PixelSubdetector::PixelEndcap, layer) == HIT_TYPE::VALID) {
574  count++;
575  }
576  }
577  return count;
578 }
579 
581 {
582  int count = 0;
583  for (uint16_t layer = 1; layer <= 4; layer++) {
584  if (getTrackerLayerCase(TRACK_HITS, StripSubdetector::TIB, layer) == HIT_TYPE::VALID) {
585  count++;
586  }
587  }
588  return count;
589 }
590 
592 {
593  int count = 0;
594  for (uint16_t layer = 1; layer <= 3; layer++) {
595  if (getTrackerLayerCase(TRACK_HITS, StripSubdetector::TID, layer) == HIT_TYPE::VALID) {
596  count++;
597  }
598  }
599  return count;
600 }
601 
603 {
604  int count = 0;
605  for (uint16_t layer = 1; layer <= 6; layer++) {
606  if (getTrackerLayerCase(TRACK_HITS, StripSubdetector::TOB, layer) == HIT_TYPE::VALID) {
607  count++;
608  }
609  }
610  return count;
611 }
612 
614 {
615  int count = 0;
616  for (uint16_t layer = 1; layer <= 9; layer++) {
617  if (getTrackerLayerCase(TRACK_HITS, StripSubdetector::TEC, layer) == HIT_TYPE::VALID) {
618  count++;
619  }
620  }
621  return count;
622 }
623 
625 {
626  int count = 0;
627  uint16_t NPixBarrel = 4;
628  for (uint16_t layer = 1; layer <= NPixBarrel; layer++) {
629  if (getTrackerLayerCase(category, PixelSubdetector::PixelBarrel, layer) == HIT_TYPE::MISSING) {
630  count++;
631  }
632  }
633  return count;
634 }
635 
637 {
638  int count = 0;
639  uint16_t NPixForward = 3;
640  for (uint16_t layer = 1; layer <= NPixForward; layer++) {
641  if (getTrackerLayerCase(category, PixelSubdetector::PixelEndcap, layer) == HIT_TYPE::MISSING) {
642  count++;
643  }
644  }
645  return count;
646 }
647 
649 {
650  int count = 0;
651  for (uint16_t layer = 1; layer <= 4; layer++) {
652  if (getTrackerLayerCase(category, StripSubdetector::TIB, layer) == HIT_TYPE::MISSING) {
653  count++;
654  }
655  }
656  return count;
657 }
658 
660 {
661  int count = 0;
662  for (uint16_t layer = 1; layer <= 3; layer++) {
663  if (getTrackerLayerCase(category, StripSubdetector::TID, layer) == HIT_TYPE::MISSING) {
664  count++;
665  }
666  }
667  return count;
668 }
669 
671 {
672  int count = 0;
673  for (uint16_t layer = 1; layer <= 6; layer++) {
674  if (getTrackerLayerCase(category, StripSubdetector::TOB, layer) == HIT_TYPE::MISSING) {
675  count++;
676  }
677  }
678  return count;
679 }
680 
682 {
683  int count = 0;
684  for (uint16_t layer = 1; layer <= 9; layer++) {
685  if (getTrackerLayerCase(category, StripSubdetector::TEC, layer) == HIT_TYPE::MISSING) {
686  count++;
687  }
688  }
689  return count;
690 }
691 
692 
694 {
695  int count = 0;
696  uint16_t NPixBarrel = 4;
697  for (uint16_t layer = 1; layer <= NPixBarrel; layer++) {
698  if (getTrackerLayerCase(TRACK_HITS, PixelSubdetector::PixelBarrel, layer) == HIT_TYPE::INACTIVE) {
699  count++;
700  }
701  }
702  return count;
703 }
704 
706 {
707  int count = 0;
708  uint16_t NPixForward = 3;
709  for (uint16_t layer = 1; layer <= NPixForward; layer++) {
710  if (getTrackerLayerCase(TRACK_HITS, PixelSubdetector::PixelEndcap, layer) == HIT_TYPE::INACTIVE) {
711  count++;
712  }
713  }
714  return count;
715 }
716 
718 {
719  int count = 0;
720  for (uint16_t layer = 1; layer <= 4; layer++) {
721  if (getTrackerLayerCase(TRACK_HITS, StripSubdetector::TIB, layer) == HIT_TYPE::INACTIVE) {
722  count++;
723  }
724  }
725  return count;
726 }
727 
729 {
730  int count = 0;
731  for (uint16_t layer = 1; layer <= 3; layer++) {
732  if (getTrackerLayerCase(TRACK_HITS, StripSubdetector::TID, layer) == HIT_TYPE::INACTIVE) {
733  count++;
734  }
735  }
736  return count;
737 }
738 
740 {
741  int count = 0;
742  for (uint16_t layer = 1; layer <= 6; layer++) {
743 
744  if (getTrackerLayerCase(TRACK_HITS, StripSubdetector::TOB, layer) == HIT_TYPE::INACTIVE) {
745  count++;
746  }
747  }
748  return count;
749 }
750 
752 {
753  int count = 0;
754  for (uint16_t layer = 1; layer <= 9; layer++) {
755  if (getTrackerLayerCase(TRACK_HITS, StripSubdetector::TEC, layer) == HIT_TYPE::INACTIVE) {
756  count++;
757  }
758  }
759  return count;
760 }
761 
763 {
764  int count = 0;
765  uint16_t NPixBarrel = 4;
766  for (uint16_t layer = 1; layer <= NPixBarrel; layer++) {
768  count++;
769  }
770  }
771  return count;
772 }
773 
775 {
776  int count = 0;
777  uint16_t NPixForward = 3;
778  for (uint16_t layer = 1; layer <= NPixForward; layer++) {
780  count++;
781  }
782  }
783  return count;
784 }
785 
787 {
788  int count = 0;
789  for (uint16_t layer = 1; layer <= 4; layer++) {
791  count++;
792  }
793  }
794  return count;
795 }
796 
798 {
799  int count = 0;
800  for (uint16_t layer = 1; layer <= 3; layer++) {
802  count++;
803  }
804  }
805  return count;
806 }
807 
809 {
810  int count = 0;
811  for (uint16_t layer = 1; layer <= 6; layer++) {
813  count++;
814  }
815  }
816  return count;
817 }
818 
820 {
821  int count = 0;
822  for (uint16_t layer = 1; layer <= 9; layer++) {
824  count++;
825  }
826  }
827  return count;
828 }
829 
830 void HitPattern::printHitPattern(HitCategory category, int position, std::ostream &stream) const
831 {
832  uint16_t pattern = getHitPattern(category, position);
833  stream << "\t";
834  if (muonHitFilter(pattern)) {
835  stream << "muon";
836  } else if (trackerHitFilter(pattern)) {
837  stream << "tracker";
838  }
839 
840  stream << "\tsubstructure " << getSubStructure(pattern);
841  if (muonHitFilter(pattern)) {
842  stream << "\tstation " << getMuonStation(pattern);
843  if (muonDTHitFilter(pattern)) {
844  stream << "\tdt superlayer " << getDTSuperLayer(pattern);
845  } else if (muonCSCHitFilter(pattern)) {
846  stream << "\tcsc ring " << getCSCRing(pattern);
847  } else if (muonRPCHitFilter(pattern)) {
848  stream << "\trpc " << (getRPCregion(pattern) ? "endcaps" : "barrel")
849  << ", layer " << getRPCLayer(pattern);
850  } else if (muonGEMHitFilter(pattern)) {
851  stream << "\tgem " << (getGEMLayer(pattern) ? "layer1" : "layer2")
852  << ", station " << getGEMStation(pattern);
853  } else {
854  stream << "(UNKNOWN Muon SubStructure!) \tsubsubstructure "
855  << getSubStructure(pattern);
856  }
857  } else {
858  stream << "\tlayer " << getLayer(pattern);
859  }
860  stream << "\thit type " << getHitType(pattern);
861  stream << std::endl;
862 }
863 
864 void HitPattern::print(HitCategory category, std::ostream &stream) const
865 {
866  stream << "HitPattern" << std::endl;
867  for (int i = 0; i < numberOfHits(category); ++i) {
868  printHitPattern(category, i, stream);
869  }
870  std::ios_base::fmtflags flags = stream.flags();
871  stream.setf(std::ios_base::hex, std::ios_base::basefield);
872  stream.setf(std::ios_base::showbase);
873 
874  for (int i = 0; i < this->numberOfHits(category); ++i) {
875  stream << getHitPattern(category, i) << std::endl;
876  }
877 
878  stream.flags(flags);
879 }
880 
882 {
883  if (i.det() != DetId::Tracker) {
884  return 0;
885  }
886 
887  switch (i.subdetId()) {
890  return 0;
892  return ttopo.tibIsStereo(i);
894  return ttopo.tidIsStereo(i);
896  return ttopo.tobIsStereo(i);
898  return ttopo.tecIsStereo(i);
899  default:
900  return 0;
901  }
902 }
903 
904 int HitPattern::muonStations(int subdet, int hitType) const
905 {
906  int stations[4] = {0, 0, 0, 0};
907  for (int i = beginTrackHits; i < endTrackHits; ++i) {
909  if (muonHitFilter(pattern)
910  && (subdet == 0 || int(getSubStructure(pattern)) == subdet)
911  && (hitType == -1 || int(getHitType(pattern)) == hitType)) {
912  stations[getMuonStation(pattern) - 1] = 1;
913  }
914  }
915 
916  return stations[0] + stations[1] + stations[2] + stations[3];
917 }
918 
920 {
921  int ret = 0;
922  for (int i = beginTrackHits; i < endTrackHits; ++i) {
924  if (muonHitFilter(pattern)
925  && (hitType == -1 || int(getHitType(pattern)) == hitType)) {
926  int stat = getMuonStation(pattern);
927  if (ret == 0 || stat < ret) {
928  ret = stat;
929  }
930  }
931  }
932 
933  return ret;
934 }
935 
937 {
938  int ret = 0;
939  for (int i = beginTrackHits; i < endTrackHits; ++i) {
941  if (muonHitFilter(pattern) &&
942  (hitType == -1 || int(getHitType(pattern)) == hitType)) {
943  int stat = getMuonStation(pattern);
944  if (ret == 0 || stat > ret) {
945  ret = stat;
946  }
947  }
948  }
949  return ret;
950 }
951 
953 {
954  int stations[4] = {0, 0, 0, 0};
955  for (int i = beginTrackHits; i < endTrackHits; ++i) {
957 
958  if (muonDTHitFilter(pattern) && validHitFilter(pattern)
959  && getDTSuperLayer(pattern) != 2) {
960  stations[getMuonStation(pattern) - 1] = 1;
961  }
962  }
963  return stations[0] + stations[1] + stations[2] + stations[3];
964 }
965 
967 {
968  int stations[4] = {0, 0, 0, 0};
969  for (int i = beginTrackHits; i < endTrackHits; ++i) {
971  if (muonDTHitFilter(pattern) && validHitFilter(pattern)
972  && getDTSuperLayer(pattern) == 2) {
973  stations[getMuonStation(pattern) - 1] = 1;
974  }
975  }
976  return stations[0] + stations[1] + stations[2] + stations[3];
977 }
978 
980 {
981  int stations[4][2] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
982  for (int i = beginTrackHits; i < endTrackHits; ++i) {
984  if (muonDTHitFilter(pattern) && validHitFilter(pattern)) {
985  stations[getMuonStation(pattern) - 1][getDTSuperLayer(pattern) == 2] = 1;
986  }
987  }
988 
989  return stations[0][0] * stations[0][1]
990  + stations[1][0] * stations[1][1]
991  + stations[2][0] * stations[2][1]
992  + stations[3][0] * stations[3][1];
993 }
994 
995 void HitPattern::insertHit(const uint16_t pattern)
996 {
997  int offset = hitCount * HIT_LENGTH;
998  for (int i = 0; i < HIT_LENGTH; i++) {
999  int pos = offset + i;
1000  uint16_t bit = (pattern >> i) & 0x1;
1001  //equivalent to hitPattern[pos / 16] += bit << ((offset + i) % 16);
1002  hitPattern[pos >> 4] += bit << ((offset + i) & (16 - 1));
1003  }
1004  hitCount++;
1005 }
1006 
1008 {
1009  // if begin is 0, this is the first hit of this type being inserted, so
1010  // we need to update begin so it points to the correct index, the first
1011  // empty index.
1012  // unlikely, because it will happen only when inserting
1013  // the first hit of this type
1014  if unlikely((0 == beginTrackHits && 0 == endTrackHits)) {
1016  // before the first hit of this type is inserted, there are no hits
1018  }
1019 
1020  insertHit(pattern);
1021  endTrackHits++;
1022 
1023  return true;
1024 }
1025 
1027 {
1028  if unlikely((0 == beginInner && 0 == endInner)) {
1029  beginInner = hitCount;
1030  endInner = beginInner;
1031  }
1032 
1033  insertHit(pattern);
1034  endInner++;
1035 
1036  return true;
1037 }
1038 
1040 {
1041  if unlikely((0 == beginOuter && 0 == endOuter)) {
1042  beginOuter = hitCount;
1043  endOuter = beginOuter;
1044  }
1045 
1046  insertHit(pattern);
1047  endOuter++;
1048 
1049  return true;
1050 }
1051 
int stripTOBLayersWithMeasurement() const
Definition: HitPattern.cc:602
static uint16_t getCSCRing(uint16_t pattern)
CSC ring (1-4). Only valid for muon CSC patterns, of course.
Definition: HitPattern.h:732
int pixelBarrelLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:624
int i
Definition: DBlmapReader.cc:9
static uint32_t getLayer(uint16_t pattern)
Definition: HitPattern.h:680
void insertHit(const uint16_t pattern)
Definition: HitPattern.cc:995
int outermostMuonStationWithHits(int hitType) const
hitType=-1(all), 0=valid, 3=bad; 0 = no stations at all
Definition: HitPattern.cc:936
static const unsigned short HIT_LENGTH
Definition: HitPattern.h:166
static const unsigned short ARRAY_LENGTH
Definition: HitPattern.h:165
static const uint32_t NULL_RETURN
Definition: HitPattern.h:169
int pixelBarrelLayersNull() const
Definition: HitPattern.cc:762
int stripTIBLayersNull() const
Definition: HitPattern.cc:786
static uint16_t isStereo(DetId i, const TrackerTopology &ttopo)
Definition: HitPattern.cc:881
bool tobIsStereo(const DetId &id) const
int stripTIBLayersWithMeasurement() const
Definition: HitPattern.cc:580
int stripTECLayersNull() const
Definition: HitPattern.cc:819
static const unsigned short SideOffset
Definition: HitPattern.h:412
static const uint16_t EMPTY_PATTERN
Definition: HitPattern.h:170
int muonStations(int subdet, int hitType) const
subdet = 0(all), 1(DT), 2(CSC), 3(RPC) 4(GEM); hitType=-1(all), 0=valid, 3=bad
Definition: HitPattern.cc:904
static uint16_t getDTSuperLayer(uint16_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:727
static const unsigned short SubstrOffset
Definition: HitPattern.h:420
int stripTOBLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:670
int numberOfDTStationsWithRPhiView() const
Definition: HitPattern.cc:952
static const int GEM
Definition: MuonSubdetId.h:15
HitPattern & operator=(const HitPattern &other)
Definition: HitPattern.cc:49
uint16_t getTrackerMonoStereo(HitCategory category, uint16_t substr, uint16_t layer) const
Definition: HitPattern.cc:458
static const unsigned short MaxHits
Definition: HitPattern.h:167
uint32_t getTrackerLayerCase(HitCategory category, uint16_t substr, uint16_t layer) const
Definition: HitPattern.cc:426
std::vector< Variable::Flags > flags
Definition: MVATrainer.cc:135
int pixelLayersWithMeasurement() const
Definition: HitPattern.cc:497
int numberOfValidStripLayersWithMonoAndStereo() const
Definition: HitPattern.cc:386
int pixelEndcapLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:636
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:516
static const unsigned short HitTypeMask
Definition: HitPattern.h:409
static bool pixelBarrelHitFilter(uint16_t pattern)
Definition: HitPattern.h:562
int pixelEndcapLayersWithMeasurement() const
Definition: HitPattern.cc:568
bool insertExpectedOuterHit(const uint16_t pattern)
Definition: HitPattern.cc:1039
bool tidIsStereo(const DetId &id) const
static bool pixelEndcapHitFilter(uint16_t pattern)
Definition: HitPattern.h:572
1: Failed selection (without additional info)
Definition: ParticleCode.h:34
bool hasValidHitInFirstPixelEndcap() const
Definition: HitPattern.cc:327
static bool validHitFilter(uint16_t pattern)
Definition: HitPattern.h:765
#define unlikely(x)
uint8_t endInner
Definition: HitPattern.h:465
void printHitPattern(HitCategory category, int position, std::ostream &stream) const
Definition: HitPattern.cc:830
bool tecIsStereo(const DetId &id) const
static uint16_t getGEMLayer(uint16_t pattern)
GEM layer: 1,2. Only valid for muon GEM patterns, of course.
Definition: HitPattern.h:760
static const int CSC
Definition: MuonSubdetId.h:13
int stripTOBLayersTotallyOffOrBad() const
Definition: HitPattern.cc:739
static const unsigned short minTrackerWord
Definition: HitPattern.h:427
uint16_t hitPattern[ARRAY_LENGTH]
Definition: HitPattern.h:459
int stripTIDLayersTotallyOffOrBad() const
Definition: HitPattern.cc:728
static bool muonCSCHitFilter(uint16_t pattern)
Definition: HitPattern.h:627
static uint32_t getHitType(uint16_t pattern)
Definition: HitPattern.h:713
int numberOfValidTECLayersWithMonoAndStereo(uint32_t layer=0) const
Definition: HitPattern.cc:421
int stripTIDLayersWithMeasurement() const
Definition: HitPattern.cc:591
static const unsigned short SubDetectorMask
Definition: HitPattern.h:425
static bool stripHitFilter(uint16_t pattern)
Definition: HitPattern.h:582
int stripTECLayersTotallyOffOrBad() const
Definition: HitPattern.cc:751
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
int j
Definition: DBlmapReader.cc:9
bool appendHit(const TrackingRecHit &hit, const TrackerTopology &ttopo)
Definition: HitPattern.cc:178
int numberOfDTStationsWithRZView() const
Definition: HitPattern.cc:966
uint8_t beginInner
Definition: HitPattern.h:464
int stripTIDLayersNull() const
Definition: HitPattern.cc:797
static const unsigned short HitTypeOffset
Definition: HitPattern.h:408
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
int numberOfValidTIDLayersWithMonoAndStereo(uint32_t layer=0) const
Definition: HitPattern.cc:416
bool appendTrackerHit(uint16_t subdet, uint16_t layer, uint16_t stereo, TrackingRecHit::Type hitType)
Definition: HitPattern.cc:254
uint8_t beginTrackHits
Definition: HitPattern.h:462
static uint32_t getSubStructure(uint16_t pattern)
Definition: HitPattern.h:671
int numberOfDTStationsWithBothViews() const
Definition: HitPattern.cc:979
int numberOfValidTIBLayersWithMonoAndStereo(uint32_t layer=0) const
Definition: HitPattern.cc:411
static uint16_t getRPCregion(uint16_t pattern)
RPC region: 0 = barrel, 1 = endcap. Only valid for muon RPC patterns, of course.
Definition: HitPattern.h:749
static bool muonGEMHitFilter(uint16_t pattern)
Definition: HitPattern.h:647
static uint16_t getGEMStation(uint16_t pattern)
GEM station: 1,2. Only valid for muon GEM patterns, of course.
Definition: HitPattern.h:755
int stripTIDLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:659
Definition: DetId.h:18
int innermostMuonStationWithHits(int hitType) const
hitType=-1(all), 0=valid, 3=bad; 0 = no stations at all
Definition: HitPattern.cc:919
static bool muonHitFilter(uint16_t pattern)
Definition: HitPattern.h:662
Type getType() const
static bool trackerHitFilter(uint16_t pattern)
Definition: HitPattern.h:657
uint8_t endTrackHits
Definition: HitPattern.h:463
static const unsigned short SideMask
Definition: HitPattern.h:413
static const unsigned short minStripWord
Definition: HitPattern.h:429
std::pair< uint8_t, uint8_t > getCategoryIndexRange(HitCategory category) const
Definition: HitPattern.h:475
uint8_t hitCount
Definition: HitPattern.h:460
uint8_t beginOuter
Definition: HitPattern.h:466
static const unsigned short SubDetectorOffset
Definition: HitPattern.h:424
bool tibIsStereo(const DetId &id) const
int pixelBarrelLayersWithMeasurement() const
Definition: HitPattern.cc:556
unsigned int layer(const DetId &id) const
uint16_t getHitPatternByAbsoluteIndex(int position) const
Definition: HitPattern.cc:273
static uint32_t getSide(uint16_t pattern)
Definition: HitPattern.h:704
int stripTOBLayersNull() const
Definition: HitPattern.cc:808
static bool muonDTHitFilter(uint16_t pattern)
Definition: HitPattern.h:617
int trackerLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:533
bool insertExpectedInnerHit(const uint16_t pattern)
Definition: HitPattern.cc:1026
int pixelBarrelLayersTotallyOffOrBad() const
Definition: HitPattern.cc:693
static const unsigned short SubstrMask
Definition: HitPattern.h:421
static const int RPC
Definition: MuonSubdetId.h:14
static const unsigned short LayerOffset
Definition: HitPattern.h:416
static int position[264][3]
Definition: ReadPGInfo.cc:509
bool insertTrackHit(const uint16_t pattern)
Definition: HitPattern.cc:1007
int stripTECLayersWithMeasurement() const
Definition: HitPattern.cc:613
int stripTECLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:681
int pixelEndcapLayersTotallyOffOrBad() const
Definition: HitPattern.cc:705
static uint16_t getRPCLayer(uint16_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:737
static uint16_t getMuonStation(uint16_t pattern)
Muon station (1-4). Only valid for muon patterns, of course. only for patterns from muon...
Definition: HitPattern.h:722
static const int DT
Definition: MuonSubdetId.h:12
void print(HitCategory category, std::ostream &stream=std::cout) const
Definition: HitPattern.cc:864
int numberOfValidTOBLayersWithMonoAndStereo(uint32_t layer=0) const
Definition: HitPattern.cc:406
bool hasValidHitInFirstPixelBarrel() const
Definition: HitPattern.cc:315
DetId geographicalId() const
static uint32_t getSubSubStructure(uint16_t pattern)
Definition: HitPattern.h:685
uint16_t getHitPattern(HitCategory category, int position) const
Definition: HitPattern.h:502
int stripTIBLayersTotallyOffOrBad() const
Definition: HitPattern.cc:717
static const unsigned short LayerMask
Definition: HitPattern.h:417
Detector det() const
get the detector field from this detid
Definition: DetId.h:35
static bool muonRPCHitFilter(uint16_t pattern)
Definition: HitPattern.h:637
uint8_t endOuter
Definition: HitPattern.h:467
static uint16_t encode(const TrackingRecHit &hit, const TrackerTopology &ttopo)
Definition: HitPattern.cc:89
int numberOfHits(HitCategory category) const
Definition: HitPattern.h:785
int stripTIBLayersWithoutMeasurement(HitCategory category) const
Definition: HitPattern.cc:648
bool appendMuonHit(const DetId &id, TrackingRecHit::Type hitType)
Definition: HitPattern.cc:258
int pixelEndcapLayersNull() const
Definition: HitPattern.cc:774