Inheritance diagram for ElectronHEEPIDValueMapProducer:

Classes
class	DataFormat

struct	DualToken

Public Member Functions
	ElectronHEEPIDValueMapProducer (const edm::ParameterSet &)

	~ElectronHEEPIDValueMapProducer () 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 Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

template<typename T >
void	setToken (edm::EDGetTokenT< T > &token, edm::InputTag tag)

template<typename T >
void	setToken (edm::EDGetTokenT< T > &token, const edm::ParameterSet &iPara, const std::string &tag)

template<typename T >
void	setToken (std::vector< edm::EDGetTokenT< T >> &tokens, const edm::ParameterSet &iPara, const std::string &tagName)

template<typename T >
void	setToken (DualToken< T > &token, const edm::ParameterSet &iPara, const std::string &tagAOD, const std::string &tagMiniAOD, DataFormat format)

template<typename T >
void	setToken (std::vector< DualToken< T >> &tokens, const edm::ParameterSet &iPara, const std::string &tagAOD, const std::string &tagMiniAOD, DataFormat format)

Static Private Member Functions
static float	calTrkIso (const reco::GsfElectron &ele, IsolationCalculators const &isolationCalculators)

template<typename T >
static edm::Handle< T >	getHandle (const edm::Event &iEvent, const DualToken< T > &token)

template<typename T >
static std::vector < edm::Handle< T > >	getHandles (const edm::Event &iEvent, const std::vector< DualToken< T >> &tokens)

template<typename T >
static bool	isEventAOD (const edm::Event &iEvent, const DualToken< T > &token)

static int	nrSaturatedCrysIn5x5 (const reco::GsfElectron &ele, edm::Handle< EcalRecHitCollection > &ebHits, edm::Handle< EcalRecHitCollection > &eeHits, edm::ESHandle< CaloTopology > &caloTopo)

template<typename T >
static void	writeValueMap (edm::Event &iEvent, const edm::Handle< edm::View< reco::GsfElectron >> &handle, const std::vector< T > &values, const std::string &label)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	caloTopoToken_

std::vector< DualToken < pat::PackedCandidateCollection > >	candTokens_

std::vector < EleTkIsolFromCands::PIDVeto >	candVetosAOD_

std::vector < EleTkIsolFromCands::PIDVeto >	candVetosMiniAOD_

DataFormat	dataFormat_

DualToken< EcalRecHitCollection >	ebRecHitToken_

DualToken< EcalRecHitCollection >	eeRecHitToken_

DualToken< edm::View < reco::GsfElectron > >	eleToken_

bool	makeTrkIso04_

EleTkIsolFromCands::Configuration	trkIso04CalcCfg_

EleTkIsolFromCands::Configuration	trkIsoCalcCfg_

Static Private Attributes
static const std::string	eleNrSaturateIn5x5Label_ = "eleNrSaturateIn5x5"

static const std::string	eleTrkPtIso04Label_ = "eleTrkPtIso04"

static const std::string	eleTrkPtIsoLabel_ = "eleTrkPtIso"

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 33 of file ElectronHEEPIDValueMapProducer.cc.

Constructor & Destructor Documentation

ElectronHEEPIDValueMapProducer::ElectronHEEPIDValueMapProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 191 of file ElectronHEEPIDValueMapProducer.cc.

References beamSpotToken_, caloTopoToken_, candTokens_, candVetosAOD_, candVetosMiniAOD_, dataFormat_, ebRecHitToken_, eeRecHitToken_, eleNrSaturateIn5x5Label_, eleToken_, eleTrkPtIso04Label_, eleTrkPtIsoLabel_, DeDxTools::esConsumes(), Exception, edm::ParameterSet::getParameter(), recoMuon::in, makeTrkIso04_, submitPVResolutionJobs::out, EleTkIsolFromCands::pidVetoFromStr(), setToken(), findQualityFiles::size, and HcalDetIdTransform::transform().

     : trkIsoCalcCfg_(iConfig.getParameter<edm::ParameterSet>("trkIsoConfig")),
       trkIso04CalcCfg_(iConfig.getParameter<edm::ParameterSet>("trkIso04Config")),
       makeTrkIso04_(iConfig.getParameter<bool>("makeTrkIso04")),
       dataFormat_(iConfig.getParameter<int>("dataFormat")) {
   setToken(ebRecHitToken_, iConfig, "ebRecHitsAOD", "ebRecHitsMiniAOD", dataFormat_);
   setToken(eeRecHitToken_, iConfig, "eeRecHitsAOD", "eeRecHitsMiniAOD", dataFormat_);
   setToken(eleToken_, iConfig, "elesAOD", "elesMiniAOD", dataFormat_);
   setToken(candTokens_, iConfig, "candsAOD", "candsMiniAOD", dataFormat_);
   setToken(beamSpotToken_, iConfig, "beamSpot");
   caloTopoToken_ = esConsumes();
 
   auto fillVetos = [](const auto& in, auto& out) {
     std::transform(in.begin(), in.end(), std::back_inserter(out), EleTkIsolFromCands::pidVetoFromStr);
   };
 
   fillVetos(iConfig.getParameter<std::vector<std::string>>("candVetosAOD"), candVetosAOD_);
   if (candVetosAOD_.size() != iConfig.getParameter<std::vector<edm::InputTag>>("candsAOD").size()) {
     throw cms::Exception("ConfigError") << " Error candVetosAOD should be the same size as candsAOD " << std::endl;
   }
 
   fillVetos(iConfig.getParameter<std::vector<std::string>>("candVetosMiniAOD"), candVetosMiniAOD_);
   if (candVetosMiniAOD_.size() != iConfig.getParameter<std::vector<edm::InputTag>>("candsMiniAOD").size()) {
     throw cms::Exception("ConfigError") << " Error candVetosMiniAOD should be the same size as candsMiniAOD "
                                         << std::endl;
   }
 
   produces<edm::ValueMap<float>>(eleTrkPtIsoLabel_);
   if (makeTrkIso04_)
     produces<edm::ValueMap<float>>(eleTrkPtIso04Label_);
   produces<edm::ValueMap<int>>(eleNrSaturateIn5x5Label_);
 }

ElectronHEEPIDValueMapProducer::~ElectronHEEPIDValueMapProducer ( )

override

Definition at line 224 of file ElectronHEEPIDValueMapProducer.cc.

224 {}

Member Function Documentation

float ElectronHEEPIDValueMapProducer::calTrkIso	(	const reco::GsfElectron &	ele,
		IsolationCalculators const &	isolationCalculators
	)

staticprivate

Definition at line 280 of file ElectronHEEPIDValueMapProducer.cc.

References reco::GsfElectron::gsfTrack(), edm::Ref< C, T, F >::isNull(), and SiStripPI::max.

Referenced by produce().

                                                                                                   {
   if (ele.gsfTrack().isNull()) {
     return std::numeric_limits<float>::max();
   }
 
   float trkIso = 0.;
   for (auto& calculator : isolationCalculators) {
     trkIso += (*calculator)(*ele.gsfTrack()).ptSum;
   }
   return trkIso;
 }

void ElectronHEEPIDValueMapProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 305 of file ElectronHEEPIDValueMapProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and EleTkIsolFromCands::pSetDescript().

                                                                                                 {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
   desc.add<edm::InputTag>("ebRecHitsAOD", edm::InputTag("reducedEcalRecHitsEB"));
   desc.add<edm::InputTag>("eeRecHitsAOD", edm::InputTag("reducedEcalRecHitsEE"));
   desc.add<std::vector<edm::InputTag>>("candsAOD", {edm::InputTag("packedCandidates")});
   desc.add<std::vector<std::string>>("candVetosAOD", {"none"});
   desc.add<edm::InputTag>("elesAOD", edm::InputTag("gedGsfElectrons"));
 
   desc.add<edm::InputTag>("ebRecHitsMiniAOD", edm::InputTag("reducedEcalRecHitsEB"));
   desc.add<edm::InputTag>("eeRecHitsMiniAOD", edm::InputTag("reducedEcalRecHitsEE"));
   desc.add<std::vector<edm::InputTag>>("candsMiniAOD", {edm::InputTag("packedCandidates")});
   desc.add<std::vector<std::string>>("candVetosMiniAOD", {"none"});
   desc.add<edm::InputTag>("elesMiniAOD", edm::InputTag("gedGsfElectrons"));
   desc.add<int>("dataFormat", 0);
   desc.add<bool>("makeTrkIso04", false);
   desc.add("trkIsoConfig", EleTkIsolFromCands::pSetDescript());
   desc.add("trkIso04Config", EleTkIsolFromCands::pSetDescript());
 
   descriptions.addDefault(desc);
 }

template<typename T >

static edm::Handle<T> ElectronHEEPIDValueMapProducer::getHandle	(	const edm::Event &	iEvent,
		const DualToken< T > &	token
	)

inlinestaticprivate

Definition at line 129 of file ElectronHEEPIDValueMapProducer.cc.

References ElectronHEEPIDValueMapProducer::DualToken< T >::aod, edm::Event::getByToken(), patZpeak::handle, edm::HandleBase::isValid(), and ElectronHEEPIDValueMapProducer::DualToken< T >::miniAOD.

Referenced by produce().

                                                                                    {
     edm::Handle<T> handle;
     if (!token.aod.isUninitialized())
       iEvent.getByToken(token.aod, handle);
     if (!handle.isValid() && !token.miniAOD.isUninitialized())
       iEvent.getByToken(token.miniAOD, handle);
     return handle;
   }

template<typename T >

static std::vector<edm::Handle<T> > ElectronHEEPIDValueMapProducer::getHandles	(	const edm::Event &	iEvent,
		const std::vector< DualToken< T >> &	tokens
	)

inlinestaticprivate

Definition at line 139 of file ElectronHEEPIDValueMapProducer.cc.

References edm::Event::getByToken(), PAT_cff::miniAOD, and unpackBuffers-CaloStage2::token.

Referenced by produce().

                                                                                                            {
     std::vector<edm::Handle<T>> handles(tokens.size());
     if (tokens.empty())
       return handles;
     if (!tokens[0].aod.isUninitialized())
       iEvent.getByToken(tokens[0].aod, handles[0]);
     bool isAOD = handles[0].isValid();
     if (!isAOD && !tokens[0].miniAOD.isUninitialized())
       iEvent.getByToken(tokens[0].miniAOD, handles[0]);
 
     for (size_t tokenNr = 1; tokenNr < tokens.size(); tokenNr++) {
       auto token = isAOD ? tokens[tokenNr].aod : tokens[tokenNr].miniAOD;
       if (!token.isUninitialized())
         iEvent.getByToken(token, handles[tokenNr]);
     }
     return handles;
   }

template<typename T >

static bool ElectronHEEPIDValueMapProducer::isEventAOD	(	const edm::Event &	iEvent,
		const DualToken< T > &	token
	)

inlinestaticprivate

Definition at line 158 of file ElectronHEEPIDValueMapProducer.cc.

References ElectronHEEPIDValueMapProducer::DualToken< T >::aod, edm::Event::getByToken(), patZpeak::handle, and edm::HandleBase::isValid().

Referenced by produce().

                                                                             {
     edm::Handle<T> handle;
     if (!token.aod.isUninitialized())
       iEvent.getByToken(token.aod, handle);
     if (handle.isValid())
       return true;
     else
       return false;
   }

int ElectronHEEPIDValueMapProducer::nrSaturatedCrysIn5x5	(	const reco::GsfElectron &	ele,
		edm::Handle< EcalRecHitCollection > &	ebHits,
		edm::Handle< EcalRecHitCollection > &	eeHits,
		edm::ESHandle< CaloTopology > &	caloTopo
	)

staticprivate

Definition at line 271 of file ElectronHEEPIDValueMapProducer.cc.

References EcalBarrel, EcalClusterToolsT< noZS >::nrSaturatedCrysIn5x5(), edm::Handle< T >::product(), edm::ESHandle< class >::product(), HLT_FULL_cff::recHits, and reco::GsfElectron::superCluster().

Referenced by produce().

                                                                                               {
   DetId id = ele.superCluster()->seed()->seed();
   auto recHits = id.subdetId() == EcalBarrel ? ebHits.product() : eeHits.product();
   return noZS::EcalClusterTools::nrSaturatedCrysIn5x5(id, recHits, caloTopo.product());
 }

void ElectronHEEPIDValueMapProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 226 of file ElectronHEEPIDValueMapProducer.cc.

References beamSpotToken_, caloTopoToken_, calTrkIso(), candTokens_, candVetosAOD_, candVetosMiniAOD_, ebRecHitToken_, eeRecHitToken_, eleNrSaturateIn5x5Label_, eleToken_, eleTrkPtIso04Label_, eleTrkPtIsoLabel_, getHandle(), edm::EventSetup::getHandle(), edm::Event::getHandle(), getHandles(), patZpeak::handle, isEventAOD(), makeTrkIso04_, nrSaturatedCrysIn5x5(), trkIso04CalcCfg_, trkIsoCalcCfg_, and writeValueMap().

                                                                                           {
   auto eleHandle = getHandle(iEvent, eleToken_);
   auto ebRecHitHandle = getHandle(iEvent, ebRecHitToken_);
   auto eeRecHitHandle = getHandle(iEvent, eeRecHitToken_);
   auto beamSpotHandle = iEvent.getHandle(beamSpotToken_);
 
   bool isAOD = isEventAOD(iEvent, eleToken_);
   const auto& candVetos = isAOD ? candVetosAOD_ : candVetosMiniAOD_;
 
   IsolationCalculators trkIsoCalcs;
   IsolationCalculators trkIso04Calcs;
 
   {
     int handleNr = 0;
     for (auto const& handle : getHandles(iEvent, candTokens_)) {
       if (handle.isValid()) {
         trkIsoCalcs.emplace_back(std::make_unique<EleTkIsolFromCands>(trkIsoCalcCfg_, *handle, candVetos[handleNr]));
         if (makeTrkIso04_) {
           trkIso04Calcs.emplace_back(
               std::make_unique<EleTkIsolFromCands>(trkIso04CalcCfg_, *handle, candVetos[handleNr]));
         }
       }
       ++handleNr;
     }
   }
 
   edm::ESHandle<CaloTopology> caloTopoHandle = iSetup.getHandle(caloTopoToken_);
 
   std::vector<float> eleTrkPtIso;
   std::vector<float> eleTrkPtIso04;
   std::vector<int> eleNrSaturateIn5x5;
   for (auto const& ele : *eleHandle) {
     eleTrkPtIso.push_back(calTrkIso(ele, trkIsoCalcs));
     if (makeTrkIso04_) {
       eleTrkPtIso04.push_back(calTrkIso(ele, trkIso04Calcs));
     }
     eleNrSaturateIn5x5.push_back(nrSaturatedCrysIn5x5(ele, ebRecHitHandle, eeRecHitHandle, caloTopoHandle));
   }
 
   writeValueMap(iEvent, eleHandle, eleTrkPtIso, eleTrkPtIsoLabel_);
   if (makeTrkIso04_)
     writeValueMap(iEvent, eleHandle, eleTrkPtIso04, eleTrkPtIso04Label_);
   writeValueMap(iEvent, eleHandle, eleNrSaturateIn5x5, eleNrSaturateIn5x5Label_);
 }

template<typename T >

void ElectronHEEPIDValueMapProducer::setToken	(	edm::EDGetTokenT< T > &	token,
		edm::InputTag	tag
	)

inlineprivate

Definition at line 78 of file ElectronHEEPIDValueMapProducer.cc.

References GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by ElectronHEEPIDValueMapProducer(), and setToken().

                                                            {
     token = consumes<T>(tag);
   }

template<typename T >

void ElectronHEEPIDValueMapProducer::setToken	(	edm::EDGetTokenT< T > &	token,
		const edm::ParameterSet &	iPara,
		const std::string &	tag
	)

inlineprivate

Definition at line 82 of file ElectronHEEPIDValueMapProducer.cc.

References edm::ParameterSet::getParameter(), and GlobalPosition_Frontier_DevDB_cff::tag.

                                                                                               {
     token = consumes<T>(iPara.getParameter<edm::InputTag>(tag));
   }

template<typename T >

void ElectronHEEPIDValueMapProducer::setToken	(	std::vector< edm::EDGetTokenT< T >> &	tokens,
		const edm::ParameterSet &	iPara,
		const std::string &	tagName
	)

inlineprivate

Definition at line 86 of file ElectronHEEPIDValueMapProducer.cc.

References edm::ParameterSet::getParameter(), setToken(), GlobalPosition_Frontier_DevDB_cff::tag, getPayloadData::tags, and unpackBuffers-CaloStage2::token.

                                                                                                               {
     auto tags = iPara.getParameter<std::vector<edm::InputTag>>(tagName);
     for (auto& tag : tags) {
       edm::EDGetTokenT<T> token;
       setToken(token, tag);
       tokens.push_back(token);
     }
   }

template<typename T >

void ElectronHEEPIDValueMapProducer::setToken	(	DualToken< T > &	token,
		const edm::ParameterSet &	iPara,
		const std::string &	tagAOD,
		const std::string &	tagMiniAOD,
		DataFormat	format
	)

inlineprivate

Definition at line 95 of file ElectronHEEPIDValueMapProducer.cc.

References ElectronHEEPIDValueMapProducer::DualToken< T >::aod, edm::ParameterSet::getParameter(), ElectronHEEPIDValueMapProducer::DualToken< T >::miniAOD, ElectronHEEPIDValueMapProducer::DataFormat::tryAOD(), and ElectronHEEPIDValueMapProducer::DataFormat::tryMiniAOD().

                                    {
     if (format.tryAOD())
       token.aod = consumes<T>(iPara.getParameter<edm::InputTag>(tagAOD));
     if (format.tryMiniAOD())
       token.miniAOD = consumes<T>(iPara.getParameter<edm::InputTag>(tagMiniAOD));
   }

template<typename T >

void ElectronHEEPIDValueMapProducer::setToken	(	std::vector< DualToken< T >> &	tokens,
		const edm::ParameterSet &	iPara,
		const std::string &	tagAOD,
		const std::string &	tagMiniAOD,
		DataFormat	format
	)

inlineprivate

Definition at line 106 of file ElectronHEEPIDValueMapProducer.cc.

References edm::ParameterSet::getParameter(), SiStripPI::max, reco_skim_cfg_mod::maxSize, PAT_cff::miniAOD, setToken(), ElectronHEEPIDValueMapProducer::DataFormat::tryAOD(), and ElectronHEEPIDValueMapProducer::DataFormat::tryMiniAOD().

                                    {
     auto tagsAOD = iPara.getParameter<std::vector<edm::InputTag>>(tagAOD);
     auto tagsMiniAOD = iPara.getParameter<std::vector<edm::InputTag>>(tagMiniAOD);
     size_t maxSize = std::max(tagsAOD.size(), tagsMiniAOD.size());
     tokens.clear();
     tokens.resize(maxSize);
     if (format.tryAOD()) {
       for (size_t tagNr = 0; tagNr < tagsAOD.size(); tagNr++) {
         setToken(tokens[tagNr].aod, tagsAOD[tagNr]);
       }
     }
     if (format.tryMiniAOD()) {
       for (size_t tagNr = 0; tagNr < tagsMiniAOD.size(); tagNr++) {
         setToken(tokens[tagNr].miniAOD, tagsMiniAOD[tagNr]);
       }
     }
   }

template<typename T >

void ElectronHEEPIDValueMapProducer::writeValueMap	(	edm::Event &	iEvent,
		const edm::Handle< edm::View< reco::GsfElectron >> &	handle,
		const std::vector< T > &	values,
		const std::string &	label
	)

staticprivate

Definition at line 294 of file ElectronHEEPIDValueMapProducer.cc.

References edm::helper::Filler< Map >::fill(), patZpeak::handle, edm::helper::Filler< Map >::insert(), eostools::move(), and edm::Event::put().

Referenced by produce().

                                                                            {
   std::unique_ptr<edm::ValueMap<T>> valMap(new edm::ValueMap<T>());
   typename edm::ValueMap<T>::Filler filler(*valMap);
   filler.insert(handle, values.begin(), values.end());
   filler.fill();
   iEvent.put(std::move(valMap), label);
 }