File indexing completed on 2023-03-17 11:18:43
0001
0002
0003
0004
0005
0006
0007
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
0046
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
0056
0057
0058 edm::EDGetTokenT<EBSrFlagCollection> ebSrFlagToken_;
0059 edm::EDGetTokenT<EESrFlagCollection> eeSrFlagToken_;
0060
0061
0062 edm::EDGetTokenT<EBDetIdCollection> ebIntegrityGainErrorsToken_;
0063 edm::EDGetTokenT<EBDetIdCollection> ebIntegrityGainSwitchErrorsToken_;
0064 edm::EDGetTokenT<EBDetIdCollection> ebIntegrityChIdErrorsToken_;
0065
0066
0067 edm::EDGetTokenT<EEDetIdCollection> eeIntegrityGainErrorsToken_;
0068 edm::EDGetTokenT<EEDetIdCollection> eeIntegrityGainSwitchErrorsToken_;
0069 edm::EDGetTokenT<EEDetIdCollection> eeIntegrityChIdErrorsToken_;
0070
0071
0072 edm::EDGetTokenT<EcalElectronicsIdCollection> integrityTTIdErrorsToken_;
0073 edm::EDGetTokenT<EcalElectronicsIdCollection> integrityBlockSizeErrorsToken_;
0074
0075
0076
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
0089 ebSrFlagToken_ = consumes<EBSrFlagCollection>(ps.getParameter<edm::InputTag>("ebSrFlagCollection"));
0090 eeSrFlagToken_ = consumes<EESrFlagCollection>(ps.getParameter<edm::InputTag>("eeSrFlagCollection"));
0091
0092
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
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
0105 integrityTTIdErrorsToken_ =
0106 consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityTTIdErrors"));
0107 integrityBlockSizeErrorsToken_ =
0108 consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityBlockSizeErrors"));
0109
0110
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
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>>();
0145 auto eeDetIdToRecover = std::make_unique<std::set<EEDetId>>();
0146 auto ebTTDetIdToRecover = std::make_unique<std::set<EcalTrigTowerDetId>>();
0147 auto eeSCDetIdToRecover = std::make_unique<std::set<EcalScDetId>>();
0148
0149
0150
0151
0152
0153
0154 edm::Handle<EBSrFlagCollection> ebSrFlags;
0155 ev.getByToken(ebSrFlagToken_, ebSrFlags);
0156
0157 edm::Handle<EESrFlagCollection> eeSrFlags;
0158 ev.getByToken(eeSrFlagToken_, eeSrFlags);
0159
0160
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
0196
0197
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
0214 EEDetIdCollection eeSrpDetId;
0215
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
0220
0221 const EcalScDetId scId(it->id());
0222
0223
0224
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
0237
0238 for (std::vector<DetId>::const_iterator itId = vid.begin(); itId != vid.end(); ++itId) {
0239 eeSrpDetId.push_back(*itId);
0240 }
0241 }
0242 }
0243
0244 if (ebSrFlags->empty()) {
0245 }
0246
0247 if (eeSrFlags->empty()) {
0248 }
0249
0250
0251
0252
0253
0254
0255
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
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
0274
0275
0276
0277
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) {
0283 ebDetIdToRecover->insert(*itId);
0284 } else if (flag == 13 || flag == 14) {
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
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) {
0298 eeDetIdToRecover->insert(*itId);
0299 } else if (flag == 13 || flag == 14) {
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
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) {
0319
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) {
0331
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
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);