Back to home page

Project CMSSW displayed by LXR
 
 

    

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    \class HcalLutManager
0041    \brief Various manipulations with trigger Lookup Tables
0042    \author Gena Kukartsev, Brown University, March 14, 2008
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   //return lut_xml->getString();
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     // get label
0181     getline(infile, _lutset.label);
0182 
0183     if (_type == 1) {  // for linearization LUTs get subdetectors (default)
0184       //get subdetectors
0185       getline(infile, buf);
0186       _lutset.subdet = HcalQIEManager::splitString(buf);
0187     }
0188 
0189     //get min etas
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     //get max etas
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     //get min phis
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     //get max phis
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) {  // for linearization LUTs get depth range (default)
0219       //get min depths
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       //get max depths
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;  // index - crate number
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   // read LUTs and their eta/phi/depth/subdet ranges
0267   HcalLutSet _set = getLutSetFromFile(_filename);
0268   int lut_set_size = _set.lut.size();  // number of different luts
0269 
0270   RooGKCounter _counter;
0271   //loop over all HCAL channels
0272   for (std::map<int, LMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0273     LutXml::Config _cfg;
0274 
0275     // search for the correct LUT for a given channel,
0276     // higher LUT numbers have priority in case of overlapping
0277     int lut_index = -1;
0278     for (int i = 0; i < lut_set_size; i++) {
0279       if ((row->second.crate == _crate || _crate == -1) &&  // -1 stands for all crates
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       // FIXME: probably fixed. fiber==htr_fi, not rm_fi in LMAP notation.
0305       //_cfg.fiber = row->second.rm_fi;
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       // "original" definition of GENERALIZEDINDEX from Mike Weinberger
0317       //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
0318       //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
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 //_____ get HO from ASCII master here ___________________________________
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;  // index - crate number
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   // read LUTs and their eta/phi/depth/subdet ranges
0351   HcalLutSet _set = getLutSetFromFile(_filename);
0352   int lut_set_size = _set.lut.size();  // number of different luts
0353   edm::LogInfo("HcalLutManager") << "  ==> " << lut_set_size << " sets of different LUTs read from the master file";
0354 
0355   // setup "zero" LUT for channel masking
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   //loop over all EMap channels
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       // search for the correct LUT for a given channel,
0369       // higher LUT numbers have priority in case of overlapping
0370       int lut_index = -1;
0371       for (int i = 0; i < lut_set_size; i++) {
0372         if ((row->crate == _crate || _crate == -1) &&  // -1 stands for all crates
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         // "original" definition of GENERALIZEDINDEX from Mike Weinberger
0406         //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
0407         //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
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         // consider channel status here
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;  // index - crate number
0439 
0440   // read LUTs and their eta/phi/depth/subdet ranges
0441   HcalLutSet _set = getLutSetFromFile(_filename);
0442   int lut_set_size = _set.lut.size();  // number of different luts
0443   edm::LogInfo("HcalLutManager") << "  ==> " << lut_set_size << " sets of different LUTs read from the master file";
0444 
0445   RooGKCounter _counter;
0446   //loop over all EMap channels
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       // FIXME: this is probably wrong, raw ids are different
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       // search for the correct LUT for a given channel,
0465       // higher LUT numbers have priority in case of overlapping
0466       int lut_index = -1;
0467       for (int i = 0; i < lut_set_size; i++) {
0468         if ((aCrate == _crate || _crate == -1) &&  // -1 stands for all crates
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         // "original" definition of GENERALIZEDINDEX from Mike Weinberger
0495         //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
0496         //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
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;  // index - crate number
0521 
0522   edm::LogInfo("HcalLutManager")
0523       << "instantiating CaloTPGTranscoderULUT in order to check the validity of (ieta,iphi)...";
0524   CaloTPGTranscoderULUT _coder;
0525 
0526   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
0527   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
0528   EMap _emap(emap);
0529   std::vector<EMap::EMapRow>& _map = _emap.get_map();
0530   edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
0531 
0532   // read LUTs and their eta/phi/depth/subdet ranges
0533   HcalLutSet _set = getLutSetFromFile(_filename, 2);
0534   int lut_set_size = _set.lut.size();  // number of different luts
0535   edm::LogInfo("HcalLutManager") << "  ==> " << lut_set_size << " sets of different LUTs read from the master file";
0536 
0537   //loop over all EMap channels
0538   RooGKCounter _counter;
0539   for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
0540     LutXml::Config _cfg;
0541 
0542     // search for the correct LUT for a given channel,
0543     // higher LUT numbers have priority in case of overlapping
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) &&  // -1 stands for all crates
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       // "original" definition of GENERALIZEDINDEX from Mike Weinberger
0583       //   int generalizedIndex=id.ietaAbs()+10000*id.iphi()+
0584       //       ((id.ieta()<0)?(0):(100));
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;  // index - crate number
0606 
0607   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
0608   //std::vector<EMap::EMapRow> & _map = _emap.get_map();
0609   //std::cout << "EMap contains " << _map . size() << " entries" << std::endl;
0610 
0611   LMap _lmap;
0612   _lmap.read("backup/HCALmapHBEF.txt", "HBEF");
0613   // HO is not part of trigger, so TPGCoder cannot generate LUTs for it
0614   //_lmap . read( "backup/HCALmapHO.txt", "HO" );
0615   std::map<int, LMapRow>& _map = _lmap.get_map();
0616   edm::LogInfo("HcalLutManager") << "LMap contains " << _map.size() << " channels";
0617 
0618   // read LUTs and their eta/phi/depth/subdet ranges
0619   //HcalLutSet _set = getLinearizationLutSetFromCoder();
0620   //int lut_set_size = _set.lut.size(); // number of different luts
0621 
0622   //loop over all HCAL channels
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     // FIXME: probably fixed. fiber==htr_fi, not rm_fi in LMAP notation.
0644     //_cfg.fiber = row->second.rm_fi;
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     // "original" definition of GENERALIZEDINDEX from Mike Weinberger
0653     //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
0654     //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
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     //HcalDetId _detid(row->first);
0659     HcalDetId _detid(row->second.det, row->second.side * row->second.eta, row->second.phi, row->second.depth);
0660     //std::cout << "### DEBUG: rawid = " << _detid.rawId() << std::endl;
0661 
0662     //std::cout << "### DEBUG: subdetector = " << row->second.det << std::endl;
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       //if (_temp!=0) std::cout << "DEBUG non-zero LUT!!!!!!!!!!!!!!!" << (*_i) << "     " << _temp << std::endl;
0667       //unsigned int _temp = 0;
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;  // index - crate number
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;  // index - crate number
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   //loop over all EMap channels
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       // "original" definition of GENERALIZEDINDEX from Mike Weinberger
0801       //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
0802       //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
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;  // index - crate number
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   //loop over all EMap channels
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;  //do only actual physical towers
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       // fine grain LUTs only relevant for HE
0883       HcalSubdetector _subdet = HcalEndcap;
0884       HcalDetId _detid(_subdet, row->ieta, row->iphi, row->idepth);
0885 
0886       HcalFinegrainBit fg_algo(conditions->getHcalTPParameters()->getFGVersionHBHE());
0887 
0888       // loop over all possible configurations,
0889       // computing the LUT for each
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;  // index - crate number
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   //need to equalize compression LUT size in each crate-slot, needed for mixed uHTR
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);  //is this used for anything?
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;  // index - crate number
1014 
1015   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v5_080208.txt");
1016   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
1017   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
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   // read LUTs and their eta/phi/depth/subdet ranges
1024   //HcalLutSet _set = getLutSetFromFile( _filename, 2 );
1025   //int lut_set_size = _set.lut.size(); // number of different luts
1026 
1027   CaloTPGTranscoderULUT _coder;
1028 
1029   //loop over all EMap channels
1030   RooGKCounter _counter;
1031   for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1032     LutXml::Config _cfg;
1033 
1034     // only trigger tower channels
1035     // and valid (ieta,iphi)
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       // "original" definition of GENERALIZEDINDEX from Mike Weinberger
1064       //   int generalizedIndex=id.ietaAbs()+10000*id.iphi()+
1065       //       ((id.ieta()<0)?(0):(100));
1066       _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);
1067 
1068       // FIXME: work around bug in emap v6: rawId wasn't filled
1069       //HcalTrigTowerDetId _detid(row->rawId);
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   //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
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   //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
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     //addLutMap( xml, getLutXmlFromAsciiMaster( _lin_file, _tag, -1, split_by_crate ) );
1134     addLutMap(xml, getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate));
1135   }
1136   if (!_comp_file.empty()) {
1137     //std::cout << "DEBUG1!!!!" << std::endl;
1138     addLutMap(xml, getCompressionLutXmlFromAsciiMaster(_comp_file, _tag, -1, split_by_crate));
1139     //std::cout << "DEBUG2!!!!" << std::endl;
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   //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
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   //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
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   //addLutMap( xml, getLinearizationLutXmlFromCoder( _coder, _tag, split_by_crate ) );
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 //_____ use this for creating a full set of LUTs ________________________
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 // use this to create HBEF only from coders (physics LUTs)
1252 int HcalLutManager::createAllLutXmlFilesLinAsciiCompCoder(std::string _tag,
1253                                                           std::string _lin_file,
1254                                                           bool split_by_crate) {
1255   //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
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   //strftime( timebuf, 50, "%c", gmtime( &_time ) );
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   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
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   // make sure that all init is done
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   // loop over random LUTs
1322   for (int _iter = 0; _iter < 100; _iter++) {
1323     gettimeofday(&_t, nullptr);
1324     //std::cout << "before getting a LUT: " << _t . tv_sec << "." << _t . tv_usec << std::endl;
1325 
1326     // select valid random emap channel
1327     while (true) {
1328       int _key = (rand() % map_size);
1329       //_key = 3356;
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 // obsolete, use getLutFromXml() instead
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   //std::cout << "HcalLutManager: LMap contains " << _map . size() << " channels (out of 9072 total)" << std::endl;
1421 
1422   HcalDetId _id(_rawid);
1423 
1424   unsigned int _crate, _slot, _fiber, _channel;
1425   std::string _fpga;
1426   int topbottom, luttype;
1427 
1428   // FIXME: check validity of _rawid
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();  // initialize xerces-c engine
1476   //const std::string _accessor = "occi://CMS_HCL_PRTTYPE_HCAL_READER@anyhost/int2r?PASSWORD=HCAL_Reader_88,LHWM_VERSION=22";
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   //int crate = 0;
1483 
1484   //
1485   // _____ query is different for the old validation DB _________________
1486   //
1487   //std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB, CRATE FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_TRIG_LOOKUP_TABLES");
1488   std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB, CRATE FROM CMS_HCL_HCAL_COND.V_HCAL_TRIG_LOOKUP_TABLES");
1489   //query+=toolbox::toString(" WHERE TAG_NAME='%s' AND CRATE=%d", tag.c_str(), crate);
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     //SELECT
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     //RooGKCounter _lines;
1505     while (rs->next()) {
1506       //_lines.count();
1507       oracle::occi::Clob clob = rs->getClob(1);
1508       int crate = rs->getInt(2);
1509       if (crate != -1) {  // not a brick with checksums
1510         edm::LogInfo("HcalLutManager") << "Getting LUTs for crate #" << crate << " out of the database...";
1511         brick_set = db->clobToString(clob);
1512         /*
1513     // FIXME: DEBUG lut xml files from simple strings
1514     stringstream file_name;
1515     ofstream out_file;
1516     file_name << tag << "_" << crate << "_debug" << ".xml";
1517     out_file . open( file_name.str().c_str() );
1518     out_file << brick_set;
1519     out_file . close();
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     //Always terminate statement
1529     _connection->terminateStatement(stmt);
1530     //std::cout << "Query line count: " << _lines.getCount() << std::endl;
1531   } catch (SQLException& e) {
1532     XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,
1533                 ::toolbox::toString("Oracle  exception : %s", e.getMessage().c_str()));
1534   }
1535 
1536   //std::cout << lut_map.size() << std::endl;
1537 
1538   db->disconnect();
1539   //delete db;
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   //std::cout << _prefix << "..." << tag_name << std::endl;
1551 
1552   XMLLUTLoader::loaderBaseConfig baseConf;
1553   XMLLUTLoader::lutDBConfig conf;
1554   XMLLUTLoader::checksumsDBConfig CSconf;
1555 
1556   baseConf.tag_name = tag_name;
1557   //baseConf . comment_description = tag_name;
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   //_____ fix due to the new convention: version/subversion combo must be unique for every payload
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     //conf . trig_prim_lookuptbl_data_file += ".dat";
1595     conf.crate = crate_number[_file - file_name.begin()];
1596     //
1597     //_____ fix due to the new convention: version/subversion combo must be unique for every payload
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   //doc . write( _prefix + "_Loader.xml" );
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   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v5_080208.txt");
1620   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
1621   //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
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   //loop over all EMap channels
1628   //RooGKCounter _c;
1629   for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1630     // only trigger tower channels
1631     if (row->subdet.find("HT") != std::string::npos) {
1632       s << " -----> Subdet = " << row->subdet << std::endl;
1633 
1634       if (abs(row->ieta) > 28) {
1635         //if (row->iphi == 71){
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   XMLDOMBlock _xml(_filename);
1646   //DOMElement * data_set_elem = (DOMElement *)(document -> getElementsByTagName( XMLProcessor::_toXMLCh( "DATA_SET" ) ) -> item(0));  
1647   DOMNodeList * brick_list = _xml . getDocument() ->  getElementsByTagName( XMLProcessor::_toXMLCh( "CFGBrick" ));  
1648 
1649   double n_bricks = brick_list->getLength();
1650   std::cout << "amount of LUT bricks: " << n_bricks << std::endl;
1651 
1652   for (int iter=0; iter!=n_bricks; iter++){
1653     DOMElement * _brick = (DOMElement *)(brick_list->item(iter));
1654     
1655     DOMElement * _param = 0;
1656     // loop over brick parameters
1657     int par_iter = 0;
1658     while(1){
1659       _param = (DOMElement *)(_brick->getElementsByTagName(XMLProcessor::_toXMLCh("Parameter")));
1660       std::string _name = _param->getAttribute( XMLProcessor::_toXMLCh( "name" ) );
1661       if (_name.find("IETA")==string::npos) break;
1662 
1663       std::string _tag = "Parameter";
1664       std::cout << "### Parameter IETA = " << _xml.getTagValue( _tag, 0, _brick);
1665       par_iter++;
1666     }
1667   }
1668   */
1669   return 0;
1670 }
1671 
1672 //
1673 //_____ attempt to include ZDC LUTs _____________________________________
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;  // index - crate number
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   //loop over all EMap channels
1727   RooGKCounter _counter;
1728   for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
1729     LutXml::Config _cfg;
1730 
1731     // only ZDC channels
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       //  FIXME: introduce proper tag names in ZDC bricks for logical channel info
1739       _cfg.ieta = row->zdc_channel;  // int
1740       //_cfg.ieta = row->zdc_zside; // int
1741       //_cfg.iphi = row->zdc_section; // string
1742       _cfg.depth = row->idepth;  // int
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       //HcalZDCDetId _detid(row->zdc_section, (row->zdc_zside>0), row->zdc_channel);
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           //if (_temp!=0) std::cout << "DEBUG non-zero LUT!!!!!!!!!!!!!!!" << (*_i) << "     " << _temp << std::endl;
1768           //unsigned int _temp = 0;
1769           _cfg.lut.push_back(_temp);
1770         }
1771         //_cfg.lut = _set.lut[lut_index];
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       }  //size of lut
1781     }
1782   }
1783   edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
1784                                  << "Generating ZDC LUTs...DONE" << std::endl;
1785 
1786   return _xml;
1787 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!