#include <IsolatedPFCandidateSelectorDefinition.h>

Inheritance diagram for pf2pat::IsolatedPFCandidateSelectorDefinition:

Public Types
typedef edm::ValueMap< double >	IsoMap

Public Types inherited from pf2pat::PFCandidateSelectorDefinition
typedef reco::PFCandidateCollection	collection

typedef boost::transform_iterator< Pointer, container::const_iterator >	const_iterator

typedef std::vector< reco::PFCandidate >	container

typedef edm::Handle< collection >	HandleToCollection

Public Member Functions
	IsolatedPFCandidateSelectorDefinition (const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)

void	select (const HandleToCollection &hc, const edm::Event &e, const edm::EventSetup &s)

Public Member Functions inherited from pf2pat::PFCandidateSelectorDefinition
const_iterator	begin () const

const_iterator	end () const

	PFCandidateSelectorDefinition ()

const container &	selected () const

size_t	size () const

Private Attributes
double	deltaBetaFactor_

edm::EDGetTokenT< IsoMap >	deltaBetaIsolationValueMapToken_

bool	doDeltaBetaCorrection_

double	isolationCut_

std::vector< edm::EDGetTokenT< IsoMap > >	isolationValueMapChargedTokens_

std::vector< edm::EDGetTokenT< IsoMap > >	isolationValueMapNeutralTokens_

bool	isRelative_

Additional Inherited Members
Protected Attributes inherited from pf2pat::PFCandidateSelectorDefinition
container	selected_

Detailed Description

Definition at line 16 of file IsolatedPFCandidateSelectorDefinition.h.

Member Typedef Documentation

◆ IsoMap

typedef edm::ValueMap<double> pf2pat::IsolatedPFCandidateSelectorDefinition::IsoMap

Definition at line 18 of file IsolatedPFCandidateSelectorDefinition.h.

Constructor & Destructor Documentation

◆ IsolatedPFCandidateSelectorDefinition()

pf2pat::IsolatedPFCandidateSelectorDefinition::IsolatedPFCandidateSelectorDefinition	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC
	)

inline

Definition at line 20 of file IsolatedPFCandidateSelectorDefinition.h.

         : isolationValueMapChargedTokens_(
               edm::vector_transform(cfg.getParameter<std::vector<edm::InputTag> >("isolationValueMapsCharged"),
                                     [&](edm::InputTag const& tag) { return iC.consumes<IsoMap>(tag); })),
           isolationValueMapNeutralTokens_(
               edm::vector_transform(cfg.getParameter<std::vector<edm::InputTag> >("isolationValueMapsNeutral"),
                                     [&](edm::InputTag const& tag) { return iC.consumes<IsoMap>(tag); })),
           doDeltaBetaCorrection_(cfg.getParameter<bool>("doDeltaBetaCorrection")),
           deltaBetaIsolationValueMapToken_(
               iC.mayConsume<IsoMap>(cfg.getParameter<edm::InputTag>("deltaBetaIsolationValueMap"))),
           deltaBetaFactor_(cfg.getParameter<double>("deltaBetaFactor")),
           isRelative_(cfg.getParameter<bool>("isRelative")),
           isolationCut_(cfg.getParameter<double>("isolationCut")) {}

References GlobalPosition_Frontier_DevDB_cff::tag.

Member Function Documentation

◆ select()

void pf2pat::IsolatedPFCandidateSelectorDefinition::select	(	const HandleToCollection &	hc,
		const edm::Event &	e,
		const edm::EventSetup &	s
	)

inline

Definition at line 34 of file IsolatedPFCandidateSelectorDefinition.h.

                                                                                          {
       selected_.clear();
  
       // read all charged isolation value maps
       std::vector<edm::Handle<IsoMap> > isoMapsCharged(isolationValueMapChargedTokens_.size());
       for (unsigned iMap = 0; iMap < isolationValueMapChargedTokens_.size(); ++iMap) {
         e.getByToken(isolationValueMapChargedTokens_[iMap], isoMapsCharged[iMap]);
       }
  
       // read all neutral isolation value maps
       std::vector<edm::Handle<IsoMap> > isoMapsNeutral(isolationValueMapNeutralTokens_.size());
       for (unsigned iMap = 0; iMap < isolationValueMapNeutralTokens_.size(); ++iMap) {
         e.getByToken(isolationValueMapNeutralTokens_[iMap], isoMapsNeutral[iMap]);
       }
  
       edm::Handle<IsoMap> dBetaH;
       if (doDeltaBetaCorrection_) {
         e.getByToken(deltaBetaIsolationValueMapToken_, dBetaH);
       }
  
       unsigned key = 0;
       for (collection::const_iterator pfc = hc->begin(); pfc != hc->end(); ++pfc, ++key) {
         reco::PFCandidateRef candidate(hc, key);
  
         bool passed = true;
         double isoSumCharged = 0.0;
         double isoSumNeutral = 0.0;
  
         for (unsigned iMap = 0; iMap < isoMapsCharged.size(); ++iMap) {
           const IsoMap& isoMap = *(isoMapsCharged[iMap]);
           double val = isoMap[candidate];
           isoSumCharged += val;
         }
  
         for (unsigned iMap = 0; iMap < isoMapsNeutral.size(); ++iMap) {
           const IsoMap& isoMap = *(isoMapsNeutral[iMap]);
           double val = isoMap[candidate];
           isoSumNeutral += val;
         }
  
         if (doDeltaBetaCorrection_) {
           const IsoMap& isoMap = *dBetaH;
           double dBetaVal = isoMap[candidate];
           double dBetaCorIsoSumNeutral = isoSumNeutral + deltaBetaFactor_ * dBetaVal;
           isoSumNeutral = dBetaCorIsoSumNeutral > 0 ? dBetaCorIsoSumNeutral : 0;  //follow muon POG definition in 2012
         }
  
         double isoSum = isoSumCharged + isoSumNeutral;
  
         if (isRelative_) {
           isoSum /= candidate->pt();
         }
  
         if (isoSum > isolationCut_) {
           passed = false;
         }
  
         if (passed) {
           // passed all cuts, selected
           selected_.push_back(reco::PFCandidate(*pfc));
           reco::PFCandidatePtr ptrToMother(hc, key);
           selected_.back().setSourceCandidatePtr(ptrToMother);
         }
       }
     }