#include <WtoLNuSelector.h>

Inheritance diagram for WtoLNuSelector:

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

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

	EDFilter (const EDFilter &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDFilter &	operator= (const EDFilter &)=delete

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

	EDFilterBase (const EDFilterBase &)=delete

ModuleDescription const &	moduleDescription () const

const EDFilterBase &	operator= (const EDFilterBase &)=delete

	~EDFilterBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

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

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 23 of file WtoLNuSelector.h.

Constructor & Destructor Documentation

◆ WtoLNuSelector()

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

◆ filter()

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

overrideprivatevirtual

Implements edm::stream::EDFilterBase.

Definition at line 36 of file WtoLNuSelector.cc.

References pwdgSkimBPark_cfi::beamSpot, bsTag_, bsToken_, hltPixelTracks_cff::chi2, reco::TrackBase::chi2(), reco::TrackBase::d0(), electronIdCutBasedExt_cfi::deltaEtaIn, electronIdCutBasedExt_cfi::deltaPhiIn, reco::TrackBase::dxy(), reco::TrackBase::dz(), electronTag_, electronToken_, getMt(), reco::TrackBase::hitPattern(), EgHLTOffHistBins_cfi::hOverE, iEvent, edm::Ref< C, T, F >::isNonnull(), edm::HandleBase::isValid(), SiStripPI::max, TtSemiLepEvtBuilder_cfi::mt, amptDefaultParameters_cff::mu, muonTag_, muonToken_, ndof, 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.

                                                                          {
   // 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.empty() && muList.empty())
     return false;
 
   // Both should not be present at the same time
   if ((!eleList.empty() && eleList[0].Pt() > 20) && (!muList.empty() && muList[0].Pt() > 20))
     return false;
 
   // find the high pt lepton
   TLorentzVector vlep;
   if (!eleList.empty() && !muList.empty()) {
     vlep = (eleList[0].Pt() > muList[0].Pt()) ? eleList[0] : muList[0];
   } else if (!eleList.empty()) {
     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;
 }

◆ getMt()

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

private

Definition at line 190 of file WtoLNuSelector.cc.

References funct::cos(), SiPixelRawToDigiRegional_cfi::deltaPhi, BTaggingMonitor_cfi::met, getGTfromDQMFile::obj, 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

◆ bsTag_

const edm::InputTag WtoLNuSelector::bsTag_

private

Definition at line 34 of file WtoLNuSelector.h.

Referenced by filter().

◆ bsToken_

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

private

Definition at line 38 of file WtoLNuSelector.h.

Referenced by filter().

◆ electronTag_

const edm::InputTag WtoLNuSelector::electronTag_

private

Definition at line 33 of file WtoLNuSelector.h.

Referenced by filter().

◆ electronToken_

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

private

Definition at line 37 of file WtoLNuSelector.h.

Referenced by filter().

◆ muonTag_

const edm::InputTag WtoLNuSelector::muonTag_

private

Definition at line 35 of file WtoLNuSelector.h.

Referenced by filter().

◆ muonToken_

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

private

Definition at line 39 of file WtoLNuSelector.h.

Referenced by filter().

◆ pfmetTag_

const edm::InputTag WtoLNuSelector::pfmetTag_

private

Definition at line 36 of file WtoLNuSelector.h.

Referenced by filter().

◆ pfmetToken_

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

private

Definition at line 40 of file WtoLNuSelector.h.

Referenced by filter().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ WtoLNuSelector()

Member Function Documentation

◆ filter()

◆ getMt()

Member Data Documentation

◆ bsTag_

◆ bsToken_

◆ electronTag_

◆ electronToken_

◆ muonTag_

◆ muonToken_

◆ pfmetTag_

◆ pfmetToken_