Inheritance diagram for PatElectronAnalyzer:

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

	~PatElectronAnalyzer ()

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &) override

virtual void	beginJob () override

virtual 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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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

Constructor & Destructor Documentation

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

explicit

Definition at line 78 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 ( )

Definition at line 109 of file PatElectronAnalyzer.cc.

110 {

111 }

Member Function Documentation

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

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 114 of file PatElectronAnalyzer.cc.

References funct::abs(), SiPixelRawToDigiRegional_cfi::deltaPhi, deltaPhi_, deltaR(), deltaR_, electronID_, HI_PhotonSkim_cff::electrons, electronSrcToken_, eta_, genEta_, genPhi_, genPt_, edm::Event::getByToken(), invMass_, isoTag_, 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_.compare("none")!=0 ){
         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_.compare("none")!=0 ){
           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() );
         }
       }
     }
       }
     }
   }
 }