Inheritance diagram for citk::PFIsolationSumProducer:

Public Member Functions
void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) overridefinal

	PFIsolationSumProducer (const edm::ParameterSet &)

void	produce (edm::Event &, const edm::EventSetup &) overridefinal

virtual	~PFIsolationSumProducer ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	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

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Types
typedef edm::View < reco::Candidate >	CandView

typedef std::vector < std::unique_ptr < IsolationConeDefinitionBase > >	IsoTypes

typedef std::unordered_map < std::string, int >	TypeMap

Private Attributes
edm::EDGetTokenT< CandView >	_isolate_with

std::array< IsoTypes, kNPFTypes >	_isolation_types

std::array< std::vector < std::string >, kNPFTypes >	_product_names

edm::EDGetTokenT< CandView >	_to_isolate

const TypeMap	_typeMap

Static Private Attributes
static unsigned	kNPFTypes = 8

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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 32 of file CITKPFIsolationSumProducer.cc.

Member Typedef Documentation

typedef edm::View<reco::Candidate> citk::PFIsolationSumProducer::CandView

private

Definition at line 49 of file CITKPFIsolationSumProducer.cc.

typedef std::vector<std::unique_ptr<IsolationConeDefinitionBase> > citk::PFIsolationSumProducer::IsoTypes

private

Definition at line 48 of file CITKPFIsolationSumProducer.cc.

typedef std::unordered_map<std::string,int> citk::PFIsolationSumProducer::TypeMap

private

Definition at line 47 of file CITKPFIsolationSumProducer.cc.

Constructor & Destructor Documentation

citk::PFIsolationSumProducer::PFIsolationSumProducer ( const edm::ParameterSet & c )

Definition at line 63 of file CITKPFIsolationSumProducer.cc.

                                                                          :
     _typeMap( { {"h+",1},
             {"h0",5},
         {"gamma",4},
         {"electron",2},
         {"muon",3},
         {"HFh",6},
         {"HFgamma",7} } ){

virtual citk::PFIsolationSumProducer::~PFIsolationSumProducer ( )

inlinevirtual

Definition at line 37 of file CITKPFIsolationSumProducer.cc.

37 {}

Member Function Documentation

void citk::PFIsolationSumProducer::beginLuminosityBlock	(	const edm::LuminosityBlock &	,
		const edm::EventSetup &	es
	)

finaloverridevirtual

Reimplemented from edm::EDProducer.

Definition at line 106 of file CITKPFIsolationSumProducer.cc.

References _isolation_types.

                                         {
     for( const auto& isolators_for_type : _isolation_types ) {
       for( const auto& isolator : isolators_for_type ) {
     isolator->getEventSetupInfo(es);
       }
     }
   }

void citk::PFIsolationSumProducer::produce	(	edm::Event &	ev,
		const edm::EventSetup &	es
	)

finaloverridevirtual

Implements edm::EDProducer.

Definition at line 116 of file CITKPFIsolationSumProducer.cc.

References _isolate_with, _isolation_types, _product_names, _to_isolate, begin, EnergyCorrector::c, end, edm::helper::Filler< Map >::fill(), edm::Event::getByToken(), i, edm::helper::Filler< Map >::insert(), j, relval_steps::k, kNPFTypes, edm::Event::put(), reco::PFCandidate::translatePdgIdToType(), and relativeConstraints::value.

                                                  {
     typedef std::auto_ptr<edm::ValueMap<float> >  product_type;
     typedef std::vector<float> product_values;
     edm::Handle<CandView> to_isolate;
     edm::Handle<CandView> isolate_with;
     ev.getByToken(_to_isolate,to_isolate);
     ev.getByToken(_isolate_with,isolate_with);
     // the list of value vectors indexed as "to_isolate"
     std::array<std::vector<product_values>,kNPFTypes> the_values;    
     // get extra event info and setup value cache
     unsigned i = 0;
     for( const auto& isolators_for_type : _isolation_types ) {
       the_values[i++].resize(isolators_for_type.size());
       for( const auto& isolator : isolators_for_type ) {
     isolator->getEventInfo(ev);
       }
     }
     reco::PFCandidate helper; // to translate pdg id to type    
     // loop over the candidates we are isolating and fill the values
     for( size_t c = 0; c < to_isolate->size(); ++c ) {
       auto cand_to_isolate = to_isolate->ptrAt(c);
       std::array<std::vector<float>,kNPFTypes> cand_values;      
       unsigned k = 0;
       for( const auto& isolators_for_type : _isolation_types ) {
     cand_values[k].resize(isolators_for_type.size());
     for( auto& value : cand_values[k] ) value = 0.0;
     ++k;
       }
       for( size_t ic = 0; ic < isolate_with->size(); ++ic ) {
         auto isocand = isolate_with->ptrAt(ic);
     auto isotype = helper.translatePdgIdToType(isocand->pdgId());   
     const auto& isolations = _isolation_types[isotype]; 
     for( unsigned i = 0; i < isolations.size(); ++ i  ) {
       if( isolations[i]->isInIsolationCone(cand_to_isolate,isocand) ) {
         cand_values[isotype][i] += isocand->pt();
       }
     }
       }
       // add this candidate to isolation value list
       for( unsigned i = 0; i < kNPFTypes; ++i ) {
     for( unsigned j = 0; j < cand_values[i].size(); ++j ) {
       the_values[i][j].push_back(cand_values[i][j]);
     }
       }
     }
     // fill and put all products
     for( unsigned i = 0; i < kNPFTypes; ++ i ) {
       for( unsigned j = 0; j < the_values[i].size(); ++j ) {
     product_type the_product( new edm::ValueMap<float> );
     edm::ValueMap<float>::Filler fillerprod(*the_product);
     fillerprod.insert(to_isolate, 
               the_values[i][j].begin(),
               the_values[i][j].end());
     fillerprod.fill();
     ev.put(the_product,_product_names[i][j]);
       }
     }
   }