Selects PFCandidates basing on cuts provided with string cut parser. More...

#include "CommonTools/ParticleFlow/interface/ElectronIDPFCandidateSelectorDefinition.h"

Inheritance diagram for pf2pat::ElectronIDPFCandidateSelectorDefinition:

Public Member Functions
	ElectronIDPFCandidateSelectorDefinition (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
edm::EDGetTokenT< edm::ValueMap< float > >	electronIdToken_

edm::EDGetTokenT< reco::GsfElectronCollection >	electronsToken_

bool	isBitMap_

uint32_t	mask_

double	value_

Additional Inherited Members
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

Protected Attributes inherited from pf2pat::PFCandidateSelectorDefinition
container	selected_

Detailed Description

Selects PFCandidates basing on cuts provided with string cut parser.

Author: Giovanni Petrucciani

Version

Id: ElectronIDPFCandidateSelectorDefinition.h,v 1.1 2011/01/28 20:56:44 srappocc Exp

Definition at line 24 of file ElectronIDPFCandidateSelectorDefinition.h.

Constructor & Destructor Documentation

◆ ElectronIDPFCandidateSelectorDefinition()

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

inline

Definition at line 25 of file ElectronIDPFCandidateSelectorDefinition.h.

         : electronsToken_(
               iC.consumes<reco::GsfElectronCollection>(cfg.getParameter<edm::InputTag>("recoGsfElectrons"))),
           electronIdToken_(iC.consumes<edm::ValueMap<float> >(cfg.getParameter<edm::InputTag>("electronIdMap"))) {
       if (cfg.exists("bitsToCheck")) {
         isBitMap_ = true;
         mask_ = 0;
         if (cfg.existsAs<std::vector<std::string> >("bitsToCheck")) {
           std::vector<std::string> strbits = cfg.getParameter<std::vector<std::string> >("bitsToCheck");
           for (std::vector<std::string>::const_iterator istrbit = strbits.begin(), estrbit = strbits.end();
                istrbit != estrbit;
                ++istrbit) {
             if (*istrbit == "id") {
               mask_ |= 1;
             } else if (*istrbit == "iso") {
               mask_ |= 2;
             } else if (*istrbit == "conv") {
               mask_ |= 4;
             } else if (*istrbit == "ip") {
               mask_ |= 8;
             } else
               throw cms::Exception("Configuration")
                   << "ElectronIDPFCandidateSelector: "
                   << "bitsToCheck allowed string values are only id(0), iso(1), conv(2), ip(3).\n"
                   << "Otherwise, use uint32_t bitmask).\n";
           }
         } else if (cfg.existsAs<uint32_t>("bitsToCheck")) {
           mask_ = cfg.getParameter<uint32_t>("bitsToCheck");
         } else {
           throw cms::Exception("Configuration")
               << "ElectronIDPFCandidateSelector: "
               << "bitsToCheck must be either a vector of strings, or a uint32 bitmask.\n";
         }
       } else {
         isBitMap_ = false;
         value_ = cfg.getParameter<double>("electronIdCut");
       }
     }

References looper::cfg, Exception, isBitMap_, mask_, and value_.

Member Function Documentation

◆ select()

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

inline

Definition at line 64 of file ElectronIDPFCandidateSelectorDefinition.h.

                                                                                          {
       selected_.clear();
  
       edm::Handle<reco::GsfElectronCollection> electrons;
       e.getByToken(electronsToken_, electrons);
  
       edm::Handle<edm::ValueMap<float> > electronId;
       e.getByToken(electronIdToken_, electronId);
  
       unsigned key = 0;
       for (collection::const_iterator pfc = hc->begin(); pfc != hc->end(); ++pfc, ++key) {
         // Get GsfTrack for matching with reco::GsfElectron objects
         reco::GsfTrackRef PfTk = pfc->gsfTrackRef();
  
         // skip ones without GsfTrack: they won't be matched anyway
         if (PfTk.isNull())
           continue;
  
         int match = -1;
         // try first the non-ambiguous tracks
         for (auto it = electrons->begin(), ed = electrons->end(); it != ed; ++it) {
           if (it->gsfTrack() == PfTk) {
             match = it - electrons->begin();
             break;
           }
         }
         // then the ambiguous ones
         if (match == -1) {
           for (auto it = electrons->begin(), ed = electrons->end(); it != ed; ++it) {
             if (std::count(it->ambiguousGsfTracks().begin(), it->ambiguousGsfTracks().end(), PfTk) > 0) {
               match = it - electrons->begin();
               break;
             }
           }
         }
         // if found, make a GsfElectronRef and read electron id
         if (match != -1) {
           reco::GsfElectronRef ref(electrons, match);
           float eleId = (*electronId)[ref];
           bool pass = false;
           if (isBitMap_) {
             uint32_t thisval = eleId;
             pass = ((thisval & mask_) == mask_);
           } else {
             pass = (eleId > value_);
           }
           if (pass) {
             selected_.push_back(reco::PFCandidate(*pfc));
             reco::PFCandidatePtr ptrToMother(hc, key);
             selected_.back().setSourceCandidatePtr(ptrToMother);
           }
         }
       }
     }