Skip to content

Commit

Permalink
new met filter
Browse files Browse the repository at this point in the history
  • Loading branch information
amkalsi committed May 28, 2020
1 parent 442ae07 commit 88b2430
Show file tree
Hide file tree
Showing 3 changed files with 199 additions and 155 deletions.
348 changes: 193 additions & 155 deletions RecoMET/METFilters/plugins/BadParticleFilter.cc
View file
Expand Up @@ -19,182 +19,220 @@
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"

//
// class declaration
//

class BadParticleFilter : public edm::global::EDFilter<> {
public:
explicit BadParticleFilter(const edm::ParameterSet&);
~BadParticleFilter() override;

private:
bool filter(edm::StreamID iID, edm::Event&, const edm::EventSetup&) const override;

// ----------member data ---------------------------

edm::EDGetTokenT<edm::View<reco::Candidate> > tokenPFCandidates_;
edm::EDGetTokenT<edm::View<reco::Muon> > tokenMuons_;

const bool taggingMode_;
int algo_;
const double maxDR_;
const double minPtDiffRel_;
const double minMuonTrackRelErr_;
const double innerTrackRelErr_;
const double minMuPt_;
const double segmentCompatibility_;

double maxDR2_;

int filterType_;
enum { kBadPFMuon = 0, kBadPFMuonSummer16, kBadChargedCandidate, kBadChargedCandidateSummer16 };
public:
explicit BadParticleFilter(const edm::ParameterSet&);
~BadParticleFilter() override;

private:
bool filter(edm::StreamID iID, edm::Event&, const edm::EventSetup&) const override;

// ----------member data ---------------------------

edm::EDGetTokenT<edm::View<reco::Candidate> > tokenPFCandidates_;
edm::EDGetTokenT<edm::View<reco::Muon> > tokenMuons_;
edm::EDGetTokenT<std::vector<reco::Vertex>> vtx_;

const bool taggingMode_;
int algo_;
const double maxDR_;
const double minPtDiffRel_;
const double minMuonTrackRelErr_;
const double innerTrackRelErr_;
const double minDxyBestTrack;
const double minDzBestTrack;
const double minMuPt_;
const double segmentCompatibility_;

double maxDR2_;

int filterType_;
enum {kBadPFMuon=0,kBadPFMuonSummer16,kBadChargedCandidate,kBadChargedCandidateSummer16,kBadPFMuonDxyDz,kBadPFMuonDz};
};

//
// constructors and destructor
//
BadParticleFilter::BadParticleFilter(const edm::ParameterSet& iConfig)
: tokenPFCandidates_(consumes<edm::View<reco::Candidate> >(iConfig.getParameter<edm::InputTag>("PFCandidates"))),
tokenMuons_(consumes<edm::View<reco::Muon> >(iConfig.getParameter<edm::InputTag>("muons"))),
taggingMode_(iConfig.getParameter<bool>("taggingMode")),
maxDR_(iConfig.getParameter<double>("maxDR")),
minPtDiffRel_(iConfig.getParameter<double>("minPtDiffRel")),
minMuonTrackRelErr_(iConfig.getParameter<double>("minMuonTrackRelErr")),
innerTrackRelErr_(iConfig.getParameter<double>("innerTrackRelErr")),
minMuPt_(iConfig.getParameter<double>("minMuonPt")),
segmentCompatibility_(iConfig.getParameter<double>("segmentCompatibility")) {
maxDR2_ = maxDR_ * maxDR_;

std::string filterName = iConfig.getParameter<std::string>("filterType");
if (filterName == "BadPFMuon")
filterType_ = kBadPFMuon;
else if (filterName == "BadPFMuonSummer16")
filterType_ = kBadPFMuonSummer16;
else if (filterName == "BadChargedCandidate")
filterType_ = kBadChargedCandidate;
else if (filterName == "BadChargedCandidateSummer16")
filterType_ = kBadChargedCandidateSummer16;
else {
throw cms::Exception("BadParticleFilter") << " Filter " << filterName << " is not available, please check name \n";
}

algo_ = 0;
if (filterType_ == kBadPFMuon) {
algo_ = iConfig.getParameter<int>("algo");
}

produces<bool>();
: tokenPFCandidates_ ( consumes<edm::View<reco::Candidate> >(iConfig.getParameter<edm::InputTag> ("PFCandidates") ))
, tokenMuons_ ( consumes<edm::View<reco::Muon> >(iConfig.getParameter<edm::InputTag> ("muons") ))
, vtx_(consumes<std::vector<reco::Vertex>>(iConfig.getParameter<edm::InputTag>("vtx")))
, taggingMode_ ( iConfig.getParameter<bool> ("taggingMode") )
, maxDR_ ( iConfig.getParameter<double> ("maxDR") )
, minPtDiffRel_ ( iConfig.getParameter<double> ("minPtDiffRel") )
, minMuonTrackRelErr_ ( iConfig.getParameter<double> ("minMuonTrackRelErr") )
, innerTrackRelErr_ ( iConfig.getParameter<double> ("innerTrackRelErr") )
, minDxyBestTrack ( iConfig.getParameter<double> ("minDxyBestTrack") )
, minDzBestTrack ( iConfig.getParameter<double> ("minDzBestTrack") )
, minMuPt_ ( iConfig.getParameter<double> ("minMuonPt") )
, segmentCompatibility_ ( iConfig.getParameter<double> ("segmentCompatibility") )

{
maxDR2_=maxDR_*maxDR_;

std::string filterName=iConfig.getParameter<std::string>("filterType");
if(filterName=="BadPFMuon") filterType_=kBadPFMuon;
else if(filterName=="BadPFMuonSummer16") filterType_=kBadPFMuonSummer16;
else if(filterName=="BadChargedCandidate") filterType_=kBadChargedCandidate;
else if(filterName=="BadChargedCandidateSummer16") filterType_=kBadChargedCandidateSummer16;
else if(filterName=="BadPFMuonDxyDz") filterType_=kBadPFMuonDxyDz;
else if(filterName=="BadPFMuonDz") filterType_=kBadPFMuonDz;
else {
throw cms::Exception("BadParticleFilter")<<" Filter "<<filterName<<" is not available, please check name \n";
}

algo_=0;
if(filterType_==kBadPFMuon || filterType_==kBadPFMuonDxyDz || filterType_==kBadPFMuonDz) {
algo_=iConfig.getParameter<int>("algo");
}

produces<bool>();
}

BadParticleFilter::~BadParticleFilter() {}
BadParticleFilter::~BadParticleFilter() { }


//
// member functions
//

// ------------ method called on each new Event ------------
bool BadParticleFilter::filter(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const {
using namespace std;
using namespace edm;

typedef View<reco::Candidate> CandidateView;
Handle<CandidateView> pfCandidates;
iEvent.getByToken(tokenPFCandidates_, pfCandidates);

typedef View<reco::Muon> MuonView;
Handle<MuonView> muons;
iEvent.getByToken(tokenMuons_, muons);

bool foundBadCandidate = 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 bestMuonTrack = muon.muonBestTrack();

if (innerMuonTrack.isNull()) {
continue;
}

if (filterType_ == kBadChargedCandidate || filterType_ == kBadPFMuon) {
if (muon.pt() < minMuPt_ && innerMuonTrack->pt() < minMuPt_)
continue;
}
if (filterType_ == kBadChargedCandidateSummer16) {
if (muon.pt() < minMuPt_)
continue;
}
if (filterType_ == kBadPFMuonSummer16) {
if (innerMuonTrack->pt() < minMuPt_)
continue;
}

// Consider only Global Muons
if (filterType_ == kBadChargedCandidate || filterType_ == kBadPFMuon) {
if (muon.isGlobalMuon() == 0)
continue;
}

if (filterType_ == kBadPFMuon || filterType_ == kBadPFMuonSummer16) {
if (!(innerMuonTrack->originalAlgo() == algo_ && innerMuonTrack->algo() == algo_))
continue;
}

if (filterType_ == kBadChargedCandidate || filterType_ == kBadPFMuon) {
if (muon::segmentCompatibility(muon) > segmentCompatibility_ &&
bestMuonTrack->ptError() / bestMuonTrack->pt() < minMuonTrackRelErr_ &&
innerMuonTrack->ptError() / innerMuonTrack->pt() < innerTrackRelErr_) {
continue;
}
}
if (filterType_ == kBadChargedCandidateSummer16 || filterType_ == kBadPFMuonSummer16) {
if (innerMuonTrack->quality(reco::TrackBase::highPurity))
continue;
if (!(innerMuonTrack->ptError() / innerMuonTrack->pt() > minMuonTrackRelErr_))
continue;
}

for (unsigned j = 0; j < pfCandidates->size(); ++j) {
const reco::Candidate& pfCandidate = (*pfCandidates)[j];

float dr2 = 1000;
if (filterType_ == kBadChargedCandidate || filterType_ == kBadChargedCandidateSummer16) {
if (!(std::abs(pfCandidate.pdgId()) == 211))
continue;
dr2 = deltaR2(innerMuonTrack->eta(), innerMuonTrack->phi(), pfCandidate.eta(), pfCandidate.phi());
float dpt = (pfCandidate.pt() - innerMuonTrack->pt()) / (0.5 * (innerMuonTrack->pt() + pfCandidate.pt()));
if ((dr2 < maxDR2_) && (std::abs(dpt) < minPtDiffRel_) &&
(filterType_ == kBadChargedCandidateSummer16 || muon.isPFMuon() == 0)) {
foundBadCandidate = true;
break;
}
}

if (filterType_ == kBadPFMuon || filterType_ == kBadPFMuonSummer16) {
if (!((std::abs(pfCandidate.pdgId()) == 13) && (pfCandidate.pt() > minMuPt_)))
continue;
dr2 = deltaR2(muon.eta(), muon.phi(), pfCandidate.eta(), pfCandidate.phi());
if (dr2 < maxDR2_) {
foundBadCandidate = true;
break;
}
}

if (foundBadCandidate)
break;
}
} // end loop over muonss

bool pass = !foundBadCandidate;

iEvent.put(std::unique_ptr<bool>(new bool(pass)));

return taggingMode_ || pass;
bool
BadParticleFilter::filter(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const
{
using namespace std;
using namespace edm;

typedef View<reco::Candidate> CandidateView;
Handle<CandidateView> pfCandidates;
iEvent.getByToken(tokenPFCandidates_,pfCandidates);

typedef View<reco::Muon> MuonView;
Handle<MuonView> muons;
iEvent.getByToken(tokenMuons_,muons);

Handle<std::vector<reco::Vertex>> vtx;
iEvent.getByToken(vtx_, vtx);
assert(!vtx->empty());
const auto &PV = vtx->front().position();


bool foundBadCandidate = 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 bestMuonTrack = muon.muonBestTrack();

if(innerMuonTrack.isNull() ) {
continue;
}

if(filterType_==kBadChargedCandidate || filterType_==kBadPFMuon || filterType_==kBadPFMuonDxyDz || filterType_==kBadPFMuonDz) {
if(muon.pt()<minMuPt_ && innerMuonTrack->pt() < minMuPt_) continue;
}
if(filterType_==kBadChargedCandidateSummer16) {
if(muon.pt()<minMuPt_) continue;
}
if(filterType_==kBadPFMuonSummer16) {
if(innerMuonTrack->pt() < minMuPt_) continue;
}

// Consider only Global Muons
if(filterType_==kBadChargedCandidate || filterType_==kBadPFMuon || filterType_==kBadPFMuonDxyDz || filterType_==kBadPFMuonDz) {
if(muon.isGlobalMuon() == 0) continue;
}


if(filterType_==kBadPFMuon || filterType_==kBadPFMuonSummer16 || filterType_==kBadPFMuonDxyDz || filterType_==kBadPFMuonDz) {
if(! (innerMuonTrack->originalAlgo() == algo_ &&
innerMuonTrack->algo() == algo_ ) ) continue;
}

if(filterType_==kBadChargedCandidate || filterType_==kBadPFMuon) {
if(muon::segmentCompatibility(muon) > segmentCompatibility_ &&
bestMuonTrack->ptError()/bestMuonTrack->pt() < minMuonTrackRelErr_ &&
innerMuonTrack->ptError()/innerMuonTrack->pt() < innerTrackRelErr_ ) {
continue;
}
}


if(filterType_==kBadPFMuonDxyDz) {
if(muon::segmentCompatibility(muon) > segmentCompatibility_ &&
bestMuonTrack->ptError()/bestMuonTrack->pt() < minMuonTrackRelErr_ &&
innerMuonTrack->ptError()/innerMuonTrack->pt() < innerTrackRelErr_ &&
fabs(bestMuonTrack->dxy(PV)) < minDxyBestTrack &&
fabs(bestMuonTrack->dz(PV)) < minDzBestTrack ) {
continue;
}
}

if(filterType_==kBadPFMuonDz) {

if(muon::segmentCompatibility(muon) > segmentCompatibility_ &&
bestMuonTrack->ptError()/bestMuonTrack->pt() < minMuonTrackRelErr_ &&
innerMuonTrack->ptError()/innerMuonTrack->pt() < innerTrackRelErr_ &&
fabs(bestMuonTrack->dz(PV)) < minDzBestTrack ) {
continue;
}
}

if(filterType_==kBadChargedCandidateSummer16 || filterType_==kBadPFMuonSummer16) {
if(innerMuonTrack->quality(reco::TrackBase::highPurity)) continue;
if(!(innerMuonTrack->ptError()/innerMuonTrack->pt() > minMuonTrackRelErr_) ) continue;
}


for(unsigned j=0;j<pfCandidates->size();++j ) {
const reco::Candidate & pfCandidate = (*pfCandidates)[j];

float dr2=1000;
if(filterType_==kBadChargedCandidate || filterType_==kBadChargedCandidateSummer16) {
if(!(std::abs(pfCandidate.pdgId()) == 211) ) continue;
dr2 = deltaR2( innerMuonTrack->eta(), innerMuonTrack->phi(), pfCandidate.eta(), pfCandidate.phi() );
float dpt = ( pfCandidate.pt() - innerMuonTrack->pt())/(0.5*(innerMuonTrack->pt() + pfCandidate.pt()));
if( (dr2<maxDR2_) && (std::abs(dpt)<minPtDiffRel_) &&
(filterType_==kBadChargedCandidateSummer16 || muon.isPFMuon()==0) ) {
foundBadCandidate = true;
break;
}

}

if(filterType_==kBadPFMuon || filterType_==kBadPFMuonSummer16 || filterType_==kBadPFMuonDxyDz || filterType_==kBadPFMuonDz) {
if(!((std::abs(pfCandidate.pdgId()) == 13) && (pfCandidate.pt() > minMuPt_) ) ) continue;
dr2 = deltaR2( muon.eta(), muon.phi(), pfCandidate.eta(), pfCandidate.phi() );
if (dr2 < maxDR2_) {
foundBadCandidate=true;
break;
}
}

if(foundBadCandidate) break;

}
} // end loop over muonss

bool pass = !foundBadCandidate;

iEvent.put( std::unique_ptr<bool>(new bool(pass)) );

return taggingMode_ || pass;


}




//define this as a plug-in
DEFINE_FWK_MODULE(BadParticleFilter);
3 changes: 3 additions & 0 deletions RecoMET/METFilters/python/BadPFMuonFilter_cfi.py
View file
Expand Up @@ -4,13 +4,16 @@
"BadParticleFilter",
PFCandidates = cms.InputTag("particleFlow"), # Collection to test
muons = cms.InputTag("muons"), # Collection to test
vtx = cms.InputTag("offlinePrimaryVertices"),
taggingMode = cms.bool(False),
filterType =cms.string("BadPFMuon"),
maxDR = cms.double(0.001), # Maximum DR between reco::muon->innerTrack and pfCandidate
minPtDiffRel = cms.double(0.0), # lower threshold on difference between pt of reco::muon->innerTrack and pfCandidate
algo = cms.int32(14),
minMuonTrackRelErr = cms.double(2.0), # threshold on best track RelptError
innerTrackRelErr = cms.double(1.0), # threshold on innerTrack relPtErr
minDxyBestTrack = cms.double(-1.0),
minDzBestTrack = cms.double(-1.0),
minMuonPt = cms.double(100), # pt threshold on PF muons
segmentCompatibility = cms.double(0.3), # compatibility between the inner track and the segments in the muon spectrometer
)

0 comments on commit 88b2430

Please sign in to comment.