#include <InterestingDetIdFromSuperClusterProducer.h>

Inheritance diagram for InterestingDetIdFromSuperClusterProducer:

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

	InterestingDetIdFromSuperClusterProducer (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	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
const CaloTopology *	caloTopology_

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	caloTopologyToken_

std::string	interestingDetIdCollection_

bool	keepNextToBoundary_

bool	keepNextToDead_

int	minimalEtaSize_

int	minimalPhiSize_

edm::ESGetToken< EcalNextToDeadChannel, EcalNextToDeadChannelRcd >	nextToDeadToken_

edm::EDGetTokenT< EcalRecHitCollection >	recHitsToken_

const EcalSeverityLevelAlgo *	severity_

int	severityLevel_

edm::ESGetToken< EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd >	severityLevelToken_

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

Adapted from InterestingDetIdCollectionProducer by J.Bendavid

Make a collection of detids to be kept tipically in a AOD rechit collection

The following classes of "interesting id" are considered

1.All rechits included in all subclusters, plus in a region around  the seed of each subcluster
  The size of the region is specified by
  minimalEtaSize_, minimalPhiSize_

2. if the severity of the hit is >= severityLevel_
   If severityLevel=0 this class is ignored

3. Channels next to dead ones,  keepNextToDead_ is true
4. Channels next to the EB/EE transition if keepNextToBoundary_ is true

Definition at line 52 of file InterestingDetIdFromSuperClusterProducer.h.

Constructor & Destructor Documentation

◆ InterestingDetIdFromSuperClusterProducer()

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

explicit

ctor

Definition at line 15 of file InterestingDetIdFromSuperClusterProducer.cc.

                                                                                                                  {
   recHitsToken_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsLabel"));
   superClustersToken_ =
       consumes<reco::SuperClusterCollection>(iConfig.getParameter<edm::InputTag>("superClustersLabel"));
   caloTopologyToken_ = esConsumes<CaloTopology, CaloTopologyRecord, edm::Transition::BeginRun>();
   severityLevelToken_ = esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd, edm::Transition::BeginRun>();
   interestingDetIdCollection_ = iConfig.getParameter<std::string>("interestingDetIdCollection");
  
   minimalEtaSize_ = iConfig.getParameter<int>("etaSize");
   minimalPhiSize_ = iConfig.getParameter<int>("phiSize");
   if (minimalPhiSize_ % 2 == 0 || minimalEtaSize_ % 2 == 0)
     edm::LogError("InterestingDetIdFromSuperClusterProducerError") << "Size of eta/phi should be odd numbers";
  
   //register your products
   produces<DetIdCollection>(interestingDetIdCollection_);
  
   severityLevel_ = iConfig.getParameter<int>("severityLevel");
   keepNextToDead_ = iConfig.getParameter<bool>("keepNextToDead");
   keepNextToBoundary_ = iConfig.getParameter<bool>("keepNextToBoundary");
   if (keepNextToDead_) {
     nextToDeadToken_ = esConsumes<EcalNextToDeadChannel, EcalNextToDeadChannelRcd>();
   }
 }

References caloTopologyToken_, edm::ParameterSet::getParameter(), interestingDetIdCollection_, keepNextToBoundary_, keepNextToDead_, minimalEtaSize_, minimalPhiSize_, nextToDeadToken_, recHitsToken_, severityLevel_, severityLevelToken_, AlCaHLTBitMon_QueryRunRegistry::string, and superClustersToken_.

Member Function Documentation

◆ beginRun()

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

final

Definition at line 39 of file InterestingDetIdFromSuperClusterProducer.cc.

                                                                                                       {
   edm::ESHandle<CaloTopology> theCaloTopology = iSetup.getHandle(caloTopologyToken_);
   caloTopology_ = &(*theCaloTopology);
  
   edm::ESHandle<EcalSeverityLevelAlgo> sevLv = iSetup.getHandle(severityLevelToken_);
   severity_ = sevLv.product();
 }

References caloTopology_, caloTopologyToken_, edm::EventSetup::getHandle(), edm::ESHandle< T >::product(), severity_, and severityLevelToken_.

◆ produce()

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

override

producer

Definition at line 48 of file InterestingDetIdFromSuperClusterProducer.cc.

                                                                                                     {
   using namespace edm;
   using namespace std;
  
   // take BasicClusters
   Handle<reco::SuperClusterCollection> pClusters;
   iEvent.getByToken(superClustersToken_, pClusters);
  
   // take EcalRecHits
   Handle<EcalRecHitCollection> recHitsHandle;
   iEvent.getByToken(recHitsToken_, recHitsHandle);
  
   //Create empty output collections
   std::vector<DetId> indexToStore;
   indexToStore.reserve(1000);
  
   reco::SuperClusterCollection::const_iterator sclusIt;
  
   std::vector<DetId> xtalsToStore;
   xtalsToStore.reserve(50);
  
   //loop over superclusters
   for (sclusIt = pClusters->begin(); sclusIt != pClusters->end(); sclusIt++) {
     //loop over subclusters
     for (reco::CaloCluster_iterator clusIt = sclusIt->clustersBegin(); clusIt != sclusIt->clustersEnd(); ++clusIt) {
       //PG barrel
  
       float eMax = 0.;
       DetId eMaxId(0);
  
       std::vector<std::pair<DetId, float> > clusterDetIds = (*clusIt)->hitsAndFractions();
       std::vector<std::pair<DetId, float> >::iterator posCurrent;
  
       EcalRecHit testEcalRecHit;
  
       for (posCurrent = clusterDetIds.begin(); posCurrent != clusterDetIds.end(); posCurrent++) {
         EcalRecHitCollection::const_iterator itt = recHitsHandle->find((*posCurrent).first);
         if ((!((*posCurrent).first.null())) && (itt != recHitsHandle->end()) && ((*itt).energy() > eMax)) {
           eMax = (*itt).energy();
           eMaxId = (*itt).id();
         }
       }
  
       if (eMaxId.null())
         continue;
  
       const CaloSubdetectorTopology* topology = caloTopology_->getSubdetectorTopology(eMaxId.det(), eMaxId.subdetId());
  
       xtalsToStore = topology->getWindow(eMaxId, minimalEtaSize_, minimalPhiSize_);
       std::vector<std::pair<DetId, float> > xtalsInClus = (*clusIt)->hitsAndFractions();
  
       for (unsigned int ii = 0; ii < xtalsInClus.size(); ii++) {
         xtalsToStore.push_back(xtalsInClus[ii].first);
       }
  
       indexToStore.insert(indexToStore.end(), xtalsToStore.begin(), xtalsToStore.end());
     }
   }
  
   for (EcalRecHitCollection::const_iterator it = recHitsHandle->begin(); it != recHitsHandle->end(); ++it) {
     // also add recHits of dead TT if the corresponding TP is saturated
     if (it->checkFlag(EcalRecHit::kTPSaturated)) {
       indexToStore.push_back(it->id());
     }
     // add hits for severities above a threshold
     if (severityLevel_ >= 0 && severity_->severityLevel(*it) >= severityLevel_) {
       indexToStore.push_back(it->id());
     }
     if (keepNextToDead_) {
       edm::ESHandle<EcalNextToDeadChannel> dch = iSetup.getHandle(nextToDeadToken_);
       // also keep channels next to dead ones
       if (EcalTools::isNextToDead(it->id(), *dch)) {
         indexToStore.push_back(it->id());
       }
     }
  
     if (keepNextToBoundary_) {
       // keep channels around EB/EE boundary
       if (it->id().subdetId() == EcalBarrel) {
         EBDetId ebid(it->id());
         if (abs(ebid.ieta()) == 85)
           indexToStore.push_back(it->id());
       } else {
         if (EEDetId::isNextToRingBoundary(it->id()))
           indexToStore.push_back(it->id());
       }
     }
   }
  
   //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_);
 }