CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Member Functions | Private Attributes
XMLConfigReader Class Reference

#include <XMLConfigReader.h>

Public Member Functions

void readConfig (const std::string fName)
 
void readConfig (OMTFConfiguration *aConfig)
 
void readConfig (L1TMuonOverlapParams *aConfig)
 
std::vector< std::vector< int > > readEvent (unsigned int iEvent=0, unsigned int iProcessor=0, bool readEta=false)
 
void readLUT (l1t::LUT *lut, const std::string &type)
 
std::vector< GoldenPattern * > readPatterns ()
 
void setConfigFile (const std::string &fName)
 
void setEventsFile (const std::string &fName)
 
void setPatternsFile (const std::string &fName)
 
 XMLConfigReader ()
 

Private Member Functions

GoldenPattern * buildGP (xercesc::DOMElement *aGPElement, unsigned int index=0)
 

Private Attributes

std::vector< GoldenPattern * > aGPs
 Cache with GPs read. More...
 
std::string configFile
 
xercesc::DOMDocument * doc
 
std::string eventsFile
 
xercesc::XercesDOMParser * parser
 
std::string patternsFile
 

Detailed Description

Definition at line 25 of file XMLConfigReader.h.

Constructor & Destructor Documentation

XMLConfigReader::XMLConfigReader ( )

Initialise XML parser

Definition at line 42 of file XMLConfigReader.cc.

References doc, and parser.

42  {
43 
44  XMLPlatformUtils::Initialize();
45 
47  parser = new XercesDOMParser();
48  parser->setValidationScheme(XercesDOMParser::Val_Auto);
49  parser->setDoNamespaces(false);
50 
51  doc = 0;
52 
53 
54 
55 }
XMLConfigReader::doc
xercesc::DOMDocument * doc
Definition: XMLConfigReader.h:61
XMLConfigReader::parser
xercesc::XercesDOMParser * parser
Definition: XMLConfigReader.h:60

Member Function Documentation

GoldenPattern * XMLConfigReader::buildGP ( xercesc::DOMElement *  aGPElement,
unsigned int  index = 0 
)
private

Loop over layers

MeanDistPhi vector

PDF vector

Definition at line 160 of file XMLConfigReader.cc.

References _toDOMS(), _toString(), assert(), cmsHarvester::index, OMTFConfiguration::nLayers, OMTFConfiguration::nPdfAddrBits, OMTFConfiguration::nRefLayers, GoldenPattern::setMeanDistPhi(), and GoldenPattern::setPdf().

Referenced by readPatterns().

161  {
162 
163  std::ostringstream stringStr;
164  if(index>0) stringStr<<"iPt"<<index;
165  else stringStr.str("iPt");
166 
167  unsigned int iPt = std::atoi(_toString(aGPElement->getAttribute(_toDOMS(stringStr.str().c_str()))).c_str());
168  if(iPt==0) return 0;
169 
170  int iEta = std::atoi(_toString(aGPElement->getAttribute(_toDOMS("iEta"))).c_str());
171  int iCharge = std::atoi(_toString(aGPElement->getAttribute(_toDOMS("iCharge"))).c_str());
172  int val = 0;
173  unsigned int nLayers = aGPElement->getElementsByTagName(_toDOMS("Layer"))->getLength();
174  assert(nLayers==OMTFConfiguration::nLayers);
175  DOMNode *aNode = 0;
176  DOMElement* aLayerElement = 0;
177  DOMElement* aItemElement = 0;
178  GoldenPattern::vector2D meanDistPhi2D(nLayers);
179  GoldenPattern::vector1D pdf1D(exp2(OMTFConfiguration::nPdfAddrBits));
180  GoldenPattern::vector3D pdf3D(OMTFConfiguration::nLayers);
181  GoldenPattern::vector2D pdf2D(OMTFConfiguration::nRefLayers);
183  for(unsigned int iLayer=0;iLayer<nLayers;++iLayer){
184  aNode = aGPElement->getElementsByTagName(_toDOMS("Layer"))->item(iLayer);
185  aLayerElement = static_cast<DOMElement *>(aNode);
187  unsigned int nItems = aLayerElement->getElementsByTagName(_toDOMS("RefLayer"))->getLength();
188  assert(nItems==OMTFConfiguration::nRefLayers);
189  GoldenPattern::vector1D meanDistPhi1D(nItems);
190  for(unsigned int iItem=0;iItem<nItems;++iItem){
191  aNode = aLayerElement->getElementsByTagName(_toDOMS("RefLayer"))->item(iItem);
192  aItemElement = static_cast<DOMElement *>(aNode);
193  val = std::atoi(_toString(aItemElement->getAttribute(_toDOMS("meanDistPhi"))).c_str());
194  meanDistPhi1D[iItem] = val;
195  }
196  meanDistPhi2D[iLayer] = meanDistPhi1D;
197 
199  stringStr.str("");
200  if(index>0) stringStr<<"value"<<index;
201  else stringStr.str("value");
202  nItems = aLayerElement->getElementsByTagName(_toDOMS("PDF"))->getLength();
203  assert(nItems==OMTFConfiguration::nRefLayers*exp2(OMTFConfiguration::nPdfAddrBits));
204  for(unsigned int iRefLayer=0;iRefLayer<OMTFConfiguration::nRefLayers;++iRefLayer){
205  pdf1D.assign(exp2(OMTFConfiguration::nPdfAddrBits),0);
206  for(unsigned int iPdf=0;iPdf<exp2(OMTFConfiguration::nPdfAddrBits);++iPdf){
207  aNode = aLayerElement->getElementsByTagName(_toDOMS("PDF"))->item(iRefLayer*exp2(OMTFConfiguration::nPdfAddrBits)+iPdf);
208  aItemElement = static_cast<DOMElement *>(aNode);
209  val = std::atoi(_toString(aItemElement->getAttribute(_toDOMS(stringStr.str().c_str()))).c_str());
210  pdf1D[iPdf] = val;
211  }
212  pdf2D[iRefLayer] = pdf1D;
213  }
214  pdf3D[iLayer] = pdf2D;
215  }
216 
217  Key aKey(iEta,iPt,iCharge);
218  GoldenPattern *aGP = new GoldenPattern(aKey);
219  aGP->setMeanDistPhi(meanDistPhi2D);
220  aGP->setPdf(pdf3D);
221 
222  return aGP;
223 }
OMTFConfiguration::nLayers
static unsigned int nLayers
Definition: OMTFConfiguration.h:65
GoldenPattern::vector1D
std::vector< int > vector1D
Definition: GoldenPattern.h:49
assert
assert(m_qm.get())
_toString
std::string _toString(const XMLCh *toTranscode)
Definition: MiscalibReaderXML.cc:14
OMTFConfiguration::nPdfAddrBits
static unsigned int nPdfAddrBits
Definition: OMTFConfiguration.h:69
GoldenPattern::vector2D
std::vector< vector1D > vector2D
Definition: GoldenPattern.h:50
GoldenPattern::vector3D
std::vector< vector2D > vector3D
Definition: GoldenPattern.h:51
GoldenPattern::setPdf
void setPdf(const vector3D &aPdf)
Definition: GoldenPattern.h:67
OMTFConfiguration::nRefLayers
static unsigned int nRefLayers
Definition: OMTFConfiguration.h:67
GoldenPattern::setMeanDistPhi
void setMeanDistPhi(const vector2D &aMeanDistPhi)
Definition: GoldenPattern.h:61
_toDOMS
XMLCh * _toDOMS(std::string temp)
Definition: MiscalibReaderXML.cc:19
void XMLConfigReader::readConfig ( const std::string  fName)

Referenced by OMTFConfiguration::configure(), and L1TMuonOverlapParamsESProducer::readConnectionsXML().

void XMLConfigReader::readConfig ( OMTFConfiguration *  aConfig)

Addresing bits numbers

Chamber sectors connections to logic processros.

hw <-> logic numbering map

ref<->logic numberig map

processors initial phi for each reference layer

connections tables for each processor each logic cone Vector of all layers

Vector of all logic cones

Vector of all processors

Starting phis of each region Vector of all regions in one processor

Vector of all reflayers

Vector of all processors

Vector of all processros

Definition at line 504 of file XMLConfigReader.cc.

References _toDOMS(), _toString(), assert(), OMTFConfiguration::barrelMax, OMTFConfiguration::barrelMin, OMTFConfiguration::bendingLayers, configFile, OMTFConfiguration::connections, doc, OMTFConfiguration::endcap10DegMax, OMTFConfiguration::endcap10DegMin, OMTFConfiguration::endcap20DegMax, OMTFConfiguration::endcap20DegMin, OMTFConfiguration::hwToLogicLayer, i, cuy::ii, OMTFConfiguration::logicToHwLayer, OMTFConfiguration::logicToLogic, OMTFConfiguration::minPdfVal, OMTFConfiguration::nGoldenPatterns, OMTFConfiguration::nHitsPerLayer, OMTFConfiguration::nInputs, OMTFConfiguration::nLayers, OMTFConfiguration::nLogicRegions, OMTFConfiguration::nPdfAddrBits, OMTFConfiguration::nPdfValBits, OMTFConfiguration::nPhiBins, ecaldqm::binning::nPhiBins, OMTFConfiguration::nPhiBits, OMTFConfiguration::nProcessors, OMTFConfiguration::nRefHits, OMTFConfiguration::nRefLayers, OMTFConfiguration::nTestRefHits, parser, OMTFConfiguration::processorPhiVsRefLayer, OMTFConfiguration::refHitsDefs, OMTFConfiguration::refToLogicNumber, and OMTFConfiguration::regionPhisVsRefLayerVsProcessor.

504  {
505 
506  parser->parse(configFile.c_str());
507  xercesc::DOMDocument* doc = parser->getDocument();
508  assert(doc);
509  unsigned int nElem = doc->getElementsByTagName(_toDOMS("OMTF"))->getLength();
510  if(nElem!=1){
511  edm::LogError("critical")<<"Problem parsing XML file "<<configFile<<std::endl;
512  assert(nElem==1);
513  }
514  DOMNode *aNode = doc->getElementsByTagName(_toDOMS("OMTF"))->item(0);
515  DOMElement* aOMTFElement = static_cast<DOMElement *>(aNode);
516 
518  nElem = aOMTFElement->getElementsByTagName(_toDOMS("GlobalData"))->getLength();
519  assert(nElem==1);
520  aNode = aOMTFElement->getElementsByTagName(_toDOMS("GlobalData"))->item(0);
521  DOMElement* aElement = static_cast<DOMElement *>(aNode);
522 
523  float minPdfVal = 0.001;
524  unsigned int nPdfAddrBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPdfAddrBits"))).c_str());
525  unsigned int nPdfValBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPdfValBits"))).c_str());
526  unsigned int nHitsPerLayer = std::atoi(_toString(aElement->getAttribute(_toDOMS("nHitsPerLayer"))).c_str());
527  unsigned int nPhiBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPhiBits"))).c_str());
528  unsigned int nPhiBins = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPhiBins"))).c_str());
529  unsigned int nRefHits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nRefHits"))).c_str());
530  unsigned int nTestRefHits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nTestRefHits"))).c_str());
531  unsigned int nProcessors = std::atoi(_toString(aElement->getAttribute(_toDOMS("nProcessors"))).c_str());
532  unsigned int nLogicRegions = std::atoi(_toString(aElement->getAttribute(_toDOMS("nLogicRegions"))).c_str());
533  unsigned int nInputs = std::atoi(_toString(aElement->getAttribute(_toDOMS("nInputs"))).c_str());
534  unsigned int nGoldenPatterns = std::atoi(_toString(aElement->getAttribute(_toDOMS("nGoldenPatterns"))).c_str());
535  OMTFConfiguration::minPdfVal = minPdfVal;
536  OMTFConfiguration::nPdfAddrBits = nPdfAddrBits;
537  OMTFConfiguration::nPdfValBits = nPdfValBits;
538  OMTFConfiguration::nHitsPerLayer = nHitsPerLayer;
539  OMTFConfiguration::nPhiBits = nPhiBits;
540  OMTFConfiguration::nPhiBins = nPhiBins;
541  OMTFConfiguration::nRefHits = nRefHits;
542  OMTFConfiguration::nTestRefHits = nTestRefHits;
543  OMTFConfiguration::nProcessors = nProcessors;
544  OMTFConfiguration::nLogicRegions = nLogicRegions;
545  OMTFConfiguration::nInputs = nInputs;
546  OMTFConfiguration::nGoldenPatterns = nGoldenPatterns;
547 
549  OMTFConfiguration::barrelMin = std::vector<unsigned int>(6);
550  OMTFConfiguration::barrelMax = std::vector<unsigned int>(6);
551 
552  OMTFConfiguration::endcap10DegMin = std::vector<unsigned int>(6);
553  OMTFConfiguration::endcap10DegMax = std::vector<unsigned int>(6);
554 
555  OMTFConfiguration::endcap20DegMin = std::vector<unsigned int>(6);
556  OMTFConfiguration::endcap20DegMax = std::vector<unsigned int>(6);
557 
558  nElem = aOMTFElement->getElementsByTagName(_toDOMS("ConnectionMap"))->getLength();
559  DOMElement* aConnectionElement = 0;
560  for(uint i=0;i<nElem;++i){
561  aNode = aOMTFElement->getElementsByTagName(_toDOMS("ConnectionMap"))->item(i);
562  aConnectionElement = static_cast<DOMElement *>(aNode);
563  unsigned int iProcessor = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("iProcessor"))).c_str());
564  unsigned int barrelMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("barrelMin"))).c_str());
565  unsigned int barrelMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("barrelMax"))).c_str());
566  unsigned int endcap10DegMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap10DegMin"))).c_str());
567  unsigned int endcap10DegMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap10DegMax"))).c_str());
568  unsigned int endcap20DegMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap20DegMin"))).c_str());
569  unsigned int endcap20DegMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap20DegMax"))).c_str());
570 
571  OMTFConfiguration::barrelMin[iProcessor] = barrelMin;
572  OMTFConfiguration::endcap10DegMin[iProcessor] = endcap10DegMin;
573  OMTFConfiguration::endcap20DegMin[iProcessor] = endcap20DegMin;
574 
575  OMTFConfiguration::barrelMax[iProcessor] = barrelMax;
576  OMTFConfiguration::endcap10DegMax[iProcessor] = endcap10DegMax;
577  OMTFConfiguration::endcap20DegMax[iProcessor] = endcap20DegMax;
578  }
579 
581  unsigned int nLogicLayers = 0;
582  nElem = aOMTFElement->getElementsByTagName(_toDOMS("LayerMap"))->getLength();
583  DOMElement* aLayerElement = 0;
584  for(uint i=0;i<nElem;++i){
585  aNode = aOMTFElement->getElementsByTagName(_toDOMS("LayerMap"))->item(i);
586  aLayerElement = static_cast<DOMElement *>(aNode);
587  unsigned int hwNumber = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("hwNumber"))).c_str());
588  unsigned int logicNumber = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("logicNumber"))).c_str());
589  unsigned int isBendingLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("bendingLayer"))).c_str());
590  unsigned int iConnectedLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("connectedToLayer"))).c_str());
591  aConfig->hwToLogicLayer[hwNumber] = logicNumber;
592  aConfig->logicToHwLayer[logicNumber] = hwNumber;
593  aConfig->logicToLogic[logicNumber] = iConnectedLayer;
594  if(isBendingLayer) aConfig->bendingLayers.insert(logicNumber);
595  if(nLogicLayers<logicNumber) nLogicLayers = logicNumber;
596  }
597  ++nLogicLayers;//logic number in XML starts from 0.
598  OMTFConfiguration::nLayers = nLogicLayers;
599 
601  unsigned int nRefLayers = 0;
602  nElem = aOMTFElement->getElementsByTagName(_toDOMS("RefLayerMap"))->getLength();
603  aConfig->refToLogicNumber.resize(nElem);
604  DOMElement* aRefLayerElement = 0;
605  for(uint i=0;i<nElem;++i){
606  aNode = aOMTFElement->getElementsByTagName(_toDOMS("RefLayerMap"))->item(i);
607  aRefLayerElement = static_cast<DOMElement *>(aNode);
608  unsigned int refLayer = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("refLayer"))).c_str());
609  unsigned int logicNumber = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("logicNumber"))).c_str());
610  aConfig->refToLogicNumber[refLayer] = logicNumber;
611  if(nRefLayers<logicNumber) nRefLayers = refLayer;
612  }
613  ++nRefLayers;//ref number in XML starts from 0.
614  OMTFConfiguration::nRefLayers = nRefLayers;
615 
617  std::vector<int> vector1D(OMTFConfiguration::nRefLayers,OMTFConfiguration::nPhiBins);
618  OMTFConfiguration::processorPhiVsRefLayer.assign(OMTFConfiguration::nProcessors,vector1D);
619 
622  OMTFConfiguration::vector1D_A aLayer1D(OMTFConfiguration::nLayers);
624  OMTFConfiguration::vector2D_A aLayer2D;
625  aLayer2D.assign(OMTFConfiguration::nProcessors,aLayer1D);
627  OMTFConfiguration::connections.assign(OMTFConfiguration::nProcessors,aLayer2D);
628 
631  std::vector<std::pair<int,int> > aRefHit1D(OMTFConfiguration::nLogicRegions,std::pair<int,int>(9999,9999));
633  std::vector<std::vector<std::pair<int,int> > > aRefHit2D;
634  aRefHit2D.assign(OMTFConfiguration::nRefLayers,aRefHit1D);
636  OMTFConfiguration::regionPhisVsRefLayerVsProcessor.assign(OMTFConfiguration::nProcessors,aRefHit2D);
637 
638  //Vector of ref hit definitions
639  std::vector<RefHitDef> aRefHitsDefs(OMTFConfiguration::nRefHits);
641  OMTFConfiguration::refHitsDefs.assign(OMTFConfiguration::nProcessors,aRefHitsDefs);
642 
643  nElem = aOMTFElement->getElementsByTagName(_toDOMS("Processor"))->getLength();
644  assert(nElem==OMTFConfiguration::nProcessors);
645  DOMElement* aProcessorElement = 0;
646  for(uint i=0;i<nElem;++i){
647  aNode = aOMTFElement->getElementsByTagName(_toDOMS("Processor"))->item(i);
648  aProcessorElement = static_cast<DOMElement *>(aNode);
649  unsigned int iProcessor = std::atoi(_toString(aProcessorElement->getAttribute(_toDOMS("iProcessor"))).c_str());
650  unsigned int nElem1 = aProcessorElement->getElementsByTagName(_toDOMS("RefLayer"))->getLength();
651  assert(nElem1==OMTFConfiguration::nRefLayers);
652  DOMElement* aRefLayerElement = 0;
653  for(uint ii=0;ii<nElem1;++ii){
654  aNode = aProcessorElement->getElementsByTagName(_toDOMS("RefLayer"))->item(ii);
655  aRefLayerElement = static_cast<DOMElement *>(aNode);
656  unsigned int iRefLayer = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("iRefLayer"))).c_str());
657  int iPhi = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("iGlobalPhiStart"))).c_str());
658  OMTFConfiguration::processorPhiVsRefLayer[iProcessor][iRefLayer] = iPhi;
659  }
661  nElem1 = aProcessorElement->getElementsByTagName(_toDOMS("RefHit"))->getLength();
662  assert(nElem1==OMTFConfiguration::nRefHits);
663  DOMElement* aRefHitElement = 0;
664  std::vector<int> starts;
665  starts.assign(OMTFConfiguration::nRefLayers,-1);
666  for(uint ii=0;ii<nElem1;++ii){
667  aNode = aProcessorElement->getElementsByTagName(_toDOMS("RefHit"))->item(ii);
668  aRefHitElement = static_cast<DOMElement *>(aNode);
669  unsigned int iRefHit = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRefHit"))).c_str());
670  int iPhiMin = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iPhiMin"))).c_str());
671  int iPhiMax = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iPhiMax"))).c_str());
672  unsigned int iInput = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iInput"))).c_str());
673  unsigned int iRegion = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRegion"))).c_str());
674  unsigned int iRefLayer = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRefLayer"))).c_str());
676  OMTFConfiguration::regionPhisVsRefLayerVsProcessor[iProcessor][iRefLayer][iRegion] = std::pair<int,int>(iPhiMin,iPhiMax);
677  OMTFConfiguration::refHitsDefs[iProcessor][iRefHit] = RefHitDef(iInput,iPhiMin,iPhiMax,iRegion,iRefLayer);
678  }
680  unsigned int nElem2 = aProcessorElement->getElementsByTagName(_toDOMS("LogicRegion"))->getLength();
681  assert(nElem2==OMTFConfiguration::nProcessors);
682  DOMElement* aRegionElement = 0;
683  for(uint ii=0;ii<nElem2;++ii){
684  aNode = aProcessorElement->getElementsByTagName(_toDOMS("LogicRegion"))->item(ii);
685  aRegionElement = static_cast<DOMElement *>(aNode);
686  unsigned int iRegion = std::atoi(_toString(aRegionElement->getAttribute(_toDOMS("iRegion"))).c_str());
687  unsigned int nElem3 = aRegionElement->getElementsByTagName(_toDOMS("Layer"))->getLength();
688  assert(nElem3==OMTFConfiguration::nLayers);
689  DOMElement* aLayerElement = 0;
690  for(uint iii=0;iii<nElem3;++iii){
691  aNode = aRegionElement->getElementsByTagName(_toDOMS("Layer"))->item(iii);
692  aLayerElement = static_cast<DOMElement *>(aNode);
693  unsigned int iLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iLayer"))).c_str());
694  unsigned int iFirstInput = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iFirstInput"))).c_str());
695  unsigned int nInputs = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("nInputs"))).c_str());
696  OMTFConfiguration::connections[iProcessor][iRegion][iLayer] = std::pair<unsigned int, unsigned int>(iFirstInput,nInputs);
697  }
698  }
699  }
700  delete doc;
701 }
OMTFConfiguration::nLayers
static unsigned int nLayers
Definition: OMTFConfiguration.h:65
i
int i
Definition: DBlmapReader.cc:9
OMTFConfiguration::nInputs
static unsigned int nInputs
Definition: OMTFConfiguration.h:76
XMLConfigReader::doc
xercesc::DOMDocument * doc
Definition: XMLConfigReader.h:61
OMTFConfiguration::endcap20DegMax
static std::vector< unsigned int > endcap20DegMax
Definition: OMTFConfiguration.h:93
OMTFConfiguration::connections
static vector3D_A connections
Definition: OMTFConfiguration.h:120
assert
assert(m_qm.get())
_toString
std::string _toString(const XMLCh *toTranscode)
Definition: MiscalibReaderXML.cc:14
OMTFConfiguration::minPdfVal
static float minPdfVal
Definition: OMTFConfiguration.h:64
OMTFConfiguration::endcap10DegMin
static std::vector< unsigned int > endcap10DegMin
Definition: OMTFConfiguration.h:90
OMTFConfiguration::barrelMax
static std::vector< unsigned int > barrelMax
Definition: OMTFConfiguration.h:89
OMTFConfiguration::nProcessors
static unsigned int nProcessors
Definition: OMTFConfiguration.h:74
cuy.ii
int ii
Definition: cuy.py:588
OMTFConfiguration::nLogicRegions
static unsigned int nLogicRegions
Definition: OMTFConfiguration.h:75
OMTFConfiguration::logicToLogic
static std::map< int, int > logicToLogic
Definition: OMTFConfiguration.h:81
OMTFConfiguration::nPdfAddrBits
static unsigned int nPdfAddrBits
Definition: OMTFConfiguration.h:69
OMTFConfiguration::barrelMin
static std::vector< unsigned int > barrelMin
Definition: OMTFConfiguration.h:88
OMTFConfiguration::nTestRefHits
static unsigned int nTestRefHits
Definition: OMTFConfiguration.h:73
OMTFConfiguration::nHitsPerLayer
static unsigned int nHitsPerLayer
Definition: OMTFConfiguration.h:66
OMTFConfiguration::processorPhiVsRefLayer
static std::vector< std::vector< int > > processorPhiVsRefLayer
Definition: OMTFConfiguration.h:99
OMTFConfiguration::vector1D_A
std::vector< std::pair< unsigned int, unsigned int > > vector1D_A
Map of connections.
Definition: OMTFConfiguration.h:117
OMTFConfiguration::nPhiBins
static unsigned int nPhiBins
Definition: OMTFConfiguration.h:71
OMTFConfiguration::refToLogicNumber
static std::vector< int > refToLogicNumber
Definition: OMTFConfiguration.h:83
OMTFConfiguration::nPhiBits
static unsigned int nPhiBits
Definition: OMTFConfiguration.h:68
XMLConfigReader::parser
xercesc::XercesDOMParser * parser
Definition: XMLConfigReader.h:60
OMTFConfiguration::hwToLogicLayer
static std::map< int, int > hwToLogicLayer
Definition: OMTFConfiguration.h:79
OMTFConfiguration::nRefLayers
static unsigned int nRefLayers
Definition: OMTFConfiguration.h:67
OMTFConfiguration::logicToHwLayer
static std::map< int, int > logicToHwLayer
Definition: OMTFConfiguration.h:80
OMTFConfiguration::nRefHits
static unsigned int nRefHits
Definition: OMTFConfiguration.h:72
OMTFConfiguration::bendingLayers
static std::set< int > bendingLayers
Definition: OMTFConfiguration.h:82
_toDOMS
XMLCh * _toDOMS(std::string temp)
Definition: MiscalibReaderXML.cc:19
OMTFConfiguration::nGoldenPatterns
static unsigned int nGoldenPatterns
Definition: OMTFConfiguration.h:77
OMTFConfiguration::vector2D_A
std::vector< vector1D_A > vector2D_A
Definition: OMTFConfiguration.h:118
XMLConfigReader::configFile
std::string configFile
Definition: XMLConfigReader.h:53
OMTFConfiguration::endcap10DegMax
static std::vector< unsigned int > endcap10DegMax
Definition: OMTFConfiguration.h:91
OMTFConfiguration::regionPhisVsRefLayerVsProcessor
static std::vector< std::vector< std::vector< std::pair< int, int > > > > regionPhisVsRefLayerVsProcessor
Definition: OMTFConfiguration.h:107
OMTFConfiguration::endcap20DegMin
static std::vector< unsigned int > endcap20DegMin
Definition: OMTFConfiguration.h:92
OMTFConfiguration::nPdfValBits
static unsigned int nPdfValBits
Definition: OMTFConfiguration.h:70
OMTFConfiguration::refHitsDefs
static std::vector< std::vector< RefHitDef > > refHitsDefs
Definition: OMTFConfiguration.h:114
void XMLConfigReader::readConfig ( L1TMuonOverlapParams *  aConfig)

Addresing bits numbers

Chamber sectors connections to logic processros. Start/End values for all processors, and chamber types are put into a single vector

hw <-> logic numbering map

ref<->logic numberig map

Definition at line 305 of file XMLConfigReader.cc.

References _toDOMS(), _toString(), assert(), L1TMuonOverlapParams::LayerMapNode::bendingLayer, configFile, L1TMuonOverlapParams::LayerMapNode::connectedToLayer, doc, L1TMuonOverlapParams::GENERAL_ADDRBITS, L1TMuonOverlapParams::GENERAL_HITSPERLAYER, L1TMuonOverlapParams::GENERAL_NCONFIG, L1TMuonOverlapParams::GENERAL_NGOLDENPATTERNS, L1TMuonOverlapParams::GENERAL_NINPUTS, L1TMuonOverlapParams::GENERAL_NLAYERS, L1TMuonOverlapParams::GENERAL_NLOGIC_REGIONS, L1TMuonOverlapParams::GENERAL_NPROCESSORS, L1TMuonOverlapParams::GENERAL_NREFHITS, L1TMuonOverlapParams::GENERAL_NREFLAYERS, L1TMuonOverlapParams::GENERAL_NTESTREFHITS, L1TMuonOverlapParams::GENERAL_PHIBINS, L1TMuonOverlapParams::GENERAL_PHIBITS, L1TMuonOverlapParams::GENERAL_VALBITS, L1TMuonOverlapParams::LayerMapNode::hwNumber, i, L1TMuonOverlapParams::LayerInputNode::iFirstInput, cuy::ii, L1TMuonOverlapParams::RefHitNode::iInput, L1TMuonOverlapParams::LayerInputNode::iLayer, L1TMuonOverlapParams::RefHitNode::iPhiMax, L1TMuonOverlapParams::RefHitNode::iPhiMin, L1TMuonOverlapParams::RefHitNode::iRefHit, L1TMuonOverlapParams::RefHitNode::iRefLayer, L1TMuonOverlapParams::RefHitNode::iRegion, L1TMuonOverlapParams::LayerMapNode::logicNumber, L1TMuonOverlapParams::RefLayerMapNode::logicNumber, L1TMuonOverlapParams::LayerInputNode::nInputs, ecaldqm::binning::nPhiBins, parser, L1TMuonOverlapParams::RefLayerMapNode::refLayer, L1TMuonOverlapParams::setConnectedSectorsEnd(), L1TMuonOverlapParams::setConnectedSectorsStart(), L1TMuonOverlapParams::setFwVersion(), L1TMuonOverlapParams::setGeneralParams(), L1TMuonOverlapParams::setGlobalPhiStartMap(), L1TMuonOverlapParams::setLayerInputMap(), L1TMuonOverlapParams::setLayerMap(), L1TMuonOverlapParams::setRefHitMap(), L1TMuonOverlapParams::setRefLayerMap(), and relval_steps::version.

305  {
306 
307  parser->parse(configFile.c_str());
308  xercesc::DOMDocument* doc = parser->getDocument();
309  assert(doc);
310  unsigned int nElem = doc->getElementsByTagName(_toDOMS("OMTF"))->getLength();
311  if(nElem!=1){
312  edm::LogError("critical")<<"Problem parsing XML file "<<configFile<<std::endl;
313  assert(nElem==1);
314  }
315  DOMNode *aNode = doc->getElementsByTagName(_toDOMS("OMTF"))->item(0);
316  DOMElement* aOMTFElement = static_cast<DOMElement *>(aNode);
317 
318  unsigned int version = std::atoi(_toString(aOMTFElement->getAttribute(_toDOMS("version"))).c_str());
319  aConfig->setFwVersion(version);
320 
322  nElem = aOMTFElement->getElementsByTagName(_toDOMS("GlobalData"))->getLength();
323  assert(nElem==1);
324  aNode = aOMTFElement->getElementsByTagName(_toDOMS("GlobalData"))->item(0);
325  DOMElement* aElement = static_cast<DOMElement *>(aNode);
326 
327  unsigned int nPdfAddrBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPdfAddrBits"))).c_str());
328  unsigned int nPdfValBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPdfValBits"))).c_str());
329  unsigned int nHitsPerLayer = std::atoi(_toString(aElement->getAttribute(_toDOMS("nHitsPerLayer"))).c_str());
330  unsigned int nPhiBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPhiBits"))).c_str());
331  unsigned int nPhiBins = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPhiBins"))).c_str());
332  unsigned int nRefHits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nRefHits"))).c_str());
333  unsigned int nTestRefHits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nTestRefHits"))).c_str());
334  unsigned int nProcessors = std::atoi(_toString(aElement->getAttribute(_toDOMS("nProcessors"))).c_str());
335  unsigned int nLogicRegions = std::atoi(_toString(aElement->getAttribute(_toDOMS("nLogicRegions"))).c_str());
336  unsigned int nInputs = std::atoi(_toString(aElement->getAttribute(_toDOMS("nInputs"))).c_str());
337  unsigned int nLayers = std::atoi(_toString(aElement->getAttribute(_toDOMS("nLayers"))).c_str());
338  unsigned int nRefLayers = std::atoi(_toString(aElement->getAttribute(_toDOMS("nRefLayers"))).c_str());
339  unsigned int nGoldenPatterns = std::atoi(_toString(aElement->getAttribute(_toDOMS("nGoldenPatterns"))).c_str());
340 
341  std::vector<int> paramsVec(L1TMuonOverlapParams::GENERAL_NCONFIG);
342  paramsVec[L1TMuonOverlapParams::GENERAL_ADDRBITS] = nPdfAddrBits;
343  paramsVec[L1TMuonOverlapParams::GENERAL_VALBITS] = nPdfValBits;
344  paramsVec[L1TMuonOverlapParams::GENERAL_HITSPERLAYER] = nHitsPerLayer;
345  paramsVec[L1TMuonOverlapParams::GENERAL_PHIBITS] = nPhiBits;
346  paramsVec[L1TMuonOverlapParams::GENERAL_PHIBINS] = nPhiBins;
347  paramsVec[L1TMuonOverlapParams::GENERAL_NREFHITS] = nRefHits;
348  paramsVec[L1TMuonOverlapParams::GENERAL_NTESTREFHITS] = nTestRefHits;
349  paramsVec[L1TMuonOverlapParams::GENERAL_NPROCESSORS] = nProcessors;
350  paramsVec[L1TMuonOverlapParams::GENERAL_NLOGIC_REGIONS] = nLogicRegions;
351  paramsVec[L1TMuonOverlapParams::GENERAL_NINPUTS] = nInputs;
352  paramsVec[L1TMuonOverlapParams::GENERAL_NLAYERS] = nLayers;
353  paramsVec[L1TMuonOverlapParams::GENERAL_NREFLAYERS] = nRefLayers;
354  paramsVec[L1TMuonOverlapParams::GENERAL_NGOLDENPATTERNS] = nGoldenPatterns;
355  aConfig->setGeneralParams(paramsVec);
356 
359  std::vector<int> sectorsStart(3*6), sectorsEnd(3*6);
360  nElem = aOMTFElement->getElementsByTagName(_toDOMS("ConnectionMap"))->getLength();
361  DOMElement* aConnectionElement = 0;
362  for(uint i=0;i<nElem;++i){
363  aNode = aOMTFElement->getElementsByTagName(_toDOMS("ConnectionMap"))->item(i);
364  aConnectionElement = static_cast<DOMElement *>(aNode);
365  unsigned int iProcessor = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("iProcessor"))).c_str());
366  unsigned int barrelMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("barrelMin"))).c_str());
367  unsigned int barrelMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("barrelMax"))).c_str());
368  unsigned int endcap10DegMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap10DegMin"))).c_str());
369  unsigned int endcap10DegMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap10DegMax"))).c_str());
370  unsigned int endcap20DegMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap20DegMin"))).c_str());
371  unsigned int endcap20DegMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap20DegMax"))).c_str());
372 
373  sectorsStart[iProcessor] = barrelMin;
374  sectorsStart[iProcessor + 6] = endcap10DegMin;
375  sectorsStart[iProcessor +12] = endcap20DegMin;
376 
377  sectorsEnd[iProcessor] = barrelMax;
378  sectorsEnd[iProcessor + 6] = endcap10DegMax;
379  sectorsEnd[iProcessor + 12] = endcap20DegMax;
380  }
381  aConfig->setConnectedSectorsStart(sectorsStart);
382  aConfig->setConnectedSectorsEnd(sectorsEnd);
383 
384 
386  std::vector<L1TMuonOverlapParams::LayerMapNode> aLayerMapVec;
387  L1TMuonOverlapParams::LayerMapNode aLayerMapNode;
388 
389  nElem = aOMTFElement->getElementsByTagName(_toDOMS("LayerMap"))->getLength();
390  DOMElement* aLayerElement = 0;
391  for(uint i=0;i<nElem;++i){
392  aNode = aOMTFElement->getElementsByTagName(_toDOMS("LayerMap"))->item(i);
393  aLayerElement = static_cast<DOMElement *>(aNode);
394  unsigned int hwNumber = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("hwNumber"))).c_str());
395  unsigned int logicNumber = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("logicNumber"))).c_str());
396  unsigned int isBendingLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("bendingLayer"))).c_str());
397  unsigned int iConnectedLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("connectedToLayer"))).c_str());
398  aLayerMapNode.logicNumber = logicNumber;
399  aLayerMapNode.hwNumber = hwNumber;
400  aLayerMapNode.connectedToLayer = iConnectedLayer;
401  aLayerMapNode.bendingLayer = isBendingLayer;
402  aLayerMapVec.push_back(aLayerMapNode);
403  }
404  aConfig->setLayerMap(aLayerMapVec);
405 
407  std::vector<L1TMuonOverlapParams::RefLayerMapNode> aRefLayerMapVec;
408  L1TMuonOverlapParams::RefLayerMapNode aRefLayerNode;
409 
410  nElem = aOMTFElement->getElementsByTagName(_toDOMS("RefLayerMap"))->getLength();
411  DOMElement* aRefLayerElement = 0;
412  for(uint i=0;i<nElem;++i){
413  aNode = aOMTFElement->getElementsByTagName(_toDOMS("RefLayerMap"))->item(i);
414  aRefLayerElement = static_cast<DOMElement *>(aNode);
415  unsigned int refLayer = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("refLayer"))).c_str());
416  unsigned int logicNumber = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("logicNumber"))).c_str());
417  aRefLayerNode.refLayer = refLayer;
418  aRefLayerNode.logicNumber = logicNumber;
419  aRefLayerMapVec.push_back(aRefLayerNode);
420  }
421  aConfig->setRefLayerMap(aRefLayerMapVec);
422 
423 
424  std::vector<int> aGlobalPhiStartVec(nProcessors*nRefLayers);
425 
426  std::vector<L1TMuonOverlapParams::RefHitNode> aRefHitMapVec(nProcessors*nRefHits);
427  L1TMuonOverlapParams::RefHitNode aRefHitNode;
428 
429  std::vector<L1TMuonOverlapParams::LayerInputNode> aLayerInputMapVec(nProcessors*nLogicRegions*nLayers);
430  L1TMuonOverlapParams::LayerInputNode aLayerInputNode;
431 
432  nElem = aOMTFElement->getElementsByTagName(_toDOMS("Processor"))->getLength();
433  assert(nElem==nProcessors);
434  DOMElement* aProcessorElement = 0;
435  for(uint i=0;i<nElem;++i){
436  aNode = aOMTFElement->getElementsByTagName(_toDOMS("Processor"))->item(i);
437  aProcessorElement = static_cast<DOMElement *>(aNode);
438  unsigned int iProcessor = std::atoi(_toString(aProcessorElement->getAttribute(_toDOMS("iProcessor"))).c_str());
439  unsigned int nElem1 = aProcessorElement->getElementsByTagName(_toDOMS("RefLayer"))->getLength();
440  assert(nElem1==nRefLayers);
441  DOMElement* aRefLayerElement = 0;
442  for(uint ii=0;ii<nElem1;++ii){
443  aNode = aProcessorElement->getElementsByTagName(_toDOMS("RefLayer"))->item(ii);
444  aRefLayerElement = static_cast<DOMElement *>(aNode);
445  unsigned int iRefLayer = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("iRefLayer"))).c_str());
446  int iPhi = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("iGlobalPhiStart"))).c_str());
447  aGlobalPhiStartVec[iRefLayer + iProcessor*nRefLayers] = iPhi;
448  }
450  nElem1 = aProcessorElement->getElementsByTagName(_toDOMS("RefHit"))->getLength();
451  assert(nElem1==nRefHits);
452  DOMElement* aRefHitElement = 0;
453  for(uint ii=0;ii<nElem1;++ii){
454  aNode = aProcessorElement->getElementsByTagName(_toDOMS("RefHit"))->item(ii);
455  aRefHitElement = static_cast<DOMElement *>(aNode);
456  unsigned int iRefHit = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRefHit"))).c_str());
457  int iPhiMin = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iPhiMin"))).c_str());
458  int iPhiMax = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iPhiMax"))).c_str());
459  unsigned int iInput = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iInput"))).c_str());
460  unsigned int iRegion = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRegion"))).c_str());
461  unsigned int iRefLayer = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRefLayer"))).c_str());
462 
463  aRefHitNode.iRefHit = iRefHit;
464  aRefHitNode.iPhiMin = iPhiMin;
465  aRefHitNode.iPhiMax = iPhiMax;
466  aRefHitNode.iInput = iInput;
467  aRefHitNode.iRegion = iRegion;
468  aRefHitNode.iRefLayer = iRefLayer;
469  aRefHitMapVec[iRefHit + iProcessor*nRefHits] = aRefHitNode;
470  }
472  unsigned int nElem2 = aProcessorElement->getElementsByTagName(_toDOMS("LogicRegion"))->getLength();
473  assert(nElem2==nProcessors);
474  DOMElement* aRegionElement = 0;
475  for(uint ii=0;ii<nElem2;++ii){
476  aNode = aProcessorElement->getElementsByTagName(_toDOMS("LogicRegion"))->item(ii);
477  aRegionElement = static_cast<DOMElement *>(aNode);
478  unsigned int iRegion = std::atoi(_toString(aRegionElement->getAttribute(_toDOMS("iRegion"))).c_str());
479  unsigned int nElem3 = aRegionElement->getElementsByTagName(_toDOMS("Layer"))->getLength();
480  assert(nElem3==nLayers);
481  DOMElement* aLayerElement = 0;
482  for(uint iii=0;iii<nElem3;++iii){
483  aNode = aRegionElement->getElementsByTagName(_toDOMS("Layer"))->item(iii);
484  aLayerElement = static_cast<DOMElement *>(aNode);
485  unsigned int iLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iLayer"))).c_str());
486  unsigned int iFirstInput = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iFirstInput"))).c_str());
487  unsigned int nInputs = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("nInputs"))).c_str());
488  aLayerInputNode.iLayer = iLayer;
489  aLayerInputNode.iFirstInput = iFirstInput;
490  aLayerInputNode.nInputs = nInputs;
491  aLayerInputMapVec[iLayer + iRegion*nLayers + iProcessor*nLayers*nLogicRegions] = aLayerInputNode;
492  }
493  }
494  }
495 
496  aConfig->setGlobalPhiStartMap(aGlobalPhiStartVec);
497  aConfig->setLayerInputMap(aLayerInputMapVec);
498  aConfig->setRefHitMap(aRefHitMapVec);
499 
500  delete doc;
501 }
i
int i
Definition: DBlmapReader.cc:9
L1TMuonOverlapParams::setLayerMap
void setLayerMap(const std::vector< LayerMapNode > &aVector)
Connections definitions.
Definition: L1TMuonOverlapParams.h:143
L1TMuonOverlapParams::setConnectedSectorsEnd
void setConnectedSectorsEnd(const std::vector< int > &aVector)
Definition: L1TMuonOverlapParams.h:155
XMLConfigReader::doc
xercesc::DOMDocument * doc
Definition: XMLConfigReader.h:61
L1TMuonOverlapParams::LayerMapNode::hwNumber
unsigned int hwNumber
short layer number used within OMTF emulator
Definition: L1TMuonOverlapParams.h:34
L1TMuonOverlapParams::setRefLayerMap
void setRefLayerMap(const std::vector< RefLayerMapNode > &aVector)
Definition: L1TMuonOverlapParams.h:145
relval_steps.version
string version
Definition: relval_steps.py:1453
assert
assert(m_qm.get())
_toString
std::string _toString(const XMLCh *toTranscode)
Definition: MiscalibReaderXML.cc:14
L1TMuonOverlapParams::LayerMapNode::logicNumber
unsigned int logicNumber
logic numer of the layer
Definition: L1TMuonOverlapParams.h:37
cuy.ii
int ii
Definition: cuy.py:588
L1TMuonOverlapParams::setGeneralParams
void setGeneralParams(const std::vector< int > &paramsVec)
Definition: L1TMuonOverlapParams.h:113
L1TMuonOverlapParams::LayerMapNode::bendingLayer
bool bendingLayer
Is this a bending layers?
Definition: L1TMuonOverlapParams.h:40
L1TMuonOverlapParams::setConnectedSectorsStart
void setConnectedSectorsStart(const std::vector< int > &aVector)
Definition: L1TMuonOverlapParams.h:153
XMLConfigReader::parser
xercesc::XercesDOMParser * parser
Definition: XMLConfigReader.h:60
L1TMuonOverlapParams::RefLayerMapNode::refLayer
unsigned int refLayer
Reference layer number.
Definition: L1TMuonOverlapParams.h:55
L1TMuonOverlapParams::setGlobalPhiStartMap
void setGlobalPhiStartMap(const std::vector< int > &aVector)
Definition: L1TMuonOverlapParams.h:149
L1TMuonOverlapParams::setLayerInputMap
void setLayerInputMap(const std::vector< LayerInputNode > &aVector)
Definition: L1TMuonOverlapParams.h:151
L1TMuonOverlapParams::setRefHitMap
void setRefHitMap(const std::vector< RefHitNode > &aVector)
Definition: L1TMuonOverlapParams.h:147
L1TMuonOverlapParams::RefLayerMapNode::logicNumber
unsigned int logicNumber
Corresponding logical layer number.
Definition: L1TMuonOverlapParams.h:58
_toDOMS
XMLCh * _toDOMS(std::string temp)
Definition: MiscalibReaderXML.cc:19
L1TMuonOverlapParams::setFwVersion
void setFwVersion(unsigned fwVersion)
Definition: L1TMuonOverlapParams.h:109
XMLConfigReader::configFile
std::string configFile
Definition: XMLConfigReader.h:53
std::vector< std::vector< int > > XMLConfigReader::readEvent ( unsigned int  iEvent = 0,
unsigned int  iProcessor = 0,
bool  readEta = false 
)

Definition at line 226 of file XMLConfigReader.cc.

References _toDOMS(), _toString(), assert(), doc, eventsFile, input, OMTFConfiguration::nLayers, OMTFConfiguration::nPhiBins, and parser.

Referenced by OMTFinput::readData().

228  {
229  if(!doc){
230  parser->parse(eventsFile.c_str());
231  doc = parser->getDocument();
232  }
233  assert(doc);
234 
235 
236  OMTFinput::vector1D input1D(14,OMTFConfiguration::nPhiBins);
237  OMTFinput::vector2D input2D(OMTFConfiguration::nLayers);
238 
239  unsigned int nElem = doc->getElementsByTagName(_toDOMS("OMTF_Events"))->getLength();
240  assert(nElem==1);
241 
242  DOMNode *aNode = doc->getElementsByTagName(_toDOMS("OMTF_Events"))->item(0);
243  DOMElement* aOMTFElement = static_cast<DOMElement *>(aNode);
244  DOMElement* aEventElement = 0;
245  DOMElement* aBxElement = 0;
246  DOMElement* aProcElement = 0;
247  DOMElement* aLayerElement = 0;
248  DOMElement* aHitElement = 0;
249  unsigned int aLogicLayer = OMTFConfiguration::nLayers+1;
250  int val = 0, input=0;
251 
252  nElem = aOMTFElement->getElementsByTagName(_toDOMS("Event"))->getLength();
253  if(nElem<iEvent){
254  edm::LogError("critical")<<"Problem parsing XML file "<<eventsFile<<std::endl;
255  edm::LogError("critical")<<"not enough events found: "<<nElem<<std::endl;
256  assert(nElem>=iEvent);
257  }
258 
259  aNode = aOMTFElement->getElementsByTagName(_toDOMS("Event"))->item(iEvent);
260  aEventElement = static_cast<DOMElement *>(aNode);
261 
262  unsigned int nBX = aEventElement->getElementsByTagName(_toDOMS("bx"))->getLength();
263  assert(nBX>0);
264  aNode = aEventElement->getElementsByTagName(_toDOMS("bx"))->item(0);
265  aBxElement = static_cast<DOMElement *>(aNode);
266 
267  unsigned int nProc = aEventElement->getElementsByTagName(_toDOMS("Processor"))->getLength();
268  unsigned int aProcID = 99;
269  assert(nProc>=iProcessor);
270  for(unsigned int aProc=0;aProc<nProc;++aProc){
271  aNode = aBxElement->getElementsByTagName(_toDOMS("Processor"))->item(aProc);
272  aProcElement = static_cast<DOMElement *>(aNode);
273  aProcID = std::atoi(_toString(aProcElement->getAttribute(_toDOMS("iProcessor"))).c_str());
274  if(aProcID==iProcessor) break;
275  }
276  if(aProcID!=iProcessor) return input2D;
277 
278  unsigned int nLayersHit = aProcElement->getElementsByTagName(_toDOMS("Layer"))->getLength();
279  assert(nLayersHit<=OMTFConfiguration::nLayers);
280 
281  input2D.assign(OMTFConfiguration::nLayers,input1D);
282 
283  for(unsigned int iLayer=0;iLayer<nLayersHit;++iLayer){
284  aNode = aProcElement->getElementsByTagName(_toDOMS("Layer"))->item(iLayer);
285  aLayerElement = static_cast<DOMElement *>(aNode);
286  aLogicLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iLayer"))).c_str());
287  nElem = aLayerElement->getElementsByTagName(_toDOMS("Hit"))->getLength();
288  input1D.assign(14,OMTFConfiguration::nPhiBins);
289  for(unsigned int iHit=0;iHit<nElem;++iHit){
290  aNode = aLayerElement->getElementsByTagName(_toDOMS("Hit"))->item(iHit);
291  aHitElement = static_cast<DOMElement *>(aNode);
292  val = std::atoi(_toString(aHitElement->getAttribute(_toDOMS("iPhi"))).c_str());
293  if(readEta) val = std::atoi(_toString(aHitElement->getAttribute(_toDOMS("iEta"))).c_str());
294  input = std::atoi(_toString(aHitElement->getAttribute(_toDOMS("iInput"))).c_str());
295  input1D[input] = val;
296  }
297  input2D[aLogicLayer] = input1D;
298  }
299 
300  //delete doc;
301  return input2D;
302 }
OMTFConfiguration::nLayers
static unsigned int nLayers
Definition: OMTFConfiguration.h:65
XMLConfigReader::doc
xercesc::DOMDocument * doc
Definition: XMLConfigReader.h:61
assert
assert(m_qm.get())
_toString
std::string _toString(const XMLCh *toTranscode)
Definition: MiscalibReaderXML.cc:14
OMTFinput::vector1D
std::vector< int > vector1D
Definition: OMTFinput.h:14
OMTFinput::vector2D
std::vector< vector1D > vector2D
Definition: OMTFinput.h:15
input
static std::string const input
Definition: EdmProvDump.cc:44
iEvent
int iEvent
Definition: GenABIO.cc:230
OMTFConfiguration::nPhiBins
static unsigned int nPhiBins
Definition: OMTFConfiguration.h:71
XMLConfigReader::eventsFile
std::string eventsFile
Definition: XMLConfigReader.h:55
XMLConfigReader::parser
xercesc::XercesDOMParser * parser
Definition: XMLConfigReader.h:60
_toDOMS
XMLCh * _toDOMS(std::string temp)
Definition: MiscalibReaderXML.cc:19
void XMLConfigReader::readLUT ( l1t::LUT *  lut,
const std::string &  type 
)

Prepare the header

Fill payload string

Read the data into LUT

Definition at line 58 of file XMLConfigReader.cc.

References aGPs, recoMuon::in, OMTFConfiguration::nLayers, OMTFConfiguration::nPdfAddrBits, OMTFConfiguration::nRefLayers, GenerateHcalLaserBadRunList::out, l1t::LUT::read(), and readPatterns().

Referenced by L1TMuonOverlapParamsESProducer::readPatternsXML().

58  {
59 
60  std::stringstream strStream;
61  int totalInWidth = 6;
62  int outWidth = 6;
63 
64  if(type=="iCharge") outWidth = 1;
65  if(type=="iEta") outWidth = 2;
66  if(type=="iPt") outWidth = 6;
67  if(type=="meanDistPhi"){
68  outWidth = 11;
69  totalInWidth = 14;
70  }
71  if(type=="pdf"){
72  outWidth = 6;
73  totalInWidth = 20;
74  }
75 
77  strStream <<"#<header> V1 "<<totalInWidth<<" "<<outWidth<<" </header> "<<std::endl;
78 
80  const std::vector<GoldenPattern *> & aGPs = readPatterns();
81  unsigned int in = 0;
82  int out = 0;
83  for(auto it: aGPs){
84  if(type=="iCharge") out = it->key().theCharge + 1*(it->key().theCharge<0);
85  if(type=="iEta") out = it->key().theEtaCode;
86  if(type=="iPt") out = it->key().thePtCode;
87  if(type=="meanDistPhi"){
88  for(unsigned int iLayer = 0;iLayer<OMTFConfiguration::nLayers;++iLayer){
89  for(unsigned int iRefLayer=0;iRefLayer<OMTFConfiguration::nRefLayers;++iRefLayer){
90  out = (1<<(outWidth-1)) + it->meanDistPhiValue(iLayer,iRefLayer);
91  strStream<<in<<" "<<out<<std::endl;
92  ++in;
93  }
94  }
95  }
96  if(type=="pdf"){
97  for(unsigned int iLayer = 0;iLayer<OMTFConfiguration::nLayers;++iLayer){
98  for(unsigned int iRefLayer=0;iRefLayer<OMTFConfiguration::nRefLayers;++iRefLayer){
99  for(unsigned int iPdf=0;iPdf<exp2(OMTFConfiguration::nPdfAddrBits);++iPdf){
100  out = it->pdfValue(iLayer,iRefLayer,iPdf);
101  strStream<<in<<" "<<out<<std::endl;
102  ++in;
103  }
104  }
105  }
106  }
107  if(type!="meanDistPhi" && type!="pdf"){
108  strStream<<in<<" "<<out<<std::endl;
109  ++in;
110  }
111  }
113  lut->read(strStream);
114 }
type
type
Definition: HCALResponse.h:21
OMTFConfiguration::nLayers
static unsigned int nLayers
Definition: OMTFConfiguration.h:65
OMTFConfiguration::nPdfAddrBits
static unsigned int nPdfAddrBits
Definition: OMTFConfiguration.h:69
l1t::LUT::read
int read(std::istream &stream)
Definition: LUT.cc:35
OMTFConfiguration::nRefLayers
static unsigned int nRefLayers
Definition: OMTFConfiguration.h:67
XMLConfigReader::aGPs
std::vector< GoldenPattern * > aGPs
Cache with GPs read.
Definition: XMLConfigReader.h:64
XMLConfigReader::readPatterns
std::vector< GoldenPattern * > readPatterns()
Definition: XMLConfigReader.cc:117
std::vector< GoldenPattern * > XMLConfigReader::readPatterns ( )

Patterns XMl format backward compatibility. Can use both packed by 4, or by 1 XML files.

Definition at line 117 of file XMLConfigReader.cc.

References _toDOMS(), aGPs, assert(), buildGP(), doc, cmsHarvester::index, parser, and patternsFile.

Referenced by OMTFProcessor::configure(), and readLUT().

117  {
118 
119  if(aGPs.size()) return aGPs;
120 
121  parser->parse(patternsFile.c_str());
122  xercesc::DOMDocument* doc = parser->getDocument();
123  assert(doc);
124 
125  unsigned int nElem = doc->getElementsByTagName(_toDOMS("GP"))->getLength();
126  if(nElem<1){
127  edm::LogError("critical")<<"Problem parsing XML file "<<patternsFile<<std::endl;
128  edm::LogError("critical")<<"No GoldenPattern items: GP found"<<std::endl;
129  return aGPs;
130  }
131 
132  DOMNode *aNode = 0;
133  DOMElement* aGPElement = 0;
134  for(unsigned int iItem=0;iItem<nElem;++iItem){
135  aNode = doc->getElementsByTagName(_toDOMS("GP"))->item(iItem);
136  aGPElement = static_cast<DOMElement *>(aNode);
137 
138  std::ostringstream stringStr;
139  GoldenPattern *aGP;
140  for(unsigned int index = 1;index<5;++index){
141  stringStr.str("");
142  stringStr<<"iPt"<<index;
144  if(aGPElement->getAttributeNode(_toDOMS(stringStr.str().c_str()))){
145  aGP = buildGP(aGPElement,index);
146  if(aGP) aGPs.push_back(aGP);
147  }
148  else{
149  aGPs.push_back(buildGP(aGPElement));
150  break;
151  }
152  }
153  }
154  delete doc;
155 
156  return aGPs;
157 }
XMLConfigReader::buildGP
GoldenPattern * buildGP(xercesc::DOMElement *aGPElement, unsigned int index=0)
Definition: XMLConfigReader.cc:160
XMLConfigReader::doc
xercesc::DOMDocument * doc
Definition: XMLConfigReader.h:61
assert
assert(m_qm.get())
XMLConfigReader::patternsFile
std::string patternsFile
Definition: XMLConfigReader.h:54
XMLConfigReader::parser
xercesc::XercesDOMParser * parser
Definition: XMLConfigReader.h:60
XMLConfigReader::aGPs
std::vector< GoldenPattern * > aGPs
Cache with GPs read.
Definition: XMLConfigReader.h:64
_toDOMS
XMLCh * _toDOMS(std::string temp)
Definition: MiscalibReaderXML.cc:19
void XMLConfigReader::setConfigFile ( const std::string &  fName)
inline

Definition at line 33 of file XMLConfigReader.h.

References configFile, and MainPageGenerator::fName.

Referenced by L1TMuonOverlapParamsESProducer::L1TMuonOverlapParamsESProducer(), and OMTFConfiguration::OMTFConfiguration().

33 {configFile = fName;}
XMLConfigReader::configFile
std::string configFile
Definition: XMLConfigReader.h:53
void XMLConfigReader::setEventsFile ( const std::string &  fName)
inline

Definition at line 37 of file XMLConfigReader.h.

References eventsFile, and MainPageGenerator::fName.

37 {eventsFile = fName;}
XMLConfigReader::eventsFile
std::string eventsFile
Definition: XMLConfigReader.h:55
void XMLConfigReader::setPatternsFile ( const std::string &  fName)
inline

Definition at line 35 of file XMLConfigReader.h.

References MainPageGenerator::fName, and patternsFile.

Referenced by L1TMuonOverlapParamsESProducer::L1TMuonOverlapParamsESProducer(), and OMTFProcessor::OMTFProcessor().

35 {patternsFile = fName;}
XMLConfigReader::patternsFile
std::string patternsFile
Definition: XMLConfigReader.h:54

Member Data Documentation

std::vector<GoldenPattern*> XMLConfigReader::aGPs
private

Cache with GPs read.

Definition at line 64 of file XMLConfigReader.h.

Referenced by readLUT(), and readPatterns().

std::string XMLConfigReader::configFile
private

Definition at line 53 of file XMLConfigReader.h.

Referenced by readConfig(), cmsswPreprocessor.CmsswPreprocessor::run(), and setConfigFile().

xercesc::DOMDocument* XMLConfigReader::doc
private

Definition at line 61 of file XMLConfigReader.h.

Referenced by readConfig(), readEvent(), readPatterns(), and XMLConfigReader().

std::string XMLConfigReader::eventsFile
private

Definition at line 55 of file XMLConfigReader.h.

Referenced by readEvent(), and setEventsFile().

xercesc::XercesDOMParser* XMLConfigReader::parser
private

Definition at line 60 of file XMLConfigReader.h.

Referenced by readConfig(), readEvent(), readPatterns(), and XMLConfigReader().

std::string XMLConfigReader::patternsFile
private

Definition at line 54 of file XMLConfigReader.h.

Referenced by readPatterns(), and setPatternsFile().

Generated for CMSSW Reference Manual by doxygen 1.8.5