#include <EcalDetIdToBeRecoveredProducer.h>

Inheritance diagram for EcalDetIdToBeRecoveredProducer:

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

	EcalDetIdToBeRecoveredProducer (const edm::ParameterSet &ps)

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

	~EcalDetIdToBeRecoveredProducer () override

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

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

Private Attributes
edm::ESGetToken< EcalChannelStatusMap, EcalChannelStatusRcd >	channelStatusToken_

const EcalChannelStatusMap *	chStatus_

std::string	ebDetIdCollection_

edm::EDGetTokenT< EBDetIdCollection >	ebIntegrityChIdErrorsToken_

edm::EDGetTokenT< EBDetIdCollection >	ebIntegrityGainErrorsToken_

edm::EDGetTokenT< EBDetIdCollection >	ebIntegrityGainSwitchErrorsToken_

edm::EDGetTokenT< EBSrFlagCollection >	ebSrFlagToken_

const EcalElectronicsMapping *	ecalMapping_

edm::ESGetToken< EcalElectronicsMapping, EcalMappingRcd >	ecalMappingToken_

std::string	eeDetIdCollection_

edm::EDGetTokenT< EEDetIdCollection >	eeIntegrityChIdErrorsToken_

edm::EDGetTokenT< EEDetIdCollection >	eeIntegrityGainErrorsToken_

edm::EDGetTokenT< EEDetIdCollection >	eeIntegrityGainSwitchErrorsToken_

edm::EDGetTokenT< EESrFlagCollection >	eeSrFlagToken_

edm::EDGetTokenT< EcalElectronicsIdCollection >	integrityBlockSizeErrorsToken_

edm::EDGetTokenT< EcalElectronicsIdCollection >	integrityTTIdErrorsToken_

std::string	scDetIdCollection_

std::string	ttDetIdCollection_

edm::ESHandle< EcalTrigTowerConstituentsMap >	ttMap_

edm::ESGetToken< EcalTrigTowerConstituentsMap, IdealGeometryRecord >	ttMapToken_

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

produce ECAL rechits from uncalibrated rechits

$Id: $Date: $Revision:

Author: Federico Ferri, CEA-Saclay IRFU/SPP

Definition at line 33 of file EcalDetIdToBeRecoveredProducer.h.

Constructor & Destructor Documentation

◆ EcalDetIdToBeRecoveredProducer()

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

explicit

Definition at line 19 of file EcalDetIdToBeRecoveredProducer.cc.

References channelStatusToken_, ebDetIdCollection_, ebIntegrityChIdErrorsToken_, ebIntegrityGainErrorsToken_, ebIntegrityGainSwitchErrorsToken_, ebSrFlagToken_, ecalMappingToken_, eeDetIdCollection_, eeIntegrityChIdErrorsToken_, eeIntegrityGainErrorsToken_, eeIntegrityGainSwitchErrorsToken_, eeSrFlagToken_, edm::ParameterSet::getParameter(), integrityBlockSizeErrorsToken_, integrityTTIdErrorsToken_, scDetIdCollection_, AlCaHLTBitMon_QueryRunRegistry::string, ttDetIdCollection_, and ttMapToken_.

                                                                                         {
   ecalMappingToken_ = esConsumes<EcalElectronicsMapping, EcalMappingRcd, edm::Transition::BeginRun>();
   channelStatusToken_ = esConsumes<EcalChannelStatusMap, EcalChannelStatusRcd, edm::Transition::BeginRun>();
   ttMapToken_ = esConsumes<EcalTrigTowerConstituentsMap, IdealGeometryRecord, edm::Transition::BeginRun>();
   // SRP collections
   ebSrFlagToken_ = consumes<EBSrFlagCollection>(ps.getParameter<edm::InputTag>("ebSrFlagCollection"));
   eeSrFlagToken_ = consumes<EESrFlagCollection>(ps.getParameter<edm::InputTag>("eeSrFlagCollection"));
 
   // Integrity for xtal data
   ebIntegrityGainErrorsToken_ = consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityGainErrors"));
   ebIntegrityGainSwitchErrorsToken_ =
       consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityGainSwitchErrors"));
   ebIntegrityChIdErrorsToken_ = consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityChIdErrors"));
 
   // Integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
   eeIntegrityGainErrorsToken_ = consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityGainErrors"));
   eeIntegrityGainSwitchErrorsToken_ =
       consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityGainSwitchErrors"));
   eeIntegrityChIdErrorsToken_ = consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityChIdErrors"));
 
   // Integrity Errors
   integrityTTIdErrorsToken_ =
       consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityTTIdErrors"));
   integrityBlockSizeErrorsToken_ =
       consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityBlockSizeErrors"));
 
   // output collections
   ebDetIdCollection_ = ps.getParameter<std::string>("ebDetIdToBeRecovered");
   eeDetIdCollection_ = ps.getParameter<std::string>("eeDetIdToBeRecovered");
   ttDetIdCollection_ = ps.getParameter<std::string>("ebFEToBeRecovered");
   scDetIdCollection_ = ps.getParameter<std::string>("eeFEToBeRecovered");
 
   produces<std::set<EBDetId>>(ebDetIdCollection_);
   produces<std::set<EEDetId>>(eeDetIdCollection_);
   produces<std::set<EcalTrigTowerDetId>>(ttDetIdCollection_);
   produces<std::set<EcalScDetId>>(scDetIdCollection_);
 }

◆ ~EcalDetIdToBeRecoveredProducer()

EcalDetIdToBeRecoveredProducer::~EcalDetIdToBeRecoveredProducer ( )

override

Definition at line 57 of file EcalDetIdToBeRecoveredProducer.cc.

57 {}

Member Function Documentation

◆ beginRun()

void EcalDetIdToBeRecoveredProducer::beginRun	(	edm::Run const &	run,
		const edm::EventSetup &	es
	)

final

Definition at line 59 of file EcalDetIdToBeRecoveredProducer.cc.

References channelStatusToken_, chStatus_, ecalMapping_, ecalMappingToken_, edm::EventSetup::getHandle(), edm::ESHandle< T >::product(), ttMap_, and ttMapToken_.

                                                                                         {
   edm::ESHandle<EcalElectronicsMapping> pEcalMapping = es.getHandle(ecalMappingToken_);
   ecalMapping_ = pEcalMapping.product();
 
   edm::ESHandle<EcalChannelStatusMap> pChStatus = es.getHandle(channelStatusToken_);
   chStatus_ = pChStatus.product();
 
   ttMap_ = es.getHandle(ttMapToken_);
 }

◆ fillDescriptions()

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

static

Definition at line 301 of file EcalDetIdToBeRecoveredProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v12_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                 {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("ebIntegrityChIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityChIdErrors"));
   desc.add<std::string>("ebDetIdToBeRecovered", "ebDetId");
   desc.add<edm::InputTag>("integrityTTIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityTTIdErrors"));
   desc.add<edm::InputTag>("eeIntegrityGainErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainErrors"));
   desc.add<std::string>("ebFEToBeRecovered", "ebFE");
   desc.add<edm::InputTag>("ebIntegrityGainErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainErrors"));
   desc.add<std::string>("eeDetIdToBeRecovered", "eeDetId");
   desc.add<edm::InputTag>("eeIntegrityGainSwitchErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainSwitchErrors"));
   desc.add<edm::InputTag>("eeIntegrityChIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityChIdErrors"));
   desc.add<edm::InputTag>("ebIntegrityGainSwitchErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainSwitchErrors"));
   desc.add<edm::InputTag>("ebSrFlagCollection", edm::InputTag("ecalDigis"));
   desc.add<std::string>("eeFEToBeRecovered", "eeFE");
   desc.add<edm::InputTag>("integrityBlockSizeErrors", edm::InputTag("ecalDigis", "EcalIntegrityBlockSizeErrors"));
   desc.add<edm::InputTag>("eeSrFlagCollection", edm::InputTag("ecalDigis"));
   descriptions.add("ecalDetIdToBeRecovered", desc);
 }

◆ produce()

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

final

Definition at line 76 of file EcalDetIdToBeRecoveredProducer.cc.

References edm::EDCollection< T >::begin(), edm::SortedCollection< T, SORT >::begin(), chStatus_, EcalTrigTowerConstituentsMap::constituentsOf(), PVValHelper::dx, PVValHelper::dy, ebDetIdCollection_, HLT_2022v12_cff::ebIntegrityChIdErrors, ebIntegrityChIdErrorsToken_, HLT_2022v12_cff::ebIntegrityGainErrors, ebIntegrityGainErrorsToken_, HLT_2022v12_cff::ebIntegrityGainSwitchErrors, ebIntegrityGainSwitchErrorsToken_, ebSrFlagToken_, EcalBarrel, EcalEndcap, ecalMapping_, eeDetIdCollection_, HLT_2022v12_cff::eeIntegrityChIdErrors, eeIntegrityChIdErrorsToken_, HLT_2022v12_cff::eeIntegrityGainErrors, eeIntegrityGainErrorsToken_, HLT_2022v12_cff::eeIntegrityGainSwitchErrors, eeIntegrityGainSwitchErrorsToken_, eeSrFlagToken_, edm::SortedCollection< T, SORT >::empty(), edm::EDCollection< T >::end(), EcalCondObjectContainer< T >::end(), edm::SortedCollection< T, SORT >::end(), makeMEIFBenchmarkPlots::ev, EcalCondObjectContainer< T >::find(), RemoveAddSevLevel::flag, EcalElectronicsMapping::getDetId(), mps_fire::i, include(), HLT_2022v12_cff::integrityBlockSizeErrors, integrityBlockSizeErrorsToken_, HLT_2022v12_cff::integrityTTIdErrors, integrityTTIdErrorsToken_, EcalScDetId::ix(), EcalScDetId::iy(), dqmiolumiharvest::j, eostools::move(), edm::EDCollection< T >::push_back(), scDetIdCollection_, edm::EDCollection< T >::size(), EcalSrFlag::SRF_FORCED_MASK, EcalSrFlag::SRF_FULL, EcalElectronicsId::subdet(), submitPVValidationJobs::t, EBDetId::tower(), EcalTrigTowerConstituentsMap::towerOf(), ttDetIdCollection_, ecaldqm::ttId(), ttMap_, EEDetId::validDetId(), trackerHitRTTI::vector, and EcalScDetId::zside().

                                                                                   {
   std::vector<edm::Handle<EBDetIdCollection>> ebDetIdColls;
   std::vector<edm::Handle<EEDetIdCollection>> eeDetIdColls;
   std::vector<edm::Handle<EcalElectronicsIdCollection>> ttColls;
 
   auto ebDetIdToRecover = std::make_unique<std::set<EBDetId>>();               // isolated channels to be recovered
   auto eeDetIdToRecover = std::make_unique<std::set<EEDetId>>();               // isolated channels to be recovered
   auto ebTTDetIdToRecover = std::make_unique<std::set<EcalTrigTowerDetId>>();  // tt to be recovered
   auto eeSCDetIdToRecover = std::make_unique<std::set<EcalScDetId>>();         // sc to be recovered
 
   /*
          * get collections
          */
 
   // Selective Readout Flags
   edm::Handle<EBSrFlagCollection> ebSrFlags;
   ev.getByToken(ebSrFlagToken_, ebSrFlags);
 
   edm::Handle<EESrFlagCollection> eeSrFlags;
   ev.getByToken(eeSrFlagToken_, eeSrFlags);
 
   // Integrity errors
   edm::Handle<EBDetIdCollection> ebIntegrityGainErrors;
   ev.getByToken(ebIntegrityGainErrorsToken_, ebIntegrityGainErrors);
 
   ebDetIdColls.push_back(ebIntegrityGainErrors);
 
   edm::Handle<EBDetIdCollection> ebIntegrityGainSwitchErrors;
   ev.getByToken(ebIntegrityGainSwitchErrorsToken_, ebIntegrityGainSwitchErrors);
   ebDetIdColls.push_back(ebIntegrityGainSwitchErrors);
 
   edm::Handle<EBDetIdCollection> ebIntegrityChIdErrors;
   ev.getByToken(ebIntegrityChIdErrorsToken_, ebIntegrityChIdErrors);
   ebDetIdColls.push_back(ebIntegrityChIdErrors);
 
   edm::Handle<EEDetIdCollection> eeIntegrityGainErrors;
   ev.getByToken(eeIntegrityGainErrorsToken_, eeIntegrityGainErrors);
   eeDetIdColls.push_back(eeIntegrityGainErrors);
 
   edm::Handle<EEDetIdCollection> eeIntegrityGainSwitchErrors;
   ev.getByToken(eeIntegrityGainSwitchErrorsToken_, eeIntegrityGainSwitchErrors);
   eeDetIdColls.push_back(eeIntegrityGainSwitchErrors);
 
   edm::Handle<EEDetIdCollection> eeIntegrityChIdErrors;
   ev.getByToken(eeIntegrityChIdErrorsToken_, eeIntegrityChIdErrors);
   eeDetIdColls.push_back(eeIntegrityChIdErrors);
 
   edm::Handle<EcalElectronicsIdCollection> integrityTTIdErrors;
   ev.getByToken(integrityTTIdErrorsToken_, integrityTTIdErrors);
   ttColls.push_back(integrityTTIdErrors);
 
   edm::Handle<EcalElectronicsIdCollection> integrityBlockSizeErrors;
   ev.getByToken(integrityBlockSizeErrorsToken_, integrityBlockSizeErrors);
   ttColls.push_back(integrityBlockSizeErrors);
 
   /*
          *  get regions of interest from SRP
          */
   // -- Barrel
   EBDetIdCollection ebSrpDetId;
   EcalTrigTowerDetIdCollection ebSrpTTDetId;
   for (EBSrFlagCollection::const_iterator it = ebSrFlags->begin(); it != ebSrFlags->end(); ++it) {
     const int flag = it->value();
     if (flag == EcalSrFlag::SRF_FULL || (flag == EcalSrFlag::SRF_FORCED_MASK)) {
       const EcalTrigTowerDetId ttId = it->id();
       ebSrpTTDetId.push_back(ttId);
 
       const std::vector<DetId> vid = ttMap_->constituentsOf(ttId);
 
       for (std::vector<DetId>::const_iterator itId = vid.begin(); itId != vid.end(); ++itId) {
         ebSrpDetId.push_back(*itId);
       }
     }
   }
   // -- Endcap
   EEDetIdCollection eeSrpDetId;
   //EcalTrigTowerDetIdCollection eeSrpTTDetId;
   for (EESrFlagCollection::const_iterator it = eeSrFlags->begin(); it != eeSrFlags->end(); ++it) {
     const int flag = it->value();
     if (flag == EcalSrFlag::SRF_FULL || (flag == EcalSrFlag::SRF_FORCED_MASK)) {
       //EcalTrigTowerDetId ttId = it->id();
       //eeSrpTTDetId.push_back( ttId );
       const EcalScDetId scId(it->id());
       // not clear how to get the vector of DetId constituents of a SC...
       //std::vector<DetId> vid = ecalMapping_->dccTowerConstituents( eId.dccId(), eId.towerId() );
       std::vector<DetId> vid;
       for (int dx = 1; dx <= 5; ++dx) {
         for (int dy = 1; dy <= 5; ++dy) {
           const int ix = (scId.ix() - 1) * 5 + dx;
           const int iy = (scId.iy() - 1) * 5 + dy;
           const int iz = scId.zside();
           if (EEDetId::validDetId(ix, iy, iz)) {
             vid.push_back(EEDetId(ix, iy, iz));
           }
         }
       }
       //std::vector<DetId> vid = ttMap_->constituentsOf( ttId );
       for (std::vector<DetId>::const_iterator itId = vid.begin(); itId != vid.end(); ++itId) {
         eeSrpDetId.push_back(*itId);
       }
     }
   }
   // SRP switched off: get the list from the DB
   if (ebSrFlags->empty()) {
   }
   // SRP switched off: get the list from the DB
   if (eeSrFlags->empty()) {
   }
 
   /*
          *  get OR of integrity error collections
          *  in interesting regions flagged by SRP
          *  and insert them in the list of DetId to recover
          */
   // -- Barrel
   for (std::vector<edm::Handle<EBDetIdCollection>>::const_iterator it = ebDetIdColls.begin(); it != ebDetIdColls.end();
        ++it) {
     const EBDetIdCollection* idc = it->product();
     for (EBDetIdCollection::const_iterator jt = idc->begin(); jt != idc->end(); ++jt)
       if (include(ebSrpDetId, *jt))
         ebDetIdToRecover->insert(*jt);
   }
   // -- Endcap
   for (std::vector<edm::Handle<EEDetIdCollection>>::const_iterator it = eeDetIdColls.begin(); it != eeDetIdColls.end();
        ++it) {
     const EEDetIdCollection* idc = it->product();
     for (EEDetIdCollection::const_iterator jt = idc->begin(); jt != idc->end(); ++jt)
       if (include(eeSrpDetId, *jt))
         eeDetIdToRecover->insert(*jt);
   }
 
   /* 
          * find isolated dead channels (from DB info)           --> chStatus 10, 11, 12
          * and group of dead channels w/ trigger(from DB info)  --> chStatus 13
          * in interesting regions flagged by SRP
          */
   // -- Barrel
   for (EBDetIdCollection::const_iterator itId = ebSrpDetId.begin(); itId != ebSrpDetId.end(); ++itId) {
     EcalChannelStatusMap::const_iterator chit = chStatus_->find(*itId);
     if (chit != chStatus_->end()) {
       const int flag = (*chit).getStatusCode();
       if (flag >= 10 && flag <= 12) {  // FIXME -- avoid hardcoded values...
         ebDetIdToRecover->insert(*itId);
       } else if (flag == 13 || flag == 14) {  // FIXME -- avoid hardcoded values...
         ebTTDetIdToRecover->insert((*itId).tower());
       }
     } else {
       edm::LogError("EcalDetIdToBeRecoveredProducer") << "No channel status found for xtal " << (*itId).rawId()
                                                       << "! something wrong with EcalChannelStatus in your DB? ";
     }
   }
   // -- Endcap
   for (EEDetIdCollection::const_iterator itId = eeSrpDetId.begin(); itId != eeSrpDetId.end(); ++itId) {
     EcalChannelStatusMap::const_iterator chit = chStatus_->find(*itId);
     if (chit != chStatus_->end()) {
       int flag = (*chit).getStatusCode();
       if (flag >= 10 && flag <= 12) {  // FIXME -- avoid hardcoded values...
         eeDetIdToRecover->insert(*itId);
       } else if (flag == 13 || flag == 14) {  // FIXME -- avoid hardcoded values...
         eeSCDetIdToRecover->insert(
             EcalScDetId(1 + ((*itId).ix() - 1) / 5, 1 + ((*itId).iy() - 1) / 5, (*itId).zside()));
       }
     } else {
       edm::LogError("EcalDetIdToBeRecoveredProducer") << "No channel status found for xtal " << (*itId).rawId()
                                                       << "! something wrong with EcalChannelStatus in your DB? ";
     }
   }
 
   // loop over electronics id associated with TT and SC
   for (size_t t = 0; t < ttColls.size(); ++t) {
     const EcalElectronicsIdCollection& coll = *(ttColls[t]);
 
     for (size_t i = 0; i < coll.size(); ++i) {
       const EcalElectronicsId elId = coll[i];
       const EcalSubdetector subdet = elId.subdet();
       const DetId detId = ecalMapping_->getDetId(elId);
 
       if (subdet == EcalBarrel) {  // elId pointing to TT
         // get list of crystals corresponding to TT
         const EcalTrigTowerDetId ttId(ttMap_->towerOf(detId));
         const std::vector<DetId>& vid = ttMap_->constituentsOf(ttId);
 
         for (size_t j = 0; j < vid.size(); ++j) {
           const EBDetId ebdi(vid[j]);
           if (include(ebSrpDetId, ebdi)) {
             ebDetIdToRecover->insert(ebdi);
             ebTTDetIdToRecover->insert(ebdi.tower());
           }
         }
       } else if (subdet == EcalEndcap) {  // elId pointing to SC
         // extract list of crystals corresponding to SC
         const EcalScDetId scId(detId);
         std::vector<DetId> vid;
         for (int dx = 1; dx <= 5; ++dx) {
           for (int dy = 1; dy <= 5; ++dy) {
             const int ix = (scId.ix() - 1) * 5 + dx;
             const int iy = (scId.iy() - 1) * 5 + dy;
             const int iz = scId.zside();
             if (EEDetId::validDetId(ix, iy, iz))
               vid.push_back(EEDetId(ix, iy, iz));
           }
         }
 
         for (size_t j = 0; j < vid.size(); ++j) {
           const EEDetId eedi(vid[i]);
           if (include(eeSrpDetId, eedi)) {
             eeDetIdToRecover->insert(eedi);
             eeSCDetIdToRecover->insert(EcalScDetId(eedi));
           }
         }
       } else
         edm::LogWarning("EcalDetIdToBeRecoveredProducer")
             << "Incorrect EcalSubdetector = " << subdet << " in EcalElectronicsIdCollection collection ";
     }
   }
 
   // return the collections
   ev.put(std::move(ebDetIdToRecover), ebDetIdCollection_);
   ev.put(std::move(eeDetIdToRecover), eeDetIdCollection_);
   ev.put(std::move(ebTTDetIdToRecover), ttDetIdCollection_);
   ev.put(std::move(eeSCDetIdToRecover), scDetIdCollection_);
 }