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

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

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

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

bool	usePUPPINoLepton = false

bool	useValueMapForPUPPI = true

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

Member Typedef Documentation

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

private

Definition at line 45 of file CITKPFIsolationSumProducerForPUPPI.cc.

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

private

Definition at line 44 of file CITKPFIsolationSumProducerForPUPPI.cc.

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

private

Definition at line 43 of file CITKPFIsolationSumProducerForPUPPI.cc.

Constructor & Destructor Documentation

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

Definition at line 63 of file CITKPFIsolationSumProducerForPUPPI.cc.

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

                                                                                          :
     _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!.";
       }
       _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::PFIsolationSumProducerForPUPPI::~PFIsolationSumProducerForPUPPI ( )

inlineoverride

Definition at line 31 of file CITKPFIsolationSumProducerForPUPPI.cc.

References beginLuminosityBlock(), fillDescriptions(), and produce().

31 {}

Member Function Documentation

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

final

Definition at line 114 of file CITKPFIsolationSumProducerForPUPPI.cc.

References _isolation_types, and produce().

Referenced by PFIsolationSumProducerForPUPPI(), and ~PFIsolationSumProducerForPUPPI().

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

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

static

Definition at line 192 of file CITKPFIsolationSumProducerForPUPPI.cc.

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

Referenced by ~PFIsolationSumProducerForPUPPI().

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

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

final

Definition at line 124 of file CITKPFIsolationSumProducerForPUPPI.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(), puppiValueMap, puppiValueMapToken_, edm::Event::put(), edm::View< T >::size(), reco::PFCandidate::translatePdgIdToType(), usePUPPINoLepton, and useValueMapForPUPPI.

Referenced by beginLuminosityBlock(), and ~PFIsolationSumProducerForPUPPI().

                                                  {
     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(isocand);
         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 && !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]);
       }
     }
   }