HcalLutManager Class Reference

Various manipulations with trigger Lookup Tables. More...

#include <HcalLutManager.h>

Public Member Functions
void	addLutMap (std::map< int, std::shared_ptr< LutXml > > &result, const std::map< int, std::shared_ptr< LutXml > > &other)
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)
int	createAllLutXmlFiles (std::string _tag, std::string _lin_file, std::string _comp_file, bool split_by_crate=true)
int	createAllLutXmlFilesFromCoder (const HcalTPGCoder &_coder, std::string _tag, bool split_by_crate=true)
int	createAllLutXmlFilesLinAsciiCompCoder (std::string _tag, std::string _lin_file, bool split_by_crate=true)
int	createCompLutXmlFilesFromCoder (std::string _tag, bool split_by_crate=true)
int	createLinLutXmlFiles (std::string _tag, std::string _lin_file, bool split_by_crate=true)
int	createLutXmlFiles_HBEFFromCoder_HOFromAscii (std::string _tag, const HcalTPGCoder &_coder, const CaloTPGTranscoderULUT &_transcoder, std::string _lin_file, bool split_by_crate=true)
int	createLutXmlFiles_HBEFFromCoder_HOFromAscii (std::string _tag, const HcalTPGCoder &_coder, std::string _lin_file, bool split_by_crate=true)
int	createLutXmlFiles_HBEFFromCoder_HOFromAscii_ZDC (std::string _tag, const HcalTPGCoder &_coder, const CaloTPGTranscoderULUT &_transcoder, std::string _lin_file, bool split_by_crate=true)
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")
std::string	get_checksum (std::vector< unsigned int > &lut)
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)
std::map< int, std::shared_ptr< LutXml > >	getCompressionLutXmlFromAsciiMaster (std::string _filename, std::string _tag, int _crate=-1, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getCompressionLutXmlFromCoder (const CaloTPGTranscoderULUT &_coder, std::string _tag, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getCompressionLutXmlFromCoder (std::string _tag, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getHEFineGrainLUTs (std::string _tag, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getLinearizationLutXmlFromAsciiMasterEmap (std::string _filename, std::string _tag, int _crate, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getLinearizationLutXmlFromAsciiMasterEmap_new (std::string _filename, std::string _tag, int _crate, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getLinearizationLutXmlFromCoder (const HcalTPGCoder &_coder, std::string _tag, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getLinearizationLutXmlFromCoderEmap (const HcalTPGCoder &_coder, std::string _tag, bool split_by_crate=true)
std::vector< unsigned int >	getLutFromXml (std::string tag, uint32_t _rawid, hcal::ConfigurationDatabase::LUTType _lt)
std::vector< unsigned int >	getLutFromXml_old (std::string tag, uint32_t _rawid, hcal::ConfigurationDatabase::LUTType _lt)
HcalLutSet	getLutSetFromFile (std::string _filename, int _type=1)
std::string &	getLutXml (std::vector< unsigned int > &_lut)
std::map< int, std::shared_ptr< LutXml > >	getLutXmlFromAsciiMaster (std::string _filename, std::string _tag, int _crate=-1, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getMasks (int var, std::string _tag, bool split_by_crate=true)
std::map< int, std::shared_ptr< LutXml > >	getZdcLutXml (std::string _tag, bool split_by_crate=true)
	HcalLutManager ()
	HcalLutManager (const HcalDbService *conditions, const HcalChannelQuality *_cq=nullptr, uint32_t _status_word_to_mask=0x0000)
	HcalLutManager (const HcalElectronicsMap *_emap, const HcalChannelQuality *_cq=nullptr, uint32_t _status_word_to_mask=0x0000)
	HcalLutManager (std::vector< HcalGenericDetId > &map)
void	init (void)
int	initChannelIterator (std::vector< HcalGenericDetId > &map)
int	local_connect (std::string lut_xml_file, std::string lmap_hbef_file, std::string lmap_ho_file)
int	read_lmap (std::string lmap_hbef_file, std::string lmap_ho_file)
int	read_luts (std::string lut_xml_file)
int	test_direct_xml_parsing (std::string _filename)
void	test_emap (void)
int	test_xml_access (std::string _tag, std::string _filename)
int	writeLutXmlFiles (std::map< int, std::shared_ptr< LutXml > > &_xml, std::string _tag="default_tag", bool split_by_crate=true)
	~HcalLutManager ()

Static Public Member Functions
static HcalSubdetector	get_subdetector (std::string _subdet)
static std::string	get_time_stamp (time_t _time)
static int	getInt (std::string number)

Protected Attributes
HcalAssistant	_ass
HcalChannelIterator	_iter
const HcalDbService *	conditions
const HcalChannelQuality *	cq
HCALConfigDB *	db
const HcalElectronicsMap *	emap
LMap *	lmap
XMLDOMBlock *	lut_checksums_xml
LutXml *	lut_xml
uint32_t	status_word_to_mask

Detailed Description

Various manipulations with trigger Lookup Tables.

Author

Gena Kukartsev, Brown University, March 14, 2008

Definition at line 39 of file HcalLutManager.h.

Constructor & Destructor Documentation

HcalLutManager() [1/4]

HcalLutManager::HcalLutManager

(

void

)

Definition at line 46 of file HcalLutManager.cc.

{ init(); }

References init.

HcalLutManager() [2/4]

HcalLutManager::HcalLutManager

(

std::vector< HcalGenericDetId > &

map

)

Definition at line 48 of file HcalLutManager.cc.

                                                               {
  init();
  _iter.init(map);
}

References init, and genParticles_cff::map.

HcalLutManager() [3/4]

HcalLutManager::HcalLutManager	(	const HcalElectronicsMap *	_emap,
		const HcalChannelQuality *	_cq = nullptr,
		uint32_t	_status_word_to_mask = 0x0000
	)

Definition at line 53 of file HcalLutManager.cc.

                                                              {
  init();
  emap = _emap;
  cq = _cq;
  status_word_to_mask = _status_word_to_mask;
}

References init.

HcalLutManager() [4/4]

HcalLutManager::HcalLutManager	(	const HcalDbService *	conditions,
		const HcalChannelQuality *	_cq = nullptr,
		uint32_t	_status_word_to_mask = 0x0000
	)

Definition at line 62 of file HcalLutManager.cc.

                                                              {
  init();
  conditions = _conditions;
  emap = conditions->getHcalMapping();
  cq = _cq;
  status_word_to_mask = _status_word_to_mask;
}

References submitPVValidationJobs::conditions, and init.

~HcalLutManager()

HcalLutManager::~HcalLutManager

(

void

)

Definition at line 83 of file HcalLutManager.cc.

                                    {
  delete lut_xml;
  delete lut_checksums_xml;
  delete db;
  delete lmap;
}

References dqmiodatasetharvest::db.

Member Function Documentation

addLutMap()

void HcalLutManager::addLutMap	(	std::map< int, std::shared_ptr< LutXml > > &	result,
		const std::map< int, std::shared_ptr< LutXml > > &	other
	)

Definition at line 1270 of file HcalLutManager.cc.

                                                                                {
  for (std::map<int, std::shared_ptr<LutXml>>::const_iterator lut = other.begin(); lut != other.end(); lut++) {
    edm::LogInfo("HcalLutManager") << "Added LUTs for crate " << lut->first;
    if (result.count(lut->first) == 0) {
      result.insert(*lut);
    } else {
      *(result[lut->first]) += *(lut->second);
    }
  }
}

References genParticles_cff::map, trackingPlots::other, and mps_fire::result.

create_lut_loader()

int HcalLutManager::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 at line 1540 of file HcalLutManager.cc.

                                                      {
  edm::LogInfo("HcalLutManager") << "Generating XML loader for LUTs...";
  //std::cout << _prefix << "..." << tag_name << std::endl;
 
  XMLLUTLoader::loaderBaseConfig baseConf;
  XMLLUTLoader::lutDBConfig conf;
  XMLLUTLoader::checksumsDBConfig CSconf;
 
  baseConf.tag_name = tag_name;
  //baseConf . comment_description = tag_name;
  baseConf.comment_description = comment;
  baseConf.iov_begin = "1";
  baseConf.iov_end = "-1";
 
  conf.version = version;
 
  std::stringstream _subversion;
  _subversion << subversion;
  conf.subversion = _subversion.str();
 
  CSconf.version = conf.version;
  CSconf.subversion = conf.subversion;
  CSconf.trig_prim_lookuptbl_data_file = _prefix + "_checksums.xml.dat";
  CSconf.comment_description = tag_name;
 
  XMLLUTLoader doc(&baseConf);
 
  std::vector<int> crate_number;
  std::vector<std::string> file_name = HcalQIEManager::splitString(file_list);
  for (std::vector<std::string>::const_iterator _f = file_name.begin(); _f != file_name.end(); _f++) {
    int crate_begin = _f->rfind("_");
    int crate_end = _f->rfind(".xml.dat");
    crate_number.push_back(getInt(_f->substr(crate_begin + 1, crate_end - crate_begin - 1)));
  }
  //
  //_____ fix due to the new convention: version/subversion combo must be unique for every payload
  //
  char _buf[128];
  time_t _offset = time(nullptr);
  sprintf(_buf, "%d", (uint32_t)_offset);
  conf.version.append(".");
  conf.version.append(_buf);
  CSconf.version = conf.version;
  //
  for (std::vector<std::string>::const_iterator _file = file_name.begin(); _file != file_name.end(); _file++) {
    conf.trig_prim_lookuptbl_data_file = *_file;
    //conf . trig_prim_lookuptbl_data_file += ".dat";
    conf.crate = crate_number[_file - file_name.begin()];
    //
    //_____ fix due to the new convention: version/subversion combo must be unique for every payload
    //
    sprintf(_buf, "%.2d", conf.crate);
    conf.subversion.clear();
    conf.subversion.append(_buf);
    sprintf(_buf, "CRATE%.2d", conf.crate);
    std::string _namelabel;
    _namelabel.append(_buf);
    conf.name_label = _namelabel;
    doc.addLUT(&conf);
  }
 
  doc.addChecksums(&CSconf);
  //doc . write( _prefix + "_Loader.xml" );
  doc.write(tag_name + "_Loader.xml");
 
  edm::LogInfo("HcalLutManager") << "Generating XML loader for LUTs... done.";
 
  return 0;
}

References XMLLUTLoader::_checksumsDBConfig::comment_description, XMLProcessor::_loaderBaseConfig::comment_description, XMLLUTLoader::_lutDBConfig::crate, common_cff::doc, contentValuesCheck::file_name, getInt(), XMLProcessor::_loaderBaseConfig::iov_begin, XMLProcessor::_loaderBaseConfig::iov_end, XMLLUTLoader::_lutDBConfig::name_label, HcalQIEManager::splitString(), AlCaHLTBitMon_QueryRunRegistry::string, XMLProcessor::_DBConfig::subversion, XMLProcessor::_loaderBaseConfig::tag_name, ntuplemaker::time, XMLLUTLoader::_lutDBConfig::trig_prim_lookuptbl_data_file, XMLLUTLoader::_checksumsDBConfig::trig_prim_lookuptbl_data_file, BeamSplash_cfg::version, and XMLProcessor::_DBConfig::version.

Referenced by main().

createAllLutXmlFiles()

int HcalLutManager::createAllLutXmlFiles	(	std::string	_tag,
		std::string	_lin_file,
		std::string	_comp_file,
		bool	split_by_crate = true
	)

Definition at line 1119 of file HcalLutManager.cc.

                                                              {
  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
  std::map<int, std::shared_ptr<LutXml>> xml;
  if (!lut_checksums_xml) {
    lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
  }
 
  if (!_lin_file.empty()) {
    //addLutMap( xml, getLutXmlFromAsciiMaster( _lin_file, _tag, -1, split_by_crate ) );
    addLutMap(xml, getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate));
  }
  if (!_comp_file.empty()) {
    //std::cout << "DEBUG1!!!!" << std::endl;
    addLutMap(xml, getCompressionLutXmlFromAsciiMaster(_comp_file, _tag, -1, split_by_crate));
    //std::cout << "DEBUG2!!!!" << std::endl;
  }
  writeLutXmlFiles(xml, _tag, split_by_crate);
 
  std::string checksums_file = _tag + "_checksums.xml";
  lut_checksums_xml->write(checksums_file);
 
  return 0;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

createAllLutXmlFilesFromCoder()

int HcalLutManager::createAllLutXmlFilesFromCoder	(	const HcalTPGCoder &	_coder,
		std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 1163 of file HcalLutManager.cc.

                                                                                                                 {
  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
  std::map<int, std::shared_ptr<LutXml>> xml;
  if (!lut_checksums_xml) {
    lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
  }
 
  //addLutMap( xml, getLinearizationLutXmlFromCoder( _coder, _tag, split_by_crate ) );
  addLutMap(xml, getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate));
  addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
 
  writeLutXmlFiles(xml, _tag, split_by_crate);
 
  std::string checksums_file = _tag + "_checksums.xml";
  lut_checksums_xml->write(checksums_file);
 
  return 0;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

createAllLutXmlFilesLinAsciiCompCoder()

int HcalLutManager::createAllLutXmlFilesLinAsciiCompCoder	(	std::string	_tag,
		std::string	_lin_file,
		bool	split_by_crate = true
	)

Definition at line 1249 of file HcalLutManager.cc.

                                                                               {
  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
  std::map<int, std::shared_ptr<LutXml>> xml;
  if (!lut_checksums_xml) {
    lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
  }
 
  if (!_lin_file.empty()) {
    addLutMap(xml, getLutXmlFromAsciiMaster(_lin_file, _tag, -1, split_by_crate));
  }
  addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
  writeLutXmlFiles(xml, _tag, split_by_crate);
 
  std::string checksums_file = _tag + "_checksums.xml";
  lut_checksums_xml->write(checksums_file);
 
  return 0;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

createCompLutXmlFilesFromCoder()

int HcalLutManager::createCompLutXmlFilesFromCoder	(	std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 1146 of file HcalLutManager.cc.

                                                                                      {
  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
  std::map<int, std::shared_ptr<LutXml>> xml;
  if (!lut_checksums_xml) {
    lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
  }
 
  addLutMap(xml, getCompressionLutXmlFromCoder(_tag, split_by_crate));
 
  writeLutXmlFiles(xml, _tag, split_by_crate);
 
  std::string checksums_file = _tag + "_checksums.xml";
  lut_checksums_xml->write(checksums_file);
 
  return 0;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

createLinLutXmlFiles()

int HcalLutManager::createLinLutXmlFiles	(	std::string	_tag,
		std::string	_lin_file,
		bool	split_by_crate = true
	)

Definition at line 1101 of file HcalLutManager.cc.

                                                                                                 {
  //std::cout << "DEBUG1: split_by_crate = " << split_by_crate << std::endl;
  std::map<int, std::shared_ptr<LutXml>> xml;
  if (!lut_checksums_xml) {
    lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
  }
 
  if (!_lin_file.empty()) {
    addLutMap(xml, getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate));
  }
  writeLutXmlFiles(xml, _tag, split_by_crate);
 
  std::string checksums_file = _tag + "_checksums.xml";
  lut_checksums_xml->write(checksums_file);
 
  return 0;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

createLutXmlFiles_HBEFFromCoder_HOFromAscii() [1/2]

int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii	(	std::string	_tag,
		const HcalTPGCoder &	_coder,
		const CaloTPGTranscoderULUT &	_transcoder,
		std::string	_lin_file,
		bool	split_by_crate = true
	)

Definition at line 1185 of file HcalLutManager.cc.

                                                                                     {
  std::map<int, std::shared_ptr<LutXml>> xml;
  if (!lut_checksums_xml) {
    lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
  }
 
  if (!_lin_file.empty()) {
    const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
        getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
    addLutMap(xml, _lin_lut_ascii_xml);
  }
  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
      getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
  addLutMap(xml, _lin_lut_xml);
  //
  const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml =
      getCompressionLutXmlFromCoder(_transcoder, _tag, split_by_crate);
  addLutMap(xml, _comp_lut_xml);
 
  const std::map<int, std::shared_ptr<LutXml>> _HE_FG_lut_xml = getHEFineGrainLUTs(_tag, split_by_crate);
  addLutMap(xml, _HE_FG_lut_xml);
 
  writeLutXmlFiles(xml, _tag, split_by_crate);
 
  std::string checksums_file = _tag + "_checksums.xml";
  lut_checksums_xml->write(checksums_file);
 
  return 0;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

createLutXmlFiles_HBEFFromCoder_HOFromAscii() [2/2]

int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii	(	std::string	_tag,
		const HcalTPGCoder &	_coder,
		std::string	_lin_file,
		bool	split_by_crate = true
	)

Definition at line 1219 of file HcalLutManager.cc.

                                                                                     {
  std::map<int, std::shared_ptr<LutXml>> xml;
  if (!lut_checksums_xml) {
    lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
  }
 
  if (!_lin_file.empty()) {
    const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
        getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
    addLutMap(xml, _lin_lut_ascii_xml);
  }
  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
      getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
  addLutMap(xml, _lin_lut_xml);
  //
  const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml = getCompressionLutXmlFromCoder(_tag, split_by_crate);
  addLutMap(xml, _comp_lut_xml);
 
  writeLutXmlFiles(xml, _tag, split_by_crate);
 
  std::string checksums_file = _tag + "_checksums.xml";
  lut_checksums_xml->write(checksums_file);
 
  return 0;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

createLutXmlFiles_HBEFFromCoder_HOFromAscii_ZDC()

int HcalLutManager::createLutXmlFiles_HBEFFromCoder_HOFromAscii_ZDC	(	std::string	_tag,
		const HcalTPGCoder &	_coder,
		const CaloTPGTranscoderULUT &	_transcoder,
		std::string	_lin_file,
		bool	split_by_crate = true
	)

Definition at line 1672 of file HcalLutManager.cc.

                                                                                         {
  std::map<int, std::shared_ptr<LutXml>> xml;
  if (!lut_checksums_xml) {
    lut_checksums_xml = new XMLDOMBlock("CFGBrick", 1);
  }
 
  if (!_lin_file.empty()) {
    const std::map<int, std::shared_ptr<LutXml>> _lin_lut_ascii_xml =
        getLinearizationLutXmlFromAsciiMasterEmap(_lin_file, _tag, -1, split_by_crate);
    addLutMap(xml, _lin_lut_ascii_xml);
  }
  const std::map<int, std::shared_ptr<LutXml>> _lin_lut_xml =
      getLinearizationLutXmlFromCoderEmap(_coder, _tag, split_by_crate);
  addLutMap(xml, _lin_lut_xml);
  //
  const std::map<int, std::shared_ptr<LutXml>> _comp_lut_xml =
      getCompressionLutXmlFromCoder(_transcoder, _tag, split_by_crate);
  addLutMap(xml, _comp_lut_xml);
 
  const std::map<int, std::shared_ptr<LutXml>> _HE_FG_lut_xml = getHEFineGrainLUTs(_tag, split_by_crate);
  addLutMap(xml, _HE_FG_lut_xml);
 
  for (auto masktype : {0, 1, 2}) {
    const auto masks = getMasks(masktype, _tag, split_by_crate);
    addLutMap(xml, masks);
  }
  //
  const std::map<int, std::shared_ptr<LutXml>> _zdc_lut_xml = getZdcLutXml(_tag, split_by_crate);
  addLutMap(xml, _zdc_lut_xml);
 
  writeLutXmlFiles(xml, _tag, split_by_crate);
 
  std::string checksums_file = _tag + "_checksums.xml";
  lut_checksums_xml->write(checksums_file);
 
  return 0;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by HcalLutGenerator::analyze().

get_brickSet_from_oracle()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::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 at line 1469 of file HcalLutManager.cc.

                                                                                                           {
  HCALConfigDB* db = new HCALConfigDB();
  XMLProcessor::getInstance();  // initialize xerces-c engine
  //const std::string _accessor = "occi://CMS_HCL_PRTTYPE_HCAL_READER@anyhost/int2r?PASSWORD=HCAL_Reader_88,LHWM_VERSION=22";
  db->connect(_accessor);
  oracle::occi::Connection* _connection = db->getConnection();
 
  edm::LogInfo("HcalLutManager") << "Preparing to request the LUT CLOBs from the database...";
 
  //int crate = 0;
 
  //
  // _____ query is different for the old validation DB _________________
  //
  //std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB, CRATE FROM CMS_HCL_HCAL_CONDITION_OWNER.V_HCAL_TRIG_LOOKUP_TABLES");
  std::string query = ("SELECT TRIG_PRIM_LOOKUPTBL_DATA_CLOB, CRATE FROM CMS_HCL_HCAL_COND.V_HCAL_TRIG_LOOKUP_TABLES");
  //query+=toolbox::toString(" WHERE TAG_NAME='%s' AND CRATE=%d", tag.c_str(), crate);
  query += toolbox::toString(" WHERE TAG_NAME='%s'", tag.c_str());
 
  std::string brick_set;
 
  std::map<int, std::shared_ptr<LutXml>> lut_map;
 
  try {
    //SELECT
    edm::LogInfo("HcalLutManager") << "Executing the query...";
    Statement* stmt = _connection->createStatement();
    ResultSet* rs = stmt->executeQuery(query);
    edm::LogInfo("HcalLutManager") << "Executing the query... done";
 
    edm::LogInfo("HcalLutManager") << "Processing the query results...";
    //RooGKCounter _lines;
    while (rs->next()) {
      //_lines.count();
      oracle::occi::Clob clob = rs->getClob(1);
      int crate = rs->getInt(2);
      if (crate != -1) {  // not a brick with checksums
        edm::LogInfo("HcalLutManager") << "Getting LUTs for crate #" << crate << " out of the database...";
        brick_set = db->clobToString(clob);
        /*
    // FIXME: DEBUG lut xml files from simple strings
    stringstream file_name;
    ofstream out_file;
    file_name << tag << "_" << crate << "_debug" << ".xml";
    out_file . open( file_name.str().c_str() );
    out_file << brick_set;
    out_file . close();
    */
        const char* bs = brick_set.c_str();
        MemBufInputSource* lut_clob = new MemBufInputSource((const XMLByte*)bs, strlen(bs), "lut_clob", false);
        std::shared_ptr<LutXml> lut_xml = std::make_shared<LutXml>(*lut_clob);
        lut_map[crate] = lut_xml;
        edm::LogInfo("HcalLutManager") << "done";
      }
    }
    //Always terminate statement
    _connection->terminateStatement(stmt);
    //std::cout << "Query line count: " << _lines.getCount() << std::endl;
  } catch (SQLException& e) {
    XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,
                ::toolbox::toString("Oracle  exception : %s", e.getMessage().c_str()));
  }
 
  //std::cout << lut_map.size() << std::endl;
 
  db->disconnect();
  //delete db;
  return lut_map;
}

References cms::cuda::bs, dqmiodatasetharvest::db, MillePedeFileConverter_cfg::e, XMLProcessor::getInstance(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, and toolbox::toString().

get_checksum()

std::string HcalLutManager::get_checksum

(

std::vector< unsigned int > &

lut

)

get_subdetector()

HcalSubdetector HcalLutManager::get_subdetector ( std::string  _subdet )

static

Definition at line 117 of file HcalLutManager.cc.

                                                              {
  HcalSubdetector result;
  if (_det.find("HB") != std::string::npos)
    result = HcalBarrel;
  else if (_det.find("HE") != std::string::npos)
    result = HcalEndcap;
  else if (_det.find("HF") != std::string::npos)
    result = HcalForward;
  else if (_det.find("HO") != std::string::npos)
    result = HcalOuter;
  else
    result = HcalOther;
 
  return result;
}

References HcalBarrel, HcalEndcap, HcalForward, HcalOther, HcalOuter, and mps_fire::result.

get_time_stamp()

string HcalLutManager::get_time_stamp ( time_t  _time )

static

Definition at line 1282 of file HcalLutManager.cc.

                                                  {
  char timebuf[50];
  //strftime( timebuf, 50, "%c", gmtime( &_time ) );
  strftime(timebuf, 50, "%Y-%m-%d %H:%M:%S", gmtime(&_time));
  std::string creationstamp = timebuf;
 
  return creationstamp;
}

References AlCaHLTBitMon_QueryRunRegistry::string.

get_xml_files_from_db()

int HcalLutManager::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 at line 1452 of file HcalLutManager.cc.

                                                                                                         {
  std::map<int, std::shared_ptr<LutXml>> lut_map = get_brickSet_from_oracle(tag, db_accessor);
  if (split_by_crate) {
    writeLutXmlFiles(lut_map, tag, split_by_crate);
  } else {
    LutXml result;
    for (std::map<int, std::shared_ptr<LutXml>>::const_iterator xml = lut_map.begin(); xml != lut_map.end(); xml++) {
      result += *(xml->second);
    }
    std::stringstream out_file;
    out_file << tag << ".xml";
    result.write(out_file.str());
  }
 
  return 0;
}

References genParticles_cff::map, DeadROCCounter::out_file, mps_fire::result, and GlobalPosition_Frontier_DevDB_cff::tag.

getCompressionLutXmlFromAsciiMaster()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getCompressionLutXmlFromAsciiMaster	(	std::string	_filename,
		std::string	_tag,
		int	_crate = -1,
		bool	split_by_crate = true
	)

Definition at line 515 of file HcalLutManager.cc.

                                                                                                                {
  edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from ascii master file...";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  edm::LogInfo("HcalLutManager")
      << "instantiating CaloTPGTranscoderULUT in order to check the validity of (ieta,iphi)...";
  CaloTPGTranscoderULUT _coder;
 
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
  EMap _emap(emap);
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
 
  // read LUTs and their eta/phi/depth/subdet ranges
  HcalLutSet _set = getLutSetFromFile(_filename, 2);
  int lut_set_size = _set.lut.size();  // number of different luts
  edm::LogInfo("HcalLutManager") << "  ==> " << lut_set_size << " sets of different LUTs read from the master file";
 
  //loop over all EMap channels
  RooGKCounter _counter;
  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    LutXml::Config _cfg;
 
    // search for the correct LUT for a given channel,
    // higher LUT numbers have priority in case of overlapping
    int lut_index = -1;
    for (int i = 0; i < lut_set_size; i++) {
      if (row->subdet.find("HT") != std::string::npos &&
          (row->crate == _crate || _crate == -1) &&  // -1 stands for all crates
          _set.eta_min[i] <= row->ieta && _set.eta_max[i] >= row->ieta && _set.phi_min[i] <= row->iphi &&
          _set.phi_max[i] >= row->iphi && _coder.HTvalid(row->ieta, row->iphi, row->idepth / 10)) {
        lut_index = i;
      }
    }
    if (lut_index >= 0) {
      if (_xml.count(row->crate) == 0 && split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
      } else if (_xml.count(0) == 0 && !split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
      }
      _cfg.ieta = row->ieta;
      _cfg.iphi = row->iphi;
      _cfg.depth = row->idepth;
      _cfg.crate = row->crate;
      _cfg.slot = row->slot;
      if (row->topbottom.find('t') != std::string::npos)
        _cfg.topbottom = 1;
      else if (row->topbottom.find('b') != std::string::npos)
        _cfg.topbottom = 0;
      else if (row->topbottom.find('u') != std::string::npos)
        _cfg.topbottom = 2;
      else
        edm::LogWarning("HcalLutManager") << "fpga out of range...";
      _cfg.fiber = row->fiber;
      _cfg.fiberchan = row->fiberchan;
      if (_set.lut[lut_index].size() == 128)
        _cfg.lut_type = 1;
      else
        _cfg.lut_type = 2;
      _cfg.creationtag = _tag;
      _cfg.creationstamp = get_time_stamp(time(nullptr));
      _cfg.targetfirmware = "1.0.0";
      _cfg.formatrevision = "1";  //???
      // "original" definition of GENERALIZEDINDEX from Mike Weinberger
      //   int generalizedIndex=id.ietaAbs()+10000*id.iphi()+
      //       ((id.ieta()<0)?(0):(100));
      _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);
      _cfg.lut = _set.lut[lut_index];
      if (split_by_crate) {
        _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      } else {
        _xml[0]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      }
    }
  }
  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
                                 << "Generating compression (output) LUTs from ascii master file...DONE" << std::endl;
  return _xml;
}

References funct::abs(), RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, HcalLutSet::eta_max, HcalLutSet::eta_min, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, EMap::get_map(), RooGKCounter::getCount(), CaloTPGTranscoderULUT::HTvalid(), mps_fire::i, LutXml::_Config::ieta, LutXml::_Config::iphi, HcalLutSet::lut, LutXml::_Config::lut, LutXml::_Config::lut_type, HcalLutSet::phi_max, HcalLutSet::phi_min, LutXml::_Config::slot, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getCompressionLutXmlFromCoder() [1/2]

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getCompressionLutXmlFromCoder	(	const CaloTPGTranscoderULUT &	_coder,
		std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 914 of file HcalLutManager.cc.

                                                                              {
  edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from CaloTPGTranscoderULUT," << std::endl
                                 << "initialized from Event Setup" << std::endl;
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  EMap _emap(emap);
 
  std::map<int, unsigned int> maxsize;
 
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
 
  //need to equalize compression LUT size in each crate-slot, needed for mixed uHTR
  for (const auto& row : _map) {
    if (row.subdet.find("HT") == std::string::npos)
      continue;
    HcalTrigTowerDetId _detid(row.rawId);
    if (!cq->topo()->validHT(_detid))
      continue;
    int crot = 100 * row.crate + row.slot;
    unsigned int size = _coder.getCompressionLUT(_detid).size();
    if (maxsize.count(crot) == 0 || size > maxsize[crot])
      maxsize[crot] = size;
  }
 
  RooGKCounter _counter;
  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    LutXml::Config _cfg;
 
    if (row->subdet.find("HT") == std::string::npos)
      continue;
 
    HcalTrigTowerDetId _detid(row->rawId);
 
    if (!cq->topo()->validHT(_detid))
      continue;
 
    if (_xml.count(row->crate) == 0 && split_by_crate) {
      _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
    } else if (_xml.count(0) == 0 && !split_by_crate) {
      _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
    }
 
    _cfg.ieta = row->ieta;
    _cfg.iphi = row->iphi;
    _cfg.depth = row->idepth;
    _cfg.crate = row->crate;
    _cfg.slot = row->slot;
    if (row->topbottom.find('t') != std::string::npos)
      _cfg.topbottom = 1;
    else if (row->topbottom.find('b') != std::string::npos)
      _cfg.topbottom = 0;
    else if (row->topbottom.find('u') != std::string::npos)
      _cfg.topbottom = 2;
    else
      edm::LogWarning("HcalLutManager") << "fpga out of range...";
    _cfg.fiber = row->fiber;
    _cfg.fiberchan = row->fiberchan;
    _cfg.lut_type = 2;
    _cfg.creationtag = _tag;
    _cfg.creationstamp = get_time_stamp(time(nullptr));
    _cfg.targetfirmware = "1.0.0";
    _cfg.formatrevision = "1";                                                           //???
    _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);  //is this used for anything?
 
    _cfg.lut = _coder.getCompressionLUT(_detid);
 
    int crot = 100 * row->crate + row->slot;
    unsigned int size = _cfg.lut.size();
    if (size < maxsize[crot]) {
      edm::LogWarning("HcalLutManager") << " resizing LUT for " << _detid << ", channel=[" << _cfg.crate << ":"
                                        << _cfg.slot << ":" << _cfg.fiber << ":" << _cfg.fiberchan
                                        << "], using value=" << _cfg.lut[size - 1] << std::endl;
      for (unsigned int i = size; i < maxsize[crot]; ++i)
        _cfg.lut.push_back(_cfg.lut[size - 1]);
    }
 
    if (split_by_crate) {
      _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
      _counter.count();
    } else {
      _xml[0]->addLut(_cfg, lut_checksums_xml);
      _counter.count();
    }
  }
  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
                                 << "Generating compression (output) LUTs from CaloTPGTranscoderULUT...DONE"
                                 << std::endl;
 
  return _xml;
}

References funct::abs(), RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, EMap::get_map(), CaloTPGTranscoderULUT::getCompressionLUT(), RooGKCounter::getCount(), mps_fire::i, LutXml::_Config::ieta, LutXml::_Config::iphi, LutXml::_Config::lut, LutXml::_Config::lut_type, cmsswSequenceInfo::maxsize, findQualityFiles::size, LutXml::_Config::slot, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getCompressionLutXmlFromCoder() [2/2]

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getCompressionLutXmlFromCoder	(	std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 1007 of file HcalLutManager.cc.

                                                                                                          {
  edm::LogInfo("HcalLutManager") << "Generating compression (output) LUTs from CaloTPGTranscoderULUT";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v5_080208.txt");
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
  EMap _emap(emap);
 
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
 
  // read LUTs and their eta/phi/depth/subdet ranges
  //HcalLutSet _set = getLutSetFromFile( _filename, 2 );
  //int lut_set_size = _set.lut.size(); // number of different luts
 
  CaloTPGTranscoderULUT _coder;
 
  //loop over all EMap channels
  RooGKCounter _counter;
  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    LutXml::Config _cfg;
 
    // only trigger tower channels
    // and valid (ieta,iphi)
    const int tp_version = row->idepth / 10;
    if (row->subdet.find("HT") != std::string::npos && _coder.HTvalid(row->ieta, row->iphi, tp_version)) {
      if (_xml.count(row->crate) == 0 && split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
      } else if (_xml.count(0) == 0 && !split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
      }
      _cfg.ieta = row->ieta;
      _cfg.iphi = row->iphi;
      _cfg.depth = row->idepth;
      _cfg.crate = row->crate;
      _cfg.slot = row->slot;
      if (row->topbottom.find('t') != std::string::npos)
        _cfg.topbottom = 1;
      else if (row->topbottom.find('b') != std::string::npos)
        _cfg.topbottom = 0;
      else if (row->topbottom.find('u') != std::string::npos)
        _cfg.topbottom = 2;
      else
        edm::LogWarning("HcalLutManager") << "fpga out of range...";
      _cfg.fiber = row->fiber;
      _cfg.fiberchan = row->fiberchan;
      _cfg.lut_type = 2;
      _cfg.creationtag = _tag;
      _cfg.creationstamp = get_time_stamp(time(nullptr));
      _cfg.targetfirmware = "1.0.0";
      _cfg.formatrevision = "1";  //???
      // "original" definition of GENERALIZEDINDEX from Mike Weinberger
      //   int generalizedIndex=id.ietaAbs()+10000*id.iphi()+
      //       ((id.ieta()<0)?(0):(100));
      _cfg.generalizedindex = _cfg.iphi * 10000 + (row->ieta > 0) * 100 + abs(row->ieta);
 
      // FIXME: work around bug in emap v6: rawId wasn't filled
      //HcalTrigTowerDetId _detid(row->rawId);
      HcalTrigTowerDetId _detid(row->ieta, row->iphi);
 
      _cfg.lut = _coder.getCompressionLUT(_detid);
 
      if (split_by_crate) {
        _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      } else {
        _xml[0]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      }
    }
  }
  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
                                 << "Generating compression (output) LUTs from CaloTPGTranscoderULUT...DONE"
                                 << std::endl;
  return _xml;
}

References funct::abs(), RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, EMap::get_map(), CaloTPGTranscoderULUT::getCompressionLUT(), RooGKCounter::getCount(), CaloTPGTranscoderULUT::HTvalid(), LutXml::_Config::ieta, LutXml::_Config::iphi, LutXml::_Config::lut, LutXml::_Config::lut_type, LutXml::_Config::slot, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getHEFineGrainLUTs()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getHEFineGrainLUTs	(	std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 835 of file HcalLutManager.cc.

                                                                                                         {
  edm::LogInfo("HcalLutManager") << "Generating HE fine grain LUTs";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  EMap _emap(emap);
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
 
  RooGKCounter _counter;
  //loop over all EMap channels
  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    if (row->subdet.find("HT") != string::npos && row->subdet.size() == 2) {
      int abseta = abs(row->ieta);
      const HcalTopology* topo = cq->topo();
      if (abseta <= topo->lastHBRing() or abseta > topo->lastHERing())
        continue;
      if (abseta >= topo->firstHEDoublePhiRing() and row->fiberchan % 2 == 1)
        continue;  //do only actual physical towers
      LutXml::Config _cfg;
 
      if (_xml.count(row->crate) == 0 && split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
      } else if (_xml.count(0) == 0 && !split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
      }
      _cfg.ieta = row->ieta;
      _cfg.iphi = row->iphi;
      _cfg.depth = row->idepth;
      _cfg.crate = row->crate;
      _cfg.slot = row->slot;
      if (row->topbottom.find('t') != std::string::npos)
        _cfg.topbottom = 1;
      else if (row->topbottom.find('b') != std::string::npos)
        _cfg.topbottom = 0;
      else if (row->topbottom.find('u') != std::string::npos)
        _cfg.topbottom = 2;
      else
        edm::LogWarning("HcalLutManager") << "fpga out of range...";
      _cfg.fiber = row->fiber;
      _cfg.fiberchan = row->fiberchan;
      _cfg.lut_type = 4;
      _cfg.creationtag = _tag;
      _cfg.creationstamp = get_time_stamp(time(nullptr));
      _cfg.targetfirmware = "1.0.0";
      _cfg.formatrevision = "1";  //???
      _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
                              (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
      // fine grain LUTs only relevant for HE
      HcalSubdetector _subdet = HcalEndcap;
      HcalDetId _detid(_subdet, row->ieta, row->iphi, row->idepth);
 
      HcalFinegrainBit fg_algo(conditions->getHcalTPParameters()->getFGVersionHBHE());
 
      // loop over all possible configurations,
      // computing the LUT for each
      const int n_fgab_bits = 2048;
      for (int i = 0; i < 2 * n_fgab_bits; i++) {
        HcalFinegrainBit::Tower tow;
        for (int k = 0; k < 6; k++) {
          tow[0][k] = (1 << k) & i;
          tow[1][k] = (1 << (k + 6)) & i;
        }
        _cfg.lut.push_back(fg_algo.compute(tow).to_ulong());
      }
 
      if (split_by_crate) {
        _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      } else {
        _xml[0]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      }
    }
  }
  edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
                                 << "Generating HE fine grain LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
  return _xml;
}

References funct::abs(), submitPVValidationJobs::conditions, RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, LutXml::_Config::fiber, LutXml::_Config::fiberchan, HcalTopology::firstHEDoublePhiRing(), LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, EMap::get_map(), RooGKCounter::getCount(), HcalEndcap, mps_fire::i, LutXml::_Config::ieta, LutXml::_Config::iphi, dqmdumpme::k, HcalTopology::lastHERing(), LutXml::_Config::lut, LutXml::_Config::lut_type, or, LutXml::_Config::slot, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getInt()

int HcalLutManager::getInt ( std::string  number )

static

Definition at line 111 of file HcalLutManager.cc.

                                           {
  int result;
  sscanf(number.c_str(), "%d", &result);
  return result;
}

References contentValuesFiles::number, and mps_fire::result.

Referenced by getLutSetFromFile().

getLinearizationLutXmlFromAsciiMasterEmap()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getLinearizationLutXmlFromAsciiMasterEmap	(	std::string	_filename,
		std::string	_tag,
		int	_crate,
		bool	split_by_crate = true
	)

Definition at line 339 of file HcalLutManager.cc.

                                                                                                                      {
  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  EMap _emap(emap);
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
 
  // read LUTs and their eta/phi/depth/subdet ranges
  HcalLutSet _set = getLutSetFromFile(_filename);
  int lut_set_size = _set.lut.size();  // number of different luts
  edm::LogInfo("HcalLutManager") << "  ==> " << lut_set_size << " sets of different LUTs read from the master file";
 
  // setup "zero" LUT for channel masking
  std::vector<unsigned int> zeroLut;
  for (size_t adc = 0; adc < 128; adc++)
    zeroLut.push_back(0);
 
  RooGKCounter _counter;
  //loop over all EMap channels
  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    if ((row->subdet.find("HB") != string::npos || row->subdet.find("HE") != string::npos ||
         row->subdet.find("HO") != string::npos || row->subdet.find("HF") != string::npos) &&
        row->subdet.size() == 2) {
      LutXml::Config _cfg;
 
      // search for the correct LUT for a given channel,
      // higher LUT numbers have priority in case of overlapping
      int lut_index = -1;
      for (int i = 0; i < lut_set_size; i++) {
        if ((row->crate == _crate || _crate == -1) &&  // -1 stands for all crates
            _set.eta_min[i] <= row->ieta && _set.eta_max[i] >= row->ieta && _set.phi_min[i] <= row->iphi &&
            _set.phi_max[i] >= row->iphi && _set.depth_min[i] <= row->idepth && _set.depth_max[i] >= row->idepth &&
            _set.subdet[i].find(row->subdet) != string::npos) {
          lut_index = i;
        }
      }
      if (lut_index >= 0) {
        if (_xml.count(row->crate) == 0 && split_by_crate) {
          _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
        } else if (_xml.count(0) == 0 && !split_by_crate) {
          _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
        }
        _cfg.ieta = row->ieta;
        _cfg.iphi = row->iphi;
        _cfg.depth = row->idepth;
        _cfg.crate = row->crate;
        _cfg.slot = row->slot;
        if (row->topbottom.find('t') != std::string::npos)
          _cfg.topbottom = 1;
        else if (row->topbottom.find('b') != std::string::npos)
          _cfg.topbottom = 0;
        else if (row->topbottom.find('u') != std::string::npos)
          _cfg.topbottom = 2;
        else
          edm::LogWarning("HcalLutManager") << "fpga out of range...";
        _cfg.fiber = row->fiber;
        _cfg.fiberchan = row->fiberchan;
        _cfg.lut_type = 1;
        _cfg.creationtag = _tag;
        _cfg.creationstamp = get_time_stamp(time(nullptr));
        _cfg.targetfirmware = "1.0.0";
        _cfg.formatrevision = "1";  //???
        // "original" definition of GENERALIZEDINDEX from Mike Weinberger
        //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
        //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
        _cfg.generalizedindex =
            _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
            (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
        //
        // consider channel status here
        DetId _detId(row->rawId);
        uint32_t status_word = cq->getValues(_detId)->getValue();
        if ((status_word & status_word_to_mask) > 0) {
          _cfg.lut = zeroLut;
        } else {
          _cfg.lut = _set.lut[lut_index];
        }
        if (split_by_crate) {
          _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
          _counter.count();
        } else {
          _xml[0]->addLut(_cfg, lut_checksums_xml);
          _counter.count();
        }
      }
    }
  }
  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
                                 << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
  return _xml;
}

References funct::abs(), ecalLiteDTU::adc(), RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, HcalLutSet::depth_max, HcalLutSet::depth_min, HcalLutSet::eta_max, HcalLutSet::eta_min, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, EMap::get_map(), RooGKCounter::getCount(), mps_fire::i, LutXml::_Config::ieta, LutXml::_Config::iphi, HcalLutSet::lut, LutXml::_Config::lut, LutXml::_Config::lut_type, HcalLutSet::phi_max, HcalLutSet::phi_min, LutXml::_Config::slot, HcalLutSet::subdet, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getLinearizationLutXmlFromAsciiMasterEmap_new()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getLinearizationLutXmlFromAsciiMasterEmap_new	(	std::string	_filename,
		std::string	_tag,
		int	_crate,
		bool	split_by_crate = true
	)

Definition at line 435 of file HcalLutManager.cc.

                                                                          {
  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  // read LUTs and their eta/phi/depth/subdet ranges
  HcalLutSet _set = getLutSetFromFile(_filename);
  int lut_set_size = _set.lut.size();  // number of different luts
  edm::LogInfo("HcalLutManager") << "  ==> " << lut_set_size << " sets of different LUTs read from the master file";
 
  RooGKCounter _counter;
  //loop over all EMap channels
  for (_iter.begin(); !_iter.end(); _iter.next()) {
    HcalSubdetector _subdet = _iter.getHcalSubdetector();
    if ((_subdet == HcalBarrel || _subdet == HcalEndcap || _subdet == HcalForward || _subdet == HcalOuter)) {
      int _ieta = _iter.getIeta();
      int _iphi = _iter.getIphi();
      int _depth = _iter.getDepth();
 
      // FIXME: this is probably wrong, raw ids are different
      HcalElectronicsId _eId(_iter.getHcalGenericDetId().rawId());
      int aCrate = _eId.readoutVMECrateId();
      int aSlot = _eId.htrSlot();
      int aTopBottom = _eId.htrTopBottom();
      int aFiber = _eId.fiberIndex();
      int aFiberChan = _eId.fiberChanId();
 
      LutXml::Config _cfg;
 
      // search for the correct LUT for a given channel,
      // higher LUT numbers have priority in case of overlapping
      int lut_index = -1;
      for (int i = 0; i < lut_set_size; i++) {
        if ((aCrate == _crate || _crate == -1) &&  // -1 stands for all crates
            _set.eta_min[i] <= _ieta && _set.eta_max[i] >= _ieta && _set.phi_min[i] <= _iphi &&
            _set.phi_max[i] >= _iphi && _set.depth_min[i] <= _depth && _set.depth_max[i] >= _depth &&
            _set.subdet[i].find(_ass.getSubdetectorString(_subdet)) != string::npos) {
          lut_index = i;
        }
      }
      if (lut_index >= 0) {
        if (_xml.count(aCrate) == 0 && split_by_crate) {
          _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(aCrate, std::make_shared<LutXml>()));
        } else if (_xml.count(0) == 0 && !split_by_crate) {
          _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
        }
        _cfg.ieta = _ieta;
        _cfg.iphi = _iphi;
        _cfg.depth = _depth;
        _cfg.crate = aCrate;
        _cfg.slot = aSlot;
        _cfg.topbottom = aTopBottom;
        _cfg.fiber = aFiber;
        _cfg.fiberchan = aFiberChan;
        _cfg.lut_type = 1;
        _cfg.creationtag = _tag;
        _cfg.creationstamp = get_time_stamp(time(nullptr));
        _cfg.targetfirmware = "1.0.0";
        _cfg.formatrevision = "1";  //???
        // "original" definition of GENERALIZEDINDEX from Mike Weinberger
        //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
        //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
        _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (_ieta > 0) * 100 + abs(_ieta) +
                                (((_subdet == HcalForward) && abs(_ieta) == 29) ? (4 * 10000) : (0));
        _cfg.lut = _set.lut[lut_index];
        if (split_by_crate) {
          _xml[aCrate]->addLut(_cfg, lut_checksums_xml);
          _counter.count();
        } else {
          _xml[0]->addLut(_cfg, lut_checksums_xml);
          _counter.count();
        }
      }
    }
  }
  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
                                 << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
  return _xml;
}

References funct::abs(), RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, HcalLutSet::depth_max, HcalLutSet::depth_min, HcalLutSet::eta_max, HcalLutSet::eta_min, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, RooGKCounter::getCount(), HcalBarrel, HcalEndcap, HcalForward, HcalOuter, mps_fire::i, LutXml::_Config::ieta, LutXml::_Config::iphi, HcalLutSet::lut, LutXml::_Config::lut, LutXml::_Config::lut_type, HcalLutSet::phi_max, HcalLutSet::phi_min, HcalElectronicsId::readoutVMECrateId(), LutXml::_Config::slot, HcalLutSet::subdet, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getLinearizationLutXmlFromCoder()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getLinearizationLutXmlFromCoder	(	const HcalTPGCoder &	_coder,
		std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 601 of file HcalLutManager.cc.

                                                                                                            {
  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
  //std::vector<EMap::EMapRow> & _map = _emap.get_map();
  //std::cout << "EMap contains " << _map . size() << " entries" << std::endl;
 
  LMap _lmap;
  _lmap.read("backup/HCALmapHBEF.txt", "HBEF");
  // HO is not part of trigger, so TPGCoder cannot generate LUTs for it
  //_lmap . read( "backup/HCALmapHO.txt", "HO" );
  std::map<int, LMapRow>& _map = _lmap.get_map();
  edm::LogInfo("HcalLutManager") << "LMap contains " << _map.size() << " channels";
 
  // read LUTs and their eta/phi/depth/subdet ranges
  //HcalLutSet _set = getLinearizationLutSetFromCoder();
  //int lut_set_size = _set.lut.size(); // number of different luts
 
  //loop over all HCAL channels
  RooGKCounter _counter;
  for (std::map<int, LMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    LutXml::Config _cfg;
 
    if (_xml.count(row->second.crate) == 0 && split_by_crate) {
      _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->second.crate, std::make_shared<LutXml>()));
    } else if (_xml.count(0) == 0 && !split_by_crate) {
      _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
    }
    _cfg.ieta = row->second.side * row->second.eta;
    _cfg.iphi = row->second.phi;
    _cfg.depth = row->second.depth;
    _cfg.crate = row->second.crate;
    _cfg.slot = row->second.htr;
    if (row->second.fpga.find("top") != std::string::npos)
      _cfg.topbottom = 1;
    else if (row->second.fpga.find("bot") != std::string::npos)
      _cfg.topbottom = 0;
    else
      edm::LogWarning("HcalLutManager") << "fpga out of range...";
    // FIXME: probably fixed. fiber==htr_fi, not rm_fi in LMAP notation.
    //_cfg.fiber = row->second.rm_fi;
    _cfg.fiber = row->second.htr_fi;
    _cfg.fiberchan = row->second.fi_ch;
    _cfg.lut_type = 1;
    _cfg.creationtag = _tag;
    _cfg.creationstamp = get_time_stamp(time(nullptr));
    _cfg.targetfirmware = "1.0.0";
    _cfg.formatrevision = "1";  //???
    // "original" definition of GENERALIZEDINDEX from Mike Weinberger
    //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
    //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
    _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->second.side > 0) * 100 + row->second.eta +
                            ((row->second.det == HcalForward && row->second.eta == 29) ? (4 * 10000) : (0));
 
    //HcalDetId _detid(row->first);
    HcalDetId _detid(row->second.det, row->second.side * row->second.eta, row->second.phi, row->second.depth);
    //std::cout << "### DEBUG: rawid = " << _detid.rawId() << std::endl;
 
    //std::cout << "### DEBUG: subdetector = " << row->second.det << std::endl;
    std::vector<unsigned short> coder_lut = _coder.getLinearizationLUT(_detid);
    for (std::vector<unsigned short>::const_iterator _i = coder_lut.begin(); _i != coder_lut.end(); _i++) {
      unsigned int _temp = (unsigned int)(*_i);
      //if (_temp!=0) std::cout << "DEBUG non-zero LUT!!!!!!!!!!!!!!!" << (*_i) << "     " << _temp << std::endl;
      //unsigned int _temp = 0;
      _cfg.lut.push_back(_temp);
    }
    if (split_by_crate) {
      _xml[row->second.crate]->addLut(_cfg, lut_checksums_xml);
      _counter.count();
    } else {
      _xml[0]->addLut(_cfg, lut_checksums_xml);
      _counter.count();
    }
  }
  edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
                                 << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
  return _xml;
}

References RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, LMap::get_map(), RooGKCounter::getCount(), HcalTPGCoder::getLinearizationLUT(), HcalForward, LutXml::_Config::ieta, createfilelist::int, LutXml::_Config::iphi, LutXml::_Config::lut, LutXml::_Config::lut_type, LMap::read(), LutXml::_Config::slot, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getLinearizationLutXmlFromCoderEmap()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getLinearizationLutXmlFromCoderEmap	(	const HcalTPGCoder &	_coder,
		std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 757 of file HcalLutManager.cc.

                                                                                                                {
  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  EMap _emap(emap);
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " entries";
 
  RooGKCounter _counter;
  //loop over all EMap channels
  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    if ((row->subdet.find("HB") != string::npos || row->subdet.find("HE") != string::npos ||
         row->subdet.find("HF") != string::npos) &&
        row->subdet.size() == 2) {
      LutXml::Config _cfg;
 
      if (_xml.count(row->crate) == 0 && split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
      } else if (_xml.count(0) == 0 && !split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
      }
      _cfg.ieta = row->ieta;
      _cfg.iphi = row->iphi;
      _cfg.depth = row->idepth;
      _cfg.crate = row->crate;
      _cfg.slot = row->slot;
      if (row->topbottom.find('t') != std::string::npos)
        _cfg.topbottom = 1;
      else if (row->topbottom.find('b') != std::string::npos)
        _cfg.topbottom = 0;
      else if (row->topbottom.find('u') != std::string::npos)
        _cfg.topbottom = 2;
      else
        edm::LogWarning("HcalLutManager") << "fpga out of range...";
      _cfg.fiber = row->fiber;
      _cfg.fiberchan = row->fiberchan;
      _cfg.lut_type = 1;
      _cfg.creationtag = _tag;
      _cfg.creationstamp = get_time_stamp(time(nullptr));
      _cfg.targetfirmware = "1.0.0";
      _cfg.formatrevision = "1";  //???
      // "original" definition of GENERALIZEDINDEX from Mike Weinberger
      //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
      //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
      _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->ieta > 0) * 100 + abs(row->ieta) +
                              (((row->subdet.find("HF") != string::npos) && abs(row->ieta) == 29) ? (4 * 10000) : (0));
      HcalSubdetector _subdet;
      if (row->subdet.find("HB") != string::npos)
        _subdet = HcalBarrel;
      else if (row->subdet.find("HE") != string::npos)
        _subdet = HcalEndcap;
      else if (row->subdet.find("HO") != string::npos)
        _subdet = HcalOuter;
      else if (row->subdet.find("HF") != string::npos)
        _subdet = HcalForward;
      else
        _subdet = HcalOther;
      HcalDetId _detid(_subdet, row->ieta, row->iphi, row->idepth);
 
      for (const auto i : _coder.getLinearizationLUT(_detid))
        _cfg.lut.push_back(i);
 
      if (split_by_crate) {
        _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      } else {
        _xml[0]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      }
    }
  }
  edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
                                 << "Generating linearization (input) LUTs from HcaluLUTTPGCoder...DONE" << std::endl;
  return _xml;
}

References funct::abs(), RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, EMap::get_map(), RooGKCounter::getCount(), HcalTPGCoder::getLinearizationLUT(), HcalBarrel, HcalEndcap, HcalForward, HcalOther, HcalOuter, mps_fire::i, LutXml::_Config::ieta, LutXml::_Config::iphi, LutXml::_Config::lut, LutXml::_Config::lut_type, LutXml::_Config::slot, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getLutFromXml()

std::vector< unsigned int > HcalLutManager::getLutFromXml	(	std::string	tag,
		uint32_t	_rawid,
		hcal::ConfigurationDatabase::LUTType	_lt
	)

Definition at line 1391 of file HcalLutManager.cc.

                                                                                              {
  edm::LogInfo("HcalLutManager") << "getLutFromXml (new version) is not implemented. Use getLutFromXml_old() for now";
 
  std::vector<unsigned int> result;
 
  return result;
}

References mps_fire::result.

getLutFromXml_old()

std::vector< unsigned int > HcalLutManager::getLutFromXml_old	(	std::string	tag,
		uint32_t	_rawid,
		hcal::ConfigurationDatabase::LUTType	_lt
	)

Definition at line 1402 of file HcalLutManager.cc.

                                                                                                  {
  if (!lmap) {
    edm::LogError("HcalLutManager") << "Cannot find LUT without LMAP, exiting...";
    exit(-1);
  }
  if (!db) {
    edm::LogError("HcalLutManager") << "Cannot find LUT, no source (local XML file), exiting...";
    exit(-1);
  }
 
  std::vector<unsigned int> result;
 
  std::map<int, LMapRow>& _map = lmap->get_map();
  //std::cout << "HcalLutManager: LMap contains " << _map . size() << " channels (out of 9072 total)" << std::endl;
 
  HcalDetId _id(_rawid);
 
  unsigned int _crate, _slot, _fiber, _channel;
  std::string _fpga;
  int topbottom, luttype;
 
  // FIXME: check validity of _rawid
  if (_map.find(_rawid) != _map.end()) {
    _crate = _map[_rawid].crate;
    _slot = _map[_rawid].htr;
    _fiber = _map[_rawid].htr_fi;
    _channel = _map[_rawid].fi_ch;
    _fpga = _map[_rawid].fpga;
 
    if (_fpga.find("top") != std::string::npos)
      topbottom = 1;
    else if (_fpga.find("bot") != std::string::npos)
      topbottom = 0;
    else {
      edm::LogError("HcalLutManager") << "Irregular LMAP fpga value... do not know what to do - exiting";
      exit(-1);
    }
    if (_lt == hcal::ConfigurationDatabase::LinearizerLUT)
      luttype = 1;
    else
      luttype = 2;
 
    result = db->getOnlineLUT(tag, _crate, _slot, topbottom, _fiber, _channel, luttype);
  }
 
  return result;
}

References dqmiodatasetharvest::db, beamvalidation::exit(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, and GlobalPosition_Frontier_DevDB_cff::tag.

getLutSetFromFile()

HcalLutSet HcalLutManager::getLutSetFromFile	(	std::string	_filename,
		int	_type = 1
	)

Definition at line 170 of file HcalLutManager.cc.

                                                                           {
  HcalLutSet _lutset;
 
  ifstream infile(_filename.c_str());
  std::string buf;
 
  if (infile.is_open()) {
    edm::LogInfo("HcalLutManager") << "File " << _filename << " is open..." << std::endl
                                   << "Reading LUTs and their eta/phi/depth/subdet ranges...";
 
    // get label
    getline(infile, _lutset.label);
 
    if (_type == 1) {  // for linearization LUTs get subdetectors (default)
      //get subdetectors
      getline(infile, buf);
      _lutset.subdet = HcalQIEManager::splitString(buf);
    }
 
    //get min etas
    std::vector<std::string> buf_vec;
    getline(infile, buf);
    buf_vec = HcalQIEManager::splitString(buf);
    for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
      _lutset.eta_min.push_back(HcalLutManager::getInt(*iter));
    }
 
    //get max etas
    getline(infile, buf);
    buf_vec = HcalQIEManager::splitString(buf);
    for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
      _lutset.eta_max.push_back(HcalLutManager::getInt(*iter));
    }
 
    //get min phis
    getline(infile, buf);
    buf_vec = HcalQIEManager::splitString(buf);
    for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
      _lutset.phi_min.push_back(HcalLutManager::getInt(*iter));
    }
 
    //get max phis
    getline(infile, buf);
    buf_vec = HcalQIEManager::splitString(buf);
    for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
      _lutset.phi_max.push_back(HcalLutManager::getInt(*iter));
    }
 
    if (_type == 1) {  // for linearization LUTs get depth range (default)
      //get min depths
      getline(infile, buf);
      buf_vec = HcalQIEManager::splitString(buf);
      for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
        _lutset.depth_min.push_back(HcalLutManager::getInt(*iter));
      }
 
      //get max depths
      getline(infile, buf);
      buf_vec = HcalQIEManager::splitString(buf);
      for (std::vector<std::string>::const_iterator iter = buf_vec.begin(); iter != buf_vec.end(); iter++) {
        _lutset.depth_max.push_back(HcalLutManager::getInt(*iter));
      }
    }
 
    bool first_lut_entry = true;
    while (getline(infile, buf)) {
      buf_vec = HcalQIEManager::splitString(buf);
      for (unsigned int i = 0; i < buf_vec.size(); i++) {
        if (first_lut_entry) {
          std::vector<unsigned int> _l;
          _lutset.lut.push_back(_l);
        }
        _lutset.lut[i].push_back(HcalLutManager::getInt(buf_vec[i]));
      }
      first_lut_entry = false;
    }
  }
 
  edm::LogInfo("HcalLutManager") << "done.";
 
  return _lutset;
}

References visDQMUpload::buf, HcalLutSet::depth_max, HcalLutSet::depth_min, HcalLutSet::eta_max, HcalLutSet::eta_min, getInt(), mps_fire::i, timingPdfMaker::infile, HcalLutSet::label, HcalLutSet::lut, HcalLutSet::phi_max, HcalLutSet::phi_min, HcalQIEManager::splitString(), AlCaHLTBitMon_QueryRunRegistry::string, and HcalLutSet::subdet.

Referenced by HcalLutManager_test::getLutSetFromFile_test().

getLutXml()

std::string & HcalLutManager::getLutXml

(

std::vector< unsigned int > &

_lut

)

Definition at line 95 of file HcalLutManager.cc.

                                                                  {
  if (lut_xml)
    delete lut_xml;
 
  lut_xml = new LutXml();
 
  LutXml::Config _config;
  _config.lut = _lut;
  lut_xml->addLut(_config);
  lut_xml->addLut(_config);
  lut_xml->addLut(_config);
 
  //return lut_xml->getString();
  return lut_xml->getCurrentBrick();
}

References LutXml::_Config::lut.

getLutXmlFromAsciiMaster()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getLutXmlFromAsciiMaster	(	std::string	_filename,
		std::string	_tag,
		int	_crate = -1,
		bool	split_by_crate = true
	)

Definition at line 253 of file HcalLutManager.cc.

                                                                                                     {
  edm::LogInfo("HcalLutManager") << "Generating linearization (input) LUTs from ascii master file...";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  LMap _lmap;
  _lmap.read("./backup/HCALmapHBEF.txt", "HBEF");
  _lmap.read("./backup/HCALmapHO.txt", "HO");
  std::map<int, LMapRow>& _map = _lmap.get_map();
  edm::LogInfo("HcalLutManager") << "LMap contains " << _map.size() << " channels";
 
  // read LUTs and their eta/phi/depth/subdet ranges
  HcalLutSet _set = getLutSetFromFile(_filename);
  int lut_set_size = _set.lut.size();  // number of different luts
 
  RooGKCounter _counter;
  //loop over all HCAL channels
  for (std::map<int, LMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    LutXml::Config _cfg;
 
    // search for the correct LUT for a given channel,
    // higher LUT numbers have priority in case of overlapping
    int lut_index = -1;
    for (int i = 0; i < lut_set_size; i++) {
      if ((row->second.crate == _crate || _crate == -1) &&  // -1 stands for all crates
          _set.eta_min[i] <= row->second.side * row->second.eta &&
          _set.eta_max[i] >= row->second.side * row->second.eta && _set.phi_min[i] <= row->second.phi &&
          _set.phi_max[i] >= row->second.phi && _set.depth_min[i] <= row->second.depth &&
          _set.depth_max[i] >= row->second.depth && get_subdetector(_set.subdet[i]) == row->second.det) {
        lut_index = i;
      }
    }
    if (lut_index >= 0) {
      if (_xml.count(row->second.crate) == 0 && split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->second.crate, std::make_shared<LutXml>()));
      } else if (_xml.count(0) == 0 && !split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
      }
      _cfg.ieta = row->second.side * row->second.eta;
      _cfg.iphi = row->second.phi;
      _cfg.depth = row->second.depth;
      _cfg.crate = row->second.crate;
      _cfg.slot = row->second.htr;
      if (row->second.fpga.find("top") != std::string::npos)
        _cfg.topbottom = 1;
      else if (row->second.fpga.find("bot") != std::string::npos)
        _cfg.topbottom = 0;
      else
        edm::LogWarning("HcalLutManager") << "fpga out of range...";
      // FIXME: probably fixed. fiber==htr_fi, not rm_fi in LMAP notation.
      //_cfg.fiber = row->second.rm_fi;
      _cfg.fiber = row->second.htr_fi;
      _cfg.fiberchan = row->second.fi_ch;
      if (_set.lut[lut_index].size() == 128)
        _cfg.lut_type = 1;
      else
        _cfg.lut_type = 2;
      _cfg.creationtag = _tag;
      _cfg.creationstamp = get_time_stamp(time(nullptr));
      _cfg.targetfirmware = "1.0.0";
      _cfg.formatrevision = "1";  //???
      // "original" definition of GENERALIZEDINDEX from Mike Weinberger
      //    int generalizedIndex=id.ietaAbs()+1000*id.depth()+10000*id.iphi()+
      //        ((id.ieta()<0)?(0):(100))+((id.subdet()==HcalForward && id.ietaAbs()==29)?(4*10000):(0));
      _cfg.generalizedindex = _cfg.iphi * 10000 + _cfg.depth * 1000 + (row->second.side > 0) * 100 + row->second.eta +
                              ((row->second.det == HcalForward && row->second.eta == 29) ? (4 * 10000) : (0));
      _cfg.lut = _set.lut[lut_index];
      if (split_by_crate) {
        _xml[row->second.crate]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      } else {
        _xml[0]->addLut(_cfg, lut_checksums_xml);
        _counter.count();
      }
    }
  }
  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
                                 << "Generating linearization (input) LUTs from ascii master file...DONE" << std::endl;
  return _xml;
}

References RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, HcalLutSet::depth_max, HcalLutSet::depth_min, HcalLutSet::eta_max, HcalLutSet::eta_min, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, LMap::get_map(), RooGKCounter::getCount(), HcalForward, mps_fire::i, LutXml::_Config::ieta, LutXml::_Config::iphi, HcalLutSet::lut, LutXml::_Config::lut, LutXml::_Config::lut_type, HcalLutSet::phi_max, HcalLutSet::phi_min, LMap::read(), LutXml::_Config::slot, HcalLutSet::subdet, LutXml::_Config::targetfirmware, ntuplemaker::time, and LutXml::_Config::topbottom.

getMasks()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getMasks	(	int	var,
		std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 683 of file HcalLutManager.cc.

                                                                                                             {
  edm::LogInfo("HcalLutManager") << "Generating TDC masks...";
 
  EMap _emap(emap);
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  edm::LogInfo("HcalLutManager") << "EMap contains new" << _map.size() << " entries";
 
  std::map<int, std::vector<uint64_t>> masks;
 
  for (const auto& row : _map) {
    std::string subdet = row.subdet;
    if (subdet != "HF")
      continue;
    int crate = row.crate;
    int slot = row.slot;
    int crot = 100 * crate + slot;
    int fiber = row.fiber;
    int channel = row.fiberchan;
    unsigned int finel = 4 * fiber + channel;
    if (masks.count(crot) == 0)
      masks[crot] = {};
    if (finel >= masks[crot].size())
      masks[crot].resize(finel + 1);
 
    if (masktype == 0) {
      HcalSubdetector _subdet;
      if (row.subdet.find("HB") != string::npos)
        _subdet = HcalBarrel;
      else if (row.subdet.find("HE") != string::npos)
        _subdet = HcalEndcap;
      else if (row.subdet.find("HO") != string::npos)
        _subdet = HcalOuter;
      else if (row.subdet.find("HF") != string::npos)
        _subdet = HcalForward;
      else
        _subdet = HcalOther;
      HcalDetId _detid(_subdet, row.ieta, row.iphi, row.idepth);
      masks[crot][finel] = conditions->getHcalTPChannelParameter(_detid)->getMask();
    } else {
      auto parameters = conditions->getHcalTPParameters();
      masks[crot][finel] = masktype == 1 ? parameters->getADCThresholdHF() : parameters->getTDCMaskHF();
    }
  }
 
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
  RooGKCounter _counter;
 
  for (const auto& i : masks) {
    int crot = i.first;
    int crate = crot / 100;
 
    LutXml::Config _cfg;
    _cfg.lut_type = 5 + masktype;
    _cfg.crate = crate;
    _cfg.slot = crot % 100;
    _cfg.generalizedindex = crot;
    _cfg.mask = i.second;
    _cfg.creationtag = _tag;
    _cfg.targetfirmware = "1.0.0";
    _cfg.formatrevision = "1";
 
    int c = split_by_crate ? crate : 0;
    if (_xml.count(c) == 0)
      _xml[c] = std::make_shared<LutXml>();
 
    _xml[c]->addLut(_cfg);
    _counter.count();
  }
 
  edm::LogInfo("HcalLutManager") << "Generated LUTs: " << _counter.getCount() << std::endl
                                 << "Generating Masks...DONE" << std::endl;
  return _xml;
}

References HltBtagPostValidation_cff::c, submitPVValidationJobs::conditions, RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationtag, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, EMap::get_map(), RooGKCounter::getCount(), HcalBarrel, HcalEndcap, HcalForward, HcalOther, HcalOuter, mps_fire::i, LutXml::_Config::lut_type, LutXml::_Config::mask, findQualityFiles::size, LutXml::_Config::slot, AlCaHLTBitMon_QueryRunRegistry::string, and LutXml::_Config::targetfirmware.

getZdcLutXml()

std::map< int, std::shared_ptr< LutXml > > HcalLutManager::getZdcLutXml	(	std::string	_tag,
		bool	split_by_crate = true
	)

Definition at line 1714 of file HcalLutManager.cc.

                                                                                                   {
  edm::LogInfo("HcalLutManager") << "Generating ZDC LUTs ...may the Force be with us...";
  std::map<int, std::shared_ptr<LutXml>> _xml;  // index - crate number
 
  EMap _emap(emap);
 
  ZdcLut zdc;
 
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  edm::LogInfo("HcalLutManager") << "EMap contains " << _map.size() << " channels";
 
  //loop over all EMap channels
  RooGKCounter _counter;
  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    LutXml::Config _cfg;
 
    // only ZDC channels
    if (row->zdc_section.find("ZDC") != std::string::npos) {
      if (_xml.count(row->crate) == 0 && split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(row->crate, std::make_shared<LutXml>()));
      } else if (_xml.count(0) == 0 && !split_by_crate) {
        _xml.insert(std::pair<int, std::shared_ptr<LutXml>>(0, std::make_shared<LutXml>()));
      }
      //  FIXME: introduce proper tag names in ZDC bricks for logical channel info
      _cfg.ieta = row->zdc_channel;  // int
      //_cfg.ieta = row->zdc_zside; // int
      //_cfg.iphi = row->zdc_section; // string
      _cfg.depth = row->idepth;  // int
      _cfg.crate = row->crate;
      _cfg.slot = row->slot;
      if (row->topbottom.find('t') != std::string::npos)
        _cfg.topbottom = 1;
      else if (row->topbottom.find('b') != std::string::npos)
        _cfg.topbottom = 0;
      else
        edm::LogWarning("HcalLutManager") << "fpga out of range...";
      _cfg.fiber = row->fiber;
      _cfg.fiberchan = row->fiberchan;
      _cfg.lut_type = 1;
      _cfg.creationtag = _tag;
      _cfg.creationstamp = get_time_stamp(time(nullptr));
      _cfg.targetfirmware = "1.0.0";
      _cfg.formatrevision = "1";  //???
      _cfg.generalizedindex = 0;
 
      //HcalZDCDetId _detid(row->zdc_section, (row->zdc_zside>0), row->zdc_channel);
 
      std::vector<int> coder_lut = zdc.get_lut(row->zdc_section, row->zdc_zside, row->zdc_channel);
      edm::LogInfo("HcalLutManager") << "***DEBUG: ZDC lut size: " << coder_lut.size();
      if (!coder_lut.empty()) {
        for (std::vector<int>::const_iterator _i = coder_lut.begin(); _i != coder_lut.end(); _i++) {
          unsigned int _temp = (unsigned int)(*_i);
          //if (_temp!=0) std::cout << "DEBUG non-zero LUT!!!!!!!!!!!!!!!" << (*_i) << "     " << _temp << std::endl;
          //unsigned int _temp = 0;
          _cfg.lut.push_back(_temp);
        }
        //_cfg.lut = _set.lut[lut_index];
 
        if (split_by_crate) {
          _xml[row->crate]->addLut(_cfg, lut_checksums_xml);
          _counter.count();
        } else {
          _xml[0]->addLut(_cfg, lut_checksums_xml);
          _counter.count();
        }
      }  //size of lut
    }
  }
  edm::LogInfo("HcalLutManager") << "LUTs generated: " << _counter.getCount() << std::endl
                                 << "Generating ZDC LUTs...DONE" << std::endl;
 
  return _xml;
}

References RooGKCounter::count(), LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, EMap::get_map(), RooGKCounter::getCount(), LutXml::_Config::ieta, createfilelist::int, LutXml::_Config::lut, LutXml::_Config::lut_type, LutXml::_Config::slot, LutXml::_Config::targetfirmware, ntuplemaker::time, LutXml::_Config::topbottom, and hcalSimParameters_cfi::zdc.

init()

void HcalLutManager::init

(

void

)

Definition at line 72 of file HcalLutManager.cc.

                              {
  lut_xml = nullptr;
  lut_checksums_xml = nullptr;
  db = nullptr;
  lmap = nullptr;
  emap = nullptr;
  cq = nullptr;
  conditions = nullptr;
  status_word_to_mask = 0x0000;
}

References submitPVValidationJobs::conditions, and dqmiodatasetharvest::db.

initChannelIterator()

int HcalLutManager::initChannelIterator

(

std::vector< HcalGenericDetId > &

map

)

Definition at line 90 of file HcalLutManager.cc.

                                                                        {
  _iter.init(map);
  return _iter.size();
}

References genParticles_cff::map.

local_connect()

int HcalLutManager::local_connect	(	std::string	lut_xml_file,
		std::string	lmap_hbef_file,
		std::string	lmap_ho_file
	)

Definition at line 1385 of file HcalLutManager.cc.

                                                                                                          {
  read_lmap(lmap_hbef_file, lmap_ho_file);
  read_luts(lut_xml_file);
  return 0;
}

read_lmap()

int HcalLutManager::read_lmap	(	std::string	lmap_hbef_file,
		std::string	lmap_ho_file
	)

Definition at line 1368 of file HcalLutManager.cc.

                                                                              {
  delete lmap;
  lmap = new LMap();
  lmap->read(lmap_hbef_file, "HBEF");
  lmap->read(lmap_ho_file, "HO");
  edm::LogInfo("HcalLutManager") << "LMap contains " << lmap->get_map().size()
                                 << " channels (compare to 9072 of all HCAL channels)";
  return 0;
}

read_luts()

int HcalLutManager::read_luts

(

std::string

lut_xml_file

)

Definition at line 1378 of file HcalLutManager.cc.

                                                    {
  delete db;
  db = new HCALConfigDB();
  db->connect(lut_xml_file);
  return 0;
}

References dqmiodatasetharvest::db.

test_direct_xml_parsing()

int HcalLutManager::test_direct_xml_parsing

(

std::string

_filename

)

Definition at line 1640 of file HcalLutManager.cc.

                                                               {
  /*
  XMLDOMBlock _xml(_filename);
  //DOMElement * data_set_elem = (DOMElement *)(document -> getElementsByTagName( XMLProcessor::_toXMLCh( "DATA_SET" ) ) -> item(0));  
  DOMNodeList * brick_list = _xml . getDocument() ->  getElementsByTagName( XMLProcessor::_toXMLCh( "CFGBrick" ));  
 
  double n_bricks = brick_list->getLength();
  std::cout << "amount of LUT bricks: " << n_bricks << std::endl;
 
  for (int iter=0; iter!=n_bricks; iter++){
    DOMElement * _brick = (DOMElement *)(brick_list->item(iter));
    
    DOMElement * _param = 0;
    // loop over brick parameters
    int par_iter = 0;
    while(1){
      _param = (DOMElement *)(_brick->getElementsByTagName(XMLProcessor::_toXMLCh("Parameter")));
      std::string _name = _param->getAttribute( XMLProcessor::_toXMLCh( "name" ) );
      if (_name.find("IETA")==string::npos) break;
 
      std::string _tag = "Parameter";
      std::cout << "### Parameter IETA = " << _xml.getTagValue( _tag, 0, _brick);
      par_iter++;
    }
  }
  */
  return 0;
}

test_emap()

void HcalLutManager::test_emap

(

void

)

Definition at line 1615 of file HcalLutManager.cc.

                                   {
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v5_080208.txt");
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.03_080817.txt");
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
  EMap _emap(emap);
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  std::stringstream s;
  s << "EMap contains " << _map.size() << " channels" << std::endl;
 
  //loop over all EMap channels
  //RooGKCounter _c;
  for (std::vector<EMap::EMapRow>::const_iterator row = _map.begin(); row != _map.end(); row++) {
    // only trigger tower channels
    if (row->subdet.find("HT") != std::string::npos) {
      s << " -----> Subdet = " << row->subdet << std::endl;
 
      if (abs(row->ieta) > 28) {
        //if (row->iphi == 71){
        s << " ==> (ieta,iphi) = " << row->ieta << ",   " << row->iphi << std::endl;
      }
    }
  }
  edm::LogInfo("HcalLutManager") << s.str();
}

References funct::abs(), EMap::get_map(), and alignCSCRings::s.

test_xml_access()

int HcalLutManager::test_xml_access	(	std::string	_tag,
		std::string	_filename
	)

Definition at line 1291 of file HcalLutManager.cc.

                                                                       {
  local_connect(_filename, "backup/HCALmapHBEF.txt", "backup/HCALmapHO.txt");
 
  //EMap _emap("../../../CondFormats/HcalObjects/data/official_emap_v6.04_080905.txt");
  EMap _emap(emap);
  std::vector<EMap::EMapRow>& _map = _emap.get_map();
  int map_size = _map.size();
  edm::LogInfo("HcalLutManager") << "EMap contains " << map_size << " channels";
 
  // make sure that all init is done
  std::vector<unsigned int> _lut;
  _lut = getLutFromXml(_tag, 1107313727, hcal::ConfigurationDatabase::LinearizerLUT);
 
  edm::LogInfo("HcalLutManager") << "Testing direct parsing of the LUT XML";
  struct timeval _t;
  gettimeofday(&_t, nullptr);
  double _time = (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0;
  test_direct_xml_parsing(_filename);
  gettimeofday(&_t, nullptr);
  edm::LogInfo("HcalLutManager") << "parsing took that much time: "
                                 << (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0 - _time;
 
  gettimeofday(&_t, nullptr);
  _time = (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0;
  edm::LogInfo("HcalLutManager") << "before loop over random LUTs: " << _time;
  int _raw_id;
 
  // loop over random LUTs
  for (int _iter = 0; _iter < 100; _iter++) {
    gettimeofday(&_t, nullptr);
    //std::cout << "before getting a LUT: " << _t . tv_sec << "." << _t . tv_usec << std::endl;
 
    // select valid random emap channel
    while (true) {
      int _key = (rand() % map_size);
      //_key = 3356;
      if ((_map[_key].subdet.find("HB") != string::npos || _map[_key].subdet.find("HE") != string::npos ||
           _map[_key].subdet.find("HO") != string::npos || _map[_key].subdet.find("HF") != string::npos) &&
          _map[_key].subdet.size() == 2) {
        HcalSubdetector _subdet;
        if (_map[_key].subdet.find("HB") != string::npos)
          _subdet = HcalBarrel;
        else if (_map[_key].subdet.find("HE") != string::npos)
          _subdet = HcalEndcap;
        else if (_map[_key].subdet.find("HO") != string::npos)
          _subdet = HcalOuter;
        else if (_map[_key].subdet.find("HF") != string::npos)
          _subdet = HcalForward;
        else
          _subdet = HcalOther;
        HcalDetId _detid(_subdet, _map[_key].ieta, _map[_key].iphi, _map[_key].idepth);
        _raw_id = _detid.rawId();
        break;
      }
    }
    _lut = getLutFromXml(_tag, _raw_id, hcal::ConfigurationDatabase::LinearizerLUT);
 
    gettimeofday(&_t, nullptr);
  }
  double d_time = _t.tv_sec + _t.tv_usec / 1000000.0 - _time;
  edm::LogInfo("HcalLutManager") << "after the loop over random LUTs: " << _time + d_time << std::endl
                                 << "total time: " << d_time << std::endl;
 
  edm::LogInfo("HcalLutManager") << "LUT length = " << _lut.size();
  for (std::vector<unsigned int>::const_iterator i = _lut.end() - 1; i != _lut.begin() - 1; i--) {
    edm::LogInfo("HcalLutManager") << (i - _lut.begin()) << "     " << _lut[(i - _lut.begin())];
    break;
  }
 
  db->disconnect();
 
  delete db;
  db = nullptr;
 
  return 0;
}

References dqmiodatasetharvest::db, EMap::get_map(), HcalBarrel, HcalEndcap, HcalForward, HcalOther, HcalOuter, mps_fire::i, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, and DetId::rawId().

writeLutXmlFiles()

int HcalLutManager::writeLutXmlFiles	(	std::map< int, std::shared_ptr< LutXml > > &	_xml,
		std::string	_tag = "default_tag",
		bool	split_by_crate = true
	)

Definition at line 1086 of file HcalLutManager.cc.

                                                          {
  for (std::map<int, std::shared_ptr<LutXml>>::const_iterator cr = _xml.begin(); cr != _xml.end(); cr++) {
    std::stringstream output_file_name;
    if (split_by_crate) {
      output_file_name << _tag << "_" << cr->first << ".xml";
    } else {
      output_file_name << _tag << ".xml";
    }
    cr->second->write(output_file_name.str());
  }
  return 0;
}

References genParticles_cff::map.

Member Data Documentation

_ass

HcalAssistant HcalLutManager::_ass

protected

Definition at line 183 of file HcalLutManager.h.

_iter

HcalChannelIterator HcalLutManager::_iter

protected

Definition at line 182 of file HcalLutManager.h.

conditions

const HcalDbService* HcalLutManager::conditions

protected

Definition at line 186 of file HcalLutManager.h.

cq

const HcalChannelQuality* HcalLutManager::cq

protected

Definition at line 185 of file HcalLutManager.h.

db

HCALConfigDB* HcalLutManager::db

protected

Definition at line 180 of file HcalLutManager.h.

Referenced by conddb_version_mgr.conddb_tool::connect(), conddbCopyTest.CopyTest::execute(), conddb_version_mgr.version_db::fetch_boost_run_map(), conddb_version_mgr.version_db::fetch_cmssw_boost_map(), conddb_version_mgr.conddb_tool::insert_boost_run(), conddb_version_mgr.version_db::insert_boost_run_range(), conddb_version_mgr.version_db::insert_cmssw_boost(), conddb_version_mgr.conddb_tool::list_boost_run(), conddb_version_mgr.version_db::populate_for_gts(), conddb_version_mgr.conddb_tool::process_tag_boost_version(), conddb_version_mgr.conddb_tool::show_tag_boost_version(), conddb_version_mgr.conddb_tool::update_tag_boost_version_in_db(), conddb_version_mgr.conddb_tool::update_tags(), conditionUploadTest.UploadTest::upload(), and conddb_version_mgr.conddb_tool::validate_boost_version().

emap

const HcalElectronicsMap* HcalLutManager::emap

protected

Definition at line 184 of file HcalLutManager.h.

lmap

LMap* HcalLutManager::lmap

protected

Definition at line 181 of file HcalLutManager.h.

lut_checksums_xml

XMLDOMBlock* HcalLutManager::lut_checksums_xml

protected

Definition at line 179 of file HcalLutManager.h.

lut_xml

LutXml* HcalLutManager::lut_xml

protected

Definition at line 178 of file HcalLutManager.h.

status_word_to_mask

uint32_t HcalLutManager::status_word_to_mask

protected

Definition at line 187 of file HcalLutManager.h.