diff --git a/RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h b/RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h index 319902aea6a8e..2b800939dd016 100644 --- a/RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h +++ b/RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h @@ -42,8 +42,6 @@ class PFMuonAlgo { static bool isIsolatedMuon( const reco::PFBlockElement& elt ); - static bool hasValidTracks(const reco::MuonRef& ); - static bool isMuon( const reco::MuonRef& muonRef ); static bool isLooseMuon( const reco::MuonRef& muonRef ); @@ -52,6 +50,9 @@ class PFMuonAlgo { static bool isGlobalLooseMuon( const reco::MuonRef& muonRef ); + + + static bool isTrackerTightMuon( const reco::MuonRef& muonRef ); static bool isTrackerLooseMuon( const reco::MuonRef& muonRef ); @@ -66,6 +67,10 @@ class PFMuonAlgo { ////POST CLEANING AND MOMEMNTUM ASSIGNMENT + bool hasValidTrack(const reco::MuonRef& muonRef,bool loose =false); + + + //Make a PF Muon : Basic method bool reconstructMuon(reco::PFCandidate&, const reco::MuonRef&,bool allowLoose = false); diff --git a/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporter.cc b/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporter.cc index 6767967f980cd..9c1a73d51c4ba 100644 --- a/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporter.cc +++ b/RecoParticleFlow/PFProducer/plugins/importers/GeneralTracksImporter.cc @@ -18,7 +18,12 @@ class GeneralTracksImporter : public BlockElementImporterBase { _NHitCut(conf.getParameter >("NHitCuts_byTrackAlgo")), _useIterTracking(conf.getParameter("useIterativeTracking")), _cleanBadConvBrems(conf.existsAs("cleanBadConvertedBrems") ? conf.getParameter("cleanBadConvertedBrems") : false), - _debug(conf.getUntrackedParameter("debug",false)) {} + _debug(conf.getUntrackedParameter("debug",false)) { + + pfmu_ = std::unique_ptr(new PFMuonAlgo()); + pfmu_->setParameters(conf); + + } void importToBlock( const edm::Event& , ElementList& ) const override; @@ -33,6 +38,9 @@ class GeneralTracksImporter : public BlockElementImporterBase { const std::vector _DPtovPtCut; const std::vector _NHitCut; const bool _useIterTracking,_cleanBadConvBrems,_debug; + + std::unique_ptr pfmu_; + }; DEFINE_EDM_PLUGIN(BlockElementImporterFactory, @@ -120,8 +128,8 @@ importToBlock( const edm::Event& e, bool thisIsAPotentialMuon = false; if( muId != -1 ) { muonref= reco::MuonRef( muons, muId ); - thisIsAPotentialMuon = ( PFMuonAlgo::isLooseMuon(muonref) || - PFMuonAlgo::isMuon(muonref) ); + thisIsAPotentialMuon = ( (pfmu_->hasValidTrack(muonref,true)&&PFMuonAlgo::isLooseMuon(muonref)) || + (pfmu_->hasValidTrack(muonref,false)&&PFMuonAlgo::isMuon(muonref))); } if(thisIsAPotentialMuon || goodPtResolution( pftrackref->trackRef() ) ) { trkElem = new reco::PFBlockElementTrack( pftrackref ); @@ -157,8 +165,6 @@ goodPtResolution( const reco::TrackRef& trackref) const { case reco::TrackBase::lowPtTripletStep: case reco::TrackBase::pixelPairStep: case reco::TrackBase::jetCoreRegionalStep: - case reco::TrackBase::muonSeededStepInOut: - case reco::TrackBase::muonSeededStepOutIn: Algo = 0; break; case reco::TrackBase::detachedTripletStep: @@ -173,6 +179,10 @@ goodPtResolution( const reco::TrackRef& trackref) const { case reco::TrackBase::tobTecStep: Algo = 4; break; + case reco::TrackBase::muonSeededStepInOut: + case reco::TrackBase::muonSeededStepOutIn: + Algo = 5; + break; case reco::TrackBase::hltIter0: case reco::TrackBase::hltIter1: case reco::TrackBase::hltIter2: @@ -188,22 +198,19 @@ goodPtResolution( const reco::TrackRef& trackref) const { Algo = _useIterTracking ? 0 : 0; break; default: - Algo = _useIterTracking ? 5 : 0; + Algo = _useIterTracking ? 6 : 0; break; } // Protection against 0 momentum tracks if ( P < 0.05 ) return false; - // Temporary : Reject all tracking iteration beyond 5th step. -// if ( Algo > 4 ) return false; if (_debug) std::cout << " PFBlockAlgo: PFrecTrack->Track Pt= " << Pt << " DPt = " << DPt << std::endl; if ( ( _DPtovPtCut[Algo] > 0. && DPt/Pt > _DPtovPtCut[Algo]*sigmaHad ) || NHit < _NHitCut[Algo] ) { - // (Algo >= 3 && LostHits != 0) ) { if (_debug) std::cout << " PFBlockAlgo: skip badly measured track" << ", P = " << P << ", Pt = " << Pt @@ -213,27 +220,9 @@ goodPtResolution( const reco::TrackRef& trackref) const { << std::endl; if (_debug) std::cout << " cut is DPt/Pt < " << _DPtovPtCut[Algo] * sigmaHad << std::endl; if (_debug) std::cout << " cut is NHit >= " << _NHitCut[Algo] << std::endl; - /* - std::cout << "Track REJECTED : "; - std::cout << ", P = " << P - << ", Pt = " << Pt - << " DPt = " << DPt - << ", N(hits) = " << NHit << " (Lost : " << LostHits << "/" << NLostHit << ")" - << ", Algo = " << Algo - << std::std::endl; - */ return false; } - /* - std::cout << "Track Accepted : "; - std::cout << ", P = " << P - << ", Pt = " << Pt - << " DPt = " << DPt - << ", N(hits) = " << NHit << " (Lost : " << LostHits << "/" << NLostHit << ")" - << ", Algo = " << Algo - << std::std::endl; - */ return true; } diff --git a/RecoParticleFlow/PFProducer/python/particleFlowBlock_cfi.py b/RecoParticleFlow/PFProducer/python/particleFlowBlock_cfi.py index eac9d45de6a57..71eb2f54b3af7 100644 --- a/RecoParticleFlow/PFProducer/python/particleFlowBlock_cfi.py +++ b/RecoParticleFlow/PFProducer/python/particleFlowBlock_cfi.py @@ -43,9 +43,10 @@ muonSrc = cms.InputTag("muons1stStep"), cleanBadConvertedBrems = cms.bool(True), useIterativeTracking = cms.bool(True), + maxDPtOPt = cms.double(1.), DPtOverPtCuts_byTrackAlgo = cms.vdouble(-1.0,-1.0,-1.0, - 1.0,1.0), - NHitCuts_byTrackAlgo = cms.vuint32(3,3,3,3,3) + 1.0,1.0,5.0), + NHitCuts_byTrackAlgo = cms.vuint32(3,3,3,3,3,3) ), # secondary GSF tracks are also turned off #cms.PSet( importerName = cms.string("GSFTrackImporter"), diff --git a/RecoParticleFlow/PFProducer/src/PFAlgo.cc b/RecoParticleFlow/PFProducer/src/PFAlgo.cc index b3905e25666d8..da56683811c4d 100644 --- a/RecoParticleFlow/PFProducer/src/PFAlgo.cc +++ b/RecoParticleFlow/PFProducer/src/PFAlgo.cc @@ -3229,6 +3229,7 @@ unsigned PFAlgo::reconstructTrack( const reco::PFBlockElement& elt, bool allowLo pfCandidates_->back().setFlag( reco::PFCandidate::T_TO_DISP, true); pfCandidates_->back().setDisplacedVertexRef( eltTrack->displacedVertexRef(reco::PFBlockElement::T_TO_DISP)->displacedVertexRef(), reco::PFCandidate::T_TO_DISP); } + // returns index to the newly created PFCandidate return pfCandidates_->size()-1; } diff --git a/RecoParticleFlow/PFProducer/src/PFMuonAlgo.cc b/RecoParticleFlow/PFProducer/src/PFMuonAlgo.cc index dac732410bf9c..549038383b7a5 100644 --- a/RecoParticleFlow/PFProducer/src/PFMuonAlgo.cc +++ b/RecoParticleFlow/PFProducer/src/PFMuonAlgo.cc @@ -149,6 +149,8 @@ void PFMuonAlgo::setParameters(const edm::ParameterSet& iConfig ) + + bool PFMuonAlgo::isMuon( const reco::PFBlockElement& elt ) { @@ -181,6 +183,7 @@ PFMuonAlgo::isLooseMuon( const reco::PFBlockElement& elt ) { } + bool PFMuonAlgo::isGlobalTightMuon( const reco::PFBlockElement& elt ) { @@ -242,7 +245,7 @@ PFMuonAlgo::isMuon(const reco::MuonRef& muonRef ){ bool PFMuonAlgo::isLooseMuon(const reco::MuonRef& muonRef ){ - return isGlobalLooseMuon(muonRef) || isTrackerLooseMuon(muonRef); + return (isGlobalLooseMuon(muonRef) || isTrackerLooseMuon(muonRef)); } @@ -256,7 +259,7 @@ PFMuonAlgo::isGlobalTightMuon( const reco::MuonRef& muonRef ) { if ( muonRef->isTrackerMuon() ) { - + bool result = muon::isGoodMuon(*muonRef,muon::GlobalMuonPromptTight); bool isTM2DCompatibilityTight = muon::isGoodMuon(*muonRef,muon::TM2DCompatibilityTight); @@ -266,7 +269,7 @@ PFMuonAlgo::isGlobalTightMuon( const reco::MuonRef& muonRef ) { return result && quality; } else { - + reco::TrackRef standAloneMu = muonRef->standAloneMuon(); // No tracker muon -> Request a perfect stand-alone muon, or an even better global muon @@ -459,11 +462,15 @@ PFMuonAlgo::isIsolatedMuon( const reco::MuonRef& muonRef ){ reco::TrackRef trackerMu = muonRef->track(); if(trackerMu->pt() < smallestMuPt) smallestMuPt= trackerMu->pt(); } - + + double sumPtR03 = muonRef->isolationR03().sumPt; double relIso = sumPtR03/smallestMuPt; + + + if(relIso<0.1) return true; else return false; } @@ -490,6 +497,17 @@ PFMuonAlgo::isTightMuonPOG(const reco::MuonRef& muonRef) { } + +bool +PFMuonAlgo::hasValidTrack(const reco::MuonRef& muonRef,bool loose) { + if(loose) + return muonTracks(muonRef).size()>0; + else + return goodMuonTracks(muonRef).size()>0; + +} + + void PFMuonAlgo::printMuonProperties(const reco::MuonRef& muonRef){ @@ -703,6 +721,7 @@ bool PFMuonAlgo::reconstructMuon(reco::PFCandidate& candidate, const reco::MuonR if (!muon.isNonnull()) return false; + bool isMu=false; @@ -715,6 +734,10 @@ bool PFMuonAlgo::reconstructMuon(reco::PFCandidate& candidate, const reco::MuonR if( !isMu) return false; + + + + //get the valid tracks(without standalone except we allow loose muons) //MIKE: Here we need to be careful. If we have a muon inside a dense //jet environment often the track is badly measured. In this case @@ -731,6 +754,7 @@ bool PFMuonAlgo::reconstructMuon(reco::PFCandidate& candidate, const reco::MuonR + //check what is the track used.Rerun TuneP reco::Muon::MuonTrackTypePair bestTrackPair = muon::tevOptimized(*muon); @@ -874,13 +898,6 @@ void PFMuonAlgo::postClean(reco::PFCandidateCollection* cands) { const reco::PFCandidate& cand = (*cands)[i]; if ( cand.particleId() == reco::PFCandidate::mu ) muons.push_back(i); - else if ( cand.particleId() == reco::PFCandidate::h && cand.muonRef().isNonnull()) { - //MET cleaning for muons that are not high purity and became charged hadrons - if (cand.pt()>100.0 && (!cand.trackRef()->quality(trackQuality_)) && cand.muonRef()->isGlobalMuon() && cand.rawHcalEnergy()<0.05*cand.p()) { - maskedIndices_.push_back(i); - pfPunchThroughMuonCleanedCandidates_->push_back(cand); - } - } } //Then sort the muon indicess by decsending pt