CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
XMLConfigReader.cc
Go to the documentation of this file.
1 #include <iostream>
2 #include <cmath>
3 #include <algorithm>
4 #include <utility>
5 
6 #include "L1Trigger/L1TMuonOverlap/interface/XMLConfigReader.h"
7 #include "L1Trigger/L1TMuonOverlap/interface/GoldenPattern.h"
8 #include "L1Trigger/L1TMuonOverlap/interface/OMTFinput.h"
9 
10 #include "CondFormats/L1TObjects/interface/L1TMuonOverlapParams.h"
11 
12 #include "FWCore/MessageLogger/interface/MessageLogger.h"
13 
14 #include "xercesc/framework/StdOutFormatTarget.hpp"
15 #include "xercesc/framework/LocalFileFormatTarget.hpp"
16 #include "xercesc/parsers/XercesDOMParser.hpp"
17 #include "xercesc/dom/DOM.hpp"
18 #include "xercesc/dom/DOMException.hpp"
19 #include "xercesc/dom/DOMImplementation.hpp"
20 #include "xercesc/sax/HandlerBase.hpp"
21 #include "xercesc/util/XMLString.hpp"
22 #include "xercesc/util/PlatformUtils.hpp"
23 #include "xercesc/util/XercesDefs.hpp"
24 XERCES_CPP_NAMESPACE_USE
25 
26 #include "L1Trigger/RPCTrigger/interface/RPCConst.h"
28 // XMLConfigReader
30 inline std::string _toString(XMLCh const* toTranscode) {
31 std::string tmp(xercesc::XMLString::transcode(toTranscode));
32 return tmp;
33 }
34 
35 inline XMLCh* _toDOMS(std::string temp) {
36  XMLCh* buff = XMLString::transcode(temp.c_str());
37  return buff;
38 }
41 XMLConfigReader::XMLConfigReader(OMTFConfiguration * omtf_config) : m_omtf_config(omtf_config) {
42 
43  XMLPlatformUtils::Initialize();
44 
46  parser = new XercesDOMParser();
47  parser->setValidationScheme(XercesDOMParser::Val_Auto);
48  parser->setDoNamespaces(false);
49 
50  doc = 0;
51 
52 
53 
54 }
57 void XMLConfigReader::readLUT(l1t::LUT *lut, const std::string & type){
58 
59  std::stringstream strStream;
60  int totalInWidth = 6;
61  int outWidth = 6;
62 
63  if(type=="iCharge") outWidth = 1;
64  if(type=="iEta") outWidth = 2;
65  if(type=="iPt") outWidth = 9;
66  if(type=="meanDistPhi"){
67  outWidth = 11;
68  totalInWidth = 14;
69  }
70  if(type=="pdf"){
71  outWidth = 6;
72  totalInWidth = 20;
73  }
74 
76  strStream <<"#<header> V1 "<<totalInWidth<<" "<<outWidth<<" </header> "<<std::endl;
77 
79  const std::vector<GoldenPattern *> & aGPs = readPatterns();
80  unsigned int in = 0;
81  int out = 0;
82  for(auto it: aGPs){
83  if(type=="iCharge") out = it->key().theCharge==-1 ? 0:1;
84  if(type=="iEta") out = it->key().theEtaCode;
85  if(type=="iPt") out = it->key().thePtCode;
86  if(type=="meanDistPhi"){
87  for(unsigned int iLayer = 0;iLayer<m_omtf_config->nLayers;++iLayer){
88  for(unsigned int iRefLayer=0;iRefLayer<m_omtf_config->nRefLayers;++iRefLayer){
89  out = (1<<(outWidth-1)) + it->meanDistPhiValue(iLayer,iRefLayer);
90  strStream<<in<<" "<<out<<std::endl;
91  ++in;
92  }
93  }
94  }
95  if(type=="pdf"){
96  for(unsigned int iLayer = 0;iLayer<m_omtf_config->nLayers;++iLayer){
97  for(unsigned int iRefLayer=0;iRefLayer<m_omtf_config->nRefLayers;++iRefLayer){
98  for(unsigned int iPdf=0;iPdf<exp2(m_omtf_config->nPdfAddrBits);++iPdf){
99  out = it->pdfValue(iLayer,iRefLayer,iPdf);
100  strStream<<in<<" "<<out<<std::endl;
101  ++in;
102  }
103  }
104  }
105  }
106  if(type!="meanDistPhi" && type!="pdf"){
107  strStream<<in<<" "<<out<<std::endl;
108  ++in;
109  }
110  }
112  lut->read(strStream);
113 }
116 std::vector<GoldenPattern*> XMLConfigReader::readPatterns(){
117 
118  //if(aGPs.size()) return aGPs;
119  aGPs.clear();
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  aGP = buildGP(aGPElement);
150  if(aGP) aGPs.push_back(aGP);
151  break;
152  }
153  }
154  }
155  delete doc;
156 
157  return aGPs;
158 }
161 GoldenPattern * XMLConfigReader::buildGP(DOMElement* aGPElement,
162  unsigned int index){
163 
164  std::ostringstream stringStr;
165  if(index>0) stringStr<<"iPt"<<index;
166  else stringStr.str("iPt");
167 
168  unsigned int iPt = std::atoi(_toString(aGPElement->getAttribute(_toDOMS(stringStr.str().c_str()))).c_str());
169  if(iPt==0) return 0;
170 
171  int iEta = std::atoi(_toString(aGPElement->getAttribute(_toDOMS("iEta"))).c_str());
172  int iCharge = std::atoi(_toString(aGPElement->getAttribute(_toDOMS("iCharge"))).c_str());
173  int val = 0;
174  unsigned int nLayers = aGPElement->getElementsByTagName(_toDOMS("Layer"))->getLength();
175  assert(nLayers==m_omtf_config->nLayers);
176  DOMNode *aNode = 0;
177  DOMElement* aLayerElement = 0;
178  DOMElement* aItemElement = 0;
179  GoldenPattern::vector2D meanDistPhi2D(nLayers);
180  GoldenPattern::vector1D pdf1D(exp2(m_omtf_config->nPdfAddrBits));
181  GoldenPattern::vector3D pdf3D(m_omtf_config->nLayers);
182  GoldenPattern::vector2D pdf2D(m_omtf_config->nRefLayers);
184  for(unsigned int iLayer=0;iLayer<nLayers;++iLayer){
185  aNode = aGPElement->getElementsByTagName(_toDOMS("Layer"))->item(iLayer);
186  aLayerElement = static_cast<DOMElement *>(aNode);
188  unsigned int nItems = aLayerElement->getElementsByTagName(_toDOMS("RefLayer"))->getLength();
189  assert(nItems==m_omtf_config->nRefLayers);
190  GoldenPattern::vector1D meanDistPhi1D(nItems);
191  for(unsigned int iItem=0;iItem<nItems;++iItem){
192  aNode = aLayerElement->getElementsByTagName(_toDOMS("RefLayer"))->item(iItem);
193  aItemElement = static_cast<DOMElement *>(aNode);
194  val = std::atoi(_toString(aItemElement->getAttribute(_toDOMS("meanDistPhi"))).c_str());
195  meanDistPhi1D[iItem] = val;
196  }
197  meanDistPhi2D[iLayer] = meanDistPhi1D;
198 
200  stringStr.str("");
201  if(index>0) stringStr<<"value"<<index;
202  else stringStr.str("value");
203  nItems = aLayerElement->getElementsByTagName(_toDOMS("PDF"))->getLength();
204  assert(nItems==m_omtf_config->nRefLayers*exp2(m_omtf_config->nPdfAddrBits));
205  for(unsigned int iRefLayer=0;iRefLayer<m_omtf_config->nRefLayers;++iRefLayer){
206  pdf1D.assign(exp2(m_omtf_config->nPdfAddrBits),0);
207  for(unsigned int iPdf=0;iPdf<exp2(m_omtf_config->nPdfAddrBits);++iPdf){
208  aNode = aLayerElement->getElementsByTagName(_toDOMS("PDF"))->item(iRefLayer*exp2(m_omtf_config->nPdfAddrBits)+iPdf);
209  aItemElement = static_cast<DOMElement *>(aNode);
210  val = std::atoi(_toString(aItemElement->getAttribute(_toDOMS(stringStr.str().c_str()))).c_str());
211  pdf1D[iPdf] = val;
212  }
213  pdf2D[iRefLayer] = pdf1D;
214  }
215  pdf3D[iLayer] = pdf2D;
216  }
217 
218  Key aKey(iEta,iPt,iCharge);
219  GoldenPattern *aGP = new GoldenPattern(aKey);
220  aGP->setMeanDistPhi(meanDistPhi2D);
221  aGP->setPdf(pdf3D);
222 
223  return aGP;
224 }
227 std::vector<std::vector<int> > XMLConfigReader::readEvent(unsigned int iEvent,
228  unsigned int iProcessor,
229  bool readEta){
230  if(!doc){
231  parser->parse(eventsFile.c_str());
232  doc = parser->getDocument();
233  }
234  assert(doc);
235 
236 
237  OMTFinput::vector1D input1D(14,m_omtf_config->nPhiBins);
238  OMTFinput::vector2D input2D(m_omtf_config->nLayers);
239 
240  unsigned int nElem = doc->getElementsByTagName(_toDOMS("OMTF_Events"))->getLength();
241  assert(nElem==1);
242 
243  DOMNode *aNode = doc->getElementsByTagName(_toDOMS("OMTF_Events"))->item(0);
244  DOMElement* aOMTFElement = static_cast<DOMElement *>(aNode);
245  DOMElement* aEventElement = 0;
246  DOMElement* aBxElement = 0;
247  DOMElement* aProcElement = 0;
248  DOMElement* aLayerElement = 0;
249  DOMElement* aHitElement = 0;
250  unsigned int aLogicLayer = m_omtf_config->nLayers+1;
251  int val = 0, input=0;
252 
253  nElem = aOMTFElement->getElementsByTagName(_toDOMS("Event"))->getLength();
254  if(nElem<iEvent){
255  edm::LogError("critical")<<"Problem parsing XML file "<<eventsFile<<std::endl;
256  edm::LogError("critical")<<"not enough events found: "<<nElem<<std::endl;
257  assert(nElem>=iEvent);
258  }
259 
260  aNode = aOMTFElement->getElementsByTagName(_toDOMS("Event"))->item(iEvent);
261  aEventElement = static_cast<DOMElement *>(aNode);
262 
263  unsigned int nBX = aEventElement->getElementsByTagName(_toDOMS("bx"))->getLength();
264  assert(nBX>0);
265  aNode = aEventElement->getElementsByTagName(_toDOMS("bx"))->item(0);
266  aBxElement = static_cast<DOMElement *>(aNode);
267 
268  unsigned int nProc = aEventElement->getElementsByTagName(_toDOMS("Processor"))->getLength();
269  unsigned int aProcID = 99;
270  assert(nProc>=iProcessor);
271  for(unsigned int aProc=0;aProc<nProc;++aProc){
272  aNode = aBxElement->getElementsByTagName(_toDOMS("Processor"))->item(aProc);
273  aProcElement = static_cast<DOMElement *>(aNode);
274  aProcID = std::atoi(_toString(aProcElement->getAttribute(_toDOMS("iProcessor"))).c_str());
275  if(aProcID==iProcessor) break;
276  }
277  if(aProcID!=iProcessor) return input2D;
278 
279  unsigned int nLayersHit = aProcElement->getElementsByTagName(_toDOMS("Layer"))->getLength();
280  assert(nLayersHit<=m_omtf_config->nLayers);
281 
282  input2D.assign(m_omtf_config->nLayers,input1D);
283 
284  for(unsigned int iLayer=0;iLayer<nLayersHit;++iLayer){
285  aNode = aProcElement->getElementsByTagName(_toDOMS("Layer"))->item(iLayer);
286  aLayerElement = static_cast<DOMElement *>(aNode);
287  aLogicLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iLayer"))).c_str());
288  nElem = aLayerElement->getElementsByTagName(_toDOMS("Hit"))->getLength();
289  input1D.assign(14,m_omtf_config->nPhiBins);
290  for(unsigned int iHit=0;iHit<nElem;++iHit){
291  aNode = aLayerElement->getElementsByTagName(_toDOMS("Hit"))->item(iHit);
292  aHitElement = static_cast<DOMElement *>(aNode);
293  val = std::atoi(_toString(aHitElement->getAttribute(_toDOMS("iPhi"))).c_str());
294  if(readEta) val = std::atoi(_toString(aHitElement->getAttribute(_toDOMS("iEta"))).c_str());
295  input = std::atoi(_toString(aHitElement->getAttribute(_toDOMS("iInput"))).c_str());
296  input1D[input] = val;
297  }
298  input2D[aLogicLayer] = input1D;
299  }
300 
301  //delete doc;
302  return input2D;
303 }
306 void XMLConfigReader::readConfig( L1TMuonOverlapParams *aConfig){
307 
308  parser->parse(configFile.c_str());
309  xercesc::DOMDocument* doc = parser->getDocument();
310  assert(doc);
311  unsigned int nElem = doc->getElementsByTagName(_toDOMS("OMTF"))->getLength();
312  if(nElem!=1){
313  edm::LogError("critical")<<"Problem parsing XML file "<<configFile<<std::endl;
314  assert(nElem==1);
315  }
316  DOMNode *aNode = doc->getElementsByTagName(_toDOMS("OMTF"))->item(0);
317  DOMElement* aOMTFElement = static_cast<DOMElement *>(aNode);
318 
319  unsigned int version = std::stoul(_toString(aOMTFElement->getAttribute(_toDOMS("version"))), nullptr, 16);
320  aConfig->setFwVersion(version);
321 
323  nElem = aOMTFElement->getElementsByTagName(_toDOMS("GlobalData"))->getLength();
324  assert(nElem==1);
325  aNode = aOMTFElement->getElementsByTagName(_toDOMS("GlobalData"))->item(0);
326  DOMElement* aElement = static_cast<DOMElement *>(aNode);
327 
328  unsigned int nPdfAddrBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPdfAddrBits"))).c_str());
329  unsigned int nPdfValBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPdfValBits"))).c_str());
330  unsigned int nHitsPerLayer = std::atoi(_toString(aElement->getAttribute(_toDOMS("nHitsPerLayer"))).c_str());
331  unsigned int nPhiBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPhiBits"))).c_str());
332  unsigned int nPhiBins = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPhiBins"))).c_str());
333  unsigned int nRefHits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nRefHits"))).c_str());
334  unsigned int nTestRefHits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nTestRefHits"))).c_str());
335  unsigned int nProcessors = std::atoi(_toString(aElement->getAttribute(_toDOMS("nProcessors"))).c_str());
336  unsigned int nLogicRegions = std::atoi(_toString(aElement->getAttribute(_toDOMS("nLogicRegions"))).c_str());
337  unsigned int nInputs = std::atoi(_toString(aElement->getAttribute(_toDOMS("nInputs"))).c_str());
338  unsigned int nLayers = std::atoi(_toString(aElement->getAttribute(_toDOMS("nLayers"))).c_str());
339  unsigned int nRefLayers = std::atoi(_toString(aElement->getAttribute(_toDOMS("nRefLayers"))).c_str());
340  unsigned int nGoldenPatterns = std::atoi(_toString(aElement->getAttribute(_toDOMS("nGoldenPatterns"))).c_str());
341 
342  std::vector<int> paramsVec(L1TMuonOverlapParams::GENERAL_NCONFIG);
343  paramsVec[L1TMuonOverlapParams::GENERAL_ADDRBITS] = nPdfAddrBits;
344  paramsVec[L1TMuonOverlapParams::GENERAL_VALBITS] = nPdfValBits;
345  paramsVec[L1TMuonOverlapParams::GENERAL_HITSPERLAYER] = nHitsPerLayer;
346  paramsVec[L1TMuonOverlapParams::GENERAL_PHIBITS] = nPhiBits;
347  paramsVec[L1TMuonOverlapParams::GENERAL_PHIBINS] = nPhiBins;
348  paramsVec[L1TMuonOverlapParams::GENERAL_NREFHITS] = nRefHits;
349  paramsVec[L1TMuonOverlapParams::GENERAL_NTESTREFHITS] = nTestRefHits;
350  paramsVec[L1TMuonOverlapParams::GENERAL_NPROCESSORS] = nProcessors;
351  paramsVec[L1TMuonOverlapParams::GENERAL_NLOGIC_REGIONS] = nLogicRegions;
352  paramsVec[L1TMuonOverlapParams::GENERAL_NINPUTS] = nInputs;
353  paramsVec[L1TMuonOverlapParams::GENERAL_NLAYERS] = nLayers;
354  paramsVec[L1TMuonOverlapParams::GENERAL_NREFLAYERS] = nRefLayers;
355  paramsVec[L1TMuonOverlapParams::GENERAL_NGOLDENPATTERNS] = nGoldenPatterns;
356  aConfig->setGeneralParams(paramsVec);
357 
360  std::vector<int> sectorsStart(3*6), sectorsEnd(3*6);
361  nElem = aOMTFElement->getElementsByTagName(_toDOMS("ConnectionMap"))->getLength();
362  DOMElement* aConnectionElement = 0;
363  for(uint i=0;i<nElem;++i){
364  aNode = aOMTFElement->getElementsByTagName(_toDOMS("ConnectionMap"))->item(i);
365  aConnectionElement = static_cast<DOMElement *>(aNode);
366  unsigned int iProcessor = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("iProcessor"))).c_str());
367  unsigned int barrelMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("barrelMin"))).c_str());
368  unsigned int barrelMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("barrelMax"))).c_str());
369  unsigned int endcap10DegMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap10DegMin"))).c_str());
370  unsigned int endcap10DegMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap10DegMax"))).c_str());
371  unsigned int endcap20DegMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap20DegMin"))).c_str());
372  unsigned int endcap20DegMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap20DegMax"))).c_str());
373 
374  sectorsStart[iProcessor] = barrelMin;
375  sectorsStart[iProcessor + 6] = endcap10DegMin;
376  sectorsStart[iProcessor +12] = endcap20DegMin;
377 
378  sectorsEnd[iProcessor] = barrelMax;
379  sectorsEnd[iProcessor + 6] = endcap10DegMax;
380  sectorsEnd[iProcessor + 12] = endcap20DegMax;
381  }
382  aConfig->setConnectedSectorsStart(sectorsStart);
383  aConfig->setConnectedSectorsEnd(sectorsEnd);
384 
385 
387  std::vector<L1TMuonOverlapParams::LayerMapNode> aLayerMapVec;
388  L1TMuonOverlapParams::LayerMapNode aLayerMapNode;
389 
390  nElem = aOMTFElement->getElementsByTagName(_toDOMS("LayerMap"))->getLength();
391  DOMElement* aLayerElement = 0;
392  for(uint i=0;i<nElem;++i){
393  aNode = aOMTFElement->getElementsByTagName(_toDOMS("LayerMap"))->item(i);
394  aLayerElement = static_cast<DOMElement *>(aNode);
395  unsigned int hwNumber = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("hwNumber"))).c_str());
396  unsigned int logicNumber = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("logicNumber"))).c_str());
397  unsigned int isBendingLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("bendingLayer"))).c_str());
398  unsigned int iConnectedLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("connectedToLayer"))).c_str());
399  aLayerMapNode.logicNumber = logicNumber;
400  aLayerMapNode.hwNumber = hwNumber;
401  aLayerMapNode.connectedToLayer = iConnectedLayer;
402  aLayerMapNode.bendingLayer = isBendingLayer;
403  aLayerMapVec.push_back(aLayerMapNode);
404  }
405  aConfig->setLayerMap(aLayerMapVec);
406 
408  std::vector<L1TMuonOverlapParams::RefLayerMapNode> aRefLayerMapVec;
409  L1TMuonOverlapParams::RefLayerMapNode aRefLayerNode;
410 
411  nElem = aOMTFElement->getElementsByTagName(_toDOMS("RefLayerMap"))->getLength();
412  DOMElement* aRefLayerElement = 0;
413  for(uint i=0;i<nElem;++i){
414  aNode = aOMTFElement->getElementsByTagName(_toDOMS("RefLayerMap"))->item(i);
415  aRefLayerElement = static_cast<DOMElement *>(aNode);
416  unsigned int refLayer = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("refLayer"))).c_str());
417  unsigned int logicNumber = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("logicNumber"))).c_str());
418  aRefLayerNode.refLayer = refLayer;
419  aRefLayerNode.logicNumber = logicNumber;
420  aRefLayerMapVec.push_back(aRefLayerNode);
421  }
422  aConfig->setRefLayerMap(aRefLayerMapVec);
423 
424 
425  std::vector<int> aGlobalPhiStartVec(nProcessors*nRefLayers);
426 
427  std::vector<L1TMuonOverlapParams::RefHitNode> aRefHitMapVec(nProcessors*nRefHits);
428  L1TMuonOverlapParams::RefHitNode aRefHitNode;
429 
430  std::vector<L1TMuonOverlapParams::LayerInputNode> aLayerInputMapVec(nProcessors*nLogicRegions*nLayers);
431  L1TMuonOverlapParams::LayerInputNode aLayerInputNode;
432 
433  nElem = aOMTFElement->getElementsByTagName(_toDOMS("Processor"))->getLength();
434  assert(nElem==nProcessors);
435  DOMElement* aProcessorElement = 0;
436  for(uint i=0;i<nElem;++i){
437  aNode = aOMTFElement->getElementsByTagName(_toDOMS("Processor"))->item(i);
438  aProcessorElement = static_cast<DOMElement *>(aNode);
439  unsigned int iProcessor = std::atoi(_toString(aProcessorElement->getAttribute(_toDOMS("iProcessor"))).c_str());
440  unsigned int nElem1 = aProcessorElement->getElementsByTagName(_toDOMS("RefLayer"))->getLength();
441  assert(nElem1==nRefLayers);
442  DOMElement* aRefLayerElement = 0;
443  for(uint ii=0;ii<nElem1;++ii){
444  aNode = aProcessorElement->getElementsByTagName(_toDOMS("RefLayer"))->item(ii);
445  aRefLayerElement = static_cast<DOMElement *>(aNode);
446  unsigned int iRefLayer = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("iRefLayer"))).c_str());
447  int iPhi = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("iGlobalPhiStart"))).c_str());
448  aGlobalPhiStartVec[iRefLayer + iProcessor*nRefLayers] = iPhi;
449  }
451  nElem1 = aProcessorElement->getElementsByTagName(_toDOMS("RefHit"))->getLength();
452  assert( (iProcessor==0 && nElem1==nRefHits) || (iProcessor!=0 && nElem1==0) );
453  DOMElement* aRefHitElement = 0;
454  for(uint ii=0;ii<nElem1;++ii){
455  aNode = aProcessorElement->getElementsByTagName(_toDOMS("RefHit"))->item(ii);
456  aRefHitElement = static_cast<DOMElement *>(aNode);
457  unsigned int iRefHit = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRefHit"))).c_str());
458  int iPhiMin = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iPhiMin"))).c_str());
459  int iPhiMax = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iPhiMax"))).c_str());
460  unsigned int iInput = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iInput"))).c_str());
461  unsigned int iRegion = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRegion"))).c_str());
462  unsigned int iRefLayer = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRefLayer"))).c_str());
463 
464  aRefHitNode.iRefHit = iRefHit;
465  aRefHitNode.iPhiMin = iPhiMin;
466  aRefHitNode.iPhiMax = iPhiMax;
467  aRefHitNode.iInput = iInput;
468  aRefHitNode.iRegion = iRegion;
469  aRefHitNode.iRefLayer = iRefLayer;
470  //aRefHitMapVec[iRefHit + iProcessor*nRefHits] = aRefHitNode;
471  for (unsigned int ip=0; ip<nProcessors; ++ip) aRefHitMapVec[iRefHit + ip*nRefHits] = aRefHitNode;
472  }
474  unsigned int nElem2 = aProcessorElement->getElementsByTagName(_toDOMS("LogicRegion"))->getLength();
475  assert( (iProcessor==0 && nElem2==nLogicRegions) || (iProcessor!=0 && nElem2==0) );
476  DOMElement* aRegionElement = 0;
477  for(uint ii=0;ii<nElem2;++ii){
478  aNode = aProcessorElement->getElementsByTagName(_toDOMS("LogicRegion"))->item(ii);
479  aRegionElement = static_cast<DOMElement *>(aNode);
480  unsigned int iRegion = std::atoi(_toString(aRegionElement->getAttribute(_toDOMS("iRegion"))).c_str());
481  unsigned int nElem3 = aRegionElement->getElementsByTagName(_toDOMS("Layer"))->getLength();
482  assert(nElem3==nLayers);
483  DOMElement* aLayerElement = 0;
484  for(uint iii=0;iii<nElem3;++iii){
485  aNode = aRegionElement->getElementsByTagName(_toDOMS("Layer"))->item(iii);
486  aLayerElement = static_cast<DOMElement *>(aNode);
487  unsigned int iLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iLayer"))).c_str());
488  unsigned int iFirstInput = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iFirstInput"))).c_str());
489  unsigned int nInputs = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("nInputs"))).c_str());
490  aLayerInputNode.iLayer = iLayer;
491  aLayerInputNode.iFirstInput = iFirstInput;
492  aLayerInputNode.nInputs = nInputs;
493 // aLayerInputMapVec[iLayer + iRegion*nLayers + iProcessor*nLayers*nLogicRegions] = aLayerInputNode;
494  for (unsigned int ip=0; ip<nProcessors; ++ip) aLayerInputMapVec[iLayer + iRegion*nLayers + ip*nLayers*nLogicRegions] = aLayerInputNode;
495  }
496  }
497  }
498 
499  aConfig->setGlobalPhiStartMap(aGlobalPhiStartVec);
500  aConfig->setLayerInputMap(aLayerInputMapVec);
501  aConfig->setRefHitMap(aRefHitMapVec);
502 
503  delete doc;
504 }
507 void XMLConfigReader::readConfig(OMTFConfiguration *aConfig){
508 
509  parser->parse(configFile.c_str());
510  xercesc::DOMDocument* doc = parser->getDocument();
511  assert(doc);
512  unsigned int nElem = doc->getElementsByTagName(_toDOMS("OMTF"))->getLength();
513  if(nElem!=1){
514  edm::LogError("critical")<<"Problem parsing XML file "<<configFile<<std::endl;
515  assert(nElem==1);
516  }
517  DOMNode *aNode = doc->getElementsByTagName(_toDOMS("OMTF"))->item(0);
518  DOMElement* aOMTFElement = static_cast<DOMElement *>(aNode);
519  unsigned int fwVersion = std::atoi(_toString(aOMTFElement->getAttribute(_toDOMS("version"))).c_str());
520 
522  nElem = aOMTFElement->getElementsByTagName(_toDOMS("GlobalData"))->getLength();
523  assert(nElem==1);
524  aNode = aOMTFElement->getElementsByTagName(_toDOMS("GlobalData"))->item(0);
525  DOMElement* aElement = static_cast<DOMElement *>(aNode);
526 
527  float minPdfVal = 0.001;
528  unsigned int nPdfAddrBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPdfAddrBits"))).c_str());
529  unsigned int nPdfValBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPdfValBits"))).c_str());
530  unsigned int nHitsPerLayer = std::atoi(_toString(aElement->getAttribute(_toDOMS("nHitsPerLayer"))).c_str());
531  unsigned int nPhiBits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPhiBits"))).c_str());
532  unsigned int nPhiBins = std::atoi(_toString(aElement->getAttribute(_toDOMS("nPhiBins"))).c_str());
533  unsigned int nRefHits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nRefHits"))).c_str());
534  unsigned int nTestRefHits = std::atoi(_toString(aElement->getAttribute(_toDOMS("nTestRefHits"))).c_str());
535  unsigned int nProcessors = std::atoi(_toString(aElement->getAttribute(_toDOMS("nProcessors"))).c_str());
536  unsigned int nLogicRegions = std::atoi(_toString(aElement->getAttribute(_toDOMS("nLogicRegions"))).c_str());
537  unsigned int nInputs = std::atoi(_toString(aElement->getAttribute(_toDOMS("nInputs"))).c_str());
538  unsigned int nGoldenPatterns = std::atoi(_toString(aElement->getAttribute(_toDOMS("nGoldenPatterns"))).c_str());
539  m_omtf_config->fwVersion = fwVersion;
540  m_omtf_config->minPdfVal = minPdfVal;
541  m_omtf_config->nPdfAddrBits = nPdfAddrBits;
542  m_omtf_config->nPdfValBits = nPdfValBits;
543  m_omtf_config->nHitsPerLayer = nHitsPerLayer;
544  m_omtf_config->nPhiBits = nPhiBits;
545  m_omtf_config->nPhiBins = nPhiBins;
546  m_omtf_config->nRefHits = nRefHits;
547  m_omtf_config->nTestRefHits = nTestRefHits;
548  m_omtf_config->nProcessors = nProcessors;
549  m_omtf_config->nLogicRegions = nLogicRegions;
550  m_omtf_config->nInputs = nInputs;
551  m_omtf_config->nGoldenPatterns = nGoldenPatterns;
552 
554  m_omtf_config->barrelMin = std::vector<unsigned int>(6);
555  m_omtf_config->barrelMax = std::vector<unsigned int>(6);
556 
557  m_omtf_config->endcap10DegMin = std::vector<unsigned int>(6);
558  m_omtf_config->endcap10DegMax = std::vector<unsigned int>(6);
559 
560  m_omtf_config->endcap20DegMin = std::vector<unsigned int>(6);
561  m_omtf_config->endcap20DegMax = std::vector<unsigned int>(6);
562 
563  nElem = aOMTFElement->getElementsByTagName(_toDOMS("ConnectionMap"))->getLength();
564  DOMElement* aConnectionElement = 0;
565  for(uint i=0;i<nElem;++i){
566  aNode = aOMTFElement->getElementsByTagName(_toDOMS("ConnectionMap"))->item(i);
567  aConnectionElement = static_cast<DOMElement *>(aNode);
568  unsigned int iProcessor = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("iProcessor"))).c_str());
569  unsigned int barrelMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("barrelMin"))).c_str());
570  unsigned int barrelMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("barrelMax"))).c_str());
571  unsigned int endcap10DegMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap10DegMin"))).c_str());
572  unsigned int endcap10DegMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap10DegMax"))).c_str());
573  unsigned int endcap20DegMin = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap20DegMin"))).c_str());
574  unsigned int endcap20DegMax = std::atoi(_toString(aConnectionElement->getAttribute(_toDOMS("endcap20DegMax"))).c_str());
575 
576  m_omtf_config->barrelMin[iProcessor] = barrelMin;
577  m_omtf_config->endcap10DegMin[iProcessor] = endcap10DegMin;
578  m_omtf_config->endcap20DegMin[iProcessor] = endcap20DegMin;
579 
580  m_omtf_config->barrelMax[iProcessor] = barrelMax;
581  m_omtf_config->endcap10DegMax[iProcessor] = endcap10DegMax;
582  m_omtf_config->endcap20DegMax[iProcessor] = endcap20DegMax;
583  }
584 
586  unsigned int nLogicLayers = 0;
587  nElem = aOMTFElement->getElementsByTagName(_toDOMS("LayerMap"))->getLength();
588  DOMElement* aLayerElement = 0;
589  for(uint i=0;i<nElem;++i){
590  aNode = aOMTFElement->getElementsByTagName(_toDOMS("LayerMap"))->item(i);
591  aLayerElement = static_cast<DOMElement *>(aNode);
592  unsigned int hwNumber = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("hwNumber"))).c_str());
593  unsigned int logicNumber = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("logicNumber"))).c_str());
594  unsigned int isBendingLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("bendingLayer"))).c_str());
595  unsigned int iConnectedLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("connectedToLayer"))).c_str());
596  aConfig->hwToLogicLayer[hwNumber] = logicNumber;
597  aConfig->logicToHwLayer[logicNumber] = hwNumber;
598  aConfig->logicToLogic[logicNumber] = iConnectedLayer;
599  if(isBendingLayer) aConfig->bendingLayers.insert(logicNumber);
600  if(nLogicLayers<logicNumber) nLogicLayers = logicNumber;
601  }
602  ++nLogicLayers;//logic number in XML starts from 0.
603  m_omtf_config->nLayers = nLogicLayers;
604 
606  unsigned int nRefLayers = 0;
607  nElem = aOMTFElement->getElementsByTagName(_toDOMS("RefLayerMap"))->getLength();
608  aConfig->refToLogicNumber.resize(nElem);
609  DOMElement* aRefLayerElement = 0;
610  for(uint i=0;i<nElem;++i){
611  aNode = aOMTFElement->getElementsByTagName(_toDOMS("RefLayerMap"))->item(i);
612  aRefLayerElement = static_cast<DOMElement *>(aNode);
613  unsigned int refLayer = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("refLayer"))).c_str());
614  unsigned int logicNumber = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("logicNumber"))).c_str());
615  aConfig->refToLogicNumber[refLayer] = logicNumber;
616  if(nRefLayers<logicNumber) nRefLayers = refLayer;
617  }
618  ++nRefLayers;//ref number in XML starts from 0.
619  m_omtf_config->nRefLayers = nRefLayers;
620 
622  std::vector<int> vector1D(m_omtf_config->nRefLayers,m_omtf_config->nPhiBins);
623  m_omtf_config->processorPhiVsRefLayer.assign(m_omtf_config->nProcessors,vector1D);
624 
627  OMTFConfiguration::vector1D_A aLayer1D(m_omtf_config->nLayers);
629  OMTFConfiguration::vector2D_A aLayer2D;
630  aLayer2D.assign(m_omtf_config->nLogicRegions,aLayer1D);
632  m_omtf_config->connections.assign(m_omtf_config->nProcessors,aLayer2D);
633 
636  std::vector<std::pair<int,int> > aRefHit1D(m_omtf_config->nLogicRegions,std::pair<int,int>(9999,9999));
638  std::vector<std::vector<std::pair<int,int> > > aRefHit2D;
639  aRefHit2D.assign(m_omtf_config->nRefLayers,aRefHit1D);
641  m_omtf_config->regionPhisVsRefLayerVsInput.assign(m_omtf_config->nInputs,aRefHit2D);
642 
643  //Vector of ref hit definitions
644  std::vector<RefHitDef> aRefHitsDefs(m_omtf_config->nRefHits);
646  m_omtf_config->refHitsDefs.assign(m_omtf_config->nProcessors,aRefHitsDefs);
647 
648  nElem = aOMTFElement->getElementsByTagName(_toDOMS("Processor"))->getLength();
649  assert(nElem==m_omtf_config->nProcessors);
650  DOMElement* aProcessorElement = 0;
651  for(uint i=0;i<nElem;++i){
652  aNode = aOMTFElement->getElementsByTagName(_toDOMS("Processor"))->item(i);
653  aProcessorElement = static_cast<DOMElement *>(aNode);
654  unsigned int iProcessor = std::atoi(_toString(aProcessorElement->getAttribute(_toDOMS("iProcessor"))).c_str());
655  unsigned int nElem1 = aProcessorElement->getElementsByTagName(_toDOMS("RefLayer"))->getLength();
656  assert(nElem1==m_omtf_config->nRefLayers);
657  DOMElement* aRefLayerElement = 0;
658  for(uint ii=0;ii<nElem1;++ii){
659  aNode = aProcessorElement->getElementsByTagName(_toDOMS("RefLayer"))->item(ii);
660  aRefLayerElement = static_cast<DOMElement *>(aNode);
661  unsigned int iRefLayer = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("iRefLayer"))).c_str());
662  int iPhi = std::atoi(_toString(aRefLayerElement->getAttribute(_toDOMS("iGlobalPhiStart"))).c_str());
663  m_omtf_config->processorPhiVsRefLayer[iProcessor][iRefLayer] = iPhi;
664  }
666  nElem1 = aProcessorElement->getElementsByTagName(_toDOMS("RefHit"))->getLength();
667  assert((iProcessor==0 && nElem1==nRefHits) || (iProcessor!=0 && nElem1==0) );
668  DOMElement* aRefHitElement = 0;
669  for(uint ii=0;ii<nElem1;++ii){
670  aNode = aProcessorElement->getElementsByTagName(_toDOMS("RefHit"))->item(ii);
671  aRefHitElement = static_cast<DOMElement *>(aNode);
672  unsigned int iRefHit = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRefHit"))).c_str());
673  int iPhiMin = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iPhiMin"))).c_str());
674  int iPhiMax = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iPhiMax"))).c_str());
675  unsigned int iInput = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iInput"))).c_str());
676  unsigned int iRegion = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRegion"))).c_str());
677  unsigned int iRefLayer = std::atoi(_toString(aRefHitElement->getAttribute(_toDOMS("iRefLayer"))).c_str());
679  m_omtf_config->regionPhisVsRefLayerVsInput[iInput][iRefLayer][iRegion] = std::pair<int,int>(iPhiMin,iPhiMax);
680  m_omtf_config->refHitsDefs[iProcessor][iRefHit] = RefHitDef(iInput,iPhiMin,iPhiMax,iRegion,iRefLayer);
682  if(iProcessor==0){
683  for (unsigned int iProcessorTmp=0; iProcessorTmp<m_omtf_config->nProcessors; ++iProcessorTmp){
684  m_omtf_config->refHitsDefs[iProcessorTmp][iRefHit] = RefHitDef(iInput,iPhiMin,iPhiMax,iRegion,iRefLayer);
685  }
686  }
687  }
689  unsigned int nElem2 = aProcessorElement->getElementsByTagName(_toDOMS("LogicRegion"))->getLength();
690  assert( (iProcessor==0 && nElem2==nLogicRegions) || (iProcessor!=0 && nElem2==0) );
691  DOMElement* aRegionElement = 0;
692  for(uint ii=0;ii<nElem2;++ii){
693  aNode = aProcessorElement->getElementsByTagName(_toDOMS("LogicRegion"))->item(ii);
694  aRegionElement = static_cast<DOMElement *>(aNode);
695  unsigned int iRegion = std::atoi(_toString(aRegionElement->getAttribute(_toDOMS("iRegion"))).c_str());
696  unsigned int nElem3 = aRegionElement->getElementsByTagName(_toDOMS("Layer"))->getLength();
697  assert(nElem3==m_omtf_config->nLayers);
698  DOMElement* aLayerElement = 0;
699  for(uint iii=0;iii<nElem3;++iii){
700  aNode = aRegionElement->getElementsByTagName(_toDOMS("Layer"))->item(iii);
701  aLayerElement = static_cast<DOMElement *>(aNode);
702  unsigned int iLayer = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iLayer"))).c_str());
703  unsigned int iFirstInput = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("iFirstInput"))).c_str());
704  unsigned int nInputs = std::atoi(_toString(aLayerElement->getAttribute(_toDOMS("nInputs"))).c_str());
705  m_omtf_config->connections[iProcessor][iRegion][iLayer] = std::pair<unsigned int, unsigned int>(iFirstInput,nInputs);
707  if(iProcessor==0){
708  for (unsigned int iProcessorTmp=0; iProcessorTmp<m_omtf_config->nProcessors; ++iProcessorTmp){
709  m_omtf_config->connections[iProcessorTmp][iRegion][iLayer] = std::pair<unsigned int, unsigned int>(iFirstInput,nInputs);
710  }
711  }
712  }
713  }
714  }
715  delete doc;
716 }
719 
OMTFConfiguration::endcap20DegMax
std::vector< unsigned int > endcap20DegMax
Definition: OMTFConfiguration.h:96
type
type
Definition: HCALResponse.h:21
OMTFConfiguration::nLayers
unsigned int nLayers
Definition: OMTFConfiguration.h:68
i
int i
Definition: DBlmapReader.cc:9
OMTFConfiguration::logicToLogic
std::map< int, int > logicToLogic
Definition: OMTFConfiguration.h:84
OMTFConfiguration::endcap10DegMin
std::vector< unsigned int > endcap10DegMin
Definition: OMTFConfiguration.h:93
L1TMuonOverlapParams::setLayerMap
void setLayerMap(const std::vector< LayerMapNode > &aVector)
Connections definitions.
Definition: L1TMuonOverlapParams.h:143
XMLConfigReader::buildGP
GoldenPattern * buildGP(xercesc::DOMElement *aGPElement, unsigned int index=0)
Definition: XMLConfigReader.cc:161
OMTFConfiguration::nInputs
unsigned int nInputs
Definition: OMTFConfiguration.h:79
L1TMuonOverlapParams::setConnectedSectorsEnd
void setConnectedSectorsEnd(const std::vector< int > &aVector)
Definition: L1TMuonOverlapParams.h:155
XMLConfigReader::doc
xercesc::DOMDocument * doc
Definition: XMLConfigReader.h:62
L1TMuonOverlapParams::LayerMapNode::hwNumber
unsigned int hwNumber
short layer number used within OMTF emulator
Definition: L1TMuonOverlapParams.h:34
GoldenPattern::vector1D
std::vector< int > vector1D
Definition: GoldenPattern.h:49
L1TMuonOverlapParams::setRefLayerMap
void setRefLayerMap(const std::vector< RefLayerMapNode > &aVector)
Definition: L1TMuonOverlapParams.h:145
relval_steps.version
string version
Definition: relval_steps.py:1494
assert
assert(m_qm.get())
_toString
std::string _toString(const XMLCh *toTranscode)
Definition: MiscalibReaderXML.cc:14
XMLConfigReader::m_omtf_config
OMTFConfiguration * m_omtf_config
Definition: XMLConfigReader.h:67
L1TMuonOverlapParams::LayerMapNode::logicNumber
unsigned int logicNumber
logic numer of the layer
Definition: L1TMuonOverlapParams.h:37
XMLConfigReader::readEvent
std::vector< std::vector< int > > readEvent(unsigned int iEvent=0, unsigned int iProcessor=0, bool readEta=false)
Definition: XMLConfigReader.cc:227
OMTFConfiguration::processorPhiVsRefLayer
std::vector< std::vector< int > > processorPhiVsRefLayer
Definition: OMTFConfiguration.h:102
OMTFConfiguration::nProcessors
unsigned int nProcessors
Definition: OMTFConfiguration.h:77
cuy.ii
int ii
Definition: cuy.py:588
OMTFinput::vector1D
std::vector< int > vector1D
Definition: OMTFinput.h:14
OMTFConfiguration::nLogicRegions
unsigned int nLogicRegions
Definition: OMTFConfiguration.h:78
OMTFConfiguration::logicToHwLayer
std::map< int, int > logicToHwLayer
Definition: OMTFConfiguration.h:83
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
OMTFConfiguration::endcap20DegMin
std::vector< unsigned int > endcap20DegMin
Definition: OMTFConfiguration.h:95
OMTFinput::vector2D
std::vector< vector1D > vector2D
Definition: OMTFinput.h:15
input
static std::string const input
Definition: EdmProvDump.cc:44
OMTFConfiguration::refToLogicNumber
std::vector< int > refToLogicNumber
Definition: OMTFConfiguration.h:86
XMLConfigReader::patternsFile
std::string patternsFile
Definition: XMLConfigReader.h:55
OMTFConfiguration::endcap10DegMax
std::vector< unsigned int > endcap10DegMax
Definition: OMTFConfiguration.h:94
OMTFConfiguration::nPdfAddrBits
unsigned int nPdfAddrBits
Definition: OMTFConfiguration.h:72
l1t::LUT::read
int read(std::istream &stream)
Definition: LUT.cc:35
iEvent
int iEvent
Definition: GenABIO.cc:230
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
XMLConfigReader::XMLConfigReader
XMLConfigReader(OMTFConfiguration *omtf_config)
Definition: XMLConfigReader.cc:41
L1TMuonOverlapParams::setGeneralParams
void setGeneralParams(const std::vector< int > &paramsVec)
Definition: L1TMuonOverlapParams.h:113
OMTFConfiguration::fwVersion
unsigned int fwVersion
Definition: OMTFConfiguration.h:66
OMTFConfiguration::nTestRefHits
unsigned int nTestRefHits
Definition: OMTFConfiguration.h:76
XERCES_CPP_NAMESPACE_USE::transcode
XMLCh * transcode(const T &fInput)
Definition: HcalDQMDbInterface.cc:6
OMTFConfiguration::nHitsPerLayer
unsigned int nHitsPerLayer
Definition: OMTFConfiguration.h:69
OMTFConfiguration::refHitsDefs
std::vector< std::vector< RefHitDef > > refHitsDefs
Definition: OMTFConfiguration.h:117
OMTFConfiguration::vector1D_A
std::vector< std::pair< unsigned int, unsigned int > > vector1D_A
Map of connections.
Definition: OMTFConfiguration.h:120
OMTFConfiguration::nPhiBins
unsigned int nPhiBins
Definition: OMTFConfiguration.h:74
lumiPlot.lut
tuple lut
Definition: lumiPlot.py:244
XMLConfigReader::readLUT
void readLUT(l1t::LUT *lut, const std::string &type)
Definition: XMLConfigReader.cc:57
XMLConfigReader::readConfig
void readConfig(const std::string fName)
L1TMuonOverlapParams::LayerMapNode::bendingLayer
bool bendingLayer
Is this a bending layers?
Definition: L1TMuonOverlapParams.h:40
XMLConfigReader::eventsFile
std::string eventsFile
Definition: XMLConfigReader.h:56
OMTFConfiguration::nPhiBits
unsigned int nPhiBits
Definition: OMTFConfiguration.h:71
stage2BMTFBufferRaw_cfi.fwVersion
tuple fwVersion
Definition: stage2BMTFBufferRaw_cfi.py:62
L1TMuonOverlapParams::setConnectedSectorsStart
void setConnectedSectorsStart(const std::vector< int > &aVector)
Definition: L1TMuonOverlapParams.h:153
XMLConfigReader::parser
xercesc::XercesDOMParser * parser
Definition: XMLConfigReader.h:61
l1t::LUT
Definition: LUT.h:29
OMTFConfiguration::barrelMin
std::vector< unsigned int > barrelMin
Definition: OMTFConfiguration.h:91
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
OMTFConfiguration::nRefLayers
unsigned int nRefLayers
Definition: OMTFConfiguration.h:70
L1TMuonOverlapParams::setLayerInputMap
void setLayerInputMap(const std::vector< LayerInputNode > &aVector)
Definition: L1TMuonOverlapParams.h:151
OMTFConfiguration::bendingLayers
std::set< int > bendingLayers
Definition: OMTFConfiguration.h:85
OMTFConfiguration::hwToLogicLayer
std::map< int, int > hwToLogicLayer
Definition: OMTFConfiguration.h:82
XMLConfigReader::aGPs
std::vector< GoldenPattern * > aGPs
Cache with GPs read.
Definition: XMLConfigReader.h:65
XMLConfigReader::readPatterns
std::vector< GoldenPattern * > readPatterns()
Definition: XMLConfigReader.cc:116
L1TMuonOverlapParams::setRefHitMap
void setRefHitMap(const std::vector< RefHitNode > &aVector)
Definition: L1TMuonOverlapParams.h:147
OMTFConfiguration::nRefHits
unsigned int nRefHits
Definition: OMTFConfiguration.h:75
tmp
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100
GoldenPattern::setMeanDistPhi
void setMeanDistPhi(const vector2D &aMeanDistPhi)
Definition: GoldenPattern.h:61
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
OMTFConfiguration::nGoldenPatterns
unsigned int nGoldenPatterns
Definition: OMTFConfiguration.h:80
OMTFConfiguration::vector2D_A
std::vector< vector1D_A > vector2D_A
Definition: OMTFConfiguration.h:121
OMTFConfiguration::regionPhisVsRefLayerVsInput
std::vector< std::vector< std::vector< std::pair< int, int > > > > regionPhisVsRefLayerVsInput
Definition: OMTFConfiguration.h:110
XMLConfigReader::configFile
std::string configFile
Definition: XMLConfigReader.h:54
OMTFConfiguration::barrelMax
std::vector< unsigned int > barrelMax
Definition: OMTFConfiguration.h:92
OMTFConfiguration::nPdfValBits
unsigned int nPdfValBits
Definition: OMTFConfiguration.h:73
Generated for CMSSW Reference Manual by doxygen 1.8.5