File indexing completed on 2021-02-14 14:24:21
0001 #include "RecoLocalCalo/EcalRecProducers/plugins/EcalDetIdToBeRecoveredProducer.h"
0002
0003 #include "DataFormats/Common/interface/Handle.h"
0004 #include "FWCore/Framework/interface/ESHandle.h"
0005
0006 #include "DataFormats/EcalDetId/interface/EcalDetIdCollections.h"
0007
0008 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0009 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0010 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0011
0012 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
0013
0014 #include <set>
0015
0016 #include <sys/types.h>
0017 #include <csignal>
0018
0019 EcalDetIdToBeRecoveredProducer::EcalDetIdToBeRecoveredProducer(const edm::ParameterSet& ps) {
0020 ecalMappingToken_ = esConsumes<EcalElectronicsMapping, EcalMappingRcd, edm::Transition::BeginRun>();
0021 channelStatusToken_ = esConsumes<EcalChannelStatusMap, EcalChannelStatusRcd, edm::Transition::BeginRun>();
0022 ttMapToken_ = esConsumes<EcalTrigTowerConstituentsMap, IdealGeometryRecord, edm::Transition::BeginRun>();
0023
0024 ebSrFlagToken_ = consumes<EBSrFlagCollection>(ps.getParameter<edm::InputTag>("ebSrFlagCollection"));
0025 eeSrFlagToken_ = consumes<EESrFlagCollection>(ps.getParameter<edm::InputTag>("eeSrFlagCollection"));
0026
0027
0028 ebIntegrityGainErrorsToken_ = consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityGainErrors"));
0029 ebIntegrityGainSwitchErrorsToken_ =
0030 consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityGainSwitchErrors"));
0031 ebIntegrityChIdErrorsToken_ = consumes<EBDetIdCollection>(ps.getParameter<edm::InputTag>("ebIntegrityChIdErrors"));
0032
0033
0034 eeIntegrityGainErrorsToken_ = consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityGainErrors"));
0035 eeIntegrityGainSwitchErrorsToken_ =
0036 consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityGainSwitchErrors"));
0037 eeIntegrityChIdErrorsToken_ = consumes<EEDetIdCollection>(ps.getParameter<edm::InputTag>("eeIntegrityChIdErrors"));
0038
0039
0040 integrityTTIdErrorsToken_ =
0041 consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityTTIdErrors"));
0042 integrityBlockSizeErrorsToken_ =
0043 consumes<EcalElectronicsIdCollection>(ps.getParameter<edm::InputTag>("integrityBlockSizeErrors"));
0044
0045
0046 ebDetIdCollection_ = ps.getParameter<std::string>("ebDetIdToBeRecovered");
0047 eeDetIdCollection_ = ps.getParameter<std::string>("eeDetIdToBeRecovered");
0048 ttDetIdCollection_ = ps.getParameter<std::string>("ebFEToBeRecovered");
0049 scDetIdCollection_ = ps.getParameter<std::string>("eeFEToBeRecovered");
0050
0051 produces<std::set<EBDetId>>(ebDetIdCollection_);
0052 produces<std::set<EEDetId>>(eeDetIdCollection_);
0053 produces<std::set<EcalTrigTowerDetId>>(ttDetIdCollection_);
0054 produces<std::set<EcalScDetId>>(scDetIdCollection_);
0055 }
0056
0057 EcalDetIdToBeRecoveredProducer::~EcalDetIdToBeRecoveredProducer() {}
0058
0059 void EcalDetIdToBeRecoveredProducer::beginRun(edm::Run const& run, const edm::EventSetup& es) {
0060 edm::ESHandle<EcalElectronicsMapping> pEcalMapping = es.getHandle(ecalMappingToken_);
0061 ecalMapping_ = pEcalMapping.product();
0062
0063 edm::ESHandle<EcalChannelStatusMap> pChStatus = es.getHandle(channelStatusToken_);
0064 chStatus_ = pChStatus.product();
0065
0066 ttMap_ = es.getHandle(ttMapToken_);
0067 }
0068
0069
0070 template <typename CollT, typename ItemT>
0071 bool include(const CollT& coll, const ItemT& item) {
0072 typename CollT::const_iterator res = std::find(coll.begin(), coll.end(), item);
0073 return (res != coll.end());
0074 }
0075
0076 void EcalDetIdToBeRecoveredProducer::produce(edm::Event& ev, const edm::EventSetup& es) {
0077 std::vector<edm::Handle<EBDetIdCollection>> ebDetIdColls;
0078 std::vector<edm::Handle<EEDetIdCollection>> eeDetIdColls;
0079 std::vector<edm::Handle<EcalElectronicsIdCollection>> ttColls;
0080
0081 auto ebDetIdToRecover = std::make_unique<std::set<EBDetId>>();
0082 auto eeDetIdToRecover = std::make_unique<std::set<EEDetId>>();
0083 auto ebTTDetIdToRecover = std::make_unique<std::set<EcalTrigTowerDetId>>();
0084 auto eeSCDetIdToRecover = std::make_unique<std::set<EcalScDetId>>();
0085
0086
0087
0088
0089
0090
0091 edm::Handle<EBSrFlagCollection> ebSrFlags;
0092 ev.getByToken(ebSrFlagToken_, ebSrFlags);
0093
0094 edm::Handle<EESrFlagCollection> eeSrFlags;
0095 ev.getByToken(eeSrFlagToken_, eeSrFlags);
0096
0097
0098 edm::Handle<EBDetIdCollection> ebIntegrityGainErrors;
0099 ev.getByToken(ebIntegrityGainErrorsToken_, ebIntegrityGainErrors);
0100
0101 ebDetIdColls.push_back(ebIntegrityGainErrors);
0102
0103 edm::Handle<EBDetIdCollection> ebIntegrityGainSwitchErrors;
0104 ev.getByToken(ebIntegrityGainSwitchErrorsToken_, ebIntegrityGainSwitchErrors);
0105 ebDetIdColls.push_back(ebIntegrityGainSwitchErrors);
0106
0107 edm::Handle<EBDetIdCollection> ebIntegrityChIdErrors;
0108 ev.getByToken(ebIntegrityChIdErrorsToken_, ebIntegrityChIdErrors);
0109 ebDetIdColls.push_back(ebIntegrityChIdErrors);
0110
0111 edm::Handle<EEDetIdCollection> eeIntegrityGainErrors;
0112 ev.getByToken(eeIntegrityGainErrorsToken_, eeIntegrityGainErrors);
0113 eeDetIdColls.push_back(eeIntegrityGainErrors);
0114
0115 edm::Handle<EEDetIdCollection> eeIntegrityGainSwitchErrors;
0116 ev.getByToken(eeIntegrityGainSwitchErrorsToken_, eeIntegrityGainSwitchErrors);
0117 eeDetIdColls.push_back(eeIntegrityGainSwitchErrors);
0118
0119 edm::Handle<EEDetIdCollection> eeIntegrityChIdErrors;
0120 ev.getByToken(eeIntegrityChIdErrorsToken_, eeIntegrityChIdErrors);
0121 eeDetIdColls.push_back(eeIntegrityChIdErrors);
0122
0123 edm::Handle<EcalElectronicsIdCollection> integrityTTIdErrors;
0124 ev.getByToken(integrityTTIdErrorsToken_, integrityTTIdErrors);
0125 ttColls.push_back(integrityTTIdErrors);
0126
0127 edm::Handle<EcalElectronicsIdCollection> integrityBlockSizeErrors;
0128 ev.getByToken(integrityBlockSizeErrorsToken_, integrityBlockSizeErrors);
0129 ttColls.push_back(integrityBlockSizeErrors);
0130
0131
0132
0133
0134
0135 EBDetIdCollection ebSrpDetId;
0136 EcalTrigTowerDetIdCollection ebSrpTTDetId;
0137 for (EBSrFlagCollection::const_iterator it = ebSrFlags->begin(); it != ebSrFlags->end(); ++it) {
0138 const int flag = it->value();
0139 if (flag == EcalSrFlag::SRF_FULL || (flag == EcalSrFlag::SRF_FORCED_MASK)) {
0140 const EcalTrigTowerDetId ttId = it->id();
0141 ebSrpTTDetId.push_back(ttId);
0142
0143 const std::vector<DetId> vid = ttMap_->constituentsOf(ttId);
0144
0145 for (std::vector<DetId>::const_iterator itId = vid.begin(); itId != vid.end(); ++itId) {
0146 ebSrpDetId.push_back(*itId);
0147 }
0148 }
0149 }
0150
0151 EEDetIdCollection eeSrpDetId;
0152
0153 for (EESrFlagCollection::const_iterator it = eeSrFlags->begin(); it != eeSrFlags->end(); ++it) {
0154 const int flag = it->value();
0155 if (flag == EcalSrFlag::SRF_FULL || (flag == EcalSrFlag::SRF_FORCED_MASK)) {
0156
0157
0158 const EcalScDetId scId(it->id());
0159
0160
0161
0162 std::vector<DetId> vid;
0163 for (int dx = 1; dx <= 5; ++dx) {
0164 for (int dy = 1; dy <= 5; ++dy) {
0165 const int ix = (scId.ix() - 1) * 5 + dx;
0166 const int iy = (scId.iy() - 1) * 5 + dy;
0167 const int iz = scId.zside();
0168 if (EEDetId::validDetId(ix, iy, iz)) {
0169 vid.push_back(EEDetId(ix, iy, iz));
0170 }
0171 }
0172 }
0173
0174
0175 for (std::vector<DetId>::const_iterator itId = vid.begin(); itId != vid.end(); ++itId) {
0176 eeSrpDetId.push_back(*itId);
0177 }
0178 }
0179 }
0180
0181 if (ebSrFlags->empty()) {
0182 }
0183
0184 if (eeSrFlags->empty()) {
0185 }
0186
0187
0188
0189
0190
0191
0192
0193 for (std::vector<edm::Handle<EBDetIdCollection>>::const_iterator it = ebDetIdColls.begin(); it != ebDetIdColls.end();
0194 ++it) {
0195 const EBDetIdCollection* idc = it->product();
0196 for (EBDetIdCollection::const_iterator jt = idc->begin(); jt != idc->end(); ++jt)
0197 if (include(ebSrpDetId, *jt))
0198 ebDetIdToRecover->insert(*jt);
0199 }
0200
0201 for (std::vector<edm::Handle<EEDetIdCollection>>::const_iterator it = eeDetIdColls.begin(); it != eeDetIdColls.end();
0202 ++it) {
0203 const EEDetIdCollection* idc = it->product();
0204 for (EEDetIdCollection::const_iterator jt = idc->begin(); jt != idc->end(); ++jt)
0205 if (include(eeSrpDetId, *jt))
0206 eeDetIdToRecover->insert(*jt);
0207 }
0208
0209
0210
0211
0212
0213
0214
0215 for (EBDetIdCollection::const_iterator itId = ebSrpDetId.begin(); itId != ebSrpDetId.end(); ++itId) {
0216 EcalChannelStatusMap::const_iterator chit = chStatus_->find(*itId);
0217 if (chit != chStatus_->end()) {
0218 const int flag = (*chit).getStatusCode();
0219 if (flag >= 10 && flag <= 12) {
0220 ebDetIdToRecover->insert(*itId);
0221 } else if (flag == 13 || flag == 14) {
0222 ebTTDetIdToRecover->insert((*itId).tower());
0223 }
0224 } else {
0225 edm::LogError("EcalDetIdToBeRecoveredProducer") << "No channel status found for xtal " << (*itId).rawId()
0226 << "! something wrong with EcalChannelStatus in your DB? ";
0227 }
0228 }
0229
0230 for (EEDetIdCollection::const_iterator itId = eeSrpDetId.begin(); itId != eeSrpDetId.end(); ++itId) {
0231 EcalChannelStatusMap::const_iterator chit = chStatus_->find(*itId);
0232 if (chit != chStatus_->end()) {
0233 int flag = (*chit).getStatusCode();
0234 if (flag >= 10 && flag <= 12) {
0235 eeDetIdToRecover->insert(*itId);
0236 } else if (flag == 13 || flag == 14) {
0237 eeSCDetIdToRecover->insert(
0238 EcalScDetId(1 + ((*itId).ix() - 1) / 5, 1 + ((*itId).iy() - 1) / 5, (*itId).zside()));
0239 }
0240 } else {
0241 edm::LogError("EcalDetIdToBeRecoveredProducer") << "No channel status found for xtal " << (*itId).rawId()
0242 << "! something wrong with EcalChannelStatus in your DB? ";
0243 }
0244 }
0245
0246
0247 for (size_t t = 0; t < ttColls.size(); ++t) {
0248 const EcalElectronicsIdCollection& coll = *(ttColls[t]);
0249
0250 for (size_t i = 0; i < coll.size(); ++i) {
0251 const EcalElectronicsId elId = coll[i];
0252 const EcalSubdetector subdet = elId.subdet();
0253 const DetId detId = ecalMapping_->getDetId(elId);
0254
0255 if (subdet == EcalBarrel) {
0256
0257 const EcalTrigTowerDetId ttId(ttMap_->towerOf(detId));
0258 const std::vector<DetId>& vid = ttMap_->constituentsOf(ttId);
0259
0260 for (size_t j = 0; j < vid.size(); ++j) {
0261 const EBDetId ebdi(vid[j]);
0262 if (include(ebSrpDetId, ebdi)) {
0263 ebDetIdToRecover->insert(ebdi);
0264 ebTTDetIdToRecover->insert(ebdi.tower());
0265 }
0266 }
0267 } else if (subdet == EcalEndcap) {
0268
0269 const EcalScDetId scId(detId);
0270 std::vector<DetId> vid;
0271 for (int dx = 1; dx <= 5; ++dx) {
0272 for (int dy = 1; dy <= 5; ++dy) {
0273 const int ix = (scId.ix() - 1) * 5 + dx;
0274 const int iy = (scId.iy() - 1) * 5 + dy;
0275 const int iz = scId.zside();
0276 if (EEDetId::validDetId(ix, iy, iz))
0277 vid.push_back(EEDetId(ix, iy, iz));
0278 }
0279 }
0280
0281 for (size_t j = 0; j < vid.size(); ++j) {
0282 const EEDetId eedi(vid[i]);
0283 if (include(eeSrpDetId, eedi)) {
0284 eeDetIdToRecover->insert(eedi);
0285 eeSCDetIdToRecover->insert(EcalScDetId(eedi));
0286 }
0287 }
0288 } else
0289 edm::LogWarning("EcalDetIdToBeRecoveredProducer")
0290 << "Incorrect EcalSubdetector = " << subdet << " in EcalElectronicsIdCollection collection ";
0291 }
0292 }
0293
0294
0295 ev.put(std::move(ebDetIdToRecover), ebDetIdCollection_);
0296 ev.put(std::move(eeDetIdToRecover), eeDetIdCollection_);
0297 ev.put(std::move(ebTTDetIdToRecover), ttDetIdCollection_);
0298 ev.put(std::move(eeSCDetIdToRecover), scDetIdCollection_);
0299 }
0300
0301 void EcalDetIdToBeRecoveredProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0302 edm::ParameterSetDescription desc;
0303 desc.add<edm::InputTag>("ebIntegrityChIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityChIdErrors"));
0304 desc.add<std::string>("ebDetIdToBeRecovered", "ebDetId");
0305 desc.add<edm::InputTag>("integrityTTIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityTTIdErrors"));
0306 desc.add<edm::InputTag>("eeIntegrityGainErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainErrors"));
0307 desc.add<std::string>("ebFEToBeRecovered", "ebFE");
0308 desc.add<edm::InputTag>("ebIntegrityGainErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainErrors"));
0309 desc.add<std::string>("eeDetIdToBeRecovered", "eeDetId");
0310 desc.add<edm::InputTag>("eeIntegrityGainSwitchErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainSwitchErrors"));
0311 desc.add<edm::InputTag>("eeIntegrityChIdErrors", edm::InputTag("ecalDigis", "EcalIntegrityChIdErrors"));
0312 desc.add<edm::InputTag>("ebIntegrityGainSwitchErrors", edm::InputTag("ecalDigis", "EcalIntegrityGainSwitchErrors"));
0313 desc.add<edm::InputTag>("ebSrFlagCollection", edm::InputTag("ecalDigis"));
0314 desc.add<std::string>("eeFEToBeRecovered", "eeFE");
0315 desc.add<edm::InputTag>("integrityBlockSizeErrors", edm::InputTag("ecalDigis", "EcalIntegrityBlockSizeErrors"));
0316 desc.add<edm::InputTag>("eeSrFlagCollection", edm::InputTag("ecalDigis"));
0317 descriptions.add("ecalDetIdToBeRecovered", desc);
0318 }
0319
0320 #include "FWCore/Framework/interface/MakerMacros.h"
0321 DEFINE_FWK_MODULE(EcalDetIdToBeRecoveredProducer);