Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-03-17 11:18:43 

0001 /** \class EcalDetIdToBeRecoveredProducer
0002  *   produce ECAL rechits from uncalibrated rechits
0003  *
0004  *  $Id:
0005  *  $Date:
0006  *  $Revision:
0007  *  \author Federico Ferri, CEA-Saclay IRFU/SPP
0008  *
0009  **/
0010 
0011 #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
0012 #include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"
0013 #include "DataFormats/Common/interface/Handle.h"
0014 #include "DataFormats/EcalDetId/interface/EcalDetIdCollections.h"
0015 #include "DataFormats/EcalDigi/interface/EBSrFlag.h"
0016 #include "DataFormats/EcalDigi/interface/EESrFlag.h"
0017 #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
0018 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
0019 #include "FWCore/Framework/interface/ESHandle.h"
0020 #include "FWCore/Framework/interface/Event.h"
0021 #include "FWCore/Framework/interface/EventSetup.h"
0022 #include "FWCore/Framework/interface/stream/EDProducer.h"
0023 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0024 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0025 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0026 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0027 #include "FWCore/Utilities/interface/ESGetToken.h"
0028 #include "Geometry/CaloTopology/interface/EcalTrigTowerConstituentsMap.h"
0029 #include "Geometry/EcalMapping/interface/EcalElectronicsMapping.h"
0030 #include "Geometry/EcalMapping/interface/EcalMappingRcd.h"
0031 #include "Geometry/Records/interface/IdealGeometryRecord.h"
0032 
0033 #include <csignal>
0034 #include <set>
0035 #include <sys/types.h>
0036 
0037 class EcalDetIdToBeRecoveredProducer : public edm::stream::EDProducer<> {
0038 public:
0039   explicit EcalDetIdToBeRecoveredProducer(const edm::ParameterSet& ps);
0040   void produce(edm::Event& evt, const edm::EventSetup& es) final;
0041   void beginRun(edm::Run const& run, const edm::EventSetup& es) final;
0042   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0043 
0044 private:
0045   //edm::InputTag eeUncalibRecHitCollection_; // secondary name given to collection of EE uncalib rechits
0046   //std::string eeRechitCollection_; // secondary name to be given to EE collection of hits
0047 
0048   const EcalChannelStatusMap* chStatus_;
0049   const EcalElectronicsMapping* ecalMapping_;
0050   edm::ESHandle<EcalTrigTowerConstituentsMap> ttMap_;
0051   edm::ESGetToken<EcalElectronicsMapping, EcalMappingRcd> ecalMappingToken_;
0052   edm::ESGetToken<EcalChannelStatusMap, EcalChannelStatusRcd> channelStatusToken_;
0053   edm::ESGetToken<EcalTrigTowerConstituentsMap, IdealGeometryRecord> ttMapToken_;
0054   /*
0055                  * InputTag for collections
0056                  */
0057   // SRP collections
0058   edm::EDGetTokenT<EBSrFlagCollection> ebSrFlagToken_;
0059   edm::EDGetTokenT<EESrFlagCollection> eeSrFlagToken_;
0060 
0061   // Integrity for xtal data
0062   edm::EDGetTokenT<EBDetIdCollection> ebIntegrityGainErrorsToken_;
0063   edm::EDGetTokenT<EBDetIdCollection> ebIntegrityGainSwitchErrorsToken_;
0064   edm::EDGetTokenT<EBDetIdCollection> ebIntegrityChIdErrorsToken_;
0065 
0066   // Integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
0067   edm::EDGetTokenT<EEDetIdCollection> eeIntegrityGainErrorsToken_;
0068   edm::EDGetTokenT<EEDetIdCollection> eeIntegrityGainSwitchErrorsToken_;
0069   edm::EDGetTokenT<EEDetIdCollection> eeIntegrityChIdErrorsToken_;
0070 
0071   // Integrity Errors
0072   edm::EDGetTokenT<EcalElectronicsIdCollection> integrityTTIdErrorsToken_;
0073   edm::EDGetTokenT<EcalElectronicsIdCollection> integrityBlockSizeErrorsToken_;
0074 
0075   /*
0076                  * output collections
0077                  */
0078   std::string ebDetIdCollection_;
0079   std::string eeDetIdCollection_;
0080   std::string ttDetIdCollection_;
0081   std::string scDetIdCollection_;
0082 };
0083 
0084 EcalDetIdToBeRecoveredProducer::EcalDetIdToBeRecoveredProducer(const edm::ParameterSet& ps) {
0085   ecalMappingToken_ = esConsumes<EcalElectronicsMapping, EcalMappingRcd, edm::Transition::BeginRun>();
0086   channelStatusToken_ = esConsumes<EcalChannelStatusMap, EcalChannelStatusRcd, edm::Transition::BeginRun>();
0087   ttMapToken_ = esConsumes<EcalTrigTowerConstituentsMap, IdealGeometryRecord, edm::Transition::BeginRun>();
0088   // SRP collections
0089   ebSrFlagToken_ = consumes<EBSrFlagCollection>(ps.getParameter<edm::InputTag>("ebSrFlagCollection"));
0090   eeSrFlagToken_ = consumes<EESrFlagCollection>(ps.getParameter<edm::InputTag>("eeSrFlagCollection"));
0091 
0092   // Integrity for xtal data
0093   ebIntegrityGainErrorsToken_ = consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityGainErrors"));
0094   ebIntegrityGainSwitchErrorsToken_ =
0095       consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityGainSwitchErrors"));
0096   ebIntegrityChIdErrorsToken_ = consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityChIdErrors"));
0097 
0098   // Integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
0099   eeIntegrityGainErrorsToken_ = consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityGainErrors"));
0100   eeIntegrityGainSwitchErrorsToken_ =
0101       consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityGainSwitchErrors"));
0102   eeIntegrityChIdErrorsToken_ = consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityChIdErrors"));
0103 
0104   // Integrity Errors
0105   integrityTTIdErrorsToken_ =
0106       consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityTTIdErrors"));
0107   integrityBlockSizeErrorsToken_ =
0108       consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityBlockSizeErrors"));
0109 
0110   // output collections
0111   ebDetIdCollection_ = ps.getParameter<std::string>("ebDetIdToBeRecovered");
0112   eeDetIdCollection_ = ps.getParameter<std::string>("eeDetIdToBeRecovered");
0113   ttDetIdCollection_ = ps.getParameter<std::string>("ebFEToBeRecovered");
0114   scDetIdCollection_ = ps.getParameter<std::string>("eeFEToBeRecovered");
0115 
0116   produces<std::set<EBDetId>>(ebDetIdCollection_);
0117   produces<std::set<EEDetId>>(eeDetIdCollection_);
0118   produces<std::set<EcalTrigTowerDetId>>(ttDetIdCollection_);
0119   produces<std::set<EcalScDetId>>(scDetIdCollection_);
0120 }
0121 
0122 void EcalDetIdToBeRecoveredProducer::beginRun(edm::Run const& run, const edm::EventSetup& es) {
0123   edm::ESHandle<EcalElectronicsMapping> pEcalMapping = es.getHandle(ecalMappingToken_);
0124   ecalMapping_ = pEcalMapping.product();
0125 
0126   edm::ESHandle<EcalChannelStatusMap> pChStatus = es.getHandle(channelStatusToken_);
0127   chStatus_ = pChStatus.product();
0128 
0129   ttMap_ = es.getHandle(ttMapToken_);
0130 }
0131 
0132 // fuction return true if "coll" have "item"
0133 template <typename CollT, typename ItemT>
0134 bool include(const CollT& coll, const ItemT& item) {
0135   typename CollT::const_iterator res = std::find(coll.begin(), coll.end(), item);
0136   return (res != coll.end());
0137 }
0138 
0139 void EcalDetIdToBeRecoveredProducer::produce(edm::Event& ev, const edm::EventSetup& es) {
0140   std::vector<edm::Handle<EBDetIdCollection>> ebDetIdColls;
0141   std::vector<edm::Handle<EEDetIdCollection>> eeDetIdColls;
0142   std::vector<edm::Handle<EcalElectronicsIdCollection>> ttColls;
0143 
0144   auto ebDetIdToRecover = std::make_unique<std::set<EBDetId>>();               // isolated channels to be recovered
0145   auto eeDetIdToRecover = std::make_unique<std::set<EEDetId>>();               // isolated channels to be recovered
0146   auto ebTTDetIdToRecover = std::make_unique<std::set<EcalTrigTowerDetId>>();  // tt to be recovered
0147   auto eeSCDetIdToRecover = std::make_unique<std::set<EcalScDetId>>();         // sc to be recovered
0148 
0149   /*
0150          * get collections
0151          */
0152 
0153   // Selective Readout Flags
0154   edm::Handle<EBSrFlagCollection> ebSrFlags;
0155   ev.getByToken(ebSrFlagToken_, ebSrFlags);
0156 
0157   edm::Handle<EESrFlagCollection> eeSrFlags;
0158   ev.getByToken(eeSrFlagToken_, eeSrFlags);
0159 
0160   // Integrity errors
0161   edm::Handle<EBDetIdCollection> ebIntegrityGainErrors;
0162   ev.getByToken(ebIntegrityGainErrorsToken_, ebIntegrityGainErrors);
0163 
0164   ebDetIdColls.push_back(ebIntegrityGainErrors);
0165 
0166   edm::Handle<EBDetIdCollection> ebIntegrityGainSwitchErrors;
0167   ev.getByToken(ebIntegrityGainSwitchErrorsToken_, ebIntegrityGainSwitchErrors);
0168   ebDetIdColls.push_back(ebIntegrityGainSwitchErrors);
0169 
0170   edm::Handle<EBDetIdCollection> ebIntegrityChIdErrors;
0171   ev.getByToken(ebIntegrityChIdErrorsToken_, ebIntegrityChIdErrors);
0172   ebDetIdColls.push_back(ebIntegrityChIdErrors);
0173 
0174   edm::Handle<EEDetIdCollection> eeIntegrityGainErrors;
0175   ev.getByToken(eeIntegrityGainErrorsToken_, eeIntegrityGainErrors);
0176   eeDetIdColls.push_back(eeIntegrityGainErrors);
0177 
0178   edm::Handle<EEDetIdCollection> eeIntegrityGainSwitchErrors;
0179   ev.getByToken(eeIntegrityGainSwitchErrorsToken_, eeIntegrityGainSwitchErrors);
0180   eeDetIdColls.push_back(eeIntegrityGainSwitchErrors);
0181 
0182   edm::Handle<EEDetIdCollection> eeIntegrityChIdErrors;
0183   ev.getByToken(eeIntegrityChIdErrorsToken_, eeIntegrityChIdErrors);
0184   eeDetIdColls.push_back(eeIntegrityChIdErrors);
0185 
0186   edm::Handle<EcalElectronicsIdCollection> integrityTTIdErrors;
0187   ev.getByToken(integrityTTIdErrorsToken_, integrityTTIdErrors);
0188   ttColls.push_back(integrityTTIdErrors);
0189 
0190   edm::Handle<EcalElectronicsIdCollection> integrityBlockSizeErrors;
0191   ev.getByToken(integrityBlockSizeErrorsToken_, integrityBlockSizeErrors);
0192   ttColls.push_back(integrityBlockSizeErrors);
0193 
0194   /*
0195          *  get regions of interest from SRP
0196          */
0197   // -- Barrel
0198   EBDetIdCollection ebSrpDetId;
0199   EcalTrigTowerDetIdCollection ebSrpTTDetId;
0200   for (EBSrFlagCollection::const_iterator it = ebSrFlags->begin(); it != ebSrFlags->end(); ++it) {
0201     const int flag = it->value();
0202     if (flag == EcalSrFlag::SRF_FULL || (flag == EcalSrFlag::SRF_FORCED_MASK)) {
0203       const EcalTrigTowerDetId ttId = it->id();
0204       ebSrpTTDetId.push_back(ttId);
0205 
0206       const std::vector<DetId> vid = ttMap_->constituentsOf(ttId);
0207 
0208       for (std::vector<DetId>::const_iterator itId = vid.begin(); itId != vid.end(); ++itId) {
0209         ebSrpDetId.push_back(*itId);
0210       }
0211     }
0212   }
0213   // -- Endcap
0214   EEDetIdCollection eeSrpDetId;
0215   //EcalTrigTowerDetIdCollection eeSrpTTDetId;
0216   for (EESrFlagCollection::const_iterator it = eeSrFlags->begin(); it != eeSrFlags->end(); ++it) {
0217     const int flag = it->value();
0218     if (flag == EcalSrFlag::SRF_FULL || (flag == EcalSrFlag::SRF_FORCED_MASK)) {
0219       //EcalTrigTowerDetId ttId = it->id();
0220       //eeSrpTTDetId.push_back( ttId );
0221       const EcalScDetId scId(it->id());
0222       // not clear how to get the vector of DetId constituents of a SC...
0223       //////////EcalElectronicsId eId( scId.rawId() );
0224       //std::vector<DetId> vid = ecalMapping_->dccTowerConstituents( eId.dccId(), eId.towerId() );
0225       std::vector<DetId> vid;
0226       for (int dx = 1; dx <= 5; ++dx) {
0227         for (int dy = 1; dy <= 5; ++dy) {
0228           const int ix = (scId.ix() - 1) * 5 + dx;
0229           const int iy = (scId.iy() - 1) * 5 + dy;
0230           const int iz = scId.zside();
0231           if (EEDetId::validDetId(ix, iy, iz)) {
0232             vid.push_back(EEDetId(ix, iy, iz));
0233           }
0234         }
0235       }
0236       ////eeSrpDetId.insert( interestingDetId.end(), vid.begin(), vid.end() );
0237       //std::vector<DetId> vid = ttMap_->constituentsOf( ttId );
0238       for (std::vector<DetId>::const_iterator itId = vid.begin(); itId != vid.end(); ++itId) {
0239         eeSrpDetId.push_back(*itId);
0240       }
0241     }
0242   }
0243   // SRP switched off: get the list from the DB
0244   if (ebSrFlags->empty()) {
0245   }
0246   // SRP switched off: get the list from the DB
0247   if (eeSrFlags->empty()) {
0248   }
0249 
0250   /*
0251          *  get OR of integrity error collections
0252          *  in interesting regions flagged by SRP
0253          *  and insert them in the list of DetId to recover
0254          */
0255   // -- Barrel
0256   for (std::vector<edm::Handle<EBDetIdCollection>>::const_iterator it = ebDetIdColls.begin(); it != ebDetIdColls.end();
0257        ++it) {
0258     const EBDetIdCollection* idc = it->product();
0259     for (EBDetIdCollection::const_iterator jt = idc->begin(); jt != idc->end(); ++jt)
0260       if (include(ebSrpDetId, *jt))
0261         ebDetIdToRecover->insert(*jt);
0262   }
0263   // -- Endcap
0264   for (std::vector<edm::Handle<EEDetIdCollection>>::const_iterator it = eeDetIdColls.begin(); it != eeDetIdColls.end();
0265        ++it) {
0266     const EEDetIdCollection* idc = it->product();
0267     for (EEDetIdCollection::const_iterator jt = idc->begin(); jt != idc->end(); ++jt)
0268       if (include(eeSrpDetId, *jt))
0269         eeDetIdToRecover->insert(*jt);
0270   }
0271 
0272   /* 
0273          * find isolated dead channels (from DB info)           --> chStatus 10, 11, 12
0274          * and group of dead channels w/ trigger(from DB info)  --> chStatus 13
0275          * in interesting regions flagged by SRP
0276          */
0277   // -- Barrel
0278   for (EBDetIdCollection::const_iterator itId = ebSrpDetId.begin(); itId != ebSrpDetId.end(); ++itId) {
0279     EcalChannelStatusMap::const_iterator chit = chStatus_->find(*itId);
0280     if (chit != chStatus_->end()) {
0281       const int flag = (*chit).getStatusCode();
0282       if (flag >= 10 && flag <= 12) {  // FIXME -- avoid hardcoded values...
0283         ebDetIdToRecover->insert(*itId);
0284       } else if (flag == 13 || flag == 14) {  // FIXME -- avoid hardcoded values...
0285         ebTTDetIdToRecover->insert((*itId).tower());
0286       }
0287     } else {
0288       edm::LogError("EcalDetIdToBeRecoveredProducer") << "No channel status found for xtal " << (*itId).rawId()
0289                                                       << "! something wrong with EcalChannelStatus in your DB? ";
0290     }
0291   }
0292   // -- Endcap
0293   for (EEDetIdCollection::const_iterator itId = eeSrpDetId.begin(); itId != eeSrpDetId.end(); ++itId) {
0294     EcalChannelStatusMap::const_iterator chit = chStatus_->find(*itId);
0295     if (chit != chStatus_->end()) {
0296       int flag = (*chit).getStatusCode();
0297       if (flag >= 10 && flag <= 12) {  // FIXME -- avoid hardcoded values...
0298         eeDetIdToRecover->insert(*itId);
0299       } else if (flag == 13 || flag == 14) {  // FIXME -- avoid hardcoded values...
0300         eeSCDetIdToRecover->insert(
0301             EcalScDetId(1 + ((*itId).ix() - 1) / 5, 1 + ((*itId).iy() - 1) / 5, (*itId).zside()));
0302       }
0303     } else {
0304       edm::LogError("EcalDetIdToBeRecoveredProducer") << "No channel status found for xtal " << (*itId).rawId()
0305                                                       << "! something wrong with EcalChannelStatus in your DB? ";
0306     }
0307   }
0308 
0309   // loop over electronics id associated with TT and SC
0310   for (size_t t = 0; t < ttColls.size(); ++t) {
0311     const EcalElectronicsIdCollection& coll = *(ttColls[t]);
0312 
0313     for (size_t i = 0; i < coll.size(); ++i) {
0314       const EcalElectronicsId elId = coll[i];
0315       const EcalSubdetector subdet = elId.subdet();
0316       const DetId detId = ecalMapping_->getDetId(elId);
0317 
0318       if (subdet == EcalBarrel) {  // elId pointing to TT
0319         // get list of crystals corresponding to TT
0320         const EcalTrigTowerDetId ttId(ttMap_->towerOf(detId));
0321         const std::vector<DetId>& vid = ttMap_->constituentsOf(ttId);
0322 
0323         for (size_t j = 0; j < vid.size(); ++j) {
0324           const EBDetId ebdi(vid[j]);
0325           if (include(ebSrpDetId, ebdi)) {
0326             ebDetIdToRecover->insert(ebdi);
0327             ebTTDetIdToRecover->insert(ebdi.tower());
0328           }
0329         }
0330       } else if (subdet == EcalEndcap) {  // elId pointing to SC
0331         // extract list of crystals corresponding to SC
0332         const EcalScDetId scId(detId);
0333         std::vector<DetId> vid;
0334         for (int dx = 1; dx <= 5; ++dx) {
0335           for (int dy = 1; dy <= 5; ++dy) {
0336             const int ix = (scId.ix() - 1) * 5 + dx;
0337             const int iy = (scId.iy() - 1) * 5 + dy;
0338             const int iz = scId.zside();
0339             if (EEDetId::validDetId(ix, iy, iz))
0340               vid.push_back(EEDetId(ix, iy, iz));
0341           }
0342         }
0343 
0344         for (size_t j = 0; j < vid.size(); ++j) {
0345           const EEDetId eedi(vid[i]);
0346           if (include(eeSrpDetId, eedi)) {
0347             eeDetIdToRecover->insert(eedi);
0348             eeSCDetIdToRecover->insert(EcalScDetId(eedi));
0349           }
0350         }
0351       } else
0352         edm::LogWarning("EcalDetIdToBeRecoveredProducer")
0353             << "Incorrect EcalSubdetector = " << subdet << " in EcalElectronicsIdCollection collection ";
0354     }
0355   }
0356 
0357   // return the collections
0358   ev.put(std::move(ebDetIdToRecover), ebDetIdCollection_);
0359   ev.put(std::move(eeDetIdToRecover), eeDetIdCollection_);
0360   ev.put(std::move(ebTTDetIdToRecover), ttDetIdCollection_);
0361   ev.put(std::move(eeSCDetIdToRecover), scDetIdCollection_);
0362 }
0363 
0364 void EcalDetIdToBeRecoveredProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0365   edm::ParameterSetDescription desc;
0366   desc.add<edm::InputTag>("ebIntegrityChIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityChIdErrors"));
0367   desc.add<std::string>("ebDetIdToBeRecovered", "ebDetId");
0368   desc.add<edm::InputTag>("integrityTTIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityTTIdErrors"));
0369   desc.add<edm::InputTag>("eeIntegrityGainErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainErrors"));
0370   desc.add<std::string>("ebFEToBeRecovered", "ebFE");
0371   desc.add<edm::InputTag>("ebIntegrityGainErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainErrors"));
0372   desc.add<std::string>("eeDetIdToBeRecovered", "eeDetId");
0373   desc.add<edm::InputTag>("eeIntegrityGainSwitchErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainSwitchErrors"));
0374   desc.add<edm::InputTag>("eeIntegrityChIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityChIdErrors"));
0375   desc.add<edm::InputTag>("ebIntegrityGainSwitchErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainSwitchErrors"));
0376   desc.add<edm::InputTag>("ebSrFlagCollection", edm::InputTag("ecalDigis"));
0377   desc.add<std::string>("eeFEToBeRecovered", "eeFE");
0378   desc.add<edm::InputTag>("integrityBlockSizeErrors", edm::InputTag("ecalDigis", "EcalIntegrityBlockSizeErrors"));
0379   desc.add<edm::InputTag>("eeSrFlagCollection", edm::InputTag("ecalDigis"));
0380   descriptions.add("ecalDetIdToBeRecovered", desc);
0381 }
0382 
0383 #include "FWCore/Framework/interface/MakerMacros.h"
0384 DEFINE_FWK_MODULE(EcalDetIdToBeRecoveredProducer);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!