CMS 3D CMS Logo
Muon.cc
Go to the documentation of this file.
1 #include "DataFormats/MuonReco/interface/Muon.h"
2 #include "DataFormats/MuonDetId/interface/MuonSubdetId.h"
3 #include "DataFormats/MuonDetId/interface/RPCDetId.h"
4 #include "DataFormats/MuonDetId/interface/GEMDetId.h"
5 #include "DataFormats/MuonDetId/interface/ME0DetId.h"
6 
7 using namespace reco;
8 
9 Muon::Muon(Charge q, const LorentzVector& p4, const Point& vtx) : RecoCandidate(q, p4, vtx, -13 * q) {
10  energyValid_ = false;
11  matchesValid_ = false;
12  isolationValid_ = false;
13  pfIsolationValid_ = false;
14  qualityValid_ = false;
15  caloCompatibility_ = -9999.;
16  type_ = 0;
17  bestTunePTrackType_ = reco::Muon::None;
18  bestTrackType_ = reco::Muon::None;
19  selectors_ = 0;
20 }
21 
22 Muon::Muon() {
23  energyValid_ = false;
24  matchesValid_ = false;
25  isolationValid_ = false;
26  pfIsolationValid_ = false;
27  qualityValid_ = false;
28  caloCompatibility_ = -9999.;
29  type_ = 0;
30  bestTrackType_ = reco::Muon::None;
31  bestTunePTrackType_ = reco::Muon::None;
32  selectors_ = 0;
33 }
34 
35 bool Muon::overlap(const Candidate& c) const {
36  const RecoCandidate* o = dynamic_cast<const RecoCandidate*>(&c);
37  return (o != nullptr && (checkOverlap(track(), o->track()) || checkOverlap(standAloneMuon(), o->standAloneMuon()) ||
38  checkOverlap(combinedMuon(), o->combinedMuon()) ||
39  checkOverlap(standAloneMuon(), o->track()) || checkOverlap(combinedMuon(), o->track())));
40 }
41 
42 Muon* Muon::clone() const { return new Muon(*this); }
43 
44 int Muon::numberOfChambersCSCorDT() const {
45  int total = 0;
46  int nAll = numberOfChambers();
47  for (int iC = 0; iC < nAll; ++iC) {
48  if (matches()[iC].detector() == MuonSubdetId::CSC || matches()[iC].detector() == MuonSubdetId::DT)
49  total++;
50  }
51 
52  return total;
53 }
54 
55 int Muon::numberOfMatches(ArbitrationType type) const {
56  int matches(0);
57  for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
58  chamberMatch != muMatches_.end();
59  chamberMatch++) {
60  if (type == RPCHitAndTrackArbitration) {
61  if (chamberMatch->rpcMatches.empty())
62  continue;
63  matches += chamberMatch->rpcMatches.size();
64  continue;
65  }
66  if (type == ME0SegmentAndTrackArbitration) {
67  if (chamberMatch->me0Matches.empty())
68  continue;
69  matches += chamberMatch->me0Matches.size();
70  continue;
71  }
72  if (type == GEMSegmentAndTrackArbitration) {
73  if (chamberMatch->gemMatches.empty())
74  continue;
75  matches += chamberMatch->gemMatches.size();
76  continue;
77  }
78 
79  if (chamberMatch->segmentMatches.empty())
80  continue;
81  if (type == NoArbitration) {
82  matches++;
83  continue;
84  }
85 
86  for (std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
87  segmentMatch != chamberMatch->segmentMatches.end();
88  segmentMatch++) {
89  if (type == SegmentArbitration)
90  if (segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR)) {
91  matches++;
92  break;
93  }
94  if (type == SegmentAndTrackArbitration)
95  if (segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR) &&
96  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
97  matches++;
98  break;
99  }
100  if (type == SegmentAndTrackArbitrationCleaned)
101  if (segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR) &&
102  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
103  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
104  matches++;
105  break;
106  }
107  }
108  }
109 
110  return matches;
111 }
112 
113 int Muon::numberOfMatchedStations(ArbitrationType type) const {
114  int stations(0);
115 
116  unsigned int theStationMask = stationMask(type);
117  // eight stations, eight bits
118  for (int it = 0; it < 8; ++it)
119  if (theStationMask & 1 << it)
120  ++stations;
121 
122  return stations;
123 }
124 
125 unsigned int Muon::expectedNnumberOfMatchedStations(float minDistanceFromEdge) const {
126  unsigned int stationMask = 0;
127  for (auto& chamberMatch : muMatches_) {
128  if (chamberMatch.detector() != MuonSubdetId::DT && chamberMatch.detector() != MuonSubdetId::CSC)
129  continue;
130  float edgeX = chamberMatch.edgeX;
131  float edgeY = chamberMatch.edgeY;
132  // check we if the trajectory is well within the acceptance
133  if (edgeX < 0 && fabs(edgeX) > fabs(minDistanceFromEdge) && edgeY < 0 && fabs(edgeY) > fabs(minDistanceFromEdge))
134  stationMask |= 1 << ((chamberMatch.station() - 1) + 4 * (chamberMatch.detector() - 1));
135  }
136  unsigned int n = 0;
137  for (unsigned int i = 0; i < 8; ++i)
138  if (stationMask & (1 << i))
139  n++;
140  return n;
141 }
142 
143 unsigned int Muon::stationMask(ArbitrationType type) const {
144  unsigned int totMask(0);
145  unsigned int curMask(0);
146 
147  for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
148  chamberMatch != muMatches_.end();
149  chamberMatch++) {
150  if (type == RPCHitAndTrackArbitration) {
151  if (chamberMatch->rpcMatches.empty())
152  continue;
153 
154  RPCDetId rollId = chamberMatch->id.rawId();
155  const int region = rollId.region();
156  int rpcIndex = 1;
157  if (region != 0)
158  rpcIndex = 2;
159 
160  for (std::vector<MuonRPCHitMatch>::const_iterator rpcMatch = chamberMatch->rpcMatches.begin();
161  rpcMatch != chamberMatch->rpcMatches.end();
162  rpcMatch++) {
163  curMask = 1 << ((chamberMatch->station() - 1) + 4 * (rpcIndex - 1));
164 
165  // do not double count
166  if (!(totMask & curMask))
167  totMask += curMask;
168  }
169  continue;
170  }
171 
172  if (chamberMatch->segmentMatches.empty())
173  continue;
174  if (type == NoArbitration) {
175  curMask = 1 << ((chamberMatch->station() - 1) + 4 * (chamberMatch->detector() - 1));
176  // do not double count
177  if (!(totMask & curMask))
178  totMask += curMask;
179  continue;
180  }
181 
182  for (std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
183  segmentMatch != chamberMatch->segmentMatches.end();
184  segmentMatch++) {
185  if (type == SegmentArbitration)
186  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) {
187  curMask = 1 << ((chamberMatch->station() - 1) + 4 * (chamberMatch->detector() - 1));
188  // do not double count
189  if (!(totMask & curMask))
190  totMask += curMask;
191  break;
192  }
193  if (type == SegmentAndTrackArbitration)
194  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
195  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
196  curMask = 1 << ((chamberMatch->station() - 1) + 4 * (chamberMatch->detector() - 1));
197  // do not double count
198  if (!(totMask & curMask))
199  totMask += curMask;
200  break;
201  }
202  if (type == SegmentAndTrackArbitrationCleaned)
203  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
204  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
205  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
206  curMask = 1 << ((chamberMatch->station() - 1) + 4 * (chamberMatch->detector() - 1));
207  // do not double count
208  if (!(totMask & curMask))
209  totMask += curMask;
210  break;
211  }
212  }
213  }
214 
215  return totMask;
216 }
217 
218 int Muon::numberOfMatchedRPCLayers(ArbitrationType type) const {
219  int layers(0);
220 
221  unsigned int theRPCLayerMask = RPClayerMask(type);
222  // maximum ten layers because of 6 layers in barrel and 3 (4) layers in each endcap before (after) upscope
223  for (int it = 0; it < 10; ++it)
224  if (theRPCLayerMask & 1 << it)
225  ++layers;
226 
227  return layers;
228 }
229 
230 unsigned int Muon::RPClayerMask(ArbitrationType type) const {
231  unsigned int totMask(0);
232  unsigned int curMask(0);
233  for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
234  chamberMatch != muMatches_.end();
235  chamberMatch++) {
236  if (chamberMatch->rpcMatches.empty())
237  continue;
238 
239  RPCDetId rollId = chamberMatch->id.rawId();
240  const int region = rollId.region();
241 
242  const int layer = rollId.layer();
243  int rpcLayer = chamberMatch->station();
244  if (region == 0) {
245  rpcLayer = chamberMatch->station() - 1 + chamberMatch->station() * layer;
246  if ((chamberMatch->station() == 2 && layer == 2) || (chamberMatch->station() == 4 && layer == 1))
247  rpcLayer -= 1;
248  } else
249  rpcLayer += 6;
250 
251  for (std::vector<MuonRPCHitMatch>::const_iterator rpcMatch = chamberMatch->rpcMatches.begin();
252  rpcMatch != chamberMatch->rpcMatches.end();
253  rpcMatch++) {
254  curMask = 1 << (rpcLayer - 1);
255 
256  // do not double count
257  if (!(totMask & curMask))
258  totMask += curMask;
259  }
260  }
261 
262  return totMask;
263 }
264 
265 unsigned int Muon::stationGapMaskDistance(float distanceCut) const {
266  unsigned int totMask(0);
267  for (int stationIndex = 1; stationIndex < 5; stationIndex++) {
268  for (int detectorIndex = 1; detectorIndex < 4; detectorIndex++) {
269  unsigned int curMask(0);
270  for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
271  chamberMatch != muMatches_.end();
272  chamberMatch++) {
273  if (!(chamberMatch->station() == stationIndex && chamberMatch->detector() == detectorIndex))
274  continue;
275 
276  float edgeX = chamberMatch->edgeX;
277  float edgeY = chamberMatch->edgeY;
278  if (edgeX < 0 && fabs(edgeX) > fabs(distanceCut) && edgeY < 0 &&
279  fabs(edgeY) > fabs(distanceCut)) // inside the chamber so negates all gaps for this station
280  {
281  curMask = 0;
282  break;
283  }
284  if ((fabs(edgeX) < fabs(distanceCut) && edgeY < fabs(distanceCut)) ||
285  (fabs(edgeY) < fabs(distanceCut) && edgeX < fabs(distanceCut))) // inside gap
286  curMask = 1 << ((stationIndex - 1) + 4 * (detectorIndex - 1));
287  }
288 
289  totMask += curMask; // add to total mask
290  }
291  }
292 
293  return totMask;
294 }
295 
296 unsigned int Muon::stationGapMaskPull(float sigmaCut) const {
297  unsigned int totMask(0);
298  for (int stationIndex = 1; stationIndex < 5; stationIndex++) {
299  for (int detectorIndex = 1; detectorIndex < 4; detectorIndex++) {
300  unsigned int curMask(0);
301  for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
302  chamberMatch != muMatches_.end();
303  chamberMatch++) {
304  if (!(chamberMatch->station() == stationIndex && chamberMatch->detector() == detectorIndex))
305  continue;
306 
307  float edgeX = chamberMatch->edgeX;
308  float edgeY = chamberMatch->edgeY;
309  float xErr = chamberMatch->xErr + 0.000001; // protect against division by zero later
310  float yErr = chamberMatch->yErr + 0.000001; // protect against division by zero later
311  if (edgeX < 0 && fabs(edgeX / xErr) > fabs(sigmaCut) && edgeY < 0 &&
312  fabs(edgeY / yErr) > fabs(sigmaCut)) // inside the chamber so negates all gaps for this station
313  {
314  curMask = 0;
315  break;
316  }
317  if ((fabs(edgeX / xErr) < fabs(sigmaCut) && edgeY / yErr < fabs(sigmaCut)) ||
318  (fabs(edgeY / yErr) < fabs(sigmaCut) && edgeX / xErr < fabs(sigmaCut))) // inside gap
319  curMask = 1 << ((stationIndex - 1) + 4 * (detectorIndex - 1));
320  }
321 
322  totMask += curMask; // add to total mask
323  }
324  }
325 
326  return totMask;
327 }
328 
329 int Muon::nDigisInStation(int station, int muonSubdetId) const {
330  int nDigis(0);
331  std::map<int, int> me11DigisPerCh;
332 
333  if (muonSubdetId != MuonSubdetId::CSC && muonSubdetId != MuonSubdetId::DT)
334  return 0;
335 
336  for (auto& match : muMatches_) {
337  if (match.detector() != muonSubdetId || match.station() != station)
338  continue;
339 
340  int nDigisInCh = match.nDigisInRange;
341 
342  if (muonSubdetId == MuonSubdetId::CSC && station == 1) {
343  CSCDetId id(match.id.rawId());
344 
345  int chamber = id.chamber();
346  int ring = id.ring();
347 
348  if (ring == 1 || ring == 4) // merge ME1/1a and ME1/1b digis
349  {
350  if (me11DigisPerCh.find(chamber) == me11DigisPerCh.end())
351  me11DigisPerCh[chamber] = 0;
352 
353  me11DigisPerCh[chamber] += nDigisInCh;
354 
355  continue;
356  }
357  }
358 
359  if (nDigisInCh > nDigis)
360  nDigis = nDigisInCh;
361  }
362 
363  for (const auto& me11DigisInCh : me11DigisPerCh) {
364  int nMe11DigisInCh = me11DigisInCh.second;
365  if (nMe11DigisInCh > nDigis)
366  nDigis = nMe11DigisInCh;
367  }
368 
369  return nDigis;
370 }
371 
372 bool Muon::hasShowerInStation(int station, int muonSubdetId, int nDtDigisCut, int nCscDigisCut) const {
373  if (muonSubdetId != MuonSubdetId::DT && muonSubdetId != MuonSubdetId::CSC)
374  return false;
375  auto nDigisCut = muonSubdetId == MuonSubdetId::DT ? nDtDigisCut : nCscDigisCut;
376 
377  return nDigisInStation(station, muonSubdetId) >= nDigisCut;
378 }
379 
380 int Muon::numberOfShowers(int nDtDigisCut, int nCscDigisCut) const {
381  int nShowers = 0;
382  for (int station = 1; station < 5; ++station) {
383  if (hasShowerInStation(station, MuonSubdetId::DT, nDtDigisCut, nCscDigisCut))
384  nShowers++;
385  if (hasShowerInStation(station, MuonSubdetId::CSC, nDtDigisCut, nCscDigisCut))
386  nShowers++;
387  }
388 
389  return nShowers;
390 }
391 
392 int Muon::numberOfSegments(int station, int muonSubdetId, ArbitrationType type) const {
393  int segments(0);
394  for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
395  chamberMatch != muMatches_.end();
396  chamberMatch++) {
397  if (chamberMatch->segmentMatches.empty())
398  continue;
399  if (!(chamberMatch->station() == station && chamberMatch->detector() == muonSubdetId))
400  continue;
401 
402  if (type == NoArbitration) {
403  segments += chamberMatch->segmentMatches.size();
404  continue;
405  }
406 
407  for (std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
408  segmentMatch != chamberMatch->segmentMatches.end();
409  segmentMatch++) {
410  if (type == SegmentArbitration)
411  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) {
412  segments++;
413  break;
414  }
415  if (type == SegmentAndTrackArbitration)
416  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
417  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
418  segments++;
419  break;
420  }
421  if (type == SegmentAndTrackArbitrationCleaned)
422  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
423  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
424  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
425  segments++;
426  break;
427  }
428  }
429  }
430 
431  return segments;
432 }
433 
434 const std::vector<const MuonChamberMatch*> Muon::chambers(int station, int muonSubdetId) const {
435  std::vector<const MuonChamberMatch*> chambers;
436  for (std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
437  chamberMatch != muMatches_.end();
438  chamberMatch++)
439  if (chamberMatch->station() == station && chamberMatch->detector() == muonSubdetId)
440  chambers.push_back(&(*chamberMatch));
441  return chambers;
442 }
443 
444 std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> Muon::pair(
445  const std::vector<const MuonChamberMatch*>& chambers, ArbitrationType type) const {
446  MuonChamberMatch* m = nullptr;
447  MuonSegmentMatch* s = nullptr;
448  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair(m, s);
449 
450  if (chambers.empty())
451  return chamberSegmentPair;
452  for (std::vector<const MuonChamberMatch*>::const_iterator chamberMatch = chambers.begin();
453  chamberMatch != chambers.end();
454  chamberMatch++) {
455  if ((*chamberMatch)->segmentMatches.empty())
456  continue;
457  if (type == NoArbitration)
458  return std::make_pair(*chamberMatch, &((*chamberMatch)->segmentMatches.front()));
459 
460  for (std::vector<MuonSegmentMatch>::const_iterator segmentMatch = (*chamberMatch)->segmentMatches.begin();
461  segmentMatch != (*chamberMatch)->segmentMatches.end();
462  segmentMatch++) {
463  if (type == SegmentArbitration)
464  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR))
465  return std::make_pair(*chamberMatch, &(*segmentMatch));
466  if (type == SegmentAndTrackArbitration)
467  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
468  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR))
469  return std::make_pair(*chamberMatch, &(*segmentMatch));
470  if (type == SegmentAndTrackArbitrationCleaned)
471  if (segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
472  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
473  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning))
474  return std::make_pair(*chamberMatch, &(*segmentMatch));
475  }
476  }
477 
478  return chamberSegmentPair;
479 }
480 
481 float Muon::dX(int station, int muonSubdetId, ArbitrationType type) const {
482  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
483  pair(chambers(station, muonSubdetId), type);
484  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
485  return 999999;
486  if (!chamberSegmentPair.second->hasPhi())
487  return 999999;
488  return chamberSegmentPair.first->x - chamberSegmentPair.second->x;
489 }
490 
491 float Muon::dY(int station, int muonSubdetId, ArbitrationType type) const {
492  if (station == 4 && muonSubdetId == MuonSubdetId::DT)
493  return 999999; // no y information
494  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
495  pair(chambers(station, muonSubdetId), type);
496  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
497  return 999999;
498  if (!chamberSegmentPair.second->hasZed())
499  return 999999;
500  return chamberSegmentPair.first->y - chamberSegmentPair.second->y;
501 }
502 
503 float Muon::dDxDz(int station, int muonSubdetId, ArbitrationType type) const {
504  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
505  pair(chambers(station, muonSubdetId), type);
506  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
507  return 999999;
508  if (!chamberSegmentPair.second->hasPhi())
509  return 999999;
510  return chamberSegmentPair.first->dXdZ - chamberSegmentPair.second->dXdZ;
511 }
512 
513 float Muon::dDyDz(int station, int muonSubdetId, ArbitrationType type) const {
514  if (station == 4 && muonSubdetId == MuonSubdetId::DT)
515  return 999999; // no y information
516  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
517  pair(chambers(station, muonSubdetId), type);
518  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
519  return 999999;
520  if (!chamberSegmentPair.second->hasZed())
521  return 999999;
522  return chamberSegmentPair.first->dYdZ - chamberSegmentPair.second->dYdZ;
523 }
524 
525 float Muon::pullX(int station, int muonSubdetId, ArbitrationType type, bool includeSegmentError) const {
526  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
527  pair(chambers(station, muonSubdetId), type);
528  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
529  return 999999;
530  if (!chamberSegmentPair.second->hasPhi())
531  return 999999;
532  if (includeSegmentError)
533  return (chamberSegmentPair.first->x - chamberSegmentPair.second->x) /
534  sqrt(pow(chamberSegmentPair.first->xErr, 2) + pow(chamberSegmentPair.second->xErr, 2));
535  return (chamberSegmentPair.first->x - chamberSegmentPair.second->x) / chamberSegmentPair.first->xErr;
536 }
537 
538 float Muon::pullY(int station, int muonSubdetId, ArbitrationType type, bool includeSegmentError) const {
539  if (station == 4 && muonSubdetId == MuonSubdetId::DT)
540  return 999999; // no y information
541  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
542  pair(chambers(station, muonSubdetId), type);
543  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
544  return 999999;
545  if (!chamberSegmentPair.second->hasZed())
546  return 999999;
547  if (includeSegmentError)
548  return (chamberSegmentPair.first->y - chamberSegmentPair.second->y) /
549  sqrt(pow(chamberSegmentPair.first->yErr, 2) + pow(chamberSegmentPair.second->yErr, 2));
550  return (chamberSegmentPair.first->y - chamberSegmentPair.second->y) / chamberSegmentPair.first->yErr;
551 }
552 
553 float Muon::pullDxDz(int station, int muonSubdetId, ArbitrationType type, bool includeSegmentError) const {
554  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
555  pair(chambers(station, muonSubdetId), type);
556  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
557  return 999999;
558  if (!chamberSegmentPair.second->hasPhi())
559  return 999999;
560  if (includeSegmentError)
561  return (chamberSegmentPair.first->dXdZ - chamberSegmentPair.second->dXdZ) /
562  sqrt(pow(chamberSegmentPair.first->dXdZErr, 2) + pow(chamberSegmentPair.second->dXdZErr, 2));
563  return (chamberSegmentPair.first->dXdZ - chamberSegmentPair.second->dXdZ) / chamberSegmentPair.first->dXdZErr;
564 }
565 
566 float Muon::pullDyDz(int station, int muonSubdetId, ArbitrationType type, bool includeSegmentError) const {
567  if (station == 4 && muonSubdetId == MuonSubdetId::DT)
568  return 999999; // no y information
569  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
570  pair(chambers(station, muonSubdetId), type);
571  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
572  return 999999;
573  if (!chamberSegmentPair.second->hasZed())
574  return 999999;
575  if (includeSegmentError)
576  return (chamberSegmentPair.first->dYdZ - chamberSegmentPair.second->dYdZ) /
577  sqrt(pow(chamberSegmentPair.first->dYdZErr, 2) + pow(chamberSegmentPair.second->dYdZErr, 2));
578  return (chamberSegmentPair.first->dYdZ - chamberSegmentPair.second->dYdZ) / chamberSegmentPair.first->dYdZErr;
579 }
580 
581 float Muon::segmentX(int station, int muonSubdetId, ArbitrationType type) const {
582  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
583  pair(chambers(station, muonSubdetId), type);
584  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
585  return 999999;
586  if (!chamberSegmentPair.second->hasPhi())
587  return 999999;
588  return chamberSegmentPair.second->x;
589 }
590 
591 float Muon::segmentY(int station, int muonSubdetId, ArbitrationType type) const {
592  if (station == 4 && muonSubdetId == MuonSubdetId::DT)
593  return 999999; // no y information
594  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
595  pair(chambers(station, muonSubdetId), type);
596  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
597  return 999999;
598  if (!chamberSegmentPair.second->hasZed())
599  return 999999;
600  return chamberSegmentPair.second->y;
601 }
602 
603 float Muon::segmentDxDz(int station, int muonSubdetId, ArbitrationType type) const {
604  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
605  pair(chambers(station, muonSubdetId), type);
606  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
607  return 999999;
608  if (!chamberSegmentPair.second->hasPhi())
609  return 999999;
610  return chamberSegmentPair.second->dXdZ;
611 }
612 
613 float Muon::segmentDyDz(int station, int muonSubdetId, ArbitrationType type) const {
614  if (station == 4 && muonSubdetId == MuonSubdetId::DT)
615  return 999999; // no y information
616  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
617  pair(chambers(station, muonSubdetId), type);
618  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
619  return 999999;
620  if (!chamberSegmentPair.second->hasZed())
621  return 999999;
622  return chamberSegmentPair.second->dYdZ;
623 }
624 
625 float Muon::segmentXErr(int station, int muonSubdetId, ArbitrationType type) const {
626  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
627  pair(chambers(station, muonSubdetId), type);
628  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
629  return 999999;
630  if (!chamberSegmentPair.second->hasPhi())
631  return 999999;
632  return chamberSegmentPair.second->xErr;
633 }
634 
635 float Muon::segmentYErr(int station, int muonSubdetId, ArbitrationType type) const {
636  if (station == 4 && muonSubdetId == MuonSubdetId::DT)
637  return 999999; // no y information
638  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
639  pair(chambers(station, muonSubdetId), type);
640  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
641  return 999999;
642  if (!chamberSegmentPair.second->hasZed())
643  return 999999;
644  return chamberSegmentPair.second->yErr;
645 }
646 
647 float Muon::segmentDxDzErr(int station, int muonSubdetId, ArbitrationType type) const {
648  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
649  pair(chambers(station, muonSubdetId), type);
650  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
651  return 999999;
652  if (!chamberSegmentPair.second->hasPhi())
653  return 999999;
654  return chamberSegmentPair.second->dXdZErr;
655 }
656 
657 float Muon::segmentDyDzErr(int station, int muonSubdetId, ArbitrationType type) const {
658  if (station == 4 && muonSubdetId == MuonSubdetId::DT)
659  return 999999; // no y information
660  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair =
661  pair(chambers(station, muonSubdetId), type);
662  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr)
663  return 999999;
664  if (!chamberSegmentPair.second->hasZed())
665  return 999999;
666  return chamberSegmentPair.second->dYdZErr;
667 }
668 
669 float Muon::trackEdgeX(int station, int muonSubdetId, ArbitrationType type) const {
670  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
671  if (muonChambers.empty())
672  return 999999;
673 
674  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
675  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
676  float dist = 999999;
677  float supVar = 999999;
678  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
679  muonChamber != muonChambers.end();
680  ++muonChamber) {
681  float currDist = (*muonChamber)->dist();
682  if (currDist < dist) {
683  dist = currDist;
684  supVar = (*muonChamber)->edgeX;
685  }
686  }
687  return supVar;
688  } else
689  return chamberSegmentPair.first->edgeX;
690 }
691 
692 float Muon::trackEdgeY(int station, int muonSubdetId, ArbitrationType type) const {
693  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
694  if (muonChambers.empty())
695  return 999999;
696 
697  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
698  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
699  float dist = 999999;
700  float supVar = 999999;
701  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
702  muonChamber != muonChambers.end();
703  ++muonChamber) {
704  float currDist = (*muonChamber)->dist();
705  if (currDist < dist) {
706  dist = currDist;
707  supVar = (*muonChamber)->edgeY;
708  }
709  }
710  return supVar;
711  } else
712  return chamberSegmentPair.first->edgeY;
713 }
714 
715 float Muon::trackX(int station, int muonSubdetId, ArbitrationType type) const {
716  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
717  if (muonChambers.empty())
718  return 999999;
719 
720  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
721  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
722  float dist = 999999;
723  float supVar = 999999;
724  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
725  muonChamber != muonChambers.end();
726  ++muonChamber) {
727  float currDist = (*muonChamber)->dist();
728  if (currDist < dist) {
729  dist = currDist;
730  supVar = (*muonChamber)->x;
731  }
732  }
733  return supVar;
734  } else
735  return chamberSegmentPair.first->x;
736 }
737 
738 float Muon::trackY(int station, int muonSubdetId, ArbitrationType type) const {
739  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
740  if (muonChambers.empty())
741  return 999999;
742 
743  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
744  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
745  float dist = 999999;
746  float supVar = 999999;
747  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
748  muonChamber != muonChambers.end();
749  ++muonChamber) {
750  float currDist = (*muonChamber)->dist();
751  if (currDist < dist) {
752  dist = currDist;
753  supVar = (*muonChamber)->y;
754  }
755  }
756  return supVar;
757  } else
758  return chamberSegmentPair.first->y;
759 }
760 
761 float Muon::trackDxDz(int station, int muonSubdetId, ArbitrationType type) const {
762  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
763  if (muonChambers.empty())
764  return 999999;
765 
766  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
767  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
768  float dist = 999999;
769  float supVar = 999999;
770  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
771  muonChamber != muonChambers.end();
772  ++muonChamber) {
773  float currDist = (*muonChamber)->dist();
774  if (currDist < dist) {
775  dist = currDist;
776  supVar = (*muonChamber)->dXdZ;
777  }
778  }
779  return supVar;
780  } else
781  return chamberSegmentPair.first->dXdZ;
782 }
783 
784 float Muon::trackDyDz(int station, int muonSubdetId, ArbitrationType type) const {
785  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
786  if (muonChambers.empty())
787  return 999999;
788 
789  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
790  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
791  float dist = 999999;
792  float supVar = 999999;
793  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
794  muonChamber != muonChambers.end();
795  ++muonChamber) {
796  float currDist = (*muonChamber)->dist();
797  if (currDist < dist) {
798  dist = currDist;
799  supVar = (*muonChamber)->dYdZ;
800  }
801  }
802  return supVar;
803  } else
804  return chamberSegmentPair.first->dYdZ;
805 }
806 
807 float Muon::trackXErr(int station, int muonSubdetId, ArbitrationType type) const {
808  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
809  if (muonChambers.empty())
810  return 999999;
811 
812  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
813  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
814  float dist = 999999;
815  float supVar = 999999;
816  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
817  muonChamber != muonChambers.end();
818  ++muonChamber) {
819  float currDist = (*muonChamber)->dist();
820  if (currDist < dist) {
821  dist = currDist;
822  supVar = (*muonChamber)->xErr;
823  }
824  }
825  return supVar;
826  } else
827  return chamberSegmentPair.first->xErr;
828 }
829 
830 float Muon::trackYErr(int station, int muonSubdetId, ArbitrationType type) const {
831  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
832  if (muonChambers.empty())
833  return 999999;
834 
835  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
836  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
837  float dist = 999999;
838  float supVar = 999999;
839  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
840  muonChamber != muonChambers.end();
841  ++muonChamber) {
842  float currDist = (*muonChamber)->dist();
843  if (currDist < dist) {
844  dist = currDist;
845  supVar = (*muonChamber)->yErr;
846  }
847  }
848  return supVar;
849  } else
850  return chamberSegmentPair.first->yErr;
851 }
852 
853 float Muon::trackDxDzErr(int station, int muonSubdetId, ArbitrationType type) const {
854  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
855  if (muonChambers.empty())
856  return 999999;
857 
858  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
859  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
860  float dist = 999999;
861  float supVar = 999999;
862  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
863  muonChamber != muonChambers.end();
864  ++muonChamber) {
865  float currDist = (*muonChamber)->dist();
866  if (currDist < dist) {
867  dist = currDist;
868  supVar = (*muonChamber)->dXdZErr;
869  }
870  }
871  return supVar;
872  } else
873  return chamberSegmentPair.first->dXdZErr;
874 }
875 
876 float Muon::trackDyDzErr(int station, int muonSubdetId, ArbitrationType type) const {
877  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
878  if (muonChambers.empty())
879  return 999999;
880 
881  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
882  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
883  float dist = 999999;
884  float supVar = 999999;
885  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
886  muonChamber != muonChambers.end();
887  ++muonChamber) {
888  float currDist = (*muonChamber)->dist();
889  if (currDist < dist) {
890  dist = currDist;
891  supVar = (*muonChamber)->dYdZErr;
892  }
893  }
894  return supVar;
895  } else
896  return chamberSegmentPair.first->dYdZErr;
897 }
898 
899 float Muon::trackDist(int station, int muonSubdetId, ArbitrationType type) const {
900  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
901  if (muonChambers.empty())
902  return 999999;
903 
904  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
905  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
906  float dist = 999999;
907  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
908  muonChamber != muonChambers.end();
909  ++muonChamber) {
910  float currDist = (*muonChamber)->dist();
911  if (currDist < dist)
912  dist = currDist;
913  }
914  return dist;
915  } else
916  return chamberSegmentPair.first->dist();
917 }
918 
919 float Muon::trackDistErr(int station, int muonSubdetId, ArbitrationType type) const {
920  const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
921  if (muonChambers.empty())
922  return 999999;
923 
924  std::pair<const MuonChamberMatch*, const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers, type);
925  if (chamberSegmentPair.first == nullptr || chamberSegmentPair.second == nullptr) {
926  float dist = 999999;
927  float supVar = 999999;
928  for (std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
929  muonChamber != muonChambers.end();
930  ++muonChamber) {
931  float currDist = (*muonChamber)->dist();
932  if (currDist < dist) {
933  dist = currDist;
934  supVar = (*muonChamber)->distErr();
935  }
936  }
937  return supVar;
938  } else
939  return chamberSegmentPair.first->distErr();
940 }
941 
942 void Muon::setIsolation(const MuonIsolation& isoR03, const MuonIsolation& isoR05) {
943  isolationR03_ = isoR03;
944  isolationR05_ = isoR05;
945  isolationValid_ = true;
946 }
947 
948 void Muon::setPFIsolation(const std::string& label, const MuonPFIsolation& deposit) {
949  if (label == "pfIsolationR03")
950  pfIsolationR03_ = deposit;
951 
952  if (label == "pfIsolationR04")
953  pfIsolationR04_ = deposit;
954 
955  if (label == "pfIsoMeanDRProfileR03")
956  pfIsoMeanDRR03_ = deposit;
957 
958  if (label == "pfIsoMeanDRProfileR04")
959  pfIsoMeanDRR04_ = deposit;
960 
961  if (label == "pfIsoSumDRProfileR03")
962  pfIsoSumDRR03_ = deposit;
963 
964  if (label == "pfIsoSumDRProfileR04")
965  pfIsoSumDRR04_ = deposit;
966 
967  pfIsolationValid_ = true;
968 }
969 
970 void Muon::setPFP4(const reco::Candidate::LorentzVector& p4) {
971  pfP4_ = p4;
972  type_ = type_ | PFMuon;
973 }
974 
975 void Muon::setOuterTrack(const TrackRef& t) { outerTrack_ = t; }
976 void Muon::setInnerTrack(const TrackRef& t) { innerTrack_ = t; }
977 void Muon::setTrack(const TrackRef& t) { setInnerTrack(t); }
978 void Muon::setStandAlone(const TrackRef& t) { setOuterTrack(t); }
979 void Muon::setGlobalTrack(const TrackRef& t) { globalTrack_ = t; }
980 void Muon::setCombined(const TrackRef& t) { setGlobalTrack(t); }
981 
982 bool Muon::isAValidMuonTrack(const MuonTrackType& type) const { return muonTrack(type).isNonnull(); }
983 
984 TrackRef Muon::muonTrack(const MuonTrackType& type) const {
985  switch (type) {
986  case InnerTrack:
987  return innerTrack();
988  case OuterTrack:
989  return standAloneMuon();
990  case CombinedTrack:
991  return globalTrack();
992  case TPFMS:
993  return tpfmsTrack();
994  case Picky:
995  return pickyTrack();
996  case DYT:
997  return dytTrack();
998  default:
999  return muonTrackFromMap(type);
1000  }
1001 }
1002 
1003 void Muon::setMuonTrack(const MuonTrackType& type, const TrackRef& t) {
1004  switch (type) {
1005  case InnerTrack:
1006  setInnerTrack(t);
1007  break;
1008  case OuterTrack:
1009  setStandAlone(t);
1010  break;
1011  case CombinedTrack:
1012  setGlobalTrack(t);
1013  break;
1014  default:
1015  refittedTrackMap_[type] = t;
1016  break;
1017  }
1018 }
type
type
Definition: HCALResponse.h:21
mps_fire.i
i
Definition: mps_fire.py:341
reco::LeafCandidate::clone
LeafCandidate * clone() const override
returns a clone of the Candidate object
Definition: LeafCandidate.h:195
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLT_2018_cff.region
region
Definition: HLT_2018_cff.py:81376
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
reco::RecoCandidate::standAloneMuon
virtual reco::TrackRef standAloneMuon() const
reference to a stand-alone muon Track
Definition: RecoCandidate.cc:21
cutBasedMuonId_MuonPOG_V0_cff.globalTrack
globalTrack
Definition: cutBasedMuonId_MuonPOG_V0_cff.py:135
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
reco::RecoCandidate::track
virtual reco::TrackRef track() const
reference to a Track
Definition: RecoCandidate.cc:13
label
char const * label
Definition: PFTauDecayModeTools.cc:11
EcalTangentSkim_cfg.o
o
Definition: EcalTangentSkim_cfg.py:36
Muon
Definition: Muon.py:1
HLT_2018_cff.sigmaCut
sigmaCut
Definition: HLT_2018_cff.py:11753
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
p4
double p4[4]
Definition: TauolaWrapper.h:92
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:60
LorentzVector
math::XYZTLorentzVector LorentzVector
Definition: HLTMuonMatchAndPlot.h:49
plotscripts.stationIndex
def stationIndex(name)
Definition: plotscripts.py:355
reco::LeafCandidate::p4
const LorentzVector & p4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:114
RPCDetId::layer
int layer() const
Definition: RPCDetId.h:85
hgcalTestNeighbor_cfi.detector
detector
Definition: hgcalTestNeighbor_cfi.py:6
reco::Candidate::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:37
g4TestGeometry_cfi.checkOverlap
def checkOverlap(process)
Definition: g4TestGeometry_cfi.py:3
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
Point
Structure Point Contains parameters of Gaussian fits to DMRs.
Definition: DMRtrends.cc:57
reco::LeafCandidate::overlap
bool overlap(const Candidate &) const override
check overlap with another Candidate
Definition: LeafCandidate.cc:25
match
std::pair< typename Association::data_type::first_type, double > match(Reference key, Association association, bool bestMatchByMaxValue)
Generic matching function.
Definition: Utils.h:10
badGlobalMuonTaggersAOD_cff.vtx
vtx
Definition: badGlobalMuonTaggersAOD_cff.py:5
MuonSubdetId::DT
static constexpr int DT
Definition: MuonSubdetId.h:11
reco::MuonTrackType
MuonTrackType
Definition: MuonTrackType.h:28
chambers
static char chambers[264][20]
Definition: ReadPGInfo.cc:243
hgcalTopologyTester_cfi.layers
layers
Definition: hgcalTopologyTester_cfi.py:8
MuonSubdetId::CSC
static constexpr int CSC
Definition: MuonSubdetId.h:12
patCandidatesForDimuonsSequences_cff.matches
matches
Definition: patCandidatesForDimuonsSequences_cff.py:131
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
l1t::Muon::Muon
Muon()
Definition: Muon.cc:3
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10339
reco::RecoCandidate::combinedMuon
virtual reco::TrackRef combinedMuon() const
reference to a stand-alone muon Track
Definition: RecoCandidate.cc:23
RPCDetId::region
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:53
Generated for CMSSW Reference Manual by doxygen 1.8.11