CMS 3D CMS Logo
Classes | Enumerations | Functions | Variables
muon Namespace Reference

Classes

struct  SelectionTypeStringToEnum
 a lightweight "map" for selection type string label and enum value More...
 
struct  SelectorStringToEnum
 

Enumerations

enum  AlgorithmType {
  TMLastStation, TM2DCompatibility, TMOneStation, RPCMu,
  ME0Mu, GEMMu
}
 
enum  SelectionType {
  All = 0, AllGlobalMuons = 1, AllStandAloneMuons = 2, AllTrackerMuons = 3,
  TrackerMuonArbitrated = 4, AllArbitrated = 5, GlobalMuonPromptTight = 6, TMLastStationLoose = 7,
  TMLastStationTight = 8, TM2DCompatibilityLoose = 9, TM2DCompatibilityTight = 10, TMOneStationLoose = 11,
  TMOneStationTight = 12, TMLastStationOptimizedLowPtLoose = 13, TMLastStationOptimizedLowPtTight = 14, GMTkChiCompatibility = 15,
  GMStaChiCompatibility = 16, GMTkKinkTight = 17, TMLastStationAngLoose = 18, TMLastStationAngTight = 19,
  TMOneStationAngLoose = 20, TMOneStationAngTight = 21, TMLastStationOptimizedBarrelLowPtLoose = 22, TMLastStationOptimizedBarrelLowPtTight = 23,
  RPCMuLoose = 24, AllME0Muons = 25, ME0MuonArbitrated = 26, AllGEMMuons = 27,
  GEMMuonArbitrated = 28, TriggerIdLoose = 29, All = 0, VeryLoose = 1,
  Loose = 2, Tight = 3
}
 Selector type. More...
 
enum  SelectionType {
  All = 0, AllGlobalMuons = 1, AllStandAloneMuons = 2, AllTrackerMuons = 3,
  TrackerMuonArbitrated = 4, AllArbitrated = 5, GlobalMuonPromptTight = 6, TMLastStationLoose = 7,
  TMLastStationTight = 8, TM2DCompatibilityLoose = 9, TM2DCompatibilityTight = 10, TMOneStationLoose = 11,
  TMOneStationTight = 12, TMLastStationOptimizedLowPtLoose = 13, TMLastStationOptimizedLowPtTight = 14, GMTkChiCompatibility = 15,
  GMStaChiCompatibility = 16, GMTkKinkTight = 17, TMLastStationAngLoose = 18, TMLastStationAngTight = 19,
  TMOneStationAngLoose = 20, TMOneStationAngTight = 21, TMLastStationOptimizedBarrelLowPtLoose = 22, TMLastStationOptimizedBarrelLowPtTight = 23,
  RPCMuLoose = 24, AllME0Muons = 25, ME0MuonArbitrated = 26, AllGEMMuons = 27,
  GEMMuonArbitrated = 28, TriggerIdLoose = 29, All = 0, VeryLoose = 1,
  Loose = 2, Tight = 3
}
 Selector type. More...
 

Functions

float caloCompatibility (const reco::Muon &muon)
 
reco::TrackRef getTevRefitTrack (const reco::TrackRef &combinedTrack, const reco::TrackToTrackMap &map)
 
bool isGoodMuon (const reco::ME0Muon &me0muon, double MaxPullX, double MaxDiffX, double MaxPullY, double MaxDiffY, double MaxDiffPhiDir)
 Specialized isGoodMuon function called from main wrapper. More...
 
bool isGoodMuon (const reco::ME0Muon &me0muon, SelectionType type)
 main GoodMuon wrapper call More...
 
bool isGoodMuon (const reco::Muon &muon, AlgorithmType type, double minCompatibility, reco::Muon::ArbitrationType arbitrationType)
 
bool isGoodMuon (const reco::Muon &muon, AlgorithmType type, int minNumberOfMatches, double maxAbsDx, double maxAbsPullX, double maxAbsDy, double maxAbsPullY, double maxChamberDist, double maxChamberDistPull, reco::Muon::ArbitrationType arbitrationType, bool syncMinNMatchesNRequiredStationsInBarrelOnly=true, bool applyAlsoAngularCuts=false)
 
bool isGoodMuon (const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
 main GoodMuon wrapper call More...
 
bool isHighPtMuon (const reco::Muon &, const reco::Vertex &)
 
bool isLooseMuon (const reco::Muon &)
 
bool isLooseTriggerMuon (const reco::Muon &)
 
bool isMediumMuon (const reco::Muon &, bool run2016_hip_mitigation=false)
 
bool isSoftMuon (const reco::Muon &, const reco::Vertex &, bool run2016_hip_mitigation=false)
 
bool isTightMuon (const reco::Muon &, const reco::Vertex &)
 
bool isTrackerHighPtMuon (const reco::Muon &, const reco::Vertex &)
 
reco::Muon::Selector makeSelectorBitset (reco::Muon const &muon, reco::Vertex const *vertex=nullptr, bool run2016_hip_mitigation=false)
 
bool overlap (const reco::Muon &muon1, const reco::Muon &muon2, double pullX=1.0, double pullY=1.0, bool checkAdjacentChambers=false)
 
unsigned int RequiredStationMask (const reco::Muon &muon, double maxChamberDist, double maxChamberDistPull, reco::Muon::ArbitrationType arbitrationType)
 
float segmentCompatibility (const reco::Muon &muon, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
 
SelectionType selectionTypeFromString (const std::string &label)
 
reco::Muon::Selector selectorFromString (const std::string &label)
 
int sharedSegments (const reco::Muon &muon1, const reco::Muon &muon2, unsigned int segmentArbitrationMask=reco::MuonSegmentMatch::BestInChamberByDR)
 
reco::Muon::MuonTrackTypePair sigmaSwitch (const reco::Muon &muon, const double nSigma=2., const double ptThreshold=200.)
 
reco::Muon::MuonTrackTypePair sigmaSwitch (const reco::TrackRef &combinedTrack, const reco::TrackRef &trackerTrack, const double nSigma=2., const double ptThreshold=200.)
 
reco::Muon::MuonTrackTypePair tevOptimized (const reco::Muon &muon, const double ptThreshold=200., const double tune1=17., const double tune2=40., const double dptcut=0.25)
 
reco::Muon::MuonTrackTypePair tevOptimized (const reco::TrackRef &combinedTrack, const reco::TrackRef &trackerTrack, const reco::TrackRef &tpfmsTrack, const reco::TrackRef &pickyTrack, const reco::TrackRef &dytTrack, const double ptThreshold=200., const double tune1=17., const double tune2=40., const double dptcut=0.25)
 
reco::Muon::MuonTrackTypePair TMR (const reco::TrackRef &trackerTrack, const reco::TrackRef &fmsTrack, const double tune=4.)
 
double trackProbability (const reco::TrackRef track)
 

Variables

static const SelectionTypeStringToEnum selectionTypeStringToEnumMap []
 
static const SelectorStringToEnum selectorStringToEnumMap []
 

Detailed Description

Filter to select me0Muons based on pulls and differences w.r.t. me0Segments

Enumeration Type Documentation

◆ AlgorithmType

enum muon::AlgorithmType
Enumerator
TMLastStation 
TM2DCompatibility 
TMOneStation 
RPCMu 
ME0Mu 
GEMMu 

Definition at line 155 of file MuonSelectors.h.

155 { TMLastStation, TM2DCompatibility, TMOneStation, RPCMu, ME0Mu, GEMMu };

◆ SelectionType [1/2]

enum muon::SelectionType

Selector type.

Enumerator
All 
AllGlobalMuons 
AllStandAloneMuons 
AllTrackerMuons 
TrackerMuonArbitrated 
AllArbitrated 
GlobalMuonPromptTight 
TMLastStationLoose 
TMLastStationTight 
TM2DCompatibilityLoose 
TM2DCompatibilityTight 
TMOneStationLoose 
TMOneStationTight 
TMLastStationOptimizedLowPtLoose 
TMLastStationOptimizedLowPtTight 
GMTkChiCompatibility 
GMStaChiCompatibility 
GMTkKinkTight 
TMLastStationAngLoose 
TMLastStationAngTight 
TMOneStationAngLoose 
TMOneStationAngTight 
TMLastStationOptimizedBarrelLowPtLoose 
TMLastStationOptimizedBarrelLowPtTight 
RPCMuLoose 
AllME0Muons 
ME0MuonArbitrated 
AllGEMMuons 
GEMMuonArbitrated 
TriggerIdLoose 
All 
VeryLoose 
Loose 
Tight 

Definition at line 13 of file ME0MuonSelector.h.

13  {
14  All = 0, // dummy options - always true
15  VeryLoose = 1, //
16  Loose = 2, //
17  Tight = 3, //
18  };

◆ SelectionType [2/2]

enum muon::SelectionType

Selector type.

Enumerator
All 
AllGlobalMuons 
AllStandAloneMuons 
AllTrackerMuons 
TrackerMuonArbitrated 
AllArbitrated 
GlobalMuonPromptTight 
TMLastStationLoose 
TMLastStationTight 
TM2DCompatibilityLoose 
TM2DCompatibilityTight 
TMOneStationLoose 
TMOneStationTight 
TMLastStationOptimizedLowPtLoose 
TMLastStationOptimizedLowPtTight 
GMTkChiCompatibility 
GMStaChiCompatibility 
GMTkKinkTight 
TMLastStationAngLoose 
TMLastStationAngTight 
TMOneStationAngLoose 
TMOneStationAngTight 
TMLastStationOptimizedBarrelLowPtLoose 
TMLastStationOptimizedBarrelLowPtTight 
RPCMuLoose 
AllME0Muons 
ME0MuonArbitrated 
AllGEMMuons 
GEMMuonArbitrated 
TriggerIdLoose 
All 
VeryLoose 
Loose 
Tight 

Definition at line 19 of file MuonSelectors.h.

19  {
20  All = 0, // dummy options - always true
21  AllGlobalMuons = 1, // checks isGlobalMuon flag
22  AllStandAloneMuons = 2, // checks isStandAloneMuon flag
23  AllTrackerMuons = 3, // checks isTrackerMuon flag
24  TrackerMuonArbitrated = 4, // resolve ambiguity of sharing segments
25  AllArbitrated = 5, // all muons with the tracker muon arbitrated
26  GlobalMuonPromptTight = 6, // global muons with tighter fit requirements
27  TMLastStationLoose = 7, // penetration depth loose selector
28  TMLastStationTight = 8, // penetration depth tight selector
29  TM2DCompatibilityLoose = 9, // likelihood based loose selector
30  TM2DCompatibilityTight = 10, // likelihood based tight selector
31  TMOneStationLoose = 11, // require one well matched segment
32  TMOneStationTight = 12, // require one well matched segment
33  TMLastStationOptimizedLowPtLoose = 13, // combination of TMLastStation and TMOneStation
34  TMLastStationOptimizedLowPtTight = 14, // combination of TMLastStation and TMOneStation
35  GMTkChiCompatibility = 15, // require tk stub have good chi2 relative to glb track
36  GMStaChiCompatibility = 16, // require sta stub have good chi2 compatibility relative to glb track
37  GMTkKinkTight = 17, // require a small kink value in the tracker stub
38  TMLastStationAngLoose = 18, // TMLastStationLoose with additional angular cuts
39  TMLastStationAngTight = 19, // TMLastStationTight with additional angular cuts
40  TMOneStationAngLoose = 20, // TMOneStationLoose with additional angular cuts
41  TMOneStationAngTight = 21, // TMOneStationTight with additional angular cuts
42  // The two algorithms that follow are identical to what were known as
43  // TMLastStationOptimizedLowPt* (sans the Barrel) as late as revision
44  // 1.7 of this file. The names were changed because indeed the low pt
45  // optimization applies only to the barrel region, whereas the sel-
46  // ectors above are more efficient at low pt in the endcaps, which is
47  // what we feel is more suggestive of the algorithm name. This will be
48  // less confusing for future generations of CMS members, I hope...
49  // combination of TMLastStation and TMOneStation but with low pT optimization in barrel only
50  TMLastStationOptimizedBarrelLowPtLoose = 22,
51  // combination of TMLastStation and TMOneStation but with low pT optimization in barrel only
52  TMLastStationOptimizedBarrelLowPtTight = 23,
53  RPCMuLoose = 24, // checks isRPCMuon flag (require two well matched hits in different RPC layers)
54  AllME0Muons = 25,
55  ME0MuonArbitrated = 26,
56  AllGEMMuons = 27,
57  GEMMuonArbitrated = 28,
58  TriggerIdLoose = 29
59  };

Function Documentation

◆ caloCompatibility()

float muon::caloCompatibility ( const reco::Muon &  muon)

Definition at line 58 of file MuonSelectors.cc.

58 { return muon.caloCompatibility(); }

Referenced by CSCEfficiency::filter(), isGoodMuon(), and pat::MuonSelector::muIdSelection_().

◆ getTevRefitTrack()

reco::TrackRef muon::getTevRefitTrack ( const reco::TrackRef &  combinedTrack,
const reco::TrackToTrackMap &  map 
)

Definition at line 131 of file MuonCocktails.cc.

131  {
132  reco::TrackToTrackMap::const_iterator it = map.find(combinedTrack);
133  return it == map.end() ? reco::TrackRef() : it->val;
134 }

References genParticles_cff::map, and edm::helpers::KeyVal< K, V >::val.

Referenced by MuonIdProducer::makeMuon().

◆ isGoodMuon() [1/5]

bool muon::isGoodMuon ( const reco::ME0Muon &  me0muon,
double  MaxPullX,
double  MaxDiffX,
double  MaxPullY,
double  MaxDiffY,
double  MaxDiffPhiDir 
)

Specialized isGoodMuon function called from main wrapper.

Definition at line 53 of file ME0MuonSelector.cc.

58  {
59  using namespace reco;
60 
61  const ME0Segment& thisSegment = me0muon.me0segment();
62 
63  const LocalPoint& r3FinalReco = me0muon.localTrackPosAtSurface();
64 
65  AlgebraicSymMatrix55 C = me0muon.localTrackCov();
66  LocalPoint thisPosition(thisSegment.localPosition());
67 
68  double sigmax = sqrt(C[3][3] + thisSegment.localPositionError().xx());
69  double sigmay = sqrt(C[4][4] + thisSegment.localPositionError().yy());
70 
71  bool X_MatchFound = false, Y_MatchFound = false, Dir_MatchFound = false;
72 
73  if (((std::abs(thisPosition.x() - r3FinalReco.x()) / sigmax) < MaxPullX) ||
74  (std::abs(thisPosition.x() - r3FinalReco.x()) < MaxDiffX))
75  X_MatchFound = true;
76  if (((std::abs(thisPosition.y() - r3FinalReco.y()) / sigmay) < MaxPullY) ||
77  (std::abs(thisPosition.y() - r3FinalReco.y()) < MaxDiffY))
78  Y_MatchFound = true;
79  if (std::abs(reco::deltaPhi(me0muon.localTrackMomAtSurface().barePhi(), thisSegment.localDirection().barePhi())) <
80  MaxDiffPhiDir)
81  Dir_MatchFound = true;
82 
83  return (X_MatchFound && Y_MatchFound && Dir_MatchFound);
84 }

References funct::abs(), PV3DBase< T, PVType, FrameType >::barePhi(), gen::C, reco::deltaPhi(), ME0Segment::localDirection(), ME0Segment::localPosition(), ME0Segment::localPositionError(), reco::ME0Muon::localTrackCov(), reco::ME0Muon::localTrackMomAtSurface(), reco::ME0Muon::localTrackPosAtSurface(), reco::ME0Muon::me0segment(), mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), PV3DBase< T, PVType, FrameType >::y(), and LocalError::yy().

◆ isGoodMuon() [2/5]

bool muon::isGoodMuon ( const reco::ME0Muon &  me0muon,
SelectionType  type 
)

main GoodMuon wrapper call

Definition at line 34 of file ME0MuonSelector.cc.

34  {
35  switch (type) {
36  case muon::All:
37  return true;
38  break;
39  case muon::VeryLoose:
40  return isGoodMuon(me0muon, 3, 4, 20, 20, 3.14);
41  break;
42  case muon::Loose:
43  return isGoodMuon(me0muon, 3, 2, 3, 2, 0.5);
44  break;
45  case muon::Tight:
46  return isGoodMuon(me0muon, 3, 2, 3, 2, 0.15);
47  break;
48  default:
49  return false;
50  }
51 }

References All, isGoodMuon(), Loose, Tight, and VeryLoose.

◆ isGoodMuon() [3/5]

bool muon::isGoodMuon ( const reco::Muon &  muon,
AlgorithmType  type,
double  minCompatibility,
reco::Muon::ArbitrationType  arbitrationType 
)

Definition at line 305 of file MuonSelectors.cc.

308  {
309  if (!muon.isMatchesValid())
310  return false;
311  bool goodMuon = false;
312 
313  switch (type) {
314  case TM2DCompatibility:
315  // Simplistic first cut in the 2D segment- vs calo-compatibility plane. Will have to be refined!
316  if (((0.8 * caloCompatibility(muon)) + (1.2 * segmentCompatibility(muon, arbitrationType))) > minCompatibility)
317  goodMuon = true;
318  else
319  goodMuon = false;
320  return goodMuon;
321  break;
322  default:
323  // LogTrace("MuonIdentification")<<" // Invalid Algorithm Type called!";
324  goodMuon = false;
325  return goodMuon;
326  break;
327  }
328 }

References caloCompatibility(), BadChargedCandidateFilter_cfi::segmentCompatibility, and TM2DCompatibility.

◆ isGoodMuon() [4/5]

bool muon::isGoodMuon ( const reco::Muon &  muon,
AlgorithmType  type,
int  minNumberOfMatches,
double  maxAbsDx,
double  maxAbsPullX,
double  maxAbsDy,
double  maxAbsPullY,
double  maxChamberDist,
double  maxChamberDistPull,
reco::Muon::ArbitrationType  arbitrationType,
bool  syncMinNMatchesNRequiredStationsInBarrelOnly = true,
bool  applyAlsoAngularCuts = false 
)

Definition at line 330 of file MuonSelectors.cc.

341  {
342  if (!muon.isMatchesValid())
343  return false;
344  bool goodMuon = false;
345 
346  if (type == TMLastStation) {
347  // To satisfy my own paranoia, if the user specifies that the
348  // minimum number of matches is zero, then return true.
349  if (minNumberOfMatches == 0)
350  return true;
351 
352  unsigned int theStationMask = muon.stationMask(arbitrationType);
353  unsigned int theRequiredStationMask =
354  RequiredStationMask(muon, maxChamberDist, maxChamberDistPull, arbitrationType);
355 
356  // Require that there be at least a minimum number of segments
357  int numSegs = 0;
358  int numRequiredStations = 0;
359  for (int it = 0; it < 8; ++it) {
360  if (theStationMask & 1 << it)
361  ++numSegs;
362  if (theRequiredStationMask & 1 << it)
363  ++numRequiredStations;
364  }
365 
366  // Make sure the minimum number of matches is not greater than
367  // the number of required stations but still greater than zero
368  if (syncMinNMatchesNRequiredStationsInBarrelOnly) {
369  // Note that we only do this in the barrel region!
370  if (fabs(muon.eta()) < 1.2) {
371  if (minNumberOfMatches > numRequiredStations)
372  minNumberOfMatches = numRequiredStations;
373  if (minNumberOfMatches < 1) //SK: this only happens for negative values
374  minNumberOfMatches = 1;
375  }
376  } else {
377  if (minNumberOfMatches > numRequiredStations)
378  minNumberOfMatches = numRequiredStations;
379  if (minNumberOfMatches < 1) //SK: this only happens for negative values
380  minNumberOfMatches = 1;
381  }
382 
383  if (numSegs >= minNumberOfMatches)
384  goodMuon = true;
385 
386  // Require that last required station have segment
387  // If there are zero required stations keep track
388  // of the last station with a segment so that we may
389  // apply the quality cuts below to it instead
390  int lastSegBit = 0;
391  if (theRequiredStationMask) {
392  for (int stationIdx = 7; stationIdx >= 0; --stationIdx)
393  if (theRequiredStationMask & 1 << stationIdx) {
394  if (theStationMask & 1 << stationIdx) {
395  lastSegBit = stationIdx;
396  goodMuon &= 1;
397  break;
398  } else {
399  goodMuon = false;
400  break;
401  }
402  }
403  } else {
404  for (int stationIdx = 7; stationIdx >= 0; --stationIdx)
405  if (theStationMask & 1 << stationIdx) {
406  lastSegBit = stationIdx;
407  break;
408  }
409  }
410 
411  if (!goodMuon)
412  return false;
413 
414  // Impose pull cuts on last segment
415  int station = 0, detector = 0;
416  station = lastSegBit < 4 ? lastSegBit + 1 : lastSegBit - 3;
417  detector = lastSegBit < 4 ? 1 : 2;
418 
419  // Check x information
420  if (fabs(muon.pullX(station, detector, arbitrationType, true)) > maxAbsPullX &&
421  fabs(muon.dX(station, detector, arbitrationType)) > maxAbsDx)
422  return false;
423 
424  if (applyAlsoAngularCuts && fabs(muon.pullDxDz(station, detector, arbitrationType, true)) > maxAbsPullX)
425  return false;
426 
427  // Is this a tight algorithm, i.e. do we bother to check y information?
428  if (maxAbsDy < 999999) { // really if maxAbsDy < 1E9 as currently defined
429 
430  // Check y information
431  if (detector == 2) { // CSC
432  if (fabs(muon.pullY(station, 2, arbitrationType, true)) > maxAbsPullY &&
433  fabs(muon.dY(station, 2, arbitrationType)) > maxAbsDy)
434  return false;
435 
436  if (applyAlsoAngularCuts && fabs(muon.pullDyDz(station, 2, arbitrationType, true)) > maxAbsPullY)
437  return false;
438  } else {
439  //
440  // In DT, if this is a "Tight" algorithm and the last segment is
441  // missing y information (always the case in station 4!!!), impose
442  // respective cuts on the next station in the stationMask that has
443  // a segment with y information. If there are no segments with y
444  // information then there is nothing to penalize. Should we
445  // penalize in Tight for having zero segments with y information?
446  // That is the fundamental question. Of course I am being uber
447  // paranoid; if this is a good muon then there will probably be at
448  // least one segment with y information but not always. Suppose
449  // somehow a muon only creates segments in station 4, then we
450  // definitely do not want to require that there be at least one
451  // segment with y information because we will lose it completely.
452  //
453 
454  for (int stationIdx = station; stationIdx > 0; --stationIdx) {
455  if (!(theStationMask & 1 << (stationIdx - 1))) // don't bother if the station is not in the stationMask
456  continue;
457 
458  if (muon.dY(stationIdx, 1, arbitrationType) > 999998) // no y-information
459  continue;
460 
461  if (fabs(muon.pullY(stationIdx, 1, arbitrationType, true)) > maxAbsPullY &&
462  fabs(muon.dY(stationIdx, 1, arbitrationType)) > maxAbsDy) {
463  return false;
464  }
465 
466  if (applyAlsoAngularCuts && fabs(muon.pullDyDz(stationIdx, 1, arbitrationType, true)) > maxAbsPullY)
467  return false;
468 
469  // If we get this far then great this is a good muon
470  return true;
471  }
472  }
473  }
474 
475  return goodMuon;
476  } // TMLastStation
477 
478  // TMOneStation requires only that there be one "good" segment, regardless
479  // of the required stations. We do not penalize if there are absolutely zero
480  // segments with y information in the Tight algorithm. Maybe I'm being
481  // paranoid but so be it. If it's really a good muon then we will probably
482  // find at least one segment with both x and y information but you never
483  // know, and I don't want to deal with a potential inefficiency in the DT
484  // like we did with the original TMLastStation. Incidentally, not penalizing
485  // for total lack of y information in the Tight algorithm is what is done in
486  // the new TMLastStation
487  //
488  if (type == TMOneStation) {
489  unsigned int theStationMask = muon.stationMask(arbitrationType);
490 
491  // Of course there must be at least one segment
492  if (!theStationMask)
493  return false;
494 
495  int station = 0, detector = 0;
496  // Keep track of whether or not there is a DT segment with y information.
497  // In the end, if it turns out there are absolutely zero DT segments with
498  // y information, require only that there was a segment with good x info.
499  // This of course only applies to the Tight algorithms.
500  bool existsGoodDTSegX = false;
501  bool existsDTSegY = false;
502 
503  // Impose cuts on the segments in the station mask until we find a good one
504  // Might as well start with the lowest bit to speed things up.
505  for (int stationIdx = 0; stationIdx <= 7; ++stationIdx)
506  if (theStationMask & 1 << stationIdx) {
507  station = stationIdx < 4 ? stationIdx + 1 : stationIdx - 3;
508  detector = stationIdx < 4 ? 1 : 2;
509 
510  if ((fabs(muon.pullX(station, detector, arbitrationType, true)) > maxAbsPullX &&
511  fabs(muon.dX(station, detector, arbitrationType)) > maxAbsDx) ||
512  (applyAlsoAngularCuts && fabs(muon.pullDxDz(station, detector, arbitrationType, true)) > maxAbsPullX))
513  continue;
514  else if (detector == 1)
515  existsGoodDTSegX = true;
516 
517  // Is this a tight algorithm? If yes, use y information
518  if (maxAbsDy < 999999) {
519  if (detector == 2) { // CSC
520  if ((fabs(muon.pullY(station, 2, arbitrationType, true)) > maxAbsPullY &&
521  fabs(muon.dY(station, 2, arbitrationType)) > maxAbsDy) ||
522  (applyAlsoAngularCuts && fabs(muon.pullDyDz(station, 2, arbitrationType, true)) > maxAbsPullY))
523  continue;
524  } else {
525  if (muon.dY(station, 1, arbitrationType) > 999998) // no y-information
526  continue;
527  else
528  existsDTSegY = true;
529 
530  if ((fabs(muon.pullY(station, 1, arbitrationType, true)) > maxAbsPullY &&
531  fabs(muon.dY(station, 1, arbitrationType)) > maxAbsDy) ||
532  (applyAlsoAngularCuts && fabs(muon.pullDyDz(station, 1, arbitrationType, true)) > maxAbsPullY)) {
533  continue;
534  }
535  }
536  }
537 
538  // If we get this far then great this is a good muon
539  return true;
540  }
541 
542  // If we get this far then for sure there are no "good" CSC segments. For
543  // DT, check if there were any segments with y information. If there
544  // were none, but there was a segment with good x, then we're happy. If
545  // there WERE segments with y information, then they must have been shit
546  // since we are here so fail it. Of course, if this is a Loose algorithm
547  // then fail immediately since if we had good x we would already have
548  // returned true
549  if (maxAbsDy < 999999) {
550  if (existsDTSegY)
551  return false;
552  else if (existsGoodDTSegX)
553  return true;
554  } else
555  return false;
556  } // TMOneStation
557 
558  if (type == RPCMu) {
559  if (minNumberOfMatches == 0)
560  return true;
561 
562  int nMatch = 0;
563  for (std::vector<reco::MuonChamberMatch>::const_iterator chamberMatch = muon.matches().begin();
564  chamberMatch != muon.matches().end();
565  ++chamberMatch) {
566  if (chamberMatch->detector() != 3)
567  continue;
568 
569  const double trkX = chamberMatch->x;
570  const double errX = chamberMatch->xErr;
571 
572  for (std::vector<reco::MuonRPCHitMatch>::const_iterator rpcMatch = chamberMatch->rpcMatches.begin();
573  rpcMatch != chamberMatch->rpcMatches.end();
574  ++rpcMatch) {
575  const double rpcX = rpcMatch->x;
576 
577  const double dX = fabs(rpcX - trkX);
578  if (dX < maxAbsDx or dX / errX < maxAbsPullX) {
579  ++nMatch;
580  break;
581  }
582  }
583  }
584 
585  if (nMatch >= minNumberOfMatches)
586  return true;
587  else
588  return false;
589  } // RPCMu
590 
591  if (type == ME0Mu) {
592  if (minNumberOfMatches == 0)
593  return true;
594 
595  int nMatch = 0;
596  for (const auto& chamberMatch : muon.matches()) {
597  if (chamberMatch.detector() != MuonSubdetId::ME0)
598  continue;
599 
600  const double trkX = chamberMatch.x;
601  const double errX = chamberMatch.xErr;
602  const double trkY = chamberMatch.y;
603  const double errY = chamberMatch.yErr;
604 
605  for (const auto& segment : chamberMatch.me0Matches) {
606  const double me0X = segment.x;
607  const double me0ErrX = segment.xErr;
608  const double me0Y = segment.y;
609  const double me0ErrY = segment.yErr;
610 
611  const double dX = fabs(me0X - trkX);
612  const double dY = fabs(me0Y - trkY);
613  const double pullX = dX / std::sqrt(errX + me0ErrX);
614  const double pullY = dY / std::sqrt(errY + me0ErrY);
615 
616  if ((dX < maxAbsDx or pullX < maxAbsPullX) and (dY < maxAbsDy or pullY < maxAbsPullY)) {
617  ++nMatch;
618  break;
619  }
620  }
621  }
622 
623  return (nMatch >= minNumberOfMatches);
624  } // ME0Mu
625 
626  if (type == GEMMu) {
627  if (minNumberOfMatches == 0)
628  return true;
629 
630  int nMatch = 0;
631  for (const auto& chamberMatch : muon.matches()) {
632  if (chamberMatch.detector() != MuonSubdetId::GEM)
633  continue;
634 
635  const double trkX = chamberMatch.x;
636  const double errX = chamberMatch.xErr;
637  const double trkY = chamberMatch.y;
638  const double errY = chamberMatch.yErr;
639 
640  for (const auto& segment : chamberMatch.gemMatches) {
641  const double gemX = segment.x;
642  const double gemErrX = segment.xErr;
643  const double gemY = segment.y;
644  const double gemErrY = segment.yErr;
645 
646  const double dX = fabs(gemX - trkX);
647  const double dY = fabs(gemY - trkY);
648  const double pullX = dX / std::sqrt(errX + gemErrX);
649  const double pullY = dY / std::sqrt(errY + gemErrY);
650 
651  if ((dX < maxAbsDx or pullX < maxAbsPullX) and (dY < maxAbsDy or pullY < maxAbsPullY)) {
652  ++nMatch;
653  break;
654  }
655  }
656  }
657 
658  return (nMatch >= minNumberOfMatches);
659  } // GEMMu
660 
661  return goodMuon;
662 }

References hgcalTestNeighbor_cfi::detector, fftjetvertexadder_cfi::errX, fftjetvertexadder_cfi::errY, MuonSubdetId::GEM, GEMMu, HLT_2018_cff::maxAbsDx, HLT_2018_cff::maxAbsDy, HLT_2018_cff::maxAbsPullX, HLT_2018_cff::maxAbsPullY, MuonSubdetId::ME0, ME0Mu, HLT_2018_cff::minNumberOfMatches, or, RequiredStationMask(), RPCMu, mathSSE::sqrt(), relativeConstraints::station, TMLastStation, and TMOneStation.

◆ isGoodMuon() [5/5]

bool muon::isGoodMuon ( const reco::Muon &  muon,
SelectionType  type,
reco::Muon::ArbitrationType  arbitrationType = reco::Muon::SegmentAndTrackArbitration 
)

main GoodMuon wrapper call

Definition at line 664 of file MuonSelectors.cc.

664  {
665  switch (type) {
666  case muon::All:
667  return true;
668  break;
669  case muon::AllGlobalMuons:
670  return muon.isGlobalMuon();
671  break;
672  case muon::AllTrackerMuons:
673  return muon.isTrackerMuon();
674  break;
675  case muon::AllStandAloneMuons:
676  return muon.isStandAloneMuon();
677  break;
678  case muon::TrackerMuonArbitrated:
679  return muon.isTrackerMuon() && muon.numberOfMatches(arbitrationType) > 0;
680  break;
681  case muon::AllArbitrated:
682  return !muon.isTrackerMuon() || muon.numberOfMatches(arbitrationType) > 0;
683  break;
684  case muon::GlobalMuonPromptTight:
685  return muon.isGlobalMuon() && muon.globalTrack()->normalizedChi2() < 10. &&
686  muon.globalTrack()->hitPattern().numberOfValidMuonHits() > 0;
687  break;
688  // For "Loose" algorithms we choose maximum y quantity cuts of 1E9 instead of
689  // 9999 as before. We do this because the muon methods return 999999 (note
690  // there are six 9's) when the requested information is not available. For
691  // example, if a muon fails to traverse the z measuring superlayer in a station
692  // in the DT, then all methods involving segmentY in this station return
693  // 999999 to demonstrate that the information is missing. In order to not
694  // penalize muons for missing y information in Loose algorithms where we do
695  // not care at all about y information, we raise these limits. In the
696  // TMLastStation and TMOneStation algorithms we actually use this huge number
697  // to determine whether to consider y information at all.
698  case muon::TMLastStationLoose:
699  return muon.isTrackerMuon() &&
700  isGoodMuon(muon, TMLastStation, 2, 3, 3, 1E9, 1E9, -3, -3, arbitrationType, true, false);
701  break;
702  case muon::TMLastStationTight:
703  return muon.isTrackerMuon() &&
704  isGoodMuon(muon, TMLastStation, 2, 3, 3, 3, 3, -3, -3, arbitrationType, true, false);
705  break;
706  case muon::TMOneStationLoose:
707  return muon.isTrackerMuon() &&
708  isGoodMuon(muon, TMOneStation, 1, 3, 3, 1E9, 1E9, 1E9, 1E9, arbitrationType, false, false);
709  break;
710  case muon::TMOneStationTight:
711  return muon.isTrackerMuon() &&
712  isGoodMuon(muon, TMOneStation, 1, 3, 3, 3, 3, 1E9, 1E9, arbitrationType, false, false);
713  break;
714  case muon::TMLastStationOptimizedLowPtLoose:
715  if (muon.pt() < 8. && fabs(muon.eta()) < 1.2)
716  return muon.isTrackerMuon() &&
717  isGoodMuon(muon, TMOneStation, 1, 3, 3, 1E9, 1E9, 1E9, 1E9, arbitrationType, false, false);
718  else
719  return muon.isTrackerMuon() &&
720  isGoodMuon(muon, TMLastStation, 2, 3, 3, 1E9, 1E9, -3, -3, arbitrationType, false, false);
721  break;
722  case muon::TMLastStationOptimizedLowPtTight:
723  if (muon.pt() < 8. && fabs(muon.eta()) < 1.2)
724  return muon.isTrackerMuon() &&
725  isGoodMuon(muon, TMOneStation, 1, 3, 3, 3, 3, 1E9, 1E9, arbitrationType, false, false);
726  else
727  return muon.isTrackerMuon() &&
728  isGoodMuon(muon, TMLastStation, 2, 3, 3, 3, 3, -3, -3, arbitrationType, false, false);
729  break;
730  //compatibility loose
731  case muon::TM2DCompatibilityLoose:
732  return muon.isTrackerMuon() && isGoodMuon(muon, TM2DCompatibility, 0.7, arbitrationType);
733  break;
734  //compatibility tight
735  case muon::TM2DCompatibilityTight:
736  return muon.isTrackerMuon() && isGoodMuon(muon, TM2DCompatibility, 1.0, arbitrationType);
737  break;
738  case muon::GMTkChiCompatibility:
739  return muon.isGlobalMuon() && muon.isQualityValid() &&
740  fabs(muon.combinedQuality().trkRelChi2 - muon.innerTrack()->normalizedChi2()) < 2.0;
741  break;
742  case muon::GMStaChiCompatibility:
743  return muon.isGlobalMuon() && muon.isQualityValid() &&
744  fabs(muon.combinedQuality().staRelChi2 - muon.outerTrack()->normalizedChi2()) < 2.0;
745  break;
746  case muon::GMTkKinkTight:
747  return muon.isGlobalMuon() && muon.isQualityValid() && muon.combinedQuality().trkKink < 100.0;
748  break;
749  case muon::TMLastStationAngLoose:
750  return muon.isTrackerMuon() &&
751  isGoodMuon(muon, TMLastStation, 2, 3, 3, 1E9, 1E9, -3, -3, arbitrationType, false, true);
752  break;
753  case muon::TMLastStationAngTight:
754  return muon.isTrackerMuon() &&
755  isGoodMuon(muon, TMLastStation, 2, 3, 3, 3, 3, -3, -3, arbitrationType, false, true);
756  break;
757  case muon::TMOneStationAngLoose:
758  return muon.isTrackerMuon() &&
759  isGoodMuon(muon, TMOneStation, 1, 3, 3, 1E9, 1E9, 1E9, 1E9, arbitrationType, false, true);
760  break;
761  case muon::TMOneStationAngTight:
762  return muon.isTrackerMuon() &&
763  isGoodMuon(muon, TMOneStation, 1, 3, 3, 3, 3, 1E9, 1E9, arbitrationType, false, true);
764  break;
765  case muon::TMLastStationOptimizedBarrelLowPtLoose:
766  if (muon.pt() < 8. && fabs(muon.eta()) < 1.2)
767  return muon.isTrackerMuon() &&
768  isGoodMuon(muon, TMOneStation, 1, 3, 3, 1E9, 1E9, 1E9, 1E9, arbitrationType, false, false);
769  else
770  return muon.isTrackerMuon() &&
771  isGoodMuon(muon, TMLastStation, 2, 3, 3, 1E9, 1E9, -3, -3, arbitrationType, true, false);
772  break;
773  case muon::TMLastStationOptimizedBarrelLowPtTight:
774  if (muon.pt() < 8. && fabs(muon.eta()) < 1.2)
775  return muon.isTrackerMuon() &&
776  isGoodMuon(muon, TMOneStation, 1, 3, 3, 3, 3, 1E9, 1E9, arbitrationType, false, false);
777  else
778  return muon.isTrackerMuon() &&
779  isGoodMuon(muon, TMLastStation, 2, 3, 3, 3, 3, -3, -3, arbitrationType, true, false);
780  break;
781  case muon::RPCMuLoose:
782  return muon.isRPCMuon() && isGoodMuon(muon, RPCMu, 2, 20, 4, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
783  break;
784  case muon::AllME0Muons:
785  return muon.isME0Muon();
786  break;
787  case muon::ME0MuonArbitrated:
788  return muon.isME0Muon() &&
789  isGoodMuon(muon, ME0Mu, 1, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
790  break;
791  case muon::AllGEMMuons:
792  return muon.isGEMMuon();
793  break;
794  case muon::GEMMuonArbitrated:
795  return muon.isGEMMuon() &&
796  isGoodMuon(muon, GEMMu, 1, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
797  break;
798  case muon::TriggerIdLoose:
799  return isLooseTriggerMuon(muon);
800  break;
801  default:
802  return false;
803  }
804 }

References All, AllArbitrated, AllGEMMuons, AllGlobalMuons, AllME0Muons, AllStandAloneMuons, AllTrackerMuons, GEMMu, GEMMuonArbitrated, GlobalMuonPromptTight, GMStaChiCompatibility, GMTkChiCompatibility, GMTkKinkTight, isLooseTriggerMuon(), ME0Mu, ME0MuonArbitrated, RPCMu, RPCMuLoose, TM2DCompatibility, TM2DCompatibilityLoose, TM2DCompatibilityTight, TMLastStation, TMLastStationAngLoose, TMLastStationAngTight, TMLastStationLoose, TMLastStationOptimizedBarrelLowPtLoose, TMLastStationOptimizedBarrelLowPtTight, TMLastStationOptimizedLowPtLoose, TMLastStationOptimizedLowPtTight, TMLastStationTight, TMOneStation, TMOneStationAngLoose, TMOneStationAngTight, TMOneStationLoose, TMOneStationTight, TrackerMuonArbitrated, and TriggerIdLoose.

Referenced by BPHSoftMuonSelect::accept(), ExampleMuonAnalyzer::analyze(), BPhysicsOniaDQM::analyze(), TrackEfficiencyMonitor::analyze(), HiggsDQM::analyze(), MuonIdVal::analyze(), MuonCosmicCompatibilityFiller::checkMuonID(), PFRecoTauDiscriminationAgainstMuon::discriminate(), ZtoMMEventSelector::filter(), WMuNuValidator::filter(), WMuNuSelector::filter(), HLTDiMuonGlbTrkFilter::hltFilter(), HLTMuonTrkFilter::hltFilter(), HLTMuonTrkL1TFilter::hltFilter(), HLTMuonL3PreFilter::hltFilter(), PFMuonAlgo::isGlobalLooseMuon(), PFMuonAlgo::isGlobalTightMuon(), isGoodMuon(), isLooseTriggerMuon(), isSoftMuon(), MuonIDTableProducer::isSoftMuonHIP(), isTightMuon(), PFMuonAlgo::isTightMuonPOG(), PFMuonAlgo::isTrackerLooseMuon(), PFMuonAlgo::isTrackerTightMuon(), PFB::match(), JetPlusTrackCorrector::matchMuons(), pat::MuonSelector::muIdSelection_(), MuonSelectorVIDWrapper< selectionType, arbitrationType >::operator()(), MuonBadTrackFilter::printMuonProperties(), PFMuonAlgo::printMuonProperties(), MuonTrackProducer::produce(), MuonIDFilterProducerForHLT::produce(), MuonSelectionTypeValueMapProducer::produce(), MuonRefProducer::produce(), ME0MuonTrackCollProducer::produce(), SoftLepton::produce(), and MuonSelectorVIDWrapper< selectionType, arbitrationType >::value().

◆ isHighPtMuon()

bool muon::isHighPtMuon ( const reco::Muon &  muon,
const reco::Vertex &  vtx 
)

Definition at line 947 of file MuonSelectors.cc.

947  {
948  if (!muon.isGlobalMuon())
949  return false;
950 
951  bool muValHits = (muon.globalTrack()->hitPattern().numberOfValidMuonHits() > 0 ||
952  muon.tunePMuonBestTrack()->hitPattern().numberOfValidMuonHits() > 0);
953 
954  bool muMatchedSt = muon.numberOfMatchedStations() > 1;
955  if (!muMatchedSt) {
956  if (muon.isTrackerMuon() && muon.numberOfMatchedStations() == 1) {
957  if (muon.expectedNnumberOfMatchedStations() < 2 || !(muon.stationMask() == 1 || muon.stationMask() == 16) ||
958  muon.numberOfMatchedRPCLayers() > 2)
959  muMatchedSt = true;
960  }
961  }
962 
963  bool muID = muValHits && muMatchedSt;
964 
965  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
966  muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
967 
968  bool momQuality = muon.tunePMuonBestTrack()->ptError() / muon.tunePMuonBestTrack()->pt() < 0.3;
969 
970  bool ip = fabs(muon.innerTrack()->dxy(vtx.position())) < 0.2 && fabs(muon.innerTrack()->dz(vtx.position())) < 0.5;
971 
972  return muID && hits && momQuality && ip;
973 }

References hfClusterShapes_cfi::hits, and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by MuonKinVsEtaAnalyzer::analyze(), makeSelectorBitset(), Muon.Muon::muonID(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), and MuonPOGStandardCut::value().

◆ isLooseMuon()

bool muon::isLooseMuon ( const reco::Muon &  muon)

Definition at line 910 of file MuonSelectors.cc.

910  {
911  return muon.isPFMuon() && (muon.isGlobalMuon() || muon.isTrackerMuon());
912 }

Referenced by DiMuonHistograms::analyze(), EfficiencyAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), L1TTauOffline::getTightMuons(), isMediumMuon(), MuonIDTableProducer::isMediumMuonHIP(), Muon.Muon::looseId(), makeSelectorBitset(), Muon.Muon::muonID(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), SoftPFMuonTagInfoProducer::produce(), and MuonPOGStandardCut::value().

◆ isLooseTriggerMuon()

bool muon::isLooseTriggerMuon ( const reco::Muon &  muon)

Definition at line 881 of file MuonSelectors.cc.

881  {
882  // Requirements:
883  // - no depencence on information not availabe in the muon object
884  // - use only robust inputs
885  bool tk_id = muon::isGoodMuon(muon, TMOneStationTight);
886  if (not tk_id)
887  return false;
888  bool layer_requirements = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
889  muon.innerTrack()->hitPattern().pixelLayersWithMeasurement() > 0;
890  bool match_requirements =
891  (muon.expectedNnumberOfMatchedStations() < 2) or (muon.numberOfMatchedStations() > 1) or (muon.pt() < 8);
892  return layer_requirements and match_requirements;
893 }

References isGoodMuon(), or, and TMOneStationTight.

Referenced by isGoodMuon(), makeSelectorBitset(), and MuonIDFilterProducerForHLT::produce().

◆ isMediumMuon()

bool muon::isMediumMuon ( const reco::Muon &  muon,
bool  run2016_hip_mitigation = false 
)

Definition at line 914 of file MuonSelectors.cc.

914  {
915  if (not isLooseMuon(muon))
916  return false;
917  if (run2016_hip_mitigation) {
918  if (muon.innerTrack()->validFraction() < 0.49)
919  return false;
920  } else {
921  if (muon.innerTrack()->validFraction() < 0.8)
922  return false;
923  }
924 
925  bool goodGlb = muon.isGlobalMuon() && muon.globalTrack()->normalizedChi2() < 3. &&
926  muon.combinedQuality().chi2LocalPosition < 12. && muon.combinedQuality().trkKink < 20.;
927 
928  return (segmentCompatibility(muon) > (goodGlb ? 0.303 : 0.451));
929 }

References isLooseMuon(), and BadChargedCandidateFilter_cfi::segmentCompatibility.

Referenced by DiMuonHistograms::analyze(), EfficiencyAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), HcalHBHEMuonAnalyzer::analyze(), makeSelectorBitset(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), BadGlobalMuonTagger::tighterId(), and MuonPOGStandardCut::value().

◆ isSoftMuon()

bool muon::isSoftMuon ( const reco::Muon &  muon,
const reco::Vertex &  vtx,
bool  run2016_hip_mitigation = false 
)

Definition at line 931 of file MuonSelectors.cc.

931  {
932  bool muID = muon::isGoodMuon(muon, TMOneStationTight);
933 
934  if (!muID)
935  return false;
936 
937  bool layers = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
938  muon.innerTrack()->hitPattern().pixelLayersWithMeasurement() > 0;
939 
940  bool ishighq = muon.innerTrack()->quality(reco::Track::highPurity);
941 
942  bool ip = fabs(muon.innerTrack()->dxy(vtx.position())) < 0.3 && fabs(muon.innerTrack()->dz(vtx.position())) < 20.;
943 
944  return layers && ip && (ishighq | run2016_hip_mitigation);
945 }

References reco::TrackBase::highPurity, isGoodMuon(), hgcalTopologyTester_cfi::layers, TMOneStationTight, and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by DiMuonHistograms::analyze(), MuonKinVsEtaAnalyzer::analyze(), LeptonSkimming::filter(), makeSelectorBitset(), Muon.Muon::muonID(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), and MuonPOGStandardCut::value().

◆ isTightMuon()

bool muon::isTightMuon ( const reco::Muon &  muon,
const reco::Vertex &  vtx 
)

Definition at line 895 of file MuonSelectors.cc.

895  {
896  if (!muon.isPFMuon() || !muon.isGlobalMuon())
897  return false;
898 
899  bool muID = isGoodMuon(muon, GlobalMuonPromptTight) && (muon.numberOfMatchedStations() > 1);
900 
901  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
902  muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
903 
904  bool ip =
905  fabs(muon.muonBestTrack()->dxy(vtx.position())) < 0.2 && fabs(muon.muonBestTrack()->dz(vtx.position())) < 0.5;
906 
907  return muID && hits && ip;
908 }

References GlobalMuonPromptTight, hfClusterShapes_cfi::hits, isGoodMuon(), and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by METplusTrackMonitor::analyze(), RecoMuonValidator::analyze(), DiMuonHistograms::analyze(), EfficiencyAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonPFAnalyzer::analyze(), MuonRecoOneHLT::analyze(), HcalHBHEMuonAnalyzer::analyze(), L1TMuonDQMOffline::getTightMuons(), makeSelectorBitset(), Muon.Muon::muonID(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), and MuonPOGStandardCut::value().

◆ isTrackerHighPtMuon()

bool muon::isTrackerHighPtMuon ( const reco::Muon &  muon,
const reco::Vertex &  vtx 
)

Definition at line 975 of file MuonSelectors.cc.

975  {
976  bool muID = muon.isTrackerMuon() && muon.track().isNonnull() && (muon.numberOfMatchedStations() > 1);
977  if (!muID)
978  return false;
979 
980  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
981  muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
982 
983  bool momQuality = muon.tunePMuonBestTrack()->ptError() / muon.tunePMuonBestTrack()->pt() < 0.3;
984 
985  bool ip = fabs(muon.innerTrack()->dxy(vtx.position())) < 0.2 && fabs(muon.innerTrack()->dz(vtx.position())) < 0.5;
986 
987  return muID && hits && momQuality && ip;
988 }

References hfClusterShapes_cfi::hits, and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by makeSelectorBitset().

◆ makeSelectorBitset()

reco::Muon::Selector muon::makeSelectorBitset ( reco::Muon const &  muon,
reco::Vertex const *  vertex = nullptr,
bool  run2016_hip_mitigation = false 
)

Definition at line 1045 of file MuonSelectors.cc.

1047  {
1048  // https://twiki.cern.ch/twiki/bin/viewauth/CMS/SWGuideMuonIdRun2
1049  unsigned int selectors = muon.selectors();
1050  // Compute Id and Isolation variables
1051  double chIso = muon.pfIsolationR04().sumChargedHadronPt;
1052  double nIso = muon.pfIsolationR04().sumNeutralHadronEt;
1053  double phoIso = muon.pfIsolationR04().sumPhotonEt;
1054  double puIso = muon.pfIsolationR04().sumPUPt;
1055  double dbCorrectedIsolation = chIso + std::max(nIso + phoIso - .5 * puIso, 0.);
1056  double dbCorrectedRelIso = dbCorrectedIsolation / muon.pt();
1057  double tkRelIso = muon.isolationR03().sumPt / muon.pt();
1058 
1059  // Base selectors
1060  if (muon::isLooseMuon(muon))
1061  selectors |= reco::Muon::CutBasedIdLoose;
1062  if (vertex) {
1063  if (muon::isTightMuon(muon, *vertex))
1064  selectors |= reco::Muon::CutBasedIdTight;
1065  if (muon::isSoftMuon(muon, *vertex, run2016_hip_mitigation))
1066  selectors |= reco::Muon::SoftCutBasedId;
1067  if (muon::isHighPtMuon(muon, *vertex))
1068  selectors |= reco::Muon::CutBasedIdGlobalHighPt;
1069  if (muon::isTrackerHighPtMuon(muon, *vertex))
1070  selectors |= reco::Muon::CutBasedIdTrkHighPt;
1071  }
1072  if (muon::isMediumMuon(muon, run2016_hip_mitigation)) {
1073  selectors |= reco::Muon::CutBasedIdMedium;
1074  if (vertex and fabs(muon.muonBestTrack()->dz(vertex->position())) < 0.1 and
1075  fabs(muon.muonBestTrack()->dxy(vertex->position())) < 0.02)
1076  selectors |= reco::Muon::CutBasedIdMediumPrompt;
1077  }
1078 
1079  // PF isolation
1080  if (dbCorrectedRelIso < 0.40)
1081  selectors |= reco::Muon::PFIsoVeryLoose;
1082  if (dbCorrectedRelIso < 0.25)
1083  selectors |= reco::Muon::PFIsoLoose;
1084  if (dbCorrectedRelIso < 0.20)
1085  selectors |= reco::Muon::PFIsoMedium;
1086  if (dbCorrectedRelIso < 0.15)
1087  selectors |= reco::Muon::PFIsoTight;
1088  if (dbCorrectedRelIso < 0.10)
1089  selectors |= reco::Muon::PFIsoVeryTight;
1090  if (dbCorrectedRelIso < 0.05)
1091  selectors |= reco::Muon::PFIsoVeryVeryTight;
1092 
1093  // Tracker isolation
1094  if (tkRelIso < 0.10)
1095  selectors |= reco::Muon::TkIsoLoose;
1096  if (tkRelIso < 0.05)
1097  selectors |= reco::Muon::TkIsoTight;
1098 
1099  // Trigger selectors
1100  if (isLooseTriggerMuon(muon))
1101  selectors |= reco::Muon::TriggerIdLoose;
1102 
1103  // Timing
1104  if (!outOfTimeMuon(muon))
1105  selectors |= reco::Muon::InTimeMuon;
1106 
1107  return static_cast<reco::Muon::Selector>(selectors);
1108 }

References reco::Muon::CutBasedIdGlobalHighPt, reco::Muon::CutBasedIdLoose, reco::Muon::CutBasedIdMedium, reco::Muon::CutBasedIdMediumPrompt, reco::Muon::CutBasedIdTight, reco::Muon::CutBasedIdTrkHighPt, reco::Muon::InTimeMuon, isHighPtMuon(), isLooseMuon(), isLooseTriggerMuon(), isMediumMuon(), isSoftMuon(), isTightMuon(), isTrackerHighPtMuon(), SiStripPI::max, outOfTimeMuon(), reco::Muon::PFIsoLoose, reco::Muon::PFIsoMedium, reco::Muon::PFIsoTight, reco::Muon::PFIsoVeryLoose, reco::Muon::PFIsoVeryTight, reco::Muon::PFIsoVeryVeryTight, reco::Muon::SoftCutBasedId, reco::Muon::TkIsoLoose, reco::Muon::TkIsoTight, muons_cff::tkRelIso, reco::Muon::TriggerIdLoose, and bphysicsOniaDQM_cfi::vertex.

Referenced by MuonProducer::produce(), pat::PATMuonProducer::produce(), and pat::LeptonUpdater< T >::recomputeMuonBasicSelectors().

◆ overlap()

bool muon::overlap ( const reco::Muon &  muon1,
const reco::Muon &  muon2,
double  pullX = 1.0,
double  pullY = 1.0,
bool  checkAdjacentChambers = false 
)

Definition at line 806 of file MuonSelectors.cc.

807  {
808  unsigned int nMatches1 = muon1.numberOfMatches(reco::Muon::SegmentAndTrackArbitration);
809  unsigned int nMatches2 = muon2.numberOfMatches(reco::Muon::SegmentAndTrackArbitration);
810  unsigned int betterMuon = (muon1.pt() > muon2.pt() ? 1 : 2);
811  for (std::vector<reco::MuonChamberMatch>::const_iterator chamber1 = muon1.matches().begin();
812  chamber1 != muon1.matches().end();
813  ++chamber1)
814  for (std::vector<reco::MuonChamberMatch>::const_iterator chamber2 = muon2.matches().begin();
815  chamber2 != muon2.matches().end();
816  ++chamber2) {
817  // if ( (chamber1->segmentMatches.empty() || chamber2->segmentMatches.empty()) ) continue;
818 
819  // handle case where both muons have information about the same chamber
820  // here we know how close they are
821  if (chamber1->id == chamber2->id) {
822  // found the same chamber
823  if (fabs(chamber1->x - chamber2->x) <
824  pullX * sqrt(chamber1->xErr * chamber1->xErr + chamber2->xErr * chamber2->xErr)) {
825  if (betterMuon == 1)
826  nMatches2--;
827  else
828  nMatches1--;
829  if (nMatches1 == 0 || nMatches2 == 0)
830  return true;
831  continue;
832  }
833  if (fabs(chamber1->y - chamber2->y) <
834  pullY * sqrt(chamber1->yErr * chamber1->yErr + chamber2->yErr * chamber2->yErr)) {
835  if (betterMuon == 1)
836  nMatches2--;
837  else
838  nMatches1--;
839  if (nMatches1 == 0 || nMatches2 == 0)
840  return true;
841  }
842  } else {
843  if (!checkAdjacentChambers)
844  continue;
845  // check if tracks are pointing into overlaping region of the CSC detector
846  if (chamber1->id.subdetId() != MuonSubdetId::CSC || chamber2->id.subdetId() != MuonSubdetId::CSC)
847  continue;
848  CSCDetId id1(chamber1->id);
849  CSCDetId id2(chamber2->id);
850  if (id1.endcap() != id2.endcap())
851  continue;
852  if (id1.station() != id2.station())
853  continue;
854  if (id1.ring() != id2.ring())
855  continue;
856  if (abs(id1.chamber() - id2.chamber()) > 1)
857  continue;
858  // FIXME: we don't handle 18->1; 36->1 transitions since
859  // I don't know how to check for sure how many chambers
860  // are there. Probably need to hard code some checks.
861 
862  // Now we have to make sure that both tracks are close to an edge
863  // FIXME: ignored Y coordinate for now
864  if (fabs(chamber1->edgeX) > chamber1->xErr * pullX)
865  continue;
866  if (fabs(chamber2->edgeX) > chamber2->xErr * pullX)
867  continue;
868  if (chamber1->x * chamber2->x < 0) { // check if the same edge
869  if (betterMuon == 1)
870  nMatches2--;
871  else
872  nMatches1--;
873  if (nMatches1 == 0 || nMatches2 == 0)
874  return true;
875  }
876  }
877  }
878  return false;
879 }

References funct::abs(), MuonSubdetId::CSC, globals_cff::id1, globals_cff::id2, reco::Muon::matches(), reco::Muon::numberOfMatches(), reco::LeafCandidate::pt(), reco::Muon::SegmentAndTrackArbitration, and mathSSE::sqrt().

◆ RequiredStationMask()

unsigned int muon::RequiredStationMask ( const reco::Muon &  muon,
double  maxChamberDist,
double  maxChamberDistPull,
reco::Muon::ArbitrationType  arbitrationType 
)

Definition at line 40 of file MuonSelectors.cc.

43  {
44  unsigned int theMask = 0;
45 
46  for (int stationIdx = 1; stationIdx < 5; ++stationIdx)
47  for (int detectorIdx = 1; detectorIdx < 3; ++detectorIdx)
48  if (muon.trackDist(stationIdx, detectorIdx, arbitrationType) < maxChamberDist &&
49  muon.trackDist(stationIdx, detectorIdx, arbitrationType) /
50  muon.trackDistErr(stationIdx, detectorIdx, arbitrationType) <
51  maxChamberDistPull)
52  theMask += 1 << ((stationIdx - 1) + 4 * (detectorIdx - 1));
53 
54  return theMask;
55 }

Referenced by isGoodMuon().

◆ segmentCompatibility()

float muon::segmentCompatibility ( const reco::Muon &  muon,
reco::Muon::ArbitrationType  arbitrationType = reco::Muon::SegmentAndTrackArbitration 
)

Definition at line 61 of file MuonSelectors.cc.

61  {
62  bool use_weight_regain_at_chamber_boundary = true;
63  bool use_match_dist_penalty = true;
64 
65  int nr_of_stations_crossed = 0;
66  int nr_of_stations_with_segment = 0;
67  std::vector<int> stations_w_track(8);
68  std::vector<int> station_has_segmentmatch(8);
69  std::vector<int> station_was_crossed(8);
70  std::vector<float> stations_w_track_at_boundary(8);
71  std::vector<float> station_weight(8);
72  int position_in_stations = 0;
73  float full_weight = 0.;
74 
75  for (int i = 1; i <= 8; ++i) {
76  // ********************************************************;
77  // *** fill local info for this muon (do some counting) ***;
78  // ************** begin ***********************************;
79  if (i <= 4) { // this is the section for the DTs
80  if (muon.trackDist(i, 1, arbitrationType) < 999999) { //current "raw" info that a track is close to a chamber
81  ++nr_of_stations_crossed;
82  station_was_crossed[i - 1] = 1;
83  if (muon.trackDist(i, 1, arbitrationType) > -10.)
84  stations_w_track_at_boundary[i - 1] = muon.trackDist(i, 1, arbitrationType);
85  else
86  stations_w_track_at_boundary[i - 1] = 0.;
87  }
88  //current "raw" info that a segment is matched to the current track
89  if (muon.segmentX(i, 1, arbitrationType) < 999999) {
90  ++nr_of_stations_with_segment;
91  station_has_segmentmatch[i - 1] = 1;
92  }
93  } else { // this is the section for the CSCs
94  if (muon.trackDist(i - 4, 2, arbitrationType) < 999999) { //current "raw" info that a track is close to a chamber
95  ++nr_of_stations_crossed;
96  station_was_crossed[i - 1] = 1;
97  if (muon.trackDist(i - 4, 2, arbitrationType) > -10.)
98  stations_w_track_at_boundary[i - 1] = muon.trackDist(i - 4, 2, arbitrationType);
99  else
100  stations_w_track_at_boundary[i - 1] = 0.;
101  }
102  //current "raw" info that a segment is matched to the current track
103  if (muon.segmentX(i - 4, 2, arbitrationType) < 999999) {
104  ++nr_of_stations_with_segment;
105  station_has_segmentmatch[i - 1] = 1;
106  }
107  }
108  // rough estimation of chamber border efficiency (should be parametrized better, this is just a quick guess):
109  // TF1 * merf = new TF1("merf","-0.5*(TMath::Erf(x/6.)-1)",-100,100);
110  // use above value to "unpunish" missing segment if close to border, i.e. rather than not adding any weight, add
111  // the one from the function. Only for dist ~> -10 cm, else full punish!.
112 
113  // ********************************************************;
114  // *** fill local info for this muon (do some counting) ***;
115  // ************** end *************************************;
116  }
117 
118  // ********************************************************;
119  // *** calculate weights for each station *****************;
120  // ************** begin ***********************************;
121  // const float slope = 0.5;
122  // const float attenuate_weight_regain = 1.;
123  // if attenuate_weight_regain < 1., additional punishment if track is close to boundary and no segment
124  const float attenuate_weight_regain = 0.5;
125 
126  for (int i = 1; i <= 8; ++i) { // loop over all possible stations
127 
128  // first set all weights if a station has been crossed
129  // later penalize if a station did not have a matching segment
130 
131  //old logic if(station_has_segmentmatch[i-1] > 0 ) { // the track has an associated segment at the current station
132  if (station_was_crossed[i - 1] > 0) { // the track crossed this chamber (or was nearby)
133  // - Apply a weight depending on the "depth" of the muon passage.
134  // - The station_weight is later reduced for stations with badly matched segments.
135  // - Even if there is no segment but the track passes close to a chamber boundary, the
136  // weight is set non zero and can go up to 0.5 of the full weight if the track is quite
137  // far from any station.
138  ++position_in_stations;
139 
140  switch (nr_of_stations_crossed) { // define different weights depending on how many stations were crossed
141  case 1:
142  station_weight[i - 1] = 1.;
143  break;
144  case 2:
145  if (position_in_stations == 1)
146  station_weight[i - 1] = 0.33;
147  else
148  station_weight[i - 1] = 0.67;
149  break;
150  case 3:
151  if (position_in_stations == 1)
152  station_weight[i - 1] = 0.23;
153  else if (position_in_stations == 2)
154  station_weight[i - 1] = 0.33;
155  else
156  station_weight[i - 1] = 0.44;
157  break;
158  case 4:
159  if (position_in_stations == 1)
160  station_weight[i - 1] = 0.10;
161  else if (position_in_stations == 2)
162  station_weight[i - 1] = 0.20;
163  else if (position_in_stations == 3)
164  station_weight[i - 1] = 0.30;
165  else
166  station_weight[i - 1] = 0.40;
167  break;
168 
169  default:
170  // LogTrace("MuonIdentification")<<" // Message: A muon candidate track has more than 4 stations with matching segments.";
171  // LogTrace("MuonIdentification")<<" // Did not expect this - please let me know: ibloch@fnal.gov";
172  // for all other cases
173  station_weight[i - 1] = 1. / nr_of_stations_crossed;
174  }
175 
176  if (use_weight_regain_at_chamber_boundary) { // reconstitute some weight if there is no match but the segment is close to a boundary:
177  if (station_has_segmentmatch[i - 1] <= 0 && stations_w_track_at_boundary[i - 1] != 0.) {
178  // if segment is not present but track in inefficient region, do not count as "missing match" but add some reduced weight.
179  // original "match weight" is currently reduced by at least attenuate_weight_regain, variing with an error function down to 0 if the track is
180  // inside the chamber.
181  // remark: the additional scale of 0.5 normalizes Err to run from 0 to 1 in y
182  station_weight[i - 1] = station_weight[i - 1] * attenuate_weight_regain * 0.5 *
183  (TMath::Erf(stations_w_track_at_boundary[i - 1] / 6.) + 1.);
184  } else if (station_has_segmentmatch[i - 1] <= 0 &&
185  stations_w_track_at_boundary[i - 1] == 0.) { // no segment match and track well inside chamber
186  // full penalization
187  station_weight[i - 1] = 0.;
188  }
189  } else { // always fully penalize tracks with no matching segment, whether the segment is close to the boundary or not.
190  if (station_has_segmentmatch[i - 1] <= 0)
191  station_weight[i - 1] = 0.;
192  }
193 
194  // if track has matching segment, but the matching is not high quality, penalize
195  if (station_has_segmentmatch[i - 1] > 0 && 42 == 42) {
196  if (i <= 4) { // we are in the DTs
197  if (muon.dY(i, 1, arbitrationType) < 999999 &&
198  muon.dX(i, 1, arbitrationType) < 999999) { // have both X and Y match
199  if (TMath::Sqrt(TMath::Power(muon.pullX(i, 1, arbitrationType), 2.) +
200  TMath::Power(muon.pullY(i, 1, arbitrationType), 2.)) > 1.) {
201  // reduce weight
202  if (use_match_dist_penalty) {
203  // only use pull if 3 sigma is not smaller than 3 cm
204  if (TMath::Sqrt(TMath::Power(muon.dX(i, 1, arbitrationType), 2.) +
205  TMath::Power(muon.dY(i, 1, arbitrationType), 2.)) < 3. &&
206  TMath::Sqrt(TMath::Power(muon.pullX(i, 1, arbitrationType), 2.) +
207  TMath::Power(muon.pullY(i, 1, arbitrationType), 2.)) > 3.) {
208  station_weight[i - 1] *=
209  1. /
210  TMath::Power(TMath::Max((double)TMath::Sqrt(TMath::Power(muon.dX(i, 1, arbitrationType), 2.) +
211  TMath::Power(muon.dY(i, 1, arbitrationType), 2.)),
212  (double)1.),
213  .25);
214  } else {
215  station_weight[i - 1] *=
216  1. / TMath::Power(TMath::Sqrt(TMath::Power(muon.pullX(i, 1, arbitrationType), 2.) +
217  TMath::Power(muon.pullY(i, 1, arbitrationType), 2.)),
218  .25);
219  }
220  }
221  }
222  } else if (muon.dY(i, 1, arbitrationType) >= 999999) { // has no match in Y
223  // has a match in X. Pull larger that 1 to avoid increasing the weight (just penalize, don't anti-penalize)
224  if (muon.pullX(i, 1, arbitrationType) > 1.) {
225  // reduce weight
226  if (use_match_dist_penalty) {
227  // only use pull if 3 sigma is not smaller than 3 cm
228  if (muon.dX(i, 1, arbitrationType) < 3. && muon.pullX(i, 1, arbitrationType) > 3.) {
229  station_weight[i - 1] *=
230  1. / TMath::Power(TMath::Max((double)muon.dX(i, 1, arbitrationType), (double)1.), .25);
231  } else {
232  station_weight[i - 1] *= 1. / TMath::Power(muon.pullX(i, 1, arbitrationType), .25);
233  }
234  }
235  }
236  } else { // has no match in X
237  // has a match in Y. Pull larger that 1 to avoid increasing the weight (just penalize, don't anti-penalize)
238  if (muon.pullY(i, 1, arbitrationType) > 1.) {
239  // reduce weight
240  if (use_match_dist_penalty) {
241  // only use pull if 3 sigma is not smaller than 3 cm
242  if (muon.dY(i, 1, arbitrationType) < 3. && muon.pullY(i, 1, arbitrationType) > 3.) {
243  station_weight[i - 1] *=
244  1. / TMath::Power(TMath::Max((double)muon.dY(i, 1, arbitrationType), (double)1.), .25);
245  } else {
246  station_weight[i - 1] *= 1. / TMath::Power(muon.pullY(i, 1, arbitrationType), .25);
247  }
248  }
249  }
250  }
251  } else { // We are in the CSCs
252  if (TMath::Sqrt(TMath::Power(muon.pullX(i - 4, 2, arbitrationType), 2.) +
253  TMath::Power(muon.pullY(i - 4, 2, arbitrationType), 2.)) > 1.) {
254  // reduce weight
255  if (use_match_dist_penalty) {
256  // only use pull if 3 sigma is not smaller than 3 cm
257  if (TMath::Sqrt(TMath::Power(muon.dX(i - 4, 2, arbitrationType), 2.) +
258  TMath::Power(muon.dY(i - 4, 2, arbitrationType), 2.)) < 3. &&
259  TMath::Sqrt(TMath::Power(muon.pullX(i - 4, 2, arbitrationType), 2.) +
260  TMath::Power(muon.pullY(i - 4, 2, arbitrationType), 2.)) > 3.) {
261  station_weight[i - 1] *=
262  1. /
263  TMath::Power(TMath::Max((double)TMath::Sqrt(TMath::Power(muon.dX(i - 4, 2, arbitrationType), 2.) +
264  TMath::Power(muon.dY(i - 4, 2, arbitrationType), 2.)),
265  (double)1.),
266  .25);
267  } else {
268  station_weight[i - 1] *=
269  1. / TMath::Power(TMath::Sqrt(TMath::Power(muon.pullX(i - 4, 2, arbitrationType), 2.) +
270  TMath::Power(muon.pullY(i - 4, 2, arbitrationType), 2.)),
271  .25);
272  }
273  }
274  }
275  }
276  }
277 
278  // Thoughts:
279  // - should penalize if the segment has only x OR y info
280  // - should also use the segment direction, as it now works!
281 
282  } else { // track did not pass a chamber in this station - just reset weight
283  station_weight[i - 1] = 0.;
284  }
285 
286  //increment final weight for muon:
287  full_weight += station_weight[i - 1];
288  }
289 
290  // if we don't expect any matches, we set the compatibility to
291  // 0.5 as the track is as compatible with a muon as it is with
292  // background - we should maybe rather set it to -0.5!
293  if (nr_of_stations_crossed == 0) {
294  // full_weight = attenuate_weight_regain*0.5;
295  full_weight = 0.5;
296  }
297 
298  // ********************************************************;
299  // *** calculate weights for each station *****************;
300  // ************** end *************************************;
301 
302  return full_weight;
303 }

References mps_fire::i, and Max().

Referenced by ExampleMuonAnalyzer::analyze(), HiggsDQM::analyze(), StudyTriggerHLT::analyze(), MuonIdVal::analyze(), HcalHBHEMuonAnalyzer::analyze(), HcalHBHEMuonHighEtaAnalyzer::analyzeMuon(), MuonCosmicCompatibilityFiller::checkMuonSegments(), PFRecoTauDiscriminationAgainstMuon::discriminate(), BadParticleFilter::filter(), isMediumMuonCustom(), MuonIDTableProducer::isMediumMuonHIP(), pat::MuonSelector::muIdSelection_(), MuonSegmentCompatibilityCut::operator()(), and MuonSegmentCompatibilityCut::value().

◆ selectionTypeFromString()

SelectionType muon::selectionTypeFromString ( const std::string &  label)

Definition at line 9 of file MuonSelectors.cc.

9  {
10  SelectionType value = (SelectionType)-1;
11  bool found = false;
12  for (int i = 0; selectionTypeStringToEnumMap[i].label && (!found); ++i)
13  if (!strcmp(label.c_str(), selectionTypeStringToEnumMap[i].label)) {
14  found = true;
15  value = selectionTypeStringToEnumMap[i].value;
16  }
17 
18  // in case of unrecognized selection type
19  if (!found)
20  throw cms::Exception("MuonSelectorError") << label << " is not a recognized SelectionType";
21  return value;
22  }

References Exception, newFWLiteAna::found, mps_fire::i, label, muon::SelectionTypeStringToEnum::label, selectionTypeStringToEnumMap, relativeConstraints::value, and muon::SelectionTypeStringToEnum::value.

Referenced by MuonSelectionTypeValueMapProducer::MuonSelectionTypeValueMapProducer(), and MuonTrackProducer::produce().

◆ selectorFromString()

reco::Muon::Selector muon::selectorFromString ( const std::string &  label)

Definition at line 24 of file MuonSelectors.cc.

24  {
25  reco::Muon::Selector value = (reco::Muon::Selector)-1;
26  bool found = false;
27  for (int i = 0; selectorStringToEnumMap[i].label && (!found); ++i)
28  if (!strcmp(label.c_str(), selectorStringToEnumMap[i].label)) {
29  found = true;
30  value = selectorStringToEnumMap[i].value;
31  }
32 
33  // in case of unrecognized selection type
34  if (!found)
35  throw cms::Exception("MuonSelectorError") << label << " is not a recognized reco::Muon::Selector";
36  return value;
37  }

References Exception, newFWLiteAna::found, mps_fire::i, label, muon::SelectorStringToEnum::label, selectorStringToEnumMap, relativeConstraints::value, and muon::SelectorStringToEnum::value.

◆ sharedSegments()

int muon::sharedSegments ( const reco::Muon &  muon1,
const reco::Muon &  muon2,
unsigned int  segmentArbitrationMask = reco::MuonSegmentMatch::BestInChamberByDR 
)

Determine the number of shared segments between two muons. Comparison is done using the segment references in the reco::Muon object.

Definition at line 990 of file MuonSelectors.cc.

990  {
991  int ret = 0;
992 
993  // Will do with a stupid double loop, since creating and filling a map is probably _more_ inefficient for a single lookup.
994  for (std::vector<reco::MuonChamberMatch>::const_iterator chamberMatch = mu.matches().begin();
995  chamberMatch != mu.matches().end();
996  ++chamberMatch) {
997  if (chamberMatch->segmentMatches.empty())
998  continue;
999  for (std::vector<reco::MuonChamberMatch>::const_iterator chamberMatch2 = mu2.matches().begin();
1000  chamberMatch2 != mu2.matches().end();
1001  ++chamberMatch2) {
1002  if (chamberMatch2->segmentMatches.empty())
1003  continue;
1004  if (chamberMatch2->id() != chamberMatch->id())
1005  continue;
1006  for (std::vector<reco::MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
1007  segmentMatch != chamberMatch->segmentMatches.end();
1008  ++segmentMatch) {
1009  if (!segmentMatch->isMask(segmentArbitrationMask))
1010  continue;
1011  for (std::vector<reco::MuonSegmentMatch>::const_iterator segmentMatch2 = chamberMatch2->segmentMatches.begin();
1012  segmentMatch2 != chamberMatch2->segmentMatches.end();
1013  ++segmentMatch2) {
1014  if (!segmentMatch2->isMask(segmentArbitrationMask))
1015  continue;
1016  if ((segmentMatch->cscSegmentRef.isNonnull() &&
1017  segmentMatch->cscSegmentRef == segmentMatch2->cscSegmentRef) ||
1018  (segmentMatch->dtSegmentRef.isNonnull() && segmentMatch->dtSegmentRef == segmentMatch2->dtSegmentRef)) {
1019  ++ret;
1020  } // is the same
1021  } // segment of mu2 in chamber
1022  } // segment of mu1 in chamber
1023  } // chamber of mu2
1024  } // chamber of mu1
1025 
1026  return ret;
1027 }

References reco::Muon::matches(), amptDefaultParameters_cff::mu, and runTheMatrix::ret.

Referenced by heppy::CMGMuonCleanerBySegmentsAlgo::clean(), BadGlobalMuonTagger::filter(), and modules::MuonCleanerBySegmentsT< T >::produce().

◆ sigmaSwitch() [1/2]

reco::Muon::MuonTrackTypePair muon::sigmaSwitch ( const reco::Muon &  muon,
const double  nSigma = 2.,
const double  ptThreshold = 200. 
)
inline

Definition at line 57 of file MuonCocktails.h.

59  {
60  return muon::sigmaSwitch(muon.globalTrack(), muon.innerTrack(), nSigma, ptThreshold);
61  }

References HLTSiStripMonitoring_cff::nSigma, ewkMuLumiMonitorDQM_cfi::ptThreshold, and sigmaSwitch().

◆ sigmaSwitch() [2/2]

reco::Muon::MuonTrackTypePair muon::sigmaSwitch ( const reco::TrackRef &  combinedTrack,
const reco::TrackRef &  trackerTrack,
const double  nSigma = 2.,
const double  ptThreshold = 200. 
)

Definition at line 139 of file MuonCocktails.cc.

142  {
143  // If either the global or tracker-only fits have pT below threshold
144  // (default 200 GeV), return the tracker-only fit.
145  if (combinedTrack->pt() < ptThreshold || trackerTrack->pt() < ptThreshold)
146  return make_pair(trackerTrack, reco::Muon::InnerTrack);
147 
148  // If both are above the pT threshold, compare the difference in
149  // q/p: if less than two sigma of the tracker-only track, switch to
150  // global. Otherwise, use tracker-only.
151  const double delta = fabs(trackerTrack->qoverp() - combinedTrack->qoverp());
152  const double threshold = nSigma * trackerTrack->qoverpError();
153  return delta > threshold ? make_pair(trackerTrack, reco::Muon::InnerTrack)
154  : make_pair(combinedTrack, reco::Muon::CombinedTrack);
155 }

References reco::Muon::CombinedTrack, dumpMFGeometry_cfg::delta, reco::Muon::InnerTrack, HLTSiStripMonitoring_cff::nSigma, ewkMuLumiMonitorDQM_cfi::ptThreshold, and remoteMonitoring_LED_IterMethod_cfg::threshold.

Referenced by MuonIdProducer::makeMuon(), and sigmaSwitch().

◆ tevOptimized() [1/2]

reco::Muon::MuonTrackTypePair muon::tevOptimized ( const reco::Muon &  muon,
const double  ptThreshold = 200.,
const double  tune1 = 17.,
const double  tune2 = 40.,
const double  dptcut = 0.25 
)
inline

Definition at line 31 of file MuonCocktails.h.

35  {
36  return tevOptimized(muon.globalTrack(),
37  muon.innerTrack(),
38  muon.tpfmsTrack(),
39  muon.pickyTrack(),
40  muon.dytTrack(),
41  ptThreshold,
42  tune1,
43  tune2,
44  dptcut);
45  }

References ewkMuLumiMonitorDQM_cfi::ptThreshold, and tevOptimized().

◆ tevOptimized() [2/2]

reco::Muon::MuonTrackTypePair muon::tevOptimized ( const reco::TrackRef &  combinedTrack,
const reco::TrackRef &  trackerTrack,
const reco::TrackRef &  tpfmsTrack,
const reco::TrackRef &  pickyTrack,
const reco::TrackRef &  dytTrack,
const double  ptThreshold = 200.,
const double  tune1 = 17.,
const double  tune2 = 40.,
const double  dptcut = 0.25 
)

Definition at line 9 of file MuonCocktails.cc.

17  {
18  const unsigned int nAlgo = 5;
19 
20  // Array for convenience below.
21  const reco::Muon::MuonTrackTypePair refit[nAlgo] = {make_pair(trackerTrack, reco::Muon::InnerTrack),
22  make_pair(combinedTrack, reco::Muon::CombinedTrack),
23  make_pair(tpfmsTrack, reco::Muon::TPFMS),
24  make_pair(pickyTrack, reco::Muon::Picky),
25  make_pair(dytTrack, reco::Muon::DYT)};
26 
27  // Calculate the log(tail probabilities). If there's a problem,
28  // signify this with prob == 0. The current problems recognized are:
29  // the track being not available, whether the (re)fit failed or it's
30  // just not in the event, or if the (re)fit ended up with no valid
31  // hits.
32  double prob[nAlgo] = {0., 0., 0., 0., 0.};
33  bool valid[nAlgo] = {false, false, false, false, false};
34 
35  double dptmin = 1.;
36 
37  if (dptcut > 0) {
38  for (unsigned int i = 0; i < nAlgo; ++i)
39  if (refit[i].first.isNonnull())
40  if (refit[i].first->ptError() / refit[i].first->pt() < dptmin)
41  dptmin = refit[i].first->ptError() / refit[i].first->pt();
42 
43  if (dptmin > dptcut)
44  dptcut = dptmin + 0.15;
45  }
46 
47  for (unsigned int i = 0; i < nAlgo; ++i)
48  if (refit[i].first.isNonnull()) {
49  valid[i] = true;
50  if (refit[i].first->numberOfValidHits() &&
51  (refit[i].first->ptError() / refit[i].first->pt() < dptcut || dptcut < 0))
52  prob[i] = muon::trackProbability(refit[i].first);
53  }
54 
55  // Start with picky.
56  int chosen = 3;
57 
58  // If there's a problem with picky, make the default one of the
59  // other tracks. Try TPFMS first, then global, then tracker-only.
60  if (prob[3] == 0.) {
61  // split so that passing dptcut<0 recreates EXACTLY the old tuneP behavior
62  if (dptcut > 0) {
63  if (prob[4] > 0.)
64  chosen = 4;
65  else if (prob[0] > 0.)
66  chosen = 0;
67  else if (prob[2] > 0.)
68  chosen = 2;
69  else if (prob[1] > 0.)
70  chosen = 1;
71  } else {
72  if (prob[2] > 0.)
73  chosen = 2;
74  else if (prob[1] > 0.)
75  chosen = 1;
76  else if (prob[0] > 0.)
77  chosen = 0;
78  }
79  }
80 
81  // Now the algorithm: switch from picky to dyt if the difference is lower than a tuned value. Then
82  // switch from picky to tracker-only if the
83  // difference, log(tail prob(picky)) - log(tail prob(tracker-only))
84  // is greater than a tuned value. Then compare the
85  // so-picked track to TPFMS in the same manner using another tuned
86  // value.
87  if (prob[4] > 0. && prob[3] > 0.) {
88  if (refit[3].first->pt() > 0 && refit[4].first->pt() > 0 &&
89  (refit[4].first->ptError() / refit[4].first->pt() - refit[3].first->ptError() / refit[3].first->pt()) <= 0)
90  chosen = 4; // dyt
91  }
92 
93  if (prob[0] > 0. && prob[chosen] > 0. && (prob[chosen] - prob[0]) > tune1)
94  chosen = 0;
95  if (prob[2] > 0. && (prob[chosen] - prob[2]) > tune2)
96  chosen = 2;
97 
98  // Sanity checks
99  if (chosen == 4 && !valid[4])
100  chosen = 3;
101  if (chosen == 3 && !valid[3])
102  chosen = 2;
103  if (chosen == 2 && !valid[2])
104  chosen = 1;
105  if (chosen == 1 && !valid[1])
106  chosen = 0;
107 
108  // Done. If pT of the chosen track (or pT of the tracker track) is below the threshold value, return the tracker track.
109  if (valid[chosen] && refit[chosen].first->pt() < ptThreshold && prob[0] > 0.)
110  return make_pair(trackerTrack, reco::Muon::InnerTrack);
111  if (trackerTrack->pt() < ptThreshold && prob[0] > 0.)
112  return make_pair(trackerTrack, reco::Muon::InnerTrack);
113 
114  // Return the chosen track (which can be the global track in
115  // very rare cases).
116  return refit[chosen];
117 }

References reco::Muon::CombinedTrack, reco::Muon::DYT, dqmdumpme::first, mps_fire::i, reco::Muon::InnerTrack, reco::Muon::Picky, TtFullHadEvtBuilder_cfi::prob, ewkMuLumiMonitorDQM_cfi::ptThreshold, reco::Muon::TPFMS, trackProbability(), and validateGeometry_cfg::valid.

Referenced by MuonIdProducer::makeMuon(), MuonsFromRefitTracksProducer::produce(), PFMuonAlgo::reconstructMuon(), and tevOptimized().

◆ TMR()

reco::Muon::MuonTrackTypePair muon::TMR ( const reco::TrackRef &  trackerTrack,
const reco::TrackRef &  fmsTrack,
const double  tune = 4. 
)

Definition at line 160 of file MuonCocktails.cc.

162  {
163  double probTK = 0;
164  double probFMS = 0;
165 
166  if (trackerTrack.isNonnull() && trackerTrack->numberOfValidHits())
167  probTK = muon::trackProbability(trackerTrack);
168  if (fmsTrack.isNonnull() && fmsTrack->numberOfValidHits())
169  probFMS = muon::trackProbability(fmsTrack);
170 
171  bool TKok = probTK > 0;
172  bool FMSok = probFMS > 0;
173 
174  if (TKok && FMSok) {
175  if (probFMS - probTK > tune)
176  return make_pair(trackerTrack, reco::Muon::InnerTrack);
177  else
178  return make_pair(fmsTrack, reco::Muon::TPFMS);
179  } else if (FMSok)
180  return make_pair(fmsTrack, reco::Muon::TPFMS);
181  else if (TKok)
182  return make_pair(trackerTrack, reco::Muon::InnerTrack);
183  else
184  return make_pair(reco::TrackRef(), reco::Muon::None);
185 }

References reco::Muon::InnerTrack, edm::Ref< C, T, F >::isNonnull(), reco::Muon::None, reco::Muon::TPFMS, and trackProbability().

◆ trackProbability()

double muon::trackProbability ( const reco::TrackRef  track)

Definition at line 122 of file MuonCocktails.cc.

122  {
123  int nDOF = (int)track->ndof();
124  if (nDOF > 0 && track->chi2() > 0) {
125  return -log(TMath::Prob(track->chi2(), nDOF));
126  } else {
127  return 0.0;
128  }
129 }

References createfilelist::int, dqm-mbProfile::log, and HLT_2018_cff::track.

Referenced by HistogramProbabilityEstimator::probability(), tevOptimized(), tevOptimizedTMR(), and TMR().

Variable Documentation

◆ selectionTypeStringToEnumMap

const SelectionTypeStringToEnum muon::selectionTypeStringToEnumMap[]
static

Definition at line 67 of file MuonSelectors.h.

Referenced by selectionTypeFromString().

◆ selectorStringToEnumMap

const SelectorStringToEnum muon::selectorStringToEnumMap[]
static

Definition at line 108 of file MuonSelectors.h.

Referenced by selectorFromString().

ewkMuLumiMonitorDQM_cfi.ptThreshold
ptThreshold
Definition: ewkMuLumiMonitorDQM_cfi.py:13
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:355
MuonSubdetId::GEM
static constexpr int GEM
Definition: MuonSubdetId.h:14
reco::Muon::CombinedTrack
Definition: Muon.h:36
MuonSubdetId::CSC
static constexpr int CSC
Definition: MuonSubdetId.h:12
muon::TMOneStation
Definition: MuonSelectors.h:155
muon::SelectorStringToEnum::value
reco::Muon::Selector value
Definition: MuonSelectors.h:105
muon::GEMMu
Definition: MuonSelectors.h:155
mps_fire.i
i
Definition: mps_fire.py:355
reco::Muon::MuonTrackTypePair
std::pair< TrackRef, Muon::MuonTrackType > MuonTrackTypePair
Definition: Muon.h:38
muon::isSoftMuon
bool isSoftMuon(const reco::Muon &, const reco::Vertex &, bool run2016_hip_mitigation=false)
Definition: MuonSelectors.cc:931
reco::Muon::SegmentAndTrackArbitration
Definition: Muon.h:190
reco::Muon::CutBasedIdTrkHighPt
Definition: Muon.h:207
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
muon
Definition: MuonCocktails.h:17
fftjetvertexadder_cfi.errY
errY
Definition: fftjetvertexadder_cfi.py:38
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
muon::VeryLoose
Definition: ME0MuonSelector.h:15
amptDefaultParameters_cff.mu
mu
Definition: amptDefaultParameters_cff.py:16
reco::Muon::TPFMS
Definition: Muon.h:36
muon::TMLastStation
Definition: MuonSelectors.h:155
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
relativeConstraints.station
station
Definition: relativeConstraints.py:67
reco::Muon::Selector
Selector
Definition: Muon.h:201
reco::Muon::DYT
Definition: Muon.h:36
globals_cff.id1
id1
Definition: globals_cff.py:32
reco::Muon::matches
std::vector< MuonChamberMatch > & matches()
get muon matching information
Definition: Muon.h:145
reco::ME0Muon::localTrackCov
const AlgebraicSymMatrix55 & localTrackCov() const
Definition: ME0Muon.h:55
muon::GlobalMuonPromptTight
Definition: MuonSelectors.h:26
muon::TMLastStationTight
Definition: MuonSelectors.h:28
muon::TrackerMuonArbitrated
Definition: MuonSelectors.h:24
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
reco::Muon::TkIsoLoose
Definition: Muon.h:213
muon::isLooseTriggerMuon
bool isLooseTriggerMuon(const reco::Muon &)
Definition: MuonSelectors.cc:881
reco::Muon::CutBasedIdLoose
Definition: Muon.h:202
newFWLiteAna.found
found
Definition: newFWLiteAna.py:118
reco::Muon::TkIsoTight
Definition: Muon.h:214
muon::RPCMuLoose
Definition: MuonSelectors.h:53
dqmdumpme.first
first
Definition: dqmdumpme.py:55
Muon
Definition: Muon.py:1
validateGeometry_cfg.valid
valid
Definition: validateGeometry_cfg.py:21
muon::AllGEMMuons
Definition: MuonSelectors.h:56
muon::GMTkChiCompatibility
Definition: MuonSelectors.h:35
edm::Ref< TrackCollection >
muon::ME0Mu
Definition: MuonSelectors.h:155
reco::Muon::CutBasedIdMedium
Definition: Muon.h:203
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:664
muon::isLooseMuon
bool isLooseMuon(const reco::Muon &)
Definition: MuonSelectors.cc:910
muon::SelectionTypeStringToEnum::value
SelectionType value
Definition: MuonSelectors.h:64
muon::isTrackerHighPtMuon
bool isTrackerHighPtMuon(const reco::Muon &, const reco::Vertex &)
Definition: MuonSelectors.cc:975
reco::Muon::PFIsoLoose
Definition: Muon.h:209
muon::SelectionType
SelectionType
Selector type.
Definition: MuonSelectors.h:19
LocalError::xx
float xx() const
Definition: LocalError.h:22
muon::trackProbability
double trackProbability(const reco::TrackRef track)
Definition: MuonCocktails.cc:122
reco::Muon::PFIsoVeryLoose
Definition: Muon.h:208
muon::Tight
Definition: ME0MuonSelector.h:17
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
muon::caloCompatibility
float caloCompatibility(const reco::Muon &muon)
Definition: MuonSelectors.cc:58
muon::TMLastStationOptimizedLowPtLoose
Definition: MuonSelectors.h:33
muon::sigmaSwitch
reco::Muon::MuonTrackTypePair sigmaSwitch(const reco::TrackRef &combinedTrack, const reco::TrackRef &trackerTrack, const double nSigma=2., const double ptThreshold=200.)
Definition: MuonCocktails.cc:139
HLT_2018_cff.maxAbsPullY
maxAbsPullY
Definition: HLT_2018_cff.py:10226
Point3DBase< float, LocalTag >
ME0Segment::localDirection
LocalVector localDirection() const override
Local direction.
Definition: ME0Segment.h:50
reco::Muon::Picky
Definition: Muon.h:36
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20
badGlobalMuonTaggersAOD_cff.vtx
vtx
Definition: badGlobalMuonTaggersAOD_cff.py:5
muon::AllGlobalMuons
Definition: MuonSelectors.h:21
muon::isHighPtMuon
bool isHighPtMuon(const reco::Muon &, const reco::Vertex &)
Definition: MuonSelectors.cc:947
muon::GMTkKinkTight
Definition: MuonSelectors.h:37
muon::TMOneStationTight
Definition: MuonSelectors.h:32
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
PV3DBase::barePhi
T barePhi() const
Definition: PV3DBase.h:65
ME0Segment
Definition: ME0Segment.h:20
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
muon::isTightMuon
bool isTightMuon(const reco::Muon &, const reco::Vertex &)
Definition: MuonSelectors.cc:895
selectors
Definition: selectors.py:1
muon::tevOptimized
reco::Muon::MuonTrackTypePair tevOptimized(const reco::Muon &muon, const double ptThreshold=200., const double tune1=17., const double tune2=40., const double dptcut=0.25)
Definition: MuonCocktails.h:31
reco::Muon::TriggerIdLoose
Definition: Muon.h:224
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
muon::TMLastStationAngTight
Definition: MuonSelectors.h:39
dumpMFGeometry_cfg.delta
delta
Definition: dumpMFGeometry_cfg.py:25
reco::Muon::PFIsoVeryTight
Definition: Muon.h:212
muon::AllME0Muons
Definition: MuonSelectors.h:54
CSCDetId
Definition: CSCDetId.h:26
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
createfilelist.int
int
Definition: createfilelist.py:10
muon::Loose
Definition: ME0MuonSelector.h:16
value
Definition: value.py:1
muon::ME0MuonArbitrated
Definition: MuonSelectors.h:55
muons_cff.tkRelIso
tkRelIso
Definition: muons_cff.py:142
ME0Segment::localPositionError
LocalError localPositionError() const override
Definition: ME0Segment.cc:83
ME0Segment::localPosition
LocalPoint localPosition() const override
Definition: ME0Segment.h:47
Max
T Max(T a, T b)
Definition: MathUtil.h:44
MuonSubdetId::ME0
static constexpr int ME0
Definition: MuonSubdetId.h:15
reco::Muon::CutBasedIdMediumPrompt
Definition: Muon.h:204
muon::TMLastStationOptimizedBarrelLowPtLoose
Definition: MuonSelectors.h:50
muon::All
Definition: MuonSelectors.h:20
muon::isMediumMuon
bool isMediumMuon(const reco::Muon &, bool run2016_hip_mitigation=false)
Definition: MuonSelectors.cc:914
reco::Muon::InnerTrack
Definition: Muon.h:36
muon::TMOneStationLoose
Definition: MuonSelectors.h:31
muon::AllArbitrated
Definition: MuonSelectors.h:25
reco::Muon::PFIsoTight
Definition: Muon.h:211
muon::TMLastStationOptimizedBarrelLowPtTight
Definition: MuonSelectors.h:52
muon::TM2DCompatibilityTight
Definition: MuonSelectors.h:30
reco::Muon::CutBasedIdGlobalHighPt
Definition: Muon.h:206
muon::selectionTypeStringToEnumMap
static const SelectionTypeStringToEnum selectionTypeStringToEnumMap[]
Definition: MuonSelectors.h:67
type
type
Definition: HCALResponse.h:21
reco::Muon::PFIsoVeryVeryTight
Definition: Muon.h:226
heppy_batch.val
val
Definition: heppy_batch.py:351
muon::selectorStringToEnumMap
static const SelectorStringToEnum selectorStringToEnumMap[]
Definition: MuonSelectors.h:108
BadChargedCandidateFilter_cfi.segmentCompatibility
segmentCompatibility
Definition: BadChargedCandidateFilter_cfi.py:14
HLT_2018_cff.minNumberOfMatches
minNumberOfMatches
Definition: HLT_2018_cff.py:10328
gen::C
C
Definition: PomwigHadronizer.cc:76
outOfTimeMuon
bool outOfTimeMuon(const reco::Muon &muon)
Definition: MuonSelectors.cc:1029
reco::Muon::PFIsoMedium
Definition: Muon.h:210
relativeConstraints.value
value
Definition: relativeConstraints.py:53
muon::GEMMuonArbitrated
Definition: MuonSelectors.h:57
Exception
Definition: hltDiff.cc:246
reco::Muon::numberOfMatches
int numberOfMatches(ArbitrationType type=SegmentAndTrackArbitration) const
get number of chambers with matched segments
muon::TMLastStationLoose
Definition: MuonSelectors.h:27
reco::ME0Muon::me0segment
const ME0Segment & me0segment() const
Definition: ME0Muon.h:42
reco::Muon::SoftCutBasedId
Definition: Muon.h:215
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
muon::SelectorStringToEnum::label
const char * label
Definition: MuonSelectors.h:104
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
muon::SelectionTypeStringToEnum::label
const char * label
Definition: MuonSelectors.h:63
muon::TMLastStationOptimizedLowPtTight
Definition: MuonSelectors.h:34
hgcalTestNeighbor_cfi.detector
detector
Definition: hgcalTestNeighbor_cfi.py:6
muon::TM2DCompatibility
Definition: MuonSelectors.h:155
muon::TMLastStationAngLoose
Definition: MuonSelectors.h:38
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
muon::AllStandAloneMuons
Definition: MuonSelectors.h:22
reco::ME0Muon::localTrackMomAtSurface
const LocalVector & localTrackMomAtSurface() const
Definition: ME0Muon.h:51
muon::GMStaChiCompatibility
Definition: MuonSelectors.h:36
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
muon::TriggerIdLoose
Definition: MuonSelectors.h:58
genParticles_cff.map
map
Definition: genParticles_cff.py:11
HLT_2018_cff.maxAbsPullX
maxAbsPullX
Definition: HLT_2018_cff.py:10225
muon::TMOneStationAngTight
Definition: MuonSelectors.h:41
globals_cff.id2
id2
Definition: globals_cff.py:33
muon::RPCMu
Definition: MuonSelectors.h:155
muon::AllTrackerMuons
Definition: MuonSelectors.h:23
remoteMonitoring_LED_IterMethod_cfg.threshold
threshold
Definition: remoteMonitoring_LED_IterMethod_cfg.py:426
muon::RequiredStationMask
unsigned int RequiredStationMask(const reco::Muon &muon, double maxChamberDist, double maxChamberDistPull, reco::Muon::ArbitrationType arbitrationType)
Definition: MuonSelectors.cc:40
reco::Muon::None
Definition: Muon.h:36
AlgebraicSymMatrix55
ROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepSym< double, 5 > > AlgebraicSymMatrix55
Definition: AlgebraicROOTObjects.h:23
HLT_2018_cff.maxAbsDy
maxAbsDy
Definition: HLT_2018_cff.py:10306
edm::AssociationMap::const_iterator
const iterator
Definition: AssociationMap.h:76
fftjetvertexadder_cfi.errX
errX
Definition: fftjetvertexadder_cfi.py:37
muon::TMOneStationAngLoose
Definition: MuonSelectors.h:40
TtFullHadEvtBuilder_cfi.prob
prob
Definition: TtFullHadEvtBuilder_cfi.py:33
LocalError::yy
float yy() const
Definition: LocalError.h:24
HLTSiStripMonitoring_cff.nSigma
nSigma
Definition: HLTSiStripMonitoring_cff.py:151
HLT_2018_cff.maxAbsDx
maxAbsDx
Definition: HLT_2018_cff.py:10326
label
const char * label
Definition: PFTauDecayModeTools.cc:11
hgcalTopologyTester_cfi.layers
layers
Definition: hgcalTopologyTester_cfi.py:8
reco::Muon::CutBasedIdTight
Definition: Muon.h:205
reco::ME0Muon::localTrackPosAtSurface
const LocalPoint & localTrackPosAtSurface() const
Definition: ME0Muon.h:50
muon::TM2DCompatibilityLoose
Definition: MuonSelectors.h:29
reco::Muon::InTimeMuon
Definition: Muon.h:225
reco::TrackBase::highPurity
Definition: TrackBase.h:154
Generated for CMSSW Reference Manual by doxygen 1.8.16