Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:25:42 

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