CMS 3D CMS Logo
Public Types | Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes

reco::Muon Class Reference

#include <DataFormats/MuonReco/interface/Muon.h>

Inheritance diagram for reco::Muon:
reco::RecoCandidate reco::LeafCandidate reco::Candidate pat::PATObject< reco::Muon > pat::Lepton< reco::Muon > pat::Muon

List of all members.

Public Types

enum  ArbitrationType { NoArbitration, SegmentArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned }
 

define arbitration schemes

More...
typedef std::map
< MuonTrackType,
reco::TrackRef > 		MuonTrackRefMap
enum  MuonTrackType {
  None, InnerTrack, OuterTrack, CombinedTrack,
  TPFMS, Picky, DYT
}
 

map for Global Muon refitters

More...
typedef std::pair< TrackRef,
Muon::MuonTrackType > 		MuonTrackTypePair

Public Member Functions

virtual const Track * bestTrack () const
 best track pointer
virtual TrackBaseRef bestTrackRef () const
 best track RefToBase
MuonEnergy calEnergy () const
 get energy deposition information
float caloCompatibility () const
Muon * clone () const
 create a clone
virtual TrackRef combinedMuon () const
 reference to a stand-alone muon Track
MuonQuality combinedQuality () const
 get energy deposition information
float dDxDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float dDyDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float dX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float dY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
virtual TrackRef dytTrack () const
virtual TrackRef globalTrack () const
 reference to Track reconstructed in both tracked and muon detector
virtual TrackRef innerTrack () const
bool isAValidMuonTrack (const MuonTrackType &type) const
bool isCaloCompatibilityValid () const
bool isCaloMuon () const
bool isEnergyValid () const
bool isGlobalMuon () const
bool isIsolationValid () const
bool isMatchesValid () const
bool isMuon () const
const MuonIsolation & isolationR03 () const
const MuonIsolation & isolationR05 () const
bool isPFIsolationValid () const
bool isPFMuon () const
bool isQualityValid () const
bool isRPCMuon () const
bool isStandAloneMuon () const
bool isTimeValid () const
bool isTrackerMuon () const
std::vector< MuonChamberMatch > & matches ()
 get muon matching information
const std::vector
< MuonChamberMatch > & 		matches () const
 Muon (Charge, const LorentzVector &, const Point &=Point(0, 0, 0))
 constructor from values
 Muon ()
virtual TrackRef muonBestTrack () const
virtual MuonTrackType muonBestTrackType () const
TrackRef muonTrack (const MuonTrackType &) const
TrackRef muonTrackFromMap (const MuonTrackType &type) const
int numberOfChambers () const
int numberOfChambersNoRPC () const
 number of chambers not including RPC matches (MuonChamberMatches include RPC rolls)
int numberOfMatchedStations (ArbitrationType type=SegmentAndTrackArbitration) const
int numberOfMatches (ArbitrationType type=SegmentAndTrackArbitration) const
 get number of chambers with matched segments
int numberOfSegments (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
 get number of segments
virtual TrackRef outerTrack () const
 reference to Track reconstructed in the muon detector only
const MuonPFIsolation & pfIsolationR03 () const
const MuonPFIsolation & pfIsolationR04 () const
reco::Candidate::LorentzVector pfP4 () const
virtual TrackRef pickyTrack () const
float pullDxDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration, bool includeSegmentError=true) const
float pullDyDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration, bool includeSegmentError=true) const
float pullX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration, bool includeSegmentError=true) const
float pullY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration, bool includeSegmentError=true) const
float segmentDxDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float segmentDxDzErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float segmentDyDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float segmentDyDzErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float segmentX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float segmentXErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float segmentY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float segmentYErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
virtual void setBestTrack (MuonTrackType muonType)
void setCalEnergy (const MuonEnergy &calEnergy)
 set energy deposition information
void setCaloCompatibility (float input)
virtual void setCombined (const TrackRef &t)
void setCombinedQuality (const MuonQuality &combinedQuality)
 set energy deposition information
virtual void setGlobalTrack (const TrackRef &t)
 set reference to Track
virtual void setInnerTrack (const TrackRef &t)
 set reference to Track
void setIsolation (const MuonIsolation &isoR03, const MuonIsolation &isoR05)
void setMatches (const std::vector< MuonChamberMatch > &matches)
 set muon matching information
void setMuonTrack (const MuonTrackType &, const TrackRef &)
virtual void setOuterTrack (const TrackRef &t)
 set reference to Track
void setPFIsolation (const MuonPFIsolation &isoR03, const MuonPFIsolation &isoR04)
virtual void setPFP4 (const reco::Candidate::LorentzVector &p4_)
virtual void setStandAlone (const TrackRef &t)
void setTime (const MuonTime &time)
 set timing information
virtual void setTrack (const TrackRef &t)
void setType (unsigned int type)
virtual TrackRef standAloneMuon () const
 reference to a stand-alone muon Track
unsigned int stationGapMaskDistance (float distanceCut=10.) const
unsigned int stationGapMaskPull (float sigmaCut=3.) const
 same as above for given number of sigmas
unsigned int stationMask (ArbitrationType type=SegmentAndTrackArbitration) const
float t0 (int n=0)
MuonTime time () const
 get timing information
virtual TrackRef tpfmsTrack () const
virtual TrackRef track () const
 reference to a Track
float trackDist (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackDistErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackDxDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackDxDzErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackDyDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackDyDzErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackEdgeX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackEdgeY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackXErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
float trackYErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
unsigned int type () const

Static Public Attributes

static const unsigned int CaloMuon = 1<<4
static const unsigned int GlobalMuon = 1<<1
static const unsigned int PFMuon = 1<<5
static const unsigned int RPCMuon = 1<<6
static const unsigned int StandAloneMuon = 1<<3
static const unsigned int TrackerMuon = 1<<2

Private Member Functions

const std::vector< const
MuonChamberMatch * > 		chambers (int station, int muonSubdetId) const
 get vector of muon chambers for given station and detector
virtual bool overlap (const Candidate &) const
 check overlap with another candidate
std::pair< const
MuonChamberMatch *, const
MuonSegmentMatch * > 		pair (const std::vector< const MuonChamberMatch * > &, ArbitrationType type=SegmentAndTrackArbitration) const
 get pointers to best segment and corresponding chamber in vector of chambers

Private Attributes

MuonTrackType bestTrackType_
 reference to the Track chosen to assign the momentum value to the muon
MuonEnergy calEnergy_
 energy deposition
float caloCompatibility_
 muon hypothesis compatibility with observer calorimeter energy
MuonQuality combinedQuality_
 quality block
bool energyValid_
TrackRef globalTrack_
 reference to Track reconstructed in both tracked and muon detector
TrackRef innerTrack_
 reference to Track reconstructed in the tracker only
MuonIsolation isolationR03_
 Isolation information for two cones with dR=0.3 and dR=0.5.
MuonIsolation isolationR05_
bool isolationValid_
bool matchesValid_
std::vector< MuonChamberMatch > muMatches_
 Information on matching between tracks and segments.
TrackRef outerTrack_
 reference to Track reconstructed in the muon detector only
MuonPFIsolation pfIsolationR03_
 PF Isolation information for two cones with dR=0.3 and dR=0.4.
MuonPFIsolation pfIsolationR04_
bool pfIsolationValid_
reco::Candidate::LorentzVector pfP4_
bool qualityValid_
MuonTrackRefMap refittedTrackMap_
 reference to the Global Track refitted with dedicated TeV reconstructors
MuonTime time_
 timing
unsigned int type_
 muon type mask

Detailed Description

A reconstructed Muon. contains reference to three fits:

Author:
Luca Lista, Claudio Campagnari, Dmytro Kovalskyi, Jake Ribnik, Riccardo Bellan, Michalis Bachtis
Version:
Id:
Muon.h,v 1.71 2012/03/28 09:52:15 dmytro Exp

Definition at line 28 of file Muon.h.

Member Typedef Documentation

typedef std::map<MuonTrackType, reco::TrackRef> reco::Muon::MuonTrackRefMap

Definition at line 40 of file Muon.h.

typedef std::pair<TrackRef, Muon::MuonTrackType> reco::Muon::MuonTrackTypePair

Definition at line 41 of file Muon.h.

Member Enumeration Documentation

enum reco::Muon::ArbitrationType

define arbitration schemes

Enumerator:
NoArbitration 
SegmentArbitration 
SegmentAndTrackArbitration 
SegmentAndTrackArbitrationCleaned 

Definition at line 168 of file Muon.h.

{ NoArbitration, SegmentArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned };
enum reco::Muon::MuonTrackType

map for Global Muon refitters

Enumerator:
None 
InnerTrack 
OuterTrack 
CombinedTrack 
TPFMS 
Picky 
DYT 

Definition at line 39 of file Muon.h.

{None, InnerTrack, OuterTrack, CombinedTrack, TPFMS, Picky, DYT};

Constructor & Destructor Documentation

Muon::Muon ( )

Reimplemented in pat::Muon.

Definition at line 18 of file Muon.cc.

References bestTrackType_, caloCompatibility_, energyValid_, isolationValid_, matchesValid_, None, pfIsolationValid_, qualityValid_, and type_.

Referenced by clone().

           {
   energyValid_  = false;
   matchesValid_ = false;
   isolationValid_ = false;
   pfIsolationValid_ = false;
   qualityValid_ = false;
   caloCompatibility_ = -9999.;
   type_ = 0;
   bestTrackType_ = reco::Muon::None;
}
Muon::Muon ( Charge  q,
const LorentzVector &  p4,
const Point &  vtx = Point( 0, 0, 0 ) 
)

constructor from values

Definition at line 6 of file Muon.cc.

References bestTrackType_, caloCompatibility_, energyValid_, isolationValid_, matchesValid_, None, pfIsolationValid_, qualityValid_, and type_.

                                                                   :
  RecoCandidate( q, p4, vtx, -13 * q ) {
     energyValid_  = false;
     matchesValid_ = false;
     isolationValid_ = false;
     pfIsolationValid_ = false;
     qualityValid_ = false;
     caloCompatibility_ = -9999.;
     type_ = 0;
     bestTrackType_ = reco::Muon::None;
}

Member Function Documentation

virtual const Track* reco::Muon::bestTrack ( ) const [inline, virtual]

best track pointer

Reimplemented from reco::RecoCandidate.

Definition at line 62 of file Muon.h.

References bestTrackType_, edm::Ref< C, T, F >::get(), and muonTrack().

{return muonTrack(bestTrackType_).get();}
virtual TrackBaseRef reco::Muon::bestTrackRef ( ) const [inline, virtual]

best track RefToBase

Reimplemented from reco::RecoCandidate.

Definition at line 63 of file Muon.h.

References bestTrackType_, and muonTrack().

Referenced by SelectReplacementCandidates::getRawIDsAdvanced().

{return reco::TrackBaseRef(muonTrack(bestTrackType_));}
MuonEnergy reco::Muon::calEnergy ( ) const [inline]

get energy deposition information

Definition at line 107 of file Muon.h.

References calEnergy_.

Referenced by MuonTimingFiller::addEcalTime(), FWMuonDetailView::addSceneInfo(), MuonEnergyDepositAnalyzer::analyze(), FWMuonDetailView::build(), FWMuonLegoProxyBuilder::build(), MuonCaloCompatibility::evaluate(), MuonMETAlgo::GetMuDepDeltas(), MuonIdProducer::makeCaloMuon(), MuonIdProducer::produce(), ZToLLEdmNtupleDumper::produce(), ZMuMuMuonUserData::produce(), setCalEnergy(), and FWMuonDetailView::setTextInfo().

{ return calEnergy_; }
float reco::Muon::caloCompatibility ( ) const [inline]

====================== MUON COMPATIBILITY BLOCK ===========================

Relative likelihood based on ECAL, HCAL, HO energy defined as L_muon/(L_muon+L_not_muon)

Definition at line 146 of file Muon.h.

References caloCompatibility_.

Referenced by muon::caloCompatibility(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), and CaloMuonMerger::produce().

{ return caloCompatibility_; }
const std::vector< const MuonChamberMatch * > Muon::chambers ( int  station,
int  muonSubdetId 
) const [private]

get vector of muon chambers for given station and detector

Definition at line 287 of file Muon.cc.

References muMatches_.

Referenced by dDxDz(), dDyDz(), dX(), dY(), pullDxDz(), pullDyDz(), pullX(), pullY(), segmentDxDz(), segmentDxDzErr(), segmentDyDz(), segmentDyDzErr(), segmentX(), segmentXErr(), segmentY(), segmentYErr(), trackDist(), trackDistErr(), trackDxDz(), trackDxDzErr(), trackDyDz(), trackDyDzErr(), trackEdgeX(), trackEdgeY(), trackX(), trackXErr(), trackY(), and trackYErr().

{
   std::vector<const MuonChamberMatch*> chambers;
   for(std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
         chamberMatch != muMatches_.end(); chamberMatch++)
      if(chamberMatch->station()==station && chamberMatch->detector()==muonSubdetId)
         chambers.push_back(&(*chamberMatch));
   return chambers;
}
Muon * Muon::clone ( void  ) const [virtual]

create a clone

Reimplemented from reco::RecoCandidate.

Reimplemented in pat::Muon, and pat::Lepton< reco::Muon >.

Definition at line 40 of file Muon.cc.

References Muon().

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack().

                         {
  return new Muon( * this );
}
virtual TrackRef reco::Muon::combinedMuon ( ) const [inline, virtual]

reference to a stand-alone muon Track

Reimplemented from reco::RecoCandidate.

Reimplemented in pat::Muon.

Definition at line 56 of file Muon.h.

References globalTrack().

Referenced by MuonRecoAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), AlignmentMuonSelector::basicCuts(), MuonIdProducer::fillGlbQuality(), MuonTimingFiller::fillTiming(), overlap(), helper::MuonCollectionStoreManager::processMuon(), and muon::tevOptimized().

{ return globalTrack(); }
MuonQuality reco::Muon::combinedQuality ( ) const [inline]

get energy deposition information

Definition at line 117 of file Muon.h.

References combinedQuality_.

Referenced by MuonIdProducer::fillGlbQuality(), MuonIdProducer::fillTrackerKink(), muon::isGoodMuon(), and setCombinedQuality().

{ return combinedQuality_; }
float Muon::dDxDz ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 353 of file Muon.cc.

References chambers(), and pair().

{
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasPhi()) return 999999;
   return chamberSegmentPair.first->dXdZ-chamberSegmentPair.second->dXdZ;
}
float Muon::dDyDz ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 361 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

{
   if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasZed()) return 999999;
   return chamberSegmentPair.first->dYdZ-chamberSegmentPair.second->dYdZ;
}
float Muon::dX ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

get deltas between (best) segment and track If no chamber or no segment returns 999999

Definition at line 336 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::isGoodMuon(), and muon::segmentCompatibility().

{
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasPhi()) return 999999;
   return chamberSegmentPair.first->x-chamberSegmentPair.second->x;
}
float Muon::dY ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 344 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

Referenced by muon::isGoodMuon(), and muon::segmentCompatibility().

{
   if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasZed()) return 999999;
   return chamberSegmentPair.first->y-chamberSegmentPair.second->y;
}
virtual TrackRef reco::Muon::dytTrack ( ) const [inline, virtual]

Reimplemented in pat::Muon.

Definition at line 60 of file Muon.h.

References DYT, and muonTrackFromMap().

Referenced by muonTrack().

{ return muonTrackFromMap(DYT);}
virtual TrackRef reco::Muon::globalTrack ( ) const [inline, virtual]

reference to Track reconstructed in both tracked and muon detector

Reimplemented in pat::Muon.

Definition at line 55 of file Muon.h.

References globalTrack_.

Referenced by TrackSplittingMonitor::analyze(), CosmicSplitterValidation::analyze(), EwkMuDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), ZToMuMuGammaAnalyzer::basicMuonSelection(), FWMuonBuilder::buildMuon(), TCMETAlgo::CalculateTCMET(), combinedMuon(), pat::Muon::embedCombinedMuon(), MuonShowerInformationFiller::fillHitsByStation(), WMuNuSelector::filter(), LeptonRecoSkim::filter(), WMuNuValidator::filter(), MuonMETAlgo::GetMuDepDeltas(), cms::MuonTCMETValueMapProducer::isGoodMuon(), muon::isGoodMuon(), BTagHLTOfflineSource::isVBTFMuon(), FourVectorHLTOffline::isVBTFMuon(), ZToMuMuGammaAnalyzer::muonSelection(), muonTrack(), helper::MuonCollectionStoreManager::processMuon(), cms::MuonMETValueMapProducer::produce(), BPhysicsOniaDQM::selGlobalMuon(), muon::sigmaSwitch(), sigmaSwitch(), muon::tevOptimized(), and tevOptimizedTMR().

{ return globalTrack_; }
virtual TrackRef reco::Muon::innerTrack ( ) const [inline, virtual]

Reimplemented in pat::Muon.

Definition at line 49 of file Muon.h.

References innerTrack_.

Referenced by HLTMuonMatchAndPlot::analyze(), EwkMuLumiMonitorDQM::analyze(), EwkMuDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), ZToMuMuGammaAnalyzer::basicMuonSelection(), FWMuonBuilder::buildMuon(), FWMuonBuilder::calculateField(), TCMETAlgo::CalculateTCMET(), MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), pat::Muon::embedTrack(), MuonIdProducer::fillTrackerKink(), LeptonRecoSkim::filter(), WMuNuValidator::filter(), MuonMETAlgo::GetMuDepDeltas(), cms::MuonTCMETValueMapProducer::isGoodCaloMuon(), cms::MuonTCMETValueMapProducer::isGoodMuon(), muon::isGoodMuon(), cms::MuonTCMETValueMapProducer::isGoodTrack(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), muon::isTightMuon(), BTagHLTOfflineSource::isVBTFMuon(), FourVectorHLTOffline::isVBTFMuon(), MuonIdProducer::makeCaloMuon(), MuonResidualsFromTrack::MuonResidualsFromTrack(), muonTrack(), MuonIdProducer::phiOfMuonIneteractionRegion(), helper::MuonCollectionStoreManager::processMuon(), MuonIdProducer::produce(), cms::MuonMETValueMapProducer::produce(), cms::MuonTCMETValueMapProducer::produce(), cms::MuonTCMETValueMapProducer::propagateTrack(), MuonCosmicCompatibilityFiller::pvMatches(), BPhysicsOniaDQM::selGlobalMuon(), BPhysicsOniaDQM::selTrackerMuon(), muon::sigmaSwitch(), sigmaSwitch(), muon::tevOptimized(), tevOptimizedTMR(), and track().

{ return innerTrack_; }
bool Muon::isAValidMuonTrack ( const MuonTrackType &  type) const

Definition at line 760 of file Muon.cc.

References edm::Ref< C, T, F >::isNonnull(), and muonTrack().

Referenced by pat::PATMuonProducer::fillMuon().

                                                           {
  return muonTrack(type).isNonnull();
}
bool reco::Muon::isCaloCompatibilityValid ( ) const [inline]

Definition at line 148 of file Muon.h.

References caloCompatibility_.

Referenced by CaloMuonMerger::produce().

{ return caloCompatibility_>=0; }
bool reco::Muon::isCaloMuon ( ) const [inline, virtual]

Reimplemented from reco::LeafCandidate.

Definition at line 209 of file Muon.h.

References CaloMuon, and type_.

Referenced by MuonRecoAnalyzer::analyze(), TCMETAlgo::CalculateTCMET(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), and cms::MuonTCMETValueMapProducer::produce().

{ return type_ & CaloMuon; }
bool reco::Muon::isEnergyValid ( ) const [inline]

====================== ENERGY BLOCK ===========================

energy deposition

Definition at line 105 of file Muon.h.

References energyValid_.

Referenced by MuonTimingFiller::addEcalTime(), FWMuonDetailView::addSceneInfo(), FWMuonDetailView::build(), FWMuonLegoProxyBuilder::build(), MuonIdProducer::makeCaloMuon(), MuonIdProducer::produce(), and FWMuonDetailView::setTextInfo().

{ return energyValid_; }
bool reco::Muon::isGlobalMuon ( ) const [inline, virtual]

Reimplemented from reco::LeafCandidate.

Definition at line 206 of file Muon.h.

References GlobalMuon, and type_.

Referenced by MuonRecoAnalyzer::analyze(), ZMuMu_efficiencyAnalyzer::analyze(), GlbMuQualityCutsAnalysis::analyze(), MuonKinVsEtaAnalyzer::analyze(), EwkMuLumiMonitorDQM::analyze(), RPCRecHitProbability::analyze(), ZMuMu_vtxAnalyzer::analyze(), RPCMonitorDigi::analyze(), EwkMuDQM::analyze(), MuTriggerAnalyzer::analyze(), HiggsDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), AlignmentMuonSelector::basicCuts(), ZToMuMuGammaAnalyzer::basicMuonSelection(), FWMuonBuilder::buildMuon(), TCMETAlgo::CalculateTCMET(), MuonCosmicCompatibilityFiller::combinedCosmicID(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), MuonIdProducer::fillGlbQuality(), EwkMuTauHistManager::fillHistograms(), MuonShowerInformationFiller::fillHitsByStation(), pat::PATMuonProducer::fillMuon(), WMuNuSelector::filter(), LeptonRecoSkim::filter(), WMuNuValidator::filter(), MuonMETAlgo::GetMuDepDeltas(), cms::MuonTCMETValueMapProducer::isGoodMuon(), muon::isGoodMuon(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), muon::isTightMuon(), cms::MuonMETValueMapProducer::produce(), ZMuMuUserData::produce(), ZToLLEdmNtupleDumper::produce(), cms::MuonTCMETValueMapProducer::produce(), ZMuMuMuonUserData::produce(), MuonProducer::produce(), MuonCosmicCompatibilityFiller::pvMatches(), and MuScleFitMuonSelector::selectMuons().

{ return type_ & GlobalMuon; }
bool reco::Muon::isIsolationValid ( ) const [inline]

Definition at line 161 of file Muon.h.

References isolationValid_.

Referenced by MuonMETAlgo::GetMuDepDeltas().

{ return isolationValid_; }
bool reco::Muon::isMatchesValid ( ) const [inline]

====================== MUON MATCH BLOCK ===========================

Definition at line 134 of file Muon.h.

References matchesValid_.

Referenced by FWMuonBuilder::buildMuon(), muon::isGoodMuon(), and MuonIdProducer::overlap().

{ return matchesValid_; }
bool reco::Muon::isMuon ( ) const [inline, virtual]

Reimplemented from reco::LeafCandidate.

Definition at line 205 of file Muon.h.

{ return true; }
const MuonIsolation& reco::Muon::isolationR03 ( ) const [inline]

====================== ISOLATION BLOCK ===========================

Summary of muon isolation information

Definition at line 154 of file Muon.h.

References isolationR03_.

Referenced by ZToMuMuGammaAnalyzer::analyze(), EwkMuDQM::analyze(), pat::Muon::ecalIso(), MuonVPlusJetsIDSelectionFunctor::fall10Cuts(), WMuNuSelector::filter(), WMuNuValidator::filter(), MuonVPlusJetsIDSelectionFunctor::firstDataCuts(), MuonMETAlgo::GetMuDepDeltas(), pat::Muon::hcalIso(), MuonVPlusJetsIDSelectionFunctor::kitQCDCuts(), EwkMuLumiMonitorDQM::muIso(), ZToMuMuGammaAnalyzer::muonSelection(), MuonVPlusJetsIDSelectionFunctor::spring10Cuts(), MuonVPlusJetsIDSelectionFunctor::summer08Cuts(), and pat::Muon::trackIso().

{ return isolationR03_; }
const MuonIsolation& reco::Muon::isolationR05 ( ) const [inline]

Definition at line 155 of file Muon.h.

References isolationR05_.

Referenced by EwkMuTauHistManager::fillHistograms().

{ return isolationR05_; }
bool reco::Muon::isPFIsolationValid ( ) const [inline]

Definition at line 164 of file Muon.h.

References pfIsolationValid_.

{ return pfIsolationValid_; }
bool reco::Muon::isPFMuon ( ) const [inline]

Definition at line 210 of file Muon.h.

References PFMuon, and type_.

Referenced by muon::isTightMuon(), and MuonProducer::produce().

{return type_ & PFMuon;} //fix me ! Has to go to type
bool reco::Muon::isQualityValid ( ) const [inline]

====================== Quality BLOCK ===========================

energy deposition

Definition at line 115 of file Muon.h.

References qualityValid_.

Referenced by MuonIdProducer::fillTrackerKink(), and muon::isGoodMuon().

{ return qualityValid_; }
bool reco::Muon::isRPCMuon ( ) const [inline]

Definition at line 211 of file Muon.h.

References RPCMuon, and type_.

{return type_ & RPCMuon;}
bool reco::Muon::isStandAloneMuon ( ) const [inline, virtual]

Reimplemented from reco::LeafCandidate.

Definition at line 208 of file Muon.h.

References StandAloneMuon, and type_.

Referenced by MuonRecoAnalyzer::analyze(), HLTMuonMatchAndPlot::analyze(), MuonKinVsEtaAnalyzer::analyze(), EwkMuLumiMonitorDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), AlignmentMuonSelector::basicCuts(), TCMETAlgo::CalculateTCMET(), MuonShowerInformationFiller::fillHitsByStation(), muon::isGoodMuon(), MuonIdProducer::phiOfMuonIneteractionRegion(), ZToLLEdmNtupleDumper::produce(), ZMuMuMuonUserData::produce(), MuonProducer::produce(), and MuonCosmicCompatibilityFiller::pvMatches().

{ return type_ & StandAloneMuon; }
bool reco::Muon::isTimeValid ( ) const [inline]

====================== TIMING BLOCK ===========================

timing information

Definition at line 125 of file Muon.h.

References reco::MuonTime::nDof, and time_.

Referenced by MuonCosmicCompatibilityFiller::muonTiming(), and MuonIdProducer::produce().

{ return (time_.nDof>0); }
bool reco::Muon::isTrackerMuon ( ) const [inline, virtual]

Reimplemented from reco::LeafCandidate.

Definition at line 207 of file Muon.h.

References TrackerMuon, and type_.

Referenced by MuonRecoAnalyzer::analyze(), HLTMuonMatchAndPlot::analyze(), GlbMuQualityCutsAnalysis::analyze(), MuonKinVsEtaAnalyzer::analyze(), EwkMuDQM::analyze(), HiggsDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), AlignmentMuonSelector::basicCuts(), FWMuonBuilder::buildMuon(), TCMETAlgo::CalculateTCMET(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), EwkMuTauHistManager::fillHistograms(), MuonIdProducer::fillMuonId(), WMuNuSelector::filter(), LeptonRecoSkim::filter(), WMuNuValidator::filter(), MuonMETAlgo::GetMuDepDeltas(), cms::MuonTCMETValueMapProducer::isGoodMuon(), muon::isGoodMuon(), FourVectorHLTOffline::isVBTFMuon(), MuonResidualsFromTrack::MuonResidualsFromTrack(), ZToMuMuGammaAnalyzer::muonSelection(), cms::MuonMETValueMapProducer::produce(), ZToLLEdmNtupleDumper::produce(), cms::MuonTCMETValueMapProducer::produce(), ZMuMuMuonUserData::produce(), MuonProducer::produce(), MuonCosmicCompatibilityFiller::pvMatches(), and MuScleFitMuonSelector::selectMuons().

{ return type_ & TrackerMuon; }
std::vector<MuonChamberMatch>& reco::Muon::matches ( ) [inline]

get muon matching information

Definition at line 136 of file Muon.h.

References muMatches_.

Referenced by MuonIdProducer::fillMuonId(), TrackerMuonHitExtractor::getMuonHits(), MuonResidualsFromTrack::MuonResidualsFromTrack(), numberOfChambersNoRPC(), numberOfMatches(), MuonIdProducer::overlap(), muon::overlap(), MuonIdProducer::phiOfMuonIneteractionRegion(), MuonIdProducer::produce(), setMatches(), and MuonIdTruthInfo::truthMatchMuon().

{ return muMatches_;}
const std::vector<MuonChamberMatch>& reco::Muon::matches ( ) const [inline]

Definition at line 137 of file Muon.h.

References muMatches_.

{ return muMatches_;    }
virtual TrackRef reco::Muon::muonBestTrack ( ) const [inline, virtual]

Definition at line 64 of file Muon.h.

References bestTrackType_, and muonTrack().

Referenced by muon::isTightMuon().

{return muonTrack(bestTrackType_);}
virtual MuonTrackType reco::Muon::muonBestTrackType ( ) const [inline, virtual]

Definition at line 65 of file Muon.h.

References bestTrackType_.

{return bestTrackType_;}
TrackRef Muon::muonTrack ( const MuonTrackType &  type) const

Definition at line 764 of file Muon.cc.

References CombinedTrack, DYT, dytTrack(), globalTrack(), innerTrack(), InnerTrack, muonTrackFromMap(), OuterTrack, Picky, pickyTrack(), standAloneMuon(), TPFMS, and tpfmsTrack().

Referenced by bestTrack(), bestTrackRef(), isAValidMuonTrack(), and muonBestTrack().

                                                       {
  switch (type) {
  case InnerTrack:     return innerTrack();
  case OuterTrack:     return standAloneMuon(); 
  case CombinedTrack:  return globalTrack();
  case TPFMS:          return tpfmsTrack();
  case Picky:          return pickyTrack();
  case DYT:            return dytTrack();
  default:             return muonTrackFromMap(type);
  }
}
TrackRef reco::Muon::muonTrackFromMap ( const MuonTrackType &  type) const [inline]

Definition at line 71 of file Muon.h.

References refittedTrackMap_.

Referenced by dytTrack(), muonTrack(), pickyTrack(), and tpfmsTrack().

                                                               {
      MuonTrackRefMap::const_iterator iter = refittedTrackMap_.find(type);
      if (iter != refittedTrackMap_.end()) 
        return iter->second;
      else 
        return TrackRef();
    }
int reco::Muon::numberOfChambers ( ) const [inline]

====================== USEFUL METHODs ===========================

number of chambers (MuonChamberMatches include RPC rolls)

Definition at line 174 of file Muon.h.

References muMatches_.

Referenced by numberOfChambersNoRPC(), ZToLLEdmNtupleDumper::produce(), and ZMuMuMuonUserData::produce().

{ return muMatches_.size(); }
int Muon::numberOfChambersNoRPC ( ) const

number of chambers not including RPC matches (MuonChamberMatches include RPC rolls)

Definition at line 44 of file Muon.cc.

References matches(), numberOfChambers(), MuonSubdetId::RPC, and pileupDistInMC::total.

{
  int total = 0;
  int nAll = numberOfChambers();
  for (int iC = 0; iC < nAll; ++iC){
    if (matches()[iC].detector() == MuonSubdetId::RPC) continue;
    total++;
  }

  return total;
}
int Muon::numberOfMatchedStations ( ArbitrationType  type = SegmentAndTrackArbitration) const

get number of stations with matched segments just adds the bits returned by stationMask

Definition at line 100 of file Muon.cc.

References stationMask(), and mergeVDriftHistosByStation::stations.

Referenced by muon::isTightMuon().

{
   int stations(0);

   unsigned int theStationMask = stationMask(type);
   // eight stations, eight bits
   for(int it = 0; it < 8; ++it)
      if (theStationMask & 1<<it)
         ++stations;

   return stations;
}
int Muon::numberOfMatches ( ArbitrationType  type = SegmentAndTrackArbitration) const

get number of chambers with matched segments

Definition at line 56 of file Muon.cc.

References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInChamberByDR, matches(), muMatches_, NoArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.

Referenced by MuonKinVsEtaAnalyzer::analyze(), EwkMuDQM::analyze(), MuonCosmicCompatibilityFiller::checkMuonSegments(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), MuonVPlusJetsIDSelectionFunctor::fall10Cuts(), MuonIdProducer::fillMuonId(), TrackerMuonHitExtractor::getMuonHits(), muon::isGoodMuon(), MuonIdProducer::isGoodTrackerMuon(), BTagHLTOfflineSource::isVBTFMuon(), FourVectorHLTOffline::isVBTFMuon(), MuonVPlusJetsIDSelectionFunctor::kitQCDCuts(), ZToMuMuGammaAnalyzer::muonSelection(), muon::overlap(), ZToLLEdmNtupleDumper::produce(), ZMuMuMuonUserData::produce(), and PFMuonSelector::spring11Cuts().

{
   int matches(0);
   for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
         chamberMatch != muMatches_.end(); chamberMatch++ )
   {
      if(chamberMatch->segmentMatches.empty()) continue;
      if(type == NoArbitration) {
         matches++;
         continue;
      }

      for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
            segmentMatch != chamberMatch->segmentMatches.end(); segmentMatch++ )
      {
         if(type == SegmentArbitration)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR)) {
               matches++;
               break;
            }
         if(type == SegmentAndTrackArbitration)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
               matches++;
               break;
            }
         if(type == SegmentAndTrackArbitrationCleaned)
           if(segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR) &&
                 segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) && 
                 segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
             matches++;
             break;
           }
         if(type > 1<<7)
            if(segmentMatch->isMask(type)) {
               matches++;
               break;
            }
      }
   }

   return matches;
}
int Muon::numberOfSegments ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

get number of segments

Definition at line 241 of file Muon.cc.

References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInStationByDR, muMatches_, NoArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.

{
   int segments(0);
   for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
         chamberMatch != muMatches_.end(); chamberMatch++ )
   {
      if(chamberMatch->segmentMatches.empty()) continue;
      if(!(chamberMatch->station()==station && chamberMatch->detector()==muonSubdetId)) continue;

      if(type == NoArbitration) {
         segments += chamberMatch->segmentMatches.size();
         continue;
      }

      for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
            segmentMatch != chamberMatch->segmentMatches.end(); segmentMatch++ )
      {
         if(type == SegmentArbitration)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) {
               segments++;
               break;
            }
         if(type == SegmentAndTrackArbitration)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
               segments++;
               break;
            }
         if(type == SegmentAndTrackArbitrationCleaned)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
               segments++;
               break;
            }
         if(type > 1<<7)
            if(segmentMatch->isMask(type)) {
               segments++;
               break;
            }
      }
   }

   return segments;
}
virtual TrackRef reco::Muon::outerTrack ( ) const [inline, virtual]

reference to Track reconstructed in the muon detector only

Reimplemented in pat::Muon.

Definition at line 52 of file Muon.h.

References outerTrack_.

Referenced by HLTMuonMatchAndPlot::analyze(), RPCRecHitProbability::analyze(), CosmicSplitterValidation::analyze(), RPCMonitorDigi::analyze(), MuonEnergyDepositAnalyzer::analyze(), FWMuonBuilder::buildMuon(), FWMuonBuilder::calculateField(), TCMETAlgo::CalculateTCMET(), MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), pat::Muon::embedStandAloneMuon(), MuonShowerInformationFiller::fillHitsByStation(), MuonMETAlgo::GetMuDepDeltas(), CosmicSplitterValidation::is_gold_muon(), muon::isGoodMuon(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), MuonCosmicCompatibilityFiller::muonTiming(), cms::MuonMETValueMapProducer::produce(), MuonCosmicCompatibilityFiller::pvMatches(), and standAloneMuon().

{ return outerTrack_; }
bool Muon::overlap ( const Candidate &  c) const [private, virtual]

check overlap with another candidate

Implements reco::RecoCandidate.

Definition at line 29 of file Muon.cc.

References trackerHits::c, reco::RecoCandidate::checkOverlap(), reco::RecoCandidate::combinedMuon(), combinedMuon(), python::connectstrParser::o, reco::RecoCandidate::standAloneMuon(), standAloneMuon(), reco::RecoCandidate::track(), and track().

                                              {
  const RecoCandidate * o = dynamic_cast<const RecoCandidate *>( & c );
  return ( o != 0 && 
           ( checkOverlap( track(), o->track() ) ||
             checkOverlap( standAloneMuon(), o->standAloneMuon() ) ||
             checkOverlap( combinedMuon(), o->combinedMuon() ) ||
             checkOverlap( standAloneMuon(), o->track() ) ||
             checkOverlap( combinedMuon(), o->track() ) )
           );
}
std::pair< const MuonChamberMatch *, const MuonSegmentMatch * > Muon::pair ( const std::vector< const MuonChamberMatch * > &  chambers,
ArbitrationType  type = SegmentAndTrackArbitration 
) const [private]

get pointers to best segment and corresponding chamber in vector of chambers

Definition at line 297 of file Muon.cc.

References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInStationByDR, m, NoArbitration, alignCSCRings::s, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.

Referenced by dDxDz(), dDyDz(), dX(), dY(), pullDxDz(), pullDyDz(), pullX(), pullY(), segmentDxDz(), segmentDxDzErr(), segmentDyDz(), segmentDyDzErr(), segmentX(), segmentXErr(), segmentY(), segmentYErr(), trackDist(), trackDistErr(), trackDxDz(), trackDxDzErr(), trackDyDz(), trackDyDzErr(), trackEdgeX(), trackEdgeY(), trackX(), trackXErr(), trackY(), and trackYErr().

{
   MuonChamberMatch* m = 0;
   MuonSegmentMatch* s = 0;
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair(m,s);

   if(chambers.empty()) return chamberSegmentPair;
   for( std::vector<const MuonChamberMatch*>::const_iterator chamberMatch = chambers.begin();
         chamberMatch != chambers.end(); chamberMatch++ )
   {
      if((*chamberMatch)->segmentMatches.empty()) continue;
      if(type == NoArbitration)
         return std::make_pair(*chamberMatch, &((*chamberMatch)->segmentMatches.front()));

      for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = (*chamberMatch)->segmentMatches.begin();
            segmentMatch != (*chamberMatch)->segmentMatches.end(); segmentMatch++ )
      {
         if(type == SegmentArbitration)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) 
               return std::make_pair(*chamberMatch, &(*segmentMatch));
         if(type == SegmentAndTrackArbitration)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR))
               return std::make_pair(*chamberMatch, &(*segmentMatch));
         if(type == SegmentAndTrackArbitrationCleaned)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning))
               return std::make_pair(*chamberMatch, &(*segmentMatch));
         if(type > 1<<7)
            if(segmentMatch->isMask(type))
               return std::make_pair(*chamberMatch, &(*segmentMatch));
      }
   }

   return chamberSegmentPair;
}
const MuonPFIsolation& reco::Muon::pfIsolationR03 ( ) const [inline]

Definition at line 157 of file Muon.h.

References pfIsolationR03_.

{ return pfIsolationR03_; }
const MuonPFIsolation& reco::Muon::pfIsolationR04 ( ) const [inline]

Definition at line 158 of file Muon.h.

References pfIsolationR04_.

{ return pfIsolationR04_; }
reco::Candidate::LorentzVector reco::Muon::pfP4 ( ) const [inline]

set reference to PFCandidate

====================== PF BLOCK ===========================

Definition at line 98 of file Muon.h.

References pfP4_.

Referenced by RecoMuonValidator::MuonME::fill(), and MuonProducer::produce().

{return pfP4_;}
virtual TrackRef reco::Muon::pickyTrack ( ) const [inline, virtual]

Reimplemented in pat::Muon.

Definition at line 59 of file Muon.h.

References muonTrackFromMap(), and Picky.

Referenced by muonTrack(), and muon::tevOptimized().

{ return muonTrackFromMap(Picky);}
float Muon::pullDxDz ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration,
bool  includeSegmentError = true 
) const

Definition at line 391 of file Muon.cc.

References chambers(), pair(), funct::pow(), and mathSSE::sqrt().

Referenced by muon::isGoodMuon().

{
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasPhi()) return 999999;
   if(includeSegmentError)
      return (chamberSegmentPair.first->dXdZ-chamberSegmentPair.second->dXdZ)/sqrt(pow(chamberSegmentPair.first->dXdZErr,2)+pow(chamberSegmentPair.second->dXdZErr,2));
   return (chamberSegmentPair.first->dXdZ-chamberSegmentPair.second->dXdZ)/chamberSegmentPair.first->dXdZErr;
}
float Muon::pullDyDz ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration,
bool  includeSegmentError = true 
) const

Definition at line 401 of file Muon.cc.

References chambers(), MuonSubdetId::DT, pair(), funct::pow(), and mathSSE::sqrt().

Referenced by muon::isGoodMuon().

{
   if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasZed()) return 999999;
   if(includeSegmentError)
      return (chamberSegmentPair.first->dYdZ-chamberSegmentPair.second->dYdZ)/sqrt(pow(chamberSegmentPair.first->dYdZErr,2)+pow(chamberSegmentPair.second->dYdZErr,2));
   return (chamberSegmentPair.first->dYdZ-chamberSegmentPair.second->dYdZ)/chamberSegmentPair.first->dYdZErr;
}
float Muon::pullX ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration,
bool  includeSegmentError = true 
) const

Definition at line 370 of file Muon.cc.

References chambers(), pair(), funct::pow(), and mathSSE::sqrt().

Referenced by muon::isGoodMuon(), and muon::segmentCompatibility().

{
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasPhi()) return 999999;
   if(includeSegmentError)
      return (chamberSegmentPair.first->x-chamberSegmentPair.second->x)/sqrt(pow(chamberSegmentPair.first->xErr,2)+pow(chamberSegmentPair.second->xErr,2));
   return (chamberSegmentPair.first->x-chamberSegmentPair.second->x)/chamberSegmentPair.first->xErr;
}
float Muon::pullY ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration,
bool  includeSegmentError = true 
) const

Definition at line 380 of file Muon.cc.

References chambers(), MuonSubdetId::DT, pair(), funct::pow(), and mathSSE::sqrt().

Referenced by muon::isGoodMuon(), and muon::segmentCompatibility().

{
   if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasZed()) return 999999;
   if(includeSegmentError)
      return (chamberSegmentPair.first->y-chamberSegmentPair.second->y)/sqrt(pow(chamberSegmentPair.first->yErr,2)+pow(chamberSegmentPair.second->yErr,2));
   return (chamberSegmentPair.first->y-chamberSegmentPair.second->y)/chamberSegmentPair.first->yErr;
}
float Muon::segmentDxDz ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 429 of file Muon.cc.

References chambers(), and pair().

{
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasPhi()) return 999999;
   return chamberSegmentPair.second->dXdZ;
}
float Muon::segmentDxDzErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 463 of file Muon.cc.

References chambers(), and pair().

{
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasPhi()) return 999999;
   return chamberSegmentPair.second->dXdZErr;
}
float Muon::segmentDyDz ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 437 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

{
   if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasZed()) return 999999;
   return chamberSegmentPair.second->dYdZ;
}
float Muon::segmentDyDzErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 471 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

{
   if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasZed()) return 999999;
   return chamberSegmentPair.second->dYdZErr;
}
float Muon::segmentX ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

get (best) segment information If no segment returns 999999

Definition at line 412 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::segmentCompatibility().

{
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasPhi()) return 999999;
   return chamberSegmentPair.second->x;
}
float Muon::segmentXErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 446 of file Muon.cc.

References chambers(), and pair().

{
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasPhi()) return 999999;
   return chamberSegmentPair.second->xErr;
}
float Muon::segmentY ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 420 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

{
   if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasZed()) return 999999;
   return chamberSegmentPair.second->y;
}
float Muon::segmentYErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 454 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

{
   if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
   if(! chamberSegmentPair.second->hasZed()) return 999999;
   return chamberSegmentPair.second->yErr;
}
virtual void reco::Muon::setBestTrack ( MuonTrackType  muonType) [inline, virtual]

Definition at line 89 of file Muon.h.

References bestTrackType_.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack().

{bestTrackType_ = muonType;}
void reco::Muon::setCalEnergy ( const MuonEnergy &  calEnergy) [inline]

set energy deposition information

Definition at line 109 of file Muon.h.

References calEnergy(), calEnergy_, and energyValid_.

Referenced by MuonIdProducer::fillMuonId(), and CaloMuonMerger::produce().

{ calEnergy_ = calEnergy; energyValid_ = true; }
void reco::Muon::setCaloCompatibility ( float  input) [inline]

Definition at line 147 of file Muon.h.

References caloCompatibility_, and collect_tpl::input.

Referenced by CaloMuonMerger::produce().

{ caloCompatibility_ = input; }
void Muon::setCombined ( const TrackRef &  t) [virtual]

Definition at line 757 of file Muon.cc.

References setGlobalTrack().

Referenced by GlobalMuonToMuonProducer::produce().

{ setGlobalTrack(t); }
void reco::Muon::setCombinedQuality ( const MuonQuality &  combinedQuality) [inline]

set energy deposition information

Definition at line 119 of file Muon.h.

References combinedQuality(), combinedQuality_, and qualityValid_.

Referenced by MuonIdProducer::fillGlbQuality(), and MuonIdProducer::fillTrackerKink().

{ combinedQuality_ = combinedQuality; qualityValid_ = true; }
void Muon::setGlobalTrack ( const TrackRef &  t) [virtual]

set reference to Track

Definition at line 756 of file Muon.cc.

References globalTrack_, and lumiQTWidget::t.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonsFromRefitTracksProducer::produce(), setCombined(), and setMuonTrack().

{ globalTrack_ = t; }
void Muon::setInnerTrack ( const TrackRef &  t) [virtual]

set reference to Track

Definition at line 753 of file Muon.cc.

References innerTrack_, and lumiQTWidget::t.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonsFromRefitTracksProducer::produce(), CaloMuonMerger::produce(), UpdatedMuonInnerTrackRef::produce(), setMuonTrack(), and setTrack().

{ innerTrack_ = t; }
void Muon::setIsolation ( const MuonIsolation &  isoR03,
const MuonIsolation &  isoR05 
)

Definition at line 728 of file Muon.cc.

References isolationR03_, isolationR05_, and isolationValid_.

Referenced by MuonIdProducer::fillMuonIsolation(), and MuonWithPFIsoProducer::produce().

{ 
   isolationR03_ = isoR03;
   isolationR05_ = isoR05;
   isolationValid_ = true; 
}
void reco::Muon::setMatches ( const std::vector< MuonChamberMatch > &  matches) [inline]

set muon matching information

Definition at line 139 of file Muon.h.

References matches(), matchesValid_, and muMatches_.

Referenced by MuonIdProducer::fillMuonId().

{ muMatches_ = matches; matchesValid_ = true; }
void Muon::setMuonTrack ( const MuonTrackType &  type,
const TrackRef &  t 
)

Definition at line 776 of file Muon.cc.

References CombinedTrack, InnerTrack, OuterTrack, refittedTrackMap_, setGlobalTrack(), setInnerTrack(), setStandAlone(), lumiQTWidget::t, and type().

Referenced by MuonIdProducer::makeMuon().

                                                                    {
  
  switch (type) {
  case InnerTrack:    setInnerTrack(t);             break;
  case OuterTrack:    setStandAlone(t);             break;
  case CombinedTrack: setGlobalTrack(t);            break;
  default:            refittedTrackMap_[type] = t;  break;
  }

}
void Muon::setOuterTrack ( const TrackRef &  t) [virtual]

set reference to Track

Definition at line 752 of file Muon.cc.

References outerTrack_, and lumiQTWidget::t.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonsFromRefitTracksProducer::produce(), and setStandAlone().

{ outerTrack_ = t; }
void Muon::setPFIsolation ( const MuonPFIsolation &  isoR03,
const MuonPFIsolation &  isoR04 
)

Definition at line 736 of file Muon.cc.

References pfIsolationR03_, pfIsolationR04_, and pfIsolationValid_.

Referenced by MuPFIsoHelper::embedPFIsolation().

{ 
   pfIsolationR03_ = isoR03;
   pfIsolationR04_ = isoR04;
   pfIsolationValid_ = true; 
}
void Muon::setPFP4 ( const reco::Candidate::LorentzVector &  p4_) [virtual]

Definition at line 744 of file Muon.cc.

References reco::LeafCandidate::p4(), PFMuon, pfP4_, and type_.

Referenced by MuonProducer::produce().

{ 
    pfP4_ = p4;
    type_ = type_ | PFMuon;
}
void Muon::setStandAlone ( const TrackRef &  t) [virtual]

Definition at line 755 of file Muon.cc.

References setOuterTrack().

Referenced by GlobalMuonToMuonProducer::produce(), and setMuonTrack().

{ setOuterTrack(t); }
void reco::Muon::setTime ( const MuonTime &  time) [inline]

set timing information

Definition at line 129 of file Muon.h.

References time(), and time_.

{ time_ = time; }
void Muon::setTrack ( const TrackRef &  t) [virtual]

Definition at line 754 of file Muon.cc.

References setInnerTrack().

Referenced by GlobalMuonToMuonProducer::produce().

{ setInnerTrack(t); }
void reco::Muon::setType ( unsigned int  type) [inline]

Definition at line 202 of file Muon.h.

References type(), and type_.

Referenced by CaloMuonMerger::produce(), and MuonIdProducer::produce().

{ type_ = type; }
virtual TrackRef reco::Muon::standAloneMuon ( ) const [inline, virtual]

reference to a stand-alone muon Track

Reimplemented from reco::RecoCandidate.

Reimplemented in pat::Muon.

Definition at line 53 of file Muon.h.

References outerTrack().

Referenced by MuonRecoAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), ZMuMuPerformances::analyze(), AlignmentMuonSelector::basicCuts(), FWMuonLegoProxyBuilder::build(), MuonCaloCompatibility::evaluate(), MuonIdProducer::fillMuonId(), MuonIdProducer::fillMuonIsolation(), MuonTimingFiller::fillTiming(), muonTrack(), overlap(), MuonIdProducer::phiOfMuonIneteractionRegion(), helper::MuonCollectionStoreManager::processMuon(), and MuonCosmicCompatibilityFiller::pvMatches().

{ return outerTrack(); }
unsigned int Muon::stationGapMaskDistance ( float  distanceCut = 10.) const

get bit map of stations with tracks within given distance (in cm) of chamber edges bit assignments are same as above

Definition at line 173 of file Muon.cc.

References muMatches_, and plotscripts::stationIndex().

{
   unsigned int totMask(0);
   for( int stationIndex = 1; stationIndex < 5; stationIndex++ )
   {
      for( int detectorIndex = 1; detectorIndex < 4; detectorIndex++ )
      {
         unsigned int curMask(0);
         for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
               chamberMatch != muMatches_.end(); chamberMatch++ )
         {
            if(!(chamberMatch->station()==stationIndex && chamberMatch->detector()==detectorIndex)) continue;

            float edgeX = chamberMatch->edgeX;
            float edgeY = chamberMatch->edgeY;
            if(edgeX<0 && fabs(edgeX)>fabs(distanceCut) &&
                  edgeY<0 && fabs(edgeY)>fabs(distanceCut)) // inside the chamber so negates all gaps for this station
            {
               curMask = 0;
               break;
            }
            if( ( fabs(edgeX) < fabs(distanceCut) && edgeY < fabs(distanceCut) ) ||
                ( fabs(edgeY) < fabs(distanceCut) && edgeX < fabs(distanceCut) ) ) // inside gap
               curMask = 1<<( (stationIndex-1)+4*(detectorIndex-1) );
         }

         totMask += curMask; // add to total mask
      }
   }

   return totMask;
}
unsigned int Muon::stationGapMaskPull ( float  sigmaCut = 3.) const

same as above for given number of sigmas

Definition at line 206 of file Muon.cc.

References muMatches_, and plotscripts::stationIndex().

{
   unsigned int totMask(0);
   for( int stationIndex = 1; stationIndex < 5; stationIndex++ )
   {
      for( int detectorIndex = 1; detectorIndex < 4; detectorIndex++ )
      {
         unsigned int curMask(0);
         for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
               chamberMatch != muMatches_.end(); chamberMatch++ )
         {
            if(!(chamberMatch->station()==stationIndex && chamberMatch->detector()==detectorIndex)) continue;

            float edgeX = chamberMatch->edgeX;
            float edgeY = chamberMatch->edgeY;
            float xErr  = chamberMatch->xErr+0.000001; // protect against division by zero later
            float yErr  = chamberMatch->yErr+0.000001; // protect against division by zero later
            if(edgeX<0 && fabs(edgeX/xErr)>fabs(sigmaCut) &&
                  edgeY<0 && fabs(edgeY/yErr)>fabs(sigmaCut)) // inside the chamber so negates all gaps for this station
            {
               curMask = 0;
               break;
            }
            if( ( fabs(edgeX/xErr) < fabs(sigmaCut) && edgeY/yErr < fabs(sigmaCut) ) ||
                ( fabs(edgeY/yErr) < fabs(sigmaCut) && edgeX/xErr < fabs(sigmaCut) ) ) // inside gap
               curMask = 1<<((stationIndex-1)+4*(detectorIndex-1));
         }

         totMask += curMask; // add to total mask
      }
   }

   return totMask;
}
unsigned int Muon::stationMask ( ArbitrationType  type = SegmentAndTrackArbitration) const

get bit map of stations with matched segments bits 0-1-2-3 = DT stations 1-2-3-4 bits 4-5-6-7 = CSC stations 1-2-3-4

Definition at line 113 of file Muon.cc.

References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInStationByDR, muMatches_, NoArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.

Referenced by muon::isGoodMuon(), and numberOfMatchedStations().

{
   unsigned int totMask(0);
   unsigned int curMask(0);
   for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
         chamberMatch != muMatches_.end(); chamberMatch++ )
   {
      if(chamberMatch->segmentMatches.empty()) continue;
      if(type == NoArbitration) {
         curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
         // do not double count
         if(!(totMask & curMask))
            totMask += curMask;
         continue;
      }

      for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
            segmentMatch != chamberMatch->segmentMatches.end(); segmentMatch++ )
      {
         if(type == SegmentArbitration)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) {
               curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
               // do not double count
               if(!(totMask & curMask))
                  totMask += curMask;
               break;
            }
         if(type == SegmentAndTrackArbitration)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
               curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
               // do not double count
               if(!(totMask & curMask))
                  totMask += curMask;
               break;
            }
         if(type == SegmentAndTrackArbitrationCleaned)
            if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
                  segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
               curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
               // do not double count
               if(!(totMask & curMask))
                  totMask += curMask;
               break;
            }
         if(type > 1<<7)
            if(segmentMatch->isMask(type)) {
               curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
               // do not double count
               if(!(totMask & curMask))
                  totMask += curMask;
               break;
            }
      }
   }

   return totMask;
}
float reco::Muon::t0 ( int  n = 0) [inline]

Definition at line 304 of file Muon.h.

References i, muMatches_, and n.

                       {
        int i = 0;
        for( std::vector<MuonChamberMatch>::const_iterator chamber = muMatches_.begin();
             chamber != muMatches_.end(); ++chamber )
          for ( std::vector<reco::MuonSegmentMatch>::const_iterator segment = chamber->segmentMatches.begin();
                segment != chamber->segmentMatches.end(); ++segment )
            {
               if (i==n) return segment->t0;
               ++i;
            }
        return 0;
     }
MuonTime reco::Muon::time ( ) const [inline]

get timing information

Definition at line 127 of file Muon.h.

References time_.

Referenced by MuonCosmicCompatibilityFiller::muonTiming(), MuonIdProducer::produce(), and setTime().

{ return time_; }
virtual TrackRef reco::Muon::tpfmsTrack ( ) const [inline, virtual]

Reimplemented in pat::Muon.

Definition at line 58 of file Muon.h.

References muonTrackFromMap(), and TPFMS.

Referenced by muonTrack(), and muon::tevOptimized().

{ return muonTrackFromMap(TPFMS);}
virtual TrackRef reco::Muon::track ( void  ) const [inline, virtual]

reference to a Track

Reimplemented from reco::RecoCandidate.

Reimplemented in pat::Muon.

Definition at line 50 of file Muon.h.

References innerTrack().

Referenced by MuonRecoAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), ZMuMuPerformances::analyze(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), AlignmentMuonSelector::basicCuts(), FWMuonLegoProxyBuilder::build(), MuonCaloCompatibility::evaluate(), RecoMuonValidator::MuonME::fill(), MuonIdProducer::fillMuonId(), MuonIdProducer::fillMuonIsolation(), MuonIdProducer::isGoodTrackerMuon(), ZToMuMuGammaAnalyzer::muonSelection(), overlap(), helper::MuonCollectionStoreManager::processMuon(), CaloMuonMerger::produce(), MuonCosmicCompatibilityFiller::pvMatches(), muon::tevOptimized(), and MuonIdTruthInfo::truthMatchMuon().

{ return innerTrack(); }
float Muon::trackDist ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 690 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::RequiredStationMask(), and muon::segmentCompatibility().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) dist  = currDist;
      }
      return dist;
   } else return chamberSegmentPair.first->dist();
}
float Muon::trackDistErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 707 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::RequiredStationMask().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->distErr();
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->distErr();
}
float Muon::trackDxDz ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 564 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->dXdZ;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->dXdZ;
}
float Muon::trackDxDzErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 648 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->dXdZErr;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->dXdZErr;
}
float Muon::trackDyDz ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 585 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->dYdZ;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->dYdZ;
}
float Muon::trackDyDzErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 669 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->dYdZErr;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->dYdZErr;
}
float Muon::trackEdgeX ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

get track information in chamber that contains (best) segment If no segment, get track information in chamber that has the most negative distance between the track and the nearest chamber edge (the chamber with the deepest track) If no chamber returns 999999

Definition at line 480 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->edgeX;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->edgeX;
}
float Muon::trackEdgeY ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 501 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->edgeY;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->edgeY;
}
float Muon::trackX ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 522 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->x;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->x;
}
float Muon::trackXErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 606 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->xErr;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->xErr;
}
float Muon::trackY ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 543 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->y;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->y;
}
float Muon::trackYErr ( int  station,
int  muonSubdetId,
ArbitrationType  type = SegmentAndTrackArbitration 
) const

Definition at line 627 of file Muon.cc.

References chambers(), and pair().

{
   const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
   if(muonChambers.empty()) return 999999;

   std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
   if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
      float dist  = 999999;
      float supVar = 999999;
      for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
            muonChamber != muonChambers.end(); ++muonChamber) {
         float currDist = (*muonChamber)->dist();
         if(currDist<dist) {
            dist  = currDist;
            supVar = (*muonChamber)->yErr;
         }
      }
      return supVar;
   } else return chamberSegmentPair.first->yErr;
}
unsigned int reco::Muon::type ( ) const [inline]

Definition at line 203 of file Muon.h.

References type_.

Referenced by CaloMuonMerger::produce(), pat::Muon::setDB(), setMuonTrack(), and setType().

{ return type_; }

Member Data Documentation

MuonTrackType reco::Muon::bestTrackType_ [private]

reference to the Track chosen to assign the momentum value to the muon

Definition at line 225 of file Muon.h.

Referenced by bestTrack(), bestTrackRef(), Muon(), muonBestTrack(), muonBestTrackType(), and setBestTrack().

MuonEnergy reco::Muon::calEnergy_ [private]

energy deposition

Definition at line 228 of file Muon.h.

Referenced by calEnergy(), and setCalEnergy().

float reco::Muon::caloCompatibility_ [private]

muon hypothesis compatibility with observer calorimeter energy

Definition at line 241 of file Muon.h.

Referenced by caloCompatibility(), isCaloCompatibilityValid(), Muon(), and setCaloCompatibility().

const unsigned int reco::Muon::CaloMuon = 1<<4 [static]

Definition at line 198 of file Muon.h.

Referenced by isCaloMuon(), and CaloMuonMerger::produce().

MuonQuality reco::Muon::combinedQuality_ [private]

quality block

Definition at line 230 of file Muon.h.

Referenced by combinedQuality(), and setCombinedQuality().

bool reco::Muon::energyValid_ [private]

Definition at line 235 of file Muon.h.

Referenced by isEnergyValid(), Muon(), and setCalEnergy().

const unsigned int reco::Muon::GlobalMuon = 1<<1 [static]

muon type - type of the algorithm that reconstructed this muon multiple algorithms can reconstruct the same muon

Definition at line 195 of file Muon.h.

Referenced by isGlobalMuon(), and MuonIdProducer::produce().

TrackRef reco::Muon::globalTrack_ [private]

reference to Track reconstructed in both tracked and muon detector

Definition at line 221 of file Muon.h.

Referenced by globalTrack(), and setGlobalTrack().

TrackRef reco::Muon::innerTrack_ [private]

reference to Track reconstructed in the tracker only

Definition at line 217 of file Muon.h.

Referenced by innerTrack(), and setInnerTrack().

MuonIsolation reco::Muon::isolationR03_ [private]

Isolation information for two cones with dR=0.3 and dR=0.5.

Definition at line 243 of file Muon.h.

Referenced by isolationR03(), and setIsolation().

MuonIsolation reco::Muon::isolationR05_ [private]

Definition at line 244 of file Muon.h.

Referenced by isolationR05(), and setIsolation().

bool reco::Muon::isolationValid_ [private]

Definition at line 237 of file Muon.h.

Referenced by isIsolationValid(), Muon(), and setIsolation().

bool reco::Muon::matchesValid_ [private]

Definition at line 236 of file Muon.h.

Referenced by isMatchesValid(), Muon(), and setMatches().

std::vector<MuonChamberMatch> reco::Muon::muMatches_ [private]

Information on matching between tracks and segments.

Definition at line 232 of file Muon.h.

Referenced by chambers(), matches(), numberOfChambers(), numberOfMatches(), numberOfSegments(), setMatches(), stationGapMaskDistance(), stationGapMaskPull(), stationMask(), and t0().

TrackRef reco::Muon::outerTrack_ [private]

reference to Track reconstructed in the muon detector only

Definition at line 219 of file Muon.h.

Referenced by outerTrack(), and setOuterTrack().

MuonPFIsolation reco::Muon::pfIsolationR03_ [private]

PF Isolation information for two cones with dR=0.3 and dR=0.4.

Definition at line 247 of file Muon.h.

Referenced by pfIsolationR03(), and setPFIsolation().

MuonPFIsolation reco::Muon::pfIsolationR04_ [private]

Definition at line 248 of file Muon.h.

Referenced by pfIsolationR04(), and setPFIsolation().

bool reco::Muon::pfIsolationValid_ [private]

Definition at line 238 of file Muon.h.

Referenced by isPFIsolationValid(), Muon(), and setPFIsolation().

const unsigned int reco::Muon::PFMuon = 1<<5 [static]

Definition at line 199 of file Muon.h.

Referenced by isPFMuon(), and setPFP4().

reco::Candidate::LorentzVector reco::Muon::pfP4_ [private]

Definition at line 254 of file Muon.h.

Referenced by pfP4(), and setPFP4().

bool reco::Muon::qualityValid_ [private]

Definition at line 239 of file Muon.h.

Referenced by isQualityValid(), Muon(), and setCombinedQuality().

MuonTrackRefMap reco::Muon::refittedTrackMap_ [private]

reference to the Global Track refitted with dedicated TeV reconstructors

Definition at line 223 of file Muon.h.

Referenced by muonTrackFromMap(), and setMuonTrack().

const unsigned int reco::Muon::RPCMuon = 1<<6 [static]

Definition at line 200 of file Muon.h.

Referenced by isRPCMuon().

const unsigned int reco::Muon::StandAloneMuon = 1<<3 [static]

Definition at line 197 of file Muon.h.

Referenced by isStandAloneMuon(), and MuonIdProducer::produce().

MuonTime reco::Muon::time_ [private]

timing

Definition at line 234 of file Muon.h.

Referenced by isTimeValid(), setTime(), and time().

const unsigned int reco::Muon::TrackerMuon = 1<<2 [static]

Definition at line 196 of file Muon.h.

Referenced by isTrackerMuon(), and MuonIdProducer::produce().

unsigned int reco::Muon::type_ [private]

muon type mask

Definition at line 251 of file Muon.h.

Referenced by pat::Muon::dB(), pat::Muon::edB(), isCaloMuon(), isGlobalMuon(), isPFMuon(), isRPCMuon(), isStandAloneMuon(), isTrackerMuon(), Muon(), setPFP4(), setType(), and type().

Generated for CMSSW Reference Manual by doxygen 1.7.3