File indexing completed on 2024-04-06 12:25:42
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 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0042
0043 private:
0044
0045
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
0055
0056
0057 edm::EDGetTokenT<EBSrFlagCollection> ebSrFlagToken_;
0058 edm::EDGetTokenT<EESrFlagCollection> eeSrFlagToken_;
0059
0060
0061 edm::EDGetTokenT<EBDetIdCollection> ebIntegrityGainErrorsToken_;
0062 edm::EDGetTokenT<EBDetIdCollection> ebIntegrityGainSwitchErrorsToken_;
0063 edm::EDGetTokenT<EBDetIdCollection> ebIntegrityChIdErrorsToken_;
0064
0065
0066 edm::EDGetTokenT<EEDetIdCollection> eeIntegrityGainErrorsToken_;
0067 edm::EDGetTokenT<EEDetIdCollection> eeIntegrityGainSwitchErrorsToken_;
0068 edm::EDGetTokenT<EEDetIdCollection> eeIntegrityChIdErrorsToken_;
0069
0070
0071 edm::EDGetTokenT<EcalElectronicsIdCollection> integrityTTIdErrorsToken_;
0072 edm::EDGetTokenT<EcalElectronicsIdCollection> integrityBlockSizeErrorsToken_;
0073
0074
0075
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
0088 ebSrFlagToken_ = consumes<EBSrFlagCollection>(ps.getParameter<edm::InputTag>("ebSrFlagCollection"));
0089 eeSrFlagToken_ = consumes<EESrFlagCollection>(ps.getParameter<edm::InputTag>("eeSrFlagCollection"));
0090
0091
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
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
0104 integrityTTIdErrorsToken_ =
0105 consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityTTIdErrors"));
0106 integrityBlockSizeErrorsToken_ =
0107 consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityBlockSizeErrors"));
0108
0109
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
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>>();
0138 auto eeDetIdToRecover = std::make_unique<std::set<EEDetId>>();
0139 auto ebTTDetIdToRecover = std::make_unique<std::set<EcalTrigTowerDetId>>();
0140 auto eeSCDetIdToRecover = std::make_unique<std::set<EcalScDetId>>();
0141
0142
0143
0144
0145
0146
0147 edm::Handle<EBSrFlagCollection> ebSrFlags;
0148 ev.getByToken(ebSrFlagToken_, ebSrFlags);
0149
0150 edm::Handle<EESrFlagCollection> eeSrFlags;
0151 ev.getByToken(eeSrFlagToken_, eeSrFlags);
0152
0153
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
0189
0190
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
0207 EEDetIdCollection eeSrpDetId;
0208
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
0213
0214 const EcalScDetId scId(it->id());
0215
0216
0217
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
0230
0231 for (std::vector<DetId>::const_iterator itId = vid.begin(); itId != vid.end(); ++itId) {
0232 eeSrpDetId.push_back(*itId);
0233 }
0234 }
0235 }
0236
0237 if (ebSrFlags->empty()) {
0238 }
0239
0240 if (eeSrFlags->empty()) {
0241 }
0242
0243
0244
0245
0246
0247
0248
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
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
0267
0268
0269
0270
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) {
0276 ebDetIdToRecover->insert(*itId);
0277 } else if (flag == 13 || flag == 14) {
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
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) {
0291 eeDetIdToRecover->insert(*itId);
0292 } else if (flag == 13 || flag == 14) {
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
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) {
0312
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) {
0324
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
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);