Inheritance diagram for PatElectronAnalyzer:

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

	~PatElectronAnalyzer () override

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () 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
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	endJob () override

Private Attributes
TH1F *	deltaPhi_

TH1F *	deltaR_

std::string	electronID_

edm::EDGetTokenT< std::vector < pat::Electron > >	electronSrcToken_

TH1F *	eta_

TH1F *	genEta_

edm::ParameterSet	genMatchMode_

TH1F *	genPhi_

TH1F *	genPt_

TH1F *	invMass_

TH1F *	isoTag_

double	maxDeltaM_

double	maxDeltaR_

double	maxEta_

double	maxTagIso_

double	minPt_

unsigned int	mode_

TH1I *	nr_

edm::EDGetTokenT < reco::GenParticleCollection >	particleSrcToken_

TH1F *	phi_

TH1F *	pt_

edm::ParameterSet	tagAndProbeMode_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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 () noexcept

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

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 15 of file PatElectronAnalyzer.cc.

Constructor & Destructor Documentation

PatElectronAnalyzer::PatElectronAnalyzer ( const edm::ParameterSet & cfg )

explicit

Definition at line 75 of file PatElectronAnalyzer.cc.

References deltaPhi_, deltaR_, eta_, genEta_, genMatchMode_, genPhi_, genPt_, edm::ParameterSet::getParameter(), invMass_, isoTag_, maxDeltaM_, maxDeltaR_, maxTagIso_, nr_, phi_, pt_, and tagAndProbeMode_.

     : minPt_(cfg.getParameter<double>("minPt")),
       maxEta_(cfg.getParameter<double>("maxEta")),
       mode_(cfg.getParameter<unsigned int>("mode")),
       electronID_(cfg.getParameter<std::string>("electronID")),
       electronSrcToken_(consumes<std::vector<pat::Electron> >(cfg.getParameter<edm::InputTag>("electronSrc"))),
       particleSrcToken_(consumes<reco::GenParticleCollection>(cfg.getParameter<edm::InputTag>("particleSrc"))),
       genMatchMode_(cfg.getParameter<edm::ParameterSet>("genMatchMode")),
       tagAndProbeMode_(cfg.getParameter<edm::ParameterSet>("tagAndProbeMode")) {
   // complete the configuration of the analyzer
   maxDeltaR_ = genMatchMode_.getParameter<double>("maxDeltaR");
   maxDeltaM_ = tagAndProbeMode_.getParameter<double>("maxDeltaM");
   maxTagIso_ = tagAndProbeMode_.getParameter<double>("maxTagIso");
 
   // register histograms to the TFileService
   edm::Service<TFileService> fs;
   nr_ = fs->make<TH1I>("nr", "nr", 10, 0, 10);
   pt_ = fs->make<TH1F>("pt", "pt", 20, 0., 100.);
   eta_ = fs->make<TH1F>("eta", "eta", 30, -3., 3.);
   phi_ = fs->make<TH1F>("phi", "phi", 35, -3.5, 3.5);
   genPt_ = fs->make<TH1F>("genPt", "pt", 20, 0., 100.);
   genEta_ = fs->make<TH1F>("genEta", "eta", 30, -3., 3.);
   genPhi_ = fs->make<TH1F>("genPhi", "phi", 35, -3.5, 3.5);
   deltaR_ = fs->make<TH1F>("deltaR", "log(dR)", 50, -5., 0.);
   isoTag_ = fs->make<TH1F>("isoTag", "iso", 50, 0., 10.);
   invMass_ = fs->make<TH1F>("invMass", "m", 100, 50., 150.);
   deltaPhi_ = fs->make<TH1F>("deltaPhi", "deltaPhi", 100, -3.5, 3.5);
 }

PatElectronAnalyzer::~PatElectronAnalyzer ( )

override

Definition at line 104 of file PatElectronAnalyzer.cc.

104 {}

Member Function Documentation

void PatElectronAnalyzer::analyze	(	const edm::Event &	evt,
		const edm::EventSetup &	setup
	)

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 106 of file PatElectronAnalyzer.cc.

References funct::abs(), srCondWrite_cfg::deltaPhi, HLT_FULL_cff::DeltaPhi, deltaPhi_, HLT_FULL_cff::DeltaR, HLT_FULL_cff::deltaR, deltaR_, electronID_, HI_PhotonSkim_cff::electrons, electronSrcToken_, eta_, genEta_, genPhi_, genPt_, edm::Event::getByToken(), invMass_, isoTag_, ResonanceBuilder::mass, maxDeltaM_, maxDeltaR_, maxEta_, maxTagIso_, minPt_, mode_, nr_, particleSrcToken_, phi_, and pt_.

                                                                                  {
   // get electron collection
   edm::Handle<std::vector<pat::Electron> > electrons;
   evt.getByToken(electronSrcToken_, electrons);
   // get generator particle collection
   edm::Handle<reco::GenParticleCollection> particles;
   evt.getByToken(particleSrcToken_, particles);
 
   nr_->Fill(electrons->size());
 
   // ----------------------------------------------------------------------
   //
   // First Part Mode 0: genMatch
   //
   // ----------------------------------------------------------------------
   if (mode_ == 0) {
     // loop generator particles
     for (reco::GenParticleCollection::const_iterator part = particles->begin(); part != particles->end(); ++part) {
       // only loop stable electrons
       if (part->status() == 1 && abs(part->pdgId()) == 11) {
         if (part->pt() > minPt_ && fabs(part->eta()) < maxEta_) {
           genPt_->Fill(part->pt());
           genEta_->Fill(part->eta());
           genPhi_->Fill(part->phi());
         }
       }
     }
 
     // loop electrons
     for (std::vector<pat::Electron>::const_iterator elec = electrons->begin(); elec != electrons->end(); ++elec) {
       if (elec->genLepton()) {
         float deltaR = ROOT::Math::VectorUtil::DeltaR(elec->genLepton()->p4(), elec->p4());
         deltaR_->Fill(TMath::Log10(deltaR));
         if (deltaR < maxDeltaR_) {
           if (electronID_ != "none") {
             if (elec->electronID(electronID_) < 0.5)
               continue;
           }
           if (elec->pt() > minPt_ && fabs(elec->eta()) < maxEta_) {
             pt_->Fill(elec->pt());
             eta_->Fill(elec->eta());
             phi_->Fill(elec->phi());
           }
         }
       }
     }
   }
 
   // ----------------------------------------------------------------------
   //
   // Second Part Mode 1: tagAndProbe
   //
   // ----------------------------------------------------------------------
   if (mode_ == 1) {
     // loop tag electron
     for (std::vector<pat::Electron>::const_iterator elec = electrons->begin(); elec != electrons->end(); ++elec) {
       isoTag_->Fill(elec->trackIso());
       if (elec->trackIso() < maxTagIso_ && elec->electronID("eidTight") > 0.5) {
         // loop probe electron
         for (std::vector<pat::Electron>::const_iterator probe = electrons->begin(); probe != electrons->end();
              ++probe) {
           // skip the tag electron itself
           if (probe == elec)
             continue;
 
           float zMass = (probe->p4() + elec->p4()).mass();
           invMass_->Fill(zMass);
           float deltaPhi = ROOT::Math::VectorUtil::DeltaPhi(elec->p4(), probe->p4());
           deltaPhi_->Fill(deltaPhi);
 
           // check for the Z mass
           if (fabs(zMass - 90.) < maxDeltaM_) {
             if (electronID_ != "none") {
               if (probe->electronID(electronID_) < 0.5)
                 continue;
             }
             if (probe->pt() > minPt_ && fabs(probe->eta()) < maxEta_) {
               pt_->Fill(probe->pt());
               eta_->Fill(probe->eta());
               phi_->Fill(probe->phi());
             }
           }
         }
       }
     }
   }
 }