|
|
|
#include <DataFormats/MuonReco/interface/Muon.h>
Public Types | |
| enum | ArbitrationType { NoArbitration, SegmentArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, RPCHitAndTrackArbitration } |
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 | numberOfMatchedRPCLayers (ArbitrationType type=RPCHitAndTrackArbitration) const |
| 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 |
| const MuonPFIsolation & | pfMeanDRIsoProfileR03 () const |
| const MuonPFIsolation & | pfMeanDRIsoProfileR04 () const |
| reco::Candidate::LorentzVector | pfP4 () const |
| const MuonPFIsolation & | pfSumDRIsoProfileR03 () const |
| const MuonPFIsolation & | pfSumDRIsoProfileR04 () 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 |
| unsigned int | RPClayerMask (ArbitrationType type=RPCHitAndTrackArbitration) 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 std::string &label, const reco::MuonPFIsolation &deposit) |
| 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_ |
| MuonPFIsolation | pfIsoMeanDRR03_ |
| MuonPFIsolation | pfIsoMeanDRR04_ |
| MuonPFIsolation | pfIsoSumDRR03_ |
| MuonPFIsolation | pfIsoSumDRR04_ |
| 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 | |
A reconstructed Muon. contains reference to three fits:
| typedef std::map<MuonTrackType, reco::TrackRef> reco::Muon::MuonTrackRefMap |
| typedef std::pair<TrackRef, Muon::MuonTrackType> reco::Muon::MuonTrackTypePair |
map for Global Muon refitters
Definition at line 39 of file Muon.h.
{None, InnerTrack, OuterTrack, CombinedTrack, TPFMS, Picky, DYT};
| Muon::Muon | ( | ) |
Reimplemented in pat::Muon.
Definition at line 19 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 7 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; }
| 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().
Referenced by muon::isHighPtMuon().
{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 361 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 41 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 427 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 435 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 410 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 418 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(), muon::isHighPtMuon(), 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(), muon::isHighPtMuon(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), muon::isSoftMuon(), muon::isTightMuon(), BTagHLTOfflineSource::isVBTFMuon(), FourVectorHLTOffline::isVBTFMuon(), MuonIdProducer::makeCaloMuon(), MuonResidualsFromTrack::MuonResidualsFromTrack(), muonTrack(), MuonIdProducer::phiOfMuonIneteractionRegion(), helper::MuonCollectionStoreManager::processMuon(), OutsideInMuonSeeder::produce(), 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 850 of file Muon.cc.
References edm::Ref< C, T, F >::isNonnull(), and muonTrack().
Referenced by pat::PATMuonProducer::fillMuon().
| 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 217 of file Muon.h.
References CaloMuon, and type_.
Referenced by MuonRecoAnalyzer::analyze(), TCMETAlgo::CalculateTCMET(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), and cms::MuonTCMETValueMapProducer::produce().
| 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 214 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(), muon::isHighPtMuon(), muon::isLooseMuon(), 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 166 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] |
| 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] |
| bool reco::Muon::isPFMuon | ( | ) | const [inline] |
Definition at line 218 of file Muon.h.
Referenced by muon::isLooseMuon(), muon::isTightMuon(), and MuonProducer::produce().
| 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 219 of file Muon.h.
References RPCMuon, and type_.
Referenced by MuonIdProducer::fillMuonId(), and muon::isGoodMuon().
| bool reco::Muon::isStandAloneMuon | ( | ) | const [inline, virtual] |
Reimplemented from reco::LeafCandidate.
Definition at line 216 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 215 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(), muon::isLooseMuon(), 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; }
| const std::vector<MuonChamberMatch>& reco::Muon::matches | ( | ) | const [inline] |
| 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(), muon::isGoodMuon(), MuonResidualsFromTrack::MuonResidualsFromTrack(), numberOfChambersNoRPC(), numberOfMatches(), MuonIdProducer::overlap(), muon::overlap(), MuonIdProducer::phiOfMuonIneteractionRegion(), MuonIdProducer::produce(), setMatches(), muon::sharedSegments(), and MuonIdTruthInfo::truthMatchMuon().
{ return muMatches_;}
| virtual TrackRef reco::Muon::muonBestTrack | ( | ) | const [inline, virtual] |
Definition at line 64 of file Muon.h.
References bestTrackType_, and muonTrack().
Referenced by pat::Muon::embedMuonBestTrack(), muon::isHighPtMuon(), and muon::isTightMuon().
{return muonTrack(bestTrackType_);}
| virtual MuonTrackType reco::Muon::muonBestTrackType | ( | ) | const [inline, virtual] |
| TrackRef Muon::muonTrack | ( | const MuonTrackType & | type | ) | const |
Definition at line 854 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 180 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 45 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::numberOfMatchedRPCLayers | ( | ArbitrationType | type = RPCHitAndTrackArbitration | ) | 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 200 of file Muon.cc.
References RPClayerMask().
Referenced by MuonIdProducer::isGoodRPCMuon().
{
int layers(0);
unsigned int theRPCLayerMask = RPClayerMask(type);
// maximum ten layers because of 6 layers in barrel and 3 (4) layers in each endcap before (after) upscope
for(int it = 0; it < 10; ++it)
if (theRPCLayerMask & 1<<it)
++layers;
return layers;
}
| int Muon::numberOfMatchedStations | ( | ArbitrationType | type = SegmentAndTrackArbitration | ) | const |
get number of stations with matched segments just adds the bits returned by stationMask
Definition at line 107 of file Muon.cc.
References stationMask(), and mergeVDriftHistosByStation::stations.
Referenced by muon::isHighPtMuon(), and 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 57 of file Muon.cc.
References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInChamberByDR, matches(), muMatches_, NoArbitration, RPCHitAndTrackArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.
Referenced by 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(type == RPCHitAndTrackArbitration) {
if(chamberMatch->rpcMatches.empty()) continue;
matches += chamberMatch->rpcMatches.size();
continue;
}
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 315 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(), OutsideInMuonSeeder::produce(), 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 30 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 371 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] |
| const MuonPFIsolation& reco::Muon::pfIsolationR04 | ( | ) | const [inline] |
| const MuonPFIsolation& reco::Muon::pfMeanDRIsoProfileR03 | ( | ) | const [inline] |
| const MuonPFIsolation& reco::Muon::pfMeanDRIsoProfileR04 | ( | ) | const [inline] |
| 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_;}
| const MuonPFIsolation& reco::Muon::pfSumDRIsoProfileR03 | ( | ) | const [inline] |
| const MuonPFIsolation& reco::Muon::pfSumDRIsoProfileR04 | ( | ) | const [inline] |
| 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 465 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 475 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 444 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 454 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;
}
| unsigned int Muon::RPClayerMask | ( | ArbitrationType | type = RPCHitAndTrackArbitration | ) | const |
Definition at line 213 of file Muon.cc.
References RPCDetId::layer(), muMatches_, DetId::rawId(), and RPCDetId::region().
Referenced by numberOfMatchedRPCLayers().
{
unsigned int totMask(0);
unsigned int curMask(0);
for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
chamberMatch != muMatches_.end(); chamberMatch++ )
{
if(chamberMatch->rpcMatches.empty()) continue;
RPCDetId rollId = chamberMatch->id.rawId();
const int region = rollId.region();
const int layer = rollId.layer();
int rpcLayer = chamberMatch->station();
if (region==0) {
rpcLayer = chamberMatch->station()-1 + chamberMatch->station()*layer;
if ((chamberMatch->station()==2 && layer==2) || (chamberMatch->station()==4 && layer==1)) rpcLayer -= 1;
} else rpcLayer += 6;
for( std::vector<MuonRPCHitMatch>::const_iterator rpcMatch = chamberMatch->rpcMatches.begin();
rpcMatch != chamberMatch->rpcMatches.end(); rpcMatch++ )
{
curMask = 1<<(rpcLayer-1);
// do not double count
if(!(totMask & curMask))
totMask += curMask;
}
}
return totMask;
}
| float Muon::segmentDxDz | ( | int | station, |
| int | muonSubdetId, | ||
| ArbitrationType | type = SegmentAndTrackArbitration |
||
| ) | const |
Definition at line 503 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 537 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 511 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 545 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 486 of file Muon.cc.
References chambers(), and pair().
Referenced by muon::segmentCompatibility().
| float Muon::segmentXErr | ( | int | station, |
| int | muonSubdetId, | ||
| ArbitrationType | type = SegmentAndTrackArbitration |
||
| ) | const |
Definition at line 520 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 494 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 528 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(), and MuonIdProducer::makeMuon().
{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 LaserDQM_cfg::input.
Referenced by CaloMuonMerger::produce().
{ caloCompatibility_ = input; }
| void Muon::setCombined | ( | const TrackRef & | t | ) | [virtual] |
Definition at line 847 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 846 of file Muon.cc.
References globalTrack_, and lumiQTWidget::t.
Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonIdProducer::makeMuon(), MuonsFromRefitTracksProducer::produce(), setCombined(), and setMuonTrack().
{ globalTrack_ = t; }
| void Muon::setInnerTrack | ( | const TrackRef & | t | ) | [virtual] |
set reference to Track
Definition at line 843 of file Muon.cc.
References innerTrack_, and lumiQTWidget::t.
Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonIdProducer::makeMuon(), MuonsFromRefitTracksProducer::produce(), CaloMuonMerger::produce(), UpdatedMuonInnerTrackRef::produce(), setMuonTrack(), and setTrack().
{ innerTrack_ = t; }
| void Muon::setIsolation | ( | const MuonIsolation & | isoR03, |
| const MuonIsolation & | isoR05 | ||
| ) |
Definition at line 802 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 866 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 842 of file Muon.cc.
References outerTrack_, and lumiQTWidget::t.
Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonIdProducer::makeMuon(), MuonsFromRefitTracksProducer::produce(), and setStandAlone().
{ outerTrack_ = t; }
| void Muon::setPFIsolation | ( | const std::string & | label, |
| const reco::MuonPFIsolation & | deposit | ||
| ) |
Definition at line 810 of file Muon.cc.
References pfIsolationR03_, pfIsolationR04_, pfIsolationValid_, pfIsoMeanDRR03_, pfIsoMeanDRR04_, pfIsoSumDRR03_, and pfIsoSumDRR04_.
Referenced by MuPFIsoHelper::embedPFIsolation().
{
if(label=="pfIsolationR03")
pfIsolationR03_ = deposit;
if(label=="pfIsolationR04")
pfIsolationR04_ = deposit;
if(label=="pfIsoMeanDRProfileR03")
pfIsoMeanDRR03_ = deposit;
if(label=="pfIsoMeanDRProfileR04")
pfIsoMeanDRR04_ = deposit;
if(label=="pfIsoSumDRProfileR03")
pfIsoSumDRR03_ = deposit;
if(label=="pfIsoSumDRProfileR04")
pfIsoSumDRR04_ = deposit;
pfIsolationValid_ = true;
}
| void Muon::setPFP4 | ( | const reco::Candidate::LorentzVector & | p4_ | ) | [virtual] |
| void Muon::setStandAlone | ( | const TrackRef & | t | ) | [virtual] |
Definition at line 845 of file Muon.cc.
References setOuterTrack().
Referenced by GlobalMuonToMuonProducer::produce(), and setMuonTrack().
{ setOuterTrack(t); }
| void reco::Muon::setTime | ( | const MuonTime & | time | ) | [inline] |
| void Muon::setTrack | ( | const TrackRef & | t | ) | [virtual] |
Definition at line 844 of file Muon.cc.
References setInnerTrack().
Referenced by GlobalMuonToMuonProducer::produce().
{ setInnerTrack(t); }
| void reco::Muon::setType | ( | unsigned int | type | ) | [inline] |
Definition at line 210 of file Muon.h.
Referenced by CaloMuonMerger::produce(), and MuonIdProducer::produce().
| 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 |
Definition at line 247 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 280 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 120 of file Muon.cc.
References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInStationByDR, muMatches_, NoArbitration, DetId::rawId(), RPCDetId::region(), RPCHitAndTrackArbitration, 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(type == RPCHitAndTrackArbitration) {
if(chamberMatch->rpcMatches.empty()) continue;
RPCDetId rollId = chamberMatch->id.rawId();
const int region = rollId.region();
int rpcIndex = 1; if (region!=0) rpcIndex = 2;
for( std::vector<MuonRPCHitMatch>::const_iterator rpcMatch = chamberMatch->rpcMatches.begin();
rpcMatch != chamberMatch->rpcMatches.end(); rpcMatch++ )
{
curMask = 1<<( (chamberMatch->station()-1)+4*(rpcIndex-1) );
// do not double count
if(!(totMask & curMask))
totMask += curMask;
}
continue;
}
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 316 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::isGoodRPCMuon(), MuonIdProducer::isGoodTrackerMuon(), ZToMuMuGammaAnalyzer::muonSelection(), overlap(), helper::MuonCollectionStoreManager::processMuon(), CaloMuonMerger::produce(), MuonReSeeder::produce(), MuonCosmicCompatibilityFiller::pvMatches(), muon::tevOptimized(), and MuonIdTruthInfo::truthMatchMuon().
{ return innerTrack(); }
| float Muon::trackDist | ( | int | station, |
| int | muonSubdetId, | ||
| ArbitrationType | type = SegmentAndTrackArbitration |
||
| ) | const |
Definition at line 764 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 781 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 638 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 722 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 659 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 743 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 554 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 575 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 596 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 680 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 617 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 701 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 211 of file Muon.h.
References type_.
Referenced by CaloMuonMerger::produce(), pat::Muon::setDB(), setMuonTrack(), and setType().
{ return type_; }
MuonTrackType reco::Muon::bestTrackType_ [private] |
reference to the Track chosen to assign the momentum value to the muon
Definition at line 233 of file Muon.h.
Referenced by bestTrack(), bestTrackRef(), Muon(), muonBestTrack(), muonBestTrackType(), and setBestTrack().
MuonEnergy reco::Muon::calEnergy_ [private] |
energy deposition
Definition at line 236 of file Muon.h.
Referenced by calEnergy(), and setCalEnergy().
float reco::Muon::caloCompatibility_ [private] |
muon hypothesis compatibility with observer calorimeter energy
Definition at line 249 of file Muon.h.
Referenced by caloCompatibility(), isCaloCompatibilityValid(), Muon(), and setCaloCompatibility().
const unsigned int reco::Muon::CaloMuon = 1<<4 [static] |
Definition at line 206 of file Muon.h.
Referenced by isCaloMuon(), and CaloMuonMerger::produce().
MuonQuality reco::Muon::combinedQuality_ [private] |
quality block
Definition at line 238 of file Muon.h.
Referenced by combinedQuality(), and setCombinedQuality().
bool reco::Muon::energyValid_ [private] |
Definition at line 243 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 203 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 229 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 225 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 251 of file Muon.h.
Referenced by isolationR03(), and setIsolation().
MuonIsolation reco::Muon::isolationR05_ [private] |
Definition at line 252 of file Muon.h.
Referenced by isolationR05(), and setIsolation().
bool reco::Muon::isolationValid_ [private] |
Definition at line 245 of file Muon.h.
Referenced by isIsolationValid(), Muon(), and setIsolation().
bool reco::Muon::matchesValid_ [private] |
Definition at line 244 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 240 of file Muon.h.
Referenced by chambers(), matches(), numberOfChambers(), numberOfMatches(), numberOfSegments(), RPClayerMask(), setMatches(), stationGapMaskDistance(), stationGapMaskPull(), stationMask(), and t0().
TrackRef reco::Muon::outerTrack_ [private] |
reference to Track reconstructed in the muon detector only
Definition at line 227 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 255 of file Muon.h.
Referenced by pfIsolationR03(), and setPFIsolation().
MuonPFIsolation reco::Muon::pfIsolationR04_ [private] |
Definition at line 258 of file Muon.h.
Referenced by pfIsolationR04(), and setPFIsolation().
bool reco::Muon::pfIsolationValid_ [private] |
Definition at line 246 of file Muon.h.
Referenced by isPFIsolationValid(), Muon(), and setPFIsolation().
MuonPFIsolation reco::Muon::pfIsoMeanDRR03_ [private] |
Definition at line 256 of file Muon.h.
Referenced by pfMeanDRIsoProfileR03(), and setPFIsolation().
MuonPFIsolation reco::Muon::pfIsoMeanDRR04_ [private] |
Definition at line 259 of file Muon.h.
Referenced by pfMeanDRIsoProfileR04(), and setPFIsolation().
MuonPFIsolation reco::Muon::pfIsoSumDRR03_ [private] |
Definition at line 257 of file Muon.h.
Referenced by pfSumDRIsoProfileR03(), and setPFIsolation().
MuonPFIsolation reco::Muon::pfIsoSumDRR04_ [private] |
Definition at line 260 of file Muon.h.
Referenced by pfSumDRIsoProfileR04(), and setPFIsolation().
const unsigned int reco::Muon::PFMuon = 1<<5 [static] |
Definition at line 207 of file Muon.h.
Referenced by isPFMuon(), and setPFP4().
bool reco::Muon::qualityValid_ [private] |
Definition at line 247 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 231 of file Muon.h.
Referenced by muonTrackFromMap(), and setMuonTrack().
const unsigned int reco::Muon::RPCMuon = 1<<6 [static] |
Definition at line 208 of file Muon.h.
Referenced by isRPCMuon(), and MuonIdProducer::produce().
const unsigned int reco::Muon::StandAloneMuon = 1<<3 [static] |
Definition at line 205 of file Muon.h.
Referenced by isStandAloneMuon(), and MuonIdProducer::produce().
MuonTime reco::Muon::time_ [private] |
const unsigned int reco::Muon::TrackerMuon = 1<<2 [static] |
Definition at line 204 of file Muon.h.
Referenced by isTrackerMuon(), and MuonIdProducer::produce().
unsigned int reco::Muon::type_ [private] |
muon type mask
Definition at line 263 of file Muon.h.
Referenced by pat::Muon::dB(), pat::Muon::edB(), isCaloMuon(), isGlobalMuon(), isPFMuon(), isRPCMuon(), isStandAloneMuon(), isTrackerMuon(), Muon(), setPFP4(), setType(), and type().
1.7.3