citk::PFIsolationSumProducerForPUPPI Class Reference

Inheritance diagram for citk::PFIsolationSumProducerForPUPPI:

Public Member Functions
void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) final
	PFIsolationSumProducerForPUPPI (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) final
	~PFIsolationSumProducerForPUPPI () 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
edm::Handle< edm::ValueMap< float > >	puppiValueMap
edm::EDGetTokenT< edm::ValueMap< float > >	puppiValueMapToken_
bool	usePUPPINoLepton
bool	useValueMapForPUPPI = true

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 26 of file CITKPFIsolationSumProducerForPUPPI.cc.

Member Typedef Documentation

CandView

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

private

Definition at line 43 of file CITKPFIsolationSumProducerForPUPPI.cc.

IsoTypes

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

private

Definition at line 42 of file CITKPFIsolationSumProducerForPUPPI.cc.

TypeMap

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

private

Definition at line 41 of file CITKPFIsolationSumProducerForPUPPI.cc.

Constructor & Destructor Documentation

PFIsolationSumProducerForPUPPI()

citk::PFIsolationSumProducerForPUPPI::PFIsolationSumProducerForPUPPI

(

const edm::ParameterSet &

c

)

Definition at line 62 of file CITKPFIsolationSumProducerForPUPPI.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"));
    if (!c.getParameter<edm::InputTag>("puppiValueMap").label().empty()) {
      puppiValueMapToken_ = mayConsume<edm::ValueMap<float>>(
          c.getParameter<edm::InputTag>("puppiValueMap"));  //getting token for puppiValueMap
      useValueMapForPUPPI = true;
    } else {
      useValueMapForPUPPI = false;
      usePUPPINoLepton = c.getParameter<bool>("usePUPPINoLepton");
    }
    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];
      std::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));
    }
  }

~PFIsolationSumProducerForPUPPI()

citk::PFIsolationSumProducerForPUPPI::~PFIsolationSumProducerForPUPPI ( )

inlineoverride

Definition at line 30 of file CITKPFIsolationSumProducerForPUPPI.cc.

{}

Member Function Documentation

beginLuminosityBlock()

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

final

Definition at line 100 of file CITKPFIsolationSumProducerForPUPPI.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::PFIsolationSumProducerForPUPPI::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 184 of file CITKPFIsolationSumProducerForPUPPI.cc.

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

                                                                                                  {
    edm::ParameterSetDescription iDesc;
    iDesc.setComment("PUPPI 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 ");
    iDesc.add<edm::InputTag>("puppiValueMap", edm::InputTag("puppi"))
        ->setComment("source for puppi, if left empty weight from packedCandidate is taken");

    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<double>("VetoThreshold", 0.0);
    descIsoConeDefinitions.addOptional<double>("VetoConeSize", 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);
    iDesc.add<bool>("usePUPPINoLepton", false);

    descriptions.add("CITKPFIsolationSumProducerForPUPPI", iDesc);
  }

produce()

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

final

Definition at line 108 of file CITKPFIsolationSumProducerForPUPPI.cc.

References _isolate_with, _isolation_types, _product_names, _to_isolate, HltBtagPostValidation_cff::c, makeMEIFBenchmarkPlots::ev, edm::helper::Filler< Map >::fill(), mps_fire::i, edm::helper::Filler< Map >::insert(), edm::Ptr< T >::isNull(), dqmiolumiharvest::j, dqmdumpme::k, kNPFTypes, eostools::move(), edm::View< T >::ptrAt(), puppiValueMap, puppiValueMapToken_, pat::PackedCandidate::puppiWeight(), pat::PackedCandidate::puppiWeightNoLep(), edm::View< T >::size(), usePUPPINoLepton, and useValueMapForPUPPI.

                                                                                    {
    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);
    if (useValueMapForPUPPI)
      ev.getByToken(puppiValueMapToken_, puppiValueMap);

    // 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);
        edm::Ptr<pat::PackedCandidate> aspackedCandidate;
        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)) {
            double puppiWeight = 0.;
            if (!useValueMapForPUPPI && aspackedCandidate.isNull())
              aspackedCandidate = edm::Ptr<pat::PackedCandidate>(isocand);
            if (!useValueMapForPUPPI && !usePUPPINoLepton)
              puppiWeight = aspackedCandidate->puppiWeight();  // if miniAOD, take puppiWeight directly from the object
            else if (!useValueMapForPUPPI && usePUPPINoLepton)
              puppiWeight =
                  aspackedCandidate->puppiWeightNoLep();  // if miniAOD, take puppiWeightNoLep directly from the object
            else
              puppiWeight = (*puppiValueMap)[isocand];  // if AOD, take puppiWeight from the valueMap
            if (puppiWeight > 0.)
              cand_values[isotype][i] +=
                  (isocand->pt()) *
                  puppiWeight;  // this is basically the main change to Lindsey's code: scale pt with puppiWeight for candidates with puppiWeight > 0.
          }
        }
      }
      // 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::PFIsolationSumProducerForPUPPI::_isolate_with

private

Definition at line 45 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by produce().

_isolation_types

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

private

Definition at line 49 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by beginLuminosityBlock(), and produce().

_product_names

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

private

Definition at line 50 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by produce().

_to_isolate

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

private

Definition at line 45 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by produce().

_typeMap

const TypeMap citk::PFIsolationSumProducerForPUPPI::_typeMap

private

Definition at line 44 of file CITKPFIsolationSumProducerForPUPPI.cc.

kNPFTypes

constexpr unsigned citk::PFIsolationSumProducerForPUPPI::kNPFTypes = 8

staticprivate

Definition at line 40 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by produce().

puppiValueMap

edm::Handle<edm::ValueMap<float> > citk::PFIsolationSumProducerForPUPPI::puppiValueMap

private

Definition at line 47 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by produce().

puppiValueMapToken_

edm::EDGetTokenT<edm::ValueMap<float> > citk::PFIsolationSumProducerForPUPPI::puppiValueMapToken_

private

Definition at line 46 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by produce().

usePUPPINoLepton

bool citk::PFIsolationSumProducerForPUPPI::usePUPPINoLepton

private

Initial value:

=
        false

Definition at line 52 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by produce().

useValueMapForPUPPI

bool citk::PFIsolationSumProducerForPUPPI::useValueMapForPUPPI = true

private

Definition at line 51 of file CITKPFIsolationSumProducerForPUPPI.cc.

Referenced by produce().