Back to home page

Project CMSSW displayed by LXR
 
 

    

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 // XMLConfigReader
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   //  delete parser;
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   ///Fill payload string
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;  //Number of bits used to address LUT
0064     int outWidth = 6;      //Number of bits used to store LUT value
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     ///Prepare the header
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     ///Read the data into LUT
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         ///Patterns XML format backward compatibility. Can use both packed by 4, or by 1 XML files.
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     // Reset the documents vector pool and release all the associated memory back to the system.
0205     //parser->resetDocumentPool();
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   //index 0 means no number at the end
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) {  ///Build empty GP
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   ///Loop over layers
0273   for (unsigned int iLayer = 0; iLayer < nLayers; ++iLayer) {
0274     aNode = aGPElement->getElementsByTagName(xmlLayer)->item(iLayer);
0275     aLayerElement = static_cast<DOMElement *>(aNode);
0276     ///MeanDistPhi vector
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     ///PDF vector
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     ///Addresing bits numbers
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     ///Chamber sectors connections to logic processros.
0430     ///Start/End values for all processors, and chamber types are put into a single vector
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     ///hw <-> logic numbering map
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     ///ref<->logic numberig map
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     // Reset the documents vector pool and release all the associated memory back to the system.
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 //  xercesc::XercesDOMParser *parser;
0626 //  xercesc::DOMDocument* doc;
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!