Inheritance diagram for EgammaIsoHcalDetIdCollectionProducer:

Public Member Functions
void	beginRun (edm::Run const &, const edm::EventSetup &) final

	EgammaIsoHcalDetIdCollectionProducer (const edm::ParameterSet &)

void	produce (edm::Event &, const edm::EventSetup &) 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 Attributes
const edm::EDGetTokenT< reco::GsfElectronCollection >	elesToken_

EGHcalRecHitSelector	hcalHitSelector_

std::string	interestingDetIdCollection_

float	minEleEt_

float	minPhoEt_

float	minSCEt_

const edm::EDGetTokenT< reco::PhotonCollection >	phosToken_

const edm::EDGetTokenT< HBHERecHitCollection >	recHitsToken_

const edm::EDGetTokenT< reco::SuperClusterCollection >	superClustersToken_

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

Original author: Sam Harper (RAL)

Make a collection of detids to be kept tipically in a AOD rechit collection Modified from the ECAL version "InterestingDetIdCollectionProducer" to be HCAL

Definition at line 30 of file EgammaIsoHcalDetIdCollectionProducer.cc.

Constructor & Destructor Documentation

◆ EgammaIsoHcalDetIdCollectionProducer()

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

explicit

Definition at line 57 of file EgammaIsoHcalDetIdCollectionProducer.cc.

     : recHitsToken_{consumes(iConfig.getParameter<edm::InputTag>("recHitsLabel"))},
       superClustersToken_{consumes(iConfig.getParameter<edm::InputTag>("superClustersLabel"))},
       elesToken_{consumes(iConfig.getParameter<edm::InputTag>("elesLabel"))},
       phosToken_{consumes(iConfig.getParameter<edm::InputTag>("phosLabel"))},
       hcalHitSelector_(iConfig.getParameter<edm::ParameterSet>("hitSelection"), consumesCollector()) {
   minSCEt_ = iConfig.getParameter<double>("minSCEt");
   minEleEt_ = iConfig.getParameter<double>("minEleEt");
   minPhoEt_ = iConfig.getParameter<double>("minPhoEt");
  
   interestingDetIdCollection_ = iConfig.getParameter<std::string>("interestingDetIdCollection");
  
   //register your products
   produces<DetIdCollection>(interestingDetIdCollection_);
 }

References edm::ParameterSet::getParameter().

Member Function Documentation

◆ beginRun()

void EgammaIsoHcalDetIdCollectionProducer::beginRun	(	edm::Run const &	run,
		const edm::EventSetup &	iSetup
	)

final

Definition at line 87 of file EgammaIsoHcalDetIdCollectionProducer.cc.

                                                                                                   {
   hcalHitSelector_.setup(iSetup);
 }

References hcalHitSelector_, and EGHcalRecHitSelector::setup().

◆ fillDescriptions()

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

static

Definition at line 73 of file EgammaIsoHcalDetIdCollectionProducer.cc.

                                                                                                       {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("recHitsLabel", edm::InputTag("hbhereco"));
   desc.add<edm::InputTag>("elesLabel", edm::InputTag("gedGsfElectrons"));
   desc.add<edm::InputTag>("phosLabel", edm::InputTag("gedPhotons"));
   desc.add<edm::InputTag>("superClustersLabel", edm::InputTag("particleFlowEGamma"));
   desc.add<double>("minSCEt", 20);
   desc.add<double>("minEleEt", 20);
   desc.add<double>("minPhoEt", 20);
   desc.add<std::string>("interestingDetIdCollection", "");
   desc.add<edm::ParameterSetDescription>("hitSelection", EGHcalRecHitSelector::makePSetDescription());
   descriptions.add(("interestingGedEgammaIsoHCALDetId"), desc);
 }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, EGHcalRecHitSelector::makePSetDescription(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

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

override

Definition at line 92 of file EgammaIsoHcalDetIdCollectionProducer.cc.

                                                                                                 {
   auto superClusters = iEvent.getHandle(superClustersToken_);
   auto eles = iEvent.getHandle(elesToken_);
   auto phos = iEvent.getHandle(phosToken_);
   auto recHits = iEvent.getHandle(recHitsToken_);
  
   std::vector<DetId> indexToStore;
   indexToStore.reserve(100);
  
   if (eles.isValid() && recHits.isValid()) {
     for (auto& ele : *eles) {
       float scEt = ele.superCluster()->energy() * std::sin(ele.superCluster()->position().theta());
       if (scEt > minEleEt_ || ele.et() > minEleEt_) {
         hcalHitSelector_.addDetIds(*ele.superCluster(), *recHits, indexToStore);
       }
     }
   }
   if (phos.isValid() && recHits.isValid()) {
     for (auto& pho : *phos) {
       float scEt = pho.superCluster()->energy() * std::sin(pho.superCluster()->position().theta());
       if (scEt > minPhoEt_ || pho.et() > minPhoEt_) {
         hcalHitSelector_.addDetIds(*pho.superCluster(), *recHits, indexToStore);
       }
     }
   }
   if (superClusters.isValid() && recHits.isValid()) {
     for (auto& sc : *superClusters) {
       float scEt = sc.energy() * std::sin(sc.position().theta());
       if (scEt > minSCEt_) {
         hcalHitSelector_.addDetIds(sc, *recHits, indexToStore);
       }
     }
   }
  
   //unify the vector
   std::sort(indexToStore.begin(), indexToStore.end());
   std::unique(indexToStore.begin(), indexToStore.end());
  
   auto detIdCollection = std::make_unique<DetIdCollection>(indexToStore);
  
   iEvent.put(std::move(detIdCollection), interestingDetIdCollection_);
 }