|
|
|
#include <DataFormats/MuonReco/interface/Muon.h>
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 | |
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 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; }
| 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 edm::Ref< C, T, F >::get(), muonBestTrackType(), and muonTrack().
Referenced by pat::Muon::isHighPtMuon().
{return muonTrack(muonBestTrackType()).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 muonBestTrackType(), and muonTrack().
Referenced by SelectReplacementCandidates::getRawIDsAdvanced().
{return reco::TrackBaseRef(muonTrack(muonBestTrackType()));}
| MuonEnergy reco::Muon::calEnergy | ( | ) | const [inline] |
get energy deposition information
Definition at line 112 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 151 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 122 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(), 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(), muonBestTrackType(), 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().
| bool reco::Muon::isCaloCompatibilityValid | ( | ) | const [inline] |
Definition at line 153 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 214 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 110 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 211 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(), pat::Muon::isHighPtMuon(), muon::isHighPtMuon(), pat::Muon::isLooseMuon(), 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 139 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 159 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 160 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 215 of file Muon.h.
Referenced by pat::Muon::isLooseMuon(), muon::isLooseMuon(), muon::isTightMuon(), and MuonProducer::produce().
| bool reco::Muon::isQualityValid | ( | ) | const [inline] |
====================== Quality BLOCK ===========================
energy deposition
Definition at line 120 of file Muon.h.
References qualityValid_.
Referenced by MuonIdProducer::fillTrackerKink(), and muon::isGoodMuon().
{ return qualityValid_; }
| bool reco::Muon::isRPCMuon | ( | ) | const [inline] |
| bool reco::Muon::isStandAloneMuon | ( | ) | const [inline, virtual] |
Reimplemented from reco::LeafCandidate.
Definition at line 213 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 130 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 212 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(), pat::Muon::isLooseMuon(), 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; }
| std::vector<MuonChamberMatch>& reco::Muon::matches | ( | ) | [inline] |
get muon matching information
Definition at line 141 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(), muon::sharedSegments(), and MuonIdTruthInfo::truthMatchMuon().
{ return muMatches_;}
| const std::vector<MuonChamberMatch>& reco::Muon::matches | ( | ) | const [inline] |
| virtual TrackRef reco::Muon::muonBestTrack | ( | ) | const [inline, virtual] |
Definition at line 64 of file Muon.h.
References muonBestTrackType(), and muonTrack().
Referenced by pat::Muon::embedMuonBestTrack(), pat::Muon::isHighPtMuon(), and muon::isTightMuon().
{return muonTrack(muonBestTrackType());}
| virtual MuonTrackType reco::Muon::muonBestTrackType | ( | ) | const [inline, virtual] |
Definition at line 65 of file Muon.h.
References bestTrackType_, innerTrack(), InnerTrack, None, OuterTrack, and standAloneMuon().
Referenced by bestTrack(), bestTrackRef(), and muonBestTrack().
{
if (bestTrackType_!=None) return bestTrackType_;
if (!innerTrack().isNull()) return InnerTrack;
if (!standAloneMuon().isNull()) return OuterTrack;
return None;
}
| 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 76 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 179 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 pat::Muon::isHighPtMuon(), 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 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] |
| const MuonPFIsolation& reco::Muon::pfIsolationR04 | ( | ) | const [inline] |
| reco::Candidate::LorentzVector reco::Muon::pfP4 | ( | ) | const [inline] |
set reference to PFCandidate
====================== PF BLOCK ===========================
Definition at line 103 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().
| 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 94 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 114 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 152 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 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 124 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(), MuonIdProducer::makeMuon(), 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(), 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 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 144 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(), MuonIdProducer::makeMuon(), 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] |
| 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] |
| 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 207 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(), muonBestTrackType(), 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 309 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 132 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 208 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 230 of file Muon.h.
Referenced by Muon(), muonBestTrackType(), and setBestTrack().
MuonEnergy reco::Muon::calEnergy_ [private] |
energy deposition
Definition at line 233 of file Muon.h.
Referenced by calEnergy(), and setCalEnergy().
float reco::Muon::caloCompatibility_ [private] |
muon hypothesis compatibility with observer calorimeter energy
Definition at line 246 of file Muon.h.
Referenced by caloCompatibility(), isCaloCompatibilityValid(), Muon(), and setCaloCompatibility().
const unsigned int reco::Muon::CaloMuon = 1<<4 [static] |
Definition at line 203 of file Muon.h.
Referenced by isCaloMuon(), and CaloMuonMerger::produce().
MuonQuality reco::Muon::combinedQuality_ [private] |
quality block
Definition at line 235 of file Muon.h.
Referenced by combinedQuality(), and setCombinedQuality().
bool reco::Muon::energyValid_ [private] |
Definition at line 240 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 200 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 226 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 222 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 248 of file Muon.h.
Referenced by isolationR03(), and setIsolation().
MuonIsolation reco::Muon::isolationR05_ [private] |
Definition at line 249 of file Muon.h.
Referenced by isolationR05(), and setIsolation().
bool reco::Muon::isolationValid_ [private] |
Definition at line 242 of file Muon.h.
Referenced by isIsolationValid(), Muon(), and setIsolation().
bool reco::Muon::matchesValid_ [private] |
Definition at line 241 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 237 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 224 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 252 of file Muon.h.
Referenced by pfIsolationR03(), and setPFIsolation().
MuonPFIsolation reco::Muon::pfIsolationR04_ [private] |
Definition at line 253 of file Muon.h.
Referenced by pfIsolationR04(), and setPFIsolation().
bool reco::Muon::pfIsolationValid_ [private] |
Definition at line 243 of file Muon.h.
Referenced by isPFIsolationValid(), Muon(), and setPFIsolation().
const unsigned int reco::Muon::PFMuon = 1<<5 [static] |
Definition at line 204 of file Muon.h.
Referenced by isPFMuon(), and setPFP4().
bool reco::Muon::qualityValid_ [private] |
Definition at line 244 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 228 of file Muon.h.
Referenced by muonTrackFromMap(), and setMuonTrack().
const unsigned int reco::Muon::RPCMuon = 1<<6 [static] |
Definition at line 205 of file Muon.h.
Referenced by isRPCMuon().
const unsigned int reco::Muon::StandAloneMuon = 1<<3 [static] |
Definition at line 202 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 201 of file Muon.h.
Referenced by isTrackerMuon(), and MuonIdProducer::produce().
unsigned int reco::Muon::type_ [private] |
muon type mask
Definition at line 256 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