#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

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

Definition at line 19 of file IsolatedPFCandidateSelectorDefinition.h.

Constructor & Destructor Documentation

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

inline

Definition at line 21 of file IsolatedPFCandidateSelectorDefinition.h.

References looper::cfg, deltaBetaFactor_, deltaBetaIsolationValueMapToken_, doDeltaBetaCorrection_, isolationCut_, isolationValueMapNeutralTokens_, isRelative_, GlobalPosition_Frontier_DevDB_cff::tag, and edm::vector_transform().

                                                                                                       :
       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")) {}

Member Function Documentation

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

inline

Definition at line 32 of file IsolatedPFCandidateSelectorDefinition.h.

References deltaBetaFactor_, deltaBetaIsolationValueMapToken_, doDeltaBetaCorrection_, edm::Event::getByToken(), isolationCut_, isolationValueMapChargedTokens_, isolationValueMapNeutralTokens_, objects.IsoTrackAnalyzer::isoSum, isRelative_, crabWrapper::key, TriggerAnalyzer::passed, pf2pat::PFCandidateSelectorDefinition::selected_, and heppy_batch::val.

Referenced by Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Views.LineDecayView.LineDecayContainer::mousePressEvent(), Vispa.Gui.PortConnection.PointToPointConnection::mousePressEvent(), Vispa.Gui.VispaWidget.VispaWidget::mousePressEvent(), and Vispa.Views.AbstractView.AbstractView::restoreSelection().

                                  {
       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 );
     }
       }
     }