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

	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

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<>
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

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 49 of file InterestingDetIdFromSuperClusterProducer.cc.

Constructor & Destructor Documentation

◆ InterestingDetIdFromSuperClusterProducer()

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

explicit

ctor

Definition at line 78 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 102 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 111 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_);
 }