File indexing completed on 2023-03-17 10:59:53
0001 #include "EventFilter/HcalRawToDigi/plugins/HcalRawToDigi.h"
0002 #include "DataFormats/FEDRawData/interface/FEDNumbering.h"
0003 #include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
0004 #include "DataFormats/HcalDigi/interface/HcalUMNioDigi.h"
0005 #include "FWCore/Framework/interface/ESHandle.h"
0006 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0007 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0008 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0009 #include <iostream>
0010 #include <unordered_set>
0011
0012 HcalRawToDigi::HcalRawToDigi(edm::ParameterSet const& conf)
0013 : unpacker_(conf.getUntrackedParameter<int>("HcalFirstFED", int(FEDNumbering::MINHCALFEDID)),
0014 conf.getParameter<int>("firstSample"),
0015 conf.getParameter<int>("lastSample")),
0016 filter_(
0017 conf.getParameter<bool>("FilterDataQuality"), conf.getParameter<bool>("FilterDataQuality"), false, 0, 0, -1),
0018 fedUnpackList_(conf.getUntrackedParameter<std::vector<int>>("FEDs", std::vector<int>())),
0019 firstFED_(conf.getUntrackedParameter<int>("HcalFirstFED", FEDNumbering::MINHCALFEDID)),
0020 unpackCalib_(conf.getUntrackedParameter<bool>("UnpackCalib", false)),
0021 unpackZDC_(conf.getUntrackedParameter<bool>("UnpackZDC", false)),
0022 unpackTTP_(conf.getUntrackedParameter<bool>("UnpackTTP", false)),
0023 unpackUMNio_(conf.getUntrackedParameter<bool>("UnpackUMNio", false)),
0024 saveQIE10DataNSamples_(conf.getUntrackedParameter<std::vector<int>>("saveQIE10DataNSamples", std::vector<int>())),
0025 saveQIE10DataTags_(
0026 conf.getUntrackedParameter<std::vector<std::string>>("saveQIE10DataTags", std::vector<std::string>())),
0027 saveQIE11DataNSamples_(conf.getUntrackedParameter<std::vector<int>>("saveQIE11DataNSamples", std::vector<int>())),
0028 saveQIE11DataTags_(
0029 conf.getUntrackedParameter<std::vector<std::string>>("saveQIE11DataTags", std::vector<std::string>())),
0030 silent_(conf.getUntrackedParameter<bool>("silent", true)),
0031 complainEmptyData_(conf.getUntrackedParameter<bool>("ComplainEmptyData", false)),
0032 unpackerMode_(conf.getUntrackedParameter<int>("UnpackerMode", 0)),
0033 expectedOrbitMessageTime_(conf.getUntrackedParameter<int>("ExpectedOrbitMessageTime", -1)) {
0034 electronicsMapLabel_ = conf.getParameter<std::string>("ElectronicsMap");
0035 tok_data_ = consumes<FEDRawDataCollection>(conf.getParameter<edm::InputTag>("InputLabel"));
0036 tok_dbService_ = esConsumes<HcalDbService, HcalDbRecord>();
0037 tok_electronicsMap_ =
0038 esConsumes<HcalElectronicsMap, HcalElectronicsMapRcd>(edm::ESInputTag("", electronicsMapLabel_));
0039
0040 if (fedUnpackList_.empty()) {
0041
0042 for (int i = FEDNumbering::MINHCALFEDID; i <= FEDNumbering::MAXHCALFEDID; i++)
0043 fedUnpackList_.push_back(i);
0044
0045
0046 for (int i = FEDNumbering::MINHCALuTCAFEDID; i <= FEDNumbering::MAXHCALuTCAFEDID; i++)
0047 fedUnpackList_.push_back(i);
0048 }
0049
0050 unpacker_.setExpectedOrbitMessageTime(expectedOrbitMessageTime_);
0051 unpacker_.setMode(unpackerMode_);
0052 std::ostringstream ss;
0053 for (unsigned int i = 0; i < fedUnpackList_.size(); i++)
0054 ss << fedUnpackList_[i] << " ";
0055 edm::LogInfo("HCAL") << "HcalRawToDigi will unpack FEDs ( " << ss.str() << ")";
0056
0057
0058 produces<HBHEDigiCollection>();
0059 produces<HFDigiCollection>();
0060 produces<HODigiCollection>();
0061 produces<HcalTrigPrimDigiCollection>();
0062 produces<HOTrigPrimDigiCollection>();
0063 produces<HcalUnpackerReport>();
0064 if (unpackCalib_)
0065 produces<HcalCalibDigiCollection>();
0066 if (unpackZDC_)
0067 produces<ZDCDigiCollection>();
0068 if (unpackTTP_)
0069 produces<HcalTTPDigiCollection>();
0070 if (unpackUMNio_)
0071 produces<HcalUMNioDigi>();
0072 produces<QIE10DigiCollection>();
0073 produces<QIE11DigiCollection>();
0074
0075 produces<QIE10DigiCollection>("ZDC");
0076 produces<QIE10DigiCollection>("LASERMON");
0077
0078
0079
0080 if (std::find(saveQIE10DataTags_.begin(), saveQIE10DataTags_.end(), "ZDC") != saveQIE10DataTags_.end()) {
0081 edm::LogWarning("HcalRawToDigi")
0082 << "Cannot create an additional QIE10 sample with name ZDC, it is already created! It must be removed along "
0083 "with the corresponding entry in saveQIE10DataNSamples"
0084 << std::endl;
0085 saveQIE10DataTags_.clear();
0086 saveQIE10DataNSamples_.clear();
0087 }
0088
0089
0090 if (std::find(saveQIE10DataTags_.begin(), saveQIE10DataTags_.end(), "LASERMON") != saveQIE10DataTags_.end()) {
0091 edm::LogWarning("HcalRawToDigi")
0092 << "Cannot create an additional QIE10 sample with name LASERMON, it is already created! It must be removed "
0093 "along with the corresponding entry in saveQIE10DataNSamples"
0094 << std::endl;
0095 saveQIE10DataTags_.clear();
0096 saveQIE10DataNSamples_.clear();
0097 }
0098
0099
0100
0101
0102 if (saveQIE10DataTags_.size() != saveQIE10DataNSamples_.size()) {
0103 edm::LogWarning("HcalRawToDigi")
0104 << "The saveQIE10DataTags and saveQIE10DataNSamples inputs must be the same length! These will be ignored"
0105 << std::endl;
0106 saveQIE10DataTags_.clear();
0107 saveQIE10DataNSamples_.clear();
0108 }
0109 if (saveQIE11DataTags_.size() != saveQIE11DataNSamples_.size()) {
0110 edm::LogWarning("HcalRawToDigi")
0111 << "The saveQIE11DataTags and saveQIE11DataNSamples inputs must be the same length! These will be ignored"
0112 << std::endl;
0113 saveQIE11DataTags_.clear();
0114 saveQIE11DataNSamples_.clear();
0115 }
0116
0117
0118
0119
0120
0121 for (unsigned idx = 0; idx < saveQIE10DataNSamples_.size(); ++idx) {
0122 int nsamples = saveQIE10DataNSamples_[idx];
0123 std::string tag = saveQIE10DataTags_[idx];
0124
0125 produces<QIE10DigiCollection>(tag);
0126
0127 saveQIE10Info_[nsamples] = tag;
0128 }
0129
0130
0131
0132
0133
0134 for (unsigned idx = 0; idx < saveQIE11DataNSamples_.size(); ++idx) {
0135 int nsamples = saveQIE11DataNSamples_[idx];
0136 std::string tag = saveQIE11DataTags_[idx];
0137
0138 produces<QIE11DigiCollection>(tag);
0139
0140 saveQIE11Info_[nsamples] = tag;
0141 }
0142
0143 memset(&stats_, 0, sizeof(stats_));
0144 }
0145
0146
0147 HcalRawToDigi::~HcalRawToDigi() {}
0148
0149 void HcalRawToDigi::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0150 edm::ParameterSetDescription desc;
0151 desc.addUntracked<int>("HcalFirstFED", int(FEDNumbering::MINHCALFEDID));
0152 desc.add<int>("firstSample", 0);
0153 desc.add<int>("lastSample", 9);
0154 desc.add<bool>("FilterDataQuality", true);
0155 desc.addUntracked<std::vector<int>>("FEDs", std::vector<int>());
0156 desc.addUntracked<bool>("UnpackZDC", true);
0157 desc.addUntracked<bool>("UnpackCalib", true);
0158 desc.addUntracked<bool>("UnpackUMNio", true);
0159 desc.addUntracked<bool>("UnpackTTP", true);
0160 desc.addUntracked<bool>("silent", true);
0161 desc.addUntracked<std::vector<int>>("saveQIE10DataNSamples", std::vector<int>());
0162 desc.addUntracked<std::vector<std::string>>("saveQIE10DataTags", std::vector<std::string>());
0163 desc.addUntracked<std::vector<int>>("saveQIE11DataNSamples", std::vector<int>());
0164 desc.addUntracked<std::vector<std::string>>("saveQIE11DataTags", std::vector<std::string>());
0165 desc.addUntracked<bool>("ComplainEmptyData", false);
0166 desc.addUntracked<int>("UnpackerMode", 0);
0167 desc.addUntracked<int>("ExpectedOrbitMessageTime", -1);
0168 desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
0169 desc.add<std::string>("ElectronicsMap", "");
0170 descriptions.add("hcalRawToDigi", desc);
0171 }
0172
0173
0174 void HcalRawToDigi::produce(edm::Event& e, const edm::EventSetup& es) {
0175
0176 edm::Handle<FEDRawDataCollection> rawraw;
0177 e.getByToken(tok_data_, rawraw);
0178
0179 edm::ESHandle<HcalDbService> pSetup = es.getHandle(tok_dbService_);
0180 edm::ESHandle<HcalElectronicsMap> item = es.getHandle(tok_electronicsMap_);
0181 const HcalElectronicsMap* readoutMap = item.product();
0182 filter_.setConditions(pSetup.product());
0183
0184
0185 std::vector<HBHEDataFrame> hbhe;
0186 std::vector<HODataFrame> ho;
0187 std::vector<HFDataFrame> hf;
0188 std::vector<HcalTriggerPrimitiveDigi> htp;
0189 std::vector<HcalCalibDataFrame> hc;
0190 std::vector<ZDCDataFrame> zdc;
0191 std::vector<HcalTTPDigi> ttp;
0192 std::vector<HOTriggerPrimitiveDigi> hotp;
0193 HcalUMNioDigi umnio;
0194 auto report = std::make_unique<HcalUnpackerReport>();
0195
0196
0197 if (stats_.max_hbhe > 0)
0198 hbhe.reserve(stats_.ave_hbhe + (stats_.max_hbhe - stats_.ave_hbhe) / 8);
0199 if (stats_.max_ho > 0)
0200 ho.reserve(stats_.ave_ho + (stats_.max_ho - stats_.ave_ho) / 8);
0201 if (stats_.max_hf > 0)
0202 hf.reserve(stats_.ave_hf + (stats_.max_hf - stats_.ave_hf) / 8);
0203 if (stats_.max_calib > 0)
0204 hc.reserve(stats_.ave_calib + (stats_.max_calib - stats_.ave_calib) / 8);
0205 if (stats_.max_tp > 0)
0206 htp.reserve(stats_.ave_tp + (stats_.max_tp - stats_.ave_tp) / 8);
0207 if (stats_.max_tpho > 0)
0208 hotp.reserve(stats_.ave_tpho + (stats_.max_tpho - stats_.ave_tpho) / 8);
0209
0210 if (unpackZDC_)
0211 zdc.reserve(24);
0212
0213 HcalUnpacker::Collections colls;
0214 colls.hbheCont = &hbhe;
0215 colls.hoCont = &ho;
0216 colls.hfCont = &hf;
0217 colls.tpCont = &htp;
0218 colls.tphoCont = &hotp;
0219 colls.calibCont = &hc;
0220 colls.zdcCont = &zdc;
0221 colls.umnio = &umnio;
0222 if (unpackTTP_)
0223 colls.ttp = &ttp;
0224
0225
0226 for (const auto& info : saveQIE10Info_) {
0227 colls.qie10Addtl[info.first] = new QIE10DigiCollection(info.first);
0228 }
0229
0230
0231 for (const auto& info : saveQIE11Info_) {
0232 colls.qie11Addtl[info.first] = new QIE11DigiCollection(info.first);
0233 }
0234
0235
0236 for (std::vector<int>::const_iterator i = fedUnpackList_.begin(); i != fedUnpackList_.end(); i++) {
0237 const FEDRawData& fed = rawraw->FEDData(*i);
0238 if (fed.size() == 0) {
0239 if (complainEmptyData_) {
0240 if (!silent_)
0241 edm::LogWarning("EmptyData") << "No data for FED " << *i;
0242 report->addError(*i);
0243 }
0244 } else if (fed.size() < 8 * 3) {
0245 if (!silent_)
0246 edm::LogWarning("EmptyData") << "Tiny data " << fed.size() << " for FED " << *i;
0247 report->addError(*i);
0248 } else {
0249 try {
0250 unpacker_.unpack(fed, *readoutMap, colls, *report, silent_);
0251 report->addUnpacked(*i);
0252 } catch (cms::Exception& e) {
0253 if (!silent_)
0254 edm::LogWarning("Unpacking error") << e.what();
0255 report->addError(*i);
0256 } catch (...) {
0257 if (!silent_)
0258 edm::LogWarning("Unpacking exception");
0259 report->addError(*i);
0260 }
0261 }
0262 }
0263
0264
0265 stats_.max_hbhe = std::max(stats_.max_hbhe, (int)hbhe.size());
0266 stats_.ave_hbhe = (stats_.ave_hbhe * stats_.n + hbhe.size()) / (stats_.n + 1);
0267 stats_.max_ho = std::max(stats_.max_ho, (int)ho.size());
0268 stats_.ave_ho = (stats_.ave_ho * stats_.n + ho.size()) / (stats_.n + 1);
0269 stats_.max_hf = std::max(stats_.max_hf, (int)hf.size());
0270 stats_.ave_hf = (stats_.ave_hf * stats_.n + hf.size()) / (stats_.n + 1);
0271 stats_.max_tp = std::max(stats_.max_tp, (int)htp.size());
0272 stats_.ave_tp = (stats_.ave_tp * stats_.n + htp.size()) / (stats_.n + 1);
0273 stats_.max_tpho = std::max(stats_.max_tpho, (int)hotp.size());
0274 stats_.ave_tpho = (stats_.ave_tpho * stats_.n + hotp.size()) / (stats_.n + 1);
0275 stats_.max_calib = std::max(stats_.max_calib, (int)hc.size());
0276 stats_.ave_calib = (stats_.ave_calib * stats_.n + hc.size()) / (stats_.n + 1);
0277
0278 stats_.n++;
0279
0280
0281 std::unordered_set<uint32_t> cacheForHFdup;
0282 unsigned int cntHFdup = 0;
0283 for (auto& hf_digi : hf) {
0284 if (!cacheForHFdup.insert(hf_digi.id().rawId()).second)
0285 cntHFdup++;
0286 }
0287 if (cntHFdup)
0288 edm::LogError("HcalRawToDigi") << "Duplicated HF digis found for " << cntHFdup << " times" << std::endl;
0289
0290
0291
0292 for (const auto& addtl : colls.qie10Addtl) {
0293 if (addtl.second->samples() == colls.qie10->samples()) {
0294 std::string tag = saveQIE10Info_[addtl.second->samples()];
0295 edm::LogWarning("HcalRawToDigi") << "QIE10 data requested to be stored in tag " << tag
0296 << " is already stored in the default QIE10 collection. "
0297 << "To avoid duplicating, remove the tag " << tag
0298 << " from the saveQIE10DataTags and the value of " << addtl.second->samples()
0299 << " from the saveQIE10DataNSamples "
0300 << "configurables to HcalRawToDigi" << std::endl;
0301 }
0302 }
0303 for (const auto& addtl : colls.qie11Addtl) {
0304 if (addtl.second->samples() == colls.qie11->samples()) {
0305 std::string tag = saveQIE11Info_[addtl.second->samples()];
0306 edm::LogWarning("HcalRawToDigi") << "QIE11 data requested to be stored in tag " << tag
0307 << " is already stored in the default QIE11 collection. "
0308 << "To avoid duplicating, remove the tag " << tag
0309 << " from the saveQIE11DataTags and the value of " << addtl.second->samples()
0310 << " from the saveQIE11DataNSamples "
0311 << "configurables to HcalRawToDigi" << std::endl;
0312 }
0313 }
0314
0315
0316 auto hbhe_prod = std::make_unique<HBHEDigiCollection>();
0317 auto hf_prod = std::make_unique<HFDigiCollection>();
0318 auto ho_prod = std::make_unique<HODigiCollection>();
0319 auto htp_prod = std::make_unique<HcalTrigPrimDigiCollection>();
0320 auto hotp_prod = std::make_unique<HOTrigPrimDigiCollection>();
0321
0322 if (colls.qie10 == nullptr) {
0323 colls.qie10 = new QIE10DigiCollection();
0324 }
0325 std::unique_ptr<QIE10DigiCollection> qie10_prod(colls.qie10);
0326
0327
0328 if (colls.qie10ZDC == nullptr) {
0329 colls.qie10ZDC = new QIE10DigiCollection();
0330 }
0331 std::unique_ptr<QIE10DigiCollection> qie10ZDC_prod(colls.qie10ZDC);
0332
0333
0334 if (colls.qie10Lasermon == nullptr) {
0335 colls.qie10Lasermon = new QIE10DigiCollection();
0336 }
0337 std::unique_ptr<QIE10DigiCollection> qie10Lasermon_prod(colls.qie10Lasermon);
0338
0339 if (colls.qie11 == nullptr) {
0340 colls.qie11 = new QIE11DigiCollection();
0341 }
0342 std::unique_ptr<QIE11DigiCollection> qie11_prod(colls.qie11);
0343
0344
0345
0346 std::unordered_map<int, std::unique_ptr<QIE10DigiCollection>> qie10_prodAddtl;
0347 std::unordered_map<int, std::unique_ptr<QIE11DigiCollection>> qie11_prodAddtl;
0348 for (const auto& orig : colls.qie10Addtl) {
0349 qie10_prodAddtl[orig.first] = std::unique_ptr<QIE10DigiCollection>(orig.second);
0350 }
0351 for (const auto& orig : colls.qie11Addtl) {
0352 qie11_prodAddtl[orig.first] = std::unique_ptr<QIE11DigiCollection>(orig.second);
0353 }
0354
0355 hbhe_prod->swap_contents(hbhe);
0356 if (!cntHFdup)
0357 hf_prod->swap_contents(hf);
0358 ho_prod->swap_contents(ho);
0359 htp_prod->swap_contents(htp);
0360 hotp_prod->swap_contents(hotp);
0361
0362
0363 if (filter_.active()) {
0364 HBHEDigiCollection filtered_hbhe = filter_.filter(*hbhe_prod, *report);
0365 HODigiCollection filtered_ho = filter_.filter(*ho_prod, *report);
0366 HFDigiCollection filtered_hf = filter_.filter(*hf_prod, *report);
0367 QIE10DigiCollection filtered_qie10 = filter_.filter(*qie10_prod, *report);
0368 QIE11DigiCollection filtered_qie11 = filter_.filter(*qie11_prod, *report);
0369
0370 hbhe_prod->swap(filtered_hbhe);
0371 ho_prod->swap(filtered_ho);
0372 hf_prod->swap(filtered_hf);
0373 qie10_prod->swap(filtered_qie10);
0374 qie11_prod->swap(filtered_qie11);
0375
0376
0377 for (auto& prod : qie10_prodAddtl) {
0378 QIE10DigiCollection filtered_qie10 = filter_.filter(*(prod.second), *report);
0379 prod.second->swap(filtered_qie10);
0380 }
0381
0382 for (auto& prod : qie11_prodAddtl) {
0383 QIE11DigiCollection filtered_qie11 = filter_.filter(*(prod.second), *report);
0384 prod.second->swap(filtered_qie11);
0385 }
0386 }
0387
0388
0389
0390 hbhe_prod->sort();
0391 ho_prod->sort();
0392 hf_prod->sort();
0393 htp_prod->sort();
0394 hotp_prod->sort();
0395 qie10_prod->sort();
0396 qie10ZDC_prod->sort();
0397 qie10Lasermon_prod->sort();
0398 qie11_prod->sort();
0399
0400
0401 for (auto& prod : qie10_prodAddtl) {
0402 prod.second->sort();
0403 }
0404 for (auto& prod : qie11_prodAddtl) {
0405 prod.second->sort();
0406 }
0407
0408 e.put(std::move(hbhe_prod));
0409 e.put(std::move(ho_prod));
0410 e.put(std::move(hf_prod));
0411 e.put(std::move(htp_prod));
0412 e.put(std::move(hotp_prod));
0413 e.put(std::move(qie10_prod));
0414 e.put(std::move(qie10ZDC_prod), "ZDC");
0415 e.put(std::move(qie10Lasermon_prod), "LASERMON");
0416 e.put(std::move(qie11_prod));
0417
0418
0419 for (auto& prod : qie10_prodAddtl) {
0420 std::string tag = saveQIE10Info_[prod.first];
0421 e.put(std::move(prod.second), tag);
0422 }
0423
0424 for (auto& prod : qie11_prodAddtl) {
0425 std::string tag = saveQIE11Info_[prod.first];
0426 e.put(std::move(prod.second), tag);
0427 }
0428
0429
0430 if (unpackCalib_) {
0431 auto hc_prod = std::make_unique<HcalCalibDigiCollection>();
0432 hc_prod->swap_contents(hc);
0433
0434 if (filter_.active()) {
0435 HcalCalibDigiCollection filtered_calib = filter_.filter(*hc_prod, *report);
0436 hc_prod->swap(filtered_calib);
0437 }
0438
0439 hc_prod->sort();
0440 e.put(std::move(hc_prod));
0441 }
0442
0443
0444 if (unpackZDC_) {
0445 auto prod = std::make_unique<ZDCDigiCollection>();
0446 prod->swap_contents(zdc);
0447
0448 if (filter_.active()) {
0449 ZDCDigiCollection filtered_zdc = filter_.filter(*prod, *report);
0450 prod->swap(filtered_zdc);
0451 }
0452
0453 prod->sort();
0454 e.put(std::move(prod));
0455 }
0456
0457 if (unpackTTP_) {
0458 auto prod = std::make_unique<HcalTTPDigiCollection>();
0459 prod->swap_contents(ttp);
0460
0461 prod->sort();
0462 e.put(std::move(prod));
0463 }
0464 e.put(std::move(report));
0465
0466 if (unpackUMNio_) {
0467 if (colls.umnio != nullptr) {
0468 e.put(std::make_unique<HcalUMNioDigi>(umnio));
0469 }
0470 }
0471 }