Back to home page

Project CMSSW displayed by LXR
 
 

    

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

0001 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/XMLConfigWriter.h"
0002 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/AlgoMuon.h"
0003 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/GoldenPattern.h"
0004 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/GoldenPatternResult.h"
0005 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/GoldenPatternWithStat.h"
0006 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/OMTFConfiguration.h"
0007 #include "L1Trigger/L1TMuonOverlapPhase1/interface/Omtf/OMTFinput.h"
0008 
0009 #include "FWCore/Framework/interface/Event.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, bool writePdfThresholds, bool writeMeanDistPhi1)
0091     : writePdfThresholds(writePdfThresholds), writeMeanDistPhi1(writeMeanDistPhi1) {
0092   cms::concurrency::xercesInitialize();
0093 
0094   ///Initialise XML document
0095   domImpl = DOMImplementationRegistry::getDOMImplementation(_toDOMS("Range"));
0096 
0097   myOMTFConfig = aOMTFConfig;
0098 }
0099 //////////////////////////////////////////////////
0100 //////////////////////////////////////////////////
0101 XMLConfigWriter::~XMLConfigWriter() { cms::concurrency::xercesTerminate(); }
0102 //////////////////////////////////////////////////
0103 //////////////////////////////////////////////////
0104 void XMLConfigWriter::initialiseXMLDocument(const std::string& docName) {
0105   theDoc = domImpl->createDocument(nullptr, _toDOMS(docName), nullptr);
0106   theTopElement = theDoc->getDocumentElement();
0107 
0108   const unsigned int mask16bits = 0xFFFF;
0109   const unsigned int version = (myOMTFConfig->patternsVersion() & mask16bits);
0110 
0111   std::ostringstream stringStr;
0112   stringStr.str("");
0113   stringStr << "0x" << std::hex << std::setfill('0') << std::setw(4) << version;
0114   theTopElement->setAttribute(_toDOMS("version"), _toDOMS(stringStr.str()));
0115 }
0116 //////////////////////////////////////////////////
0117 //////////////////////////////////////////////////
0118 void XMLConfigWriter::finaliseXMLDocument(const std::string& fName) {
0119   XMLFormatTarget* formTarget = new LocalFileFormatTarget(fName.c_str());
0120 
0121 #if _XERCES_VERSION < 30100
0122   xercesc::DOMWriter* domWriter = (dynamic_cast<DOMImplementation*>(domImpl))->createDOMWriter();
0123   if (domWriter->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) {
0124     domWriter->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);
0125   }
0126   domWriter->writeNode(formTarget, *theTopElement);
0127 
0128 #else
0129   xercesc::DOMLSSerializer* theSerializer = (dynamic_cast<DOMImplementation*>(domImpl))->createLSSerializer();
0130   if (theSerializer->getDomConfig()->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true))
0131     theSerializer->getDomConfig()->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true);
0132   DOMLSOutput* theOutput = (dynamic_cast<DOMImplementation*>(domImpl))->createLSOutput();
0133   theOutput->setByteStream(formTarget);
0134   theSerializer->write(theTopElement, theOutput);
0135   theOutput->release();
0136   theSerializer->release();
0137 #endif
0138 
0139   delete formTarget;
0140 }
0141 //////////////////////////////////////////////////
0142 //////////////////////////////////////////////////
0143 xercesc::DOMElement* XMLConfigWriter::writeEventHeader(unsigned int eventId, unsigned int mixedEventId) {
0144   unsigned int eventBx = eventId * 2;
0145 
0146   xercesc::DOMElement* aEvent = nullptr;
0147   xercesc::DOMElement* aBx = nullptr;
0148   std::ostringstream stringStr;
0149 
0150   aEvent = theDoc->createElement(_toDOMS("Event"));
0151 
0152   stringStr.str("");
0153   stringStr << eventId;
0154   aEvent->setAttribute(_toDOMS("iEvent"), _toDOMS(stringStr.str()));
0155 
0156   stringStr.str("");
0157   stringStr << mixedEventId;
0158   aEvent->setAttribute(_toDOMS("iMixedEvent"), _toDOMS(stringStr.str()));
0159 
0160   aBx = theDoc->createElement(_toDOMS("bx"));
0161   stringStr.str("");
0162   stringStr << eventBx;
0163   aBx->setAttribute(_toDOMS("iBx"), _toDOMS(stringStr.str()));
0164   aEvent->appendChild(aBx);
0165 
0166   theTopElement->appendChild(aEvent);
0167 
0168   return aBx;
0169 }
0170 //////////////////////////////////////////////////
0171 //////////////////////////////////////////////////
0172 xercesc::DOMElement* XMLConfigWriter::writeEventData(xercesc::DOMElement* aTopElement,
0173                                                      const OmtfName& board,
0174                                                      const OMTFinput& aInput) {
0175   std::ostringstream stringStr;
0176 
0177   xercesc::DOMElement* aProcessor = theDoc->createElement(_toDOMS("Processor"));
0178   aProcessor->setAttribute(_toDOMS("board"), _toDOMS(board.name()));
0179 
0180   unsigned int iProcessor = board.processor();
0181   stringStr.str("");
0182   stringStr << iProcessor;
0183   aProcessor->setAttribute(_toDOMS("iProcessor"), _toDOMS(stringStr.str()));
0184   stringStr.str("");
0185   if (board.position() == 1)
0186     stringStr << "+";
0187   stringStr << board.position();
0188   aProcessor->setAttribute(_toDOMS("position"), _toDOMS(stringStr.str()));
0189 
0190   xercesc::DOMElement *aLayer, *aHit;
0191   for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
0192     aLayer = theDoc->createElement(_toDOMS("Layer"));
0193     stringStr.str("");
0194     stringStr << iLayer;
0195     aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0196     for (unsigned int iHit = 0; iHit < aInput.getMuonStubs()[iLayer].size(); ++iHit) {
0197       int hitPhi = aInput.getPhiHw(iLayer, iHit);
0198       if (hitPhi >= (int)myOMTFConfig->nPhiBins())
0199         continue;
0200 
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 << hitPhi;
0207       aHit->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
0208       stringStr.str("");
0209       stringStr << eta2Bits(abs(aInput.getHitEta(iLayer, iHit)));
0210       aHit->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
0211 
0212       aLayer->appendChild(aHit);
0213     }
0214     if (aLayer->getChildNodes()->getLength())
0215       aProcessor->appendChild(aLayer);
0216   }
0217 
0218   aTopElement->appendChild(aProcessor);
0219   return aProcessor;
0220 }
0221 //////////////////////////////////////////////////
0222 //////////////////////////////////////////////////
0223 void XMLConfigWriter::writeAlgoMuon(xercesc::DOMElement* aTopElement, const AlgoMuon& aCand) {
0224   xercesc::DOMElement* aResult = theDoc->createElement(_toDOMS("AlgoMuon"));
0225   std::ostringstream stringStr;
0226   stringStr.str("");
0227   stringStr << aCand.getRefHitNumber();
0228   aResult->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
0229   stringStr.str("");
0230   stringStr << aCand.getPtConstr();
0231   aResult->setAttribute(_toDOMS("ptCode"), _toDOMS(stringStr.str()));
0232   stringStr.str("");
0233   stringStr << aCand.getPhi();
0234   aResult->setAttribute(_toDOMS("phiCode"), _toDOMS(stringStr.str()));
0235   stringStr.str("");
0236   stringStr << eta2Bits(abs(aCand.getEtaHw()));
0237   aResult->setAttribute(_toDOMS("etaCode"), _toDOMS(stringStr.str()));
0238   stringStr.str("");
0239   stringStr << aCand.getChargeConstr();
0240   aResult->setAttribute(_toDOMS("charge"), _toDOMS(stringStr.str()));
0241   stringStr.str("");
0242   stringStr << aCand.getQ();
0243   aResult->setAttribute(_toDOMS("nHits"), _toDOMS(stringStr.str()));
0244   stringStr.str("");
0245   stringStr << aCand.getDisc();
0246   aResult->setAttribute(_toDOMS("disc"), _toDOMS(stringStr.str()));
0247   stringStr.str("");
0248   stringStr << aCand.getRefLayer();
0249   aResult->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0250   stringStr.str("");
0251   stringStr << std::bitset<18>(aCand.getFiredLayerBits());
0252   aResult->setAttribute(_toDOMS("layers"), _toDOMS(stringStr.str()));
0253   stringStr.str("");
0254   stringStr << aCand.getPhiRHit();
0255   aResult->setAttribute(_toDOMS("phiRHit"), _toDOMS(stringStr.str()));
0256   stringStr.str("");
0257   stringStr << aCand.getHwPatternNumConstr();
0258   aResult->setAttribute(_toDOMS("patNum"), _toDOMS(stringStr.str()));
0259 
0260   aTopElement->appendChild(aResult);
0261 }
0262 //////////////////////////////////////////////////
0263 //////////////////////////////////////////////////
0264 void XMLConfigWriter::writeCandMuon(xercesc::DOMElement* aTopElement, const l1t::RegionalMuonCand& aCand) {
0265   xercesc::DOMElement* aResult = theDoc->createElement(_toDOMS("CandMuon"));
0266   std::ostringstream stringStr;
0267   stringStr.str("");
0268   stringStr << aCand.hwPt();
0269   aResult->setAttribute(_toDOMS("hwPt"), _toDOMS(stringStr.str()));
0270   stringStr.str("");
0271   stringStr << aCand.hwPhi();
0272   aResult->setAttribute(_toDOMS("hwPhi"), _toDOMS(stringStr.str()));
0273   stringStr.str("");
0274   stringStr << aCand.hwEta();
0275   aResult->setAttribute(_toDOMS("hwEta"), _toDOMS(stringStr.str()));
0276   stringStr.str("");
0277   stringStr << aCand.hwSign();
0278   aResult->setAttribute(_toDOMS("hwSign"), _toDOMS(stringStr.str()));
0279   stringStr.str("");
0280   stringStr << aCand.hwSignValid();
0281   aResult->setAttribute(_toDOMS("hwSignValid"), _toDOMS(stringStr.str()));
0282   stringStr.str("");
0283   stringStr << aCand.hwQual();
0284   aResult->setAttribute(_toDOMS("hwQual"), _toDOMS(stringStr.str()));
0285   stringStr.str("");
0286   std::map<int, int> hwAddrMap = aCand.trackAddress();
0287   stringStr << std::bitset<29>(hwAddrMap[0]);
0288   aResult->setAttribute(_toDOMS("hwTrackAddress"), _toDOMS(stringStr.str()));
0289   stringStr.str("");
0290   stringStr << aCand.link();
0291   aResult->setAttribute(_toDOMS("link"), _toDOMS(stringStr.str()));
0292   stringStr.str("");
0293   stringStr << aCand.processor();
0294   aResult->setAttribute(_toDOMS("processor"), _toDOMS(stringStr.str()));
0295   stringStr.str("");
0296   if (aCand.trackFinderType() == l1t::omtf_neg)
0297     stringStr << "OMTF_NEG";
0298   else if (aCand.trackFinderType() == l1t::omtf_pos)
0299     stringStr << "OMTF_POS";
0300   else
0301     stringStr << aCand.trackFinderType();
0302   aResult->setAttribute(_toDOMS("trackFinderType"), _toDOMS(stringStr.str()));
0303   aTopElement->appendChild(aResult);
0304 }
0305 //////////////////////////////////////////////////
0306 //////////////////////////////////////////////////
0307 //////////////////////////////////////////////////
0308 //////////////////////////////////////////////////
0309 void XMLConfigWriter::writeResultsData(xercesc::DOMElement* aTopElement,
0310                                        unsigned int iRegion,
0311                                        const Key& aKey,
0312                                        const GoldenPatternResult& aResult) {
0313   std::ostringstream stringStr;
0314   ///Write GP key parameters
0315   xercesc::DOMElement* aGP = theDoc->createElement(_toDOMS("GP"));
0316   stringStr.str("");
0317   stringStr << aKey.thePt;
0318   aGP->setAttribute(_toDOMS("iPt"), _toDOMS(stringStr.str()));
0319   stringStr.str("");
0320   stringStr << aKey.theEtaCode;
0321   aGP->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
0322   stringStr.str("");
0323   stringStr << "0";
0324   aGP->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
0325   stringStr.str("");
0326   stringStr << aKey.theCharge;
0327   aGP->setAttribute(_toDOMS("iCharge"), _toDOMS(stringStr.str()));
0328   /////////////////
0329   ///Write results details for this GP
0330   {
0331     xercesc::DOMElement* aRefLayer = theDoc->createElement(_toDOMS("Result"));
0332     stringStr.str("");
0333     stringStr << aResult.getRefLayer();
0334     aRefLayer->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0335     stringStr.str("");
0336     stringStr << iRegion;
0337     aRefLayer->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
0338     stringStr.str("");
0339     stringStr << myOMTFConfig->getRefToLogicNumber()[aResult.getRefLayer()];
0340     aRefLayer->setAttribute(_toDOMS("iLogicLayer"), _toDOMS(stringStr.str()));
0341     for (unsigned int iLogicLayer = 0; iLogicLayer < myOMTFConfig->nLayers(); ++iLogicLayer) {
0342       xercesc::DOMElement* aLayer = theDoc->createElement(_toDOMS("Layer"));
0343       stringStr.str("");
0344       stringStr << iLogicLayer;
0345       aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0346       stringStr.str("");
0347       stringStr << aResult.getStubResults()[iLogicLayer].getPdfVal();
0348       aLayer->setAttribute(_toDOMS("value"), _toDOMS(stringStr.str()));
0349       if (aResult.getStubResults()[iLogicLayer].getPdfVal())
0350         aRefLayer->appendChild(aLayer);
0351     }
0352     if (aRefLayer->getChildNodes()->getLength())
0353       aGP->appendChild(aRefLayer);
0354   }
0355   if (aGP->getChildNodes()->getLength())
0356     aTopElement->appendChild(aGP);
0357 }
0358 //////////////////////////////////////////////////
0359 //////////////////////////////////////////////////
0360 void XMLConfigWriter::writeGPData(GoldenPattern& aGP) {
0361   std::ostringstream stringStr;
0362   xercesc::DOMElement *aLayer = nullptr, *aRefLayer = nullptr, *aPdf = nullptr;
0363 
0364   xercesc::DOMElement* aGPElement = theDoc->createElement(_toDOMS("GP"));
0365   stringStr.str("");
0366   stringStr << aGP.key().thePt;
0367   aGPElement->setAttribute(_toDOMS("iPt"), _toDOMS(stringStr.str()));
0368   stringStr.str("");
0369   //stringStr<<aGP.key().theEtaCode;
0370   stringStr << "0";  //No eta code at the moment
0371   aGPElement->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
0372   stringStr.str("");
0373   stringStr << 0;  //No phi code is assigned to GP for the moment.
0374   aGPElement->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
0375   stringStr.str("");
0376   stringStr << aGP.key().theCharge;
0377   aGPElement->setAttribute(_toDOMS("iCharge"), _toDOMS(stringStr.str()));
0378 
0379   for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
0380     int nOfPhis = 0;
0381     /////////////////////////////////////
0382     aLayer = theDoc->createElement(_toDOMS("Layer"));
0383     stringStr.str("");
0384     stringStr << iLayer;
0385     //////////////////////////////////
0386     aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0387     stringStr.str("");
0388     stringStr << nOfPhis;
0389     aLayer->setAttribute(_toDOMS("nOfPhis"), _toDOMS(stringStr.str()));
0390     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0391       aRefLayer = theDoc->createElement(_toDOMS("RefLayer"));
0392       int meanDistPhi0 = aGP.getMeanDistPhi()[iLayer][iRefLayer][0];
0393       stringStr.str("");
0394       stringStr << meanDistPhi0;
0395       aRefLayer->setAttribute(_toDOMS("meanDistPhi0"), _toDOMS(stringStr.str()));
0396 
0397       int meanDistPhi1 = aGP.getMeanDistPhi()[iLayer][iRefLayer][1];
0398       stringStr.str("");
0399       stringStr << meanDistPhi1;
0400       aRefLayer->setAttribute(_toDOMS("meanDistPhi1"), _toDOMS(stringStr.str()));
0401 
0402       int selDistPhi = 0;
0403       stringStr.str("");
0404       stringStr << selDistPhi;
0405       aRefLayer->setAttribute(_toDOMS("selDistPhi"), _toDOMS(stringStr.str()));
0406 
0407       int selDistPhiShift =
0408           aGP.getDistPhiBitShift(iLayer, iRefLayer);  //TODO check if Wojtek expects it here or on the distMsbPhiShift
0409       stringStr.str("");
0410       stringStr << selDistPhiShift;
0411       aRefLayer->setAttribute(_toDOMS("selDistPhiShift"), _toDOMS(stringStr.str()));
0412 
0413       int distMsbPhiShift = 0;
0414       stringStr.str("");
0415       stringStr << distMsbPhiShift;
0416       aRefLayer->setAttribute(_toDOMS("distMsbPhiShift"), _toDOMS(stringStr.str()));
0417       aLayer->appendChild(aRefLayer);
0418     }
0419     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0420       for (unsigned int iPdf = 0; iPdf < exp2(myOMTFConfig->nPdfAddrBits()); ++iPdf) {
0421         aPdf = theDoc->createElement(_toDOMS("PDF"));
0422         stringStr.str("");
0423         stringStr << aGP.pdfValue(iLayer, iRefLayer, iPdf);
0424         aPdf->setAttribute(_toDOMS("value"), _toDOMS(stringStr.str()));
0425         aLayer->appendChild(aPdf);
0426       }
0427     }
0428     aGPElement->appendChild(aLayer);
0429   }
0430   theTopElement->appendChild(aGPElement);
0431 }
0432 //////////////////////////////////////////////////
0433 //////////////////////////////////////////////////
0434 void XMLConfigWriter::writeGPData(GoldenPattern* aGP1, GoldenPattern* aGP2, GoldenPattern* aGP3, GoldenPattern* aGP4) {
0435   std::ostringstream stringStr;
0436   auto setAttributeInt = [&](xercesc::DOMElement* domElement, std::string name, int value) -> void {
0437     stringStr << value;
0438     domElement->setAttribute(_toDOMS(name), _toDOMS(stringStr.str()));
0439     stringStr.str("");
0440   };
0441 
0442   auto setAttributeFloat = [&](xercesc::DOMElement* domElement, std::string name, float value) -> void {
0443     stringStr << value;
0444     domElement->setAttribute(_toDOMS(name), _toDOMS(stringStr.str()));
0445     stringStr.str("");
0446   };
0447 
0448   //xercesc::DOMElement *aLayer=nullptr, *aRefLayer=nullptr, *aPdf=nullptr;
0449 
0450   xercesc::DOMElement* aGPElement = theDoc->createElement(_toDOMS("GP"));
0451 
0452   setAttributeInt(aGPElement, "iPt1", aGP1->key().thePt);
0453   setAttributeInt(aGPElement, "iPt2", aGP2->key().thePt);
0454   setAttributeInt(aGPElement, "iPt3", aGP3->key().thePt);
0455   setAttributeInt(aGPElement, "iPt4", aGP4->key().thePt);
0456 
0457   if (writePdfThresholds) {
0458     if (dynamic_cast<const GoldenPatternWithThresh*>(aGP1) != nullptr) {
0459       for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0460         //cout<<__FUNCTION__<<":"<<__LINE__<<std::endl;
0461         xercesc::DOMElement* aRefLayerThresh = theDoc->createElement(_toDOMS("RefLayerThresh"));
0462         setAttributeFloat(
0463             aRefLayerThresh, "tresh1", dynamic_cast<const GoldenPatternWithThresh*>(aGP1)->getThreshold(iRefLayer));
0464         setAttributeFloat(
0465             aRefLayerThresh, "tresh2", dynamic_cast<const GoldenPatternWithThresh*>(aGP2)->getThreshold(iRefLayer));
0466         setAttributeFloat(
0467             aRefLayerThresh, "tresh3", dynamic_cast<const GoldenPatternWithThresh*>(aGP3)->getThreshold(iRefLayer));
0468         setAttributeFloat(
0469             aRefLayerThresh, "tresh4", dynamic_cast<const GoldenPatternWithThresh*>(aGP4)->getThreshold(iRefLayer));
0470 
0471         aGPElement->appendChild(aRefLayerThresh);
0472       }
0473     }
0474   }
0475 
0476   setAttributeInt(aGPElement, "iEta", 0);  //aGP1.key().theEtaCode; //No eta code at the moment
0477 
0478   setAttributeInt(aGPElement, "iPhi", 0);  //No phi code is assigned to GP for the moment.
0479 
0480   setAttributeInt(aGPElement, "iCharge", aGP1->key().theCharge);
0481 
0482   for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
0483     int nOfPhis = 0;
0484     /////////////////////////////////////
0485     xercesc::DOMElement* aLayer = theDoc->createElement(_toDOMS("Layer"));
0486 
0487     setAttributeInt(aLayer, "iLayer", iLayer);
0488     setAttributeInt(aLayer, "nOfPhis", nOfPhis);
0489 
0490     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0491       xercesc::DOMElement* aRefLayer = theDoc->createElement(_toDOMS("RefLayer"));
0492 
0493       if (writeMeanDistPhi1) {
0494         int meanDistPhi0 = aGP1->getMeanDistPhi()[iLayer][iRefLayer][0];
0495         setAttributeInt(aRefLayer, "meanDistPhi0", meanDistPhi0);
0496 
0497         int meanDistPhi1 = aGP1->getMeanDistPhi()[iLayer][iRefLayer][1];
0498         setAttributeInt(aRefLayer, "meanDistPhi1", meanDistPhi1);
0499       } else {
0500         int meanDistPhi = aGP1->getMeanDistPhi()[iLayer][iRefLayer][0];
0501         setAttributeInt(aRefLayer, "meanDistPhi", meanDistPhi);
0502       }
0503 
0504       int selDistPhi = 0;
0505       setAttributeInt(aRefLayer, "selDistPhi", selDistPhi);
0506 
0507       int selDistPhiShift = aGP1->getDistPhiBitShift(
0508           iLayer, iRefLayer);  //TODO check if Wojtek expects it here or on the distMsbPhiShift;
0509       setAttributeInt(aRefLayer, "selDistPhiShift", selDistPhiShift);
0510 
0511       int distMsbPhiShift = 0;
0512       setAttributeInt(aRefLayer, "distMsbPhiShift", distMsbPhiShift);
0513 
0514       aLayer->appendChild(aRefLayer);
0515     }
0516     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0517       for (unsigned int iPdf = 0; iPdf < exp2(myOMTFConfig->nPdfAddrBits()); ++iPdf) {
0518         xercesc::DOMElement* aPdf = theDoc->createElement(_toDOMS("PDF"));
0519 
0520         setAttributeFloat(aPdf, "value1", aGP1->pdfValue(iLayer, iRefLayer, iPdf));
0521         setAttributeFloat(aPdf, "value2", aGP2->pdfValue(iLayer, iRefLayer, iPdf));
0522         setAttributeFloat(aPdf, "value3", aGP3->pdfValue(iLayer, iRefLayer, iPdf));
0523         setAttributeFloat(aPdf, "value4", aGP4->pdfValue(iLayer, iRefLayer, iPdf));
0524 
0525         aLayer->appendChild(aPdf);
0526       }
0527     }
0528     aGPElement->appendChild(aLayer);
0529   }
0530   theTopElement->appendChild(aGPElement);
0531 }
0532 //////////////////////////////////////////////////
0533 //////////////////////////////////////////////////
0534 template <class GoldenPatternType>
0535 void XMLConfigWriter::writeGPs(const GoldenPatternVec<GoldenPatternType>& goldenPats, std::string fName) {
0536   initialiseXMLDocument("OMTF");
0537   GoldenPattern* dummy = new GoldenPatternWithThresh(Key(0, 0, 0), myOMTFConfig);
0538 
0539   OMTFConfiguration::vector2D mergedPartters = myOMTFConfig->getPatternGroups(goldenPats);
0540   for (unsigned int iGroup = 0; iGroup < mergedPartters.size(); iGroup++) {
0541     std::vector<GoldenPattern*> gps(4, dummy);
0542     for (unsigned int i = 0; i < mergedPartters[iGroup].size(); i++) {
0543       GoldenPattern* gp = dynamic_cast<GoldenPattern*>(goldenPats.at(mergedPartters[iGroup][i]).get());
0544       if (!gp) {
0545         throw cms::Exception("OMTF::XMLConfigWriter::writeGPs: the gps are not GoldenPatterns ");
0546       }
0547       gps[i] = gp;
0548     }
0549     writeGPData(gps[0], gps[1], gps[2], gps[3]);
0550   }
0551   finaliseXMLDocument(fName);
0552 }
0553 //////////////////////////////////////////////////
0554 //////////////////////////////////////////////////
0555 void XMLConfigWriter::writeConnectionsData(
0556     const std::vector<std::vector<OMTFConfiguration::vector2D> >& measurements4D) {
0557   std::ostringstream stringStr;
0558 
0559   for (unsigned int iProcessor = 0; iProcessor < myOMTFConfig->nProcessors(); ++iProcessor) {
0560     xercesc::DOMElement* aProcessorElement = theDoc->createElement(_toDOMS("Processor"));
0561     stringStr.str("");
0562     stringStr << iProcessor;
0563     aProcessorElement->setAttribute(_toDOMS("iProcessor"), _toDOMS(stringStr.str()));
0564     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0565       xercesc::DOMElement* aRefLayerElement = theDoc->createElement(_toDOMS("RefLayer"));
0566       stringStr.str("");
0567       stringStr << iRefLayer;
0568       aRefLayerElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0569       stringStr.str("");
0570       stringStr << myOMTFConfig->getProcessorPhiVsRefLayer()[iProcessor][iRefLayer];
0571       aRefLayerElement->setAttribute(_toDOMS("iGlobalPhiStart"), _toDOMS(stringStr.str()));
0572       aProcessorElement->appendChild(aRefLayerElement);
0573     }
0574     unsigned int iRefHit = 0;
0575     ///////
0576     for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
0577       for (unsigned int iRegion = 0; iRegion < myOMTFConfig->nLogicRegions(); ++iRegion) {
0578         unsigned int maxHitCount = 0;
0579         for (unsigned int iInput = 0; iInput < myOMTFConfig->nInputs(); ++iInput) {
0580           if ((int)maxHitCount < myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput])
0581             maxHitCount = myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput];
0582         }
0583         for (unsigned int iInput = 0; iInput < myOMTFConfig->nInputs(); ++iInput) {
0584           unsigned int hitCount = myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput];
0585           if (hitCount < maxHitCount * 0.1)
0586             continue;
0587           xercesc::DOMElement* aRefHitElement = theDoc->createElement(_toDOMS("RefHit"));
0588           stringStr.str("");
0589           stringStr << iRefHit;
0590           aRefHitElement->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
0591           stringStr.str("");
0592           stringStr << iRefLayer;
0593           aRefHitElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0594 
0595           stringStr.str("");
0596           stringStr << iRegion;
0597           aRefHitElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
0598 
0599           stringStr.str("");
0600           stringStr << iInput;
0601           aRefHitElement->setAttribute(_toDOMS("iInput"), _toDOMS(stringStr.str()));
0602           unsigned int logicRegionSize = 10 / 360.0 * myOMTFConfig->nPhiBins();
0603           int lowScaleEnd = std::pow(2, myOMTFConfig->nPhiBits() - 1);
0604           ///iPhiMin and iPhiMax are expressed in n bit scale -2**n, +2**2-1 used in each processor
0605           int iPhiMin = myOMTFConfig->getProcessorPhiVsRefLayer()[iProcessor][iRefLayer] -
0606                         myOMTFConfig->globalPhiStart(iProcessor) - lowScaleEnd;
0607           int iPhiMax = iPhiMin + logicRegionSize - 1;
0608 
0609           iPhiMin += iRegion * logicRegionSize;
0610           iPhiMax += iRegion * logicRegionSize;
0611 
0612           stringStr.str("");
0613           stringStr << iPhiMin;
0614           aRefHitElement->setAttribute(_toDOMS("iPhiMin"), _toDOMS(stringStr.str()));
0615 
0616           stringStr.str("");
0617           stringStr << iPhiMax;
0618           aRefHitElement->setAttribute(_toDOMS("iPhiMax"), _toDOMS(stringStr.str()));
0619           if (iRefHit < myOMTFConfig->nRefHits())
0620             aProcessorElement->appendChild(aRefHitElement);
0621           ++iRefHit;
0622         }
0623         for (; iRegion == 5 && iRefLayer == 7 && iRefHit < myOMTFConfig->nRefHits(); ++iRefHit) {
0624           xercesc::DOMElement* aRefHitElement = theDoc->createElement(_toDOMS("RefHit"));
0625           stringStr.str("");
0626           stringStr << iRefHit;
0627           aRefHitElement->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
0628           stringStr.str("");
0629           stringStr << 0;
0630           aRefHitElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
0631 
0632           stringStr.str("");
0633           stringStr << 0;
0634           aRefHitElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
0635 
0636           stringStr.str("");
0637           stringStr << 0;
0638           aRefHitElement->setAttribute(_toDOMS("iInput"), _toDOMS(stringStr.str()));
0639 
0640           int iPhiMin = 0;
0641           int iPhiMax = 1;
0642 
0643           stringStr.str("");
0644           stringStr << iPhiMin;
0645           aRefHitElement->setAttribute(_toDOMS("iPhiMin"), _toDOMS(stringStr.str()));
0646 
0647           stringStr.str("");
0648           stringStr << iPhiMax;
0649           aRefHitElement->setAttribute(_toDOMS("iPhiMax"), _toDOMS(stringStr.str()));
0650 
0651           aProcessorElement->appendChild(aRefHitElement);
0652         }
0653       }
0654     }
0655     ////
0656     for (unsigned int iRegion = 0; iRegion < myOMTFConfig->nLogicRegions(); ++iRegion) {
0657       xercesc::DOMElement* aRegionElement = theDoc->createElement(_toDOMS("LogicRegion"));
0658       stringStr.str("");
0659       stringStr << iRegion;
0660       aRegionElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
0661 
0662       for (unsigned int iLogicLayer = 0; iLogicLayer < myOMTFConfig->nLayers(); ++iLogicLayer) {
0663         xercesc::DOMElement* aLayerElement = theDoc->createElement(_toDOMS("Layer"));
0664         stringStr.str("");
0665         stringStr << iLogicLayer;
0666         ////////////////////////////////////////////////
0667         aLayerElement->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
0668         const OMTFConfiguration::vector1D& myCounts =
0669             myOMTFConfig->getMeasurements4D()[iProcessor][iRegion][iLogicLayer];
0670         unsigned int maxInput = findMaxInput(myCounts);
0671         unsigned int begin = 0, end = 0;
0672         if ((int)maxInput - 2 >= 0)
0673           begin = maxInput - 2;
0674         else
0675           begin = maxInput;
0676         end = maxInput + 3;
0677         stringStr.str("");
0678         stringStr << begin;
0679         aLayerElement->setAttribute(_toDOMS("iFirstInput"), _toDOMS(stringStr.str()));
0680         stringStr.str("");
0681         stringStr << end - begin + 1;
0682         aLayerElement->setAttribute(_toDOMS("nInputs"), _toDOMS(stringStr.str()));
0683         aRegionElement->appendChild(aLayerElement);
0684       }
0685       aProcessorElement->appendChild(aRegionElement);
0686     }
0687     theTopElement->appendChild(aProcessorElement);
0688   }
0689 }
0690 //////////////////////////////////////////////////
0691 //////////////////////////////////////////////////
0692 unsigned int XMLConfigWriter::findMaxInput(const OMTFConfiguration::vector1D& myCounts) {
0693   unsigned int max = 0;
0694   unsigned int maxInput = 0;
0695   for (unsigned int iInput = 0; iInput < myOMTFConfig->nInputs(); ++iInput) {
0696     if (myCounts[iInput] > (int)max) {
0697       max = myCounts[iInput];
0698       maxInput = iInput;
0699     }
0700   }
0701   return maxInput;
0702 }
0703 /////////////////////////////////////////////////////////////
0704 /////////////////////////////////////////////////////////////
0705 template void XMLConfigWriter::writeGPs(const GoldenPatternVec<GoldenPattern>& goldenPats, std::string fName);
0706 
0707 template void XMLConfigWriter::writeGPs(const GoldenPatternVec<GoldenPatternWithStat>& goldenPats, std::string fName);
0708 
0709 template void XMLConfigWriter::writeGPs(const GoldenPatternVec<GoldenPatternWithThresh>& goldenPats, std::string fName);
[ 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!