#include <EgammaIsoESDetIdCollectionProducer.h>

Inheritance diagram for EgammaIsoESDetIdCollectionProducer:

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

	EgammaIsoESDetIdCollectionProducer (const edm::ParameterSet &)
	ctor More...

void	produce (edm::Event &, const edm::EventSetup &) override
	producer More...

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

Private Member Functions
void	addDetIds (const reco::SuperCluster &superClus, reco::PFClusterCollection clusters, const reco::PFCluster::EEtoPSAssociation &eeClusToESMap, std::vector< DetId > &detIdsToStore)

Private Attributes
edm::EDGetTokenT< reco::PFClusterCollection >	ecalPFClustersToken_

edm::EDGetTokenT< reco::PFCluster::EEtoPSAssociation >	eeClusToESMapToken_

edm::EDGetTokenT< reco::GsfElectronCollection >	elesToken_

std::string	interestingDetIdCollection_

float	maxDR_

float	minEleEt_

float	minPhoEt_

float	minSCEt_

edm::EDGetTokenT< reco::PhotonCollection >	phosToken_

edm::EDGetTokenT< reco::SuperClusterCollection >	superClustersToken_

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

author: Sam Harper (inspired by InterestingDetIdProducer)

Make a collection of detids to be kept in a AOD rechit collection These are all the ES DetIds of ES PFClusters associated to all PF clusters within dR of ele/pho/sc The aim is to save enough preshower info in the AOD to remake the PF clusters near an ele/pho/sc

Definition at line 39 of file EgammaIsoESDetIdCollectionProducer.h.

Constructor & Destructor Documentation

◆ EgammaIsoESDetIdCollectionProducer()

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

explicit

ctor

Definition at line 9 of file EgammaIsoESDetIdCollectionProducer.cc.

                                                                                                      {
   eeClusToESMapToken_ =
       consumes<reco::PFCluster::EEtoPSAssociation>(iConfig.getParameter<edm::InputTag>("eeClusToESMapLabel"));
  
   ecalPFClustersToken_ =
       consumes<reco::PFClusterCollection>(iConfig.getParameter<edm::InputTag>("ecalPFClustersLabel"));
   elesToken_ = consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("elesLabel"));
  
   phosToken_ = consumes<reco::PhotonCollection>(iConfig.getParameter<edm::InputTag>("phosLabel"));
  
   superClustersToken_ =
       consumes<reco::SuperClusterCollection>(iConfig.getParameter<edm::InputTag>("superClustersLabel"));
  
   minSCEt_ = iConfig.getParameter<double>("minSCEt");
   minEleEt_ = iConfig.getParameter<double>("minEleEt");
   minPhoEt_ = iConfig.getParameter<double>("minPhoEt");
  
   interestingDetIdCollection_ = iConfig.getParameter<std::string>("interestingDetIdCollection");
  
   maxDR_ = iConfig.getParameter<double>("maxDR");
  
   //register your products
   produces<DetIdCollection>(interestingDetIdCollection_);
 }

References ecalPFClustersToken_, eeClusToESMapToken_, elesToken_, edm::ParameterSet::getParameter(), interestingDetIdCollection_, maxDR_, minEleEt_, minPhoEt_, minSCEt_, phosToken_, AlCaHLTBitMon_QueryRunRegistry::string, and superClustersToken_.

Member Function Documentation

◆ addDetIds()

void EgammaIsoESDetIdCollectionProducer::addDetIds	(	const reco::SuperCluster &	superClus,
		reco::PFClusterCollection	clusters,
		const reco::PFCluster::EEtoPSAssociation &	eeClusToESMap,
		std::vector< DetId > &	detIdsToStore
	)

private

Definition at line 90 of file EgammaIsoESDetIdCollectionProducer.cc.

                                                                                     {
   const float scEta = superClus.eta();
   //  if(std::abs(scEta)+maxDR_<1.5) return; //not possible to have a endcap cluster, let alone one with preshower (eta>1.65) so exit without checking further
   const float scPhi = superClus.phi();
  
   const float maxDR2 = maxDR_ * maxDR_;
  
   for (size_t clusNr = 0; clusNr < clusters.size(); clusNr++) {
     const reco::PFCluster& clus = clusters[clusNr];
     if (clus.layer() == PFLayer::ECAL_ENDCAP && reco::deltaR2(scEta, scPhi, clus.eta(), clus.phi()) < maxDR2) {
       auto keyVal = std::make_pair(clusNr, edm::Ptr<reco::PFCluster>());
       const auto esClusters = std::equal_range(
           eeClusToESMap.begin(),
           eeClusToESMap.end(),
           keyVal,
           [](const reco::PFCluster::EEtoPSAssociation::value_type& rhs,  //roll on c++14, auto & lambda 4 evar!
              const reco::PFCluster::EEtoPSAssociation::value_type& lhs) -> bool { return rhs.first < lhs.first; });
       //   std::cout <<"cluster "<<clus.eta()<<"  had "<<std::distance(esClusters.first,esClusters.second)<<" es clusters"<<std::endl;
       for (auto esIt = esClusters.first; esIt != esClusters.second; ++esIt) {
         //   std::cout <<"es clus "<<esIt->second->hitsAndFractions().size()<<std::endl;
         for (const auto& hitAndFrac : esIt->second->hitsAndFractions()) {
           detIdsToStore.push_back(hitAndFrac.first);
         }
       }
  
     }  //end of endcap & dR check
   }    //end of cluster loop
 }

References bsc_activity_cfg::clusters, reco::deltaR2(), PFLayer::ECAL_ENDCAP, reco::CaloCluster::eta(), reco::PFCluster::layer(), maxDR_, and reco::CaloCluster::phi().

Referenced by produce().

◆ beginRun()

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

final

Definition at line 34 of file EgammaIsoESDetIdCollectionProducer.cc.

34 {}

◆ produce()

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

override

producer

Definition at line 37 of file EgammaIsoESDetIdCollectionProducer.cc.

                                                                                               {
   // take BasicClusters
   edm::Handle<reco::SuperClusterCollection> superClusters;
   iEvent.getByToken(superClustersToken_, superClusters);
  
   edm::Handle<reco::GsfElectronCollection> eles;
   iEvent.getByToken(elesToken_, eles);
  
   edm::Handle<reco::PhotonCollection> phos;
   iEvent.getByToken(phosToken_, phos);
  
   edm::Handle<reco::PFCluster::EEtoPSAssociation> eeClusToESMap;
   iEvent.getByToken(eeClusToESMapToken_, eeClusToESMap);
  
   edm::Handle<reco::PFClusterCollection> ecalPFClusters;
   iEvent.getByToken(ecalPFClustersToken_, ecalPFClusters);
  
   //Create empty output collections
   std::vector<DetId> indexToStore;
   indexToStore.reserve(100);
  
   if (eles.isValid() && eeClusToESMap.isValid() && ecalPFClusters.isValid()) {
     for (auto& ele : *eles) {
       float scEt = ele.superCluster()->energy() * std::sin(ele.superCluster()->position().theta());
       if (scEt > minEleEt_ || ele.et() > minEleEt_)
         addDetIds(*ele.superCluster(), *ecalPFClusters, *eeClusToESMap, indexToStore);
     }
   }
   if (phos.isValid() && eeClusToESMap.isValid() && ecalPFClusters.isValid()) {
     for (auto& pho : *phos) {
       float scEt = pho.superCluster()->energy() * std::sin(pho.superCluster()->position().theta());
       if (scEt > minPhoEt_ || pho.et() > minPhoEt_)
         addDetIds(*pho.superCluster(), *ecalPFClusters, *eeClusToESMap, indexToStore);
     }
   }
   if (superClusters.isValid() && eeClusToESMap.isValid() && ecalPFClusters.isValid()) {
     for (auto& sc : *superClusters) {
       float scEt = sc.energy() * std::sin(sc.position().theta());
       if (scEt > minSCEt_)
         addDetIds(sc, *ecalPFClusters, *eeClusToESMap, 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_);
 }