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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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 constexpr unsigned	kNPFTypes = 8

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 36 of file CITKPFIsolationSumProducer.cc.

Member Typedef Documentation

◆ CandView

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

private

Definition at line 53 of file CITKPFIsolationSumProducer.cc.

◆ IsoTypes

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

private

Definition at line 52 of file CITKPFIsolationSumProducer.cc.

◆ TypeMap

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

private

Definition at line 51 of file CITKPFIsolationSumProducer.cc.

Constructor & Destructor Documentation

◆ PFIsolationSumProducer()

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

Definition at line 67 of file CITKPFIsolationSumProducer.cc.

       : _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!.";
       }
       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);
       _isolation_types[thetype->second].emplace_back(std::move(theisolator));
     }
   }

◆ ~PFIsolationSumProducer()

citk::PFIsolationSumProducer::~PFIsolationSumProducer ( )

inlineoverride

Definition at line 40 of file CITKPFIsolationSumProducer.cc.

40 {}

Member Function Documentation

◆ beginLuminosityBlock()

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

final

Definition at line 97 of file CITKPFIsolationSumProducer.cc.

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

References _isolation_types.

◆ fillDescriptions()

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

static

Definition at line 164 of file CITKPFIsolationSumProducer.cc.

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

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

◆ produce()

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

final

Definition at line 105 of file CITKPFIsolationSumProducer.cc.

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