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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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, const edm::View< reco::GsfElectron > &eles, const std::vector< edm::Handle< pat::PackedCandidateCollection > > &handles, const std::vector< EleTkIsolFromCands::PIDVeto > &pidVetos, const EleTkIsolFromCands &trkIsoCalc)

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

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_

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	trkIso04Calc_

EleTkIsolFromCands	trkIsoCalc_

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

Constructor & Destructor Documentation

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

explicit

Definition at line 198 of file ElectronHEEPIDValueMapProducer.cc.

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

Referenced by ElectronHEEPIDValueMapProducer::DataFormat::operator()().

     : trkIsoCalc_(iConfig.getParameter<edm::ParameterSet>("trkIsoConfig")),
       trkIso04Calc_(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");
 
   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 230 of file ElectronHEEPIDValueMapProducer.cc.

Referenced by ElectronHEEPIDValueMapProducer::DataFormat::operator()().

230 {}

Member Function Documentation

float ElectronHEEPIDValueMapProducer::calTrkIso	(	const reco::GsfElectron &	ele,
		const edm::View< reco::GsfElectron > &	eles,
		const std::vector< edm::Handle< pat::PackedCandidateCollection > > &	handles,
		const std::vector< EleTkIsolFromCands::PIDVeto > &	pidVetos,
		const EleTkIsolFromCands &	trkIsoCalc
	)

staticprivate

Definition at line 271 of file ElectronHEEPIDValueMapProducer.cc.

References EleTkIsolFromCands::calIsolPt(), Exception, reco::GsfElectron::gsfTrack(), patZpeak::handle, edm::Ref< C, T, F >::isNull(), SiStripPI::max, and ZMuMuCategoriesSequences_cff::trkIso.

Referenced by ElectronHEEPIDValueMapProducer::DataFormat::operator()(), and produce().

                                                                                       {
   if (ele.gsfTrack().isNull())
     return std::numeric_limits<float>::max();
   else {
     float trkIso = 0.;
     for (size_t handleNr = 0; handleNr < handles.size(); handleNr++) {
       auto& handle = handles[handleNr];
       if (handle.isValid()) {
         if (handleNr < pidVetos.size()) {
           trkIso += trkIsoCalc.calIsolPt(*ele.gsfTrack(), *handle, pidVetos[handleNr]);
         } else {
           throw cms::Exception("LogicError") << " somehow the pidVetos and handles do not much, given this is checked "
                                                 "at construction time, something has gone wrong in the code handle nr "
                                              << handleNr << " size of vetos " << pidVetos.size();
         }
       }
     }
     return trkIso;
   }
 }

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

static

Definition at line 308 of file ElectronHEEPIDValueMapProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, HLT_2018_cff::InputTag, and EleTkIsolFromCands::pSetDescript().

Referenced by ElectronHEEPIDValueMapProducer::DataFormat::operator()().

                                                                                                 {
   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 edm::EDGetTokenT< T > &	token
	)

inlinestaticprivate

Definition at line 131 of file ElectronHEEPIDValueMapProducer.cc.

References edm::Event::getByToken(), and patZpeak::handle.

Referenced by produce().

                                                                                         {
     edm::Handle<T> handle;
     iEvent.getByToken(token, handle);
     return handle;
   }

template<typename T >

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

inlinestaticprivate

Definition at line 137 of file ElectronHEEPIDValueMapProducer.cc.

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

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

References ElectronHEEPIDValueMapProducer::DualToken< T >::aod, edm::Event::getByToken(), HLTEGTnPMonitor_cfi::isAOD, ElectronHEEPIDValueMapProducer::DualToken< T >::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 166 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 262 of file ElectronHEEPIDValueMapProducer.cc.

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

Referenced by ElectronHEEPIDValueMapProducer::DataFormat::operator()(), and 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 232 of file ElectronHEEPIDValueMapProducer.cc.

References beamSpotToken_, calTrkIso(), candTokens_, candVetosAOD_, candVetosMiniAOD_, ebRecHitToken_, eeRecHitToken_, eleNrSaturateIn5x5Label_, eleToken_, eleTrkPtIso04Label_, eleTrkPtIsoLabel_, edm::EventSetup::get(), getHandle(), getHandles(), HLTEGTnPMonitor_cfi::isAOD, isEventAOD(), makeTrkIso04_, nrSaturatedCrysIn5x5(), trkIso04Calc_, trkIsoCalc_, and writeValueMap().

Referenced by ElectronHEEPIDValueMapProducer::DataFormat::operator()().

                                                                                           {
   auto eleHandle = getHandle(iEvent, eleToken_);
   auto ebRecHitHandle = getHandle(iEvent, ebRecHitToken_);
   auto eeRecHitHandle = getHandle(iEvent, eeRecHitToken_);
   auto beamSpotHandle = getHandle(iEvent, beamSpotToken_);
   auto candHandles = getHandles(iEvent, candTokens_);
 
   bool isAOD = isEventAOD(iEvent, eleToken_);
   const auto& candVetos = isAOD ? candVetosAOD_ : candVetosMiniAOD_;
 
   edm::ESHandle<CaloTopology> caloTopoHandle;
   iSetup.get<CaloTopologyRecord>().get(caloTopoHandle);
 
   std::vector<float> eleTrkPtIso;
   std::vector<float> eleTrkPtIso04;
   std::vector<int> eleNrSaturateIn5x5;
   for (auto const& ele : *eleHandle) {
     eleTrkPtIso.push_back(calTrkIso(ele, *eleHandle, candHandles, candVetos, trkIsoCalc_));
     if (makeTrkIso04_) {
       eleTrkPtIso04.push_back(calTrkIso(ele, *eleHandle, candHandles, candVetos, trkIso04Calc_));
     }
     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 80 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 84 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 88 of file ElectronHEEPIDValueMapProducer.cc.

References edm::ParameterSet::getParameter(), setToken(), GlobalPosition_Frontier_DevDB_cff::tag, JetPartonCorrections_cff::tagName, triggerMatcherToHLTDebug_cfi::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 97 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 108 of file ElectronHEEPIDValueMapProducer.cc.

References ElectronHEEPIDValueMapProducer::DualToken< T >::aod, edm::ParameterSet::getParameter(), SiStripPI::max, reco_skim_cfg_mod::maxSize, ElectronHEEPIDValueMapProducer::DualToken< T >::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 297 of file ElectronHEEPIDValueMapProducer.cc.

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

Referenced by ElectronHEEPIDValueMapProducer::DataFormat::operator()(), and 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);
 }