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

Classes

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

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, SelectionType type)
 main GoodMuon wrapper call More...
 
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::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
 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 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 &)
 
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)
 
void setCutBasedSelectorFlags (reco::Muon &muon, const reco::Vertex *vertex=0, bool run2016_hip_mitigation=false)
 
int sharedSegments (const reco::Muon &muon1, const reco::Muon &muon2, unsigned int segmentArbitrationMask=reco::MuonSegmentMatch::BestInChamberByDR)
 
reco::Muon::MuonTrackTypePair sigmaSwitch (const reco::TrackRef &combinedTrack, const reco::TrackRef &trackerTrack, const double nSigma=2., const double ptThreshold=200.)
 
reco::Muon::MuonTrackTypePair sigmaSwitch (const reco::Muon &muon, const double nSigma=2., const double ptThreshold=200.)
 
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 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 TMR (const reco::TrackRef &trackerTrack, const reco::TrackRef &fmsTrack, const double tune=4.)
 
double trackProbability (const reco::TrackRef track)
 

Detailed Description

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

Enumeration Type Documentation

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

Definition at line 68 of file MuonSelectors.h.

68 { TMLastStation, TM2DCompatibility, TMOneStation, RPCMu, ME0Mu, GEMMu };
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 16 of file ME0MuonSelector.h.

16  {
17  All = 0, // dummy options - always true
18  VeryLoose = 1, //
19  Loose = 2, //
20  Tight = 3, //
21  };
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 17 of file MuonSelectors.h.

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

Function Documentation

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

Definition at line 76 of file MuonSelectors.cc.

References reco::Muon::caloCompatibility().

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

76  {
77  return muon.caloCompatibility();
78 }
reco::Muon::caloCompatibility
float caloCompatibility() const
Definition: Muon.h:154
reco::TrackRef muon::getTevRefitTrack ( const reco::TrackRef &  combinedTrack,
const reco::TrackToTrackMap &  map 
)

Definition at line 121 of file MuonCocktails.cc.

References edm::AssociationMap< edm::OneToOne< reco::TrackCollection, reco::TrackCollection > >::const_iterator, edm::AssociationMap< Tag >::end(), and edm::AssociationMap< Tag >::find().

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

122  {
123  reco::TrackToTrackMap::const_iterator it = map.find(combinedTrack);
124  return it == map.end() ? reco::TrackRef() : it->val;
125 }
edm::AssociationMap::end
const_iterator end() const
last iterator over the map (read only)
Definition: AssociationMap.h:160
edm::AssociationMap::find
const_iterator find(const key_type &k) const
find element with specified reference key
Definition: AssociationMap.h:162
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:21
heppy_batch.val
val
Definition: heppy_batch.py:349
bool muon::isGoodMuon ( const reco::ME0Muon &  me0muon,
SelectionType  type 
)

main GoodMuon wrapper call

Definition at line 41 of file ME0MuonSelector.cc.

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

42 {
43  switch (type)
44  {
45  case muon::All:
46  return true;
47  break;
48  case muon::VeryLoose:
49  return isGoodMuon(me0muon,3,4,20,20,3.14);
50  break;
51  case muon::Loose:
52  return isGoodMuon(me0muon,3,2,3,2,0.5);
53  break;
54  case muon::Tight:
55  return isGoodMuon(me0muon,3,2,3,2,0.15);
56  break;
57  default:
58  return false;
59  }
60 }
type
type
Definition: HCALResponse.h:21
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:648
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 65 of file ME0MuonSelector.cc.

References funct::abs(), PV3DBase< T, PVType, FrameType >::barePhi(), patCaloMETCorrections_cff::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().

66 {
67  using namespace reco;
68 
69  const ME0Segment& thisSegment = me0muon.me0segment();
70 
71 
72  const LocalPoint& r3FinalReco = me0muon.localTrackPosAtSurface();
73 
74  AlgebraicSymMatrix55 C = me0muon.localTrackCov();
75  LocalPoint thisPosition(thisSegment.localPosition());
76 
77 
78  double sigmax = sqrt(C[3][3]+thisSegment.localPositionError().xx() );
79  double sigmay = sqrt(C[4][4]+thisSegment.localPositionError().yy() );
80 
81  bool X_MatchFound = false, Y_MatchFound = false, Dir_MatchFound = false;
82 
83 
84  if ( ( (std::abs(thisPosition.x()-r3FinalReco.x())/sigmax ) < MaxPullX ) || (std::abs(thisPosition.x()-r3FinalReco.x()) < MaxDiffX ) ) X_MatchFound = true;
85  if ( ( (std::abs(thisPosition.y()-r3FinalReco.y())/sigmay ) < MaxPullY ) || (std::abs(thisPosition.y()-r3FinalReco.y()) < MaxDiffY ) ) Y_MatchFound = true;
86  if ( std::abs(reco::deltaPhi(me0muon.localTrackMomAtSurface().barePhi(),thisSegment.localDirection().barePhi())) < MaxDiffPhiDir) Dir_MatchFound = true;
87 
88  return (X_MatchFound && Y_MatchFound && Dir_MatchFound);
89 
90 }
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:22
LocalError::xx
float xx() const
Definition: LocalError.h:24
reco::ME0Muon::localTrackPosAtSurface
const LocalPoint & localTrackPosAtSurface() const
Definition: ME0Muon.h:46
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
AlgebraicSymMatrix55
ROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepSym< double, 5 > > AlgebraicSymMatrix55
Definition: AlgebraicROOTObjects.h:23
reco::ME0Muon::me0segment
const ME0Segment & me0segment() const
Definition: ME0Muon.h:37
PV3DBase::barePhi
T barePhi() const
Definition: PV3DBase.h:68
LocalError::yy
float yy() const
Definition: LocalError.h:26
patCaloMETCorrections_cff.C
C
Definition: patCaloMETCorrections_cff.py:45
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
reco::ME0Muon::localTrackCov
const AlgebraicSymMatrix55 & localTrackCov() const
Definition: ME0Muon.h:51
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
ME0Segment::localDirection
LocalVector localDirection() const override
Local direction.
Definition: ME0Segment.h:43
ME0Segment::localPosition
LocalPoint localPosition() const override
Definition: ME0Segment.h:40
reco::ME0Muon::localTrackMomAtSurface
const LocalVector & localTrackMomAtSurface() const
Definition: ME0Muon.h:47
ME0Segment::localPositionError
LocalError localPositionError() const override
Definition: ME0Segment.cc:63
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:43
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
bool muon::isGoodMuon ( const reco::Muon &  muon,
SelectionType  type,
reco::Muon::ArbitrationType  arbitrationType = reco::Muon::SegmentAndTrackArbitration 
)

main GoodMuon wrapper call

Definition at line 648 of file MuonSelectors.cc.

References All, AllArbitrated, AllGEMMuons, AllGlobalMuons, AllME0Muons, AllStandAloneMuons, AllTrackerMuons, reco::Muon::combinedQuality(), reco::LeafCandidate::eta(), GEMMu, GEMMuonArbitrated, GlobalMuonPromptTight, reco::Muon::globalTrack(), GMStaChiCompatibility, GMTkChiCompatibility, GMTkKinkTight, reco::Muon::innerTrack(), reco::Muon::isGEMMuon(), reco::Muon::isGlobalMuon(), isLooseTriggerMuon(), reco::Muon::isME0Muon(), reco::Muon::isQualityValid(), reco::Muon::isRPCMuon(), reco::Muon::isStandAloneMuon(), reco::Muon::isTrackerMuon(), ME0Mu, ME0MuonArbitrated, reco::Muon::numberOfMatches(), reco::Muon::outerTrack(), reco::LeafCandidate::pt(), RPCMu, RPCMuLoose, reco::MuonQuality::staRelChi2, TM2DCompatibility, TM2DCompatibilityLoose, TM2DCompatibilityTight, TMLastStation, TMLastStationAngLoose, TMLastStationAngTight, TMLastStationLoose, TMLastStationOptimizedBarrelLowPtLoose, TMLastStationOptimizedBarrelLowPtTight, TMLastStationOptimizedLowPtLoose, TMLastStationOptimizedLowPtTight, TMLastStationTight, TMOneStation, TMOneStationAngLoose, TMOneStationAngTight, TMOneStationLoose, TMOneStationTight, TrackerMuonArbitrated, TriggerIdLoose, reco::MuonQuality::trkKink, and reco::MuonQuality::trkRelChi2.

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()(), reco::operator<<(), MuonBadTrackFilter::printMuonProperties(), PFMuonAlgo::printMuonProperties(), MuonTrackProducer::produce(), MuonIDFilterProducerForHLT::produce(), MuonRefProducer::produce(), MuonSelectionTypeValueMapProducer::produce(), ME0MuonTrackCollProducer::produce(), SoftLepton::produce(), and MuonSelectorVIDWrapper< selectionType, arbitrationType >::value().

650 {
651  switch (type)
652  {
653  case muon::All:
654  return true;
655  break;
656  case muon::AllGlobalMuons:
657  return muon.isGlobalMuon();
658  break;
659  case muon::AllTrackerMuons:
660  return muon.isTrackerMuon();
661  break;
662  case muon::AllStandAloneMuons:
663  return muon.isStandAloneMuon();
664  break;
665  case muon::TrackerMuonArbitrated:
666  return muon.isTrackerMuon() && muon.numberOfMatches(arbitrationType)>0;
667  break;
668  case muon::AllArbitrated:
669  return ! muon.isTrackerMuon() || muon.numberOfMatches(arbitrationType)>0;
670  break;
671  case muon::GlobalMuonPromptTight:
672  return muon.isGlobalMuon() && muon.globalTrack()->normalizedChi2()<10. && muon.globalTrack()->hitPattern().numberOfValidMuonHits() >0;
673  break;
674  // For "Loose" algorithms we choose maximum y quantity cuts of 1E9 instead of
675  // 9999 as before. We do this because the muon methods return 999999 (note
676  // there are six 9's) when the requested information is not available. For
677  // example, if a muon fails to traverse the z measuring superlayer in a station
678  // in the DT, then all methods involving segmentY in this station return
679  // 999999 to demonstrate that the information is missing. In order to not
680  // penalize muons for missing y information in Loose algorithms where we do
681  // not care at all about y information, we raise these limits. In the
682  // TMLastStation and TMOneStation algorithms we actually use this huge number
683  // to determine whether to consider y information at all.
684  case muon::TMLastStationLoose:
685  return muon.isTrackerMuon() && isGoodMuon(muon,TMLastStation,2,3,3,1E9,1E9,-3,-3,arbitrationType,true,false);
686  break;
687  case muon::TMLastStationTight:
688  return muon.isTrackerMuon() && isGoodMuon(muon,TMLastStation,2,3,3,3,3,-3,-3,arbitrationType,true,false);
689  break;
690  case muon::TMOneStationLoose:
691  return muon.isTrackerMuon() && isGoodMuon(muon,TMOneStation,1,3,3,1E9,1E9,1E9,1E9,arbitrationType,false,false);
692  break;
693  case muon::TMOneStationTight:
694  return muon.isTrackerMuon() && isGoodMuon(muon,TMOneStation,1,3,3,3,3,1E9,1E9,arbitrationType,false,false);
695  break;
696  case muon::TMLastStationOptimizedLowPtLoose:
697  if (muon.pt() < 8. && fabs(muon.eta()) < 1.2)
698  return muon.isTrackerMuon() && isGoodMuon(muon,TMOneStation,1,3,3,1E9,1E9,1E9,1E9,arbitrationType,false,false);
699  else
700  return muon.isTrackerMuon() && isGoodMuon(muon,TMLastStation,2,3,3,1E9,1E9,-3,-3,arbitrationType,false,false);
701  break;
702  case muon::TMLastStationOptimizedLowPtTight:
703  if (muon.pt() < 8. && fabs(muon.eta()) < 1.2)
704  return muon.isTrackerMuon() && isGoodMuon(muon,TMOneStation,1,3,3,3,3,1E9,1E9,arbitrationType,false,false);
705  else
706  return muon.isTrackerMuon() && isGoodMuon(muon,TMLastStation,2,3,3,3,3,-3,-3,arbitrationType,false,false);
707  break;
708  //compatibility loose
709  case muon::TM2DCompatibilityLoose:
710  return muon.isTrackerMuon() && isGoodMuon(muon,TM2DCompatibility,0.7,arbitrationType);
711  break;
712  //compatibility tight
713  case muon::TM2DCompatibilityTight:
714  return muon.isTrackerMuon() && isGoodMuon(muon,TM2DCompatibility,1.0,arbitrationType);
715  break;
716  case muon::GMTkChiCompatibility:
717  return muon.isGlobalMuon() && muon.isQualityValid() && fabs(muon.combinedQuality().trkRelChi2 - muon.innerTrack()->normalizedChi2()) < 2.0;
718  break;
719  case muon::GMStaChiCompatibility:
720  return muon.isGlobalMuon() && muon.isQualityValid() && fabs(muon.combinedQuality().staRelChi2 - muon.outerTrack()->normalizedChi2()) < 2.0;
721  break;
722  case muon::GMTkKinkTight:
723  return muon.isGlobalMuon() && muon.isQualityValid() && muon.combinedQuality().trkKink < 100.0;
724  break;
725  case muon::TMLastStationAngLoose:
726  return muon.isTrackerMuon() && isGoodMuon(muon,TMLastStation,2,3,3,1E9,1E9,-3,-3,arbitrationType,false,true);
727  break;
728  case muon::TMLastStationAngTight:
729  return muon.isTrackerMuon() && isGoodMuon(muon,TMLastStation,2,3,3,3,3,-3,-3,arbitrationType,false,true);
730  break;
731  case muon::TMOneStationAngLoose:
732  return muon.isTrackerMuon() && isGoodMuon(muon,TMOneStation,1,3,3,1E9,1E9,1E9,1E9,arbitrationType,false,true);
733  break;
734  case muon::TMOneStationAngTight:
735  return muon.isTrackerMuon() && isGoodMuon(muon,TMOneStation,1,3,3,3,3,1E9,1E9,arbitrationType,false,true);
736  break;
737  case muon::TMLastStationOptimizedBarrelLowPtLoose:
738  if (muon.pt() < 8. && fabs(muon.eta()) < 1.2)
739  return muon.isTrackerMuon() && isGoodMuon(muon,TMOneStation,1,3,3,1E9,1E9,1E9,1E9,arbitrationType,false,false);
740  else
741  return muon.isTrackerMuon() && isGoodMuon(muon,TMLastStation,2,3,3,1E9,1E9,-3,-3,arbitrationType,true,false);
742  break;
743  case muon::TMLastStationOptimizedBarrelLowPtTight:
744  if (muon.pt() < 8. && fabs(muon.eta()) < 1.2)
745  return muon.isTrackerMuon() && isGoodMuon(muon,TMOneStation,1,3,3,3,3,1E9,1E9,arbitrationType,false,false);
746  else
747  return muon.isTrackerMuon() && isGoodMuon(muon,TMLastStation,2,3,3,3,3,-3,-3,arbitrationType,true,false);
748  break;
749  case muon::RPCMuLoose:
750  return muon.isRPCMuon() && isGoodMuon(muon, RPCMu, 2, 20, 4, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
751  break;
752  case muon::AllME0Muons:
753  return muon.isME0Muon();
754  break;
755  case muon::ME0MuonArbitrated:
756  return muon.isME0Muon() && isGoodMuon(muon, ME0Mu, 1, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
757  break;
758  case muon::AllGEMMuons:
759  return muon.isGEMMuon();
760  break;
761  case muon::GEMMuonArbitrated:
762  return muon.isGEMMuon() && isGoodMuon(muon, GEMMu, 1, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
763  break;
764  case muon::TriggerIdLoose:
765  return isLooseTriggerMuon(muon);
766  break;
767  default:
768  return false;
769  }
770 }
type
type
Definition: HCALResponse.h:21
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:137
reco::Muon::isStandAloneMuon
bool isStandAloneMuon() const override
Definition: Muon.h:278
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
reco::MuonQuality::trkKink
float trkKink
value of the kink algorithm applied to the inner track stub
Definition: MuonQuality.h:11
reco::MuonQuality::trkRelChi2
float trkRelChi2
chi2 value for the inner track stub with respect to the global track
Definition: MuonQuality.h:15
reco::Muon::isME0Muon
bool isME0Muon() const
Definition: Muon.h:283
reco::Muon::isTrackerMuon
bool isTrackerMuon() const override
Definition: Muon.h:277
reco::Muon::numberOfMatches
int numberOfMatches(unsigned int type=SegmentAndTrackArbitration) const
get number of chambers with matched segments
reco::Muon::isRPCMuon
bool isRPCMuon() const
Definition: Muon.h:281
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:276
reco::Muon::combinedQuality
MuonQuality combinedQuality() const
get energy deposition information
Definition: Muon.h:121
reco::Muon::isQualityValid
bool isQualityValid() const
Definition: Muon.h:119
reco::Muon::outerTrack
virtual TrackRef outerTrack() const
reference to Track reconstructed in the muon detector only
Definition: Muon.h:51
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:648
reco::MuonQuality::staRelChi2
float staRelChi2
chi2 value for the outer track stub with respect to the global track
Definition: MuonQuality.h:17
reco::Muon::isGEMMuon
bool isGEMMuon() const
Definition: Muon.h:282
muon::isLooseTriggerMuon
bool isLooseTriggerMuon(const reco::Muon &)
Definition: MuonSelectors.cc:841
reco::Muon::globalTrack
virtual TrackRef globalTrack() const
reference to Track reconstructed in both tracked and muon detector
Definition: Muon.h:54
bool muon::isGoodMuon ( const reco::Muon &  muon,
AlgorithmType  type,
double  minCompatibility,
reco::Muon::ArbitrationType  arbitrationType 
)

Definition at line 294 of file MuonSelectors.cc.

References caloCompatibility(), reco::Muon::isMatchesValid(), segmentCompatibility(), and TM2DCompatibility.

297  {
298  if (!muon.isMatchesValid()) return false;
299  bool goodMuon = false;
300 
301  switch( type ) {
302  case TM2DCompatibility:
303  // Simplistic first cut in the 2D segment- vs calo-compatibility plane. Will have to be refined!
304  if( ( (0.8*caloCompatibility( muon ))+(1.2*segmentCompatibility( muon, arbitrationType )) ) > minCompatibility ) goodMuon = true;
305  else goodMuon = false;
306  return goodMuon;
307  break;
308  default :
309  // LogTrace("MuonIdentification")<<" // Invalid Algorithm Type called!";
310  goodMuon = false;
311  return goodMuon;
312  break;
313  }
314 }
type
type
Definition: HCALResponse.h:21
reco::Muon::isMatchesValid
bool isMatchesValid() const
Definition: Muon.h:142
muon::caloCompatibility
float caloCompatibility(const reco::Muon &muon)
Definition: MuonSelectors.cc:76
BadChargedCandidateFilter_cfi.segmentCompatibility
segmentCompatibility
Definition: BadChargedCandidateFilter_cfi.py:14
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 316 of file MuonSelectors.cc.

References gamEcalExtractorBlocks_cff::detector, reco::Muon::dX(), reco::Muon::dY(), fftjetvertexadder_cfi::errX, fftjetvertexadder_cfi::errY, reco::LeafCandidate::eta(), MuonSubdetId::GEM, GEMMu, reco::Muon::isMatchesValid(), reco::Muon::matches(), MuonSubdetId::ME0, ME0Mu, or, reco::Muon::pullDxDz(), reco::Muon::pullDyDz(), reco::Muon::pullX(), reco::Muon::pullY(), RequiredStationMask(), RPCMu, mathSSE::sqrt(), relativeConstraints::station, reco::Muon::stationMask(), TMLastStation, and TMOneStation.

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

Definition at line 910 of file MuonSelectors.cc.

References reco::Muon::globalTrack(), hfClusterShapes_cfi::hits, reco::Muon::innerTrack(), reco::Muon::isGlobalMuon(), reco::Muon::numberOfMatchedStations(), reco::Vertex::position(), and reco::Muon::tunePMuonBestTrack().

Referenced by MuonKinVsEtaAnalyzer::analyze(), pat::Muon::isGood(), MuonPOGStandardCut::operator()(), reco::operator<<(), MuonMiniAOD::PassesCut_A(), MuonMiniAOD::PassesCut_B(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), setCutBasedSelectorFlags(), and MuonPOGStandardCut::value().

910  {
911  bool muID = muon.isGlobalMuon() && muon.globalTrack()->hitPattern().numberOfValidMuonHits() >0 && (muon.numberOfMatchedStations() > 1);
912  if(!muID) return false;
913 
914  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
915  muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
916 
917  bool momQuality = muon.tunePMuonBestTrack()->ptError()/muon.tunePMuonBestTrack()->pt() < 0.3;
918 
919  bool ip = fabs(muon.innerTrack()->dxy(vtx.position())) < 0.2 && fabs(muon.innerTrack()->dz(vtx.position())) < 0.5;
920 
921  return muID && hits && momQuality && ip;
922 
923 }
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:109
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:276
reco::Muon::numberOfMatchedStations
int numberOfMatchedStations(ArbitrationType type=SegmentAndTrackArbitration) const
reco::Muon::tunePMuonBestTrack
virtual TrackRef tunePMuonBestTrack() const
Definition: Muon.h:65
reco::Muon::globalTrack
virtual TrackRef globalTrack() const
reference to Track reconstructed in both tracked and muon detector
Definition: Muon.h:54
bool muon::isLooseMuon ( const reco::Muon &  muon)

Definition at line 870 of file MuonSelectors.cc.

References reco::Muon::isGlobalMuon(), reco::Muon::isPFMuon(), and reco::Muon::isTrackerMuon().

Referenced by DiMuonHistograms::analyze(), MuonKinVsEtaAnalyzer::analyze(), EfficiencyAnalyzer::analyze(), L1TTauOffline::getTightMuons(), pat::Muon::isGood(), PFMuonAlgo::isLooseMuon(), isMediumMuon(), MuonIDTableProducer::isMediumMuonHIP(), MuonPOGStandardCut::operator()(), reco::operator<<(), MuonMiniAOD::PassesCut_A(), MuonMiniAOD::PassesCut_B(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), SoftPFMuonTagInfoProducer::produce(), PFMuonAlgo::reconstructMuon(), setCutBasedSelectorFlags(), and MuonPOGStandardCut::value().

870  {
871  return muon.isPFMuon() && ( muon.isGlobalMuon() || muon.isTrackerMuon());
872 }
reco::Muon::isTrackerMuon
bool isTrackerMuon() const override
Definition: Muon.h:277
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:276
reco::Muon::isPFMuon
bool isPFMuon() const
Definition: Muon.h:280
bool muon::isLooseTriggerMuon ( const reco::Muon &  muon)

Definition at line 841 of file MuonSelectors.cc.

References reco::Muon::expectedNnumberOfMatchedStations(), reco::Muon::innerTrack(), isGoodMuon(), reco::Muon::numberOfMatchedStations(), or, reco::LeafCandidate::pt(), and TMOneStationTight.

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

841  {
842  // Requirements:
843  // - no depencence on information not availabe in the muon object
844  // - use only robust inputs
845  bool tk_id = muon::isGoodMuon(muon, TMOneStationTight);
846  if ( not tk_id ) return false;
847  bool layer_requirements = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
848  muon.innerTrack()->hitPattern().pixelLayersWithMeasurement() > 0;
849  bool match_requirements = (muon.expectedNnumberOfMatchedStations()<2) or (muon.numberOfMatchedStations()>1) or (muon.pt()<8);
850  return layer_requirements and match_requirements;
851 }
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
reco::Muon::expectedNnumberOfMatchedStations
unsigned int expectedNnumberOfMatchedStations(float minDistanceFromEdge=10.0) const
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::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:648
reco::Muon::numberOfMatchedStations
int numberOfMatchedStations(ArbitrationType type=SegmentAndTrackArbitration) const
bool muon::isMediumMuon ( const reco::Muon &  muon,
bool  run2016_hip_mitigation = false 
)

Definition at line 875 of file MuonSelectors.cc.

References reco::MuonQuality::chi2LocalPosition, reco::Muon::combinedQuality(), reco::Muon::globalTrack(), reco::Muon::innerTrack(), reco::Muon::isGlobalMuon(), isLooseMuon(), segmentCompatibility(), and reco::MuonQuality::trkKink.

Referenced by DiMuonHistograms::analyze(), MuonKinVsEtaAnalyzer::analyze(), EfficiencyAnalyzer::analyze(), HcalHBHEMuonAnalyzer::analyze(), pat::Muon::isGood(), MuonPOGStandardCut::operator()(), reco::operator<<(), MuonMiniAOD::PassesCut_A(), MuonMiniAOD::PassesCut_B(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), setCutBasedSelectorFlags(), BadGlobalMuonTagger::tighterId(), and MuonPOGStandardCut::value().

875  {
876  if( not isLooseMuon(muon) ) return false;
877  if (run2016_hip_mitigation){
878  if (muon.innerTrack()->validFraction() < 0.49 ) return false;
879  } else {
880  if (muon.innerTrack()->validFraction() < 0.8 ) return false;
881  }
882 
883  bool goodGlb = muon.isGlobalMuon() &&
884  muon.globalTrack()->normalizedChi2() < 3. &&
885  muon.combinedQuality().chi2LocalPosition < 12. &&
886  muon.combinedQuality().trkKink < 20.;
887 
888  return (segmentCompatibility(muon) > (goodGlb ? 0.303 : 0.451));
889 }
reco::MuonQuality::chi2LocalPosition
float chi2LocalPosition
chi2 value for the STA-TK matching of local position
Definition: MuonQuality.h:19
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
reco::MuonQuality::trkKink
float trkKink
value of the kink algorithm applied to the inner track stub
Definition: MuonQuality.h:11
muon::isLooseMuon
bool isLooseMuon(const reco::Muon &)
Definition: MuonSelectors.cc:870
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:276
reco::Muon::combinedQuality
MuonQuality combinedQuality() const
get energy deposition information
Definition: Muon.h:121
BadChargedCandidateFilter_cfi.segmentCompatibility
segmentCompatibility
Definition: BadChargedCandidateFilter_cfi.py:14
reco::Muon::globalTrack
virtual TrackRef globalTrack() const
reference to Track reconstructed in both tracked and muon detector
Definition: Muon.h:54
bool muon::isSoftMuon ( const reco::Muon &  muon,
const reco::Vertex &  vtx,
bool  run2016_hip_mitigation = false 
)

Definition at line 891 of file MuonSelectors.cc.

References reco::TrackBase::highPurity, reco::Muon::innerTrack(), isGoodMuon(), LayerTriplets::layers(), reco::Vertex::position(), and TMOneStationTight.

Referenced by DiMuonHistograms::analyze(), MuonKinVsEtaAnalyzer::analyze(), LeptonSkimming::filter(), pat::Muon::isGood(), MuonPOGStandardCut::operator()(), reco::operator<<(), MuonMiniAOD::PassesCut_A(), MuonMiniAOD::PassesCut_B(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), setCutBasedSelectorFlags(), and MuonPOGStandardCut::value().

892  {
893 
894  bool muID = muon::isGoodMuon(muon, TMOneStationTight);
895 
896  if(!muID) return false;
897 
898  bool layers = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
899  muon.innerTrack()->hitPattern().pixelLayersWithMeasurement() > 0;
900 
901  bool ishighq = muon.innerTrack()->quality(reco::Track::highPurity);
902 
903  bool ip = fabs(muon.innerTrack()->dxy(vtx.position())) < 0.3 && fabs(muon.innerTrack()->dz(vtx.position())) < 20.;
904 
905  return layers && ip && (ishighq|run2016_hip_mitigation);
906 }
LayerTriplets::layers
std::vector< LayerSetAndLayers > layers(const SeedingLayerSetsHits &sets)
Definition: LayerTriplets.cc:4
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:109
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:648
bool muon::isTightMuon ( const reco::Muon &  muon,
const reco::Vertex &  vtx 
)

Definition at line 853 of file MuonSelectors.cc.

References GlobalMuonPromptTight, hfClusterShapes_cfi::hits, reco::Muon::innerTrack(), reco::Muon::isGlobalMuon(), isGoodMuon(), reco::Muon::isPFMuon(), reco::Muon::muonBestTrack(), reco::Muon::numberOfMatchedStations(), and reco::Vertex::position().

Referenced by DiMuonHistograms::analyze(), RecoMuonValidator::analyze(), MuonKinVsEtaAnalyzer::analyze(), EfficiencyAnalyzer::analyze(), MuonPFAnalyzer::analyze(), MuonRecoOneHLT::analyze(), METplusTrackMonitor::analyze(), HcalHBHEMuonAnalyzer::analyze(), L1TMuonDQMOffline::getTightMuons(), pat::Muon::isGood(), MuonPOGStandardCut::operator()(), reco::operator<<(), MuonMiniAOD::PassesCut_A(), MuonMiniAOD::PassesCut_B(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), setCutBasedSelectorFlags(), and MuonPOGStandardCut::value().

853  {
854 
855  if(!muon.isPFMuon() || !muon.isGlobalMuon() ) return false;
856 
857  bool muID = isGoodMuon(muon,GlobalMuonPromptTight) && (muon.numberOfMatchedStations() > 1);
858 
859 
860  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
861  muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
862 
863 
864  bool ip = fabs(muon.muonBestTrack()->dxy(vtx.position())) < 0.2 && fabs(muon.muonBestTrack()->dz(vtx.position())) < 0.5;
865 
866  return muID && hits && ip;
867 }
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:109
reco::Muon::muonBestTrack
virtual TrackRef muonBestTrack() const
Definition: Muon.h:63
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:276
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:648
reco::Muon::numberOfMatchedStations
int numberOfMatchedStations(ArbitrationType type=SegmentAndTrackArbitration) const
reco::Muon::isPFMuon
bool isPFMuon() const
Definition: Muon.h:280
bool muon::isTrackerHighPtMuon ( const reco::Muon &  muon,
const reco::Vertex &  vtx 
)

Definition at line 925 of file MuonSelectors.cc.

References hfClusterShapes_cfi::hits, reco::Muon::innerTrack(), edm::Ref< C, T, F >::isNonnull(), reco::Muon::isTrackerMuon(), reco::Muon::numberOfMatchedStations(), reco::Vertex::position(), reco::Muon::track(), and reco::Muon::tunePMuonBestTrack().

Referenced by setCutBasedSelectorFlags().

925  {
926  bool muID = muon.isTrackerMuon() && muon.track().isNonnull() && (muon.numberOfMatchedStations() > 1);
927  if(!muID) return false;
928 
929  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
930  muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
931 
932  bool momQuality = muon.tunePMuonBestTrack()->ptError()/muon.tunePMuonBestTrack()->pt() < 0.3;
933 
934  bool ip = fabs(muon.innerTrack()->dxy(vtx.position())) < 0.2 && fabs(muon.innerTrack()->dz(vtx.position())) < 0.5;
935 
936  return muID && hits && momQuality && ip;
937 
938 }
reco::Muon::track
TrackRef track() const override
reference to a Track
Definition: Muon.h:49
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:253
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:109
reco::Muon::isTrackerMuon
bool isTrackerMuon() const override
Definition: Muon.h:277
reco::Muon::numberOfMatchedStations
int numberOfMatchedStations(ArbitrationType type=SegmentAndTrackArbitration) const
reco::Muon::tunePMuonBestTrack
virtual TrackRef tunePMuonBestTrack() const
Definition: Muon.h:65
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 772 of file MuonSelectors.cc.

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

Referenced by TECLayer::addClosest(), MuonTiming::analyze(), TOBRod::computeWindowSize(), Phase2OTBarrelRod::computeWindowSize(), CSCCFEBData::digis(), HcalQIEShape::expand(), HLTOfflineDQMTopDiLepton::MonitorDiLepton::fill(), TopDiLeptonOffline::MonitorEnsemble::fill(), reco::GenParticle::isLastCopyBeforeFSR(), main(), IsolationProducerForTracks::produce(), MatchedProbeMaker< T >::produce(), HLTJetsCleanedFromLeadingLeptons< JetType >::produce(), TECLayer::searchNeighbors(), TOBRod::searchNeighbors(), TBPLayer::searchNeighbors(), Phase2OTBarrelRod::searchNeighbors(), CompositeTECPetal::searchNeighbors(), CSCEventData::selfTest(), edm::EventSelector::testSelectionOverlap(), and omtf::MuonUnpacker::unpack().

774 {
775  unsigned int nMatches1 = muon1.numberOfMatches(reco::Muon::SegmentAndTrackArbitration);
776  unsigned int nMatches2 = muon2.numberOfMatches(reco::Muon::SegmentAndTrackArbitration);
777  unsigned int betterMuon = ( muon1.pt() > muon2.pt() ? 1 : 2 );
778  for ( std::vector<reco::MuonChamberMatch>::const_iterator chamber1 = muon1.matches().begin();
779  chamber1 != muon1.matches().end(); ++chamber1 )
780  for ( std::vector<reco::MuonChamberMatch>::const_iterator chamber2 = muon2.matches().begin();
781  chamber2 != muon2.matches().end(); ++chamber2 )
782  {
783 
784  // if ( (chamber1->segmentMatches.empty() || chamber2->segmentMatches.empty()) ) continue;
785 
786  // handle case where both muons have information about the same chamber
787  // here we know how close they are
788  if ( chamber1->id == chamber2->id ){
789  // found the same chamber
790  if ( fabs(chamber1->x-chamber2->x) <
791  pullX * sqrt(chamber1->xErr*chamber1->xErr+chamber2->xErr*chamber2->xErr) )
792  {
793  if ( betterMuon == 1 )
794  nMatches2--;
795  else
796  nMatches1--;
797  if ( nMatches1==0 || nMatches2==0 ) return true;
798  continue;
799  }
800  if ( fabs(chamber1->y-chamber2->y) <
801  pullY * sqrt(chamber1->yErr*chamber1->yErr+chamber2->yErr*chamber2->yErr) )
802  {
803  if ( betterMuon == 1 )
804  nMatches2--;
805  else
806  nMatches1--;
807  if ( nMatches1==0 || nMatches2==0 ) return true;
808  }
809  } else {
810  if ( ! checkAdjacentChambers ) continue;
811  // check if tracks are pointing into overlaping region of the CSC detector
812  if ( chamber1->id.subdetId() != MuonSubdetId::CSC ||
813  chamber2->id.subdetId() != MuonSubdetId::CSC ) continue;
814  CSCDetId id1(chamber1->id);
815  CSCDetId id2(chamber2->id);
816  if ( id1.endcap() != id2.endcap() ) continue;
817  if ( id1.station() != id2.station() ) continue;
818  if ( id1.ring() != id2.ring() ) continue;
819  if ( abs(id1.chamber() - id2.chamber())>1 ) continue;
820  // FIXME: we don't handle 18->1; 36->1 transitions since
821  // I don't know how to check for sure how many chambers
822  // are there. Probably need to hard code some checks.
823 
824  // Now we have to make sure that both tracks are close to an edge
825  // FIXME: ignored Y coordinate for now
826  if ( fabs(chamber1->edgeX) > chamber1->xErr*pullX ) continue;
827  if ( fabs(chamber2->edgeX) > chamber2->xErr*pullX ) continue;
828  if ( chamber1->x * chamber2->x < 0 ) { // check if the same edge
829  if ( betterMuon == 1 )
830  nMatches2--;
831  else
832  nMatches1--;
833  if ( nMatches1==0 || nMatches2==0 ) return true;
834  }
835  }
836  }
837  return false;
838 }
globals_cff.id1
id1
Definition: globals_cff.py:32
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
reco::Muon::numberOfMatches
int numberOfMatches(unsigned int type=SegmentAndTrackArbitration) const
get number of chambers with matched segments
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
reco::Muon::matches
std::vector< MuonChamberMatch > & matches()
get muon matching information
Definition: Muon.h:144
globals_cff.id2
id2
Definition: globals_cff.py:33
MuonSubdetId::CSC
static constexpr int CSC
Definition: MuonSubdetId.h:13
unsigned int muon::RequiredStationMask ( const reco::Muon &  muon,
double  maxChamberDist,
double  maxChamberDistPull,
reco::Muon::ArbitrationType  arbitrationType 
)

Definition at line 59 of file MuonSelectors.cc.

References reco::Muon::trackDist(), and reco::Muon::trackDistErr().

Referenced by isGoodMuon().

63 {
64  unsigned int theMask = 0;
65 
66  for(int stationIdx = 1; stationIdx < 5; ++stationIdx)
67  for(int detectorIdx = 1; detectorIdx < 3; ++detectorIdx)
68  if(muon.trackDist(stationIdx,detectorIdx,arbitrationType) < maxChamberDist &&
69  muon.trackDist(stationIdx,detectorIdx,arbitrationType)/muon.trackDistErr(stationIdx,detectorIdx,arbitrationType) < maxChamberDistPull)
70  theMask += 1<<((stationIdx-1)+4*(detectorIdx-1));
71 
72  return theMask;
73 }
reco::Muon::trackDistErr
float trackDistErr(int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
reco::Muon::trackDist
float trackDist(int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float muon::segmentCompatibility ( const reco::Muon &  muon,
reco::Muon::ArbitrationType  arbitrationType = reco::Muon::SegmentAndTrackArbitration 
)

Definition at line 81 of file MuonSelectors.cc.

References reco::Muon::dX(), reco::Muon::dY(), mps_fire::i, Max(), reco::Muon::pullX(), reco::Muon::pullY(), reco::Muon::segmentX(), and reco::Muon::trackDist().

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

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

Definition at line 9 of file MuonSelectors.cc.

References All, AllArbitrated, AllGEMMuons, AllGlobalMuons, AllME0Muons, AllStandAloneMuons, AllTrackerMuons, Exception, runEdmFileComparison::found, GEMMuonArbitrated, GlobalMuonPromptTight, GMStaChiCompatibility, GMTkChiCompatibility, GMTkKinkTight, mps_fire::i, muon::SelectionTypeStringToEnum::label, ME0MuonArbitrated, RPCMuLoose, TM2DCompatibilityLoose, TM2DCompatibilityTight, TMLastStationAngLoose, TMLastStationAngTight, TMLastStationLoose, TMLastStationOptimizedBarrelLowPtLoose, TMLastStationOptimizedBarrelLowPtTight, TMLastStationOptimizedLowPtLoose, TMLastStationOptimizedLowPtTight, TMLastStationTight, TMOneStationAngLoose, TMOneStationAngTight, TMOneStationLoose, TMOneStationTight, TrackerMuonArbitrated, TriggerIdLoose, relativeConstraints::value, and muon::SelectionTypeStringToEnum::value.

Referenced by MuonSelectionTypeValueMapProducer::MuonSelectionTypeValueMapProducer(), reco::operator<<(), and MuonTrackProducer::produce().

10 {
11  static const SelectionTypeStringToEnum selectionTypeStringToEnumMap[] = {
12  { "All", All },
13  { "AllGlobalMuons", AllGlobalMuons },
14  { "AllStandAloneMuons", AllStandAloneMuons },
15  { "AllTrackerMuons", AllTrackerMuons },
16  { "TrackerMuonArbitrated", TrackerMuonArbitrated },
17  { "AllArbitrated", AllArbitrated },
18  { "GlobalMuonPromptTight", GlobalMuonPromptTight },
19  { "TMLastStationLoose", TMLastStationLoose },
20  { "TMLastStationTight", TMLastStationTight },
21  { "TM2DCompatibilityLoose", TM2DCompatibilityLoose },
22  { "TM2DCompatibilityTight", TM2DCompatibilityTight },
23  { "TMOneStationLoose", TMOneStationLoose },
24  { "TMOneStationTight", TMOneStationTight },
25  { "TMLastStationOptimizedLowPtLoose", TMLastStationOptimizedLowPtLoose },
26  { "TMLastStationOptimizedLowPtTight", TMLastStationOptimizedLowPtTight },
27  { "GMTkChiCompatibility", GMTkChiCompatibility },
28  { "GMStaChiCompatibility", GMStaChiCompatibility},
29  { "GMTkKinkTight", GMTkKinkTight},
30  { "TMLastStationAngLoose", TMLastStationAngLoose },
31  { "TMLastStationAngTight", TMLastStationAngTight },
32  { "TMOneStationAngLoose", TMOneStationAngLoose },
33  { "TMOneStationAngTight", TMOneStationAngTight },
34  { "TMLastStationOptimizedBarrelLowPtLoose", TMLastStationOptimizedBarrelLowPtLoose },
35  { "TMLastStationOptimizedBarrelLowPtTight", TMLastStationOptimizedBarrelLowPtTight },
36  { "RPCMuLoose", RPCMuLoose },
37  { "AllME0Muons", AllME0Muons },
38  { "ME0MuonArbitrated", ME0MuonArbitrated },
39  { "AllGEMMuons", AllGEMMuons },
40  { "GEMMuonArbitrated", GEMMuonArbitrated },
41  { "TriggerIdLoose", TriggerIdLoose },
42  { nullptr, (SelectionType)-1 }
43  };
44 
45  SelectionType value = (SelectionType)-1;
46  bool found = false;
47  for(int i = 0; selectionTypeStringToEnumMap[i].label && (! found); ++i)
48  if (! strcmp(label.c_str(), selectionTypeStringToEnumMap[i].label)) {
49  found = true;
50  value = selectionTypeStringToEnumMap[i].value;
51  }
52 
53  // in case of unrecognized selection type
54  if (! found) throw cms::Exception("MuonSelectorError") << label << " is not a recognized SelectionType";
55  return value;
56 }
mps_fire.i
i
Definition: mps_fire.py:269
muon::SelectionType
SelectionType
Selector type.
Definition: MuonSelectors.h:17
value
Definition: value.py:1
void muon::setCutBasedSelectorFlags ( reco::Muon &  muon,
const reco::Vertex *  vertex = 0,
bool  run2016_hip_mitigation = false 
)

Definition at line 987 of file MuonSelectors.cc.

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(), reco::Muon::isolationR03(), isSoftMuon(), isTightMuon(), isTrackerHighPtMuon(), SiStripPI::max, reco::Muon::muonBestTrack(), outOfTimeMuon(), reco::Muon::pfIsolationR04(), reco::Muon::PFIsoLoose, reco::Muon::PFIsoMedium, reco::Muon::PFIsoTight, reco::Muon::PFIsoVeryLoose, reco::Muon::PFIsoVeryTight, reco::Muon::PFIsoVeryVeryTight, reco::Vertex::position(), reco::LeafCandidate::pt(), reco::Muon::selectors(), TrackValidation_cff::selectors, reco::Muon::setSelectors(), reco::Muon::SoftCutBasedId, reco::MuonPFIsolation::sumChargedHadronPt, reco::MuonPFIsolation::sumNeutralHadronEt, reco::MuonPFIsolation::sumPhotonEt, reco::MuonIsolation::sumPt, reco::MuonPFIsolation::sumPUPt, reco::Muon::TkIsoLoose, reco::Muon::TkIsoTight, muons_cff::tkRelIso, and reco::Muon::TriggerIdLoose.

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

990 {
991  // https://twiki.cern.ch/twiki/bin/viewauth/CMS/SWGuideMuonIdRun2
992  unsigned int selectors = muon.selectors();
993  // Compute Id and Isolation variables
994  double chIso = muon.pfIsolationR04().sumChargedHadronPt;
995  double nIso = muon.pfIsolationR04().sumNeutralHadronEt;
996  double phoIso = muon.pfIsolationR04().sumPhotonEt;
997  double puIso = muon.pfIsolationR04().sumPUPt;
998  double dbCorrectedIsolation = chIso + std::max( nIso + phoIso - .5*puIso, 0. ) ;
999  double dbCorrectedRelIso = dbCorrectedIsolation/muon.pt();
1000  double tkRelIso = muon.isolationR03().sumPt/muon.pt();
1001 
1002  // Base selectors
1003  if (muon::isLooseMuon(muon)) selectors |= reco::Muon::CutBasedIdLoose;
1004  if (vertex){
1005  if (muon::isTightMuon(muon,*vertex)) selectors |= reco::Muon::CutBasedIdTight;
1006  if (muon::isSoftMuon(muon,*vertex,run2016_hip_mitigation)) selectors |= reco::Muon::SoftCutBasedId;
1007  if (muon::isHighPtMuon(muon,*vertex)) selectors |= reco::Muon::CutBasedIdGlobalHighPt;
1008  if (muon::isTrackerHighPtMuon(muon,*vertex)) selectors |= reco::Muon::CutBasedIdTrkHighPt;
1009  }
1010  if (muon::isMediumMuon(muon,run2016_hip_mitigation)){
1011  selectors |= reco::Muon::CutBasedIdMedium;
1012  if ( vertex and
1013  fabs(muon.muonBestTrack()->dz( vertex->position()))<0.1 and
1014  fabs(muon.muonBestTrack()->dxy(vertex->position()))< 0.02 )
1015  selectors |= reco::Muon::CutBasedIdMediumPrompt;
1016  }
1017 
1018  // PF isolation
1019  if (dbCorrectedRelIso<0.40) selectors |= reco::Muon::PFIsoVeryLoose;
1020  if (dbCorrectedRelIso<0.25) selectors |= reco::Muon::PFIsoLoose;
1021  if (dbCorrectedRelIso<0.20) selectors |= reco::Muon::PFIsoMedium;
1022  if (dbCorrectedRelIso<0.15) selectors |= reco::Muon::PFIsoTight;
1023  if (dbCorrectedRelIso<0.10) selectors |= reco::Muon::PFIsoVeryTight;
1024  if (dbCorrectedRelIso<0.05) selectors |= reco::Muon::PFIsoVeryVeryTight;
1025 
1026  // Tracker isolation
1027  if (tkRelIso<0.10) selectors |= reco::Muon::TkIsoLoose;
1028  if (tkRelIso<0.05) selectors |= reco::Muon::TkIsoTight;
1029 
1030  // Trigger selectors
1031  if (isLooseTriggerMuon(muon)) selectors |= reco::Muon::TriggerIdLoose;
1032 
1033  // Timing
1034  if (!outOfTimeMuon(muon)) selectors |= reco::Muon::InTimeMuon;
1035 
1036  muon.setSelectors(selectors);
1037 }
reco::MuonIsolation::sumPt
float sumPt
sum-pt of tracks
Definition: MuonIsolation.h:7
muon::isMediumMuon
bool isMediumMuon(const reco::Muon &, bool run2016_hip_mitigation=false)
Definition: MuonSelectors.cc:875
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
reco::MuonPFIsolation::sumPhotonEt
float sumPhotonEt
sum pt of PF photons
Definition: MuonPFIsolation.h:10
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:109
muon::isLooseMuon
bool isLooseMuon(const reco::Muon &)
Definition: MuonSelectors.cc:870
reco::MuonPFIsolation::sumNeutralHadronEt
float sumNeutralHadronEt
sum pt of neutral hadrons
Definition: MuonPFIsolation.h:9
reco::MuonPFIsolation::sumPUPt
float sumPUPt
sum pt of charged Particles not from PV (for Pu corrections)
Definition: MuonPFIsolation.h:13
reco::Muon::muonBestTrack
virtual TrackRef muonBestTrack() const
Definition: Muon.h:63
muon::isSoftMuon
bool isSoftMuon(const reco::Muon &, const reco::Vertex &, bool run2016_hip_mitigation=false)
Definition: MuonSelectors.cc:891
muon::isHighPtMuon
bool isHighPtMuon(const reco::Muon &, const reco::Vertex &)
Definition: MuonSelectors.cc:910
reco::Muon::setSelectors
void setSelectors(unsigned int selectors)
Definition: Muon.h:225
reco::Muon::pfIsolationR04
const MuonPFIsolation & pfIsolationR04() const
Definition: Muon.h:168
reco::Muon::selectors
unsigned int selectors() const
Definition: Muon.h:224
TrackValidation_cff.selectors
selectors
Definition: TrackValidation_cff.py:263
outOfTimeMuon
bool outOfTimeMuon(const reco::Muon &muon)
Definition: MuonSelectors.cc:969
muon::isTrackerHighPtMuon
bool isTrackerHighPtMuon(const reco::Muon &, const reco::Vertex &)
Definition: MuonSelectors.cc:925
muon::isTightMuon
bool isTightMuon(const reco::Muon &, const reco::Vertex &)
Definition: MuonSelectors.cc:853
muon::isLooseTriggerMuon
bool isLooseTriggerMuon(const reco::Muon &)
Definition: MuonSelectors.cc:841
muons_cff.tkRelIso
tkRelIso
Definition: muons_cff.py:141
reco::Muon::isolationR03
const MuonIsolation & isolationR03() const
Definition: Muon.h:162
reco::MuonPFIsolation::sumChargedHadronPt
float sumChargedHadronPt
sum-pt of charged Hadron
Definition: MuonPFIsolation.h:7
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 940 of file MuonSelectors.cc.

References reco::Muon::matches().

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

940  {
941  int ret = 0;
942 
943  // Will do with a stupid double loop, since creating and filling a map is probably _more_ inefficient for a single lookup.
944  for(std::vector<reco::MuonChamberMatch>::const_iterator chamberMatch = mu.matches().begin();
945  chamberMatch != mu.matches().end(); ++chamberMatch) {
946  if (chamberMatch->segmentMatches.empty()) continue;
947  for(std::vector<reco::MuonChamberMatch>::const_iterator chamberMatch2 = mu2.matches().begin();
948  chamberMatch2 != mu2.matches().end(); ++chamberMatch2) {
949  if (chamberMatch2->segmentMatches.empty()) continue;
950  if (chamberMatch2->id() != chamberMatch->id()) continue;
951  for(std::vector<reco::MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
952  segmentMatch != chamberMatch->segmentMatches.end(); ++segmentMatch) {
953  if (!segmentMatch->isMask(segmentArbitrationMask)) continue;
954  for(std::vector<reco::MuonSegmentMatch>::const_iterator segmentMatch2 = chamberMatch2->segmentMatches.begin();
955  segmentMatch2 != chamberMatch2->segmentMatches.end(); ++segmentMatch2) {
956  if (!segmentMatch2->isMask(segmentArbitrationMask)) continue;
957  if ((segmentMatch->cscSegmentRef.isNonnull() && segmentMatch->cscSegmentRef == segmentMatch2->cscSegmentRef) ||
958  (segmentMatch-> dtSegmentRef.isNonnull() && segmentMatch-> dtSegmentRef == segmentMatch2-> dtSegmentRef) ) {
959  ++ret;
960  } // is the same
961  } // segment of mu2 in chamber
962  } // segment of mu1 in chamber
963  } // chamber of mu2
964  } // chamber of mu1
965 
966  return ret;
967 }
RPCpg::mu
const int mu
Definition: Constants.h:22
reco::Muon::MuonTrackTypePair muon::sigmaSwitch ( const reco::TrackRef &  combinedTrack,
const reco::TrackRef &  trackerTrack,
const double  nSigma = 2.,
const double  ptThreshold = 200. 
)

Definition at line 131 of file MuonCocktails.cc.

References reco::Muon::CombinedTrack, delta, reco::Muon::InnerTrack, refitMuons_cfi::ptThreshold, and electronIdCutBased_cfi::threshold.

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

134  {
135  // If either the global or tracker-only fits have pT below threshold
136  // (default 200 GeV), return the tracker-only fit.
137  if (combinedTrack->pt() < ptThreshold || trackerTrack->pt() < ptThreshold)
138  return make_pair(trackerTrack,reco::Muon::InnerTrack);
139 
140  // If both are above the pT threshold, compare the difference in
141  // q/p: if less than two sigma of the tracker-only track, switch to
142  // global. Otherwise, use tracker-only.
143  const double delta = fabs(trackerTrack->qoverp() - combinedTrack->qoverp());
144  const double threshold = nSigma * trackerTrack->qoverpError();
145  return delta > threshold ? make_pair(trackerTrack,reco::Muon::InnerTrack) : make_pair(combinedTrack,reco::Muon::CombinedTrack);
146 }
delta
dbl * delta
Definition: mlp_gen.cc:36
electronIdCutBased_cfi.threshold
threshold
Definition: electronIdCutBased_cfi.py:6
Muon
Definition: Muon.py:1
refitMuons_cfi.ptThreshold
ptThreshold
Definition: refitMuons_cfi.py:61
gsfElectronCkfTrackCandidateMaker_cff.nSigma
nSigma
Definition: gsfElectronCkfTrackCandidateMaker_cff.py:45
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:43
reco::Muon::MuonTrackTypePair muon::sigmaSwitch ( const reco::Muon &  muon,
const double  nSigma = 2.,
const double  ptThreshold = 200. 
)
inline

Definition at line 58 of file MuonCocktails.h.

References reco::Muon::globalTrack(), reco::Muon::innerTrack(), gsfElectronCkfTrackCandidateMaker_cff::nSigma, refitMuons_cfi::ptThreshold, sigmaSwitch(), TMR(), HiIsolationCommonParameters_cff::track, and trackProbability().

60  {
61  return muon::sigmaSwitch(muon.globalTrack(),
62  muon.innerTrack(),
63  nSigma,
64  ptThreshold);
65  }
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
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:131
refitMuons_cfi.ptThreshold
ptThreshold
Definition: refitMuons_cfi.py:61
gsfElectronCkfTrackCandidateMaker_cff.nSigma
nSigma
Definition: gsfElectronCkfTrackCandidateMaker_cff.py:45
reco::Muon::globalTrack
virtual TrackRef globalTrack() const
reference to Track reconstructed in both tracked and muon detector
Definition: Muon.h:54
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.

References reco::Muon::CombinedTrack, reco::Muon::DYT, plotBeamSpotDB::first, mps_fire::i, reco::Muon::InnerTrack, reco::Muon::Picky, TtFullHadEvtBuilder_cfi::prob, reco::Muon::TPFMS, and trackProbability().

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

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

References reco::Muon::dytTrack(), getTevRefitTrack(), reco::Muon::globalTrack(), reco::Muon::innerTrack(), genParticles_cff::map, gsfElectronCkfTrackCandidateMaker_cff::nSigma, reco::Muon::pickyTrack(), refitMuons_cfi::ptThreshold, sigmaSwitch(), tevOptimized(), and reco::Muon::tpfmsTrack().

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  }
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
reco::Muon::tpfmsTrack
virtual TrackRef tpfmsTrack() const
Definition: Muon.h:57
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::pickyTrack
virtual TrackRef pickyTrack() const
Definition: Muon.h:58
refitMuons_cfi.ptThreshold
ptThreshold
Definition: refitMuons_cfi.py:61
reco::Muon::dytTrack
virtual TrackRef dytTrack() const
Definition: Muon.h:59
reco::Muon::globalTrack
virtual TrackRef globalTrack() const
reference to Track reconstructed in both tracked and muon detector
Definition: Muon.h:54
reco::Muon::MuonTrackTypePair muon::TMR ( const reco::TrackRef &  trackerTrack,
const reco::TrackRef &  fmsTrack,
const double  tune = 4. 
)

Definition at line 151 of file MuonCocktails.cc.

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

Referenced by sigmaSwitch().

153  {
154  double probTK = 0;
155  double probFMS = 0;
156 
157  if (trackerTrack.isNonnull() && trackerTrack->numberOfValidHits())
158  probTK = muon::trackProbability(trackerTrack);
159  if (fmsTrack.isNonnull() && fmsTrack->numberOfValidHits())
160  probFMS = muon::trackProbability(fmsTrack);
161 
162  bool TKok = probTK > 0;
163  bool FMSok = probFMS > 0;
164 
165  if (TKok && FMSok) {
166  if (probFMS - probTK > tune)
167  return make_pair(trackerTrack,reco::Muon::InnerTrack);
168  else
169  return make_pair(fmsTrack,reco::Muon::TPFMS);
170  }
171  else if (FMSok)
172  return make_pair(fmsTrack,reco::Muon::TPFMS);
173  else if (TKok)
174  return make_pair(trackerTrack,reco::Muon::InnerTrack);
175  else
176  return make_pair(reco::TrackRef(),reco::Muon::None);
177 }
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:253
muon::trackProbability
double trackProbability(const reco::TrackRef track)
Definition: MuonCocktails.cc:110
double muon::trackProbability ( const reco::TrackRef  track)

Definition at line 110 of file MuonCocktails.cc.

References createfilelist::int, and cmsBatch::log.

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

110  {
111 
112  int nDOF = (int)track->ndof();
113  if ( nDOF > 0 && track->chi2()> 0) {
114  return -log(TMath::Prob(track->chi2(), nDOF));
115  } else {
116  return 0.0;
117  }
118 
119 }
Generated for CMSSW Reference Manual by doxygen 1.8.11