#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

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

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_

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

$Id: $Date: $Revision:

Author: Federico Ferri, CEA-Saclay IRFU/SPP

Definition at line 29 of file EcalDetIdToBeRecoveredProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 23 of file EcalDetIdToBeRecoveredProducer.cc.

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

                                                                                         {
   // 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 ( )

override

Definition at line 58 of file EcalDetIdToBeRecoveredProducer.cc.

58 {}

Member Function Documentation

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

final

Definition at line 60 of file EcalDetIdToBeRecoveredProducer.cc.

References chStatus_, ecalMapping_, edm::EventSetup::get(), edm::ESHandle< T >::product(), and ttMap_.

                                                                                         {
   edm::ESHandle<EcalElectronicsMapping> pEcalMapping;
   es.get<EcalMappingRcd>().get(pEcalMapping);
   ecalMapping_ = pEcalMapping.product();
 
   edm::ESHandle<EcalChannelStatusMap> pChStatus;
   es.get<EcalChannelStatusRcd>().get(pChStatus);
   chStatus_ = pChStatus.product();
 
   es.get<IdealGeometryRecord>().get(ttMap_);
 }

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

static

Definition at line 304 of file EcalDetIdToBeRecoveredProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), DEFINE_FWK_MODULE, HLT_2018_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);
 }

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

final

Definition at line 79 of file EcalDetIdToBeRecoveredProducer.cc.

References edm::EDCollection< T >::begin(), edm::SortedCollection< T, SORT >::begin(), chStatus_, coll, EcalTrigTowerConstituentsMap::constituentsOf(), PVValHelper::dx, PVValHelper::dy, ebDetIdCollection_, HLT_2018_cff::ebIntegrityChIdErrors, ebIntegrityChIdErrorsToken_, HLT_2018_cff::ebIntegrityGainErrors, ebIntegrityGainErrorsToken_, HLT_2018_cff::ebIntegrityGainSwitchErrors, ebIntegrityGainSwitchErrorsToken_, ebSrFlagToken_, EcalBarrel, EcalEndcap, ecalMapping_, eeDetIdCollection_, HLT_2018_cff::eeIntegrityChIdErrors, eeIntegrityChIdErrorsToken_, HLT_2018_cff::eeIntegrityGainErrors, eeIntegrityGainErrorsToken_, HLT_2018_cff::eeIntegrityGainSwitchErrors, eeIntegrityGainSwitchErrorsToken_, eeSrFlagToken_, edm::SortedCollection< T, SORT >::empty(), edm::EDCollection< T >::end(), EcalCondObjectContainer< T >::end(), edm::SortedCollection< T, SORT >::end(), EcalCondObjectContainer< T >::find(), RemoveAddSevLevel::flag, edm::Event::getByToken(), EcalElectronicsMapping::getDetId(), mps_fire::i, include(), HLT_2018_cff::integrityBlockSizeErrors, integrityBlockSizeErrorsToken_, HLT_2018_cff::integrityTTIdErrors, integrityTTIdErrorsToken_, EcalScDetId::ix(), EcalScDetId::iy(), dqmiolumiharvest::j, eostools::move(), edm::EDCollection< T >::push_back(), edm::Event::put(), scDetIdCollection_, edm::EDCollection< T >::size(), EcalSrFlag::SRF_FORCED_MASK, EcalSrFlag::SRF_FULL, EcalElectronicsId::subdet(), OrderedSet::t, EBDetId::tower(), EcalTrigTowerConstituentsMap::towerOf(), ttDetIdCollection_, ecaldqm::ttId(), ttMap_, EEDetId::validDetId(), 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_);
 }