Inheritance diagram for InterestingDetIdCollectionProducer:

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

	InterestingDetIdCollectionProducer (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
edm::EDGetTokenT< reco::BasicClusterCollection >	basicClustersToken_

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

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: Paolo Meridiani PH/CMG

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

The following classes of "interesting id" are considered

1.in a region around  the seed of the cluster collection specified
  by paramter basicClusters. 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 50 of file InterestingDetIdCollectionProducer.cc.

Constructor & Destructor Documentation

◆ InterestingDetIdCollectionProducer()

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

explicit

ctor

Definition at line 80 of file InterestingDetIdCollectionProducer.cc.

                                                                                                      {
   recHitsToken_ = consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsLabel"));
   basicClustersToken_ =
       consumes<reco::BasicClusterCollection>(iConfig.getParameter<edm::InputTag>("basicClustersLabel"));
   caloTopologyToken_ = esConsumes<CaloTopology, CaloTopologyRecord, edm::Transition::BeginRun>();
   sevLVToken_ = esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd, edm::Transition::BeginRun>();
   nextToDeadToken_ = esConsumes<EcalNextToDeadChannel, EcalNextToDeadChannelRcd>();
  
   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("InterestingDetIdCollectionProducerError") << "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");
 }

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

Member Function Documentation

◆ beginRun()

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

final

Definition at line 103 of file InterestingDetIdCollectionProducer.cc.

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

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

◆ produce()

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

override

producer

Definition at line 112 of file InterestingDetIdCollectionProducer.cc.

                                                                                               {
   using namespace edm;
   using namespace std;
  
   // take BasicClusters
   Handle<reco::BasicClusterCollection> pClusters;
   iEvent.getByToken(basicClustersToken_, pClusters);
  
   // take EcalRecHits
   Handle<EcalRecHitCollection> recHitsHandle;
   iEvent.getByToken(recHitsToken_, recHitsHandle);
  
   //Create empty output collections
   std::vector<DetId> indexToStore;
   indexToStore.reserve(1000);
  
   reco::BasicClusterCollection::const_iterator clusIt;
  
   std::vector<DetId> xtalsToStore;
   xtalsToStore.reserve(50);
   for (clusIt = pClusters->begin(); clusIt != pClusters->end(); clusIt++) {
     const std::vector<std::pair<DetId, float> >& clusterDetIds = clusIt->hitsAndFractions();
     for (const auto& detidpair : clusterDetIds) {
       indexToStore.push_back(detidpair.first);
     }
  
     //below checks and additional code are only relevant for EB/EE, not for ES
     if (clusterDetIds.front().first.subdetId() == EcalBarrel || clusterDetIds.front().first.subdetId() == EcalEndcap) {
       std::vector<std::pair<DetId, float> >::const_iterator posCurrent;
  
       float eMax = 0.;
       DetId eMaxId(0);
  
       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_);
  
       for (const auto& detid : xtalsToStore) {
         indexToStore.push_back(detid);
       }
     }
   }
  
   if (severityLevel_ >= 0 || keepNextToDead_ || keepNextToBoundary_) {
     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());
  
   iEvent.put(std::make_unique<DetIdCollection>(indexToStore), interestingDetIdCollection_);
 }