diff --git a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py index 61cb4982f0da6..098c460397d2c 100644 --- a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py @@ -7,6 +7,8 @@ from RecoMET.METFilters.metFilters_cff import primaryVertexFilter, CSCTightHaloFilter, CSCTightHaloTrkMuUnvetoFilter, CSCTightHalo2015Filter, globalTightHalo2016Filter, globalSuperTightHalo2016Filter, HcalStripHaloFilter from RecoMET.METFilters.metFilters_cff import goodVertices, trackingFailureFilter, trkPOGFilters, manystripclus53X, toomanystripclus53X, logErrorTooManyClusters from RecoMET.METFilters.metFilters_cff import chargedHadronTrackResolutionFilter, muonBadTrackFilter +from RecoMET.METFilters.metFilters_cff import BadChargedCandidateFilter, BadPFMuonFilter #2016 post-ICHEPversion +from RecoMET.METFilters.metFilters_cff import BadChargedCandidateSummer16Filter, BadPFMuonSummer16Filter #2016 ICHEP version from RecoMET.METFilters.metFilters_cff import metFilters # individual filters @@ -28,6 +30,11 @@ Flag_trkPOGFilters = cms.Path(trkPOGFilters) Flag_chargedHadronTrackResolutionFilter = cms.Path(chargedHadronTrackResolutionFilter) Flag_muonBadTrackFilter = cms.Path(muonBadTrackFilter) +Flag_BadChargedCandidateFilter = cms.Path(BadChargedCandidateFilter) +Flag_BadPFMuonFilter = cms.Path(BadPFMuonFilter) +Flag_BadChargedCandidateSummer16Filter = cms.Path(BadChargedCandidateSummer16Filter) +Flag_BadPFMuonSummer16Filter = cms.Path(BadPFMuonSummer16Filter) + # and the sub-filters Flag_trkPOG_manystripclus53X = cms.Path(~manystripclus53X) Flag_trkPOG_toomanystripclus53X = cms.Path(~toomanystripclus53X) @@ -39,7 +46,9 @@ #add your new path here!! allMetFilterPaths=['HBHENoiseFilter','HBHENoiseIsoFilter','CSCTightHaloFilter','CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter','hcalLaserEventFilter','EcalDeadCellTriggerPrimitiveFilter','EcalDeadCellBoundaryEnergyFilter','goodVertices','eeBadScFilter', - 'ecalLaserCorrFilter','trkPOGFilters','chargedHadronTrackResolutionFilter','muonBadTrackFilter','trkPOG_manystripclus53X','trkPOG_toomanystripclus53X','trkPOG_logErrorTooManyClusters','METFilters'] + 'ecalLaserCorrFilter','trkPOGFilters','chargedHadronTrackResolutionFilter','muonBadTrackFilter', + 'BadChargedCandidateFilter','BadPFMuonFilter','BadChargedCandidateSummer16Filter','BadPFMuonSummer16Filter', + 'trkPOG_manystripclus53X','trkPOG_toomanystripclus53X','trkPOG_logErrorTooManyClusters','METFilters'] def miniAOD_customizeMETFiltersFastSim(process): diff --git a/RecoMET/METFilters/plugins/BadChargedCandidateFilter.cc b/RecoMET/METFilters/plugins/BadChargedCandidateFilter.cc new file mode 100644 index 0000000000000..2cdfcaae5de07 --- /dev/null +++ b/RecoMET/METFilters/plugins/BadChargedCandidateFilter.cc @@ -0,0 +1,152 @@ +// system include files +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/global/EDFilter.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/Math/interface/deltaR.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonFwd.h" +#include "DataFormats/MuonReco/interface/MuonSelectors.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h" + +// +// class declaration +// + +class BadChargedCandidateFilter : public edm::global::EDFilter<> { +public: + explicit BadChargedCandidateFilter(const edm::ParameterSet&); + ~BadChargedCandidateFilter(); + +private: + virtual bool filter(edm::StreamID iID, edm::Event&, const edm::EventSetup&) const override; + + // ----------member data --------------------------- + + edm::EDGetTokenT > tokenPFCandidates_; + edm::EDGetTokenT > tokenMuons_; + + const bool taggingMode_; + const bool debug_; + const double maxDR_; + const double minPtDiffRel_; + const double minMuonTrackRelErr_; + const double minMuonPt_; + const double segmentCompatibility_; + +}; + +// +// constructors and destructor +// +BadChargedCandidateFilter::BadChargedCandidateFilter(const edm::ParameterSet& iConfig) + : tokenPFCandidates_ ( consumes >(iConfig.getParameter ("PFCandidates") )) + , tokenMuons_ ( consumes >(iConfig.getParameter ("muons") )) + , taggingMode_ ( iConfig.getParameter ("taggingMode") ) + , debug_ ( iConfig.getParameter ("debug") ) + , maxDR_ ( iConfig.getParameter ("maxDR") ) + , minPtDiffRel_ ( iConfig.getParameter ("minPtDiffRel") ) + , minMuonTrackRelErr_ ( iConfig.getParameter ("minMuonTrackRelErr") ) + , minMuonPt_ ( iConfig.getParameter ("minMuonPt") ) + , segmentCompatibility_ ( iConfig.getParameter ("segmentCompatibility") ) +{ + produces(); +} + +BadChargedCandidateFilter::~BadChargedCandidateFilter() { } + + +// +// member functions +// + +// ------------ method called on each new Event ------------ +bool +BadChargedCandidateFilter::filter(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const +{ + using namespace std; + using namespace edm; + + typedef View CandidateView; + Handle pfCandidates; + iEvent.getByToken(tokenPFCandidates_,pfCandidates); + + typedef View MuonView; + Handle muons; + iEvent.getByToken(tokenMuons_,muons); + + bool foundBadChargedCandidate = false; + + for ( unsigned i=0; i < muons->size(); ++i ) { // loop over all muons + + const reco::Muon & muon = (*muons)[i]; + + reco::TrackRef bestMuonTrack = muon.muonBestTrack(); + + if (debug_) cout<<"BadChargedCandidate test:Muon "<< i << endl; + // reco::TrackRef innerMuonTrack = muon.innerTrack(); + // if ( muon.pt() < minMuonPt_ && innerMuonTrack->pt() < minMuonPt_) { + // if (debug_) cout <<"skipping the muon because low muon pt" << endl; + // continue ; } { + { + reco::TrackRef innerMuonTrack = muon.innerTrack(); + if (debug_) cout<<"muon "<pt() < minMuonPt_) { + if (debug_) cout <<"skipping the muon because low muon pt" << endl; + continue; + } + + if (debug_) cout << "SegmentCompatibility :"<< muon::segmentCompatibility(muon) << "RelPtErr:" << bestMuonTrack->ptError()/bestMuonTrack->pt() << endl; + if (muon::segmentCompatibility(muon) > segmentCompatibility_ && bestMuonTrack->ptError()/bestMuonTrack->pt() < minMuonTrackRelErr_) { + if (debug_) cout <<"Skipping this muon because segment compatiblity > 0.3 and relErr(best track) <2 " << endl; + continue; + } + + for ( unsigned j=0; j < pfCandidates->size(); ++j ) { + const reco::Candidate & pfCandidate = (*pfCandidates)[j]; + // look for charged hadrons + if (not ( abs(pfCandidate.pdgId()) == 211) ) continue; + float dr = deltaR( innerMuonTrack->eta(), innerMuonTrack->phi(), pfCandidate.eta(), pfCandidate.phi() ); + float dpt = ( pfCandidate.pt() - innerMuonTrack->pt())/(0.5*(innerMuonTrack->pt() + pfCandidate.pt())); + if ( (debug_) and (dr<0.5) ) cout<<" pt(it) "<pt()<<" candidate "<eta(), innerMuonTrack->phi(), pfCandidate.eta(), pfCandidate.phi() ) < maxDR_ ) + and ( ( pfCandidate.pt() - innerMuonTrack->pt())/(0.5*(innerMuonTrack->pt() + pfCandidate.pt())) > minPtDiffRel_ ) ) { + foundBadChargedCandidate = true; + cout <<"found bad track!"<(new bool(pass)) ); + + return taggingMode_ || pass; +} + +//define this as a plug-in +DEFINE_FWK_MODULE(BadChargedCandidateFilter); diff --git a/RecoMET/METFilters/plugins/BadChargedCandidateSummer16Filter.cc b/RecoMET/METFilters/plugins/BadChargedCandidateSummer16Filter.cc new file mode 100644 index 0000000000000..0e88dcb2207b3 --- /dev/null +++ b/RecoMET/METFilters/plugins/BadChargedCandidateSummer16Filter.cc @@ -0,0 +1,141 @@ +// system include files +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/global/EDFilter.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/Math/interface/deltaR.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonFwd.h" +#include "DataFormats/MuonReco/interface/MuonSelectors.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h" + +// +// class declaration +// + +class BadChargedCandidateSummer16Filter : public edm::global::EDFilter<> { +public: + explicit BadChargedCandidateSummer16Filter(const edm::ParameterSet&); + ~BadChargedCandidateSummer16Filter(); + +private: + virtual bool filter(edm::StreamID iID, edm::Event&, const edm::EventSetup&) const override; + + // ----------member data --------------------------- + + edm::EDGetTokenT > tokenPFCandidates_; + edm::EDGetTokenT > tokenMuons_; + + const bool taggingMode_; + const bool debug_; + const double maxDR_; + const double minPtDiffRel_; + const double minMuonTrackRelErr_; + const double minMuonPt_; + +}; + +// +// constructors and destructor +// +BadChargedCandidateSummer16Filter::BadChargedCandidateSummer16Filter(const edm::ParameterSet& iConfig) + : tokenPFCandidates_ ( consumes >(iConfig.getParameter ("PFCandidates") )) + , tokenMuons_ ( consumes >(iConfig.getParameter ("muons") )) + , taggingMode_ ( iConfig.getParameter ("taggingMode") ) + , debug_ ( iConfig.getParameter ("debug") ) + , maxDR_ ( iConfig.getParameter ("maxDR") ) + , minPtDiffRel_ ( iConfig.getParameter ("minPtDiffRel") ) + , minMuonTrackRelErr_ ( iConfig.getParameter ("minMuonTrackRelErr") ) + , minMuonPt_ ( iConfig.getParameter ("minMuonPt") ) +{ + produces(); +} + +BadChargedCandidateSummer16Filter::~BadChargedCandidateSummer16Filter() { } + + +// +// member functions +// + +// ------------ method called on each new Event ------------ +bool +BadChargedCandidateSummer16Filter::filter(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const +{ + using namespace std; + using namespace edm; + + typedef View CandidateView; + Handle pfCandidates; + iEvent.getByToken(tokenPFCandidates_,pfCandidates); + + typedef View MuonView; + Handle muons; + iEvent.getByToken(tokenMuons_,muons); + + bool foundBadChargedCandidate = false; + + for ( unsigned i=0; i < muons->size(); ++i ) { // loop over all muons + + const reco::Muon & muon = (*muons)[i]; + + if ( muon.pt() > minMuonPt_) { + reco::TrackRef innerMuonTrack = muon.innerTrack(); + if (debug_) cout<<"muon "<quality(reco::TrackBase::highPurity) ) { + if (debug_) cout<<"Skipping this muon because inner track is high purity."<ptError()/innerMuonTrack->pt()<ptError()/innerMuonTrack->pt() > minMuonTrackRelErr_ ) ) { + if (debug_) cout<<"Skipping this muon because seems well measured."<size(); ++j ) { + const reco::Candidate & pfCandidate = (*pfCandidates)[j]; + // look for charged hadrons + if (not ( abs(pfCandidate.pdgId()) == 211) ) continue; + float dr = deltaR( innerMuonTrack->eta(), innerMuonTrack->phi(), pfCandidate.eta(), pfCandidate.phi() ); + float dpt = ( pfCandidate.pt() - innerMuonTrack->pt())/(0.5*(innerMuonTrack->pt() + pfCandidate.pt())); + if ( (debug_) and (dr<0.5) ) cout<<" pt(it) "<pt()<<" candidate "<eta(), innerMuonTrack->phi(), pfCandidate.eta(), pfCandidate.phi() ) < maxDR_ ) + and ( ( pfCandidate.pt() - innerMuonTrack->pt())/(0.5*(innerMuonTrack->pt() + pfCandidate.pt())) > minPtDiffRel_ ) ) { + foundBadChargedCandidate = true; + cout <<"found bad track!"<(new bool(pass)) ); + + return taggingMode_ || pass; +} + +//define this as a plug-in +DEFINE_FWK_MODULE(BadChargedCandidateSummer16Filter); diff --git a/RecoMET/METFilters/plugins/BadPFMuonFilter.cc b/RecoMET/METFilters/plugins/BadPFMuonFilter.cc new file mode 100644 index 0000000000000..51a46fd14c5a7 --- /dev/null +++ b/RecoMET/METFilters/plugins/BadPFMuonFilter.cc @@ -0,0 +1,151 @@ +// system include files +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/global/EDFilter.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/Math/interface/deltaR.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonFwd.h" +#include "DataFormats/MuonReco/interface/MuonSelectors.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h" + +// +// class declaration +// + +class BadPFMuonFilter : public edm::global::EDFilter<> { +public: + explicit BadPFMuonFilter(const edm::ParameterSet&); + ~BadPFMuonFilter(); + +private: + virtual bool filter(edm::StreamID iID, edm::Event&, const edm::EventSetup&) const override; + + // ----------member data --------------------------- + + edm::EDGetTokenT > tokenPFCandidates_; + edm::EDGetTokenT > tokenMuons_; + + const bool taggingMode_; + const bool debug_; + const int algo_; + const double minDZ_; + const double minMuPt_; + const double minPtError_; + const double segmentCompatibility_; + +}; + +// +// constructors and destructor +// +BadPFMuonFilter::BadPFMuonFilter(const edm::ParameterSet& iConfig) + : tokenPFCandidates_ ( consumes >(iConfig.getParameter ("PFCandidates") )) + , tokenMuons_ ( consumes >(iConfig.getParameter ("muons") )) + , taggingMode_ ( iConfig.getParameter ("taggingMode") ) + , debug_ ( iConfig.getParameter ("debug") ) + , algo_ ( iConfig.getParameter ("algo") ) + , minDZ_ ( iConfig.getParameter ("minDZ") ) + , minMuPt_ ( iConfig.getParameter ("minMuPt") ) + , minPtError_ ( iConfig.getParameter ("minPtError") ) + , segmentCompatibility_ ( iConfig.getParameter ("segmentCompatibility") ) +{ + produces(); +} + +BadPFMuonFilter::~BadPFMuonFilter() { } + + +// +// member functions +// + +// ------------ method called on each new Event ------------ +bool +BadPFMuonFilter::filter(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const +{ + using namespace std; + using namespace edm; + + typedef View CandidateView; + Handle pfCandidates; + iEvent.getByToken(tokenPFCandidates_,pfCandidates); + + typedef View MuonView; + Handle muons; + iEvent.getByToken(tokenMuons_,muons); + + bool foundBadPFMuon = false; + + for ( unsigned i=0; i < muons->size(); ++i ) { // loop over all muons + + const reco::Muon & muon = (*muons)[i]; + + reco::TrackRef innerMuonTrack = muon.innerTrack(); + reco::TrackRef globalMuonTrack = muon.globalTrack(); + reco::TrackRef bestMuonTrack = muon.muonBestTrack(); + + if (debug_) cout << "PF filter muon:" << i << endl ; + if ( innerMuonTrack.isNull() ) { + if (debug_) cout<<"Skipping this muon because it has no inner track"<pt() < minMuPt_) and (muon.pt() < minMuPt_)) { + if (debug_) cout<<"Skipping this muon trackPt and globalPt is less than threshold"<originalAlgo() << endl; + if (not ( innerMuonTrack->originalAlgo() == algo_ && innerMuonTrack->algo() == algo_ ) ) { + if (debug_) cout<<"Skipping this muon because is not coming from the muonSeededStepOutIn"<ptError()/bestMuonTrack->pt() << endl; + if (muon::segmentCompatibility(muon) > segmentCompatibility_ && bestMuonTrack->ptError()/bestMuonTrack->pt() < minPtError_) { + if (debug_) cout <<"Skipping this muon because segment compatiblity > 0.3 and relErr(best track) <2 " << endl; + continue; + } + + for ( unsigned j=0; j < pfCandidates->size(); ++j ) { + const reco::Candidate & pfCandidate = (*pfCandidates)[j]; + // look for pf muon + if (debug_) cout << "pf pdgID:" << abs(pfCandidate.pdgId()) << "pt:" << pfCandidate.pt() << endl; + if ( not ( ( abs(pfCandidate.pdgId()) == 13) and (pfCandidate.pt() > minMuPt_) ) ) continue; + // require small dR + float dr = deltaR( muon.eta(), muon.phi(), pfCandidate.eta(), pfCandidate.phi() ); + if (dr < 0.001) { + foundBadPFMuon=true; + if (debug_) cout <<"found bad muon! SC:" << muon::segmentCompatibility(muon) <(new bool(pass)) ); + + return taggingMode_ || pass; +} + +//define this as a plug-in +DEFINE_FWK_MODULE(BadPFMuonFilter); diff --git a/RecoMET/METFilters/plugins/BadPFMuonSummer16Filter.cc b/RecoMET/METFilters/plugins/BadPFMuonSummer16Filter.cc new file mode 100644 index 0000000000000..17b800bc97093 --- /dev/null +++ b/RecoMET/METFilters/plugins/BadPFMuonSummer16Filter.cc @@ -0,0 +1,151 @@ +// system include files +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/global/EDFilter.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/Math/interface/deltaR.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonFwd.h" +#include "DataFormats/MuonReco/interface/MuonSelectors.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h" + +// +// class declaration +// + +class BadPFMuonSummer16Filter : public edm::global::EDFilter<> { +public: + explicit BadPFMuonSummer16Filter(const edm::ParameterSet&); + ~BadPFMuonSummer16Filter(); + +private: + virtual bool filter(edm::StreamID iID, edm::Event&, const edm::EventSetup&) const override; + + // ----------member data --------------------------- + + edm::EDGetTokenT > tokenPFCandidates_; + edm::EDGetTokenT > tokenMuons_; + + const bool taggingMode_; + const bool debug_; + const int algo_; + const double minDZ_; + const double minMuPt_; + const double minTrkPtError_; + +}; + +// +// constructors and destructor +// +BadPFMuonSummer16Filter::BadPFMuonSummer16Filter(const edm::ParameterSet& iConfig) + : tokenPFCandidates_ ( consumes >(iConfig.getParameter ("PFCandidates") )) + , tokenMuons_ ( consumes >(iConfig.getParameter ("muons") )) + , taggingMode_ ( iConfig.getParameter ("taggingMode") ) + , debug_ ( iConfig.getParameter ("debug") ) + , algo_ ( iConfig.getParameter ("algo") ) + , minDZ_ ( iConfig.getParameter ("minDZ") ) + , minMuPt_ ( iConfig.getParameter ("minMuPt") ) + , minTrkPtError_ ( iConfig.getParameter ("minTrkPtError") ) +{ + produces(); +} + +BadPFMuonSummer16Filter::~BadPFMuonSummer16Filter() { } + + +// +// member functions +// + +// ------------ method called on each new Event ------------ +bool +BadPFMuonSummer16Filter::filter(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const +{ + using namespace std; + using namespace edm; + + typedef View CandidateView; + Handle pfCandidates; + iEvent.getByToken(tokenPFCandidates_,pfCandidates); + + typedef View MuonView; + Handle muons; + iEvent.getByToken(tokenMuons_,muons); + + bool foundBadPFMuon = false; + + for ( unsigned i=0; i < muons->size(); ++i ) { // loop over all muons + + const reco::Muon & muon = (*muons)[i]; + + reco::TrackRef innerMuonTrack = muon.innerTrack(); + + if ( innerMuonTrack.isNull() ) { + if (debug_) cout<<"Skipping this muon because it has no inner track"<pt() < minMuPt_) { + if (debug_) cout<<"Skipping this muon because inner track pt."<quality(reco::TrackBase::highPurity) ) { + if (debug_) cout<<"Skipping this muon because inner track is high purity."<ptError()/innerMuonTrack->pt()<ptError()/innerMuonTrack->pt() > minTrkPtError_ ) ) { + if (debug_) cout<<"Skipping this muon because seems well measured."<originalAlgo() << endl; + if (not ( innerMuonTrack->originalAlgo() == algo_ && innerMuonTrack->algo() == algo_ ) ) { + if (debug_) cout<<"Skipping this muon because is not coming from the muonSeededStepOutIn"<size(); ++j ) { + const reco::Candidate & pfCandidate = (*pfCandidates)[j]; + // look for pf muon + if ( not ( ( abs(pfCandidate.pdgId()) == 13) and (pfCandidate.pt() > minMuPt_) ) ) continue; + // require small dR + float dr = deltaR( muon.eta(), muon.phi(), pfCandidate.eta(), pfCandidate.phi() ); + if( dr < 0.001 ) { + foundBadPFMuon=true; + if (debug_) cout <<"found bad muon!"<(new bool(pass)) ); + + return taggingMode_ || pass; +} + +//define this as a plug-in +DEFINE_FWK_MODULE(BadPFMuonSummer16Filter); diff --git a/RecoMET/METFilters/plugins/MuonBadTrackFilter.cc b/RecoMET/METFilters/plugins/MuonBadTrackFilter.cc index 48c92d103ac3b..39538847a9887 100644 --- a/RecoMET/METFilters/plugins/MuonBadTrackFilter.cc +++ b/RecoMET/METFilters/plugins/MuonBadTrackFilter.cc @@ -389,4 +389,4 @@ void MuonBadTrackFilter::printMuonProperties(const reco::MuonRef& muonRef) const //define this as a plug-in -DEFINE_FWK_MODULE(MuonBadTrackFilter); \ No newline at end of file +DEFINE_FWK_MODULE(MuonBadTrackFilter); diff --git a/RecoMET/METFilters/python/BadChargedCandidateFilter_cfi.py b/RecoMET/METFilters/python/BadChargedCandidateFilter_cfi.py new file mode 100644 index 0000000000000..aa9100b04a5fe --- /dev/null +++ b/RecoMET/METFilters/python/BadChargedCandidateFilter_cfi.py @@ -0,0 +1,16 @@ +import FWCore.ParameterSet.Config as cms + +BadChargedCandidateFilter = cms.EDFilter( + "BadChargedCandidateFilter", + PFCandidates = cms.InputTag("particleFlow"), # Collection to test + muons = cms.InputTag("muons"), # Collection to test + taggingMode = cms.bool(False), + debug = cms.bool(False), + maxDR = cms.double(0.001), # Maximum DR between reco::muon->innerTrack and pfCandidate + minPtDiffRel = cms.double(-0.5), # lower threshold on difference between pt of reco::muon->innerTrack and pfCandidate + # computed as (pfcand.pt - muon.track.pt)/(0.5*(pfcand.pt + muon.track.pt)) + minMuonTrackRelErr = cms.double(2.0), # minimum ptError/pt on muon best track + minMuonPt = cms.double(100), # minimum muon pt + segmentCompatibility = cms.double(0.3), # compatibility between the inner track and the segments in the muon spectrometer + +) diff --git a/RecoMET/METFilters/python/BadChargedCandidateSummer16Filter_cfi.py b/RecoMET/METFilters/python/BadChargedCandidateSummer16Filter_cfi.py new file mode 100644 index 0000000000000..14d1a481410e2 --- /dev/null +++ b/RecoMET/METFilters/python/BadChargedCandidateSummer16Filter_cfi.py @@ -0,0 +1,14 @@ +import FWCore.ParameterSet.Config as cms + +BadChargedCandidateSummer16Filter = cms.EDFilter( + "BadChargedCandidateSummer16Filter", + PFCandidates = cms.InputTag("particleFlow"), # Collection to test + muons = cms.InputTag("muons"), # Collection to test + taggingMode = cms.bool(False), + debug = cms.bool(False), + maxDR = cms.double(0.001), # Maximum DR between reco::muon->innerTrack and pfCandidate + minPtDiffRel = cms.double(-0.5), # lower threshold on difference between pt of reco::muon->innerTrack and pfCandidate + # computed as (pfcand.pt - muon.track.pt)/(0.5*(pfcand.pt + muon.track.pt)) + minMuonTrackRelErr = cms.double(0.5), # minimum ptError/pt on muon innertrack + minMuonPt = cms.double(100), # minimum muon pt +) diff --git a/RecoMET/METFilters/python/BadPFMuonFilter_cfi.py b/RecoMET/METFilters/python/BadPFMuonFilter_cfi.py new file mode 100644 index 0000000000000..b83eb4ccd1c1d --- /dev/null +++ b/RecoMET/METFilters/python/BadPFMuonFilter_cfi.py @@ -0,0 +1,14 @@ +import FWCore.ParameterSet.Config as cms + +BadPFMuonFilter = cms.EDFilter( + "BadPFMuonFilter", + PFCandidates = cms.InputTag("particleFlow"), # Collection to test + muons = cms.InputTag("muons"), # Collection to test + taggingMode = cms.bool(False), + debug = cms.bool(False), + algo = cms.int32(14), + minDZ = cms.double(0.1), # dz threshold on PF muons to consider; this is not used + minMuPt = cms.double(100), # pt threshold on PF muons + minPtError = cms.double(2.0), # threshold on inner track pt Error + segmentCompatibility = cms.double(0.3), # compatibility between the inner track and the segments in the muon spectrometer +) diff --git a/RecoMET/METFilters/python/BadPFMuonSummer16Filter_cfi.py b/RecoMET/METFilters/python/BadPFMuonSummer16Filter_cfi.py new file mode 100644 index 0000000000000..cb92878ceaa87 --- /dev/null +++ b/RecoMET/METFilters/python/BadPFMuonSummer16Filter_cfi.py @@ -0,0 +1,13 @@ +import FWCore.ParameterSet.Config as cms + +BadPFMuonSummer16Filter = cms.EDFilter( + "BadPFMuonSummer16Filter", + PFCandidates = cms.InputTag("particleFlow"), # Collection to test + muons = cms.InputTag("muons"), # Collection to test + taggingMode = cms.bool(False), + debug = cms.bool(False), + algo = cms.int32(14), + minDZ = cms.double(0.1), # dz threshold on PF muons to consider; this is not used + minMuPt = cms.double(100), # pt threshold on PF muons + minTrkPtError = cms.double(0.5), # threshold on inner track pt Error +) diff --git a/RecoMET/METFilters/python/metFilters_cff.py b/RecoMET/METFilters/python/metFilters_cff.py index 96c7589704d61..115f9c53c1635 100644 --- a/RecoMET/METFilters/python/metFilters_cff.py +++ b/RecoMET/METFilters/python/metFilters_cff.py @@ -73,6 +73,19 @@ ## The muon bad track filter ________________________________________________|| from RecoMET.METFilters.muonBadTrackFilter_cfi import * +## The charged hadron track track filter (2016) ____________________________________|| +from RecoMET.METFilters.BadChargedCandidateSummer16Filter_cfi import * + +## The muon bad track filter (2016) ________________________________________________|| +from RecoMET.METFilters.BadPFMuonSummer16Filter_cfi import * + +## The charged hadron track track filter (2016) ____________________________________|| +from RecoMET.METFilters.BadChargedCandidateFilter_cfi import * + +## The muon bad track filter (2016) ________________________________________________|| +from RecoMET.METFilters.BadPFMuonFilter_cfi import * + + metFilters = cms.Sequence( HBHENoiseFilterResultProducer * HBHENoiseFilter * @@ -94,5 +107,9 @@ # ecalLaserCorrFilter * # trkPOGFilters chargedHadronTrackResolutionFilter * + BadChargedCandidateFilter* + BadPFMuonFilter * + BadChargedCandidateSummer16Filter* + BadPFMuonSummer16Filter * muonBadTrackFilter ) diff --git a/RecoMET/METFilters/test/test_badChargedCandidateFilter.py b/RecoMET/METFilters/test/test_badChargedCandidateFilter.py new file mode 100644 index 0000000000000..aa333ea49a33f --- /dev/null +++ b/RecoMET/METFilters/test/test_badChargedCandidateFilter.py @@ -0,0 +1,45 @@ +import FWCore.ParameterSet.Config as cms +process = cms.Process("test") + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) +process.source = cms.Source( + 'PoolSource', + #RECO + #fileNames = cms.untracked.vstring('root://eoscms.cern.ch//store/group/phys_jetmet/MetScanners/bobak_pickevents.root') + #fileNames = cms.untracked.vstring('file:/afs/cern.ch/user/m/mzeinali/public/skim_9.root') + #fileNames = cms.untracked.vstring( 'file:lowMet_failBadChargedHadronFilter.root') + #miniAOD + #fileNames = cms.untracked.vstring('root://eoscms.cern.ch//store/group/phys_jetmet/MetScanners/bobak_pickevents_miniAOD.root ') + fileNames = cms.untracked.vstring('root://eoscms.cern.ch//store/mc/RunIISpring16MiniAODv1/SMS-T1tttt_mGluino-1500_mLSP-100_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/MINIAODSIM/PUSpring16_80X_mcRun2_asymptotic_2016_v3-v1/60000/26C76166-0FFE-E511-BA96-0025905D1D60.root') + #fileNames = cms.untracked.vstring( "file:/afs/cern.ch/user/s/schoef/eos/cms/store/mc/RunIISpring16MiniAODv1/SMS-T1tttt_mGluino-1500_mLSP-100_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/MINIAODSIM/PUSpring16_80X_mcRun2_asymptotic_2016_v3-v1/60000/26C76166-0FFE-E511-BA96-0025905D1D60.root") + #fileNames = cms.untracked.vstring( 'file:/data/rschoefbeck/local/SMS-T1tttt_mGluino-1500_mLSP-100_TuneCUETP8M1_13_MINIAODSIM.root') + ) + +process.load('Configuration.StandardSequences.Services_cff') +process.load('RecoMET.METFilters.BadChargedCandidateFilter_cfi') +process.load('RecoMET.METFilters.BadChargedCandidateSummer16Filter_cfi') + +## for miniAOD running +process.BadChargedCandidateFilter.muons = cms.InputTag("slimmedMuons") +process.BadChargedCandidateFilter.PFCandidates = cms.InputTag("packedPFCandidates") + +process.BadChargedCandidateFilter.debug = cms.bool(True) + +## for miniAOD running (ICHEP) +process.BadChargedCandidateSummer16Filter.muons = cms.InputTag("slimmedMuons") +process.BadChargedCandidateSummer16Filter.PFCandidates = cms.InputTag("packedPFCandidates") + +process.BadChargedCandidateSummer16Filter.debug = cms.bool(True) + +process.out = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string('histo.root'), + outputCommands = cms.untracked.vstring('keep *') +) +# +# RUN! +# +process.run = cms.Path( + process.BadChargedCandidateFilter * process.BadChargedCandidateSummer16Filter +) + +process.outpath = cms.EndPath(process.out) diff --git a/RecoMET/METFilters/test/test_badMuonCandidateFilter.py b/RecoMET/METFilters/test/test_badMuonCandidateFilter.py new file mode 100644 index 0000000000000..7940352775452 --- /dev/null +++ b/RecoMET/METFilters/test/test_badMuonCandidateFilter.py @@ -0,0 +1,44 @@ +import FWCore.ParameterSet.Config as cms +process = cms.Process("test") + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) +process.source = cms.Source( + 'PoolSource', + #RECO + #fileNames = cms.untracked.vstring('root://eoscms.cern.ch//store/group/phys_jetmet/MetScanners/bobak_pickevents.root') + #fileNames = cms.untracked.vstring('file:/afs/cern.ch/user/m/mzeinali/public/skim_9.root') + #fileNames = cms.untracked.vstring( 'file:lowMet_failBadChargedHadronFilter.root') + #miniAOD + #fileNames = cms.untracked.vstring('root://eoscms.cern.ch//store/group/phys_jetmet/MetScanners/bobak_pickevents_miniAOD.root ') + fileNames = cms.untracked.vstring('root://eoscms.cern.ch//store/mc/RunIISpring16MiniAODv1/SMS-T1tttt_mGluino-1500_mLSP-100_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/MINIAODSIM/PUSpring16_80X_mcRun2_asymptotic_2016_v3-v1/60000/26C76166-0FFE-E511-BA96-0025905D1D60.root') + #fileNames = cms.untracked.vstring( "file:/afs/cern.ch/user/s/schoef/eos/cms/store/mc/RunIISpring16MiniAODv1/SMS-T1tttt_mGluino-1500_mLSP-100_TuneCUETP8M1_13TeV-madgraphMLM-pythia8/MINIAODSIM/PUSpring16_80X_mcRun2_asymptotic_2016_v3-v1/60000/26C76166-0FFE-E511-BA96-0025905D1D60.root") + #fileNames = cms.untracked.vstring( 'file:/data/rschoefbeck/local/SMS-T1tttt_mGluino-1500_mLSP-100_TuneCUETP8M1_13_MINIAODSIM.root') + ) + +process.load('Configuration.StandardSequences.Services_cff') +process.load('RecoMET.METFilters.BadPFMuonFilter_cfi') +process.load('RecoMET.METFilters.BadPFMuonSummer16Filter_cfi') + +## for miniAOD running +process.BadPFMuonFilter.muons = cms.InputTag("slimmedMuons") +process.BadPFMuonFilter.PFCandidates = cms.InputTag("packedPFCandidates") + +## for miniAOD running ICHEP +process.BadPFMuonSummer16Filter.muons = cms.InputTag("slimmedMuons") +process.BadPFMuonSummer16Filter.PFCandidates = cms.InputTag("packedPFCandidates") + +process.BadPFMuonFilter.debug = cms.bool(True) +process.BadPFMuonSummer16Filter.debug = cms.bool(True) + +process.out = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string('histo.root'), + outputCommands = cms.untracked.vstring('keep *') +) +# +# RUN! +# +process.run = cms.Path( + process.BadPFMuonFilter * process.BadPFMuonSummer16Filter +) + +process.outpath = cms.EndPath(process.out)