CMS 3D CMS Logo
HcalLutManager.cc
Go to the documentation of this file.
1 #include <cstdlib>
2 #include <fstream>
3 #include <memory>
4 #include <sstream>
5 #include <sys/stat.h>
6 #include <sys/time.h>
7 #include <sys/types.h>
8 #include <unistd.h>
9 
10 #include <cstdlib> // For srand() and rand()
11 
12 #ifdef HAVE_XDAQ
13 #include <toolbox/string.h>
14 #else
15 #include "CaloOnlineTools/HcalOnlineDb/interface/xdaq_compat.h" // Replaces toolbox::toString
16 #endif
17 
18 #include "OnlineDB/Oracle/interface/Oracle.h"
19 
20 #include "FWCore/MessageLogger/interface/MessageLogger.h"
21 
22 #include "CaloOnlineTools/HcalOnlineDb/interface/HcalLutManager.h"
23 #include "CaloOnlineTools/HcalOnlineDb/interface/ZdcLut.h"
24 #include "CalibCalorimetry/HcalTPGAlgos/interface/XMLProcessor.h"
25 #include "CalibCalorimetry/HcalTPGAlgos/interface/XMLDOMBlock.h"
26 #include "CaloOnlineTools/HcalOnlineDb/interface/HcalQIEManager.h"
27 #include "CaloOnlineTools/HcalOnlineDb/interface/LMap.h"
28 #include "CaloOnlineTools/HcalOnlineDb/interface/XMLLUTLoader.h"
29 #include "CaloOnlineTools/HcalOnlineDb/interface/RooGKCounter.h"
30 #include "DataFormats/HcalDetId/interface/HcalDetId.h"
31 
32 #include "DataFormats/HcalDetId/interface/HcalSubdetector.h"
33 XERCES_CPP_NAMESPACE_USE
34 using namespace std;
35 using namespace oracle::occi;
36 using namespace hcal;
37 
46 HcalLutManager::HcalLutManager(void) { init(); }
47 
48 HcalLutManager::HcalLutManager(std::vector<HcalGenericDetId>& map) {
49  init();
50  _iter.init(map);
51 }
52 
53 HcalLutManager::HcalLutManager(const HcalElectronicsMap* _emap,
54  const HcalChannelQuality* _cq,
55  uint32_t _status_word_to_mask) {
56  init();
57  emap = _emap;
58  cq = _cq;
59  status_word_to_mask = _status_word_to_mask;
60 }
61 
62 HcalLutManager::HcalLutManager(const HcalDbService* _conditions,
63  const HcalChannelQuality* _cq,
64  uint32_t _status_word_to_mask) {
65  init();
66  conditions = _conditions;
67  emap = conditions->getHcalMapping();
68  cq = _cq;
69  status_word_to_mask = _status_word_to_mask;
70 }
71 
72 void HcalLutManager::init(void) {
73  lut_xml = nullptr;
74  lut_checksums_xml = nullptr;
75  db = nullptr;
76  lmap = nullptr;
77  emap = nullptr;
78  cq = nullptr;
79  conditions = nullptr;
80  status_word_to_mask = 0x0000;
81 }
82 
83 HcalLutManager::~HcalLutManager(void) {
84  delete lut_xml;
85  delete lut_checksums_xml;
86  delete db;
87  delete lmap;
88 }
89 
90 int HcalLutManager::initChannelIterator(std::vector<HcalGenericDetId>& map) {
91  _iter.init(map);
92  return _iter.size();
93 }
94 
95 std::string& HcalLutManager::getLutXml(std::vector<unsigned int>& _lut) {
96  if (lut_xml)
97  delete lut_xml;
98 
99  lut_xml = new LutXml();
100 
101  LutXml::Config _config;
102  _config.lut = _lut;
103  lut_xml->addLut(_config);
104  lut_xml->addLut(_config);
105  lut_xml->addLut(_config);
106 
107  //return lut_xml->getString();
108  return lut_xml->getCurrentBrick();
109 }
110 
111 int HcalLutManager::getInt(std::string number) {
112  int result;
113  sscanf(number.c_str(), "%d", &result);
114  return result;
115 }
116 
117 HcalSubdetector HcalLutManager::get_subdetector(std::string _det) {
118  HcalSubdetector result;
119  if (_det.find("HB") != std::string::npos)
120  result = HcalBarrel;
121  else if (_det.find("HE") != std::string::npos)
122  result = HcalEndcap;
123  else if (_det.find("HF") != std::string::npos)
124  result = HcalForward;
125  else if (_det.find("HO") != std::string::npos)
126  result = HcalOuter;
127  else
128  result = HcalOther;
129 
130  return result;
131 }
132 
133 int HcalLutManager_test::getLutSetFromFile_test(std::string _filename) {
134  HcalLutManager _manager;
135  HcalLutSet _set = _manager.getLutSetFromFile(_filename);
136  std::stringstream s;
137  s << "===> Test of HcalLutSet HcalLutManager::getLutSetFromFile( std::string _filename )" << std::endl << std::endl;
138  s << _set.label << std::endl;
139  for (unsigned int i = 0; i != _set.subdet.size(); i++)
140  s << _set.subdet[i] << " ";
141  s << std::endl;
142  for (unsigned int i = 0; i != _set.eta_min.size(); i++)
143  s << _set.eta_min[i] << " ";
144  s << std::endl;
145  for (unsigned int i = 0; i != _set.eta_max.size(); i++)
146  s << _set.eta_max[i] << " ";
147  s << std::endl;
148  for (unsigned int i = 0; i != _set.phi_min.size(); i++)
149  s << _set.phi_min[i] << " ";
150  s << std::endl;
151  for (unsigned int i = 0; i != _set.phi_max.size(); i++)
152  s << _set.phi_max[i] << " ";
153  s << std::endl;
154  for (unsigned int i = 0; i != _set.depth_min.size(); i++)
155  s << _set.depth_min[i] << " ";
156  s << std::endl;
157  for (unsigned int i = 0; i != _set.depth_max.size(); i++)
158  s << _set.depth_max[i] << " ";
159  s << std::endl;
160  for (unsigned int j = 0; j != _set.lut[0].size(); j++) {
161  for (unsigned int i = 0; i != _set.lut.size(); i++) {
162  s << _set.lut[i][j] << " ";
163  }
164  s << "---> " << j << std::endl;
165  }
166  edm::LogInfo("HcalLutManager") << s.str();
167  return 0;
168 }
169 
170 HcalLutSet HcalLutManager::getLutSetFromFile(std::string _filename, int _type) {
171  HcalLutSet _lutset;
172 
173  ifstream infile(_filename.c_str());
174  std::string buf;
175 
176  if (infile.is_open()) {
177  edm::LogInfo("HcalLutManager") << "File " << _filename << " is open..." << std::endl
178  << "Reading LUTs and their eta/phi/depth/subdet ranges...";
179 
180  // get label
181  getline(infile, _lutset.label);
182 
183  if (_type == 1) { // for linearization LUTs get subdetectors (default)
184  //get subdetectors
185  getline(infile, buf);
186  _lutset.subdet = HcalQIEManager::splitString(buf);
187  }
188 
189  //get min etas
190  std::vector<std::string> buf_vec;
191  getline(infile, buf);
192  buf_vec = HcalQIEManager::splitString(buf);
193  for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
194  _lutset.eta_min.push_back(HcalLutManager::getInt(*iter));
195  }
196 
197  //get max etas
198  getline(infile, buf);
199  buf_vec = HcalQIEManager::splitString(buf);
200  for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
201  _lutset.eta_max.push_back(HcalLutManager::getInt(*iter));
202  }
203 
204  //get min phis
205  getline(infile, buf);
206  buf_vec = HcalQIEManager::splitString(buf);
207  for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
208  _lutset.phi_min.push_back(HcalLutManager::getInt(*iter));
209  }
210 
211  //get max phis
212  getline(infile, buf);
213  buf_vec = HcalQIEManager::splitString(buf);
214  for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
215  _lutset.phi_max.push_back(HcalLutManager::getInt(*iter));
216  }
217 
218  if (_type == 1) { // for linearization LUTs get depth range (default)
219  //get min depths
220  getline(infile, buf);
221  buf_vec = HcalQIEManager::splitString(buf);
222  for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
223  _lutset.depth_min.push_back(HcalLutManager::getInt(*iter));
224  }
225 
226  //get max depths
227  getline(infile, buf);
228  buf_vec = HcalQIEManager::splitString(buf);
229  for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
230  _lutset.depth_max.push_back(HcalLutManager::getInt(*iter));
231  }
232  }
233 
234  bool first_lut_entry = true;
235  while (getline(infile, buf)) {
236  buf_vec = HcalQIEManager::splitString(buf);
237  for (unsigned int i = 0; i < buf_vec.size(); i++) {
238  if (first_lut_entry) {
239  std::vector<unsigned int> _l;
240  _lutset.lut.push_back(_l);
241  }
242  _lutset.lut[i].push_back(HcalLutManager::getInt(buf_vec[i]));
243  }
244  first_lut_entry = false;
245  }
246  }
247 
248  edm::LogInfo("HcalLutManager") << "done.";
249 
250  return _lutset;
251 }
252 
253 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLutXmlFromAsciiMaster(std::string _filename,
254  std::string _tag,
255  int _crate,
256  bool split_by_crate) {
257  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
258  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
259 
260  LMap _lmap;
261  _lmap.read("./backup/HCALmapHBEF.txt", "HBEF");
262  _lmap.read("./backup/HCALmapHO.txt", "HO");
263  std::map<int, LMapRow>& _map = _lmap.get_map();
264  edm::LogInfo("HcalLutManager") << "LMap contains " << _map.size() << " channels";
265 
266  // read LUTs and their eta/phi/depth/subdet ranges
267  HcalLutSet _set = getLutSetFromFile(_filename);
268  int lut_set_size = _set.lut.size(); // number of different luts
269 
270  RooGKCounter _counter;
271  //loop over all HCAL channels
272  for (std::map<int, LMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
273  LutXml::Config _cfg;
274 
275  // search for the correct LUT for a given channel,
276  // higher LUT numbers have priority in case of overlapping
277  int lut_index = -1;
278  for (int i = 0; i < lut_set_size; i++) {
279  if ((row->second.crate == _crate || _crate == -1) && // -1 stands for all crates
280  _set.eta_min[i] <= row->second.side * row->second.eta &&
281  _set.eta_max[i] >= row->second.side * row->second.eta && _set.phi_min[i] <= row->second.phi &&
282  _set.phi_max[i] >= row->second.phi && _set.depth_min[i] <= row->second.depth &&
283  _set.depth_max[i] >= row->second.depth && get_subdetector(_set.subdet[i]) == row->second.det) {
284  lut_index = i;
285  }
286  }
287  if (lut_index >= 0) {
288  if (_xml.count(row->second.crate) == 0 && split_by_crate) {
289  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->second.crate, std::make_shared<LutXml>()));
290  } else if (_xml.count(0) == 0 && !split_by_crate) {
291  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
292  }
293  _cfg.ieta = row->second.side * row->second.eta;
294  _cfg.iphi = row->second.phi;
295  _cfg.depth = row->second.depth;
296  _cfg.crate = row->second.crate;
297  _cfg.slot = row->second.htr;
298  if (row->second.fpga.find("top") != std::string::npos)
299  _cfg.topbottom = 1;
300  else if (row->second.fpga.find("bot") != std::string::npos)
301  _cfg.topbottom = 0;
302  else
303  edm::LogWarning("HcalLutManager") << "fpga out of range...";
304  // FIXME: probably fixed. fiber==htr_fi, not rm_fi in LMAP notation.
305  //_cfg.fiber = row->second.rm_fi;
306  _cfg.fiber = row->second.htr_fi;
307  _cfg.fiberchan = row->second.fi_ch;
308  if (_set.lut[lut_index].size() == 128)
309  _cfg.lut_type = 1;
310  else
311  _cfg.lut_type = 2;
312  _cfg.creationtag = _tag;
313  _cfg.creationstamp = get_time_stamp(time(nullptr));
314  _cfg.targetfirmware = "1.0.0";
315  _cfg.formatrevision = "1"; //???
316  // "original" definition of GENERALIZEDINDEX from Mike Weinberger
317  // int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
318  // ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
319  _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->second.side > 0) * 100 + row->second.eta +
320  ((row->second.det == HcalForward && row->second.eta == 29) ? (4 * 10000) : (0));
321  _cfg.lut = _set.lut[lut_index];
322  if (split_by_crate) {
323  _xml[row->second.crate]->addLut(_cfg, lut_checksums_xml);
324  _counter.count();
325  } else {
326  _xml[0]->addLut(_cfg, lut_checksums_xml);
327  _counter.count();
328  }
329  }
330  }
331  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
332  << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
333  return _xml;
334 }
335 
336 //
337 //_____ get HO from ASCII master here ___________________________________
338 //
339 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLinearizationLutXmlFromAsciiMasterEmap(std::string _filename,
340  std::string _tag,
341  int _crate,
342  bool split_by_crate) {
343  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
344  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
345 
346  EMap _emap(emap);
347  std::vector<EMap::EMapRow>& _map = _emap.get_map();
348  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
349 
350  // read LUTs and their eta/phi/depth/subdet ranges
351  HcalLutSet _set = getLutSetFromFile(_filename);
352  int lut_set_size = _set.lut.size(); // number of different luts
353  edm::LogInfo("HcalLutManager") << " ==> " << lut_set_size << " sets of different LUTs read from the master file";
354 
355  // setup "zero" LUT for channel masking
356  std::vector<unsigned int> zeroLut;
357  for (size_t adc = 0; adc < 128; adc++)
358  zeroLut.push_back(0);
359 
360  RooGKCounter _counter;
361  //loop over all EMap channels
362  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
363  if ((row->subdet.find("HB") != string::npos || row->subdet.find("HE") != string::npos ||
364  row->subdet.find("HO") != string::npos || row->subdet.find("HF") != string::npos) &&
365  row->subdet.size() == 2) {
366  LutXml::Config _cfg;
367 
368  // search for the correct LUT for a given channel,
369  // higher LUT numbers have priority in case of overlapping
370  int lut_index = -1;
371  for (int i = 0; i < lut_set_size; i++) {
372  if ((row->crate == _crate || _crate == -1) && // -1 stands for all crates
373  _set.eta_min[i] <= row->ieta && _set.eta_max[i] >= row->ieta && _set.phi_min[i] <= row->iphi &&
374  _set.phi_max[i] >= row->iphi && _set.depth_min[i] <= row->idepth && _set.depth_max[i] >= row->idepth &&
375  _set.subdet[i].find(row->subdet) != string::npos) {
376  lut_index = i;
377  }
378  }
379  if (lut_index >= 0) {
380  if (_xml.count(row->crate) == 0 && split_by_crate) {
381  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
382  } else if (_xml.count(0) == 0 && !split_by_crate) {
383  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
384  }
385  _cfg.ieta = row->ieta;
386  _cfg.iphi = row->iphi;
387  _cfg.depth = row->idepth;
388  _cfg.crate = row->crate;
389  _cfg.slot = row->slot;
390  if (row->topbottom.find("t") != std::string::npos)
391  _cfg.topbottom = 1;
392  else if (row->topbottom.find("b") != std::string::npos)
393  _cfg.topbottom = 0;
394  else if (row->topbottom.find("u") != std::string::npos)
395  _cfg.topbottom = 2;
396  else
397  edm::LogWarning("HcalLutManager") << "fpga out of range...";
398  _cfg.fiber = row->fiber;
399  _cfg.fiberchan = row->fiberchan;
400  _cfg.lut_type = 1;
401  _cfg.creationtag = _tag;
402  _cfg.creationstamp = get_time_stamp(time(nullptr));
403  _cfg.targetfirmware = "1.0.0";
404  _cfg.formatrevision = "1"; //???
405  // "original" definition of GENERALIZEDINDEX from Mike Weinberger
406  // int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
407  // ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
408  _cfg.generalizedindex =
409  _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
410  (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
411  //
412  // consider channel status here
413  DetId _detId(row->rawId);
414  uint32_t status_word = cq->getValues(_detId)->getValue();
415  if ((status_word & status_word_to_mask) > 0) {
416  _cfg.lut = zeroLut;
417  } else {
418  _cfg.lut = _set.lut[lut_index];
419  }
420  if (split_by_crate) {
421  _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
422  _counter.count();
423  } else {
424  _xml[0]->addLut(_cfg, lut_checksums_xml);
425  _counter.count();
426  }
427  }
428  }
429  }
430  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
431  << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
432  return _xml;
433 }
434 
435 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLinearizationLutXmlFromAsciiMasterEmap_new(
436  std::string _filename, std::string _tag, int _crate, bool split_by_crate) {
437  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
438  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
439 
440  // read LUTs and their eta/phi/depth/subdet ranges
441  HcalLutSet _set = getLutSetFromFile(_filename);
442  int lut_set_size = _set.lut.size(); // number of different luts
443  edm::LogInfo("HcalLutManager") << " ==> " << lut_set_size << " sets of different LUTs read from the master file";
444 
445  RooGKCounter _counter;
446  //loop over all EMap channels
447  for (_iter.begin(); !_iter.end(); _iter.next()) {
448  HcalSubdetector _subdet = _iter.getHcalSubdetector();
449  if ((_subdet == HcalBarrel || _subdet == HcalEndcap || _subdet == HcalForward || _subdet == HcalOuter)) {
450  int _ieta = _iter.getIeta();
451  int _iphi = _iter.getIphi();
452  int _depth = _iter.getDepth();
453 
454  // FIXME: this is probably wrong, raw ids are different
455  HcalElectronicsId _eId(_iter.getHcalGenericDetId().rawId());
456  int aCrate = _eId.readoutVMECrateId();
457  int aSlot = _eId.htrSlot();
458  int aTopBottom = _eId.htrTopBottom();
459  int aFiber = _eId.fiberIndex();
460  int aFiberChan = _eId.fiberChanId();
461 
462  LutXml::Config _cfg;
463 
464  // search for the correct LUT for a given channel,
465  // higher LUT numbers have priority in case of overlapping
466  int lut_index = -1;
467  for (int i = 0; i < lut_set_size; i++) {
468  if ((aCrate == _crate || _crate == -1) && // -1 stands for all crates
469  _set.eta_min[i] <= _ieta && _set.eta_max[i] >= _ieta && _set.phi_min[i] <= _iphi &&
470  _set.phi_max[i] >= _iphi && _set.depth_min[i] <= _depth && _set.depth_max[i] >= _depth &&
471  _set.subdet[i].find(_ass.getSubdetectorString(_subdet)) != string::npos) {
472  lut_index = i;
473  }
474  }
475  if (lut_index >= 0) {
476  if (_xml.count(aCrate) == 0 && split_by_crate) {
477  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(aCrate, std::make_shared<LutXml>()));
478  } else if (_xml.count(0) == 0 && !split_by_crate) {
479  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
480  }
481  _cfg.ieta = _ieta;
482  _cfg.iphi = _iphi;
483  _cfg.depth = _depth;
484  _cfg.crate = aCrate;
485  _cfg.slot = aSlot;
486  _cfg.topbottom = aTopBottom;
487  _cfg.fiber = aFiber;
488  _cfg.fiberchan = aFiberChan;
489  _cfg.lut_type = 1;
490  _cfg.creationtag = _tag;
491  _cfg.creationstamp = get_time_stamp(time(nullptr));
492  _cfg.targetfirmware = "1.0.0";
493  _cfg.formatrevision = "1"; //???
494  // "original" definition of GENERALIZEDINDEX from Mike Weinberger
495  // int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
496  // ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
497  _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (_ieta > 0) * 100 + abs(_ieta) +
498  (((_subdet == HcalForward) && abs(_ieta) == 29) ? (4 * 10000) : (0));
499  _cfg.lut = _set.lut[lut_index];
500  if (split_by_crate) {
501  _xml[aCrate]->addLut(_cfg, lut_checksums_xml);
502  _counter.count();
503  } else {
504  _xml[0]->addLut(_cfg, lut_checksums_xml);
505  _counter.count();
506  }
507  }
508  }
509  }
510  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
511  << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
512  return _xml;
513 }
514 
515 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getCompressionLutXmlFromAsciiMaster(std::string _filename,
516  std::string _tag,
517  int _crate,
518  bool split_by_crate) {
519  edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from ascii master file...";
520  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
521 
522  edm::LogInfo("HcalLutManager")
523  << "instantiating CaloTPGTranscoderULUT in order to check the validity of (ieta,iphi)...";
524  CaloTPGTranscoderULUT _coder;
525 
526  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
527  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
528  EMap _emap(emap);
529  std::vector<EMap::EMapRow>& _map = _emap.get_map();
530  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
531 
532  // read LUTs and their eta/phi/depth/subdet ranges
533  HcalLutSet _set = getLutSetFromFile(_filename, 2);
534  int lut_set_size = _set.lut.size(); // number of different luts
535  edm::LogInfo("HcalLutManager") << " ==> " << lut_set_size << " sets of different LUTs read from the master file";
536 
537  //loop over all EMap channels
538  RooGKCounter _counter;
539  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
540  LutXml::Config _cfg;
541 
542  // search for the correct LUT for a given channel,
543  // higher LUT numbers have priority in case of overlapping
544  int lut_index = -1;
545  for (int i = 0; i < lut_set_size; i++) {
546  if (row->subdet.find("HT") != std::string::npos &&
547  (row->crate == _crate || _crate == -1) && // -1 stands for all crates
548  _set.eta_min[i] <= row->ieta && _set.eta_max[i] >= row->ieta && _set.phi_min[i] <= row->iphi &&
549  _set.phi_max[i] >= row->iphi && _coder.HTvalid(row->ieta, row->iphi, row->idepth / 10)) {
550  lut_index = i;
551  }
552  }
553  if (lut_index >= 0) {
554  if (_xml.count(row->crate) == 0 && split_by_crate) {
555  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
556  } else if (_xml.count(0) == 0 && !split_by_crate) {
557  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
558  }
559  _cfg.ieta = row->ieta;
560  _cfg.iphi = row->iphi;
561  _cfg.depth = row->idepth;
562  _cfg.crate = row->crate;
563  _cfg.slot = row->slot;
564  if (row->topbottom.find("t") != std::string::npos)
565  _cfg.topbottom = 1;
566  else if (row->topbottom.find("b") != std::string::npos)
567  _cfg.topbottom = 0;
568  else if (row->topbottom.find("u") != std::string::npos)
569  _cfg.topbottom = 2;
570  else
571  edm::LogWarning("HcalLutManager") << "fpga out of range...";
572  _cfg.fiber = row->fiber;
573  _cfg.fiberchan = row->fiberchan;
574  if (_set.lut[lut_index].size() == 128)
575  _cfg.lut_type = 1;
576  else
577  _cfg.lut_type = 2;
578  _cfg.creationtag = _tag;
579  _cfg.creationstamp = get_time_stamp(time(nullptr));
580  _cfg.targetfirmware = "1.0.0";
581  _cfg.formatrevision = "1"; //???
582  // "original" definition of GENERALIZEDINDEX from Mike Weinberger
583  // int generalizedIndex=id.ietaAbs()+10000*id.iphi()+
584  // ((id.ieta()<0)?(0):(100));
585  _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);
586  _cfg.lut = _set.lut[lut_index];
587  if (split_by_crate) {
588  _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
589  _counter.count();
590  } else {
591  _xml[0]->addLut(_cfg, lut_checksums_xml);
592  _counter.count();
593  }
594  }
595  }
596  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
597  << "Generating compression (output) LUTs from ascii master file...DONE" << std::endl;
598  return _xml;
599 }
600 
601 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLinearizationLutXmlFromCoder(const HcalTPGCoder& _coder,
602  std::string _tag,
603  bool split_by_crate) {
604  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...";
605  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
606 
607  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
608  //std::vector<EMap::EMapRow> & _map = _emap.get_map();
609  //std::cout << "EMap contains " << _map . size() << " entries" << std::endl;
610 
611  LMap _lmap;
612  _lmap.read("backup/HCALmapHBEF.txt", "HBEF");
613  // HO is not part of trigger, so TPGCoder cannot generate LUTs for it
614  //_lmap . read( "backup/HCALmapHO.txt", "HO" );
615  std::map<int, LMapRow>& _map = _lmap.get_map();
616  edm::LogInfo("HcalLutManager") << "LMap contains " << _map.size() << " channels";
617 
618  // read LUTs and their eta/phi/depth/subdet ranges
619  //HcalLutSet _set = getLinearizationLutSetFromCoder();
620  //int lut_set_size = _set.lut.size(); // number of different luts
621 
622  //loop over all HCAL channels
623  RooGKCounter _counter;
624  for (std::map<int, LMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
625  LutXml::Config _cfg;
626 
627  if (_xml.count(row->second.crate) == 0 && split_by_crate) {
628  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->second.crate, std::make_shared<LutXml>()));
629  } else if (_xml.count(0) == 0 && !split_by_crate) {
630  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
631  }
632  _cfg.ieta = row->second.side * row->second.eta;
633  _cfg.iphi = row->second.phi;
634  _cfg.depth = row->second.depth;
635  _cfg.crate = row->second.crate;
636  _cfg.slot = row->second.htr;
637  if (row->second.fpga.find("top") != std::string::npos)
638  _cfg.topbottom = 1;
639  else if (row->second.fpga.find("bot") != std::string::npos)
640  _cfg.topbottom = 0;
641  else
642  edm::LogWarning("HcalLutManager") << "fpga out of range...";
643  // FIXME: probably fixed. fiber==htr_fi, not rm_fi in LMAP notation.
644  //_cfg.fiber = row->second.rm_fi;
645  _cfg.fiber = row->second.htr_fi;
646  _cfg.fiberchan = row->second.fi_ch;
647  _cfg.lut_type = 1;
648  _cfg.creationtag = _tag;
649  _cfg.creationstamp = get_time_stamp(time(nullptr));
650  _cfg.targetfirmware = "1.0.0";
651  _cfg.formatrevision = "1"; //???
652  // "original" definition of GENERALIZEDINDEX from Mike Weinberger
653  // int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
654  // ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
655  _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->second.side > 0) * 100 + row->second.eta +
656  ((row->second.det == HcalForward && row->second.eta == 29) ? (4 * 10000) : (0));
657 
658  //HcalDetId _detid(row->first);
659  HcalDetId _detid(row->second.det, row->second.side * row->second.eta, row->second.phi, row->second.depth);
660  //std::cout << "### DEBUG: rawid = " << _detid.rawId() << std::endl;
661 
662  //std::cout << "### DEBUG: subdetector = " << row->second.det << std::endl;
663  std::vector<unsigned short> coder_lut = _coder.getLinearizationLUT(_detid);
664  for (std::vector<unsigned short>::const_iterator _i = coder_lut.begin(); _i != coder_lut.end(); _i++) {
665  unsigned int _temp = (unsigned int)(*_i);
666  //if (_temp!=0) std::cout << "DEBUG non-zero LUT!!!!!!!!!!!!!!!" << (*_i) << " " << _temp << std::endl;
667  //unsigned int _temp = 0;
668  _cfg.lut.push_back(_temp);
669  }
670  if (split_by_crate) {
671  _xml[row->second.crate]->addLut(_cfg, lut_checksums_xml);
672  _counter.count();
673  } else {
674  _xml[0]->addLut(_cfg, lut_checksums_xml);
675  _counter.count();
676  }
677  }
678  edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
679  << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
680  return _xml;
681 }
682 
683 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getMasks(int masktype, std::string _tag, bool split_by_crate) {
684  edm::LogInfo("HcalLutManager") << "Generating TDC masks...";
685 
686  EMap _emap(emap);
687  std::vector<EMap::EMapRow>& _map = _emap.get_map();
688  edm::LogInfo("HcalLutManager") << "EMap contains new" << _map.size() << " entries";
689 
690  std::map<int, std::vector<uint64_t>> masks;
691 
692  for (const auto& row : _map) {
693  std::string subdet = row.subdet;
694  if (subdet != "HF")
695  continue;
696  int crate = row.crate;
697  int slot = row.slot;
698  int crot = 100 * crate + slot;
699  int fiber = row.fiber;
700  int channel = row.fiberchan;
701  unsigned int finel = 4 * fiber + channel;
702  if (masks.count(crot) == 0)
703  masks[crot] = {};
704  if (finel >= masks[crot].size())
705  masks[crot].resize(finel + 1);
706 
707  if (masktype == 0) {
708  HcalSubdetector _subdet;
709  if (row.subdet.find("HB") != string::npos)
710  _subdet = HcalBarrel;
711  else if (row.subdet.find("HE") != string::npos)
712  _subdet = HcalEndcap;
713  else if (row.subdet.find("HO") != string::npos)
714  _subdet = HcalOuter;
715  else if (row.subdet.find("HF") != string::npos)
716  _subdet = HcalForward;
717  else
718  _subdet = HcalOther;
719  HcalDetId _detid(_subdet, row.ieta, row.iphi, row.idepth);
720  masks[crot][finel] = conditions->getHcalTPChannelParameter(_detid)->getMask();
721  } else {
722  auto parameters = conditions->getHcalTPParameters();
723  masks[crot][finel] = masktype == 1 ? parameters->getADCThresholdHF() : parameters->getTDCMaskHF();
724  }
725  }
726 
727  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
728  RooGKCounter _counter;
729 
730  for (const auto& i : masks) {
731  int crot = i.first;
732  int crate = crot / 100;
733 
734  LutXml::Config _cfg;
735  _cfg.lut_type = 5 + masktype;
736  _cfg.crate = crate;
737  _cfg.slot = crot % 100;
738  _cfg.generalizedindex = crot;
739  _cfg.mask = i.second;
740  _cfg.creationtag = _tag;
741  _cfg.targetfirmware = "1.0.0";
742  _cfg.formatrevision = "1";
743 
744  int c = split_by_crate ? crate : 0;
745  if (_xml.count(c) == 0)
746  _xml[c] = std::make_shared<LutXml>();
747 
748  _xml[c]->addLut(_cfg);
749  _counter.count();
750  }
751 
752  edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
753  << "Generating Masks...DONE" << std::endl;
754  return _xml;
755 }
756 
757 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getLinearizationLutXmlFromCoderEmap(const HcalTPGCoder& _coder,
758  std::string _tag,
759  bool split_by_crate) {
760  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...";
761  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
762 
763  EMap _emap(emap);
764  std::vector<EMap::EMapRow>& _map = _emap.get_map();
765  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
766 
767  RooGKCounter _counter;
768  //loop over all EMap channels
769  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
770  if ((row->subdet.find("HB") != string::npos || row->subdet.find("HE") != string::npos ||
771  row->subdet.find("HF") != string::npos) &&
772  row->subdet.size() == 2) {
773  LutXml::Config _cfg;
774 
775  if (_xml.count(row->crate) == 0 && split_by_crate) {
776  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
777  } else if (_xml.count(0) == 0 && !split_by_crate) {
778  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
779  }
780  _cfg.ieta = row->ieta;
781  _cfg.iphi = row->iphi;
782  _cfg.depth = row->idepth;
783  _cfg.crate = row->crate;
784  _cfg.slot = row->slot;
785  if (row->topbottom.find("t") != std::string::npos)
786  _cfg.topbottom = 1;
787  else if (row->topbottom.find("b") != std::string::npos)
788  _cfg.topbottom = 0;
789  else if (row->topbottom.find("u") != std::string::npos)
790  _cfg.topbottom = 2;
791  else
792  edm::LogWarning("HcalLutManager") << "fpga out of range...";
793  _cfg.fiber = row->fiber;
794  _cfg.fiberchan = row->fiberchan;
795  _cfg.lut_type = 1;
796  _cfg.creationtag = _tag;
797  _cfg.creationstamp = get_time_stamp(time(nullptr));
798  _cfg.targetfirmware = "1.0.0";
799  _cfg.formatrevision = "1"; //???
800  // "original" definition of GENERALIZEDINDEX from Mike Weinberger
801  // int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
802  // ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
803  _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
804  (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
805  HcalSubdetector _subdet;
806  if (row->subdet.find("HB") != string::npos)
807  _subdet = HcalBarrel;
808  else if (row->subdet.find("HE") != string::npos)
809  _subdet = HcalEndcap;
810  else if (row->subdet.find("HO") != string::npos)
811  _subdet = HcalOuter;
812  else if (row->subdet.find("HF") != string::npos)
813  _subdet = HcalForward;
814  else
815  _subdet = HcalOther;
816  HcalDetId _detid(_subdet, row->ieta, row->iphi, row->idepth);
817 
818  for (const auto i : _coder.getLinearizationLUT(_detid))
819  _cfg.lut.push_back(i);
820 
821  if (split_by_crate) {
822  _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
823  _counter.count();
824  } else {
825  _xml[0]->addLut(_cfg, lut_checksums_xml);
826  _counter.count();
827  }
828  }
829  }
830  edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
831  << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
832  return _xml;
833 }
834 
835 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getHEFineGrainLUTs(std::string _tag, bool split_by_crate) {
836  edm::LogInfo("HcalLutManager") << "Generating HE fine grain LUTs";
837  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
838 
839  EMap _emap(emap);
840  std::vector<EMap::EMapRow>& _map = _emap.get_map();
841  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
842 
843  RooGKCounter _counter;
844  //loop over all EMap channels
845  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
846  if (row->subdet.find("HT") != string::npos && row->subdet.size() == 2) {
847  int abseta = abs(row->ieta);
848  const HcalTopology* topo = cq->topo();
849  if (abseta <= topo->lastHBRing() or abseta > topo->lastHERing())
850  continue;
851  if (abseta >= topo->firstHEDoublePhiRing() and row->fiberchan % 2 == 1)
852  continue; //do only actual physical towers
853  LutXml::Config _cfg;
854 
855  if (_xml.count(row->crate) == 0 && split_by_crate) {
856  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
857  } else if (_xml.count(0) == 0 && !split_by_crate) {
858  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
859  }
860  _cfg.ieta = row->ieta;
861  _cfg.iphi = row->iphi;
862  _cfg.depth = row->idepth;
863  _cfg.crate = row->crate;
864  _cfg.slot = row->slot;
865  if (row->topbottom.find("t") != std::string::npos)
866  _cfg.topbottom = 1;
867  else if (row->topbottom.find("b") != std::string::npos)
868  _cfg.topbottom = 0;
869  else if (row->topbottom.find("u") != std::string::npos)
870  _cfg.topbottom = 2;
871  else
872  edm::LogWarning("HcalLutManager") << "fpga out of range...";
873  _cfg.fiber = row->fiber;
874  _cfg.fiberchan = row->fiberchan;
875  _cfg.lut_type = 4;
876  _cfg.creationtag = _tag;
877  _cfg.creationstamp = get_time_stamp(time(nullptr));
878  _cfg.targetfirmware = "1.0.0";
879  _cfg.formatrevision = "1"; //???
880  _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
881  (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
882  // fine grain LUTs only relevant for HE
883  HcalSubdetector _subdet = HcalEndcap;
884  HcalDetId _detid(_subdet, row->ieta, row->iphi, row->idepth);
885 
886  HcalFinegrainBit fg_algo(conditions->getHcalTPParameters()->getFGVersionHBHE());
887 
888  // loop over all possible configurations,
889  // computing the LUT for each
890  const int n_fgab_bits = 2048;
891  for (int i = 0; i < 2 * n_fgab_bits; i++) {
892  HcalFinegrainBit::Tower tow;
893  for (int k = 0; k < 6; k++) {
894  tow[0][k] = (1 << k) & i;
895  tow[1][k] = (1 << (k + 6)) & i;
896  }
897  _cfg.lut.push_back(fg_algo.compute(tow).to_ulong());
898  }
899 
900  if (split_by_crate) {
901  _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
902  _counter.count();
903  } else {
904  _xml[0]->addLut(_cfg, lut_checksums_xml);
905  _counter.count();
906  }
907  }
908  }
909  edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
910  << "Generating HE fine grain LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
911  return _xml;
912 }
913 
914 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getCompressionLutXmlFromCoder(
915  const CaloTPGTranscoderULUT& _coder, std::string _tag, bool split_by_crate) {
916  edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from CaloTPGTranscoderULUT," << std::endl
917  << "initialized from Event Setup" << std::endl;
918  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
919 
920  EMap _emap(emap);
921 
922  std::map<int, unsigned int> maxsize;
923 
924  std::vector<EMap::EMapRow>& _map = _emap.get_map();
925  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
926 
927  //need to equalize compression LUT size in each crate-slot, needed for mixed uHTR
928  for (const auto& row : _map) {
929  if (row.subdet.find("HT") == std::string::npos)
930  continue;
931  HcalTrigTowerDetId _detid(row.rawId);
932  if (!cq->topo()->validHT(_detid))
933  continue;
934  int crot = 100 * row.crate + row.slot;
935  unsigned int size = _coder.getCompressionLUT(_detid).size();
936  if (maxsize.count(crot) == 0 || size > maxsize[crot])
937  maxsize[crot] = size;
938  }
939 
940  RooGKCounter _counter;
941  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
942  LutXml::Config _cfg;
943 
944  if (row->subdet.find("HT") == std::string::npos)
945  continue;
946 
947  HcalTrigTowerDetId _detid(row->rawId);
948 
949  if (!cq->topo()->validHT(_detid))
950  continue;
951 
952  if (_xml.count(row->crate) == 0 && split_by_crate) {
953  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
954  } else if (_xml.count(0) == 0 && !split_by_crate) {
955  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
956  }
957 
958  _cfg.ieta = row->ieta;
959  _cfg.iphi = row->iphi;
960  _cfg.depth = row->idepth;
961  _cfg.crate = row->crate;
962  _cfg.slot = row->slot;
963  if (row->topbottom.find("t") != std::string::npos)
964  _cfg.topbottom = 1;
965  else if (row->topbottom.find("b") != std::string::npos)
966  _cfg.topbottom = 0;
967  else if (row->topbottom.find("u") != std::string::npos)
968  _cfg.topbottom = 2;
969  else
970  edm::LogWarning("HcalLutManager") << "fpga out of range...";
971  _cfg.fiber = row->fiber;
972  _cfg.fiberchan = row->fiberchan;
973  _cfg.lut_type = 2;
974  _cfg.creationtag = _tag;
975  _cfg.creationstamp = get_time_stamp(time(nullptr));
976  _cfg.targetfirmware = "1.0.0";
977  _cfg.formatrevision = "1"; //???
978  _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta); //is this used for anything?
979 
980  _cfg.lut = _coder.getCompressionLUT(_detid);
981 
982  int crot = 100 * row->crate + row->slot;
983  unsigned int size = _cfg.lut.size();
984  if (size < maxsize[crot]) {
985  edm::LogWarning("HcalLutManager") << " resizing LUT for " << _detid << ", channel=[" << _cfg.crate << ":"
986  << _cfg.slot << ":" << _cfg.fiber << ":" << _cfg.fiberchan
987  << "], using value=" << _cfg.lut[size - 1] << std::endl;
988  for (unsigned int i = size; i < maxsize[crot]; ++i)
989  _cfg.lut.push_back(_cfg.lut[size - 1]);
990  }
991 
992  if (split_by_crate) {
993  _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
994  _counter.count();
995  } else {
996  _xml[0]->addLut(_cfg, lut_checksums_xml);
997  _counter.count();
998  }
999  }
1000  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
1001  << "Generating compression (output) LUTs from CaloTPGTranscoderULUT...DONE"
1002  << std::endl;
1003 
1004  return _xml;
1005 }
1006 
1007 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getCompressionLutXmlFromCoder(std::string _tag,
1008  bool split_by_crate) {
1009  edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from CaloTPGTranscoderULUT";
1010  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
1011 
1012  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v5_080208.txt");
1013  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
1014  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
1015  EMap _emap(emap);
1016 
1017  std::vector<EMap::EMapRow>& _map = _emap.get_map();
1018  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
1019 
1020  // read LUTs and their eta/phi/depth/subdet ranges
1021  //HcalLutSet _set = getLutSetFromFile( _filename, 2 );
1022  //int lut_set_size = _set.lut.size(); // number of different luts
1023 
1024  CaloTPGTranscoderULUT _coder;
1025 
1026  //loop over all EMap channels
1027  RooGKCounter _counter;
1028  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1029  LutXml::Config _cfg;
1030 
1031  // only trigger tower channels
1032  // and valid (ieta,iphi)
1033  const int tp_version = row->idepth / 10;
1034  if (row->subdet.find("HT") != std::string::npos && _coder.HTvalid(row->ieta, row->iphi, tp_version)) {
1035  if (_xml.count(row->crate) == 0 && split_by_crate) {
1036  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
1037  } else if (_xml.count(0) == 0 && !split_by_crate) {
1038  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
1039  }
1040  _cfg.ieta = row->ieta;
1041  _cfg.iphi = row->iphi;
1042  _cfg.depth = row->idepth;
1043  _cfg.crate = row->crate;
1044  _cfg.slot = row->slot;
1045  if (row->topbottom.find("t") != std::string::npos)
1046  _cfg.topbottom = 1;
1047  else if (row->topbottom.find("b") != std::string::npos)
1048  _cfg.topbottom = 0;
1049  else if (row->topbottom.find("u") != std::string::npos)
1050  _cfg.topbottom = 2;
1051  else
1052  edm::LogWarning("HcalLutManager") << "fpga out of range...";
1053  _cfg.fiber = row->fiber;
1054  _cfg.fiberchan = row->fiberchan;
1055  _cfg.lut_type = 2;
1056  _cfg.creationtag = _tag;
1057  _cfg.creationstamp = get_time_stamp(time(nullptr));
1058  _cfg.targetfirmware = "1.0.0";
1059  _cfg.formatrevision = "1"; //???
1060  // "original" definition of GENERALIZEDINDEX from Mike Weinberger
1061  // int generalizedIndex=id.ietaAbs()+10000*id.iphi()+
1062  // ((id.ieta()<0)?(0):(100));
1063  _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);
1064 
1065  // FIXME: work around bug in emap v6: rawId wasn't filled
1066  //HcalTrigTowerDetId _detid(row->rawId);
1067  HcalTrigTowerDetId _detid(row->ieta, row->iphi);
1068 
1069  _cfg.lut = _coder.getCompressionLUT(_detid);
1070 
1071  if (split_by_crate) {
1072  _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
1073  _counter.count();
1074  } else {
1075  _xml[0]->addLut(_cfg, lut_checksums_xml);
1076  _counter.count();
1077  }
1078  }
1079  }
1080  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
1081  << "Generating compression (output) LUTs from CaloTPGTranscoderULUT...DONE"
1082  << std::endl;
1083  return _xml;
1084 }
1085 
1086 int HcalLutManager::writeLutXmlFiles(std::map<int, std::shared_ptr<LutXml>>& _xml,
1087  std::string _tag,
1088  bool split_by_crate) {
1089  for (std::map<int, std::shared_ptr<LutXml>>::const_iterator cr = _xml.begin(); cr != _xml.end(); cr++) {
1090  std::stringstream output_file_name;
1091  if (split_by_crate) {
1092  output_file_name << _tag << "_" << cr->first << ".xml";
1093  } else {
1094  output_file_name << _tag << ".xml";
1095  }
1096  cr->second->write(output_file_name.str());
1097  }
1098  return 0;
1099 }
1100 
1101 int HcalLutManager::createLinLutXmlFiles(std::string _tag, std::string _lin_file, bool split_by_crate) {
1102  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
1103  std::map<int, std::shared_ptr<LutXml>> xml;
1104  if (!lut_checksums_xml) {
1105  lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1106  }
1107 
1108  if (!_lin_file.empty()) {
1109  addLutMap(xml, getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate));
1110  }
1111  writeLutXmlFiles(xml, _tag, split_by_crate);
1112 
1113  std::string checksums_file = _tag + "_checksums.xml";
1114  lut_checksums_xml->write(checksums_file);
1115 
1116  return 0;
1117 }
1118 
1119 int HcalLutManager::createAllLutXmlFiles(std::string _tag,
1120  std::string _lin_file,
1121  std::string _comp_file,
1122  bool split_by_crate) {
1123  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
1124  std::map<int, std::shared_ptr<LutXml>> xml;
1125  if (!lut_checksums_xml) {
1126  lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1127  }
1128 
1129  if (!_lin_file.empty()) {
1130  //addLutMap( xml, getLutXmlFromAsciiMaster( _lin_file, _tag, -1, split_by_crate ) );
1131  addLutMap(xml, getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate));
1132  }
1133  if (!_comp_file.empty()) {
1134  //std::cout << "DEBUG1!!!!" << std::endl;
1135  addLutMap(xml, getCompressionLutXmlFromAsciiMaster(_comp_file, _tag, -1, split_by_crate));
1136  //std::cout << "DEBUG2!!!!" << std::endl;
1137  }
1138  writeLutXmlFiles(xml, _tag, split_by_crate);
1139 
1140  std::string checksums_file = _tag + "_checksums.xml";
1141  lut_checksums_xml->write(checksums_file);
1142 
1143  return 0;
1144 }
1145 
1146 int HcalLutManager::createCompLutXmlFilesFromCoder(std::string _tag, bool split_by_crate) {
1147  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
1148  std::map<int, std::shared_ptr<LutXml>> xml;
1149  if (!lut_checksums_xml) {
1150  lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1151  }
1152 
1153  addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
1154 
1155  writeLutXmlFiles(xml, _tag, split_by_crate);
1156 
1157  std::string checksums_file = _tag + "_checksums.xml";
1158  lut_checksums_xml->write(checksums_file);
1159 
1160  return 0;
1161 }
1162 
1163 int HcalLutManager::createAllLutXmlFilesFromCoder(const HcalTPGCoder& _coder, std::string _tag, bool split_by_crate) {
1164  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
1165  std::map<int, std::shared_ptr<LutXml>> xml;
1166  if (!lut_checksums_xml) {
1167  lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1168  }
1169 
1170  //addLutMap( xml, getLinearizationLutXmlFromCoder( _coder, _tag, split_by_crate ) );
1171  addLutMap(xml, getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate));
1172  addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
1173 
1174  writeLutXmlFiles(xml, _tag, split_by_crate);
1175 
1176  std::string checksums_file = _tag + "_checksums.xml";
1177  lut_checksums_xml->write(checksums_file);
1178 
1179  return 0;
1180 }
1181 
1182 //
1183 //_____ use this for creating a full set of LUTs ________________________
1184 //
1185 int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii(std::string _tag,
1186  const HcalTPGCoder& _coder,
1187  const CaloTPGTranscoderULUT& _transcoder,
1188  std::string _lin_file,
1189  bool split_by_crate) {
1190  std::map<int, std::shared_ptr<LutXml>> xml;
1191  if (!lut_checksums_xml) {
1192  lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1193  }
1194 
1195  if (!_lin_file.empty()) {
1196  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
1197  getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
1198  addLutMap(xml, _lin_lut_ascii_xml);
1199  }
1200  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
1201  getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
1202  addLutMap(xml, _lin_lut_xml);
1203  //
1204  const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml =
1205  getCompressionLutXmlFromCoder(_transcoder, _tag, split_by_crate);
1206  addLutMap(xml, _comp_lut_xml);
1207 
1208  const std::map<int, std::shared_ptr<LutXml>> _HE_FG_lut_xml = getHEFineGrainLUTs(_tag, split_by_crate);
1209  addLutMap(xml, _HE_FG_lut_xml);
1210 
1211  writeLutXmlFiles(xml, _tag, split_by_crate);
1212 
1213  std::string checksums_file = _tag + "_checksums.xml";
1214  lut_checksums_xml->write(checksums_file);
1215 
1216  return 0;
1217 }
1218 
1219 int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii(std::string _tag,
1220  const HcalTPGCoder& _coder,
1221  std::string _lin_file,
1222  bool split_by_crate) {
1223  std::map<int, std::shared_ptr<LutXml>> xml;
1224  if (!lut_checksums_xml) {
1225  lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1226  }
1227 
1228  if (!_lin_file.empty()) {
1229  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
1230  getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
1231  addLutMap(xml, _lin_lut_ascii_xml);
1232  }
1233  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
1234  getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
1235  addLutMap(xml, _lin_lut_xml);
1236  //
1237  const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml = getCompressionLutXmlFromCoder(_tag, split_by_crate);
1238  addLutMap(xml, _comp_lut_xml);
1239 
1240  writeLutXmlFiles(xml, _tag, split_by_crate);
1241 
1242  std::string checksums_file = _tag + "_checksums.xml";
1243  lut_checksums_xml->write(checksums_file);
1244 
1245  return 0;
1246 }
1247 
1248 // use this to create HBEF only from coders (physics LUTs)
1249 int HcalLutManager::createAllLutXmlFilesLinAsciiCompCoder(std::string _tag,
1250  std::string _lin_file,
1251  bool split_by_crate) {
1252  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
1253  std::map<int, std::shared_ptr<LutXml>> xml;
1254  if (!lut_checksums_xml) {
1255  lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1256  }
1257 
1258  if (!_lin_file.empty()) {
1259  addLutMap(xml, getLutXmlFromAsciiMaster(_lin_file, _tag, -1, split_by_crate));
1260  }
1261  addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
1262  writeLutXmlFiles(xml, _tag, split_by_crate);
1263 
1264  std::string checksums_file = _tag + "_checksums.xml";
1265  lut_checksums_xml->write(checksums_file);
1266 
1267  return 0;
1268 }
1269 
1270 void HcalLutManager::addLutMap(std::map<int, std::shared_ptr<LutXml>>& result,
1271  const std::map<int, std::shared_ptr<LutXml>>& other) {
1272  for (std::map<int, std::shared_ptr<LutXml>>::const_iterator lut = other.begin(); lut != other.end(); lut++) {
1273  edm::LogInfo("HcalLutManager") << "Added LUTs for crate " << lut->first;
1274  if (result.count(lut->first) == 0) {
1275  result.insert(*lut);
1276  } else {
1277  *(result[lut->first]) += *(lut->second);
1278  }
1279  }
1280 }
1281 
1282 string HcalLutManager::get_time_stamp(time_t _time) {
1283  char timebuf[50];
1284  //strftime( timebuf, 50, "%c", gmtime( &_time ) );
1285  strftime(timebuf, 50, "%Y-%m-%d %H:%M:%S", gmtime(&_time));
1286  std::string creationstamp = timebuf;
1287 
1288  return creationstamp;
1289 }
1290 
1291 int HcalLutManager::test_xml_access(std::string _tag, std::string _filename) {
1292  local_connect(_filename, "backup/HCALmapHBEF.txt", "backup/HCALmapHO.txt");
1293 
1294  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
1295  EMap _emap(emap);
1296  std::vector<EMap::EMapRow>& _map = _emap.get_map();
1297  int map_size = _map.size();
1298  edm::LogInfo("HcalLutManager") << "EMap contains " << map_size << " channels";
1299 
1300  // make sure that all init is done
1301  std::vector<unsigned int> _lut;
1302  _lut = getLutFromXml(_tag, 1107313727, hcal::ConfigurationDatabase::LinearizerLUT);
1303 
1304  edm::LogInfo("HcalLutManager") << "Testing direct parsing of the LUT XML";
1305  struct timeval _t;
1306  gettimeofday(&_t, nullptr);
1307  double _time = (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0;
1308  test_direct_xml_parsing(_filename);
1309  gettimeofday(&_t, nullptr);
1310  edm::LogInfo("HcalLutManager") << "parsing took that much time: "
1311  << (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0 - _time;
1312 
1313  gettimeofday(&_t, nullptr);
1314  _time = (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0;
1315  edm::LogInfo("HcalLutManager") << "before loop over random LUTs: " << _time;
1316  int _raw_id;
1317 
1318  // loop over random LUTs
1319  for (int _iter = 0; _iter < 100; _iter++) {
1320  gettimeofday(&_t, nullptr);
1321  //std::cout << "before getting a LUT: " << _t . tv_sec << "." << _t . tv_usec << std::endl;
1322 
1323  // select valid random emap channel
1324  while (true) {
1325  int _key = (rand() % map_size);
1326  //_key = 3356;
1327  if ((_map[_key].subdet.find("HB") != string::npos || _map[_key].subdet.find("HE") != string::npos ||
1328  _map[_key].subdet.find("HO") != string::npos || _map[_key].subdet.find("HF") != string::npos) &&
1329  _map[_key].subdet.size() == 2) {
1330  HcalSubdetector _subdet;
1331  if (_map[_key].subdet.find("HB") != string::npos)
1332  _subdet = HcalBarrel;
1333  else if (_map[_key].subdet.find("HE") != string::npos)
1334  _subdet = HcalEndcap;
1335  else if (_map[_key].subdet.find("HO") != string::npos)
1336  _subdet = HcalOuter;
1337  else if (_map[_key].subdet.find("HF") != string::npos)
1338  _subdet = HcalForward;
1339  else
1340  _subdet = HcalOther;
1341  HcalDetId _detid(_subdet, _map[_key].ieta, _map[_key].iphi, _map[_key].idepth);
1342  _raw_id = _detid.rawId();
1343  break;
1344  }
1345  }
1346  _lut = getLutFromXml(_tag, _raw_id, hcal::ConfigurationDatabase::LinearizerLUT);
1347 
1348  gettimeofday(&_t, nullptr);
1349  }
1350  double d_time = _t.tv_sec + _t.tv_usec / 1000000.0 - _time;
1351  edm::LogInfo("HcalLutManager") << "after the loop over random LUTs: " << _time + d_time << std::endl
1352  << "total time: " << d_time << std::endl;
1353 
1354  edm::LogInfo("HcalLutManager") << "LUT length = " << _lut.size();
1355  for (std::vector<unsigned int>::const_iterator i = _lut.end() - 1; i != _lut.begin() - 1; i--) {
1356  edm::LogInfo("HcalLutManager") << (i - _lut.begin()) << " " << _lut[(i - _lut.begin())];
1357  break;
1358  }
1359 
1360  db->disconnect();
1361 
1362  delete db;
1363  db = nullptr;
1364 
1365  return 0;
1366 }
1367 
1368 int HcalLutManager::read_lmap(std::string lmap_hbef_file, std::string lmap_ho_file) {
1369  delete lmap;
1370  lmap = new LMap();
1371  lmap->read(lmap_hbef_file, "HBEF");
1372  lmap->read(lmap_ho_file, "HO");
1373  edm::LogInfo("HcalLutManager") << "LMap contains " << lmap->get_map().size()
1374  << " channels (compare to 9072 of all HCAL channels)";
1375  return 0;
1376 }
1377 
1378 int HcalLutManager::read_luts(std::string lut_xml_file) {
1379  delete db;
1380  db = new HCALConfigDB();
1381  db->connect(lut_xml_file);
1382  return 0;
1383 }
1384 
1385 int HcalLutManager::local_connect(std::string lut_xml_file, std::string lmap_hbef_file, std::string lmap_ho_file) {
1386  read_lmap(lmap_hbef_file, lmap_ho_file);
1387  read_luts(lut_xml_file);
1388  return 0;
1389 }
1390 
1391 std::vector<unsigned int> HcalLutManager::getLutFromXml(std::string tag,
1392  uint32_t _rawid,
1393  hcal::ConfigurationDatabase::LUTType _lt) {
1394  edm::LogInfo("HcalLutManager") << "getLutFromXml (new version) is not implemented. Use getLutFromXml_old() for now";
1395 
1396  std::vector<unsigned int> result;
1397 
1398  return result;
1399 }
1400 
1401 // obsolete, use getLutFromXml() instead
1402 std::vector<unsigned int> HcalLutManager::getLutFromXml_old(std::string tag,
1403  uint32_t _rawid,
1404  hcal::ConfigurationDatabase::LUTType _lt) {
1405  if (!lmap) {
1406  edm::LogError("HcalLutManager") << "Cannot find LUT without LMAP, exiting...";
1407  exit(-1);
1408  }
1409  if (!db) {
1410  edm::LogError("HcalLutManager") << "Cannot find LUT, no source (local XML file), exiting...";
1411  exit(-1);
1412  }
1413 
1414  std::vector<unsigned int> result;
1415 
1416  std::map<int, LMapRow>& _map = lmap->get_map();
1417  //std::cout << "HcalLutManager: LMap contains " << _map . size() << " channels (out of 9072 total)" << std::endl;
1418 
1419  HcalDetId _id(_rawid);
1420 
1421  unsigned int _crate, _slot, _fiber, _channel;
1422  std::string _fpga;
1423  int topbottom, luttype;
1424 
1425  // FIXME: check validity of _rawid
1426  if (_map.find(_rawid) != _map.end()) {
1427  _crate = _map[_rawid].crate;
1428  _slot = _map[_rawid].htr;
1429  _fiber = _map[_rawid].htr_fi;
1430  _channel = _map[_rawid].fi_ch;
1431  _fpga = _map[_rawid].fpga;
1432 
1433  if (_fpga.find("top") != std::string::npos)
1434  topbottom = 1;
1435  else if (_fpga.find("bot") != std::string::npos)
1436  topbottom = 0;
1437  else {
1438  edm::LogError("HcalLutManager") << "Irregular LMAP fpga value... do not know what to do - exiting";
1439  exit(-1);
1440  }
1441  if (_lt == hcal::ConfigurationDatabase::LinearizerLUT)
1442  luttype = 1;
1443  else
1444  luttype = 2;
1445 
1446  result = db->getOnlineLUT(tag, _crate, _slot, topbottom, _fiber, _channel, luttype);
1447  }
1448 
1449  return result;
1450 }
1451 
1452 int HcalLutManager::get_xml_files_from_db(std::string tag, const std::string db_accessor, bool split_by_crate) {
1453  std::map<int, std::shared_ptr<LutXml>> lut_map = get_brickSet_from_oracle(tag, db_accessor);
1454  if (split_by_crate) {
1455  writeLutXmlFiles(lut_map, tag, split_by_crate);
1456  } else {
1457  LutXml result;
1458  for (std::map<int, std::shared_ptr<LutXml>>::const_iterator xml = lut_map.begin(); xml != lut_map.end(); xml++) {
1459  result += *(xml->second);
1460  }
1461  std::stringstream out_file;
1462  out_file << tag << ".xml";
1463  result.write(out_file.str());
1464  }
1465 
1466  return 0;
1467 }
1468 
1469 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::get_brickSet_from_oracle(std::string tag,
1470  const std::string _accessor) {
1471  HCALConfigDB* db = new HCALConfigDB();
1472  XMLProcessor::getInstance(); // initialize xerces-c engine
1473  //const std::string _accessor = "occi://CMS_HCL_PRTTYPE_HCAL_READER@anyhost/int2r?PASSWORD=HCAL_Reader_88,LHWM_VERSION=22";
1474  db->connect(_accessor);
1475  oracle::occi::Connection* _connection = db->getConnection();
1476 
1477  edm::LogInfo("HcalLutManager") << "Preparing to request the LUT CLOBs from the database...";
1478 
1479  //int crate = 0;
1480 
1481  //
1482  // _____ query is different for the old validation DB _________________
1483  //
1484  //std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB, CRATE FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_TRIG_LOOKUP_TABLES");
1485  std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB, CRATE FROM CMS_HCL_HCAL_COND.V_HCAL_TRIG_LOOKUP_TABLES");
1486  //query+=toolbox::toString(" WHERE TAG_NAME='%s' AND CRATE=%d", tag.c_str(), crate);
1487  query += toolbox::toString(" WHERE TAG_NAME='%s'", tag.c_str());
1488 
1489  std::string brick_set;
1490 
1491  std::map<int, std::shared_ptr<LutXml>> lut_map;
1492 
1493  try {
1494  //SELECT
1495  edm::LogInfo("HcalLutManager") << "Executing the query...";
1496  Statement* stmt = _connection->createStatement();
1497  ResultSet* rs = stmt->executeQuery(query);
1498  edm::LogInfo("HcalLutManager") << "Executing the query... done";
1499 
1500  edm::LogInfo("HcalLutManager") << "Processing the query results...";
1501  //RooGKCounter _lines;
1502  while (rs->next()) {
1503  //_lines.count();
1504  oracle::occi::Clob clob = rs->getClob(1);
1505  int crate = rs->getInt(2);
1506  if (crate != -1) { // not a brick with checksums
1507  edm::LogInfo("HcalLutManager") << "Getting LUTs for crate #" << crate << " out of the database...";
1508  brick_set = db->clobToString(clob);
1509  /*
1510  // FIXME: DEBUG lut xml files from simple strings
1511  stringstream file_name;
1512  ofstream out_file;
1513  file_name << tag << "_" << crate << "_debug" << ".xml";
1514  out_file . open( file_name.str().c_str() );
1515  out_file << brick_set;
1516  out_file . close();
1517  */
1518  const char* bs = brick_set.c_str();
1519  MemBufInputSource* lut_clob = new MemBufInputSource((const XMLByte*)bs, strlen(bs), "lut_clob", false);
1520  std::shared_ptr<LutXml> lut_xml = std::make_shared<LutXml>(*lut_clob);
1521  lut_map[crate] = lut_xml;
1522  edm::LogInfo("HcalLutManager") << "done";
1523  }
1524  }
1525  //Always terminate statement
1526  _connection->terminateStatement(stmt);
1527  //std::cout << "Query line count: " << _lines.getCount() << std::endl;
1528  } catch (SQLException& e) {
1529  XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,
1530  ::toolbox::toString("Oracle exception : %s", e.getMessage().c_str()));
1531  }
1532 
1533  //std::cout << lut_map.size() << std::endl;
1534 
1535  db->disconnect();
1536  //delete db;
1537  return lut_map;
1538 }
1539 
1540 int HcalLutManager::create_lut_loader(std::string file_list,
1541  std::string _prefix,
1542  std::string tag_name,
1543  std::string comment,
1544  std::string version,
1545  int subversion) {
1546  edm::LogInfo("HcalLutManager") << "Generating XML loader for LUTs...";
1547  //std::cout << _prefix << "..." << tag_name << std::endl;
1548 
1549  XMLLUTLoader::loaderBaseConfig baseConf;
1550  XMLLUTLoader::lutDBConfig conf;
1551  XMLLUTLoader::checksumsDBConfig CSconf;
1552 
1553  baseConf.tag_name = tag_name;
1554  //baseConf . comment_description = tag_name;
1555  baseConf.comment_description = comment;
1556  baseConf.iov_begin = "1";
1557  baseConf.iov_end = "-1";
1558 
1559  conf.version = version;
1560 
1561  std::stringstream _subversion;
1562  _subversion << subversion;
1563  conf.subversion = _subversion.str();
1564 
1565  CSconf.version = conf.version;
1566  CSconf.subversion = conf.subversion;
1567  CSconf.trig_prim_lookuptbl_data_file = _prefix + "_checksums.xml.dat";
1568  CSconf.comment_description = tag_name;
1569 
1570  XMLLUTLoader doc(&baseConf);
1571 
1572  std::vector<int> crate_number;
1573  std::vector<std::string> file_name = HcalQIEManager::splitString(file_list);
1574  for (std::vector<std::string>::const_iterator _f = file_name.begin(); _f != file_name.end(); _f++) {
1575  int crate_begin = _f->rfind("_");
1576  int crate_end = _f->rfind(".xml.dat");
1577  crate_number.push_back(getInt(_f->substr(crate_begin + 1, crate_end - crate_begin - 1)));
1578  }
1579  //
1580  //_____ fix due to the new convention: version/subversion combo must be unique for every payload
1581  //
1582  char _buf[128];
1583  time_t _offset = time(nullptr);
1584  sprintf(_buf, "%d", (uint32_t)_offset);
1585  conf.version.append(".");
1586  conf.version.append(_buf);
1587  CSconf.version = conf.version;
1588  //
1589  for (std::vector<std::string>::const_iterator _file = file_name.begin(); _file != file_name.end(); _file++) {
1590  conf.trig_prim_lookuptbl_data_file = *_file;
1591  //conf . trig_prim_lookuptbl_data_file += ".dat";
1592  conf.crate = crate_number[_file - file_name.begin()];
1593  //
1594  //_____ fix due to the new convention: version/subversion combo must be unique for every payload
1595  //
1596  sprintf(_buf, "%.2d", conf.crate);
1597  conf.subversion.clear();
1598  conf.subversion.append(_buf);
1599  sprintf(_buf, "CRATE%.2d", conf.crate);
1600  std::string _namelabel;
1601  _namelabel.append(_buf);
1602  conf.name_label = _namelabel;
1603  doc.addLUT(&conf);
1604  }
1605 
1606  doc.addChecksums(&CSconf);
1607  //doc . write( _prefix + "_Loader.xml" );
1608  doc.write(tag_name + "_Loader.xml");
1609 
1610  edm::LogInfo("HcalLutManager") << "Generating XML loader for LUTs... done.";
1611 
1612  return 0;
1613 }
1614 
1615 void HcalLutManager::test_emap(void) {
1616  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v5_080208.txt");
1617  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
1618  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
1619  EMap _emap(emap);
1620  std::vector<EMap::EMapRow>& _map = _emap.get_map();
1621  std::stringstream s;
1622  s << "EMap contains " << _map.size() << " channels" << std::endl;
1623 
1624  //loop over all EMap channels
1625  //RooGKCounter _c;
1626  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1627  // only trigger tower channels
1628  if (row->subdet.find("HT") != std::string::npos) {
1629  s << " -----> Subdet = " << row->subdet << std::endl;
1630 
1631  if (abs(row->ieta) > 28) {
1632  //if (row->iphi == 71){
1633  s << " ==> (ieta,iphi) = " << row->ieta << ", " << row->iphi << std::endl;
1634  }
1635  }
1636  }
1637  edm::LogInfo("HcalLutManager") << s.str();
1638 }
1639 
1640 int HcalLutManager::test_direct_xml_parsing(std::string _filename) {
1641  /*
1642  XMLDOMBlock _xml(_filename);
1643  //DOMElement * data_set_elem = (DOMElement *)(document -> getElementsByTagName( XMLProcessor::_toXMLCh( "DATA_SET" ) ) -> item(0));
1644  DOMNodeList * brick_list = _xml . getDocument() -> getElementsByTagName( XMLProcessor::_toXMLCh( "CFGBrick" ));
1645 
1646  double n_bricks = brick_list->getLength();
1647  std::cout << "amount of LUT bricks: " << n_bricks << std::endl;
1648 
1649  for (int iter=0; iter!=n_bricks; iter++){
1650  DOMElement * _brick = (DOMElement *)(brick_list->item(iter));
1651 
1652  DOMElement * _param = 0;
1653  // loop over brick parameters
1654  int par_iter = 0;
1655  while(1){
1656  _param = (DOMElement *)(_brick->getElementsByTagName(XMLProcessor::_toXMLCh("Parameter")));
1657  std::string _name = _param->getAttribute( XMLProcessor::_toXMLCh( "name" ) );
1658  if (_name.find("IETA")==string::npos) break;
1659 
1660  std::string _tag = "Parameter";
1661  std::cout << "### Parameter IETA = " << _xml.getTagValue( _tag, 0, _brick);
1662  par_iter++;
1663  }
1664  }
1665  */
1666  return 0;
1667 }
1668 
1669 //
1670 //_____ attempt to include ZDC LUTs _____________________________________
1671 //
1672 int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii_ZDC(std::string _tag,
1673  const HcalTPGCoder& _coder,
1674  const CaloTPGTranscoderULUT& _transcoder,
1675  std::string _lin_file,
1676  bool split_by_crate) {
1677  std::map<int, std::shared_ptr<LutXml>> xml;
1678  if (!lut_checksums_xml) {
1679  lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
1680  }
1681 
1682  if (!_lin_file.empty()) {
1683  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
1684  getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
1685  addLutMap(xml, _lin_lut_ascii_xml);
1686  }
1687  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
1688  getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
1689  addLutMap(xml, _lin_lut_xml);
1690  //
1691  const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml =
1692  getCompressionLutXmlFromCoder(_transcoder, _tag, split_by_crate);
1693  addLutMap(xml, _comp_lut_xml);
1694 
1695  const std::map<int, std::shared_ptr<LutXml>> _HE_FG_lut_xml = getHEFineGrainLUTs(_tag, split_by_crate);
1696  addLutMap(xml, _HE_FG_lut_xml);
1697 
1698  for (auto masktype : {0, 1, 2}) {
1699  const auto masks = getMasks(masktype, _tag, split_by_crate);
1700  addLutMap(xml, masks);
1701  }
1702  //
1703  const std::map<int, std::shared_ptr<LutXml>> _zdc_lut_xml = getZdcLutXml(_tag, split_by_crate);
1704  addLutMap(xml, _zdc_lut_xml);
1705 
1706  writeLutXmlFiles(xml, _tag, split_by_crate);
1707 
1708  std::string checksums_file = _tag + "_checksums.xml";
1709  lut_checksums_xml->write(checksums_file);
1710 
1711  return 0;
1712 }
1713 
1714 std::map<int, std::shared_ptr<LutXml>> HcalLutManager::getZdcLutXml(std::string _tag, bool split_by_crate) {
1715  edm::LogInfo("HcalLutManager") << "Generating ZDC LUTs ...may the Force be with us...";
1716  std::map<int, std::shared_ptr<LutXml>> _xml; // index - crate number
1717 
1718  EMap _emap(emap);
1719 
1720  ZdcLut zdc;
1721 
1722  std::vector<EMap::EMapRow>& _map = _emap.get_map();
1723  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
1724 
1725  //loop over all EMap channels
1726  RooGKCounter _counter;
1727  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1728  LutXml::Config _cfg;
1729 
1730  // only ZDC channels
1731  if (row->zdc_section.find("ZDC") != std::string::npos) {
1732  if (_xml.count(row->crate) == 0 && split_by_crate) {
1733  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
1734  } else if (_xml.count(0) == 0 && !split_by_crate) {
1735  _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
1736  }
1737  // FIXME: introduce proper tag names in ZDC bricks for logical channel info
1738  _cfg.ieta = row->zdc_channel; // int
1739  //_cfg.ieta = row->zdc_zside; // int
1740  //_cfg.iphi = row->zdc_section; // string
1741  _cfg.depth = row->idepth; // int
1742  _cfg.crate = row->crate;
1743  _cfg.slot = row->slot;
1744  if (row->topbottom.find("t") != std::string::npos)
1745  _cfg.topbottom = 1;
1746  else if (row->topbottom.find("b") != std::string::npos)
1747  _cfg.topbottom = 0;
1748  else
1749  edm::LogWarning("HcalLutManager") << "fpga out of range...";
1750  _cfg.fiber = row->fiber;
1751  _cfg.fiberchan = row->fiberchan;
1752  _cfg.lut_type = 1;
1753  _cfg.creationtag = _tag;
1754  _cfg.creationstamp = get_time_stamp(time(nullptr));
1755  _cfg.targetfirmware = "1.0.0";
1756  _cfg.formatrevision = "1"; //???
1757  _cfg.generalizedindex = 0;
1758 
1759  //HcalZDCDetId _detid(row->zdc_section, (row->zdc_zside>0), row->zdc_channel);
1760 
1761  std::vector<int> coder_lut = zdc.get_lut(row->zdc_section, row->zdc_zside, row->zdc_channel);
1762  edm::LogInfo("HcalLutManager") << "***DEBUG: ZDC lut size: " << coder_lut.size();
1763  if (!coder_lut.empty()) {
1764  for (std::vector<int>::const_iterator _i = coder_lut.begin(); _i != coder_lut.end(); _i++) {
1765  unsigned int _temp = (unsigned int)(*_i);
1766  //if (_temp!=0) std::cout << "DEBUG non-zero LUT!!!!!!!!!!!!!!!" << (*_i) << " " << _temp << std::endl;
1767  //unsigned int _temp = 0;
1768  _cfg.lut.push_back(_temp);
1769  }
1770  //_cfg.lut = _set.lut[lut_index];
1771 
1772  if (split_by_crate) {
1773  _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
1774  _counter.count();
1775  } else {
1776  _xml[0]->addLut(_cfg, lut_checksums_xml);
1777  _counter.count();
1778  }
1779  } //size of lut
1780  }
1781  }
1782  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
1783  << "Generating ZDC LUTs...DONE" << std::endl;
1784 
1785  return _xml;
1786 }
HcalOther
Definition: HcalAssistant.h:38
HcalLutManager::local_connect
int local_connect(std::string lut_xml_file, std::string lmap_hbef_file, std::string lmap_ho_file)
Definition: HcalLutManager.cc:1385
HcalLutManager::createAllLutXmlFilesFromCoder
int createAllLutXmlFilesFromCoder(const HcalTPGCoder &_coder, std::string _tag, bool split_by_crate=true)
Definition: HcalLutManager.cc:1163
LutXml::_Config::creationtag
std::string creationtag
Definition: LutXml.h:33
ecalMGPA::adc
constexpr int adc(sample_type sample)
get the ADC sample (12 bits)
Definition: EcalMGPASample.h:11
init
int init
Definition: HydjetWrapper.h:64
common_cff.doc
doc
Definition: common_cff.py:54
HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii_ZDC
int createLutXmlFiles_HBEFFromCoder_HOFromAscii_ZDC(std::string _tag, const HcalTPGCoder &_coder, const CaloTPGTranscoderULUT &_transcoder, std::string _lin_file, bool split_by_crate=true)
Definition: HcalLutManager.cc:1672
mps_fire.i
i
Definition: mps_fire.py:355
XMLProcessor::getInstance
static XMLProcessor * getInstance()
Definition: XMLProcessor.h:134
MessageLogger.h
HcalLutManager::test_direct_xml_parsing
int test_direct_xml_parsing(std::string _filename)
Definition: HcalLutManager.cc:1640
HcalLutManager::createLinLutXmlFiles
int createLinLutXmlFiles(std::string _tag, std::string _lin_file, bool split_by_crate=true)
Definition: HcalLutManager.cc:1101
XMLLUTLoader::_lutDBConfig::name_label
std::string name_label
Definition: XMLLUTLoader.h:37
LMap.h
HcalElectronicsId::readoutVMECrateId
constexpr int readoutVMECrateId() const
get the readout VME crate number
Definition: HcalElectronicsId.h:105
LMap
Definition: LMap.h:66
HcalLutManager::getLinearizationLutXmlFromCoderEmap
std::map< int, std::shared_ptr< LutXml > > getLinearizationLutXmlFromCoderEmap(const HcalTPGCoder &_coder, std::string _tag, bool split_by_crate=true)
Definition: HcalLutManager.cc:757
hcal
Definition: ConfigurationDatabase.cc:13
XMLProcessor::_loaderBaseConfig::iov_begin
std::string iov_begin
Definition: XMLProcessor.h:49
CaloTPGTranscoderULUT::getCompressionLUT
virtual const std::vector< unsigned int > getCompressionLUT(const HcalTrigTowerDetId &id) const
Definition: CaloTPGTranscoderULUT.cc:282
LutXml::_Config::mask
std::vector< uint64_t > mask
Definition: LutXml.h:39
HcalTopology
Definition: HcalTopology.h:26
LutXml::_Config::topbottom
int topbottom
Definition: LutXml.h:32
getInt
int getInt(ResultSet *rset, int ipar)
Definition: ODFEDAQConfig.cc:26
edm::LogInfo
Definition: MessageLogger.h:254
HcalTPGCoder::getLinearizationLUT
virtual std::vector< unsigned short > getLinearizationLUT(HcalDetId id) const
Get the full linearization LUT (128 elements). Default implementation just uses adc2Linear to get all...
Definition: HcalTPGCoder.cc:3
LutXml::_Config::slot
int slot
Definition: LutXml.h:32
HcalLutManager::getCompressionLutXmlFromAsciiMaster
std::map< int, std::shared_ptr< LutXml > > getCompressionLutXmlFromAsciiMaster(std::string _filename, std::string _tag, int _crate=-1, bool split_by_crate=true)
Definition: HcalLutManager.cc:515
HcalLutManager::createAllLutXmlFiles
int createAllLutXmlFiles(std::string _tag, std::string _lin_file, std::string _comp_file, bool split_by_crate=true)
Definition: HcalLutManager.cc:1119
HcalLutSet::eta_min
std::vector< int > eta_min
Definition: HcalLutManager.h:35
HcalLutManager::getMasks
std::map< int, std::shared_ptr< LutXml > > getMasks(int var, std::string _tag, bool split_by_crate=true)
Definition: HcalLutManager.cc:683
XERCES_CPP_NAMESPACE_USE
Definition: XMLConfigWriter.cc:40
HcalChannelQuality
Definition: HcalChannelQuality.h:17
HcalLutManager::createCompLutXmlFilesFromCoder
int createCompLutXmlFilesFromCoder(std::string _tag, bool split_by_crate=true)
Definition: HcalLutManager.cc:1146
HcalBarrel
Definition: HcalAssistant.h:33
XMLProcessor::_loaderBaseConfig::comment_description
std::string comment_description
Definition: XMLProcessor.h:55
XMLProcessor::_loaderBaseConfig::tag_name
std::string tag_name
Definition: XMLProcessor.h:53
HcalLutManager::create_lut_loader
int create_lut_loader(std::string file_list, std::string _prefix, std::string tag_name, std::string comment="default comment", std::string version="V00-01-01", int subversion=1)
Definition: HcalLutManager.cc:1540
LutXml::_Config::targetfirmware
std::string targetfirmware
Definition: LutXml.h:36
HcalDbService::getHcalMapping
const HcalElectronicsMap * getHcalMapping() const
Definition: HcalDbService.cc:343
contentValuesCheck.file_name
file_name
Definition: contentValuesCheck.py:38
XMLDOMBlock
Definition: XMLDOMBlock.h:39
HcalLutSet::eta_max
std::vector< int > eta_max
Definition: HcalLutManager.h:35
parameters
parameters
Definition: BeamSpot_PayloadInspector.cc:14
HcalTPGCoder
Definition: HcalTPGCoder.h:26
HcalFinegrainBit
Definition: HcalFinegrainBit.h:7
HcalLutManager::addLutMap
void addLutMap(std::map< int, std::shared_ptr< LutXml > > &result, const std::map< int, std::shared_ptr< LutXml > > &other)
Definition: HcalLutManager.cc:1270
LutXml::_Config::generalizedindex
int generalizedindex
Definition: LutXml.h:37
LEDCalibrationChannels.iphi
iphi
Definition: LEDCalibrationChannels.py:64
dqmiodatasetharvest.db
db
Definition: dqmiodatasetharvest.py:119
HcalLutSet::lut
std::vector< std::vector< unsigned int > > lut
Definition: HcalLutManager.h:36
HcalTopology::firstHEDoublePhiRing
int firstHEDoublePhiRing() const
Definition: HcalTopology.h:101
HcalLutManager::getLinearizationLutXmlFromAsciiMasterEmap
std::map< int, std::shared_ptr< LutXml > > getLinearizationLutXmlFromAsciiMasterEmap(std::string _filename, std::string _tag, int _crate, bool split_by_crate=true)
Definition: HcalLutManager.cc:339
HcalLutSet::phi_max
std::vector< int > phi_max
Definition: HcalLutManager.h:35
std::size
constexpr auto size(const C &c) -> decltype(c.size())
Definition: cuda_cxx17.h:13
DetId
Definition: DetId.h:17
LutXml::_Config::iphi
int iphi
Definition: LutXml.h:32
HcalLutSet::depth_min
std::vector< int > depth_min
Definition: HcalLutManager.h:35
LutXml::_Config::lut_type
int lut_type
Definition: LutXml.h:32
alignCSCRings.s
s
Definition: alignCSCRings.py:92
cms::cuda::bs
bs
Definition: HistoContainer.h:127
ZdcLut
Generation of ZDC Lookup tables and associate helper methods.
Definition: ZdcLut.h:30
toolbox::toString
std::string toString(const char *format,...)
Definition: xdaq_compat.cc:4
contentValuesFiles.number
number
Definition: contentValuesFiles.py:53
CaloTPGTranscoderULUT::HTvalid
virtual bool HTvalid(const int ieta, const int iphi, const int version) const
Definition: CaloTPGTranscoderULUT.cc:198
query
Definition: query.py:1
oracle::occi
Definition: ConnectionManager.h:7
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
RooGKCounter.h
ZdcLut.h
HcalElectronicsId
Readout chain identification for Hcal.
Definition: HcalElectronicsId.h:32
HcalLutManager::get_time_stamp
static std::string get_time_stamp(time_t _time)
Definition: HcalLutManager.cc:1282
XMLProcessor::_DBConfig::subversion
std::string subversion
Definition: XMLProcessor.h:120
RooGKCounter
Definition: RooGKCounter.h:10
HcalOuter
Definition: HcalAssistant.h:35
LutXml::_Config::creationstamp
std::string creationstamp
Definition: LutXml.h:34
trackingPlots.other
other
Definition: trackingPlots.py:1465
HcalLutManager_test::getLutSetFromFile_test
static int getLutSetFromFile_test(std::string _filename)
Definition: HcalLutManager.cc:133
dqmdumpme.k
k
Definition: dqmdumpme.py:60
HcalLutManager::writeLutXmlFiles
int writeLutXmlFiles(std::map< int, std::shared_ptr< LutXml > > &_xml, std::string _tag="default_tag", bool split_by_crate=true)
Definition: HcalLutManager.cc:1086
HcalQIEManager::splitString
static std::vector< std::string > splitString(const std::string &fLine)
Definition: HcalQIEManager.cc:96
LMap::read
int read(std::string accessor, std::string type="HBEF")
Definition: LMap.cc:47
xdaq_compat.h
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
LutXml::_Config::ieta
int ieta
Definition: LutXml.h:32
HCALConfigDB
Gather config data from online DB.
Definition: HCALConfigDB.h:20
edm::LogWarning
Definition: MessageLogger.h:141
LEDCalibrationChannels.ieta
ieta
Definition: LEDCalibrationChannels.py:63
XMLLUTLoader::_checksumsDBConfig
Definition: XMLLUTLoader.h:42
HcalLutManager::get_xml_files_from_db
int get_xml_files_from_db(std::string tag, const std::string db_accessor="occi://CMS_HCL_PRTTYPE_HCAL_READER@anyhost/int2r?PASSWORD=HCAL_Reader_88,LHWM_VERSION=22", bool split_by_crate=true)
Definition: HcalLutManager.cc:1452
HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii
int createLutXmlFiles_HBEFFromCoder_HOFromAscii(std::string _tag, const HcalTPGCoder &_coder, std::string _lin_file, bool split_by_crate=true)
Definition: HcalLutManager.cc:1219
edm::LogError
Definition: MessageLogger.h:183
HcalLutManager::getLutFromXml_old
std::vector< unsigned int > getLutFromXml_old(std::string tag, uint32_t _rawid, hcal::ConfigurationDatabase::LUTType _lt)
Definition: HcalLutManager.cc:1402
LutXml::_Config::crate
int crate
Definition: LutXml.h:32
LutXml::_Config::lut
std::vector< unsigned int > lut
Definition: LutXml.h:38
HcalLutManager::test_xml_access
int test_xml_access(std::string _tag, std::string _filename)
Definition: HcalLutManager.cc:1291
HcalLutManager::read_luts
int read_luts(std::string lut_xml_file)
Definition: HcalLutManager.cc:1378
HcalQIEManager.h
HcalDetId.h
XMLLUTLoader::_lutDBConfig
Definition: XMLLUTLoader.h:34
LutXml::_Config::depth
int depth
Definition: LutXml.h:32
HcalLutManager::getLutXml
std::string & getLutXml(std::vector< unsigned int > &_lut)
Definition: HcalLutManager.cc:95
HcalLutManager::createAllLutXmlFilesLinAsciiCompCoder
int createAllLutXmlFilesLinAsciiCompCoder(std::string _tag, std::string _lin_file, bool split_by_crate=true)
Definition: HcalLutManager.cc:1249
XMLProcessor::_DBConfig::version
std::string version
Definition: XMLProcessor.h:119
EMap
Definition: LMap.h:80
LMap::get_map
std::map< int, LMapRow > & get_map(void)
Definition: LMap.cc:49
HcalDetId
Definition: HcalDetId.h:12
createfilelist.int
int
Definition: createfilelist.py:10
HcalLutManager::initChannelIterator
int initChannelIterator(std::vector< HcalGenericDetId > &map)
Definition: HcalLutManager.cc:90
HcalLutManager::~HcalLutManager
~HcalLutManager()
Definition: HcalLutManager.cc:83
HcalLutManager::getLutSetFromFile
HcalLutSet getLutSetFromFile(std::string _filename, int _type=1)
Definition: HcalLutManager.cc:170
HcalLutManager::getZdcLutXml
std::map< int, std::shared_ptr< LutXml > > getZdcLutXml(std::string _tag, bool split_by_crate=true)
Definition: HcalLutManager.cc:1714
DeadROCCounter.out_file
out_file
Definition: DeadROCCounter.py:50
LutXml::_Config::fiber
int fiber
Definition: LutXml.h:32
HcalTopology::lastHERing
int lastHERing() const
Definition: HcalTopology.h:94
rand
Signal rand(Signal arg)
Definition: vlib.cc:379
HcalSubdetector.h
HcalFinegrainBit::Tower
std::array< std::bitset< 6 >, 2 > Tower
Definition: HcalFinegrainBit.h:11
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
HcalLutSet::phi_min
std::vector< int > phi_min
Definition: HcalLutManager.h:35
XMLDOMBlock.h
cms::cuda::for
for(int i=first, nt=offsets[nh];i< nt;i+=gridDim.x *blockDim.x)
Definition: HistoContainer.h:27
visDQMUpload.buf
buf
Definition: visDQMUpload.py:154
XMLLUTLoader
Definition: XMLLUTLoader.h:29
XMLLUTLoader::_lutDBConfig::crate
int crate
Definition: XMLLUTLoader.h:39
LutXml::_Config::fiberchan
int fiberchan
Definition: LutXml.h:32
HcalLutManager::getLinearizationLutXmlFromAsciiMasterEmap_new
std::map< int, std::shared_ptr< LutXml > > getLinearizationLutXmlFromAsciiMasterEmap_new(std::string _filename, std::string _tag, int _crate, bool split_by_crate=true)
Definition: HcalLutManager.cc:435
HcalElectronicsMap
Definition: HcalElectronicsMap.h:31
HcalSubdetector
HcalSubdetector
Definition: HcalAssistant.h:31
HcalForward
Definition: HcalAssistant.h:36
hcalSimParameters_cfi.zdc
zdc
Definition: hcalSimParameters_cfi.py:92
LutXml::_Config::formatrevision
std::string formatrevision
Definition: LutXml.h:35
HcalLutManager::HcalLutManager
HcalLutManager()
Definition: HcalLutManager.cc:46
HcalLutManager::get_subdetector
static HcalSubdetector get_subdetector(std::string _subdet)
Definition: HcalLutManager.cc:117
HcalDbService
Definition: HcalDbService.h:26
HcalLutManager
Various manipulations with trigger Lookup Tables.
Definition: HcalLutManager.h:39
comment
#define comment(par)
Definition: vmac.h:163
std
Definition: JetResolutionObject.h:76
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
XMLLUTLoader::_checksumsDBConfig::comment_description
std::string comment_description
Definition: XMLLUTLoader.h:44
LutXml::_Config
Definition: LutXml.h:29
HcalEndcap
Definition: HcalAssistant.h:34
HcalLutManager::get_brickSet_from_oracle
std::map< int, std::shared_ptr< LutXml > > get_brickSet_from_oracle(std::string tag, const std::string _accessor="occi://CMS_HCL_PRTTYPE_HCAL_READER@anyhost/int2r?PASSWORD=HCAL_Reader_88,LHWM_VERSION=22")
Definition: HcalLutManager.cc:1469
HcalLutSet::label
std::string label
Definition: HcalLutManager.h:33
EMap::get_map
std::vector< EMap::EMapRow > & get_map(void)
Definition: LMap.cc:316
HcalLutManager::getInt
static int getInt(std::string number)
Definition: HcalLutManager.cc:111
RooGKCounter::getCount
unsigned long int getCount(void)
Definition: RooGKCounter.cc:95
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
XMLLUTLoader.h
timingPdfMaker.infile
infile
Definition: timingPdfMaker.py:350
XMLProcessor.h
HcalLutSet::depth_max
std::vector< int > depth_max
Definition: HcalLutManager.h:35
XMLLUTLoader::_lutDBConfig::trig_prim_lookuptbl_data_file
std::string trig_prim_lookuptbl_data_file
Definition: XMLLUTLoader.h:38
HcalLutManager::read_lmap
int read_lmap(std::string lmap_hbef_file, std::string lmap_ho_file)
Definition: HcalLutManager.cc:1368
HcalLutManager::init
void init(void)
Definition: HcalLutManager.cc:72
Oracle.h
mps_fire.result
result
Definition: mps_fire.py:303
XMLLUTLoader::_loaderBaseConfig
Definition: XMLLUTLoader.h:31
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
genParticles_cff.map
map
Definition: genParticles_cff.py:11
RooGKCounter::count
void count(void)
Definition: RooGKCounter.cc:54
beamvalidation.exit
def exit(msg="")
Definition: beamvalidation.py:53
HcalLutManager::getLutXmlFromAsciiMaster
std::map< int, std::shared_ptr< LutXml > > getLutXmlFromAsciiMaster(std::string _filename, std::string _tag, int _crate=-1, bool split_by_crate=true)
Definition: HcalLutManager.cc:253
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
LutXml
Definition: LutXml.h:27
XMLProcessor::_loaderBaseConfig::iov_end
std::string iov_end
Definition: XMLProcessor.h:50
ntuplemaker.time
time
Definition: ntuplemaker.py:310
HcalLutSet::subdet
std::vector< std::string > subdet
Definition: HcalLutManager.h:34
BeamSplash_cfg.version
version
Definition: BeamSplash_cfg.py:45
HcalLutManager::getLinearizationLutXmlFromCoder
std::map< int, std::shared_ptr< LutXml > > getLinearizationLutXmlFromCoder(const HcalTPGCoder &_coder, std::string _tag, bool split_by_crate=true)
Definition: HcalLutManager.cc:601
XMLLUTLoader::_checksumsDBConfig::trig_prim_lookuptbl_data_file
std::string trig_prim_lookuptbl_data_file
Definition: XMLLUTLoader.h:46
CaloTPGTranscoderULUT
Definition: CaloTPGTranscoderULUT.h:18
HcalLutManager::test_emap
void test_emap(void)
Definition: HcalLutManager.cc:1615
cmsswSequenceInfo.maxsize
maxsize
Definition: cmsswSequenceInfo.py:33
HcalLutSet
Definition: HcalLutManager.h:31
HcalLutManager::getHEFineGrainLUTs
std::map< int, std::shared_ptr< LutXml > > getHEFineGrainLUTs(std::string _tag, bool split_by_crate=true)
Definition: HcalLutManager.cc:835
HcalLutManager.h
HcalLutManager::getLutFromXml
std::vector< unsigned int > getLutFromXml(std::string tag, uint32_t _rawid, hcal::ConfigurationDatabase::LUTType _lt)
Definition: HcalLutManager.cc:1391
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
HcalTrigTowerDetId
Definition: HcalTrigTowerDetId.h:14
HcalLutManager::getCompressionLutXmlFromCoder
std::map< int, std::shared_ptr< LutXml > > getCompressionLutXmlFromCoder(std::string _tag, bool split_by_crate=true)
Definition: HcalLutManager.cc:1007
Generated for CMSSW Reference Manual by doxygen 1.8.16