Inheritance diagram for citk::PFIsolationSumProducer:

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

	PFIsolationSumProducer (const edm::ParameterSet &)

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

	~PFIsolationSumProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

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

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

private

Definition at line 50 of file CITKPFIsolationSumProducer.cc.

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

private

Definition at line 49 of file CITKPFIsolationSumProducer.cc.

Constructor & Destructor Documentation

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

Definition at line 65 of file CITKPFIsolationSumProducer.cc.

References _isolate_with, _isolation_types, _product_names, _to_isolate, _typeMap, beginLuminosityBlock(), EnergyCorrector::c, highPtTrackIsolations_cff::coneSize, Exception, reco::get(), eostools::move(), dataset::name, BPhysicsValidation_cfi::pname, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                          :
     _typeMap( { {"h+",1},
             {"h0",5},
         {"gamma",4},
         {"electron",2},
         {"muon",3},
         {"HFh",6},
         {"HFgamma",7} } ){
     _to_isolate = 
       consumes<CandView>(c.getParameter<edm::InputTag>("srcToIsolate"));
     _isolate_with = 
       consumes<CandView>(c.getParameter<edm::InputTag>("srcForIsolationCone"));
     const std::vector<edm::ParameterSet>& isoDefs = 
       c.getParameterSetVector("isolationConeDefinitions");
     for( const auto& isodef : isoDefs ) {
       const std::string& name = 
     isodef.getParameter<std::string>("isolationAlgo");
       const float coneSize = isodef.getParameter<double>("coneSize");
       char buf[50];
       sprintf(buf,"DR%.2f",coneSize);
       std::string coneName(buf);
       auto decimal = coneName.find('.');
       if( decimal != std::string::npos ) coneName.erase(decimal,1);
       const std::string& isotype = 
     isodef.getParameter<std::string>("isolateAgainst");
       auto theisolator =
     CITKIsolationConeDefinitionFactory::get()->create(name,isodef);
       theisolator->setConsumes(consumesCollector());
       const auto thetype = _typeMap.find(isotype);
       if( thetype == _typeMap.end() ) {
     throw cms::Exception("InvalidIsolationType")
       << "Isolation type: " << isotype << " is not available in the "
       << "list of allowed isolations!.";
       }
       _isolation_types[thetype->second].emplace_back(std::move(theisolator));
       const std::string dash("-");
       std::string pname = isotype+dash+coneName+dash+theisolator->additionalCode();
       _product_names[thetype->second].emplace_back(pname);
       produces<edm::ValueMap<float> >(pname);
     }
   }

citk::PFIsolationSumProducer::~PFIsolationSumProducer ( )

inlineoverride

Definition at line 37 of file CITKPFIsolationSumProducer.cc.

References fillDescriptions().

37 {}

Member Function Documentation

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

final

Definition at line 108 of file CITKPFIsolationSumProducer.cc.

References _isolation_types, and produce().

Referenced by PFIsolationSumProducer().

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

void citk::PFIsolationSumProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 178 of file CITKPFIsolationSumProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addVPSet(), egmElectronIsolationPUPPI_cff::isolationConeDefinitions, muons_cff::photons, edm::ParameterSetDescription::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {  
     edm::ParameterSetDescription iDesc;
     iDesc.setComment("isolation sum producer");
 
     iDesc.add<edm::InputTag>("srcToIsolate", edm::InputTag("no default"))->setComment("calculate isolation for this collection");
     iDesc.add<edm::InputTag>("srcForIsolationCone", edm::InputTag("no default"))->setComment("collection for the isolation calculation: like particleFlow ");
 
     edm::ParameterSetDescription descIsoConeDefinitions;
     descIsoConeDefinitions.add<std::string>("isolationAlgo", "no default");
     descIsoConeDefinitions.add<double>("coneSize", 0.3);
     descIsoConeDefinitions.add<std::string>("isolateAgainst", "no default");
     descIsoConeDefinitions.add<std::vector<unsigned>>("miniAODVertexCodes", {2,3});
     descIsoConeDefinitions.addOptional<double>("VetoConeSizeBarrel", 0.0);
     descIsoConeDefinitions.addOptional<double>("VetoConeSizeEndcaps", 0.0);
     descIsoConeDefinitions.addOptional<int>("vertexIndex",0);
     descIsoConeDefinitions.addOptional<edm::InputTag>("particleBasedIsolation",edm::InputTag("no default"))->setComment("map for footprint removal that is used for photons");
 
 
     std::vector<edm::ParameterSet> isolationConeDefinitions;
     edm::ParameterSet chargedHadrons, neutralHadrons,photons;
     isolationConeDefinitions.push_back(chargedHadrons);
     isolationConeDefinitions.push_back(neutralHadrons);
     isolationConeDefinitions.push_back(photons);
     iDesc.addVPSet("isolationConeDefinitions", descIsoConeDefinitions, isolationConeDefinitions);
 
     descriptions.add("CITKPFIsolationSumProducer", iDesc);
   }

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

final

Definition at line 118 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(), mps_fire::i, edm::helper::Filler< Map >::insert(), gen::k, kNPFTypes, eostools::move(), edm::View< T >::ptrAt(), edm::Event::put(), edm::View< T >::size(), and reco::PFCandidate::translatePdgIdToType().

Referenced by beginLuminosityBlock().

                                                  {
     typedef std::unique_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(std::move(the_product),_product_names[i][j]);
       }
     }
   }