File indexing completed on 2025-05-27 01:56:23
0001 #include <iostream>
0002 #include <cmath>
0003 #include <algorithm>
0004 #include <utility>
0005 #include <array>
0006
0007 #include "L1Trigger/L1TMuonOverlap/interface/XMLConfigReader.h"
0008 #include "L1Trigger/L1TMuonOverlap/interface/GoldenPattern.h"
0009 #include "L1Trigger/L1TMuonOverlap/interface/OMTFinput.h"
0010
0011 #include "CondFormats/L1TObjects/interface/L1TMuonOverlapParams.h"
0012
0013 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0014
0015 #include "Utilities/Xerces/interface/Xerces.h"
0016
0017 #include "xercesc/framework/StdOutFormatTarget.hpp"
0018 #include "xercesc/framework/LocalFileFormatTarget.hpp"
0019 #include "xercesc/parsers/XercesDOMParser.hpp"
0020 #include "xercesc/dom/DOM.hpp"
0021 #include "xercesc/dom/DOMException.hpp"
0022 #include "xercesc/dom/DOMImplementation.hpp"
0023 #include "xercesc/sax/HandlerBase.hpp"
0024 #include "xercesc/util/XMLString.hpp"
0025 #include "xercesc/util/PlatformUtils.hpp"
0026 #include "xercesc/util/XercesDefs.hpp"
0027 XERCES_CPP_NAMESPACE_USE
0028
0029 #include "L1Trigger/RPCTrigger/interface/RPCConst.h"
0030
0031
0032
0033 inline std::string _toString(XMLCh const *toTranscode) {
0034 std::string tmp(xercesc::XMLString::transcode(toTranscode));
0035 return tmp;
0036 }
0037
0038 inline XMLCh *_toDOMS(std::string temp) {
0039 XMLCh *buff = XMLString::transcode(temp.c_str());
0040 return buff;
0041 }
0042
0043
0044 XMLConfigReader::XMLConfigReader() { cms::concurrency::xercesInitialize(); }
0045
0046 XMLConfigReader::~XMLConfigReader() {
0047
0048 cms::concurrency::xercesTerminate();
0049 }
0050
0051
0052 void XMLConfigReader::readLUTs(std::vector<l1t::LUT *> luts,
0053 const L1TMuonOverlapParams &aConfig,
0054 const std::vector<std::string> &types) {
0055
0056 auto const &aGPs = readPatterns(aConfig);
0057
0058 for (unsigned int i = 0; i < luts.size(); i++) {
0059 l1t::LUT *lut = luts[i];
0060 const std::string &type = types[i];
0061
0062 std::stringstream strStream;
0063 int totalInWidth = 7;
0064 int outWidth = 6;
0065
0066 if (type == "iCharge")
0067 outWidth = 1;
0068 if (type == "iEta")
0069 outWidth = 2;
0070 if (type == "iPt")
0071 outWidth = 9;
0072 if (type == "meanDistPhi") {
0073 outWidth = 11;
0074 totalInWidth = 14;
0075 }
0076 if (type == "pdf") {
0077 outWidth = 6;
0078 totalInWidth = 21;
0079 }
0080
0081
0082 strStream << "#<header> V1 " << totalInWidth << " " << outWidth << " </header> " << std::endl;
0083
0084 unsigned int in = 0;
0085 int out = 0;
0086 for (const auto &it : aGPs) {
0087 if (type == "iCharge")
0088 out = it->key().theCharge == -1 ? 0 : 1;
0089 if (type == "iEta")
0090 out = it->key().theEtaCode;
0091 if (type == "iPt")
0092 out = it->key().thePtCode;
0093 if (type == "meanDistPhi") {
0094 for (unsigned int iLayer = 0; iLayer < (unsigned)aConfig.nLayers(); ++iLayer) {
0095 for (unsigned int iRefLayer = 0; iRefLayer < (unsigned)aConfig.nRefLayers(); ++iRefLayer) {
0096 out = (1 << (outWidth - 1)) + it->meanDistPhiValue(iLayer, iRefLayer);
0097 strStream << in << " " << out << std::endl;
0098 ++in;
0099 }
0100 }
0101 }
0102 if (type == "pdf") {
0103 for (unsigned int iLayer = 0; iLayer < (unsigned)aConfig.nLayers(); ++iLayer) {
0104 for (unsigned int iRefLayer = 0; iRefLayer < (unsigned)aConfig.nRefLayers(); ++iRefLayer) {
0105 for (unsigned int iPdf = 0; iPdf < exp2(aConfig.nPdfAddrBits()); ++iPdf) {
0106 out = it->pdfValue(iLayer, iRefLayer, iPdf);
0107 strStream << in << " " << out << std::endl;
0108 ++in;
0109 }
0110 }
0111 }
0112 }
0113 if (type != "meanDistPhi" && type != "pdf") {
0114 strStream << in << " " << out << std::endl;
0115 ++in;
0116 }
0117 }
0118
0119
0120 lut->read(strStream);
0121 }
0122 }
0123
0124
0125 unsigned int XMLConfigReader::getPatternsVersion() const {
0126 if (patternsFile.empty())
0127 return 0;
0128
0129 unsigned int version = 0;
0130 {
0131 XercesDOMParser parser;
0132 parser.setValidationScheme(XercesDOMParser::Val_Auto);
0133 parser.setDoNamespaces(false);
0134
0135 parser.parse(patternsFile.c_str());
0136 xercesc::DOMDocument *doc = parser.getDocument();
0137 assert(doc);
0138
0139 XMLCh *xmlOmtf = _toDOMS("OMTF");
0140 XMLCh *xmlVersion = _toDOMS("version");
0141 DOMNode *aNode = doc->getElementsByTagName(xmlOmtf)->item(0);
0142 DOMElement *aOMTFElement = static_cast<DOMElement *>(aNode);
0143
0144 version = std::stoul(_toString(aOMTFElement->getAttribute(xmlVersion)), nullptr, 16);
0145 XMLString::release(&xmlOmtf);
0146 XMLString::release(&xmlVersion);
0147 parser.resetDocumentPool();
0148 }
0149
0150 return version;
0151 }
0152
0153
0154 std::vector<std::shared_ptr<GoldenPattern>> XMLConfigReader::readPatterns(const L1TMuonOverlapParams &aConfig) {
0155 aGPs.clear();
0156
0157 XMLCh *xmlGP = _toDOMS("GP");
0158 std::array<XMLCh *, 4> xmliPt = {{_toDOMS("iPt1"), _toDOMS("iPt2"), _toDOMS("iPt3"), _toDOMS("iPt4")}};
0159
0160 {
0161 XercesDOMParser parser;
0162 parser.setValidationScheme(XercesDOMParser::Val_Auto);
0163 parser.setDoNamespaces(false);
0164
0165 parser.parse(patternsFile.c_str());
0166 xercesc::DOMDocument *doc = parser.getDocument();
0167 assert(doc);
0168
0169 unsigned int nElem = doc->getElementsByTagName(xmlGP)->getLength();
0170 if (nElem < 1) {
0171 edm::LogError("critical") << "Problem parsing XML file " << patternsFile << std::endl;
0172 edm::LogError("critical") << "No GoldenPattern items: GP found" << std::endl;
0173 return aGPs;
0174 }
0175
0176 DOMNode *aNode = nullptr;
0177 DOMElement *aGPElement = nullptr;
0178 unsigned int iGPNumber = 0;
0179
0180 for (unsigned int iItem = 0; iItem < nElem; ++iItem) {
0181 aNode = doc->getElementsByTagName(xmlGP)->item(iItem);
0182 aGPElement = static_cast<DOMElement *>(aNode);
0183
0184 std::unique_ptr<GoldenPattern> aGP;
0185 for (unsigned int index = 1; index < 5; ++index) {
0186
0187 if (aGPElement->getAttributeNode(xmliPt[index - 1])) {
0188 aGP = buildGP(aGPElement, aConfig, index, iGPNumber);
0189 if (aGP) {
0190 aGPs.emplace_back(std::move(aGP));
0191 iGPNumber++;
0192 }
0193 } else {
0194 aGP = buildGP(aGPElement, aConfig);
0195 if (aGP) {
0196 aGPs.emplace_back(std::move(aGP));
0197 iGPNumber++;
0198 }
0199 break;
0200 }
0201 }
0202 }
0203
0204
0205
0206 parser.resetDocumentPool();
0207 }
0208 XMLString::release(&xmlGP);
0209 XMLString::release(&xmliPt[0]);
0210 XMLString::release(&xmliPt[1]);
0211 XMLString::release(&xmliPt[2]);
0212 XMLString::release(&xmliPt[3]);
0213
0214 return aGPs;
0215 }
0216
0217
0218 std::unique_ptr<GoldenPattern> XMLConfigReader::buildGP(DOMElement *aGPElement,
0219 const L1TMuonOverlapParams &aConfig,
0220 unsigned int index,
0221 unsigned int aGPNumber) {
0222 XMLCh *xmliEta = _toDOMS("iEta");
0223
0224 std::ostringstream stringStr;
0225 if (index > 0)
0226 stringStr << "iPt" << index;
0227 else
0228 stringStr.str("iPt");
0229 XMLCh *xmliPt = _toDOMS(stringStr.str());
0230 stringStr.str("");
0231 if (index > 0)
0232 stringStr << "value" << index;
0233 else
0234 stringStr.str("value");
0235 XMLCh *xmlValue = _toDOMS(stringStr.str());
0236
0237 XMLCh *xmliCharge = _toDOMS("iCharge");
0238 XMLCh *xmlLayer = _toDOMS("Layer");
0239 XMLCh *xmlRefLayer = _toDOMS("RefLayer");
0240 XMLCh *xmlmeanDistPhi = _toDOMS("meanDistPhi");
0241 XMLCh *xmlPDF = _toDOMS("PDF");
0242
0243 unsigned int iPt = std::atoi(_toString(aGPElement->getAttribute(xmliPt)).c_str());
0244 int iEta = std::atoi(_toString(aGPElement->getAttribute(xmliEta)).c_str());
0245 int iCharge = std::atoi(_toString(aGPElement->getAttribute(xmliCharge)).c_str());
0246 int val = 0;
0247 unsigned int nLayers = aGPElement->getElementsByTagName(xmlLayer)->getLength();
0248 assert(nLayers == (unsigned)aConfig.nLayers());
0249
0250 DOMNode *aNode = nullptr;
0251 DOMElement *aLayerElement = nullptr;
0252 DOMElement *aItemElement = nullptr;
0253 GoldenPattern::vector2D meanDistPhi2D(nLayers);
0254 GoldenPattern::vector1D pdf1D(exp2(aConfig.nPdfAddrBits()));
0255 GoldenPattern::vector3D pdf3D(aConfig.nLayers());
0256 GoldenPattern::vector2D pdf2D(aConfig.nRefLayers());
0257
0258 if (iPt == 0) {
0259 GoldenPattern::vector1D meanDistPhi1D(aConfig.nRefLayers());
0260 meanDistPhi2D.assign(aConfig.nLayers(), meanDistPhi1D);
0261 pdf1D.assign(exp2(aConfig.nPdfAddrBits()), 0);
0262 pdf2D.assign(aConfig.nRefLayers(), pdf1D);
0263 pdf3D.assign(aConfig.nLayers(), pdf2D);
0264
0265 Key aKey(iEta, iPt, iCharge, aGPNumber);
0266 auto aGP = std::make_unique<GoldenPattern>(aKey, static_cast<const OMTFConfiguration *>(nullptr));
0267 aGP->setMeanDistPhi(meanDistPhi2D);
0268 aGP->setPdf(pdf3D);
0269 return aGP;
0270 }
0271
0272
0273 for (unsigned int iLayer = 0; iLayer < nLayers; ++iLayer) {
0274 aNode = aGPElement->getElementsByTagName(xmlLayer)->item(iLayer);
0275 aLayerElement = static_cast<DOMElement *>(aNode);
0276
0277 unsigned int nItems = aLayerElement->getElementsByTagName(xmlRefLayer)->getLength();
0278 assert(nItems == (unsigned)aConfig.nRefLayers());
0279 GoldenPattern::vector1D meanDistPhi1D(nItems);
0280 for (unsigned int iItem = 0; iItem < nItems; ++iItem) {
0281 aNode = aLayerElement->getElementsByTagName(xmlRefLayer)->item(iItem);
0282 aItemElement = static_cast<DOMElement *>(aNode);
0283 val = std::atoi(_toString(aItemElement->getAttribute(xmlmeanDistPhi)).c_str());
0284 meanDistPhi1D[iItem] = val;
0285 }
0286 meanDistPhi2D[iLayer] = meanDistPhi1D;
0287
0288
0289 nItems = aLayerElement->getElementsByTagName(xmlPDF)->getLength();
0290 assert(nItems == aConfig.nRefLayers() * exp2(aConfig.nPdfAddrBits()));
0291 for (unsigned int iRefLayer = 0; iRefLayer < (unsigned)aConfig.nRefLayers(); ++iRefLayer) {
0292 pdf1D.assign(exp2(aConfig.nPdfAddrBits()), 0);
0293 for (unsigned int iPdf = 0; iPdf < exp2(aConfig.nPdfAddrBits()); ++iPdf) {
0294 aNode = aLayerElement->getElementsByTagName(xmlPDF)->item(iRefLayer * exp2(aConfig.nPdfAddrBits()) + iPdf);
0295 aItemElement = static_cast<DOMElement *>(aNode);
0296 val = std::atoi(_toString(aItemElement->getAttribute(xmlValue)).c_str());
0297 pdf1D[iPdf] = val;
0298 }
0299 pdf2D[iRefLayer] = pdf1D;
0300 }
0301 pdf3D[iLayer] = pdf2D;
0302 }
0303
0304 Key aKey(iEta, iPt, iCharge, aGPNumber);
0305 auto aGP = std::make_unique<GoldenPattern>(aKey, static_cast<const OMTFConfiguration *>(nullptr));
0306 aGP->setMeanDistPhi(meanDistPhi2D);
0307 aGP->setPdf(pdf3D);
0308
0309 XMLString::release(&xmliEta);
0310 XMLString::release(&xmliPt);
0311 XMLString::release(&xmliCharge);
0312 XMLString::release(&xmlLayer);
0313 XMLString::release(&xmlRefLayer);
0314 XMLString::release(&xmlmeanDistPhi);
0315 XMLString::release(&xmlPDF);
0316 XMLString::release(&xmlValue);
0317
0318 return aGP;
0319 }
0320
0321
0322 std::vector<std::vector<int>> XMLConfigReader::readEvent(unsigned int iEvent, unsigned int iProcessor, bool readEta) {
0323 return OMTFinput::vector2D();
0324 }
0325
0326
0327 void XMLConfigReader::readConfig(L1TMuonOverlapParams *aConfig) const {
0328 {
0329 XercesDOMParser parser;
0330 parser.setValidationScheme(XercesDOMParser::Val_Auto);
0331 parser.setDoNamespaces(false);
0332
0333 XMLCh *xmlOMTF = _toDOMS("OMTF");
0334 XMLCh *xmlversion = _toDOMS("version");
0335 XMLCh *xmlGlobalData = _toDOMS("GlobalData");
0336 XMLCh *xmlnPdfAddrBits = _toDOMS("nPdfAddrBits");
0337 XMLCh *xmlnPdfValBits = _toDOMS("nPdfValBits");
0338 XMLCh *xmlnPhiBits = _toDOMS("nPhiBits");
0339 XMLCh *xmlnPhiBins = _toDOMS("nPhiBins");
0340 XMLCh *xmlnProcessors = _toDOMS("nProcessors");
0341 XMLCh *xmlnLogicRegions = _toDOMS("nLogicRegions");
0342 XMLCh *xmlnInputs = _toDOMS("nInputs");
0343 XMLCh *xmlnLayers = _toDOMS("nLayers");
0344 XMLCh *xmlnRefLayers = _toDOMS("nRefLayers");
0345 XMLCh *xmliProcessor = _toDOMS("iProcessor");
0346 XMLCh *xmlbarrelMin = _toDOMS("barrelMin");
0347 XMLCh *xmlbarrelMax = _toDOMS("barrelMax");
0348 XMLCh *xmlendcap10DegMin = _toDOMS("endcap10DegMin");
0349 XMLCh *xmlendcap10DegMax = _toDOMS("endcap10DegMax");
0350 XMLCh *xmlendcap20DegMin = _toDOMS("endcap20DegMin");
0351 XMLCh *xmlendcap20DegMax = _toDOMS("endcap20DegMax");
0352 XMLCh *xmlLayerMap = _toDOMS("LayerMap");
0353 XMLCh *xmlhwNumber = _toDOMS("hwNumber");
0354 XMLCh *xmllogicNumber = _toDOMS("logicNumber");
0355 XMLCh *xmlbendingLayer = _toDOMS("bendingLayer");
0356 XMLCh *xmlconnectedToLayer = _toDOMS("connectedToLayer");
0357 XMLCh *xmlRefLayerMap = _toDOMS("RefLayerMap");
0358 XMLCh *xmlrefLayer = _toDOMS("refLayer");
0359 XMLCh *xmlProcessor = _toDOMS("Processor");
0360 XMLCh *xmlRefLayer = _toDOMS("RefLayer");
0361 XMLCh *xmliRefLayer = _toDOMS("iRefLayer");
0362 XMLCh *xmliGlobalPhiStart = _toDOMS("iGlobalPhiStart");
0363 XMLCh *xmlRefHit = _toDOMS("RefHit");
0364 XMLCh *xmliRefHit = _toDOMS("iRefHit");
0365 XMLCh *xmliPhiMin = _toDOMS("iPhiMin");
0366 XMLCh *xmliPhiMax = _toDOMS("iPhiMax");
0367 XMLCh *xmliInput = _toDOMS("iInput");
0368 XMLCh *xmliRegion = _toDOMS("iRegion");
0369 XMLCh *xmlLogicRegion = _toDOMS("LogicRegion");
0370 XMLCh *xmlLayer = _toDOMS("Layer");
0371 XMLCh *xmliLayer = _toDOMS("iLayer");
0372 XMLCh *xmliFirstInput = _toDOMS("iFirstInput");
0373 XMLCh *xmlnHitsPerLayer = _toDOMS("nHitsPerLayer");
0374 XMLCh *xmlnRefHits = _toDOMS("nRefHits");
0375 XMLCh *xmlnTestRefHits = _toDOMS("nTestRefHits");
0376 XMLCh *xmlnGoldenPatterns = _toDOMS("nGoldenPatterns");
0377 XMLCh *xmlConnectionMap = _toDOMS("ConnectionMap");
0378 parser.parse(configFile.c_str());
0379 xercesc::DOMDocument *doc = parser.getDocument();
0380 assert(doc);
0381 unsigned int nElem = doc->getElementsByTagName(xmlOMTF)->getLength();
0382 if (nElem != 1) {
0383 edm::LogError("critical") << "Problem parsing XML file " << configFile << std::endl;
0384 assert(nElem == 1);
0385 }
0386 DOMNode *aNode = doc->getElementsByTagName(xmlOMTF)->item(0);
0387 DOMElement *aOMTFElement = static_cast<DOMElement *>(aNode);
0388
0389 unsigned int version = std::stoul(_toString(aOMTFElement->getAttribute(xmlversion)), nullptr, 16);
0390 aConfig->setFwVersion(version);
0391
0392
0393 nElem = aOMTFElement->getElementsByTagName(xmlGlobalData)->getLength();
0394 assert(nElem == 1);
0395 aNode = aOMTFElement->getElementsByTagName(xmlGlobalData)->item(0);
0396 DOMElement *aElement = static_cast<DOMElement *>(aNode);
0397
0398 unsigned int nPdfAddrBits = std::atoi(_toString(aElement->getAttribute(xmlnPdfAddrBits)).c_str());
0399 unsigned int nPdfValBits = std::atoi(_toString(aElement->getAttribute(xmlnPdfValBits)).c_str());
0400 unsigned int nHitsPerLayer = std::atoi(_toString(aElement->getAttribute(xmlnHitsPerLayer)).c_str());
0401 unsigned int nPhiBits = std::atoi(_toString(aElement->getAttribute(xmlnPhiBits)).c_str());
0402 unsigned int nPhiBins = std::atoi(_toString(aElement->getAttribute(xmlnPhiBins)).c_str());
0403
0404 unsigned int nRefHits = std::atoi(_toString(aElement->getAttribute(xmlnRefHits)).c_str());
0405 unsigned int nTestRefHits = std::atoi(_toString(aElement->getAttribute(xmlnTestRefHits)).c_str());
0406 unsigned int nProcessors = std::atoi(_toString(aElement->getAttribute(xmlnProcessors)).c_str());
0407 unsigned int nLogicRegions = std::atoi(_toString(aElement->getAttribute(xmlnLogicRegions)).c_str());
0408 unsigned int nInputs = std::atoi(_toString(aElement->getAttribute(xmlnInputs)).c_str());
0409 unsigned int nLayers = std::atoi(_toString(aElement->getAttribute(xmlnLayers)).c_str());
0410 unsigned int nRefLayers = std::atoi(_toString(aElement->getAttribute(xmlnRefLayers)).c_str());
0411 unsigned int nGoldenPatterns = std::atoi(_toString(aElement->getAttribute(xmlnGoldenPatterns)).c_str());
0412
0413 std::vector<int> paramsVec(L1TMuonOverlapParams::GENERAL_NCONFIG);
0414 paramsVec[L1TMuonOverlapParams::GENERAL_ADDRBITS] = nPdfAddrBits;
0415 paramsVec[L1TMuonOverlapParams::GENERAL_VALBITS] = nPdfValBits;
0416 paramsVec[L1TMuonOverlapParams::GENERAL_HITSPERLAYER] = nHitsPerLayer;
0417 paramsVec[L1TMuonOverlapParams::GENERAL_PHIBITS] = nPhiBits;
0418 paramsVec[L1TMuonOverlapParams::GENERAL_PHIBINS] = nPhiBins;
0419 paramsVec[L1TMuonOverlapParams::GENERAL_NREFHITS] = nRefHits;
0420 paramsVec[L1TMuonOverlapParams::GENERAL_NTESTREFHITS] = nTestRefHits;
0421 paramsVec[L1TMuonOverlapParams::GENERAL_NPROCESSORS] = nProcessors;
0422 paramsVec[L1TMuonOverlapParams::GENERAL_NLOGIC_REGIONS] = nLogicRegions;
0423 paramsVec[L1TMuonOverlapParams::GENERAL_NINPUTS] = nInputs;
0424 paramsVec[L1TMuonOverlapParams::GENERAL_NLAYERS] = nLayers;
0425 paramsVec[L1TMuonOverlapParams::GENERAL_NREFLAYERS] = nRefLayers;
0426 paramsVec[L1TMuonOverlapParams::GENERAL_NGOLDENPATTERNS] = nGoldenPatterns;
0427 aConfig->setGeneralParams(paramsVec);
0428
0429
0430
0431 std::vector<int> sectorsStart(3 * nProcessors), sectorsEnd(3 * nProcessors);
0432 nElem = aOMTFElement->getElementsByTagName(xmlConnectionMap)->getLength();
0433 DOMElement *aConnectionElement = nullptr;
0434 for (unsigned int i = 0; i < nElem; ++i) {
0435 aNode = aOMTFElement->getElementsByTagName(xmlConnectionMap)->item(i);
0436 aConnectionElement = static_cast<DOMElement *>(aNode);
0437 unsigned int iProcessor = std::atoi(_toString(aConnectionElement->getAttribute(xmliProcessor)).c_str());
0438 unsigned int barrelMin = std::atoi(_toString(aConnectionElement->getAttribute(xmlbarrelMin)).c_str());
0439 unsigned int barrelMax = std::atoi(_toString(aConnectionElement->getAttribute(xmlbarrelMax)).c_str());
0440 unsigned int endcap10DegMin = std::atoi(_toString(aConnectionElement->getAttribute(xmlendcap10DegMin)).c_str());
0441 unsigned int endcap10DegMax = std::atoi(_toString(aConnectionElement->getAttribute(xmlendcap10DegMax)).c_str());
0442 unsigned int endcap20DegMin = std::atoi(_toString(aConnectionElement->getAttribute(xmlendcap20DegMin)).c_str());
0443 unsigned int endcap20DegMax = std::atoi(_toString(aConnectionElement->getAttribute(xmlendcap20DegMax)).c_str());
0444
0445 sectorsStart[iProcessor] = barrelMin;
0446 sectorsStart[iProcessor + nProcessors] = endcap10DegMin;
0447 sectorsStart[iProcessor + 2 * nProcessors] = endcap20DegMin;
0448
0449 sectorsEnd[iProcessor] = barrelMax;
0450 sectorsEnd[iProcessor + nProcessors] = endcap10DegMax;
0451 sectorsEnd[iProcessor + 2 * nProcessors] = endcap20DegMax;
0452 }
0453 aConfig->setConnectedSectorsStart(sectorsStart);
0454 aConfig->setConnectedSectorsEnd(sectorsEnd);
0455
0456
0457 std::vector<L1TMuonOverlapParams::LayerMapNode> aLayerMapVec;
0458 L1TMuonOverlapParams::LayerMapNode aLayerMapNode;
0459
0460 nElem = aOMTFElement->getElementsByTagName(xmlLayerMap)->getLength();
0461 DOMElement *aLayerElement = nullptr;
0462 for (unsigned int i = 0; i < nElem; ++i) {
0463 aNode = aOMTFElement->getElementsByTagName(xmlLayerMap)->item(i);
0464 aLayerElement = static_cast<DOMElement *>(aNode);
0465 unsigned int hwNumber = std::atoi(_toString(aLayerElement->getAttribute(xmlhwNumber)).c_str());
0466 unsigned int logicNumber = std::atoi(_toString(aLayerElement->getAttribute(xmllogicNumber)).c_str());
0467 unsigned int isBendingLayer = std::atoi(_toString(aLayerElement->getAttribute(xmlbendingLayer)).c_str());
0468 unsigned int iConnectedLayer = std::atoi(_toString(aLayerElement->getAttribute(xmlconnectedToLayer)).c_str());
0469 aLayerMapNode.logicNumber = logicNumber;
0470 aLayerMapNode.hwNumber = hwNumber;
0471 aLayerMapNode.connectedToLayer = iConnectedLayer;
0472 aLayerMapNode.bendingLayer = isBendingLayer;
0473 aLayerMapVec.push_back(aLayerMapNode);
0474 }
0475 aConfig->setLayerMap(aLayerMapVec);
0476
0477
0478 std::vector<L1TMuonOverlapParams::RefLayerMapNode> aRefLayerMapVec;
0479 L1TMuonOverlapParams::RefLayerMapNode aRefLayerNode;
0480
0481 nElem = aOMTFElement->getElementsByTagName(xmlRefLayerMap)->getLength();
0482 DOMElement *aRefLayerElement = nullptr;
0483 for (unsigned int i = 0; i < nElem; ++i) {
0484 aNode = aOMTFElement->getElementsByTagName(xmlRefLayerMap)->item(i);
0485 aRefLayerElement = static_cast<DOMElement *>(aNode);
0486 unsigned int refLayer = std::atoi(_toString(aRefLayerElement->getAttribute(xmlrefLayer)).c_str());
0487 unsigned int logicNumber = std::atoi(_toString(aRefLayerElement->getAttribute(xmllogicNumber)).c_str());
0488 aRefLayerNode.refLayer = refLayer;
0489 aRefLayerNode.logicNumber = logicNumber;
0490 aRefLayerMapVec.push_back(aRefLayerNode);
0491 }
0492 aConfig->setRefLayerMap(aRefLayerMapVec);
0493
0494 std::vector<int> aGlobalPhiStartVec(nProcessors * nRefLayers);
0495
0496 std::vector<L1TMuonOverlapParams::RefHitNode> aRefHitMapVec(nProcessors * nRefHits);
0497 L1TMuonOverlapParams::RefHitNode aRefHitNode;
0498
0499 std::vector<L1TMuonOverlapParams::LayerInputNode> aLayerInputMapVec(nProcessors * nLogicRegions * nLayers);
0500 L1TMuonOverlapParams::LayerInputNode aLayerInputNode;
0501
0502 nElem = aOMTFElement->getElementsByTagName(xmlProcessor)->getLength();
0503 assert(nElem == nProcessors);
0504 DOMElement *aProcessorElement = nullptr;
0505 for (unsigned int i = 0; i < nElem; ++i) {
0506 aNode = aOMTFElement->getElementsByTagName(xmlProcessor)->item(i);
0507 aProcessorElement = static_cast<DOMElement *>(aNode);
0508 unsigned int iProcessor = std::atoi(_toString(aProcessorElement->getAttribute(xmliProcessor)).c_str());
0509 unsigned int nElem1 = aProcessorElement->getElementsByTagName(xmlRefLayer)->getLength();
0510 assert(nElem1 == nRefLayers);
0511 DOMElement *aRefLayerElement = nullptr;
0512 for (unsigned int ii = 0; ii < nElem1; ++ii) {
0513 aNode = aProcessorElement->getElementsByTagName(xmlRefLayer)->item(ii);
0514 aRefLayerElement = static_cast<DOMElement *>(aNode);
0515 unsigned int iRefLayer = std::atoi(_toString(aRefLayerElement->getAttribute(xmliRefLayer)).c_str());
0516 int iPhi = std::atoi(_toString(aRefLayerElement->getAttribute(xmliGlobalPhiStart)).c_str());
0517 aGlobalPhiStartVec[iRefLayer + iProcessor * nRefLayers] = iPhi;
0518 }
0519
0520 nElem1 = aProcessorElement->getElementsByTagName(xmlRefHit)->getLength();
0521 assert((iProcessor == 0 && nElem1 == nRefHits) || (iProcessor != 0 && nElem1 == 0));
0522 DOMElement *aRefHitElement = nullptr;
0523 for (unsigned int ii = 0; ii < nElem1; ++ii) {
0524 aNode = aProcessorElement->getElementsByTagName(xmlRefHit)->item(ii);
0525 aRefHitElement = static_cast<DOMElement *>(aNode);
0526 unsigned int iRefHit = std::atoi(_toString(aRefHitElement->getAttribute(xmliRefHit)).c_str());
0527 int iPhiMin = std::atoi(_toString(aRefHitElement->getAttribute(xmliPhiMin)).c_str());
0528 int iPhiMax = std::atoi(_toString(aRefHitElement->getAttribute(xmliPhiMax)).c_str());
0529 unsigned int iInput = std::atoi(_toString(aRefHitElement->getAttribute(xmliInput)).c_str());
0530 unsigned int iRegion = std::atoi(_toString(aRefHitElement->getAttribute(xmliRegion)).c_str());
0531 unsigned int iRefLayer = std::atoi(_toString(aRefHitElement->getAttribute(xmliRefLayer)).c_str());
0532
0533 aRefHitNode.iRefHit = iRefHit;
0534 aRefHitNode.iPhiMin = iPhiMin;
0535 aRefHitNode.iPhiMax = iPhiMax;
0536 aRefHitNode.iInput = iInput;
0537 aRefHitNode.iRegion = iRegion;
0538 aRefHitNode.iRefLayer = iRefLayer;
0539 for (unsigned int iProcessor = 0; iProcessor < nProcessors; iProcessor++)
0540 aRefHitMapVec[iRefHit + iProcessor * nRefHits] = aRefHitNode;
0541 }
0542
0543 unsigned int nElem2 = aProcessorElement->getElementsByTagName(xmlLogicRegion)->getLength();
0544 assert((iProcessor == 0 && nElem2 == nLogicRegions) || (iProcessor != 0 && nElem2 == 0));
0545 DOMElement *aRegionElement = nullptr;
0546 for (unsigned int ii = 0; ii < nElem2; ++ii) {
0547 aNode = aProcessorElement->getElementsByTagName(xmlLogicRegion)->item(ii);
0548 aRegionElement = static_cast<DOMElement *>(aNode);
0549 unsigned int iRegion = std::atoi(_toString(aRegionElement->getAttribute(xmliRegion)).c_str());
0550 unsigned int nElem3 = aRegionElement->getElementsByTagName(xmlLayer)->getLength();
0551 assert(nElem3 == nLayers);
0552 DOMElement *aLayerElement = nullptr;
0553 for (unsigned int iii = 0; iii < nElem3; ++iii) {
0554 aNode = aRegionElement->getElementsByTagName(xmlLayer)->item(iii);
0555 aLayerElement = static_cast<DOMElement *>(aNode);
0556 unsigned int iLayer = std::atoi(_toString(aLayerElement->getAttribute(xmliLayer)).c_str());
0557 unsigned int iFirstInput = std::atoi(_toString(aLayerElement->getAttribute(xmliFirstInput)).c_str());
0558 unsigned int nInputs = std::atoi(_toString(aLayerElement->getAttribute(xmlnInputs)).c_str());
0559 aLayerInputNode.iLayer = iLayer;
0560 aLayerInputNode.iFirstInput = iFirstInput;
0561 aLayerInputNode.nInputs = nInputs;
0562 for (unsigned int iProcessor = 0; iProcessor < nProcessors; ++iProcessor)
0563 aLayerInputMapVec[iLayer + iRegion * nLayers + iProcessor * nLayers * nLogicRegions] = aLayerInputNode;
0564 }
0565 }
0566 }
0567
0568 aConfig->setGlobalPhiStartMap(aGlobalPhiStartVec);
0569 aConfig->setLayerInputMap(aLayerInputMapVec);
0570 aConfig->setRefHitMap(aRefHitMapVec);
0571
0572
0573 parser.resetDocumentPool();
0574
0575 XMLString::release(&xmlOMTF);
0576 XMLString::release(&xmlversion);
0577 XMLString::release(&xmlGlobalData);
0578 XMLString::release(&xmlnPdfAddrBits);
0579 XMLString::release(&xmlnPdfValBits);
0580 XMLString::release(&xmlnPhiBits);
0581 XMLString::release(&xmlnPhiBins);
0582 XMLString::release(&xmlnProcessors);
0583 XMLString::release(&xmlnLogicRegions);
0584 XMLString::release(&xmlnInputs);
0585 XMLString::release(&xmlnLayers);
0586 XMLString::release(&xmlnRefLayers);
0587 XMLString::release(&xmliProcessor);
0588 XMLString::release(&xmlbarrelMin);
0589 XMLString::release(&xmlbarrelMax);
0590 XMLString::release(&xmlendcap10DegMin);
0591 XMLString::release(&xmlendcap10DegMax);
0592 XMLString::release(&xmlendcap20DegMin);
0593 XMLString::release(&xmlendcap20DegMax);
0594 XMLString::release(&xmlLayerMap);
0595 XMLString::release(&xmlhwNumber);
0596 XMLString::release(&xmllogicNumber);
0597 XMLString::release(&xmlbendingLayer);
0598 XMLString::release(&xmlconnectedToLayer);
0599 XMLString::release(&xmlRefLayerMap);
0600 XMLString::release(&xmlrefLayer);
0601 XMLString::release(&xmlProcessor);
0602 XMLString::release(&xmlRefLayer);
0603 XMLString::release(&xmliRefLayer);
0604 XMLString::release(&xmliGlobalPhiStart);
0605 XMLString::release(&xmlRefHit);
0606 XMLString::release(&xmliRefHit);
0607 XMLString::release(&xmliPhiMin);
0608 XMLString::release(&xmliPhiMax);
0609 XMLString::release(&xmliInput);
0610 XMLString::release(&xmliRegion);
0611 XMLString::release(&xmlLogicRegion);
0612 XMLString::release(&xmlLayer);
0613 XMLString::release(&xmliLayer);
0614 XMLString::release(&xmliFirstInput);
0615 XMLString::release(&xmlnHitsPerLayer);
0616 XMLString::release(&xmlnRefHits);
0617 XMLString::release(&xmlnTestRefHits);
0618 XMLString::release(&xmlnGoldenPatterns);
0619 XMLString::release(&xmlConnectionMap);
0620 }
0621 }
0622
0623
0624
0625
0626