citk::PFIsolationSumProducer Class Reference

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.

{}

Member Function Documentation

beginLuminosityBlock()

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

final

Definition at line 97 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);
      }
    }
  }

fillDescriptions()

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

static

Definition at line 164 of file CITKPFIsolationSumProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addVPSet(), HLT_2022v12_cff::InputTag, egmElectronIsolationPUPPI_cff::isolationConeDefinitions, BPHMonitor_cfi::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);
  }

produce()

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

final

Definition at line 105 of file CITKPFIsolationSumProducer.cc.

References _isolate_with, _isolation_types, _product_names, _to_isolate, c, mps_fire::end, makeMEIFBenchmarkPlots::ev, edm::helper::Filler< Map >::fill(), mps_fire::i, edm::helper::Filler< Map >::insert(), dqmiolumiharvest::j, dqmdumpme::k, kNPFTypes, eostools::move(), edm::View< T >::ptrAt(), and edm::View< T >::size().

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

Member Data Documentation

_isolate_with

edm::EDGetTokenT<CandView> citk::PFIsolationSumProducer::_isolate_with

private

Definition at line 55 of file CITKPFIsolationSumProducer.cc.

Referenced by produce().

_isolation_types

std::array<IsoTypes, kNPFTypes> citk::PFIsolationSumProducer::_isolation_types

private

Definition at line 57 of file CITKPFIsolationSumProducer.cc.

Referenced by beginLuminosityBlock(), and produce().

_product_names

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

private

Definition at line 58 of file CITKPFIsolationSumProducer.cc.

Referenced by produce().

_to_isolate

edm::EDGetTokenT<CandView> citk::PFIsolationSumProducer::_to_isolate

private

Definition at line 55 of file CITKPFIsolationSumProducer.cc.

Referenced by produce().

_typeMap

const TypeMap citk::PFIsolationSumProducer::_typeMap

private

Definition at line 54 of file CITKPFIsolationSumProducer.cc.

kNPFTypes

constexpr unsigned citk::PFIsolationSumProducer::kNPFTypes = 8

staticprivate

Definition at line 50 of file CITKPFIsolationSumProducer.cc.

Referenced by produce().