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 22 of file ElectronIDPFCandidateSelectorDefinition.h.

Constructor & Destructor Documentation

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

inline

Definition at line 24 of file ElectronIDPFCandidateSelectorDefinition.h.

References Exception, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), isBitMap_, mask_, and value_.

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

Member Function Documentation

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

inline

Definition at line 55 of file ElectronIDPFCandidateSelectorDefinition.h.

References KineDebug3::count(), electronIdToken_, HI_PhotonSkim_cff::electrons, electronsToken_, edm::Event::getByToken(), isBitMap_, edm::Ref< C, T, F >::isNull(), relval_steps::key, mask_, match(), pf2pat::PFCandidateSelectorDefinition::selected_, and value_.

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();
 
       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 (reco::GsfElectronCollection::const_iterator 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 (reco::GsfElectronCollection::const_iterator it = electrons->begin(), ed = electrons->end(); it != ed; ++it) {
                 if (std::count(it->ambiguousGsfTracksBegin(), it->ambiguousGsfTracksEnd(), 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 );
             }
         }
       }
     }