#include <CalibCalorimetry/HcalTPGAlgos/interface/LutXml.h>

Inheritance diagram for LutXml:

Classes
struct	_Config

Public Types
typedef struct LutXml::_Config	Config

typedef std::map< uint32_t, std::vector< unsigned int > >::const_iterator	const_iterator

Public Member Functions
int	a_to_i (char *inbuf)

template<typename T >
DOMElement *	addData (std::string _elements, std::string _encoding, const T &_lut)

void	addLut (Config &_config, XMLDOMBlock *checksums_xml=nullptr)

const_iterator	begin () const

int	create_lut_map (void)

const_iterator	end () const

const_iterator	find (uint32_t) const

std::string &	getCurrentBrick (void)

std::vector< unsigned int > *	getLutFast (uint32_t det_id)

void	init (void)

	LutXml ()

	LutXml (XERCES_CPP_NAMESPACE::InputSource &_source)

	LutXml (std::string filename)

HcalSubdetector	subdet_from_crate (int crate, int eta, int depth)

int	test_access (std::string filename)

	~LutXml () override

Public Member Functions inherited from XMLDOMBlock
XERCES_CPP_NAMESPACE::DOMElement *	add_element (XERCES_CPP_NAMESPACE::DOMElement parent, XMLCh tagname, XMLCh *value)

XERCES_CPP_NAMESPACE::DOMDocument *	getDocument (void)

XERCES_CPP_NAMESPACE::DOMDocument *	getDocumentConst (void) const

XERCES_CPP_NAMESPACE::DOMDocument *	getNewDocument (std::string xmlFileName)

std::string &	getString (void)

std::string &	getString (XERCES_CPP_NAMESPACE::DOMNode *_node)

const char *	getTagAttribute (const std::string &tagName, const std::string &attrName, int _item=0)

const char *	getTagValue (const std::string &tagName, int _item=0, XERCES_CPP_NAMESPACE::DOMDocument *_document=nullptr)

const char *	getTagValue (const std::string &tagName, int _item, XERCES_CPP_NAMESPACE::DOMElement *_document)

std::string	getTimestamp (time_t _time)

XMLDOMBlock &	operator+= (const XMLDOMBlock &other)

void	parse (XERCES_CPP_NAMESPACE::InputSource &_source)

XERCES_CPP_NAMESPACE::DOMNode *	setTagAttribute (const std::string &tagName, const std::string &attrName, const std::string &attrValue, int _item=0)

XERCES_CPP_NAMESPACE::DOMNode *	setTagAttribute (XERCES_CPP_NAMESPACE::DOMElement *_elem, const std::string &tagName, const std::string &attrName, const std::string &attrValue, int _item=0)

XERCES_CPP_NAMESPACE::DOMNode *	setTagAttribute (const std::string &tagName, const std::string &attrName, const int &attrValue, int _item=0)

XERCES_CPP_NAMESPACE::DOMNode *	setTagAttribute (XERCES_CPP_NAMESPACE::DOMElement *_elem, const std::string &tagName, const std::string &attrName, const int &attrValue, int _item=0)

XERCES_CPP_NAMESPACE::DOMNode *	setTagValue (const std::string &tagName, const std::string &tagValue, int _item=0, XERCES_CPP_NAMESPACE::DOMDocument *_document=nullptr)

XERCES_CPP_NAMESPACE::DOMNode *	setTagValue (XERCES_CPP_NAMESPACE::DOMElement *_elem, const std::string &tagName, const std::string &tagValue, int _item=0)

XERCES_CPP_NAMESPACE::DOMNode *	setTagValue (const std::string &tagName, const int &tagValue, int _item=0, XERCES_CPP_NAMESPACE::DOMDocument *_document=nullptr)

XERCES_CPP_NAMESPACE::DOMNode *	setTagValue (XERCES_CPP_NAMESPACE::DOMElement *_elem, const std::string &tagName, const int &tagValue, int _item=0)

int	write (std::string target="stdout")

	XMLDOMBlock ()

	XMLDOMBlock (std::string xmlFileName)

	XMLDOMBlock (XERCES_CPP_NAMESPACE::InputSource &_source)

	XMLDOMBlock (std::string _root, int rootElementName)

virtual	~XMLDOMBlock ()

Static Public Member Functions
static std::string	get_checksum (std::vector< unsigned int > &lut)

Protected Member Functions
XERCES_CPP_NAMESPACE::DOMElement *	add_checksum (XERCES_CPP_NAMESPACE::DOMDocument *parent, Config &config)

template<typename T >
XERCES_CPP_NAMESPACE::DOMElement *	addData (std::string _elements, std::string _encoding, const T &_lut)

XERCES_CPP_NAMESPACE::DOMElement *	addParameter (std::string _name, std::string _type, std::string _value)

XERCES_CPP_NAMESPACE::DOMElement *	addParameter (std::string _name, std::string _type, int _value)

Protected Member Functions inherited from XMLDOMBlock
int	init (std::string _root)

Protected Attributes
XMLCh *	brick

XERCES_CPP_NAMESPACE::DOMElement *	brickElem

std::map< uint32_t, std::vector< unsigned int > >	lut_map

XMLCh *	root

Protected Attributes inherited from XMLDOMBlock
XERCES_CPP_NAMESPACE::DOMDocument *	document

XERCES_CPP_NAMESPACE::ErrorHandler *	errHandler

XERCES_CPP_NAMESPACE::XercesDOMParser *	parser

std::string *	the_string

std::string	theFileName

XMLProcessor *	theProcessor

Detailed Description

Description: <one line="" class="" summary>="">

Usage: <usage>

Definition at line 27 of file LutXml.h.

Member Typedef Documentation

typedef struct LutXml::_Config LutXml::Config

typedef std::map<uint32_t, std::vector<unsigned int> >::const_iterator LutXml::const_iterator

Definition at line 71 of file LutXml.h.

Constructor & Destructor Documentation

LutXml::LutXml ( )

Definition at line 53 of file LutXml.cc.

References init(), and XMLDOMBlock::XMLDOMBlock().

53 : XMLDOMBlock("CFGBrickSet", 1) { init(); }

LutXml::init

void init(void)

Definition: LutXml.cc:64

XMLDOMBlock::XMLDOMBlock

XMLDOMBlock()

Definition: XMLDOMBlock.cc:46

LutXml::LutXml ( XERCES_CPP_NAMESPACE::InputSource & _source )

LutXml::LutXml ( std::string filename )

Definition at line 57 of file LutXml.cc.

References init().

57 : XMLDOMBlock(filename) { init(); }

corrVsCorr.filename

filename

Definition: corrVsCorr.py:123

LutXml::init

void init(void)

Definition: LutXml.cc:64

XMLDOMBlock::XMLDOMBlock

XMLDOMBlock()

Definition: XMLDOMBlock.cc:46

LutXml::~LutXml ( )

override

Definition at line 59 of file LutXml.cc.

References brick, and fetchall_from_DQM_v2::release.

                 {
   XMLString::release(&root);
   XMLString::release(&brick);
 }

Member Function Documentation

int LutXml::a_to_i ( char * inbuf )

Definition at line 332 of file LutXml.cc.

References mps_fire::result.

Referenced by create_lut_map().

                               {
   int result;
   sscanf(inbuf, "%d", &result);
   return result;
 }

DOMElement * LutXml::add_checksum	(	XERCES_CPP_NAMESPACE::DOMDocument *	parent,
		Config &	config
	)

protected

Definition at line 155 of file LutXml.cc.

References XMLProcessor::_toXMLCh(), class-composition::child, LutXml::_Config::crate, LutXml::_Config::fiber, LutXml::_Config::fiberchan, get_checksum(), LutXml::_Config::lut, LutXml::_Config::lut_type, LutXml::_Config::slot, and LutXml::_Config::topbottom.

Referenced by addLut().

                                                                     {
   DOMElement *child = parent->createElement(XMLProcessor::_toXMLCh("Data"));
   child->setAttribute(XMLProcessor::_toXMLCh("crate"), XMLProcessor::_toXMLCh(config.crate));
   child->setAttribute(XMLProcessor::_toXMLCh("slot"), XMLProcessor::_toXMLCh(config.slot));
   child->setAttribute(XMLProcessor::_toXMLCh("fpga"), XMLProcessor::_toXMLCh(config.topbottom));
   child->setAttribute(XMLProcessor::_toXMLCh("fiber"), XMLProcessor::_toXMLCh(config.fiber));
   child->setAttribute(XMLProcessor::_toXMLCh("fiberchan"), XMLProcessor::_toXMLCh(config.fiberchan));
   child->setAttribute(XMLProcessor::_toXMLCh("luttype"), XMLProcessor::_toXMLCh(config.lut_type));
   child->setAttribute(XMLProcessor::_toXMLCh("elements"), XMLProcessor::_toXMLCh("1"));
   child->setAttribute(XMLProcessor::_toXMLCh("encoding"), XMLProcessor::_toXMLCh("hex"));
   DOMText *checksum_value = parent->createTextNode(XMLProcessor::_toXMLCh(get_checksum(config.lut)));
   child->appendChild(checksum_value);
 
   parent->getDocumentElement()->appendChild(child);
 
   return child;
 }

template<typename T >

XERCES_CPP_NAMESPACE::DOMElement* LutXml::addData	(	std::string	_elements,
		std::string	_encoding,
		const T &	_lut
	)

protected

Referenced by addLut().

template<typename T >

DOMElement* LutXml::addData	(	std::string	_elements,
		std::string	_encoding,
		const T &	_lut
	)

Definition at line 132 of file LutXml.cc.

References XMLProcessor::_toXMLCh(), brickElem, class-composition::child, XMLDOMBlock::document, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                    {
   DOMElement *child = document->createElement(XMLProcessor::_toXMLCh("Data"));
   child->setAttribute(XMLProcessor::_toXMLCh("elements"), XMLProcessor::_toXMLCh(_elements));
   child->setAttribute(XMLProcessor::_toXMLCh("encoding"), XMLProcessor::_toXMLCh(_encoding));
 
   std::stringstream buf;
 
   for (const auto &iter : _lut) {
     char buf2[16];
     sprintf(buf2, "%lx", uint64_t(iter));
     buf << buf2 << " ";
   }
 
   std::string _value = buf.str();
 
   DOMText *data_value = document->createTextNode(XMLProcessor::_toXMLCh(_value));
   child->appendChild(data_value);
 
   brickElem->appendChild(child);
 
   return child;
 }

void LutXml::addLut	(	LutXml::Config &	_config,
		XMLDOMBlock *	checksums_xml = `nullptr`
	)

Definition at line 78 of file LutXml.cc.

References XMLProcessor::_toXMLCh(), add_checksum(), addData(), addParameter(), brickElem, LutXml::_Config::crate, LutXml::_Config::creationstamp, LutXml::_Config::creationtag, LutXml::_Config::depth, XMLDOMBlock::document, LutXml::_Config::fiber, LutXml::_Config::fiberchan, LutXml::_Config::formatrevision, LutXml::_Config::generalizedindex, get_checksum(), XMLDOMBlock::getDocument(), LutXml::_Config::ieta, LutXml::_Config::iphi, LutXml::_Config::lut, LutXml::_Config::lut_type, LutXml::_Config::mask, LutXml::_Config::slot, LutXml::_Config::targetfirmware, and LutXml::_Config::topbottom.

                                                                      {
   DOMElement *rootElem = document->getDocumentElement();
 
   brickElem = document->createElement(XMLProcessor::_toXMLCh("CFGBrick"));
   rootElem->appendChild(brickElem);
 
   addParameter("CREATIONTAG", "string", _config.creationtag);
   addParameter("CREATIONSTAMP", "string", _config.creationstamp);
   addParameter("FORMATREVISION", "string", _config.formatrevision);
   addParameter("TARGETFIRMWARE", "string", _config.targetfirmware);
   addParameter("GENERALIZEDINDEX", "int", _config.generalizedindex);
   addParameter("CRATE", "int", _config.crate);
   addParameter("SLOT", "int", _config.slot);
 
   if (checksums_xml) {
     addParameter("CHECKSUM", "string", get_checksum(_config.lut));
   }
 
   if (_config.lut_type == 1) {  // linearizer LUT
     addParameter("IETA", "int", _config.ieta);
     addParameter("IPHI", "int", _config.iphi);
     addParameter("TOPBOTTOM", "int", _config.topbottom);
     addParameter("LUT_TYPE", "int", _config.lut_type);
     addParameter("FIBER", "int", _config.fiber);
     addParameter("FIBERCHAN", "int", _config.fiberchan);
     addParameter("DEPTH", "int", _config.depth);
     addData(to_string(_config.lut.size()), "hex", _config.lut);
   } else if (_config.lut_type == 2 || _config.lut_type == 4) {  // compression LUT or HE feature bit LUT
     addParameter("IETA", "int", _config.ieta);
     addParameter("IPHI", "int", _config.iphi);
     addParameter("TOPBOTTOM", "int", _config.topbottom);
     addParameter("LUT_TYPE", "int", _config.lut_type);
     addParameter("SLB", "int", _config.fiber);
     addParameter("SLBCHAN", "int", _config.fiberchan);
     addData(to_string(_config.lut.size()), "hex", _config.lut);
   } else if (_config.lut_type == 5) {  // channel masks
     addParameter("MASK_TYPE", "string", "TRIGGERCHANMASK");
     addData(to_string(_config.mask.size()), "hex", _config.mask);
   } else if (_config.lut_type == 6) {  // adc threshold for tdc mask
     addParameter("THRESH_TYPE", "string", "TRIGINTIME");
     addData(to_string(_config.mask.size()), "hex", _config.mask);
   } else if (_config.lut_type == 7) {  // tdc mask
     addParameter("TDCMAP_TYPE", "string", "TRIGINTIME");
     addData(to_string(_config.mask.size()), "hex", _config.mask);
   } else {
     edm::LogError("LutXml") << "Unknown LUT type...produced XML will be incorrect";
   }
 
   if (checksums_xml) {
     add_checksum(checksums_xml->getDocument(), _config);
   }
 }

DOMElement * LutXml::addParameter	(	std::string	_name,
		std::string	_type,
		std::string	_value
	)

protected

Definition at line 173 of file LutXml.cc.

References XMLProcessor::_toXMLCh(), brickElem, class-composition::child, and XMLDOMBlock::document.

Referenced by editorTools.UserCodeTool::__init__(), trackTools.MakeAODTrackCandidates::__init__(), metTools.AddMETCollection::__init__(), HiCoreTools.RestrictInputToAOD::__init__(), coreTools.RunOnData::__init__(), runJetUncertainties.RunJetUncertainties::__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::__init__(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool::__init__(), editorTools.ChangeSource::__init__(), cmsswVersionTools.PickRelValInputFiles::__init__(), HiCoreTools.RemoveMCMatching::__init__(), coreTools.RemoveMCMatching::__init__(), trackTools.MakePATTrackCandidates::__init__(), trigTools.SwitchOnTrigger::__init__(), HiCoreTools.RemoveAllPATObjectsBut::__init__(), HiCoreTools.RemoveSpecificPATObjects::__init__(), trigTools.SwitchOnTriggerStandAlone::__init__(), tauTools.AddTauCollection::__init__(), trackTools.MakeTrackCandidates::__init__(), trigTools.SwitchOnTriggerMatching::__init__(), HiCoreTools.RemoveCleaning::__init__(), HiCoreTools.AddCleaning::__init__(), trigTools.SwitchOnTriggerMatchingStandAlone::__init__(), trigTools.SwitchOnTriggerMatchEmbedding::__init__(), jetTools.AddJetCollection::__init__(), jetTools.SwitchJetCollection::__init__(), jetTools.UpdateJetCollection::__init__(), jetTools.AddJetID::__init__(), jetTools.SetTagInfos::__init__(), addLut(), and addParameter().

                                                                                    {
   DOMElement *child = document->createElement(XMLProcessor::_toXMLCh("Parameter"));
   child->setAttribute(XMLProcessor::_toXMLCh("name"), XMLProcessor::_toXMLCh(_name));
   child->setAttribute(XMLProcessor::_toXMLCh("type"), XMLProcessor::_toXMLCh(_type));
   DOMText *parameter_value = document->createTextNode(XMLProcessor::_toXMLCh(_value));
   child->appendChild(parameter_value);
 
   brickElem->appendChild(child);
 
   return child;
 }

DOMElement * LutXml::addParameter	(	std::string	_name,
		std::string	_type,
		int	_value
	)

protected

Definition at line 185 of file LutXml.cc.

References addParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by editorTools.UserCodeTool::__init__(), metTools.AddMETCollection::__init__(), trackTools.MakeAODTrackCandidates::__init__(), HiCoreTools.RestrictInputToAOD::__init__(), coreTools.RunOnData::__init__(), runJetUncertainties.RunJetUncertainties::__init__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::__init__(), Vispa.Plugins.ConfigEditor.ToolDataAccessor.ImportTool::__init__(), editorTools.ChangeSource::__init__(), cmsswVersionTools.PickRelValInputFiles::__init__(), HiCoreTools.RemoveMCMatching::__init__(), coreTools.RemoveMCMatching::__init__(), trackTools.MakePATTrackCandidates::__init__(), trigTools.SwitchOnTrigger::__init__(), HiCoreTools.RemoveAllPATObjectsBut::__init__(), HiCoreTools.RemoveSpecificPATObjects::__init__(), trigTools.SwitchOnTriggerStandAlone::__init__(), tauTools.AddTauCollection::__init__(), trackTools.MakeTrackCandidates::__init__(), trigTools.SwitchOnTriggerMatching::__init__(), HiCoreTools.RemoveCleaning::__init__(), HiCoreTools.AddCleaning::__init__(), trigTools.SwitchOnTriggerMatchingStandAlone::__init__(), trigTools.SwitchOnTriggerMatchEmbedding::__init__(), jetTools.AddJetCollection::__init__(), jetTools.SwitchJetCollection::__init__(), jetTools.UpdateJetCollection::__init__(), jetTools.AddJetID::__init__(), and jetTools.SetTagInfos::__init__().

                                                                              {
   char buf[128];
   sprintf(buf, "%d", _value);
   std::string str_value = buf;
   return addParameter(_name, _type, str_value);
 }

LutXml::const_iterator LutXml::begin ( ) const

Definition at line 445 of file LutXml.cc.

References lut_map.

445 { return lut_map.begin(); }

LutXml::lut_map

std::map< uint32_t, std::vector< unsigned int > > lut_map

Definition: LutXml.h:90

int LutXml::create_lut_map ( void )

Definition at line 343 of file LutXml.cc.

References photons_cff::_id, XMLProcessor::_toXMLCh(), a_to_i(), funct::abs(), brick, LEDCalibrationChannels::depth, XMLDOMBlock::document, mps_fire::i, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, dqmiolumiharvest::j, lut_map, DetId::rawId(), slb(), subdet_from_crate(), and BeamSplash_cfg::version.

Referenced by HcalLutAnalyzer::analyze(), main(), and HcaluLUTTPGCoder::updateXML().

                                {
   //delete lut_map;
   lut_map.clear();
   //lut_map = new std::map<uint32_t,std::vector<unsigned int> >();
 
   if (document) {
     //DOMElement * rootElem =
     DOMNodeList *brick_list = document->getDocumentElement()->getElementsByTagName(brick);
     int n_of_bricks = brick_list->getLength();
     for (int i = 0; i != n_of_bricks; i++) {
       DOMElement *aBrick = (DOMElement *)(brick_list->item(i));
       DOMNodeList *par_list = aBrick->getElementsByTagName(XMLString::transcode("Parameter"));
       int n_of_par = par_list->getLength();
       int ieta = -99;
       int iphi = -99;
       int depth = -99;
       int crate = -99;
       int lut_type = -99;
       int slb = -99;
       HcalSubdetector subdet;
       for (int j = 0; j != n_of_par; j++) {
         DOMElement *aPar = (DOMElement *)(par_list->item(j));
         char *aName = XMLString::transcode(aPar->getAttribute(XMLProcessor::_toXMLCh("name")));
         if (strcmp(aName, "IETA") == 0)
           ieta = a_to_i(XMLString::transcode(aPar->getFirstChild()->getNodeValue()));
         if (strcmp(aName, "IPHI") == 0)
           iphi = a_to_i(XMLString::transcode(aPar->getFirstChild()->getNodeValue()));
         if (strcmp(aName, "DEPTH") == 0)
           depth = a_to_i(XMLString::transcode(aPar->getFirstChild()->getNodeValue()));
         if (strcmp(aName, "CRATE") == 0)
           crate = a_to_i(XMLString::transcode(aPar->getFirstChild()->getNodeValue()));
         if (strcmp(aName, "LUT_TYPE") == 0)
           lut_type = a_to_i(XMLString::transcode(aPar->getFirstChild()->getNodeValue()));
         if (strcmp(aName, "SLB") == 0)
           slb = a_to_i(XMLString::transcode(aPar->getFirstChild()->getNodeValue()));
       }
       subdet = subdet_from_crate(crate, abs(ieta), depth);
       DOMElement *_data = (DOMElement *)(aBrick->getElementsByTagName(XMLString::transcode("Data"))->item(0));
       char *_str = XMLString::transcode(_data->getFirstChild()->getNodeValue());
 
       // get the LUT vector
       int _string_length = strlen(_str);
       std::vector<unsigned int> _lut;
       unsigned int _base = 16;
       unsigned int _item = 0;
       for (int i = 0; i != _string_length; i++) {
         bool _range = false;
         char ch_cur = _str[i];
         if (_base == 16)
           _range = (ch_cur >= '0' and ch_cur <= '9') || (ch_cur >= 'a' and ch_cur <= 'f') ||
                    (ch_cur >= 'A' and ch_cur <= 'F');
         else if (_base == 10)
           _range = (ch_cur >= '0' and ch_cur <= '9');
         if (_range) {
           if (ch_cur >= 'a' and ch_cur <= 'f')
             ch_cur += 10 - 'a';
           else if (ch_cur >= 'A' and ch_cur <= 'F')
             ch_cur += 10 - 'A';
           else if (ch_cur >= '0' and ch_cur <= '9')
             ch_cur += -'0';
           _item = _item * _base;
           _item += ch_cur;
           bool last_digit = false;
           if ((i + 1) == _string_length)
             last_digit = true;
           else {
             char ch_next = _str[i + 1];
             bool _range_next = false;
             if (_base == 16)
               _range_next = (ch_next >= '0' and ch_next <= '9') || (ch_next >= 'a' and ch_next <= 'f') ||
                             (ch_next >= 'A' and ch_next <= 'F');
             else if (_base == 10)
               _range_next = (ch_next >= '0' and ch_next <= '9');
             if (!_range_next)
               last_digit = true;
           }
           if (last_digit) {
             _lut.push_back(_item);
             _item = 0;
           }
         }
       }
       // filling the map
       uint32_t _key = 0;
       if (lut_type == 1) {
         HcalDetId _id(subdet, ieta, iphi, depth);
         _key = _id.rawId();
       } else if (lut_type == 2) {
         int version = (abs(ieta) > 29 && slb != 12 && crate > 20) ? 1 : 0;
         HcalTrigTowerDetId _id(ieta, iphi, 10 * version);
         _key = _id.rawId();
       } else
         continue;
       lut_map.insert(std::pair<uint32_t, std::vector<unsigned int> >(_key, _lut));
     }
   } else {
     edm::LogError("LutXml") << "XML file with LUTs is not loaded, cannot create map!";
   }
 
   return 0;
 }

LutXml::const_iterator LutXml::end ( ) const

Definition at line 447 of file LutXml.cc.

References lut_map.

Referenced by Types.LuminosityBlockRange::cppID(), Types.EventRange::cppID(), and dumpLutDiff().

447 { return lut_map.end(); }

LutXml::lut_map

std::map< uint32_t, std::vector< unsigned int > > lut_map

Definition: LutXml.h:90

LutXml::const_iterator LutXml::find ( uint32_t id ) const

Definition at line 449 of file LutXml.cc.

References lut_map.

Referenced by BeautifulSoup.Tag::__getattr__(), dumpLutDiff(), and BeautifulSoup.Tag::firstText().

449 { return lut_map.find(id); }

LutXml::lut_map

std::map< uint32_t, std::vector< unsigned int > > lut_map

Definition: LutXml.h:90

std::string LutXml::get_checksum ( std::vector< unsigned int > & lut )

static

Definition at line 195 of file LutXml.cc.

References beamvalidation::exit(), mps_fire::i, and mps_fire::result.

Referenced by add_checksum(), and addLut().

                                                            {
   std::stringstream result;
   md5_state_t md5er;
   md5_byte_t digest[16];
   md5_init(&md5er);
   // linearizer LUT:
   if (lut.size() == 128) {
     unsigned char tool[2];
     for (int i = 0; i < 128; i++) {
       tool[0] = lut[i] & 0xFF;
       tool[1] = (lut[i] >> 8) & 0xFF;
       md5_append(&md5er, tool, 2);
     }
   } else if (lut.size() == 256) {
     unsigned char tool[2];
     for (int i = 0; i < 256; i++) {
       tool[0] = lut[i] & 0xFF;
       tool[1] = (lut[i] >> 8) & 0xFF;
       md5_append(&md5er, tool, 2);
     }
   }
   // compression LUT:
   else if (lut.size() == 1024) {
     unsigned char tool;
     for (int i = 0; i < 1024; i++) {
       tool = lut[i] & 0xFF;
       md5_append(&md5er, &tool, 1);
     }
   } else if (lut.size() == 2048) {
     unsigned char tool;
     for (int i = 0; i < 2048; i++) {
       tool = lut[i] & 0xFF;
       md5_append(&md5er, &tool, 1);
     }
   }
   // HE fine grain LUT
   else if (lut.size() == 4096) {
     unsigned char tool;
     for (int i = 0; i < 4096; i++) {
       tool = lut[i] & 0xFF;
       md5_append(&md5er, &tool, 1);
     }
   } else {
     edm::LogError("LutXml") << "Irregular LUT size, " << lut.size()
                             << " , do not know how to compute checksum, exiting...";
     exit(-1);
   }
   md5_finish(&md5er, digest);
   for (int i = 0; i < 16; i++)
     result << std::hex << (((int)(digest[i])) & 0xFF);
 
   return result.str();
 }

std::string & LutXml::getCurrentBrick ( void )

Definition at line 192 of file LutXml.cc.

References brickElem, and XMLDOMBlock::getString().

192 { return getString(brickElem); }

XMLDOMBlock::getString

std::string & getString(void)

Definition: XMLDOMBlock.cc:419

LutXml::brickElem

XERCES_CPP_NAMESPACE::DOMElement * brickElem

Definition: LutXml.h:87

std::vector< unsigned int > * LutXml::getLutFast ( uint32_t det_id )

Definition at line 70 of file LutXml.cc.

References lut_map.

Referenced by test_access(), and HcaluLUTTPGCoder::updateXML().

                                                            {
   if (lut_map.find(det_id) != lut_map.end())
     return &(lut_map)[det_id];
   edm::LogError("LutXml") << "LUT not found, null pointer is returned";
   return nullptr;
 }

void LutXml::init ( void )

Definition at line 64 of file LutXml.cc.

References brick, and brickElem.

Referenced by LutXml().

                       {
   root = XMLString::transcode("CFGBrickSet");
   brick = XMLString::transcode("CFGBrick");
   brickElem = nullptr;
 }

HcalSubdetector LutXml::subdet_from_crate	(	int	crate,
		int	eta,
		int	depth
	)

Definition at line 299 of file LutXml.cc.

References beamvalidation::exit(), HcalBarrel, HcalEndcap, HcalForward, HcalOuter, and mps_fire::result.

Referenced by create_lut_map().

                                                                         {
   HcalSubdetector result;
   // HBHE: 0,1,4,5,10,11,14,15,17
   // HF: 2,9,12
   // HO: 3,6,7,13
   int crate = crate_ < 20 ? crate_ : crate_ - 20;
 
   if (crate == 2 || crate == 9 || crate == 12)
     result = HcalForward;
   else if (crate == 3 || crate == 6 || crate == 7 || crate == 13)
     result = HcalOuter;
   else if (crate == 0 || crate == 1 || crate == 4 || crate == 5 || crate == 10 || crate == 11 || crate == 14 ||
            crate == 15 || crate == 17) {
     if (eta < 16)
       result = HcalBarrel;
     else if (eta > 16)
       result = HcalEndcap;
     else if (eta == 16 && depth < 3)
       result = HcalBarrel;
     else if (eta == 16 && depth >= 3)
       result = HcalEndcap;
     else {
       edm::LogError("LutXml") << "Impossible to determine HCAL subdetector!!!";
       exit(-1);
     }
   } else {
     edm::LogError("LutXml") << "Impossible to determine HCAL subdetector!!!";
     exit(-1);
   }
 
   return result;
 }

int LutXml::test_access ( std::string filename )

Definition at line 249 of file LutXml.cc.

References HcalEmap::get_map(), getLutFast(), HcalBarrel, HcalEndcap, HcalForward, HcalOuter, cmsLHEtoEOSManager::l, lut_map, and DetId::rawId().

                                           {
   edm::LogInfo("LutXml") << "Created map size: " << lut_map.size();
 
   struct timeval _t;
   gettimeofday(&_t, nullptr);
   double _time = (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0;
 
   HcalEmap _emap("./backup/official_emap_v6.04_080905.txt");
   std::vector<HcalEmap::HcalEmapRow> &_map = _emap.get_map();
   edm::LogInfo("LutXml") << "HcalEmap contains " << _map.size() << " entries";
 
   int _counter = 0;
   for (std::vector<HcalEmap::HcalEmapRow>::const_iterator row = _map.begin(); row != _map.end(); ++row) {
     if (row->subdet == "HB") {
       HcalDetId det_id(HcalBarrel, row->ieta, row->iphi, row->idepth);
       uint32_t raw_id = det_id.rawId();
       std::vector<unsigned int> *l = getLutFast(raw_id);
       if (l)
         _counter++;
     }
     if (row->subdet == "HE") {
       HcalDetId det_id(HcalEndcap, row->ieta, row->iphi, row->idepth);
       uint32_t raw_id = det_id.rawId();
       std::vector<unsigned int> *l = getLutFast(raw_id);
       if (l)
         _counter++;
     }
     if (row->subdet == "HF") {
       HcalDetId det_id(HcalForward, row->ieta, row->iphi, row->idepth);
       uint32_t raw_id = det_id.rawId();
       std::vector<unsigned int> *l = getLutFast(raw_id);
       if (l)
         _counter++;
     }
     if (row->subdet == "HO") {
       HcalDetId det_id(HcalOuter, row->ieta, row->iphi, row->idepth);
       uint32_t raw_id = det_id.rawId();
       std::vector<unsigned int> *l = getLutFast(raw_id);
       if (l)
         _counter++;
     }
   }
   gettimeofday(&_t, nullptr);
   edm::LogInfo("LutXml") << "access to " << _counter
                          << " HCAL channels took: " << (double)(_t.tv_sec) + (double)(_t.tv_usec) / 1000000.0 - _time
                          << "sec";
 
   return 0;
 }

Member Data Documentation

XMLCh* LutXml::brick

protected

Definition at line 78 of file LutXml.h.

Referenced by create_lut_map(), init(), and ~LutXml().

XERCES_CPP_NAMESPACE::DOMElement* LutXml::brickElem

protected

Definition at line 87 of file LutXml.h.

Referenced by addData(), addLut(), addParameter(), getCurrentBrick(), and init().

std::map<uint32_t, std::vector<unsigned int> > LutXml::lut_map

protected

Definition at line 90 of file LutXml.h.

Referenced by begin(), create_lut_map(), end(), find(), getLutFast(), and test_access().

XMLCh* LutXml::root

protected

Definition at line 77 of file LutXml.h.

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation