File indexing completed on 2023-03-17 10:44:54
0001 #include <cstdlib>
0002 #include <fstream>
0003 #include <memory>
0004 #include <sstream>
0005 #include <sys/stat.h>
0006 #include <sys/time.h>
0007 #include <sys/types.h>
0008 #include <unistd.h>
0009
0010 #include <cstdlib> // For srand() and rand()
0011
0012 #ifdef HAVE_XDAQ
0013 #include <toolbox/string.h>
0014 #else
0015 #include "CaloOnlineTools/HcalOnlineDb/interface/xdaq_compat.h" // Replaces toolbox::toString
0016 #endif
0017
0018 #include "OnlineDB/Oracle/interface/Oracle.h"
0019
0020 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0021
0022 #include "CaloOnlineTools/HcalOnlineDb/interface/HcalLutManager.h"
0023 #include "CaloOnlineTools/HcalOnlineDb/interface/ZdcLut.h"
0024 #include "CalibCalorimetry/HcalTPGAlgos/interface/XMLProcessor.h"
0025 #include "CalibCalorimetry/HcalTPGAlgos/interface/XMLDOMBlock.h"
0026 #include "CaloOnlineTools/HcalOnlineDb/interface/HcalQIEManager.h"
0027 #include "CaloOnlineTools/HcalOnlineDb/interface/LMap.h"
0028 #include "CaloOnlineTools/HcalOnlineDb/interface/XMLLUTLoader.h"
0029 #include "CaloOnlineTools/HcalOnlineDb/interface/RooGKCounter.h"
0030 #include "DataFormats/HcalDetId/interface/HcalDetId.h"
0031
0032 #include "DataFormats/HcalDetId/interface/HcalSubdetector.h"
0033 XERCES_CPP_NAMESPACE_USE
0034 using namespace std;
0035 using namespace oracle::occi;
0036 using namespace hcal;
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046 HcalLutManager::HcalLutManager(void) { init(); }
0047
0048 HcalLutManager::HcalLutManager(std::vector<HcalGenericDetId>& map) {
0049 init();
0050 _iter.init(map);
0051 }
0052
0053 HcalLutManager::HcalLutManager(const HcalElectronicsMap* _emap,
0054 const HcalChannelQuality* _cq,
0055 uint32_t _status_word_to_mask) {
0056 init();
0057 emap = _emap;
0058 cq = _cq;
0059 status_word_to_mask = _status_word_to_mask;
0060 }
0061
0062 HcalLutManager::HcalLutManager(const HcalDbService* _conditions,
0063 const HcalChannelQuality* _cq,
0064 uint32_t _status_word_to_mask) {
0065 init();
0066 conditions = _conditions;
0067 emap = conditions->getHcalMapping();
0068 cq = _cq;
0069 status_word_to_mask = _status_word_to_mask;
0070 }
0071
0072 void HcalLutManager::init(void) {
0073 lut_xml = nullptr;
0074 lut_checksums_xml = nullptr;
0075 db = nullptr;
0076 lmap = nullptr;
0077 emap = nullptr;
0078 cq = nullptr;
0079 conditions = nullptr;
0080 status_word_to_mask = 0x0000;
0081 }
0082
0083 HcalLutManager::~HcalLutManager(void) {
0084 delete lut_xml;
0085 delete lut_checksums_xml;
0086 delete db;
0087 delete lmap;
0088 }
0089
0090 int HcalLutManager::initChannelIterator(std::vector<HcalGenericDetId>& map) {
0091 _iter.init(map);
0092 return _iter.size();
0093 }
0094
0095 std::string& HcalLutManager::getLutXml(std::vector<unsigned int>& _lut) {
0096 if (lut_xml)
0097 delete lut_xml;
0098
0099 lut_xml = new LutXml();
0100
0101 LutXml::Config _config;
0102 _config.lut = _lut;
0103 lut_xml->addLut(_config);
0104 lut_xml->addLut(_config);
0105 lut_xml->addLut(_config);
0106
0107
0108 return lut_xml->getCurrentBrick();
0109 }
0110
0111 int HcalLutManager::getInt(std::string number) {
0112 int result;
0113 sscanf(number.c_str(), "%d", &result);
0114 return result;
0115 }
0116
0117 HcalSubdetector HcalLutManager::get_subdetector(std::string _det) {
0118 HcalSubdetector result;
0119 if (_det.find("HB") != std::string::npos)
0120 result = HcalBarrel;
0121 else if (_det.find("HE") != std::string::npos)
0122 result = HcalEndcap;
0123 else if (_det.find("HF") != std::string::npos)
0124 result = HcalForward;
0125 else if (_det.find("HO") != std::string::npos)
0126 result = HcalOuter;
0127 else
0128 result = HcalOther;
0129
0130 return result;
0131 }
0132
0133 int HcalLutManager_test::getLutSetFromFile_test(std::string _filename) {
0134 HcalLutManager _manager;
0135 HcalLutSet _set = _manager.getLutSetFromFile(_filename);
0136 std::stringstream s;
0137 s << "===> Test of HcalLutSet HcalLutManager::getLutSetFromFile( std::string _filename )" << std::endl << std::endl;
0138 s << _set.label << std::endl;
0139 for (unsigned int i = 0; i != _set.subdet.size(); i++)
0140 s << _set.subdet[i] << " ";
0141 s << std::endl;
0142 for (unsigned int i = 0; i != _set.eta_min.size(); i++)
0143 s << _set.eta_min[i] << " ";
0144 s << std::endl;
0145 for (unsigned int i = 0; i != _set.eta_max.size(); i++)
0146 s << _set.eta_max[i] << " ";
0147 s << std::endl;
0148 for (unsigned int i = 0; i != _set.phi_min.size(); i++)
0149 s << _set.phi_min[i] << " ";
0150 s << std::endl;
0151 for (unsigned int i = 0; i != _set.phi_max.size(); i++)
0152 s << _set.phi_max[i] << " ";
0153 s << std::endl;
0154 for (unsigned int i = 0; i != _set.depth_min.size(); i++)
0155 s << _set.depth_min[i] << " ";
0156 s << std::endl;
0157 for (unsigned int i = 0; i != _set.depth_max.size(); i++)
0158 s << _set.depth_max[i] << " ";
0159 s << std::endl;
0160 for (unsigned int j = 0; j != _set.lut[0].size(); j++) {
0161 for (unsigned int i = 0; i != _set.lut.size(); i++) {
0162 s << _set.lut[i][j] << " ";
0163 }
0164 s << "---> " << j << std::endl;
0165 }
0166 edm::LogInfo("HcalLutManager") << s.str();
0167 return 0;
0168 }
0169
0170 HcalLutSet HcalLutManager::getLutSetFromFile(std::string _filename, int _type) {
0171 HcalLutSet _lutset;
0172
0173 ifstream infile(_filename.c_str());
0174 std::string buf;
0175
0176 if (infile.is_open()) {
0177 edm::LogInfo("HcalLutManager") << "File " << _filename << " is open..." << std::endl
0178 << "Reading LUTs and their eta/phi/depth/subdet ranges...";
0179
0180
0181 getline(infile, _lutset.label);
0182
0183 if (_type == 1) {
0184
0185 getline(infile, buf);
0186 _lutset.subdet = HcalQIEManager::splitString(buf);
0187 }
0188
0189
0190 std::vector<std::string> buf_vec;
0191 getline(infile, buf);
0192 buf_vec = HcalQIEManager::splitString(buf);
0193 for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
0194 _lutset.eta_min.push_back(HcalLutManager::getInt(*iter));
0195 }
0196
0197
0198 getline(infile, buf);
0199 buf_vec = HcalQIEManager::splitString(buf);
0200 for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
0201 _lutset.eta_max.push_back(HcalLutManager::getInt(*iter));
0202 }
0203
0204
0205 getline(infile, buf);
0206 buf_vec = HcalQIEManager::splitString(buf);
0207 for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
0208 _lutset.phi_min.push_back(HcalLutManager::getInt(*iter));
0209 }
0210
0211
0212 getline(infile, buf);
0213 buf_vec = HcalQIEManager::splitString(buf);
0214 for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
0215 _lutset.phi_max.push_back(HcalLutManager::getInt(*iter));
0216 }
0217
0218 if (_type == 1) {
0219
0220 getline(infile, buf);
0221 buf_vec = HcalQIEManager::splitString(buf);
0222 for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
0223 _lutset.depth_min.push_back(HcalLutManager::getInt(*iter));
0224 }
0225
0226
0227 getline(infile, buf);
0228 buf_vec = HcalQIEManager::splitString(buf);
0229 for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
0230 _lutset.depth_max.push_back(HcalLutManager::getInt(*iter));
0231 }
0232 }
0233
0234 bool first_lut_entry = true;
0235 while (getline(infile, buf)) {
0236 buf_vec = HcalQIEManager::splitString(buf);
0237 for (unsigned int i = 0; i < buf_vec.size(); i++) {
0238 if (first_lut_entry) {
0239 std::vector<unsigned int> _l;
0240 _lutset.lut.push_back(_l);
0241 }
0242 _lutset.lut[i].push_back(HcalLutManager::getInt(buf_vec[i]));
0243 }
0244 first_lut_entry = false;
0245 }
0246 }
0247
0248 edm::LogInfo("HcalLutManager") << "done.";
0249
0250 return _lutset;
0251 }
0252
0253 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLutXmlFromAsciiMaster(std::string _filename,
0254 std::string _tag,
0255 int _crate,
0256 bool split_by_crate) {
0257 edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
0258 std::map<int, std::shared_ptr<LutXml>> _xml;
0259
0260 LMap _lmap;
0261 _lmap.read("./backup/HCALmapHBEF.txt", "HBEF");
0262 _lmap.read("./backup/HCALmapHO.txt", "HO");
0263 std::map<int, LMapRow>& _map = _lmap.get_map();
0264 edm::LogInfo("HcalLutManager") << "LMap contains " << _map.size() << " channels";
0265
0266
0267 HcalLutSet _set = getLutSetFromFile(_filename);
0268 int lut_set_size = _set.lut.size();
0269
0270 RooGKCounter _counter;
0271
0272 for (std::map<int, LMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0273 LutXml::Config _cfg;
0274
0275
0276
0277 int lut_index = -1;
0278 for (int i = 0; i < lut_set_size; i++) {
0279 if ((row->second.crate == _crate || _crate == -1) &&
0280 _set.eta_min[i] <= row->second.side * row->second.eta &&
0281 _set.eta_max[i] >= row->second.side * row->second.eta && _set.phi_min[i] <= row->second.phi &&
0282 _set.phi_max[i] >= row->second.phi && _set.depth_min[i] <= row->second.depth &&
0283 _set.depth_max[i] >= row->second.depth && get_subdetector(_set.subdet[i]) == row->second.det) {
0284 lut_index = i;
0285 }
0286 }
0287 if (lut_index >= 0) {
0288 if (_xml.count(row->second.crate) == 0 && split_by_crate) {
0289 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->second.crate, std::make_shared<LutXml>()));
0290 } else if (_xml.count(0) == 0 && !split_by_crate) {
0291 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
0292 }
0293 _cfg.ieta = row->second.side * row->second.eta;
0294 _cfg.iphi = row->second.phi;
0295 _cfg.depth = row->second.depth;
0296 _cfg.crate = row->second.crate;
0297 _cfg.slot = row->second.htr;
0298 if (row->second.fpga.find("top") != std::string::npos)
0299 _cfg.topbottom = 1;
0300 else if (row->second.fpga.find("bot") != std::string::npos)
0301 _cfg.topbottom = 0;
0302 else
0303 edm::LogWarning("HcalLutManager") << "fpga out of range...";
0304
0305
0306 _cfg.fiber = row->second.htr_fi;
0307 _cfg.fiberchan = row->second.fi_ch;
0308 if (_set.lut[lut_index].size() == 128)
0309 _cfg.lut_type = 1;
0310 else
0311 _cfg.lut_type = 2;
0312 _cfg.creationtag = _tag;
0313 _cfg.creationstamp = get_time_stamp(time(nullptr));
0314 _cfg.targetfirmware = "1.0.0";
0315 _cfg.formatrevision = "1";
0316
0317
0318
0319 _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->second.side > 0) * 100 + row->second.eta +
0320 ((row->second.det == HcalForward && row->second.eta == 29) ? (4 * 10000) : (0));
0321 _cfg.lut = _set.lut[lut_index];
0322 if (split_by_crate) {
0323 _xml[row->second.crate]->addLut(_cfg, lut_checksums_xml);
0324 _counter.count();
0325 } else {
0326 _xml[0]->addLut(_cfg, lut_checksums_xml);
0327 _counter.count();
0328 }
0329 }
0330 }
0331 edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
0332 << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
0333 return _xml;
0334 }
0335
0336
0337
0338
0339 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLinearizationLutXmlFromAsciiMasterEmap(std::string _filename,
0340 std::string _tag,
0341 int _crate,
0342 bool split_by_crate) {
0343 edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
0344 std::map<int, std::shared_ptr<LutXml>> _xml;
0345
0346 EMap _emap(emap);
0347 std::vector<EMap::EMapRow>& _map = _emap.get_map();
0348 edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
0349
0350
0351 HcalLutSet _set = getLutSetFromFile(_filename);
0352 int lut_set_size = _set.lut.size();
0353 edm::LogInfo("HcalLutManager") << " ==> " << lut_set_size << " sets of different LUTs read from the master file";
0354
0355
0356 std::vector<unsigned int> zeroLut;
0357 for (size_t adc = 0; adc < 128; adc++)
0358 zeroLut.push_back(0);
0359
0360 RooGKCounter _counter;
0361
0362 for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0363 if ((row->subdet.find("HB") != string::npos || row->subdet.find("HE") != string::npos ||
0364 row->subdet.find("HO") != string::npos || row->subdet.find("HF") != string::npos) &&
0365 row->subdet.size() == 2) {
0366 LutXml::Config _cfg;
0367
0368
0369
0370 int lut_index = -1;
0371 for (int i = 0; i < lut_set_size; i++) {
0372 if ((row->crate == _crate || _crate == -1) &&
0373 _set.eta_min[i] <= row->ieta && _set.eta_max[i] >= row->ieta && _set.phi_min[i] <= row->iphi &&
0374 _set.phi_max[i] >= row->iphi && _set.depth_min[i] <= row->idepth && _set.depth_max[i] >= row->idepth &&
0375 _set.subdet[i].find(row->subdet) != string::npos) {
0376 lut_index = i;
0377 }
0378 }
0379 if (lut_index >= 0) {
0380 if (_xml.count(row->crate) == 0 && split_by_crate) {
0381 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
0382 } else if (_xml.count(0) == 0 && !split_by_crate) {
0383 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
0384 }
0385 _cfg.ieta = row->ieta;
0386 _cfg.iphi = row->iphi;
0387 _cfg.depth = row->idepth;
0388 _cfg.crate = row->crate;
0389 _cfg.slot = row->slot;
0390 if (row->topbottom.find('t') != std::string::npos)
0391 _cfg.topbottom = 1;
0392 else if (row->topbottom.find('b') != std::string::npos)
0393 _cfg.topbottom = 0;
0394 else if (row->topbottom.find('u') != std::string::npos)
0395 _cfg.topbottom = 2;
0396 else
0397 edm::LogWarning("HcalLutManager") << "fpga out of range...";
0398 _cfg.fiber = row->fiber;
0399 _cfg.fiberchan = row->fiberchan;
0400 _cfg.lut_type = 1;
0401 _cfg.creationtag = _tag;
0402 _cfg.creationstamp = get_time_stamp(time(nullptr));
0403 _cfg.targetfirmware = "1.0.0";
0404 _cfg.formatrevision = "1";
0405
0406
0407
0408 _cfg.generalizedindex =
0409 _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
0410 (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
0411
0412
0413 DetId _detId(row->rawId);
0414 uint32_t status_word = cq->getValues(_detId)->getValue();
0415 if ((status_word & status_word_to_mask) > 0) {
0416 _cfg.lut = zeroLut;
0417 } else {
0418 _cfg.lut = _set.lut[lut_index];
0419 }
0420 if (split_by_crate) {
0421 _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
0422 _counter.count();
0423 } else {
0424 _xml[0]->addLut(_cfg, lut_checksums_xml);
0425 _counter.count();
0426 }
0427 }
0428 }
0429 }
0430 edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
0431 << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
0432 return _xml;
0433 }
0434
0435 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLinearizationLutXmlFromAsciiMasterEmap_new(
0436 std::string _filename, std::string _tag, int _crate, bool split_by_crate) {
0437 edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
0438 std::map<int, std::shared_ptr<LutXml>> _xml;
0439
0440
0441 HcalLutSet _set = getLutSetFromFile(_filename);
0442 int lut_set_size = _set.lut.size();
0443 edm::LogInfo("HcalLutManager") << " ==> " << lut_set_size << " sets of different LUTs read from the master file";
0444
0445 RooGKCounter _counter;
0446
0447 for (_iter.begin(); !_iter.end(); _iter.next()) {
0448 HcalSubdetector _subdet = _iter.getHcalSubdetector();
0449 if ((_subdet == HcalBarrel || _subdet == HcalEndcap || _subdet == HcalForward || _subdet == HcalOuter)) {
0450 int _ieta = _iter.getIeta();
0451 int _iphi = _iter.getIphi();
0452 int _depth = _iter.getDepth();
0453
0454
0455 HcalElectronicsId _eId(_iter.getHcalGenericDetId().rawId());
0456 int aCrate = _eId.readoutVMECrateId();
0457 int aSlot = _eId.htrSlot();
0458 int aTopBottom = _eId.htrTopBottom();
0459 int aFiber = _eId.fiberIndex();
0460 int aFiberChan = _eId.fiberChanId();
0461
0462 LutXml::Config _cfg;
0463
0464
0465
0466 int lut_index = -1;
0467 for (int i = 0; i < lut_set_size; i++) {
0468 if ((aCrate == _crate || _crate == -1) &&
0469 _set.eta_min[i] <= _ieta && _set.eta_max[i] >= _ieta && _set.phi_min[i] <= _iphi &&
0470 _set.phi_max[i] >= _iphi && _set.depth_min[i] <= _depth && _set.depth_max[i] >= _depth &&
0471 _set.subdet[i].find(_ass.getSubdetectorString(_subdet)) != string::npos) {
0472 lut_index = i;
0473 }
0474 }
0475 if (lut_index >= 0) {
0476 if (_xml.count(aCrate) == 0 && split_by_crate) {
0477 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(aCrate, std::make_shared<LutXml>()));
0478 } else if (_xml.count(0) == 0 && !split_by_crate) {
0479 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
0480 }
0481 _cfg.ieta = _ieta;
0482 _cfg.iphi = _iphi;
0483 _cfg.depth = _depth;
0484 _cfg.crate = aCrate;
0485 _cfg.slot = aSlot;
0486 _cfg.topbottom = aTopBottom;
0487 _cfg.fiber = aFiber;
0488 _cfg.fiberchan = aFiberChan;
0489 _cfg.lut_type = 1;
0490 _cfg.creationtag = _tag;
0491 _cfg.creationstamp = get_time_stamp(time(nullptr));
0492 _cfg.targetfirmware = "1.0.0";
0493 _cfg.formatrevision = "1";
0494
0495
0496
0497 _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (_ieta > 0) * 100 + abs(_ieta) +
0498 (((_subdet == HcalForward) && abs(_ieta) == 29) ? (4 * 10000) : (0));
0499 _cfg.lut = _set.lut[lut_index];
0500 if (split_by_crate) {
0501 _xml[aCrate]->addLut(_cfg, lut_checksums_xml);
0502 _counter.count();
0503 } else {
0504 _xml[0]->addLut(_cfg, lut_checksums_xml);
0505 _counter.count();
0506 }
0507 }
0508 }
0509 }
0510 edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
0511 << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
0512 return _xml;
0513 }
0514
0515 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getCompressionLutXmlFromAsciiMaster(std::string _filename,
0516 std::string _tag,
0517 int _crate,
0518 bool split_by_crate) {
0519 edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from ascii master file...";
0520 std::map<int, std::shared_ptr<LutXml>> _xml;
0521
0522 edm::LogInfo("HcalLutManager")
0523 << "instantiating CaloTPGTranscoderULUT in order to check the validity of (ieta,iphi)...";
0524 CaloTPGTranscoderULUT _coder;
0525
0526
0527
0528 EMap _emap(emap);
0529 std::vector<EMap::EMapRow>& _map = _emap.get_map();
0530 edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
0531
0532
0533 HcalLutSet _set = getLutSetFromFile(_filename, 2);
0534 int lut_set_size = _set.lut.size();
0535 edm::LogInfo("HcalLutManager") << " ==> " << lut_set_size << " sets of different LUTs read from the master file";
0536
0537
0538 RooGKCounter _counter;
0539 for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0540 LutXml::Config _cfg;
0541
0542
0543
0544 int lut_index = -1;
0545 for (int i = 0; i < lut_set_size; i++) {
0546 if (row->subdet.find("HT") != std::string::npos &&
0547 (row->crate == _crate || _crate == -1) &&
0548 _set.eta_min[i] <= row->ieta && _set.eta_max[i] >= row->ieta && _set.phi_min[i] <= row->iphi &&
0549 _set.phi_max[i] >= row->iphi && _coder.HTvalid(row->ieta, row->iphi, row->idepth / 10)) {
0550 lut_index = i;
0551 }
0552 }
0553 if (lut_index >= 0) {
0554 if (_xml.count(row->crate) == 0 && split_by_crate) {
0555 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
0556 } else if (_xml.count(0) == 0 && !split_by_crate) {
0557 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
0558 }
0559 _cfg.ieta = row->ieta;
0560 _cfg.iphi = row->iphi;
0561 _cfg.depth = row->idepth;
0562 _cfg.crate = row->crate;
0563 _cfg.slot = row->slot;
0564 if (row->topbottom.find('t') != std::string::npos)
0565 _cfg.topbottom = 1;
0566 else if (row->topbottom.find('b') != std::string::npos)
0567 _cfg.topbottom = 0;
0568 else if (row->topbottom.find('u') != std::string::npos)
0569 _cfg.topbottom = 2;
0570 else
0571 edm::LogWarning("HcalLutManager") << "fpga out of range...";
0572 _cfg.fiber = row->fiber;
0573 _cfg.fiberchan = row->fiberchan;
0574 if (_set.lut[lut_index].size() == 128)
0575 _cfg.lut_type = 1;
0576 else
0577 _cfg.lut_type = 2;
0578 _cfg.creationtag = _tag;
0579 _cfg.creationstamp = get_time_stamp(time(nullptr));
0580 _cfg.targetfirmware = "1.0.0";
0581 _cfg.formatrevision = "1";
0582
0583
0584
0585 _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);
0586 _cfg.lut = _set.lut[lut_index];
0587 if (split_by_crate) {
0588 _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
0589 _counter.count();
0590 } else {
0591 _xml[0]->addLut(_cfg, lut_checksums_xml);
0592 _counter.count();
0593 }
0594 }
0595 }
0596 edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
0597 << "Generating compression (output) LUTs from ascii master file...DONE" << std::endl;
0598 return _xml;
0599 }
0600
0601 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLinearizationLutXmlFromCoder(const HcalTPGCoder& _coder,
0602 std::string _tag,
0603 bool split_by_crate) {
0604 edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...";
0605 std::map<int, std::shared_ptr<LutXml>> _xml;
0606
0607
0608
0609
0610
0611 LMap _lmap;
0612 _lmap.read("backup/HCALmapHBEF.txt", "HBEF");
0613
0614
0615 std::map<int, LMapRow>& _map = _lmap.get_map();
0616 edm::LogInfo("HcalLutManager") << "LMap contains " << _map.size() << " channels";
0617
0618
0619
0620
0621
0622
0623 RooGKCounter _counter;
0624 for (std::map<int, LMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0625 LutXml::Config _cfg;
0626
0627 if (_xml.count(row->second.crate) == 0 && split_by_crate) {
0628 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->second.crate, std::make_shared<LutXml>()));
0629 } else if (_xml.count(0) == 0 && !split_by_crate) {
0630 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
0631 }
0632 _cfg.ieta = row->second.side * row->second.eta;
0633 _cfg.iphi = row->second.phi;
0634 _cfg.depth = row->second.depth;
0635 _cfg.crate = row->second.crate;
0636 _cfg.slot = row->second.htr;
0637 if (row->second.fpga.find("top") != std::string::npos)
0638 _cfg.topbottom = 1;
0639 else if (row->second.fpga.find("bot") != std::string::npos)
0640 _cfg.topbottom = 0;
0641 else
0642 edm::LogWarning("HcalLutManager") << "fpga out of range...";
0643
0644
0645 _cfg.fiber = row->second.htr_fi;
0646 _cfg.fiberchan = row->second.fi_ch;
0647 _cfg.lut_type = 1;
0648 _cfg.creationtag = _tag;
0649 _cfg.creationstamp = get_time_stamp(time(nullptr));
0650 _cfg.targetfirmware = "1.0.0";
0651 _cfg.formatrevision = "1";
0652
0653
0654
0655 _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->second.side > 0) * 100 + row->second.eta +
0656 ((row->second.det == HcalForward && row->second.eta == 29) ? (4 * 10000) : (0));
0657
0658
0659 HcalDetId _detid(row->second.det, row->second.side * row->second.eta, row->second.phi, row->second.depth);
0660
0661
0662
0663 std::vector<unsigned short> coder_lut = _coder.getLinearizationLUT(_detid);
0664 for (std::vector<unsigned short>::const_iterator _i = coder_lut.begin(); _i != coder_lut.end(); _i++) {
0665 unsigned int _temp = (unsigned int)(*_i);
0666
0667
0668 _cfg.lut.push_back(_temp);
0669 }
0670 if (split_by_crate) {
0671 _xml[row->second.crate]->addLut(_cfg, lut_checksums_xml);
0672 _counter.count();
0673 } else {
0674 _xml[0]->addLut(_cfg, lut_checksums_xml);
0675 _counter.count();
0676 }
0677 }
0678 edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
0679 << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
0680 return _xml;
0681 }
0682
0683 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getMasks(int masktype, std::string _tag, bool split_by_crate) {
0684 edm::LogInfo("HcalLutManager") << "Generating TDC masks...";
0685
0686 EMap _emap(emap);
0687 std::vector<EMap::EMapRow>& _map = _emap.get_map();
0688 edm::LogInfo("HcalLutManager") << "EMap contains new" << _map.size() << " entries";
0689
0690 std::map<int, std::vector<uint64_t>> masks;
0691
0692 for (const auto& row : _map) {
0693 std::string subdet = row.subdet;
0694 if (subdet != "HF")
0695 continue;
0696 int crate = row.crate;
0697 int slot = row.slot;
0698 int crot = 100 * crate + slot;
0699 int fiber = row.fiber;
0700 int channel = row.fiberchan;
0701 unsigned int finel = 4 * fiber + channel;
0702 if (masks.count(crot) == 0)
0703 masks[crot] = {};
0704 if (finel >= masks[crot].size())
0705 masks[crot].resize(finel + 1);
0706
0707 if (masktype == 0) {
0708 HcalSubdetector _subdet;
0709 if (row.subdet.find("HB") != string::npos)
0710 _subdet = HcalBarrel;
0711 else if (row.subdet.find("HE") != string::npos)
0712 _subdet = HcalEndcap;
0713 else if (row.subdet.find("HO") != string::npos)
0714 _subdet = HcalOuter;
0715 else if (row.subdet.find("HF") != string::npos)
0716 _subdet = HcalForward;
0717 else
0718 _subdet = HcalOther;
0719 HcalDetId _detid(_subdet, row.ieta, row.iphi, row.idepth);
0720 masks[crot][finel] = conditions->getHcalTPChannelParameter(_detid)->getMask();
0721 } else {
0722 auto parameters = conditions->getHcalTPParameters();
0723 masks[crot][finel] = masktype == 1 ? parameters->getADCThresholdHF() : parameters->getTDCMaskHF();
0724 }
0725 }
0726
0727 std::map<int, std::shared_ptr<LutXml>> _xml;
0728 RooGKCounter _counter;
0729
0730 for (const auto& i : masks) {
0731 int crot = i.first;
0732 int crate = crot / 100;
0733
0734 LutXml::Config _cfg;
0735 _cfg.lut_type = 5 + masktype;
0736 _cfg.crate = crate;
0737 _cfg.slot = crot % 100;
0738 _cfg.generalizedindex = crot;
0739 _cfg.mask = i.second;
0740 _cfg.creationtag = _tag;
0741 _cfg.targetfirmware = "1.0.0";
0742 _cfg.formatrevision = "1";
0743
0744 int c = split_by_crate ? crate : 0;
0745 if (_xml.count(c) == 0)
0746 _xml[c] = std::make_shared<LutXml>();
0747
0748 _xml[c]->addLut(_cfg);
0749 _counter.count();
0750 }
0751
0752 edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
0753 << "Generating Masks...DONE" << std::endl;
0754 return _xml;
0755 }
0756
0757 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLinearizationLutXmlFromCoderEmap(const HcalTPGCoder& _coder,
0758 std::string _tag,
0759 bool split_by_crate) {
0760 edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...";
0761 std::map<int, std::shared_ptr<LutXml>> _xml;
0762
0763 EMap _emap(emap);
0764 std::vector<EMap::EMapRow>& _map = _emap.get_map();
0765 edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
0766
0767 RooGKCounter _counter;
0768
0769 for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0770 if ((row->subdet.find("HB") != string::npos || row->subdet.find("HE") != string::npos ||
0771 row->subdet.find("HF") != string::npos) &&
0772 row->subdet.size() == 2) {
0773 LutXml::Config _cfg;
0774
0775 if (_xml.count(row->crate) == 0 && split_by_crate) {
0776 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
0777 } else if (_xml.count(0) == 0 && !split_by_crate) {
0778 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
0779 }
0780 _cfg.ieta = row->ieta;
0781 _cfg.iphi = row->iphi;
0782 _cfg.depth = row->idepth;
0783 _cfg.crate = row->crate;
0784 _cfg.slot = row->slot;
0785 if (row->topbottom.find('t') != std::string::npos)
0786 _cfg.topbottom = 1;
0787 else if (row->topbottom.find('b') != std::string::npos)
0788 _cfg.topbottom = 0;
0789 else if (row->topbottom.find('u') != std::string::npos)
0790 _cfg.topbottom = 2;
0791 else
0792 edm::LogWarning("HcalLutManager") << "fpga out of range...";
0793 _cfg.fiber = row->fiber;
0794 _cfg.fiberchan = row->fiberchan;
0795 _cfg.lut_type = 1;
0796 _cfg.creationtag = _tag;
0797 _cfg.creationstamp = get_time_stamp(time(nullptr));
0798 _cfg.targetfirmware = "1.0.0";
0799 _cfg.formatrevision = "1";
0800
0801
0802
0803 _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
0804 (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
0805 HcalSubdetector _subdet;
0806 if (row->subdet.find("HB") != string::npos)
0807 _subdet = HcalBarrel;
0808 else if (row->subdet.find("HE") != string::npos)
0809 _subdet = HcalEndcap;
0810 else if (row->subdet.find("HO") != string::npos)
0811 _subdet = HcalOuter;
0812 else if (row->subdet.find("HF") != string::npos)
0813 _subdet = HcalForward;
0814 else
0815 _subdet = HcalOther;
0816 HcalDetId _detid(_subdet, row->ieta, row->iphi, row->idepth);
0817
0818 for (const auto i : _coder.getLinearizationLUT(_detid))
0819 _cfg.lut.push_back(i);
0820
0821 if (split_by_crate) {
0822 _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
0823 _counter.count();
0824 } else {
0825 _xml[0]->addLut(_cfg, lut_checksums_xml);
0826 _counter.count();
0827 }
0828 }
0829 }
0830 edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
0831 << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
0832 return _xml;
0833 }
0834
0835 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getHEFineGrainLUTs(std::string _tag, bool split_by_crate) {
0836 edm::LogInfo("HcalLutManager") << "Generating HE fine grain LUTs";
0837 std::map<int, std::shared_ptr<LutXml>> _xml;
0838
0839 EMap _emap(emap);
0840 std::vector<EMap::EMapRow>& _map = _emap.get_map();
0841 edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
0842
0843 RooGKCounter _counter;
0844
0845 for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0846 if (row->subdet.find("HT") != string::npos && row->subdet.size() == 2) {
0847 int abseta = abs(row->ieta);
0848 const HcalTopology* topo = cq->topo();
0849 if (abseta <= topo->lastHBRing() or abseta > topo->lastHERing())
0850 continue;
0851 if (abseta >= topo->firstHEDoublePhiRing() and row->fiberchan % 2 == 1)
0852 continue;
0853 LutXml::Config _cfg;
0854
0855 if (_xml.count(row->crate) == 0 && split_by_crate) {
0856 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
0857 } else if (_xml.count(0) == 0 && !split_by_crate) {
0858 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
0859 }
0860 _cfg.ieta = row->ieta;
0861 _cfg.iphi = row->iphi;
0862 _cfg.depth = row->idepth;
0863 _cfg.crate = row->crate;
0864 _cfg.slot = row->slot;
0865 if (row->topbottom.find('t') != std::string::npos)
0866 _cfg.topbottom = 1;
0867 else if (row->topbottom.find('b') != std::string::npos)
0868 _cfg.topbottom = 0;
0869 else if (row->topbottom.find('u') != std::string::npos)
0870 _cfg.topbottom = 2;
0871 else
0872 edm::LogWarning("HcalLutManager") << "fpga out of range...";
0873 _cfg.fiber = row->fiber;
0874 _cfg.fiberchan = row->fiberchan;
0875 _cfg.lut_type = 4;
0876 _cfg.creationtag = _tag;
0877 _cfg.creationstamp = get_time_stamp(time(nullptr));
0878 _cfg.targetfirmware = "1.0.0";
0879 _cfg.formatrevision = "1";
0880 _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
0881 (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
0882
0883 HcalSubdetector _subdet = HcalEndcap;
0884 HcalDetId _detid(_subdet, row->ieta, row->iphi, row->idepth);
0885
0886 HcalFinegrainBit fg_algo(conditions->getHcalTPParameters()->getFGVersionHBHE());
0887
0888
0889
0890 const int n_fgab_bits = 2048;
0891 for (int i = 0; i < 2 * n_fgab_bits; i++) {
0892 HcalFinegrainBit::Tower tow;
0893 for (int k = 0; k < 6; k++) {
0894 tow[0][k] = (1 << k) & i;
0895 tow[1][k] = (1 << (k + 6)) & i;
0896 }
0897 _cfg.lut.push_back(fg_algo.compute(tow).to_ulong());
0898 }
0899
0900 if (split_by_crate) {
0901 _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
0902 _counter.count();
0903 } else {
0904 _xml[0]->addLut(_cfg, lut_checksums_xml);
0905 _counter.count();
0906 }
0907 }
0908 }
0909 edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
0910 << "Generating HE fine grain LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
0911 return _xml;
0912 }
0913
0914 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getCompressionLutXmlFromCoder(
0915 const CaloTPGTranscoderULUT& _coder, std::string _tag, bool split_by_crate) {
0916 edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from CaloTPGTranscoderULUT," << std::endl
0917 << "initialized from Event Setup" << std::endl;
0918 std::map<int, std::shared_ptr<LutXml>> _xml;
0919
0920 EMap _emap(emap);
0921
0922 std::map<int, unsigned int> maxsize;
0923
0924 std::vector<EMap::EMapRow>& _map = _emap.get_map();
0925 edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
0926
0927
0928 for (const auto& row : _map) {
0929 if (row.subdet.find("HT") == std::string::npos)
0930 continue;
0931 HcalTrigTowerDetId _detid(row.rawId);
0932 if (!cq->topo()->validHT(_detid))
0933 continue;
0934 int crot = 100 * row.crate + row.slot;
0935 unsigned int size = _coder.getCompressionLUT(_detid).size();
0936 if (maxsize.count(crot) == 0 || size > maxsize[crot])
0937 maxsize[crot] = size;
0938 }
0939
0940 RooGKCounter _counter;
0941 for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0942 LutXml::Config _cfg;
0943
0944 if (row->subdet.find("HT") == std::string::npos)
0945 continue;
0946
0947 HcalTrigTowerDetId _detid(row->rawId);
0948
0949 if (!cq->topo()->validHT(_detid))
0950 continue;
0951
0952 if (_xml.count(row->crate) == 0 && split_by_crate) {
0953 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
0954 } else if (_xml.count(0) == 0 && !split_by_crate) {
0955 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
0956 }
0957
0958 _cfg.ieta = row->ieta;
0959 _cfg.iphi = row->iphi;
0960 _cfg.depth = row->idepth;
0961 _cfg.crate = row->crate;
0962 _cfg.slot = row->slot;
0963 if (row->topbottom.find('t') != std::string::npos)
0964 _cfg.topbottom = 1;
0965 else if (row->topbottom.find('b') != std::string::npos)
0966 _cfg.topbottom = 0;
0967 else if (row->topbottom.find('u') != std::string::npos)
0968 _cfg.topbottom = 2;
0969 else
0970 edm::LogWarning("HcalLutManager") << "fpga out of range...";
0971 _cfg.fiber = row->fiber;
0972 _cfg.fiberchan = row->fiberchan;
0973 _cfg.lut_type = 2;
0974 _cfg.creationtag = _tag;
0975 _cfg.creationstamp = get_time_stamp(time(nullptr));
0976 _cfg.targetfirmware = "1.0.0";
0977 _cfg.formatrevision = "1";
0978 _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);
0979
0980 _cfg.lut = _coder.getCompressionLUT(_detid);
0981 auto pWeight = conditions->getHcalTPChannelParameter(_detid, false);
0982 if (pWeight)
0983 _cfg.weight = pWeight->getauxi1();
0984
0985 int crot = 100 * row->crate + row->slot;
0986 unsigned int size = _cfg.lut.size();
0987 if (size < maxsize[crot]) {
0988 edm::LogWarning("HcalLutManager") << " resizing LUT for " << _detid << ", channel=[" << _cfg.crate << ":"
0989 << _cfg.slot << ":" << _cfg.fiber << ":" << _cfg.fiberchan
0990 << "], using value=" << _cfg.lut[size - 1] << std::endl;
0991 for (unsigned int i = size; i < maxsize[crot]; ++i)
0992 _cfg.lut.push_back(_cfg.lut[size - 1]);
0993 }
0994
0995 if (split_by_crate) {
0996 _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
0997 _counter.count();
0998 } else {
0999 _xml[0]->addLut(_cfg, lut_checksums_xml);
1000 _counter.count();
1001 }
1002 }
1003 edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
1004 << "Generating compression (output) LUTs from CaloTPGTranscoderULUT...DONE"
1005 << std::endl;
1006
1007 return _xml;
1008 }
1009
1010 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getCompressionLutXmlFromCoder(std::string _tag,
1011 bool split_by_crate) {
1012 edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from CaloTPGTranscoderULUT";
1013 std::map<int, std::shared_ptr<LutXml>> _xml;
1014
1015
1016
1017
1018 EMap _emap(emap);
1019
1020 std::vector<EMap::EMapRow>& _map = _emap.get_map();
1021 edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
1022
1023
1024
1025
1026
1027 CaloTPGTranscoderULUT _coder;
1028
1029
1030 RooGKCounter _counter;
1031 for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1032 LutXml::Config _cfg;
1033
1034
1035
1036 const int tp_version = row->idepth / 10;
1037 if (row->subdet.find("HT") != std::string::npos && _coder.HTvalid(row->ieta, row->iphi, tp_version)) {
1038 if (_xml.count(row->crate) == 0 && split_by_crate) {
1039 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
1040 } else if (_xml.count(0) == 0 && !split_by_crate) {
1041 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
1042 }
1043 _cfg.ieta = row->ieta;
1044 _cfg.iphi = row->iphi;
1045 _cfg.depth = row->idepth;
1046 _cfg.crate = row->crate;
1047 _cfg.slot = row->slot;
1048 if (row->topbottom.find('t') != std::string::npos)
1049 _cfg.topbottom = 1;
1050 else if (row->topbottom.find('b') != std::string::npos)
1051 _cfg.topbottom = 0;
1052 else if (row->topbottom.find('u') != std::string::npos)
1053 _cfg.topbottom = 2;
1054 else
1055 edm::LogWarning("HcalLutManager") << "fpga out of range...";
1056 _cfg.fiber = row->fiber;
1057 _cfg.fiberchan = row->fiberchan;
1058 _cfg.lut_type = 2;
1059 _cfg.creationtag = _tag;
1060 _cfg.creationstamp = get_time_stamp(time(nullptr));
1061 _cfg.targetfirmware = "1.0.0";
1062 _cfg.formatrevision = "1";
1063
1064
1065
1066 _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);
1067
1068
1069
1070 HcalTrigTowerDetId _detid(row->ieta, row->iphi);
1071
1072 _cfg.lut = _coder.getCompressionLUT(_detid);
1073
1074 if (split_by_crate) {
1075 _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
1076 _counter.count();
1077 } else {
1078 _xml[0]->addLut(_cfg, lut_checksums_xml);
1079 _counter.count();
1080 }
1081 }
1082 }
1083 edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
1084 << "Generating compression (output) LUTs from CaloTPGTranscoderULUT...DONE"
1085 << std::endl;
1086 return _xml;
1087 }
1088
1089 int HcalLutManager::writeLutXmlFiles(std::map<int, std::shared_ptr<LutXml>>& _xml,
1090 std::string _tag,
1091 bool split_by_crate) {
1092 for (std::map<int, std::shared_ptr<LutXml>>::const_iterator cr = _xml.begin(); cr != _xml.end(); cr++) {
1093 std::stringstream output_file_name;
1094 if (split_by_crate) {
1095 output_file_name << _tag << "_" << cr->first << ".xml";
1096 } else {
1097 output_file_name << _tag << ".xml";
1098 }
1099 cr->second->write(output_file_name.str());
1100 }
1101 return 0;
1102 }
1103
1104 int HcalLutManager::createLinLutXmlFiles(std::string _tag, std::string _lin_file, bool split_by_crate) {
1105
1106 std::map<int, std::shared_ptr<LutXml>> xml;
1107 if (!lut_checksums_xml) {
1108 lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1109 }
1110
1111 if (!_lin_file.empty()) {
1112 addLutMap(xml, getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate));
1113 }
1114 writeLutXmlFiles(xml, _tag, split_by_crate);
1115
1116 std::string checksums_file = _tag + "_checksums.xml";
1117 lut_checksums_xml->write(checksums_file);
1118
1119 return 0;
1120 }
1121
1122 int HcalLutManager::createAllLutXmlFiles(std::string _tag,
1123 std::string _lin_file,
1124 std::string _comp_file,
1125 bool split_by_crate) {
1126
1127 std::map<int, std::shared_ptr<LutXml>> xml;
1128 if (!lut_checksums_xml) {
1129 lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1130 }
1131
1132 if (!_lin_file.empty()) {
1133
1134 addLutMap(xml, getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate));
1135 }
1136 if (!_comp_file.empty()) {
1137
1138 addLutMap(xml, getCompressionLutXmlFromAsciiMaster(_comp_file, _tag, -1, split_by_crate));
1139
1140 }
1141 writeLutXmlFiles(xml, _tag, split_by_crate);
1142
1143 std::string checksums_file = _tag + "_checksums.xml";
1144 lut_checksums_xml->write(checksums_file);
1145
1146 return 0;
1147 }
1148
1149 int HcalLutManager::createCompLutXmlFilesFromCoder(std::string _tag, bool split_by_crate) {
1150
1151 std::map<int, std::shared_ptr<LutXml>> xml;
1152 if (!lut_checksums_xml) {
1153 lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1154 }
1155
1156 addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
1157
1158 writeLutXmlFiles(xml, _tag, split_by_crate);
1159
1160 std::string checksums_file = _tag + "_checksums.xml";
1161 lut_checksums_xml->write(checksums_file);
1162
1163 return 0;
1164 }
1165
1166 int HcalLutManager::createAllLutXmlFilesFromCoder(const HcalTPGCoder& _coder, std::string _tag, bool split_by_crate) {
1167
1168 std::map<int, std::shared_ptr<LutXml>> xml;
1169 if (!lut_checksums_xml) {
1170 lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1171 }
1172
1173
1174 addLutMap(xml, getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate));
1175 addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
1176
1177 writeLutXmlFiles(xml, _tag, split_by_crate);
1178
1179 std::string checksums_file = _tag + "_checksums.xml";
1180 lut_checksums_xml->write(checksums_file);
1181
1182 return 0;
1183 }
1184
1185
1186
1187
1188 int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii(std::string _tag,
1189 const HcalTPGCoder& _coder,
1190 const CaloTPGTranscoderULUT& _transcoder,
1191 std::string _lin_file,
1192 bool split_by_crate) {
1193 std::map<int, std::shared_ptr<LutXml>> xml;
1194 if (!lut_checksums_xml) {
1195 lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1196 }
1197
1198 if (!_lin_file.empty()) {
1199 const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
1200 getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
1201 addLutMap(xml, _lin_lut_ascii_xml);
1202 }
1203 const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
1204 getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
1205 addLutMap(xml, _lin_lut_xml);
1206
1207 const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml =
1208 getCompressionLutXmlFromCoder(_transcoder, _tag, split_by_crate);
1209 addLutMap(xml, _comp_lut_xml);
1210
1211 const std::map<int, std::shared_ptr<LutXml>> _HE_FG_lut_xml = getHEFineGrainLUTs(_tag, split_by_crate);
1212 addLutMap(xml, _HE_FG_lut_xml);
1213
1214 writeLutXmlFiles(xml, _tag, split_by_crate);
1215
1216 std::string checksums_file = _tag + "_checksums.xml";
1217 lut_checksums_xml->write(checksums_file);
1218
1219 return 0;
1220 }
1221
1222 int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii(std::string _tag,
1223 const HcalTPGCoder& _coder,
1224 std::string _lin_file,
1225 bool split_by_crate) {
1226 std::map<int, std::shared_ptr<LutXml>> xml;
1227 if (!lut_checksums_xml) {
1228 lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1229 }
1230
1231 if (!_lin_file.empty()) {
1232 const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
1233 getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
1234 addLutMap(xml, _lin_lut_ascii_xml);
1235 }
1236 const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
1237 getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
1238 addLutMap(xml, _lin_lut_xml);
1239
1240 const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml = getCompressionLutXmlFromCoder(_tag, split_by_crate);
1241 addLutMap(xml, _comp_lut_xml);
1242
1243 writeLutXmlFiles(xml, _tag, split_by_crate);
1244
1245 std::string checksums_file = _tag + "_checksums.xml";
1246 lut_checksums_xml->write(checksums_file);
1247
1248 return 0;
1249 }
1250
1251
1252 int HcalLutManager::createAllLutXmlFilesLinAsciiCompCoder(std::string _tag,
1253 std::string _lin_file,
1254 bool split_by_crate) {
1255
1256 std::map<int, std::shared_ptr<LutXml>> xml;
1257 if (!lut_checksums_xml) {
1258 lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1259 }
1260
1261 if (!_lin_file.empty()) {
1262 addLutMap(xml, getLutXmlFromAsciiMaster(_lin_file, _tag, -1, split_by_crate));
1263 }
1264 addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
1265 writeLutXmlFiles(xml, _tag, split_by_crate);
1266
1267 std::string checksums_file = _tag + "_checksums.xml";
1268 lut_checksums_xml->write(checksums_file);
1269
1270 return 0;
1271 }
1272
1273 void HcalLutManager::addLutMap(std::map<int, std::shared_ptr<LutXml>>& result,
1274 const std::map<int, std::shared_ptr<LutXml>>& other) {
1275 for (std::map<int, std::shared_ptr<LutXml>>::const_iterator lut = other.begin(); lut != other.end(); lut++) {
1276 edm::LogInfo("HcalLutManager") << "Added LUTs for crate " << lut->first;
1277 if (result.count(lut->first) == 0) {
1278 result.insert(*lut);
1279 } else {
1280 *(result[lut->first]) += *(lut->second);
1281 }
1282 }
1283 }
1284
1285 string HcalLutManager::get_time_stamp(time_t _time) {
1286 char timebuf[50];
1287
1288 strftime(timebuf, 50, "%Y-%m-%d %H:%M:%S", gmtime(&_time));
1289 std::string creationstamp = timebuf;
1290
1291 return creationstamp;
1292 }
1293
1294 int HcalLutManager::test_xml_access(std::string _tag, std::string _filename) {
1295 local_connect(_filename, "backup/HCALmapHBEF.txt", "backup/HCALmapHO.txt");
1296
1297
1298 EMap _emap(emap);
1299 std::vector<EMap::EMapRow>& _map = _emap.get_map();
1300 int map_size = _map.size();
1301 edm::LogInfo("HcalLutManager") << "EMap contains " << map_size << " channels";
1302
1303
1304 std::vector<unsigned int> _lut;
1305 _lut = getLutFromXml(_tag, 1107313727, hcal::ConfigurationDatabase::LinearizerLUT);
1306
1307 edm::LogInfo("HcalLutManager") << "Testing direct parsing of the LUT XML";
1308 struct timeval _t;
1309 gettimeofday(&_t, nullptr);
1310 double _time = (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0;
1311 test_direct_xml_parsing(_filename);
1312 gettimeofday(&_t, nullptr);
1313 edm::LogInfo("HcalLutManager") << "parsing took that much time: "
1314 << (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0 - _time;
1315
1316 gettimeofday(&_t, nullptr);
1317 _time = (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0;
1318 edm::LogInfo("HcalLutManager") << "before loop over random LUTs: " << _time;
1319 int _raw_id;
1320
1321
1322 for (int _iter = 0; _iter < 100; _iter++) {
1323 gettimeofday(&_t, nullptr);
1324
1325
1326
1327 while (true) {
1328 int _key = (rand() % map_size);
1329
1330 if ((_map[_key].subdet.find("HB") != string::npos || _map[_key].subdet.find("HE") != string::npos ||
1331 _map[_key].subdet.find("HO") != string::npos || _map[_key].subdet.find("HF") != string::npos) &&
1332 _map[_key].subdet.size() == 2) {
1333 HcalSubdetector _subdet;
1334 if (_map[_key].subdet.find("HB") != string::npos)
1335 _subdet = HcalBarrel;
1336 else if (_map[_key].subdet.find("HE") != string::npos)
1337 _subdet = HcalEndcap;
1338 else if (_map[_key].subdet.find("HO") != string::npos)
1339 _subdet = HcalOuter;
1340 else if (_map[_key].subdet.find("HF") != string::npos)
1341 _subdet = HcalForward;
1342 else
1343 _subdet = HcalOther;
1344 HcalDetId _detid(_subdet, _map[_key].ieta, _map[_key].iphi, _map[_key].idepth);
1345 _raw_id = _detid.rawId();
1346 break;
1347 }
1348 }
1349 _lut = getLutFromXml(_tag, _raw_id, hcal::ConfigurationDatabase::LinearizerLUT);
1350
1351 gettimeofday(&_t, nullptr);
1352 }
1353 double d_time = _t.tv_sec + _t.tv_usec / 1000000.0 - _time;
1354 edm::LogInfo("HcalLutManager") << "after the loop over random LUTs: " << _time + d_time << std::endl
1355 << "total time: " << d_time << std::endl;
1356
1357 edm::LogInfo("HcalLutManager") << "LUT length = " << _lut.size();
1358 for (std::vector<unsigned int>::const_iterator i = _lut.end() - 1; i != _lut.begin() - 1; i--) {
1359 edm::LogInfo("HcalLutManager") << (i - _lut.begin()) << " " << _lut[(i - _lut.begin())];
1360 break;
1361 }
1362
1363 db->disconnect();
1364
1365 delete db;
1366 db = nullptr;
1367
1368 return 0;
1369 }
1370
1371 int HcalLutManager::read_lmap(std::string lmap_hbef_file, std::string lmap_ho_file) {
1372 delete lmap;
1373 lmap = new LMap();
1374 lmap->read(lmap_hbef_file, "HBEF");
1375 lmap->read(lmap_ho_file, "HO");
1376 edm::LogInfo("HcalLutManager") << "LMap contains " << lmap->get_map().size()
1377 << " channels (compare to 9072 of all HCAL channels)";
1378 return 0;
1379 }
1380
1381 int HcalLutManager::read_luts(std::string lut_xml_file) {
1382 delete db;
1383 db = new HCALConfigDB();
1384 db->connect(lut_xml_file);
1385 return 0;
1386 }
1387
1388 int HcalLutManager::local_connect(std::string lut_xml_file, std::string lmap_hbef_file, std::string lmap_ho_file) {
1389 read_lmap(lmap_hbef_file, lmap_ho_file);
1390 read_luts(lut_xml_file);
1391 return 0;
1392 }
1393
1394 std::vector<unsigned int> HcalLutManager::getLutFromXml(std::string tag,
1395 uint32_t _rawid,
1396 hcal::ConfigurationDatabase::LUTType _lt) {
1397 edm::LogInfo("HcalLutManager") << "getLutFromXml (new version) is not implemented. Use getLutFromXml_old() for now";
1398
1399 std::vector<unsigned int> result;
1400
1401 return result;
1402 }
1403
1404
1405 std::vector<unsigned int> HcalLutManager::getLutFromXml_old(std::string tag,
1406 uint32_t _rawid,
1407 hcal::ConfigurationDatabase::LUTType _lt) {
1408 if (!lmap) {
1409 edm::LogError("HcalLutManager") << "Cannot find LUT without LMAP, exiting...";
1410 exit(-1);
1411 }
1412 if (!db) {
1413 edm::LogError("HcalLutManager") << "Cannot find LUT, no source (local XML file), exiting...";
1414 exit(-1);
1415 }
1416
1417 std::vector<unsigned int> result;
1418
1419 std::map<int, LMapRow>& _map = lmap->get_map();
1420
1421
1422 HcalDetId _id(_rawid);
1423
1424 unsigned int _crate, _slot, _fiber, _channel;
1425 std::string _fpga;
1426 int topbottom, luttype;
1427
1428
1429 if (_map.find(_rawid) != _map.end()) {
1430 _crate = _map[_rawid].crate;
1431 _slot = _map[_rawid].htr;
1432 _fiber = _map[_rawid].htr_fi;
1433 _channel = _map[_rawid].fi_ch;
1434 _fpga = _map[_rawid].fpga;
1435
1436 if (_fpga.find("top") != std::string::npos)
1437 topbottom = 1;
1438 else if (_fpga.find("bot") != std::string::npos)
1439 topbottom = 0;
1440 else {
1441 edm::LogError("HcalLutManager") << "Irregular LMAP fpga value... do not know what to do - exiting";
1442 exit(-1);
1443 }
1444 if (_lt == hcal::ConfigurationDatabase::LinearizerLUT)
1445 luttype = 1;
1446 else
1447 luttype = 2;
1448
1449 result = db->getOnlineLUT(tag, _crate, _slot, topbottom, _fiber, _channel, luttype);
1450 }
1451
1452 return result;
1453 }
1454
1455 int HcalLutManager::get_xml_files_from_db(std::string tag, const std::string db_accessor, bool split_by_crate) {
1456 std::map<int, std::shared_ptr<LutXml>> lut_map = get_brickSet_from_oracle(tag, db_accessor);
1457 if (split_by_crate) {
1458 writeLutXmlFiles(lut_map, tag, split_by_crate);
1459 } else {
1460 LutXml result;
1461 for (std::map<int, std::shared_ptr<LutXml>>::const_iterator xml = lut_map.begin(); xml != lut_map.end(); xml++) {
1462 result += *(xml->second);
1463 }
1464 std::stringstream out_file;
1465 out_file << tag << ".xml";
1466 result.write(out_file.str());
1467 }
1468
1469 return 0;
1470 }
1471
1472 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::get_brickSet_from_oracle(std::string tag,
1473 const std::string _accessor) {
1474 HCALConfigDB* db = new HCALConfigDB();
1475 XMLProcessor::getInstance();
1476
1477 db->connect(_accessor);
1478 oracle::occi::Connection* _connection = db->getConnection();
1479
1480 edm::LogInfo("HcalLutManager") << "Preparing to request the LUT CLOBs from the database...";
1481
1482
1483
1484
1485
1486
1487
1488 std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB, CRATE FROM CMS_HCL_HCAL_COND.V_HCAL_TRIG_LOOKUP_TABLES");
1489
1490 query += toolbox::toString(" WHERE TAG_NAME='%s'", tag.c_str());
1491
1492 std::string brick_set;
1493
1494 std::map<int, std::shared_ptr<LutXml>> lut_map;
1495
1496 try {
1497
1498 edm::LogInfo("HcalLutManager") << "Executing the query...";
1499 Statement* stmt = _connection->createStatement();
1500 ResultSet* rs = stmt->executeQuery(query);
1501 edm::LogInfo("HcalLutManager") << "Executing the query... done";
1502
1503 edm::LogInfo("HcalLutManager") << "Processing the query results...";
1504
1505 while (rs->next()) {
1506
1507 oracle::occi::Clob clob = rs->getClob(1);
1508 int crate = rs->getInt(2);
1509 if (crate != -1) {
1510 edm::LogInfo("HcalLutManager") << "Getting LUTs for crate #" << crate << " out of the database...";
1511 brick_set = db->clobToString(clob);
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521 const char* bs = brick_set.c_str();
1522 MemBufInputSource* lut_clob = new MemBufInputSource((const XMLByte*)bs, strlen(bs), "lut_clob", false);
1523 std::shared_ptr<LutXml> lut_xml = std::make_shared<LutXml>(*lut_clob);
1524 lut_map[crate] = lut_xml;
1525 edm::LogInfo("HcalLutManager") << "done";
1526 }
1527 }
1528
1529 _connection->terminateStatement(stmt);
1530
1531 } catch (SQLException& e) {
1532 XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,
1533 ::toolbox::toString("Oracle exception : %s", e.getMessage().c_str()));
1534 }
1535
1536
1537
1538 db->disconnect();
1539
1540 return lut_map;
1541 }
1542
1543 int HcalLutManager::create_lut_loader(std::string file_list,
1544 std::string _prefix,
1545 std::string tag_name,
1546 std::string comment,
1547 std::string version,
1548 int subversion) {
1549 edm::LogInfo("HcalLutManager") << "Generating XML loader for LUTs...";
1550
1551
1552 XMLLUTLoader::loaderBaseConfig baseConf;
1553 XMLLUTLoader::lutDBConfig conf;
1554 XMLLUTLoader::checksumsDBConfig CSconf;
1555
1556 baseConf.tag_name = tag_name;
1557
1558 baseConf.comment_description = comment;
1559 baseConf.iov_begin = "1";
1560 baseConf.iov_end = "-1";
1561
1562 conf.version = version;
1563
1564 std::stringstream _subversion;
1565 _subversion << subversion;
1566 conf.subversion = _subversion.str();
1567
1568 CSconf.version = conf.version;
1569 CSconf.subversion = conf.subversion;
1570 CSconf.trig_prim_lookuptbl_data_file = _prefix + "_checksums.xml.dat";
1571 CSconf.comment_description = tag_name;
1572
1573 XMLLUTLoader doc(&baseConf);
1574
1575 std::vector<int> crate_number;
1576 std::vector<std::string> file_name = HcalQIEManager::splitString(file_list);
1577 for (std::vector<std::string>::const_iterator _f = file_name.begin(); _f != file_name.end(); _f++) {
1578 int crate_begin = _f->rfind("_");
1579 int crate_end = _f->rfind(".xml.dat");
1580 crate_number.push_back(getInt(_f->substr(crate_begin + 1, crate_end - crate_begin - 1)));
1581 }
1582
1583
1584
1585 char _buf[128];
1586 time_t _offset = time(nullptr);
1587 sprintf(_buf, "%d", (uint32_t)_offset);
1588 conf.version.append(".");
1589 conf.version.append(_buf);
1590 CSconf.version = conf.version;
1591
1592 for (std::vector<std::string>::const_iterator _file = file_name.begin(); _file != file_name.end(); _file++) {
1593 conf.trig_prim_lookuptbl_data_file = *_file;
1594
1595 conf.crate = crate_number[_file - file_name.begin()];
1596
1597
1598
1599 sprintf(_buf, "%.2d", conf.crate);
1600 conf.subversion.clear();
1601 conf.subversion.append(_buf);
1602 sprintf(_buf, "CRATE%.2d", conf.crate);
1603 std::string _namelabel;
1604 _namelabel.append(_buf);
1605 conf.name_label = _namelabel;
1606 doc.addLUT(&conf);
1607 }
1608
1609 doc.addChecksums(&CSconf);
1610
1611 doc.write(tag_name + "_Loader.xml");
1612
1613 edm::LogInfo("HcalLutManager") << "Generating XML loader for LUTs... done.";
1614
1615 return 0;
1616 }
1617
1618 void HcalLutManager::test_emap(void) {
1619
1620
1621
1622 EMap _emap(emap);
1623 std::vector<EMap::EMapRow>& _map = _emap.get_map();
1624 std::stringstream s;
1625 s << "EMap contains " << _map.size() << " channels" << std::endl;
1626
1627
1628
1629 for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1630
1631 if (row->subdet.find("HT") != std::string::npos) {
1632 s << " -----> Subdet = " << row->subdet << std::endl;
1633
1634 if (abs(row->ieta) > 28) {
1635
1636 s << " ==> (ieta,iphi) = " << row->ieta << ", " << row->iphi << std::endl;
1637 }
1638 }
1639 }
1640 edm::LogInfo("HcalLutManager") << s.str();
1641 }
1642
1643 int HcalLutManager::test_direct_xml_parsing(std::string _filename) {
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669 return 0;
1670 }
1671
1672
1673
1674
1675 int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii_ZDC(std::string _tag,
1676 const HcalTPGCoder& _coder,
1677 const CaloTPGTranscoderULUT& _transcoder,
1678 std::string _lin_file,
1679 bool split_by_crate) {
1680 std::map<int, std::shared_ptr<LutXml>> xml;
1681 if (!lut_checksums_xml) {
1682 lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1683 }
1684
1685 if (!_lin_file.empty()) {
1686 const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
1687 getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
1688 addLutMap(xml, _lin_lut_ascii_xml);
1689 }
1690 const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
1691 getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
1692 addLutMap(xml, _lin_lut_xml);
1693
1694 const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml =
1695 getCompressionLutXmlFromCoder(_transcoder, _tag, split_by_crate);
1696 addLutMap(xml, _comp_lut_xml);
1697
1698 const std::map<int, std::shared_ptr<LutXml>> _HE_FG_lut_xml = getHEFineGrainLUTs(_tag, split_by_crate);
1699 addLutMap(xml, _HE_FG_lut_xml);
1700
1701 for (auto masktype : {0, 1, 2}) {
1702 const auto masks = getMasks(masktype, _tag, split_by_crate);
1703 addLutMap(xml, masks);
1704 }
1705
1706
1707 writeLutXmlFiles(xml, _tag, split_by_crate);
1708
1709 std::string checksums_file = _tag + "_checksums.xml";
1710 lut_checksums_xml->write(checksums_file);
1711
1712 return 0;
1713 }
1714
1715 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getZdcLutXml(std::string _tag, bool split_by_crate) {
1716 edm::LogInfo("HcalLutManager") << "Generating ZDC LUTs ...may the Force be with us...";
1717 std::map<int, std::shared_ptr<LutXml>> _xml;
1718
1719 EMap _emap(emap);
1720
1721 ZdcLut zdc;
1722
1723 std::vector<EMap::EMapRow>& _map = _emap.get_map();
1724 edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
1725
1726
1727 RooGKCounter _counter;
1728 for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1729 LutXml::Config _cfg;
1730
1731
1732 if (row->zdc_section.find("ZDC") != std::string::npos) {
1733 if (_xml.count(row->crate) == 0 && split_by_crate) {
1734 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
1735 } else if (_xml.count(0) == 0 && !split_by_crate) {
1736 _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
1737 }
1738
1739 _cfg.ieta = row->zdc_channel;
1740
1741
1742 _cfg.depth = row->idepth;
1743 _cfg.crate = row->crate;
1744 _cfg.slot = row->slot;
1745 if (row->topbottom.find('t') != std::string::npos)
1746 _cfg.topbottom = 1;
1747 else if (row->topbottom.find('b') != std::string::npos)
1748 _cfg.topbottom = 0;
1749 else
1750 edm::LogWarning("HcalLutManager") << "fpga out of range...";
1751 _cfg.fiber = row->fiber;
1752 _cfg.fiberchan = row->fiberchan;
1753 _cfg.lut_type = 1;
1754 _cfg.creationtag = _tag;
1755 _cfg.creationstamp = get_time_stamp(time(nullptr));
1756 _cfg.targetfirmware = "1.0.0";
1757 _cfg.formatrevision = "1";
1758 _cfg.generalizedindex = 0;
1759
1760
1761
1762 std::vector<int> coder_lut = zdc.get_lut(row->zdc_section, row->zdc_zside, row->zdc_channel);
1763 edm::LogInfo("HcalLutManager") << "***DEBUG: ZDC lut size: " << coder_lut.size();
1764 if (!coder_lut.empty()) {
1765 for (std::vector<int>::const_iterator _i = coder_lut.begin(); _i != coder_lut.end(); _i++) {
1766 unsigned int _temp = (unsigned int)(*_i);
1767
1768
1769 _cfg.lut.push_back(_temp);
1770 }
1771
1772
1773 if (split_by_crate) {
1774 _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
1775 _counter.count();
1776 } else {
1777 _xml[0]->addLut(_cfg, lut_checksums_xml);
1778 _counter.count();
1779 }
1780 }
1781 }
1782 }
1783 edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
1784 << "Generating ZDC LUTs...DONE" << std::endl;
1785
1786 return _xml;
1787 }