#include <WtoLNuSelector.h>

Inheritance diagram for WtoLNuSelector:

Public Member Functions
	WtoLNuSelector (const edm::ParameterSet &)

Public Member Functions inherited from edm::stream::EDFilter<>
	EDFilter ()=default

Public Member Functions inherited from edm::stream::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDFilterBase ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
bool	filter (edm::Event &, edm::EventSetup const &) override

double	getMt (const TLorentzVector &vlep, const reco::PFMET &obj)

Private Attributes
const edm::InputTag	bsTag_

const edm::EDGetTokenT < reco::BeamSpot >	bsToken_

const edm::InputTag	electronTag_

const edm::EDGetTokenT < reco::GsfElectronCollection >	electronToken_

const edm::InputTag	muonTag_

const edm::EDGetTokenT < reco::MuonCollection >	muonToken_

const edm::InputTag	pfmetTag_

const edm::EDGetTokenT < reco::PFMETCollection >	pfmetToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDFilter<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDFilterBase
typedef EDFilterAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::stream::EDFilterBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 20 of file WtoLNuSelector.h.

Constructor & Destructor Documentation

WtoLNuSelector::WtoLNuSelector ( const edm::ParameterSet & ps )

explicit

Definition at line 25 of file WtoLNuSelector.cc.

                                                        : 
   electronTag_(ps.getUntrackedParameter<edm::InputTag>("electronInputTag", edm::InputTag("gedGsfElectrons"))),
   bsTag_(ps.getUntrackedParameter<edm::InputTag>("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))),
   muonTag_(ps.getUntrackedParameter<edm::InputTag>("muonInputTag", edm::InputTag("muons"))),
   //pfmetTag_(ps.getUntrackedParameter<edm::InputTag>("pfmetTag", edm::InputTag("pfMet"))),
   pfmetTag_(ps.getUntrackedParameter<edm::InputTag>("pfmetTag", edm::InputTag("pfMetT1T2Txy"))),
   electronToken_(consumes<reco::GsfElectronCollection>(electronTag_)),
   bsToken_(consumes<reco::BeamSpot>(bsTag_)),
   muonToken_(consumes<reco::MuonCollection>(muonTag_)),
   pfmetToken_(consumes<reco::PFMETCollection>(pfmetTag_))
 {
 }

Member Function Documentation

bool WtoLNuSelector::filter	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

overrideprivatevirtual

Implements edm::stream::EDFilterBase.

Definition at line 38 of file WtoLNuSelector.cc.

References SiPixelRawToDigiRegional_cfi::beamSpot, bsTag_, bsToken_, reco::TrackBase::chi2(), reco::TrackBase::d0(), reco::TrackBase::dxy(), reco::TrackBase::dz(), electronTag_, electronToken_, edm::Event::getByToken(), getMt(), reco::TrackBase::hitPattern(), edm::Ref< C, T, F >::isNonnull(), edm::HandleBase::isValid(), asciidump::le, bookConverter::max, RPCpg::mu, muonTag_, muonToken_, reco::TrackBase::ndof(), reco::HitPattern::numberOfValidPixelHits(), reco::HitPattern::numberOfValidStripHits(), pfmetTag_, pfmetToken_, reco::GsfElectron::PflowIsolationVariables::sumChargedHadronPt, reco::MuonPFIsolation::sumChargedParticlePt, reco::MuonPFIsolation::sumNeutralHadronEt, reco::GsfElectron::PflowIsolationVariables::sumNeutralHadronEt, reco::MuonPFIsolation::sumPhotonEt, reco::GsfElectron::PflowIsolationVariables::sumPhotonEt, reco::MuonPFIsolation::sumPUPt, and reco::GsfElectron::PflowIsolationVariables::sumPUPt.

Referenced by Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::filter(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::setDataAccessor(), and Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::switchCenterView().

                                                                          {
   // Read Electron Collection
   edm::Handle<reco::GsfElectronCollection> electronColl;
   iEvent.getByToken(electronToken_, electronColl);
   
   edm::Handle<reco::BeamSpot> beamSpot;
   iEvent.getByToken(bsToken_, beamSpot);
   
   std::vector<TLorentzVector> eleList; 
   if (electronColl.isValid()) {
     for (auto const& ele : *electronColl) {
       if (!ele.ecalDriven() ) continue;
 
       double hOverE = ele.hadronicOverEm();
       double sigmaee = ele.sigmaIetaIeta();
       double deltaPhiIn = ele.deltaPhiSuperClusterTrackAtVtx();
       double deltaEtaIn = ele.deltaEtaSuperClusterTrackAtVtx();
 
       // separate cut for barrel and endcap
       if (ele.isEB()) {
         if (std::fabs(deltaPhiIn) >= .15
             && std::fabs(deltaEtaIn) >= .007
             && hOverE >= .12
             && sigmaee >= .01) continue;
       }
       else if (ele.isEE()) {
         if (std::fabs(deltaPhiIn) >= .10
             && std::fabs(deltaEtaIn) >= .009
             && hOverE >= .10
             && sigmaee >= .03) continue;
       }
 
       reco::GsfTrackRef trk = ele.gsfTrack();
       if (!trk.isNonnull() ) continue; // only electrons wd tracks
       double chi2 = trk->chi2();
       double ndof = trk->ndof();
       double chbyndof = (ndof > 0) ? chi2/ndof : 0;
       double trkd0 = trk->d0();
       double trkdz = trk->dz();
       if (beamSpot.isValid()) {
         trkd0 = -(trk->dxy(beamSpot->position()));
         trkdz = trk->dz(beamSpot->position());
       }
       else {
     edm::LogError("WtoLNuSelector") << "Error >> Failed to get BeamSpot for label: "
                                       << bsTag_;
       }
       if (chbyndof >= 10 || std::fabs(trkd0) >= 0.02 || std::fabs(trkdz) >= 20) continue;
       const reco::HitPattern& hitp = trk->hitPattern();
       int nPixelHits = hitp.numberOfValidPixelHits();
       int nStripHits = hitp.numberOfValidStripHits();
       if (nPixelHits < 1 || nStripHits < 8) continue;
 
       // PF Isolation
       reco::GsfElectron::PflowIsolationVariables pfIso = ele.pfIsolationVariables();
       float absiso = pfIso.sumChargedHadronPt 
     + std::max(0.0, pfIso.sumNeutralHadronEt + pfIso.sumPhotonEt - 0.5 * pfIso.sumPUPt);
       float eiso = absiso/ele.pt();
       if (eiso > 0.3) continue;
 
       TLorentzVector le;
       le.SetPtEtaPhiE(ele.pt(), ele.eta(), ele.phi(), ele.energy());
       eleList.push_back(le);
     }
   }
   else {
     edm::LogError("WtoLNuSelector") << "Error >> Failed to get ElectronCollection for label: " 
                   << electronTag_;
   }
 
   // Read Muon Collection                                                                                                     
   edm::Handle<reco::MuonCollection> muonColl;
   iEvent.getByToken(muonToken_, muonColl);
   
   std::vector<TLorentzVector> muList; 
   if (muonColl.isValid()) {
     for (auto const& mu : *muonColl) {
       if (!mu.isGlobalMuon()
           || !mu.isPFMuon()
           || std::fabs(mu.eta()) > 2.1
           || mu.pt() <= 5) continue;
 
       reco::TrackRef gtrkref = mu.globalTrack();
       if (!gtrkref.isNonnull()) continue;
       const reco::Track* gtk = &(*gtrkref);
       double chi2 = gtk->chi2();
       double ndof = gtk->ndof();
       double chbyndof = (ndof > 0) ? chi2/ndof : 0;
 
       const reco::HitPattern& hitp = gtk->hitPattern();
       int nPixelHits = hitp.numberOfValidPixelHits();
       int nStripHits = hitp.numberOfValidStripHits();
 
       reco::TrackRef itrkref = mu.innerTrack();  // tracker segment only  
       if (!itrkref.isNonnull()) continue;
       const reco::Track* tk = &(*itrkref);
       double trkd0 = tk->d0();
       double trkdz = tk->dz();
       if (beamSpot.isValid()) {
         trkd0 = -(tk->dxy(beamSpot->position()));
         trkdz = tk->dz(beamSpot->position());
       }
       // Hits/section in the muon chamber 
       int nChambers = mu.numberOfChambers();
       int nMatches = mu.numberOfMatches();
       int nMatchedStations = mu.numberOfMatchedStations();
 
       // PF Isolation
       const reco::MuonPFIsolation& pfIso04 = mu.pfIsolationR04();
       double absiso = pfIso04.sumChargedParticlePt + std::max(0.0, pfIso04.sumNeutralHadronEt + pfIso04.sumPhotonEt - 0.5 * pfIso04.sumPUPt);
 
       // Final selection
       if (chbyndof < 10
           && std::fabs(trkd0) < 0.02
           && std::fabs(trkdz) < 20.0
           && nPixelHits > 1
           && nStripHits > 8
           && nChambers > 2
           && nMatches > 2
           && nMatchedStations > 2
           && absiso/mu.pt() < 0.3)
         {
           TLorentzVector lm;
           lm.SetPtEtaPhiE(mu.pt(), mu.eta(), mu.phi(), mu.energy());
           muList.push_back(lm);
         }
     }
   }
   else {
     edm::LogError("WtoLNuSelector") << "Error >> Failed to get MuonCollection for label: " << muonTag_;
   }
 
   // Require either a high pt electron or muon
   if (eleList.size() < 1 && muList.size() < 1) return false;
 
   // Both should not be present at the same time
   if ((eleList.size() > 0 && eleList[0].Pt() > 20) && 
       (muList.size() > 0 && muList[0].Pt() > 20)) return false;
 
   // find the high pt lepton
   TLorentzVector vlep;
   if (eleList.size() > 0 && muList.size() > 0) {
     vlep = (eleList[0].Pt() > muList[0].Pt()) ? eleList[0] : muList[0];
   }
   else if (eleList.size() > 0) {
     vlep = eleList[0];
   }
   else {
     vlep = muList[0];
   }
   if (vlep.Pt() < 20) return false;
       
   edm::Handle<reco::PFMETCollection> pfColl;
   iEvent.getByToken(pfmetToken_, pfColl);
 
   if (pfColl.isValid()) {
     double mt = getMt(vlep, pfColl->front());  
     if (mt < 60 || mt > 80) return false;
   }
   else {
     edm::LogError("WtoLNuSelector") << "Error >> Failed to get PFMETCollection for label: " << pfmetTag_;
     return false;
   }
 
   return true;
 }

double WtoLNuSelector::getMt	(	const TLorentzVector &	vlep,
		const reco::PFMET &	obj
	)

private

Definition at line 204 of file WtoLNuSelector.cc.

References funct::cos(), SiPixelRawToDigiRegional_cfi::deltaPhi, reco::LeafCandidate::et(), caloMETBenchmarkGeneric_cfi::met, phi, reco::LeafCandidate::phi(), funct::sin(), and mathSSE::sqrt().

Referenced by filter().

                                                                              {
   double met = obj.et();
   double phi = obj.phi();
 
   TLorentzVector vmet;
   double metx =  met * std::cos(phi);
   double mety =  met * std::sin(phi);
   vmet.SetPxPyPzE(metx, mety, 0.0, met);
   
   // transverse mass
   TLorentzVector vw = vlep + vmet;
 
   return std::sqrt(2 * vlep.Et() * met * (1 - std::cos(deltaPhi(vlep.Phi(), phi))));  
 }

Member Data Documentation

const edm::InputTag WtoLNuSelector::bsTag_

private

Definition at line 31 of file WtoLNuSelector.h.

Referenced by filter().

const edm::EDGetTokenT<reco::BeamSpot> WtoLNuSelector::bsToken_

private

Definition at line 35 of file WtoLNuSelector.h.

Referenced by filter().

const edm::InputTag WtoLNuSelector::electronTag_

private

Definition at line 30 of file WtoLNuSelector.h.

Referenced by filter().

const edm::EDGetTokenT<reco::GsfElectronCollection> WtoLNuSelector::electronToken_

private

Definition at line 34 of file WtoLNuSelector.h.

Referenced by filter().

const edm::InputTag WtoLNuSelector::muonTag_

private

Definition at line 32 of file WtoLNuSelector.h.

Referenced by filter().

const edm::EDGetTokenT<reco::MuonCollection> WtoLNuSelector::muonToken_

private

Definition at line 36 of file WtoLNuSelector.h.

Referenced by filter().

const edm::InputTag WtoLNuSelector::pfmetTag_

private

Definition at line 33 of file WtoLNuSelector.h.

Referenced by filter().

const edm::EDGetTokenT<reco::PFMETCollection> WtoLNuSelector::pfmetToken_

private

Definition at line 37 of file WtoLNuSelector.h.

Referenced by filter().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation