Reference Manual

MuonTrackType bestTrackType_

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

Definition: Muon.h:238

edm::Ref::get

T const * get() const

Returns C++ pointer to the item.

Definition: Ref.h:242

virtual TrackBaseRef reco::Muon::bestTrackRef ( ) const

inlinevirtual

best track RefToBase

Reimplemented from reco::RecoCandidate.

Definition at line 63 of file Muon.h.

References bestTrackType_, and muonTrack().

Referenced by SelectReplacementCandidates::getRawIDsAdvanced().

63 {return reco::TrackBaseRef(muonTrack(bestTrackType_));}

reco::Muon::muonTrack

TrackRef muonTrack(const MuonTrackType &) const

Definition: Muon.cc:857

reco::TrackBaseRef

edm::RefToBase< reco::Track > TrackBaseRef

persistent reference to a Track, using views

Definition: TrackFwd.h:22

reco::Muon::caloCompatibility_

MuonTrackType bestTrackType_

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

Definition: Muon.h:238

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(), FWMuonLegoProxyBuilder::build(), FWMuonDetailView::build(), MuonCaloCompatibility::evaluate(), MuonMETAlgo::GetMuDepDeltas(), MuonIdProducer::makeCaloMuon(), ZMuMuMuonUserData::produce(), ZToLLEdmNtupleDumper::produce(), MuonIdProducer::produce(), setCalEnergy(), and FWMuonDetailView::setTextInfo().

112 { return calEnergy_; }

reco::Muon::calEnergy_

MuonEnergy calEnergy_

energy deposition

Definition: Muon.h:243

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().

151 { return caloCompatibility_; }

float caloCompatibility_

muon hypothesis compatibility with observer calorimeter energy

Definition: Muon.h:256

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 364 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 44 of file Muon.cc.

References Muon().

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonWithPFIsoProducer::produce(), DistortedMuonProducerFromDB::produce(), DistortedMuonProducer::produce(), and UpdatedMuonInnerTrackRef::produce().

                          {
   return new Muon( * this );
 }

virtual TrackRef reco::Muon::combinedMuon ( ) const

inlinevirtual

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 MuonKinVsEtaAnalyzer::analyze(), MuonRecoAnalyzer::analyze(), AlignmentMuonSelector::basicCuts(), MuonIdProducer::fillGlbQuality(), MuonTimingFiller::fillTiming(), overlap(), helper::MuonCollectionStoreManager::processMuon(), and muon::tevOptimized().

56 { return globalTrack(); }

reco::Muon::globalTrack

virtual TrackRef globalTrack() const

reference to Track reconstructed in both tracked and muon detector

Definition: Muon.h:55

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().

122 { return combinedQuality_; }

reco::Muon::combinedQuality_

MuonQuality combinedQuality_

quality block

Definition: Muon.h:245

float Muon::dDxDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 430 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 438 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 413 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 421 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

inlinevirtual

Reimplemented in pat::Muon.

Definition at line 60 of file Muon.h.

References DYT, and muonTrackFromMap().

Referenced by pat::Muon::dytTrack(), pat::Muon::embedDytMuon(), and muonTrack().

60 { return muonTrackFromMap(DYT);}

reco::Muon::DYT

Definition: Muon.h:39

reco::Muon::muonTrackFromMap

TrackRef muonTrackFromMap(const MuonTrackType &type) const

Definition: Muon.h:74

virtual TrackRef reco::Muon::globalTrack ( ) const

inlinevirtual

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 EwkMuDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), TrackSplittingMonitor::analyze(), CosmicSplitterValidation::analyze(), MuonAssociatorByHits::associateMuons(), ZToMuMuGammaAnalyzer::basicMuonSelection(), FWMuonBuilder::buildMuon(), TCMETAlgo::CalculateTCMET(), combinedMuon(), pat::Muon::combinedMuon(), pat::Muon::embedCombinedMuon(), MuonShowerInformationFiller::fillHitsByStation(), WMuNuValidator::filter(), WMuNuSelector::filter(), LeptonRecoSkim::filter(), MuonMETAlgo::GetMuDepDeltas(), muon::isGoodMuon(), cms::MuonTCMETValueMapProducer::isGoodMuon(), muon::isHighPtMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), BTagHLTOfflineSource::isVBTFMuon(), FourVectorHLTOffline::isVBTFMuon(), ZToMuMuGammaAnalyzer::muonSelection(), muonTrack(), helper::MuonCollectionStoreManager::processMuon(), cms::MuonMETValueMapProducer::produce(), MuonGmtPair::pt(), BPhysicsOniaDQM::selGlobalMuon(), sigmaSwitch(), muon::sigmaSwitch(), SoftPFMuonTagInfoProducer::tagMuon(), muon::tevOptimized(), and tevOptimizedTMR().

55 { return globalTrack_; }

reco::Muon::globalTrack_

TrackRef globalTrack_

reference to Track reconstructed in both tracked and muon detector

Definition: Muon.h:234

virtual TrackRef reco::Muon::innerTrack ( ) const

inlinevirtual

Reimplemented in pat::Muon.

Definition at line 49 of file Muon.h.

References innerTrack_.

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

49 { return innerTrack_; }

reco::Muon::innerTrack_

TrackRef innerTrack_

reference to Track reconstructed in the tracker only

Definition: Muon.h:230

bool Muon::isAValidMuonTrack ( const MuonTrackType & type ) const

Definition at line 853 of file Muon.cc.

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

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

                                                            {
   return muonTrack(type).isNonnull();
 }

bool reco::Muon::isCaloCompatibilityValid ( ) const

inline

Definition at line 153 of file Muon.h.

References caloCompatibility_.

Referenced by CaloMuonMerger::produce().

153 { return caloCompatibility_>=0; }

reco::Muon::caloCompatibility_

float caloCompatibility_

muon hypothesis compatibility with observer calorimeter energy

Definition: Muon.h:256

bool reco::Muon::isCaloMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 222 of file Muon.h.

References CaloMuon, and type_.

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

222 { return type_ & CaloMuon; }

Referenced by GlbMuQualityCutsAnalysis::analyze(), EwkMuDQM::analyze(), RPCRecHitProbability::analyze(), RPCMonitorDigi::analyze(), EwkMuLumiMonitorDQM::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonRecoAnalyzer::analyze(), MuonEnergyDepositAnalyzer::analyze(), ZMuMu_efficiencyAnalyzer::analyze(), ZMuMu_vtxAnalyzer::analyze(), MuTriggerAnalyzer::analyze(), HiggsDQM::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(), WMuNuValidator::filter(), WMuNuSelector::filter(), LeptonRecoSkim::filter(), MuonMETAlgo::GetMuDepDeltas(), muon::isGoodMuon(), cms::MuonTCMETValueMapProducer::isGoodMuon(), muon::isHighPtMuon(), SoftPFMuonTagInfoProducer::isLooseMuon(), muon::isLooseMuon(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), muon::isTightMuon(), DistortedPFCandProducer::produce(), ZMuMuMuonUserData::produce(), ZMuMuUserData::produce(), cms::MuonMETValueMapProducer::produce(), MuonProducer::produce(), ZToLLEdmNtupleDumper::produce(), cms::MuonTCMETValueMapProducer::produce(), MuonMCClassifier::produce(), MuonGmtPair::pt(), MuonCosmicCompatibilityFiller::pvMatches(), and MuScleFitMuonSelector::selectMuons().

unsigned int type_

muon type mask

Definition: Muon.h:270

reco::Muon::CaloMuon

static const unsigned int CaloMuon

Definition: Muon.h:211

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(), FWMuonLegoProxyBuilder::build(), FWMuonDetailView::build(), MuonIdProducer::makeCaloMuon(), MuonIdProducer::produce(), and FWMuonDetailView::setTextInfo().

110 { return energyValid_; }

reco::Muon::energyValid_

bool energyValid_

Definition: Muon.h:250

bool reco::Muon::isGlobalMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 219 of file Muon.h.

References GlobalMuon, and type_.

219 { return type_ & GlobalMuon; }

reco::Muon::GlobalMuon

static const unsigned int GlobalMuon

Definition: Muon.h:208

reco::Muon::isolationValid_

unsigned int type_

muon type mask

Definition: Muon.h:270

bool reco::Muon::isIsolationValid ( ) const

inline

Definition at line 171 of file Muon.h.

References isolationValid_.

Referenced by MuonMETAlgo::GetMuDepDeltas().

171 { return isolationValid_; }

bool isolationValid_

Definition: Muon.h:252

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().

139 { return matchesValid_; }

reco::Muon::matchesValid_

bool matchesValid_

Definition: Muon.h:251

bool reco::Muon::isMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 218 of file Muon.h.

218 { return true; }

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 EwkMuDQM::analyze(), ZToMuMuGammaAnalyzer::analyze(), MuonPFAnalyzer::combRelIso(), pat::Muon::ecalIso(), MuonVPlusJetsIDSelectionFunctor::fall10Cuts(), WMuNuValidator::filter(), WMuNuSelector::filter(), MuonVPlusJetsIDSelectionFunctor::firstDataCuts(), MuonMETAlgo::GetMuDepDeltas(), pat::Muon::hcalIso(), MuonVPlusJetsIDSelectionFunctor::kitQCDCuts(), EwkMuLumiMonitorDQM::muIso(), ZToMuMuGammaAnalyzer::muonSelection(), MuonVPlusJetsIDSelectionFunctor::spring10Cuts(), MuonVPlusJetsIDSelectionFunctor::summer08Cuts(), and pat::Muon::trackIso().

159 { return isolationR03_; }

reco::Muon::isolationR03_

MuonIsolation isolationR03_

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

Definition: Muon.h:258

const MuonIsolation& reco::Muon::isolationR05 ( ) const

inline

Definition at line 160 of file Muon.h.

References isolationR05_.

Referenced by EwkMuTauHistManager::fillHistograms().

160 { return isolationR05_; }

reco::Muon::isolationR05_

MuonIsolation isolationR05_

Definition: Muon.h:259

bool reco::Muon::isPFIsolationValid ( ) const

inline

Definition at line 175 of file Muon.h.

References pfIsolationValid_.

175 { return pfIsolationValid_; }

reco::Muon::pfIsolationValid_

bool pfIsolationValid_

Definition: Muon.h:253

bool reco::Muon::isPFMuon ( ) const

inline

Definition at line 223 of file Muon.h.

References PFMuon, and type_.

Referenced by MuonPFAnalyzer::analyze(), SoftPFMuonTagInfoProducer::isLooseMuon(), muon::isLooseMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), muon::isTightMuon(), and MuonProducer::produce().

223 {return type_ & PFMuon;} //fix me ! Has to go to type

reco::Muon::qualityValid_

unsigned int type_

muon type mask

Definition: Muon.h:270

reco::Muon::PFMuon

static const unsigned int PFMuon

Definition: Muon.h:212

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().

120 { return qualityValid_; }

bool qualityValid_

Definition: Muon.h:254

bool reco::Muon::isRPCMuon ( ) const

inline

Definition at line 224 of file Muon.h.

References RPCMuon, and type_.

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

224 {return type_ & RPCMuon;}

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

unsigned int type_

muon type mask

Definition: Muon.h:270

reco::Muon::RPCMuon

static const unsigned int RPCMuon

Definition: Muon.h:213

bool reco::Muon::isStandAloneMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 221 of file Muon.h.

References StandAloneMuon, and type_.

221 { return type_ & StandAloneMuon; }

reco::Muon::StandAloneMuon

unsigned int type_

muon type mask

Definition: Muon.h:270

static const unsigned int StandAloneMuon

Definition: Muon.h:210

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().

130 { return (time_.nDof>0); }

reco::MuonTime::nDof

int nDof

number of muon stations used

Definition: MuonTime.h:10

reco::Muon::time_

MuonTime time_

timing

Definition: Muon.h:249

bool reco::Muon::isTrackerMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 220 of file Muon.h.

References TrackerMuon, and type_.

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

220 { return type_ & TrackerMuon; }

unsigned int type_

muon type mask

Definition: Muon.h:270

reco::Muon::TrackerMuon

static const unsigned int TrackerMuon

Definition: Muon.h:209

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(), muon::isGoodMuon(), MuonResidualsFromTrack::MuonResidualsFromTrack(), numberOfChambersNoRPC(), numberOfMatches(), MuonIdProducer::overlap(), muon::overlap(), MuonIdProducer::phiOfMuonIneteractionRegion(), MuonIdProducer::produce(), setMatches(), muon::sharedSegments(), and MuonIdTruthInfo::truthMatchMuon().

141 { return muMatches_;}

std::vector< MuonChamberMatch > muMatches_

Information on matching between tracks and segments.

Definition: Muon.h:247

const std::vector<MuonChamberMatch>& reco::Muon::matches ( ) const

inline

Definition at line 142 of file Muon.h.

References muMatches_.

142 { return muMatches_; }

std::vector< MuonChamberMatch > muMatches_

Information on matching between tracks and segments.

Definition: Muon.h:247

virtual TrackRef reco::Muon::muonBestTrack ( ) const

inlinevirtual

Definition at line 64 of file Muon.h.

References bestTrackType_, and muonTrack().

Referenced by MuonRecoAnalyzer::analyze(), pat::Muon::embedMuonBestTrack(), muon::isHighPtMuon(), SoftPFMuonTagInfoProducer::isSoftMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), and muon::isTightMuon().

64 {return muonTrack(bestTrackType_);}

reco::Muon::muonTrack

TrackRef muonTrack(const MuonTrackType &) const

Definition: Muon.cc:857

MuonTrackType bestTrackType_

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

Definition: Muon.h:238

virtual MuonTrackType reco::Muon::muonBestTrackType ( ) const

inlinevirtual

Definition at line 65 of file Muon.h.

References bestTrackType_.

Referenced by MuonPFAnalyzer::muonTrackType().

65 {return bestTrackType_;}

MuonTrackType bestTrackType_

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

Definition: Muon.h:238

TrackRef Muon::muonTrack ( const MuonTrackType & type ) const

Definition at line 857 of file Muon.cc.

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

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

                                                        {
   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 74 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 185 of file Muon.h.

References muMatches_.

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

185 { return muMatches_.size(); }

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(), ZMuMuMuonUserData::produce(), ZToLLEdmNtupleDumper::produce(), and PFMuonSelector::spring11Cuts().

std::vector< MuonChamberMatch > muMatches_

Information on matching between tracks and segments.

Definition: Muon.h:247

int Muon::numberOfChambersNoRPC ( ) const

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

Definition at line 48 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 203 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 110 of file Muon.cc.

References stationMask(), and mergeVDriftHistosByStation::stations.

Referenced by muon::isHighPtMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), 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 60 of file Muon.cc.

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

 {
    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 318 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

inlinevirtual

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 RPCRecHitProbability::analyze(), RPCMonitorDigi::analyze(), MuonEnergyDepositAnalyzer::analyze(), HLTMuonMatchAndPlot::analyze(), CosmicSplitterValidation::analyze(), MuonAssociatorByHits::associateMuons(), 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(), OutsideInMuonSeeder::produce(), MuonCosmicCompatibilityFiller::pvMatches(), standAloneMuon(), and pat::Muon::standAloneMuon().

52 { return outerTrack_; }

reco::Muon::outerTrack_

TrackRef outerTrack_

reference to Track reconstructed in the muon detector only

Definition: Muon.h:232

bool Muon::overlap ( const Candidate & c ) const

privatevirtual

check overlap with another candidate

Implements reco::RecoCandidate.

Definition at line 33 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 374 of file Muon.cc.

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

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

 {
    MuonChamberMatch* m = 0;
    MuonSegmentMatch* s = 0;
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair(m,s);
 
    if(chambers.empty()) return chamberSegmentPair;
    for( std::vector<const MuonChamberMatch*>::const_iterator chamberMatch = chambers.begin();
          chamberMatch != chambers.end(); chamberMatch++ )
    {
       if((*chamberMatch)->segmentMatches.empty()) continue;
       if(type == NoArbitration)
          return std::make_pair(*chamberMatch, &((*chamberMatch)->segmentMatches.front()));
 
       for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = (*chamberMatch)->segmentMatches.begin();
             segmentMatch != (*chamberMatch)->segmentMatches.end(); segmentMatch++ )
       {
          if(type == SegmentArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) 
                return std::make_pair(*chamberMatch, &(*segmentMatch));
          if(type == SegmentAndTrackArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                   segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR))
                return std::make_pair(*chamberMatch, &(*segmentMatch));
      if(type == SegmentAndTrackArbitrationCleaned)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
               segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
               segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning))
                return std::make_pair(*chamberMatch, &(*segmentMatch));
          if(type > 1<<7)
             if(segmentMatch->isMask(type))
                return std::make_pair(*chamberMatch, &(*segmentMatch));
       }
    }
 
    return chamberSegmentPair;
 }

const MuonPFIsolation& reco::Muon::pfIsolationR03 ( ) const

inline

Definition at line 162 of file Muon.h.

References pfIsolationR03_.

162 { return pfIsolationR03_; }

reco::Muon::pfIsolationR03_

MuonPFIsolation pfIsolationR03_

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

Definition: Muon.h:262

const MuonPFIsolation& reco::Muon::pfIsolationR04 ( ) const

inline

Definition at line 165 of file Muon.h.

References pfIsolationR04_.

165 { return pfIsolationR04_; }

reco::Muon::pfIsolationR04_

MuonPFIsolation pfIsolationR04_

Definition: Muon.h:265

const MuonPFIsolation& reco::Muon::pfMeanDRIsoProfileR03 ( ) const

inline

Definition at line 163 of file Muon.h.

References pfIsoMeanDRR03_.

163 { return pfIsoMeanDRR03_; }

reco::Muon::pfIsoMeanDRR03_

MuonPFIsolation pfIsoMeanDRR03_

Definition: Muon.h:263

const MuonPFIsolation& reco::Muon::pfMeanDRIsoProfileR04 ( ) const

inline

Definition at line 166 of file Muon.h.

References pfIsoMeanDRR04_.

166 { return pfIsoMeanDRR04_; }

reco::Muon::pfIsoMeanDRR04_

MuonPFIsolation pfIsoMeanDRR04_

Definition: Muon.h:266

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().

103 {return pfP4_;}

reco::Muon::pfP4_

reco::Candidate::LorentzVector pfP4_

Definition: Muon.h:273

const MuonPFIsolation& reco::Muon::pfSumDRIsoProfileR03 ( ) const

inline

Definition at line 164 of file Muon.h.

References pfIsoSumDRR03_.

164 { return pfIsoSumDRR03_; }

reco::Muon::pfIsoSumDRR03_

MuonPFIsolation pfIsoSumDRR03_

Definition: Muon.h:264

const MuonPFIsolation& reco::Muon::pfSumDRIsoProfileR04 ( ) const

inline

Definition at line 167 of file Muon.h.

References pfIsoSumDRR04_.

167 { return pfIsoSumDRR04_; }

reco::Muon::pfIsoSumDRR04_

MuonPFIsolation pfIsoSumDRR04_

Definition: Muon.h:267

virtual TrackRef reco::Muon::pickyTrack ( ) const

inlinevirtual

Reimplemented in pat::Muon.

Definition at line 59 of file Muon.h.

References muonTrackFromMap(), and Picky.

Referenced by pat::Muon::embedPickyMuon(), muonTrack(), pat::Muon::pickyTrack(), and muon::tevOptimized().

59 { return muonTrackFromMap(Picky);}

reco::Muon::Picky

Definition: Muon.h:39

reco::Muon::muonTrackFromMap

TrackRef muonTrackFromMap(const MuonTrackType &type) const

Definition: Muon.h:74

float Muon::pullDxDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`,
		bool	includeSegmentError = `true`
	)		const

Definition at line 468 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 478 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 447 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 457 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 216 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 506 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 540 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 514 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 548 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 489 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::segmentCompatibility().

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

float Muon::segmentXErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 523 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 497 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 531 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 )

inlinevirtual

Definition at line 92 of file Muon.h.

References bestTrackType_.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonIdProducer::makeMuon(), and MuonProducer::produce().

92 {bestTrackType_ = muonType;}

reco::Muon::caloCompatibility_

MuonTrackType bestTrackType_

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

Definition: Muon.h:238

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().

114 { calEnergy_ = calEnergy; energyValid_ = true; }

reco::Muon::calEnergy_

MuonEnergy calEnergy_

energy deposition

Definition: Muon.h:243

reco::Muon::energyValid_

bool energyValid_

Definition: Muon.h:250

reco::Muon::calEnergy

MuonEnergy calEnergy() const

get energy deposition information

Definition: Muon.h:112

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().

152 { caloCompatibility_ = input; }

float caloCompatibility_

muon hypothesis compatibility with observer calorimeter energy

Definition: Muon.h:256

LaserDQM_cfg.input

tuple input

Definition: LaserDQM_cfg.py:38

void Muon::setCombined ( const TrackRef & t )

virtual

Definition at line 850 of file Muon.cc.

References setGlobalTrack().

Referenced by GlobalMuonToMuonProducer::produce().

850 { setGlobalTrack(t); }

reco::Muon::setGlobalTrack

virtual void setGlobalTrack(const TrackRef &t)

set reference to Track

Definition: Muon.cc:849

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().

124 { combinedQuality_ = combinedQuality; qualityValid_ = true; }

reco::Muon::combinedQuality

MuonQuality combinedQuality() const

get energy deposition information

Definition: Muon.h:122

reco::Muon::combinedQuality_

MuonQuality combinedQuality_

quality block

Definition: Muon.h:245

reco::Muon::qualityValid_

bool qualityValid_

Definition: Muon.h:254

void Muon::setGlobalTrack ( const TrackRef & t )

virtual

set reference to Track

Definition at line 849 of file Muon.cc.

References globalTrack_, and lumiQTWidget::t.

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

849 { globalTrack_ = t; }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

reco::Muon::globalTrack_

TrackRef globalTrack_

reference to Track reconstructed in both tracked and muon detector

Definition: Muon.h:234

void Muon::setInnerTrack ( const TrackRef & t )

virtual

set reference to Track

Definition at line 846 of file Muon.cc.

References innerTrack_, and lumiQTWidget::t.

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

846 { innerTrack_ = t; }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

reco::Muon::innerTrack_

TrackRef innerTrack_

reference to Track reconstructed in the tracker only

Definition: Muon.h:230

void Muon::setIsolation	(	const MuonIsolation &	isoR03,
		const MuonIsolation &	isoR05
	)

Definition at line 805 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().

144 { muMatches_ = matches; matchesValid_ = true; }

reco::Muon::matches

std::vector< MuonChamberMatch > & matches()

get muon matching information

Definition: Muon.h:141

reco::Muon::matchesValid_

std::vector< MuonChamberMatch > muMatches_

Information on matching between tracks and segments.

Definition: Muon.h:247

bool matchesValid_

Definition: Muon.h:251

void Muon::setMuonTrack	(	const MuonTrackType &	type,
		const TrackRef &	t
	)

Definition at line 869 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 845 of file Muon.cc.

References outerTrack_, and lumiQTWidget::t.

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

845 { outerTrack_ = t; }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

reco::Muon::outerTrack_

TrackRef outerTrack_

reference to Track reconstructed in the muon detector only

Definition: Muon.h:232

void Muon::setPFIsolation	(	const std::string &	label,
		const reco::MuonPFIsolation &	deposit
	)

Definition at line 813 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

Definition at line 837 of file Muon.cc.

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

Referenced by MuonProducer::produce().

 { 
     pfP4_ = p4;
     type_ = type_ | PFMuon;
 }

void Muon::setStandAlone ( const TrackRef & t )

virtual

Definition at line 848 of file Muon.cc.

References setOuterTrack().

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

848 { setOuterTrack(t); }

reco::Muon::setOuterTrack

virtual void setOuterTrack(const TrackRef &t)

set reference to Track

Definition: Muon.cc:845

void reco::Muon::setTime ( const MuonTime & time )

inline

set timing information

Definition at line 134 of file Muon.h.

References time(), and time_.

134 { time_ = time; }

reco::Muon::time

MuonTime time() const

get timing information

Definition: Muon.h:132

reco::Muon::time_

MuonTime time_

timing

Definition: Muon.h:249

void Muon::setTrack ( const TrackRef & t )

virtual

Definition at line 847 of file Muon.cc.

References setInnerTrack().

Referenced by GlobalMuonToMuonProducer::produce().

847 { setInnerTrack(t); }

reco::Muon::setInnerTrack

virtual void setInnerTrack(const TrackRef &t)

set reference to Track

Definition: Muon.cc:846

virtual void reco::Muon::setTunePBestTrack ( MuonTrackType muonType )

inlinevirtual

Definition at line 94 of file Muon.h.

References bestTunePTrackType_.

Referenced by MuonIdProducer::makeMuon().

94 {bestTunePTrackType_ = muonType;}

reco::Muon::bestTunePTrackType_

MuonTrackType bestTunePTrackType_

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

Definition: Muon.h:240

void reco::Muon::setType ( unsigned int type )

inline

Definition at line 215 of file Muon.h.

References type(), and type_.

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

215 { type_ = type; }