#include <EcalRecHitProducer.h>

Inheritance diagram for EcalRecHitProducer:

Public Member Functions
	EcalRecHitProducer (const edm::ParameterSet &ps)

void	produce (edm::Event &evt, const edm::EventSetup &es) override

	~EcalRecHitProducer () override

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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
std::unique_ptr< EcalCleaningAlgo >	cleaningAlgo_

edm::EDGetTokenT< std::set< EBDetId > >	ebDetIdToBeRecoveredToken_

edm::EDGetTokenT< std::set< EcalTrigTowerDetId > >	ebFEToBeRecoveredToken_

std::string	ebRechitCollection_

edm::EDGetTokenT< EBUncalibratedRecHitCollection >	ebUncalibRecHitToken_

edm::EDGetTokenT< std::set< EEDetId > >	eeDetIdToBeRecoveredToken_

edm::EDGetTokenT< std::set< EcalScDetId > >	eeFEToBeRecoveredToken_

std::string	eeRechitCollection_

edm::EDGetTokenT< EEUncalibratedRecHitCollection >	eeUncalibRecHitToken_

bool	killDeadChannels_

bool	recoverEBFE_

bool	recoverEBIsolatedChannels_

bool	recoverEBVFE_

bool	recoverEEFE_

bool	recoverEEIsolatedChannels_

bool	recoverEEVFE_

std::unique_ptr< EcalRecHitWorkerBaseClass >	worker_

std::unique_ptr< EcalRecHitWorkerBaseClass >	workerRecover_

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

produce ECAL rechits from uncalibrated rechits

Author: Shahram Rahatlou, University of Rome & INFN, March 2006

Definition at line 26 of file EcalRecHitProducer.h.

Constructor & Destructor Documentation

◆ EcalRecHitProducer()

EcalRecHitProducer::EcalRecHitProducer ( const edm::ParameterSet & ps )

explicit

Definition at line 30 of file EcalRecHitProducer.cc.

                                                                 {
   ebRechitCollection_ = ps.getParameter<std::string>("EBrechitCollection");
   eeRechitCollection_ = ps.getParameter<std::string>("EErechitCollection");
  
   recoverEBIsolatedChannels_ = ps.getParameter<bool>("recoverEBIsolatedChannels");
   recoverEEIsolatedChannels_ = ps.getParameter<bool>("recoverEEIsolatedChannels");
   recoverEBVFE_ = ps.getParameter<bool>("recoverEBVFE");
   recoverEEVFE_ = ps.getParameter<bool>("recoverEEVFE");
   recoverEBFE_ = ps.getParameter<bool>("recoverEBFE");
   recoverEEFE_ = ps.getParameter<bool>("recoverEEFE");
   killDeadChannels_ = ps.getParameter<bool>("killDeadChannels");
  
   produces<EBRecHitCollection>(ebRechitCollection_);
   produces<EERecHitCollection>(eeRechitCollection_);
  
   ebUncalibRecHitToken_ =
       consumes<EBUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("EBuncalibRecHitCollection"));
  
   eeUncalibRecHitToken_ =
       consumes<EEUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("EEuncalibRecHitCollection"));
  
   ebDetIdToBeRecoveredToken_ = consumes<std::set<EBDetId>>(ps.getParameter<edm::InputTag>("ebDetIdToBeRecovered"));
  
   eeDetIdToBeRecoveredToken_ = consumes<std::set<EEDetId>>(ps.getParameter<edm::InputTag>("eeDetIdToBeRecovered"));
  
   ebFEToBeRecoveredToken_ = consumes<std::set<EcalTrigTowerDetId>>(ps.getParameter<edm::InputTag>("ebFEToBeRecovered"));
  
   eeFEToBeRecoveredToken_ = consumes<std::set<EcalScDetId>>(ps.getParameter<edm::InputTag>("eeFEToBeRecovered"));
  
   std::string componentType = ps.getParameter<std::string>("algo");
   edm::ConsumesCollector c{consumesCollector()};
   worker_ = EcalRecHitWorkerFactory::get()->create(componentType, ps, c);
  
   // to recover problematic channels
   componentType = ps.getParameter<std::string>("algoRecover");
   workerRecover_ = EcalRecHitWorkerFactory::get()->create(componentType, ps, c);
  
   edm::ParameterSet cleaningPs = ps.getParameter<edm::ParameterSet>("cleaningConfig");
   cleaningAlgo_ = std::make_unique<EcalCleaningAlgo>(cleaningPs);
 }

References HltBtagPostValidation_cff::c, cleaningAlgo_, ebDetIdToBeRecoveredToken_, ebFEToBeRecoveredToken_, ebRechitCollection_, ebUncalibRecHitToken_, eeDetIdToBeRecoveredToken_, eeFEToBeRecoveredToken_, eeRechitCollection_, eeUncalibRecHitToken_, get, edm::ParameterSet::getParameter(), killDeadChannels_, recoverEBFE_, recoverEBIsolatedChannels_, recoverEBVFE_, recoverEEFE_, recoverEEIsolatedChannels_, recoverEEVFE_, AlCaHLTBitMon_QueryRunRegistry::string, worker_, and workerRecover_.

◆ ~EcalRecHitProducer()

EcalRecHitProducer::~EcalRecHitProducer ( )

overridedefault

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 257 of file EcalRecHitProducer.cc.

                                                                                     {
   edm::ParameterSetDescription desc;
   desc.add<bool>("recoverEEVFE", false);
   desc.add<std::string>("EErechitCollection", "EcalRecHitsEE");
   desc.add<bool>("recoverEBIsolatedChannels", false);
   desc.add<bool>("recoverEBVFE", false);
   desc.add<bool>("laserCorrection", true);
   desc.add<double>("EBLaserMIN", 0.5);
   desc.add<bool>("killDeadChannels", true);
   {
     std::vector<int> temp1;
     temp1.reserve(3);
     temp1.push_back(14);
     temp1.push_back(78);
     temp1.push_back(142);
     desc.add<std::vector<int>>("dbStatusToBeExcludedEB", temp1);
   }
   desc.add<edm::InputTag>("EEuncalibRecHitCollection",
                           edm::InputTag("ecalMultiFitUncalibRecHit", "EcalUncalibRecHitsEE"));
   {
     std::vector<int> temp1;
     temp1.reserve(3);
     temp1.push_back(14);
     temp1.push_back(78);
     temp1.push_back(142);
     desc.add<std::vector<int>>("dbStatusToBeExcludedEE", temp1);
   }
   desc.add<double>("EELaserMIN", 0.5);
   desc.add<edm::InputTag>("ebFEToBeRecovered", edm::InputTag("ecalDetIdToBeRecovered", "ebFE"));
   {
     edm::ParameterSetDescription psd0;
     psd0.add<double>("e6e2thresh", 0.04);
     psd0.add<double>("tightenCrack_e6e2_double", 3);
     psd0.add<double>("e4e1Threshold_endcap", 0.3);
     psd0.add<double>("tightenCrack_e4e1_single", 3);
     psd0.add<double>("tightenCrack_e1_double", 2);
     psd0.add<double>("cThreshold_barrel", 4);
     psd0.add<double>("e4e1Threshold_barrel", 0.08);
     psd0.add<double>("tightenCrack_e1_single", 2);
     psd0.add<double>("e4e1_b_barrel", -0.024);
     psd0.add<double>("e4e1_a_barrel", 0.04);
     psd0.add<double>("ignoreOutOfTimeThresh", 1000000000.0);
     psd0.add<double>("cThreshold_endcap", 15);
     psd0.add<double>("e4e1_b_endcap", -0.0125);
     psd0.add<double>("e4e1_a_endcap", 0.02);
     psd0.add<double>("cThreshold_double", 10);
     desc.add<edm::ParameterSetDescription>("cleaningConfig", psd0);
   }
   desc.add<double>("logWarningEtThreshold_EE_FE", 50);
   desc.add<edm::InputTag>("eeDetIdToBeRecovered", edm::InputTag("ecalDetIdToBeRecovered", "eeDetId"));
   desc.add<bool>("recoverEBFE", true);
   desc.add<edm::InputTag>("eeFEToBeRecovered", edm::InputTag("ecalDetIdToBeRecovered", "eeFE"));
   desc.add<edm::InputTag>("ebDetIdToBeRecovered", edm::InputTag("ecalDetIdToBeRecovered", "ebDetId"));
   desc.add<double>("singleChannelRecoveryThreshold", 8);
   desc.add<double>("sum8ChannelRecoveryThreshold", 0.);
   desc.add<edm::FileInPath>("bdtWeightFileNoCracks",
                             edm::FileInPath("RecoLocalCalo/EcalDeadChannelRecoveryAlgos/data/BDTWeights/"
                                             "bdtgAllRH_8GT700MeV_noCracks_ZskimData2017_v1.xml"));
   desc.add<edm::FileInPath>("bdtWeightFileCracks",
                             edm::FileInPath("RecoLocalCalo/EcalDeadChannelRecoveryAlgos/data/BDTWeights/"
                                             "bdtgAllRH_8GT700MeV_onlyCracks_ZskimData2017_v1.xml"));
   {
     std::vector<std::string> temp1;
     temp1.reserve(9);
     temp1.push_back("kNoisy");
     temp1.push_back("kNNoisy");
     temp1.push_back("kFixedG6");
     temp1.push_back("kFixedG1");
     temp1.push_back("kFixedG0");
     temp1.push_back("kNonRespondingIsolated");
     temp1.push_back("kDeadVFE");
     temp1.push_back("kDeadFE");
     temp1.push_back("kNoDataNoTP");
     desc.add<std::vector<std::string>>("ChannelStatusToBeExcluded", temp1);
   }
   desc.add<std::string>("EBrechitCollection", "EcalRecHitsEB");
   desc.add<edm::InputTag>("triggerPrimitiveDigiCollection", edm::InputTag("ecalDigis", "EcalTriggerPrimitives"));
   desc.add<bool>("recoverEEFE", true);
   desc.add<std::string>("singleChannelRecoveryMethod", "NeuralNetworks");
   desc.add<double>("EBLaserMAX", 3.0);
   {
     edm::ParameterSetDescription psd0;
     {
       std::vector<std::string> temp2;
       temp2.reserve(4);
       temp2.push_back("kOk");
       temp2.push_back("kDAC");
       temp2.push_back("kNoLaser");
       temp2.push_back("kNoisy");
       psd0.add<std::vector<std::string>>("kGood", temp2);
     }
     {
       std::vector<std::string> temp2;
       temp2.reserve(3);
       temp2.push_back("kFixedG0");
       temp2.push_back("kNonRespondingIsolated");
       temp2.push_back("kDeadVFE");
       psd0.add<std::vector<std::string>>("kNeighboursRecovered", temp2);
     }
     {
       std::vector<std::string> temp2;
       temp2.reserve(1);
       temp2.push_back("kNoDataNoTP");
       psd0.add<std::vector<std::string>>("kDead", temp2);
     }
     {
       std::vector<std::string> temp2;
       temp2.reserve(3);
       temp2.push_back("kNNoisy");
       temp2.push_back("kFixedG6");
       temp2.push_back("kFixedG1");
       psd0.add<std::vector<std::string>>("kNoisy", temp2);
     }
     {
       std::vector<std::string> temp2;
       temp2.reserve(1);
       temp2.push_back("kDeadFE");
       psd0.add<std::vector<std::string>>("kTowerRecovered", temp2);
     }
     desc.add<edm::ParameterSetDescription>("flagsMapDBReco", psd0);
   }
   desc.add<edm::InputTag>("EBuncalibRecHitCollection",
                           edm::InputTag("ecalMultiFitUncalibRecHit", "EcalUncalibRecHitsEB"));
   desc.add<std::string>("algoRecover", "EcalRecHitWorkerRecover");
   desc.add<std::string>("algo", "EcalRecHitWorkerSimple");
   desc.add<double>("EELaserMAX", 8.0);
   desc.add<double>("logWarningEtThreshold_EB_FE", 50);
   desc.add<bool>("recoverEEIsolatedChannels", false);
   desc.add<bool>("skipTimeCalib", false);
   descriptions.add("ecalRecHit", desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, edm::ParameterSetDescription::reserve(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

void EcalRecHitProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 73 of file EcalRecHitProducer.cc.

                                                                        {
   using namespace edm;
  
   Handle<EBUncalibratedRecHitCollection> pEBUncalibRecHits;
   Handle<EEUncalibratedRecHitCollection> pEEUncalibRecHits;
  
   const EBUncalibratedRecHitCollection* ebUncalibRecHits = nullptr;
   const EEUncalibratedRecHitCollection* eeUncalibRecHits = nullptr;
  
   // get the barrel uncalib rechit collection
  
   evt.getByToken(ebUncalibRecHitToken_, pEBUncalibRecHits);
   ebUncalibRecHits = pEBUncalibRecHits.product();
   LogDebug("EcalRecHitDebug") << "total # EB uncalibrated rechits: " << ebUncalibRecHits->size();
  
   evt.getByToken(eeUncalibRecHitToken_, pEEUncalibRecHits);
   eeUncalibRecHits = pEEUncalibRecHits.product();  // get a ptr to the product
   LogDebug("EcalRecHitDebug") << "total # EE uncalibrated rechits: " << eeUncalibRecHits->size();
  
   // collection of rechits to put in the event
   auto ebRecHits = std::make_unique<EBRecHitCollection>();
   auto eeRecHits = std::make_unique<EERecHitCollection>();
  
   worker_->set(es);
  
   if (recoverEBIsolatedChannels_ || recoverEEIsolatedChannels_ || recoverEBFE_ || recoverEEFE_ || recoverEBVFE_ ||
       recoverEEVFE_ || killDeadChannels_) {
     workerRecover_->set(es);
   }
  
   if (ebUncalibRecHits) {
     // loop over uncalibrated rechits to make calibrated ones
     for (EBUncalibratedRecHitCollection::const_iterator it = ebUncalibRecHits->begin(); it != ebUncalibRecHits->end();
          ++it) {
       worker_->run(evt, *it, *ebRecHits);
     }
   }
  
   if (eeUncalibRecHits) {
     // loop over uncalibrated rechits to make calibrated ones
     for (EEUncalibratedRecHitCollection::const_iterator it = eeUncalibRecHits->begin(); it != eeUncalibRecHits->end();
          ++it) {
       worker_->run(evt, *it, *eeRecHits);
     }
   }
  
   // sort collections before attempting recovery, to avoid insertion of double recHits
   ebRecHits->sort();
   eeRecHits->sort();
  
   if (recoverEBIsolatedChannels_ || recoverEBFE_ || killDeadChannels_) {
     edm::Handle<std::set<EBDetId>> pEBDetId;
     const std::set<EBDetId>* detIds = nullptr;
     evt.getByToken(ebDetIdToBeRecoveredToken_, pEBDetId);
     detIds = pEBDetId.product();
  
     if (detIds) {
       edm::ESHandle<EcalChannelStatus> chStatus;
       es.get<EcalChannelStatusRcd>().get(chStatus);
       for (std::set<EBDetId>::const_iterator it = detIds->begin(); it != detIds->end(); ++it) {
         // get channel status map to treat dead VFE separately
         EcalChannelStatusMap::const_iterator chit = chStatus->find(*it);
         EcalChannelStatusCode chStatusCode;
         if (chit != chStatus->end()) {
           chStatusCode = *chit;
         } else {
           edm::LogError("EcalRecHitProducerError") << "No channel status found for xtal " << (*it).rawId()
                                                    << "! something wrong with EcalChannelStatus in your DB? ";
         }
         EcalUncalibratedRecHit urh;
         if (chStatusCode.getStatusCode() == EcalChannelStatusCode::kDeadVFE) {  // dead VFE (from DB info)
           // uses the EcalUncalibratedRecHit to pass the DetId info
           urh = EcalUncalibratedRecHit(*it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_VFE);
           if (recoverEBVFE_ || killDeadChannels_)
             workerRecover_->run(evt, urh, *ebRecHits);
         } else {
           // uses the EcalUncalibratedRecHit to pass the DetId info
           urh = EcalUncalibratedRecHit(*it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_single);
           if (recoverEBIsolatedChannels_ || killDeadChannels_)
             workerRecover_->run(evt, urh, *ebRecHits);
         }
       }
     }
   }
  
   if (recoverEEIsolatedChannels_ || recoverEEVFE_ || killDeadChannels_) {
     edm::Handle<std::set<EEDetId>> pEEDetId;
     const std::set<EEDetId>* detIds = nullptr;
  
     evt.getByToken(eeDetIdToBeRecoveredToken_, pEEDetId);
     detIds = pEEDetId.product();
  
     if (detIds) {
       edm::ESHandle<EcalChannelStatus> chStatus;
       es.get<EcalChannelStatusRcd>().get(chStatus);
       for (std::set<EEDetId>::const_iterator it = detIds->begin(); it != detIds->end(); ++it) {
         // get channel status map to treat dead VFE separately
         EcalChannelStatusMap::const_iterator chit = chStatus->find(*it);
         EcalChannelStatusCode chStatusCode;
         if (chit != chStatus->end()) {
           chStatusCode = *chit;
         } else {
           edm::LogError("EcalRecHitProducerError") << "No channel status found for xtal " << (*it).rawId()
                                                    << "! something wrong with EcalChannelStatus in your DB? ";
         }
         EcalUncalibratedRecHit urh;
         if (chStatusCode.getStatusCode() == EcalChannelStatusCode::kDeadVFE) {  // dead VFE (from DB info)
           // uses the EcalUncalibratedRecHit to pass the DetId info
           urh = EcalUncalibratedRecHit(*it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EE_VFE);
           if (recoverEEVFE_ || killDeadChannels_)
             workerRecover_->run(evt, urh, *eeRecHits);
         } else {
           // uses the EcalUncalibratedRecHit to pass the DetId info
           urh = EcalUncalibratedRecHit(*it, 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EE_single);
           if (recoverEEIsolatedChannels_ || killDeadChannels_)
             workerRecover_->run(evt, urh, *eeRecHits);
         }
       }
     }
   }
  
   if (recoverEBFE_ || killDeadChannels_) {
     edm::Handle<std::set<EcalTrigTowerDetId>> pEBFEId;
     const std::set<EcalTrigTowerDetId>* ttIds = nullptr;
  
     evt.getByToken(ebFEToBeRecoveredToken_, pEBFEId);
     ttIds = pEBFEId.product();
  
     if (ttIds) {
       for (std::set<EcalTrigTowerDetId>::const_iterator it = ttIds->begin(); it != ttIds->end(); ++it) {
         // uses the EcalUncalibratedRecHit to pass the DetId info
         int ieta = (((*it).ietaAbs() - 1) * 5 + 1) * (*it).zside();  // from EcalTrigTowerConstituentsMap
         int iphi = (((*it).iphi() - 1) * 5 + 11) % 360;              // from EcalTrigTowerConstituentsMap
         if (iphi <= 0)
           iphi += 360;  // from EcalTrigTowerConstituentsMap
         EcalUncalibratedRecHit urh(
             EBDetId(ieta, iphi, EBDetId::ETAPHIMODE), 0, 0, 0, 0, EcalRecHitWorkerBaseClass::EB_FE);
         workerRecover_->run(evt, urh, *ebRecHits);
       }
     }
   }
  
   if (recoverEEFE_ || killDeadChannels_) {
     edm::Handle<std::set<EcalScDetId>> pEEFEId;
     const std::set<EcalScDetId>* scIds = nullptr;
  
     evt.getByToken(eeFEToBeRecoveredToken_, pEEFEId);
     scIds = pEEFEId.product();
  
     if (scIds) {
       for (std::set<EcalScDetId>::const_iterator it = scIds->begin(); it != scIds->end(); ++it) {
         // uses the EcalUncalibratedRecHit to pass the DetId info
         if (EEDetId::validDetId(((*it).ix() - 1) * 5 + 1, ((*it).iy() - 1) * 5 + 1, (*it).zside())) {
           EcalUncalibratedRecHit urh(EEDetId(((*it).ix() - 1) * 5 + 1, ((*it).iy() - 1) * 5 + 1, (*it).zside()),
                                      0,
                                      0,
                                      0,
                                      0,
                                      EcalRecHitWorkerBaseClass::EE_FE);
           workerRecover_->run(evt, urh, *eeRecHits);
         }
       }
     }
   }
  
   // without re-sorting, find (used below in cleaning) will lead
   // to undefined results
   ebRecHits->sort();
   eeRecHits->sort();
  
   // apply spike cleaning
   if (cleaningAlgo_) {
     cleaningAlgo_->setFlags(*ebRecHits);
     cleaningAlgo_->setFlags(*eeRecHits);
   }
  
   // put the collection of recunstructed hits in the event
   LogInfo("EcalRecHitInfo") << "total # EB calibrated rechits: " << ebRecHits->size();
   LogInfo("EcalRecHitInfo") << "total # EE calibrated rechits: " << eeRecHits->size();
  
   evt.put(std::move(ebRecHits), ebRechitCollection_);
   evt.put(std::move(eeRecHits), eeRechitCollection_);
 }