Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-05-27 01:56:23 

0001 #include "FWCore/Framework/interface/Event.h"
0002 
0003 #include "L1Trigger/L1TMuonOverlap/interface/XMLConfigWriter.h"
0004 #include "L1Trigger/L1TMuonOverlap/interface/GoldenPattern.h"
0005 #include "L1Trigger/L1TMuonOverlap/interface/OMTFinput.h"
0006 #include "L1Trigger/L1TMuonOverlap/interface/OMTFConfiguration.h"
0007 #include "L1Trigger/L1TMuonOverlap/interface/OMTFResult.h"
0008 
0009 #include "L1Trigger/L1TMuonOverlap/interface/AlgoMuon.h"
0010 #include "DataFormats/L1TMuon/interface/RegionalMuonCand.h"
0011 
0012 #include "Utilities/Xerces/interface/Xerces.h"
0013 
0014 #include <iostream>
0015 #include <sstream>
0016 #include <cmath>
0017 #include <ctime>
0018 #include <iomanip>
0019 #include <bitset>
0020 
0021 #include "xercesc/framework/StdOutFormatTarget.hpp"
0022 #include "xercesc/framework/LocalFileFormatTarget.hpp"
0023 #include "xercesc/parsers/XercesDOMParser.hpp"
0024 #include "xercesc/dom/DOM.hpp"
0025 #include "xercesc/dom/DOMException.hpp"
0026 #include "xercesc/dom/DOMImplementation.hpp"
0027 #include "xercesc/sax/HandlerBase.hpp"
0028 #include "xercesc/util/XMLString.hpp"
0029 #include "xercesc/util/PlatformUtils.hpp"
0030 #include "xercesc/util/XercesDefs.hpp"
0031 #include "xercesc/util/XercesVersion.hpp"
0032 XERCES_CPP_NAMESPACE_USE
0033 
0034 #if _XERCES_VERSION < 30100
0035 #include "xercesc/dom/DOMWriter.hpp"
0036 #else
0037 #include "xercesc/dom/DOMLSSerializer.hpp"
0038 #include "xercesc/dom/DOMLSOutput.hpp"
0039 #endif
0040 //
0041 
0042 namespace {
0043   unsigned int eta2Bits(unsigned int eta) {
0044     if (eta == 73)
0045       return 0b100000000;
0046     else if (eta == 78)
0047       return 0b010000000;
0048     else if (eta == 85)
0049       return 0b001000000;
0050     else if (eta == 90)
0051       return 0b000100000;
0052     else if (eta == 94)
0053       return 0b000010000;
0054     else if (eta == 99)
0055       return 0b000001000;
0056     else if (eta == 103)
0057       return 0b000000100;
0058     else if (eta == 110)
0059       return 0b000000010;
0060     else if (eta == 75)
0061       return 0b110000000;
0062     else if (eta == 79)
0063       return 0b011000000;
0064     else if (eta == 92)
0065       return 0b000110000;
0066     else if (eta == 115)
0067       return 0b000000001;
0068     else if (eta == 121)
0069       return 0b000000000;
0070     else
0071       return 0b111111111;
0072     ;
0073   }
0074 }  // namespace
0075 
0076 //////////////////////////////////
0077 // XMLConfigWriter
0078 //////////////////////////////////
0079 inline std::string _toString(XMLCh const* toTranscode) {
0080   std::string tmp(xercesc::XMLString::transcode(toTranscode));
0081   return tmp;
0082 }
0083 
0084 inline XMLCh* _toDOMS(std::string temp) {
0085   XMLCh* buff = XMLString::transcode(temp.c_str());
0086   return buff;
0087 }
0088 ////////////////////////////////////
0089 ////////////////////////////////////
0090 XMLConfigWriter::XMLConfigWriter(const OMTFConfiguration* aOMTFConfig) {
0091   cms::concurrency::xercesInitialize();
0092 
0093   ///Initialise XML document
0094   domImpl = DOMImplementationRegistry::getDOMImplementation(_toDOMS("Range"));
0095 
0096   myOMTFConfig = aOMTFConfig;
0097 }
0098 ////////////////////////////////////
0099 ////////////////////////////////////
0100 XMLConfigWriter::~XMLConfigWriter() { cms::concurrency::xercesTerminate(); }
0101 //////////////////////////////////////////////////
0102 //////////////////////////////////////////////////
0103 void XMLConfigWriter::initialiseXMLDocument(const std::string& docName) {
0104   theDoc = domImpl->createDocument(nullptr, _toDOMS(docName), nullptr);
0105   theTopElement = theDoc->getDocumentElement();
0106 
0107   unsigned int version = myOMTFConfig->patternsVersion();
0108   unsigned int mask16bits = 0xFFFF;
0109 
0110   version &= mask16bits;
0111 
0112   std::ostringstream stringStr;
0113   stringStr.str("");
0114   stringStr << "0x" << std::hex << std::setfill('0') << std::setw(4) << version;
0115   theTopElement->setAttribute(_toDOMS("version"), _toDOMS(stringStr.str()));
0116 }
0117 //////////////////////////////////////////////////
0118 //////////////////////////////////////////////////
0119 void XMLConfigWriter::finaliseXMLDocument(const std::string& fName) {
0120   XMLFormatTarget* formTarget = new LocalFileFormatTarget(fName.c_str());
0121 
0122 #if _XERCES_VERSION < 30100
0123   xercesc::DOMWriter* domWriter = (dynamic_cast<DOMImplementation*>(domImpl))->createDOMWriter();
0124   if (domWriter->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) {
0125     domWriter->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);
0126   }
0127   domWriter->writeNode(formTarget, *theTopElement);
0128 
0129 #else
0130   xercesc::DOMLSSerializer* theSerializer = (dynamic_cast<DOMImplementation*>(domImpl))->createLSSerializer();
0131   if (theSerializer->getDomConfig()->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true))
0132     theSerializer->getDomConfig()->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true);
0133   DOMLSOutput* theOutput = (dynamic_cast<DOMImplementation*>(domImpl))->createLSOutput();
0134   theOutput->setByteStream(formTarget);
0135   theSerializer->write(theTopElement, theOutput);
0136   theOutput->release();
0137   theSerializer->release();
0138 #endif
0139 
0140   delete formTarget;
0141 }
0142 //////////////////////////////////////////////////
0143 //////////////////////////////////////////////////
0144 xercesc::DOMElement* XMLConfigWriter::writeEventHeader(unsigned int eventId, unsigned int mixedEventId) {
0145   unsigned int eventBx = eventId * 2;
0146 
0147   xercesc::DOMElement* aEvent = nullptr;
0148   xercesc::DOMElement* aBx = nullptr;
0149   std::ostringstream stringStr;
0150 
0151   aEvent = theDoc->createElement(_toDOMS("Event"));
0152 
0153   stringStr.str("");
0154   stringStr << eventId;
0155   aEvent->setAttribute(_toDOMS("iEvent"), _toDOMS(stringStr.str()));
0156 
0157   stringStr.str("");
0158   stringStr << mixedEventId;
0159   aEvent->setAttribute(_toDOMS("iMixedEvent"), _toDOMS(stringStr.str()));
0160 
0161   aBx = theDoc->createElement(_toDOMS("bx"));
0162   stringStr.str("");
0163   stringStr << eventBx;
0164   aBx->setAttribute(_toDOMS("iBx"), _toDOMS(stringStr.str()));
0165   aEvent->appendChild(aBx);
0166 
0167   theTopElement->appendChild(aEvent);
0168 
0169   return aBx;
0170 }
0171 //////////////////////////////////////////////////
0172 //////////////////////////////////////////////////
0173 xercesc::DOMElement* XMLConfigWriter::writeEventData(xercesc::DOMElement* aTopElement,
0174                                                      const OmtfName& board,
0175                                                      const OMTFinput& aInput) {
0176   std::ostringstream stringStr;
0177 
0178   xercesc::DOMElement* aProcessor = theDoc->createElement(_toDOMS("Processor"));
0179   aProcessor->setAttribute(_toDOMS("board"), _toDOMS(board.name()));
0180 
0181   unsigned int iProcessor = board.processor();
0182   stringStr.str("");
0183   stringStr << iProcessor;
0184   aProcessor->setAttribute(_toDOMS("iProcessor"), _toDOMS(stringStr.str()));
0185   stringStr.str("");
0186   if (board.position() == 1)
0187     stringStr << "+";
0188   stringStr << board.position();
0189   aProcessor->setAttribute(_toDOMS("position"), _toDOMS(stringStr.str()));
0190 
0191   xercesc::DOMElement *aLayer, *aHit;
0192   for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
0193     const OMTFinput::vector1D& layerDataPhi = aInput.getLayerData(iLayer);
0194     const OMTFinput::vector1D& layerDataEta = aInput.getLayerData(iLayer, true);
0195 
0196     aLayer = theDoc->createElement(_toDOMS("Layer"));
0197     stringStr.str("");
0198     stringStr << iLayer;
0199     aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0200     for (unsigned int iHit = 0; iHit < layerDataPhi.size(); ++iHit) {
0201       aHit = theDoc->createElement(_toDOMS("Hit"));
0202       stringStr.str("");
0203       stringStr << iHit;
0204       aHit->setAttribute(_toDOMS("iInput"), _toDOMS(stringStr.str()));
0205       stringStr.str("");
0206       stringStr << layerDataPhi[iHit];
0207       aHit->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
0208       stringStr.str("");
0209       stringStr << eta2Bits(abs(layerDataEta[iHit]));
0210       aHit->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
0211       if (layerDataPhi[iHit] >= (int)myOMTFConfig->nPhiBins())
0212         continue;
0213       aLayer->appendChild(aHit);
0214     }
0215     if (aLayer->getChildNodes()->getLength())
0216       aProcessor->appendChild(aLayer);
0217   }
0218 
0219   aTopElement->appendChild(aProcessor);
0220   return aProcessor;
0221 }
0222 //////////////////////////////////////////////////
0223 //////////////////////////////////////////////////
0224 void XMLConfigWriter::writeAlgoMuon(xercesc::DOMElement* aTopElement, unsigned int iRefHit, const AlgoMuon& aCand) {
0225   xercesc::DOMElement* aResult = theDoc->createElement(_toDOMS("AlgoMuon"));
0226   std::ostringstream stringStr;
0227   stringStr.str("");
0228   stringStr << iRefHit;
0229   aResult->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
0230   stringStr.str("");
0231   stringStr << aCand.getPt();
0232   aResult->setAttribute(_toDOMS("ptCode"), _toDOMS(stringStr.str()));
0233   stringStr.str("");
0234   stringStr << aCand.getPhi();
0235   aResult->setAttribute(_toDOMS("phiCode"), _toDOMS(stringStr.str()));
0236   stringStr.str("");
0237   stringStr << eta2Bits(abs(aCand.getEta()));
0238   aResult->setAttribute(_toDOMS("etaCode"), _toDOMS(stringStr.str()));
0239   stringStr.str("");
0240   stringStr << aCand.getCharge();
0241   aResult->setAttribute(_toDOMS("charge"), _toDOMS(stringStr.str()));
0242   stringStr.str("");
0243   stringStr << aCand.getQ();
0244   aResult->setAttribute(_toDOMS("nHits"), _toDOMS(stringStr.str()));
0245   stringStr.str("");
0246   stringStr << aCand.getDisc();
0247   aResult->setAttribute(_toDOMS("disc"), _toDOMS(stringStr.str()));
0248   stringStr.str("");
0249   stringStr << aCand.getRefLayer();
0250   aResult->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0251   stringStr.str("");
0252   stringStr << std::bitset<18>(aCand.getHits());
0253   aResult->setAttribute(_toDOMS("layers"), _toDOMS(stringStr.str()));
0254   stringStr.str("");
0255   stringStr << aCand.getPhiRHit();
0256   aResult->setAttribute(_toDOMS("phiRHit"), _toDOMS(stringStr.str()));
0257   stringStr.str("");
0258   stringStr << aCand.getPatternNumber();
0259   aResult->setAttribute(_toDOMS("patNum"), _toDOMS(stringStr.str()));
0260 
0261   aTopElement->appendChild(aResult);
0262 }
0263 //////////////////////////////////////////////////
0264 //////////////////////////////////////////////////
0265 void XMLConfigWriter::writeCandMuon(xercesc::DOMElement* aTopElement, const l1t::RegionalMuonCand& aCand) {
0266   xercesc::DOMElement* aResult = theDoc->createElement(_toDOMS("CandMuon"));
0267   std::ostringstream stringStr;
0268   stringStr.str("");
0269   stringStr << aCand.hwPt();
0270   aResult->setAttribute(_toDOMS("hwPt"), _toDOMS(stringStr.str()));
0271   stringStr.str("");
0272   stringStr << aCand.hwPhi();
0273   aResult->setAttribute(_toDOMS("hwPhi"), _toDOMS(stringStr.str()));
0274   stringStr.str("");
0275   stringStr << aCand.hwEta();
0276   aResult->setAttribute(_toDOMS("hwEta"), _toDOMS(stringStr.str()));
0277   stringStr.str("");
0278   stringStr << aCand.hwSign();
0279   aResult->setAttribute(_toDOMS("hwSign"), _toDOMS(stringStr.str()));
0280   stringStr.str("");
0281   stringStr << aCand.hwSignValid();
0282   aResult->setAttribute(_toDOMS("hwSignValid"), _toDOMS(stringStr.str()));
0283   stringStr.str("");
0284   stringStr << aCand.hwQual();
0285   aResult->setAttribute(_toDOMS("hwQual"), _toDOMS(stringStr.str()));
0286   stringStr.str("");
0287   std::map<int, int> hwAddrMap = aCand.trackAddress();
0288   stringStr << std::bitset<29>(hwAddrMap[0]);
0289   aResult->setAttribute(_toDOMS("hwTrackAddress"), _toDOMS(stringStr.str()));
0290   stringStr.str("");
0291   stringStr << aCand.link();
0292   aResult->setAttribute(_toDOMS("link"), _toDOMS(stringStr.str()));
0293   stringStr.str("");
0294   stringStr << aCand.processor();
0295   aResult->setAttribute(_toDOMS("processor"), _toDOMS(stringStr.str()));
0296   stringStr.str("");
0297   if (aCand.trackFinderType() == l1t::omtf_neg)
0298     stringStr << "OMTF_NEG";
0299   else if (aCand.trackFinderType() == l1t::omtf_pos)
0300     stringStr << "OMTF_POS";
0301   else
0302     stringStr << aCand.trackFinderType();
0303   aResult->setAttribute(_toDOMS("trackFinderType"), _toDOMS(stringStr.str()));
0304   aTopElement->appendChild(aResult);
0305 }
0306 //////////////////////////////////////////////////
0307 //////////////////////////////////////////////////
0308 //////////////////////////////////////////////////
0309 //////////////////////////////////////////////////
0310 void XMLConfigWriter::writeResultsData(xercesc::DOMElement* aTopElement,
0311                                        unsigned int iRegion,
0312                                        const Key& aKey,
0313                                        const OMTFResult& aResult) {
0314   OMTFResult::vector2D results = aResult.getResults();
0315 
0316   std::ostringstream stringStr;
0317   ///Write GP key parameters
0318   xercesc::DOMElement* aGP = theDoc->createElement(_toDOMS("GP"));
0319   stringStr.str("");
0320   stringStr << aKey.thePtCode;
0321   aGP->setAttribute(_toDOMS("iPt"), _toDOMS(stringStr.str()));
0322   stringStr.str("");
0323   stringStr << aKey.theEtaCode;
0324   aGP->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
0325   stringStr.str("");
0326   stringStr << "0";
0327   aGP->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
0328   stringStr.str("");
0329   stringStr << aKey.theCharge;
0330   aGP->setAttribute(_toDOMS("iCharge"), _toDOMS(stringStr.str()));
0331   /////////////////
0332   ///Write results details for this GP
0333   for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0334     xercesc::DOMElement* aRefLayer = theDoc->createElement(_toDOMS("Result"));
0335     stringStr.str("");
0336     stringStr << iRefLayer;
0337     aRefLayer->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0338     stringStr.str("");
0339     stringStr << iRegion;
0340     aRefLayer->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
0341     stringStr.str("");
0342     stringStr << myOMTFConfig->getRefToLogicNumber()[iRefLayer];
0343     aRefLayer->setAttribute(_toDOMS("iLogicLayer"), _toDOMS(stringStr.str()));
0344     for (unsigned int iLogicLayer = 0; iLogicLayer < myOMTFConfig->nLayers(); ++iLogicLayer) {
0345       xercesc::DOMElement* aLayer = theDoc->createElement(_toDOMS("Layer"));
0346       stringStr.str("");
0347       stringStr << iLogicLayer;
0348       aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0349       stringStr.str("");
0350       stringStr << results[iLogicLayer][iRefLayer];
0351       aLayer->setAttribute(_toDOMS("value"), _toDOMS(stringStr.str()));
0352       if (results[iLogicLayer][iRefLayer])
0353         aRefLayer->appendChild(aLayer);
0354     }
0355     if (aRefLayer->getChildNodes()->getLength())
0356       aGP->appendChild(aRefLayer);
0357   }
0358   if (aGP->getChildNodes()->getLength())
0359     aTopElement->appendChild(aGP);
0360 }
0361 //////////////////////////////////////////////////
0362 //////////////////////////////////////////////////
0363 void XMLConfigWriter::writeGPData(const GoldenPattern& aGP) {
0364   std::ostringstream stringStr;
0365   xercesc::DOMElement *aLayer = nullptr, *aRefLayer = nullptr, *aPdf = nullptr;
0366 
0367   xercesc::DOMElement* aGPElement = theDoc->createElement(_toDOMS("GP"));
0368   stringStr.str("");
0369   stringStr << aGP.key().thePtCode;
0370   aGPElement->setAttribute(_toDOMS("iPt"), _toDOMS(stringStr.str()));
0371   stringStr.str("");
0372   //stringStr<<aGP.key().theEtaCode;
0373   stringStr << "0";  //No eta code at the moment
0374   aGPElement->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
0375   stringStr.str("");
0376   stringStr << 0;  //No phi code is assigned to GP for the moment.
0377   aGPElement->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
0378   stringStr.str("");
0379   stringStr << aGP.key().theCharge;
0380   aGPElement->setAttribute(_toDOMS("iCharge"), _toDOMS(stringStr.str()));
0381 
0382   for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
0383     int nOfPhis = 0;
0384     /////////////////////////////////////
0385     aLayer = theDoc->createElement(_toDOMS("Layer"));
0386     stringStr.str("");
0387     stringStr << iLayer;
0388     //////////////////////////////////
0389     aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0390     stringStr.str("");
0391     stringStr << nOfPhis;
0392     aLayer->setAttribute(_toDOMS("nOfPhis"), _toDOMS(stringStr.str()));
0393     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0394       aRefLayer = theDoc->createElement(_toDOMS("RefLayer"));
0395       int meanDistPhi = aGP.meanDistPhiValue(iLayer, iRefLayer);
0396       stringStr.str("");
0397       stringStr << meanDistPhi;
0398       aRefLayer->setAttribute(_toDOMS("meanDistPhi"), _toDOMS(stringStr.str()));
0399       int selDistPhi = 0;
0400       stringStr.str("");
0401       stringStr << selDistPhi;
0402       aRefLayer->setAttribute(_toDOMS("selDistPhi"), _toDOMS(stringStr.str()));
0403       int selDistPhiShift = 0;
0404       stringStr.str("");
0405       stringStr << selDistPhiShift;
0406       aRefLayer->setAttribute(_toDOMS("selDistPhiShift"), _toDOMS(stringStr.str()));
0407       int distMsbPhiShift = 0;
0408       stringStr.str("");
0409       stringStr << distMsbPhiShift;
0410       aRefLayer->setAttribute(_toDOMS("distMsbPhiShift"), _toDOMS(stringStr.str()));
0411       aLayer->appendChild(aRefLayer);
0412     }
0413     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0414       for (unsigned int iPdf = 0; iPdf < exp2(myOMTFConfig->nPdfAddrBits()); ++iPdf) {
0415         aPdf = theDoc->createElement(_toDOMS("PDF"));
0416         stringStr.str("");
0417         stringStr << aGP.pdfValue(iLayer, iRefLayer, iPdf);
0418         aPdf->setAttribute(_toDOMS("value"), _toDOMS(stringStr.str()));
0419         aLayer->appendChild(aPdf);
0420       }
0421     }
0422     aGPElement->appendChild(aLayer);
0423   }
0424   theTopElement->appendChild(aGPElement);
0425 }
0426 //////////////////////////////////////////////////
0427 //////////////////////////////////////////////////
0428 void XMLConfigWriter::writeGPData(const GoldenPattern& aGP1,
0429                                   const GoldenPattern& aGP2,
0430                                   const GoldenPattern& aGP3,
0431                                   const GoldenPattern& aGP4) {
0432   std::ostringstream stringStr;
0433   xercesc::DOMElement *aLayer = nullptr, *aRefLayer = nullptr, *aPdf = nullptr;
0434 
0435   xercesc::DOMElement* aGPElement = theDoc->createElement(_toDOMS("GP"));
0436   stringStr.str("");
0437 
0438   stringStr << aGP1.key().thePtCode;
0439   aGPElement->setAttribute(_toDOMS("iPt1"), _toDOMS(stringStr.str()));
0440   stringStr.str("");
0441 
0442   stringStr << aGP2.key().thePtCode;
0443   aGPElement->setAttribute(_toDOMS("iPt2"), _toDOMS(stringStr.str()));
0444   stringStr.str("");
0445 
0446   stringStr << aGP3.key().thePtCode;
0447   aGPElement->setAttribute(_toDOMS("iPt3"), _toDOMS(stringStr.str()));
0448   stringStr.str("");
0449 
0450   stringStr << aGP4.key().thePtCode;
0451   aGPElement->setAttribute(_toDOMS("iPt4"), _toDOMS(stringStr.str()));
0452 
0453   stringStr.str("");
0454   //stringStr<<aGP1.key().theEtaCode;
0455   stringStr << "0";  //No eta code at the moment
0456   aGPElement->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
0457   stringStr.str("");
0458   stringStr << "0";  //No phi code is assigned to GP for the moment.
0459   aGPElement->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
0460   stringStr.str("");
0461   stringStr << aGP1.key().theCharge;
0462 
0463   aGPElement->setAttribute(_toDOMS("iCharge"), _toDOMS(stringStr.str()));
0464 
0465   for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
0466     int nOfPhis = 0;
0467     /////////////////////////////////////
0468     aLayer = theDoc->createElement(_toDOMS("Layer"));
0469     stringStr.str("");
0470     stringStr << iLayer;
0471     //////////////////////////////////
0472     aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0473     stringStr.str("");
0474     stringStr << nOfPhis;
0475     aLayer->setAttribute(_toDOMS("nOfPhis"), _toDOMS(stringStr.str()));
0476     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0477       aRefLayer = theDoc->createElement(_toDOMS("RefLayer"));
0478       int meanDistPhi = aGP1.meanDistPhiValue(iLayer, iRefLayer);
0479 
0480       stringStr.str("");
0481       stringStr << meanDistPhi;
0482       aRefLayer->setAttribute(_toDOMS("meanDistPhi"), _toDOMS(stringStr.str()));
0483 
0484       //int meanDistPhi2 = aGP2.meanDistPhiValue(iLayer,iRefLayer);
0485       //stringStr.str("");
0486       //stringStr<<meanDistPhi2;
0487       //aRefLayer->setAttribute(_toDOMS("meanDistPhi2"), _toDOMS(stringStr.str()));
0488 
0489       int selDistPhi = 0;
0490       stringStr.str("");
0491       stringStr << selDistPhi;
0492       aRefLayer->setAttribute(_toDOMS("selDistPhi"), _toDOMS(stringStr.str()));
0493       int selDistPhiShift = 0;
0494       stringStr.str("");
0495       stringStr << selDistPhiShift;
0496       aRefLayer->setAttribute(_toDOMS("selDistPhiShift"), _toDOMS(stringStr.str()));
0497       int distMsbPhiShift = 0;
0498       stringStr.str("");
0499       stringStr << distMsbPhiShift;
0500       aRefLayer->setAttribute(_toDOMS("distMsbPhiShift"), _toDOMS(stringStr.str()));
0501       aLayer->appendChild(aRefLayer);
0502     }
0503     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0504       for (unsigned int iPdf = 0; iPdf < exp2(myOMTFConfig->nPdfAddrBits()); ++iPdf) {
0505         aPdf = theDoc->createElement(_toDOMS("PDF"));
0506         stringStr.str("");
0507         stringStr << aGP1.pdfValue(iLayer, iRefLayer, iPdf);
0508         aPdf->setAttribute(_toDOMS("value1"), _toDOMS(stringStr.str()));
0509         stringStr.str("");
0510         stringStr << aGP2.pdfValue(iLayer, iRefLayer, iPdf);
0511         aPdf->setAttribute(_toDOMS("value2"), _toDOMS(stringStr.str()));
0512         stringStr.str("");
0513         stringStr << aGP3.pdfValue(iLayer, iRefLayer, iPdf);
0514         aPdf->setAttribute(_toDOMS("value3"), _toDOMS(stringStr.str()));
0515         stringStr.str("");
0516         stringStr << aGP4.pdfValue(iLayer, iRefLayer, iPdf);
0517         aPdf->setAttribute(_toDOMS("value4"), _toDOMS(stringStr.str()));
0518         aLayer->appendChild(aPdf);
0519       }
0520     }
0521     aGPElement->appendChild(aLayer);
0522   }
0523   theTopElement->appendChild(aGPElement);
0524 }
0525 //////////////////////////////////////////////////
0526 //////////////////////////////////////////////////
0527 void XMLConfigWriter::writeConnectionsData(
0528     const std::vector<std::vector<OMTFConfiguration::vector2D> >& measurements4D) {
0529   std::ostringstream stringStr;
0530 
0531   for (unsigned int iProcessor = 0; iProcessor < 6; ++iProcessor) {
0532     xercesc::DOMElement* aProcessorElement = theDoc->createElement(_toDOMS("Processor"));
0533     stringStr.str("");
0534     stringStr << iProcessor;
0535     aProcessorElement->setAttribute(_toDOMS("iProcessor"), _toDOMS(stringStr.str()));
0536     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0537       xercesc::DOMElement* aRefLayerElement = theDoc->createElement(_toDOMS("RefLayer"));
0538       stringStr.str("");
0539       stringStr << iRefLayer;
0540       aRefLayerElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0541       stringStr.str("");
0542       stringStr << myOMTFConfig->getProcessorPhiVsRefLayer()[iProcessor][iRefLayer];
0543       aRefLayerElement->setAttribute(_toDOMS("iGlobalPhiStart"), _toDOMS(stringStr.str()));
0544       aProcessorElement->appendChild(aRefLayerElement);
0545     }
0546     unsigned int iRefHit = 0;
0547     ///////
0548     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0549       for (unsigned int iRegion = 0; iRegion < 6; ++iRegion) {
0550         unsigned int maxHitCount = 0;
0551         for (unsigned int iInput = 0; iInput < 14; ++iInput) {
0552           if ((int)maxHitCount < myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput])
0553             maxHitCount = myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput];
0554         }
0555         for (unsigned int iInput = 0; iInput < 14; ++iInput) {
0556           unsigned int hitCount = myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput];
0557           if (hitCount < maxHitCount * 0.1)
0558             continue;
0559           xercesc::DOMElement* aRefHitElement = theDoc->createElement(_toDOMS("RefHit"));
0560           stringStr.str("");
0561           stringStr << iRefHit;
0562           aRefHitElement->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
0563           stringStr.str("");
0564           stringStr << iRefLayer;
0565           aRefHitElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0566 
0567           stringStr.str("");
0568           stringStr << iRegion;
0569           aRefHitElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
0570 
0571           stringStr.str("");
0572           stringStr << iInput;
0573           aRefHitElement->setAttribute(_toDOMS("iInput"), _toDOMS(stringStr.str()));
0574           unsigned int logicRegionSize = 10 / 360.0 * myOMTFConfig->nPhiBins();
0575           int lowScaleEnd = std::pow(2, myOMTFConfig->nPhiBits() - 1);
0576           ///iPhiMin and iPhiMax are expressed in n bit scale -2**n, +2**2-1 used in each processor
0577           int iPhiMin = myOMTFConfig->getProcessorPhiVsRefLayer()[iProcessor][iRefLayer] -
0578                         myOMTFConfig->globalPhiStart(iProcessor) - lowScaleEnd;
0579           int iPhiMax = iPhiMin + logicRegionSize - 1;
0580 
0581           iPhiMin += iRegion * logicRegionSize;
0582           iPhiMax += iRegion * logicRegionSize;
0583 
0584           stringStr.str("");
0585           stringStr << iPhiMin;
0586           aRefHitElement->setAttribute(_toDOMS("iPhiMin"), _toDOMS(stringStr.str()));
0587 
0588           stringStr.str("");
0589           stringStr << iPhiMax;
0590           aRefHitElement->setAttribute(_toDOMS("iPhiMax"), _toDOMS(stringStr.str()));
0591           if (iRefHit < myOMTFConfig->nRefHits())
0592             aProcessorElement->appendChild(aRefHitElement);
0593           ++iRefHit;
0594         }
0595         for (; iRegion == 5 && iRefLayer == 7 && iRefHit < myOMTFConfig->nRefHits(); ++iRefHit) {
0596           xercesc::DOMElement* aRefHitElement = theDoc->createElement(_toDOMS("RefHit"));
0597           stringStr.str("");
0598           stringStr << iRefHit;
0599           aRefHitElement->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
0600           stringStr.str("");
0601           stringStr << 0;
0602           aRefHitElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0603 
0604           stringStr.str("");
0605           stringStr << 0;
0606           aRefHitElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
0607 
0608           stringStr.str("");
0609           stringStr << 0;
0610           aRefHitElement->setAttribute(_toDOMS("iInput"), _toDOMS(stringStr.str()));
0611 
0612           int iPhiMin = 0;
0613           int iPhiMax = 1;
0614 
0615           stringStr.str("");
0616           stringStr << iPhiMin;
0617           aRefHitElement->setAttribute(_toDOMS("iPhiMin"), _toDOMS(stringStr.str()));
0618 
0619           stringStr.str("");
0620           stringStr << iPhiMax;
0621           aRefHitElement->setAttribute(_toDOMS("iPhiMax"), _toDOMS(stringStr.str()));
0622 
0623           aProcessorElement->appendChild(aRefHitElement);
0624         }
0625       }
0626     }
0627     ////
0628     for (unsigned int iRegion = 0; iRegion < 6; ++iRegion) {
0629       xercesc::DOMElement* aRegionElement = theDoc->createElement(_toDOMS("LogicRegion"));
0630       stringStr.str("");
0631       stringStr << iRegion;
0632       aRegionElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
0633 
0634       for (unsigned int iLogicLayer = 0; iLogicLayer < myOMTFConfig->nLayers(); ++iLogicLayer) {
0635         xercesc::DOMElement* aLayerElement = theDoc->createElement(_toDOMS("Layer"));
0636         stringStr.str("");
0637         stringStr << iLogicLayer;
0638         ////////////////////////////////////////////////
0639         aLayerElement->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0640         const OMTFConfiguration::vector1D& myCounts =
0641             myOMTFConfig->getMeasurements4D()[iProcessor][iRegion][iLogicLayer];
0642         unsigned int maxInput = findMaxInput(myCounts);
0643         unsigned int begin = 0, end = 0;
0644         if ((int)maxInput - 2 >= 0)
0645           begin = maxInput - 2;
0646         else
0647           begin = maxInput;
0648         end = maxInput + 3;
0649         stringStr.str("");
0650         stringStr << begin;
0651         aLayerElement->setAttribute(_toDOMS("iFirstInput"), _toDOMS(stringStr.str()));
0652         stringStr.str("");
0653         stringStr << end - begin + 1;
0654         aLayerElement->setAttribute(_toDOMS("nInputs"), _toDOMS(stringStr.str()));
0655         aRegionElement->appendChild(aLayerElement);
0656       }
0657       aProcessorElement->appendChild(aRegionElement);
0658     }
0659     theTopElement->appendChild(aProcessorElement);
0660   }
0661 }
0662 //////////////////////////////////////////////////
0663 //////////////////////////////////////////////////
0664 unsigned int XMLConfigWriter::findMaxInput(const OMTFConfiguration::vector1D& myCounts) {
0665   unsigned int max = 0;
0666   unsigned int maxInput = 0;
0667   for (unsigned int iInput = 0; iInput < 14; ++iInput) {
0668     if (myCounts[iInput] > (int)max) {
0669       max = myCounts[iInput];
0670       maxInput = iInput;
0671     }
0672   }
0673   return maxInput;
0674 }
0675 /////////////////////////////////////////////////////////////
0676 /////////////////////////////////////////////////////////////
[ 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!