XMLConfigWriter.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/Event.h"

#include "L1Trigger/L1TMuonOverlap/interface/XMLConfigWriter.h"
#include "L1Trigger/L1TMuonOverlap/interface/GoldenPattern.h"
#include "L1Trigger/L1TMuonOverlap/interface/OMTFinput.h"
#include "L1Trigger/L1TMuonOverlap/interface/OMTFConfiguration.h"
#include "L1Trigger/L1TMuonOverlap/interface/OMTFResult.h"

#include "L1Trigger/L1TMuonOverlap/interface/AlgoMuon.h"
#include "DataFormats/L1TMuon/interface/RegionalMuonCand.h"

#include <iostream>
#include <sstream>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <bitset>

#include "xercesc/framework/StdOutFormatTarget.hpp"
#include "xercesc/framework/LocalFileFormatTarget.hpp"
#include "xercesc/parsers/XercesDOMParser.hpp"
#include "xercesc/dom/DOM.hpp"
#include "xercesc/dom/DOMException.hpp"
#include "xercesc/dom/DOMImplementation.hpp"
#include "xercesc/sax/HandlerBase.hpp"
#include "xercesc/util/XMLString.hpp"
#include "xercesc/util/PlatformUtils.hpp"
#include "xercesc/util/XercesDefs.hpp"
#include "xercesc/util/XercesVersion.hpp"
XERCES_CPP_NAMESPACE_USE

#if _XERCES_VERSION < 30100
#include "xercesc/dom/DOMWriter.hpp"
#else
#include "xercesc/dom/DOMLSSerializer.hpp"
#include "xercesc/dom/DOMLSOutput.hpp"
#endif
//

namespace {
  unsigned int eta2Bits(unsigned int eta) {
    if (eta == 73)
      return 0b100000000;
    else if (eta == 78)
      return 0b010000000;
    else if (eta == 85)
      return 0b001000000;
    else if (eta == 90)
      return 0b000100000;
    else if (eta == 94)
      return 0b000010000;
    else if (eta == 99)
      return 0b000001000;
    else if (eta == 103)
      return 0b000000100;
    else if (eta == 110)
      return 0b000000010;
    else if (eta == 75)
      return 0b110000000;
    else if (eta == 79)
      return 0b011000000;
    else if (eta == 92)
      return 0b000110000;
    else if (eta == 115)
      return 0b000000001;
    else if (eta == 121)
      return 0b000000000;
    else
      return 0b111111111;
    ;
  }
}  // namespace

// XMLConfigWriter
inline std::string _toString(XMLCh const* toTranscode) {
  std::string tmp(xercesc::XMLString::transcode(toTranscode));
  return tmp;
}

inline XMLCh* _toDOMS(std::string temp) {
  XMLCh* buff = XMLString::transcode(temp.c_str());
  return buff;
}
XMLConfigWriter::XMLConfigWriter(const OMTFConfiguration* aOMTFConfig) {
  XMLPlatformUtils::Initialize();

  domImpl = DOMImplementationRegistry::getDOMImplementation(_toDOMS("Range"));

  myOMTFConfig = aOMTFConfig;
}
void XMLConfigWriter::initialiseXMLDocument(const std::string& docName) {
  theDoc = domImpl->createDocument(nullptr, _toDOMS(docName), nullptr);
  theTopElement = theDoc->getDocumentElement();

  unsigned int version = myOMTFConfig->patternsVersion();
  unsigned int mask16bits = 0xFFFF;

  version &= mask16bits;

  std::ostringstream stringStr;
  stringStr.str("");
  stringStr << "0x" << std::hex << std::setfill('0') << std::setw(4) << version;
  theTopElement->setAttribute(_toDOMS("version"), _toDOMS(stringStr.str()));
}
void XMLConfigWriter::finaliseXMLDocument(const std::string& fName) {
  XMLFormatTarget* formTarget = new LocalFileFormatTarget(fName.c_str());

#if _XERCES_VERSION < 30100
  xercesc::DOMWriter* domWriter = (dynamic_cast<DOMImplementation*>(domImpl))->createDOMWriter();
  if (domWriter->canSetFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true)) {
    domWriter->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);
  }
  domWriter->writeNode(formTarget, *theTopElement);

#else
  xercesc::DOMLSSerializer* theSerializer = (dynamic_cast<DOMImplementation*>(domImpl))->createLSSerializer();
  if (theSerializer->getDomConfig()->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true))
    theSerializer->getDomConfig()->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true);
  DOMLSOutput* theOutput = (dynamic_cast<DOMImplementation*>(domImpl))->createLSOutput();
  theOutput->setByteStream(formTarget);
  theSerializer->write(theTopElement, theOutput);
  theOutput->release();
  theSerializer->release();
#endif

  delete formTarget;
}
xercesc::DOMElement* XMLConfigWriter::writeEventHeader(unsigned int eventId, unsigned int mixedEventId) {
  unsigned int eventBx = eventId * 2;

  xercesc::DOMElement* aEvent = nullptr;
  xercesc::DOMElement* aBx = nullptr;
  std::ostringstream stringStr;

  aEvent = theDoc->createElement(_toDOMS("Event"));

  stringStr.str("");
  stringStr << eventId;
  aEvent->setAttribute(_toDOMS("iEvent"), _toDOMS(stringStr.str()));

  stringStr.str("");
  stringStr << mixedEventId;
  aEvent->setAttribute(_toDOMS("iMixedEvent"), _toDOMS(stringStr.str()));

  aBx = theDoc->createElement(_toDOMS("bx"));
  stringStr.str("");
  stringStr << eventBx;
  aBx->setAttribute(_toDOMS("iBx"), _toDOMS(stringStr.str()));
  aEvent->appendChild(aBx);

  theTopElement->appendChild(aEvent);

  return aBx;
}
xercesc::DOMElement* XMLConfigWriter::writeEventData(xercesc::DOMElement* aTopElement,
                                                     const OmtfName& board,
                                                     const OMTFinput& aInput) {
  std::ostringstream stringStr;

  xercesc::DOMElement* aProcessor = theDoc->createElement(_toDOMS("Processor"));
  aProcessor->setAttribute(_toDOMS("board"), _toDOMS(board.name()));

  unsigned int iProcessor = board.processor();
  stringStr.str("");
  stringStr << iProcessor;
  aProcessor->setAttribute(_toDOMS("iProcessor"), _toDOMS(stringStr.str()));
  stringStr.str("");
  if (board.position() == 1)
    stringStr << "+";
  stringStr << board.position();
  aProcessor->setAttribute(_toDOMS("position"), _toDOMS(stringStr.str()));

  xercesc::DOMElement *aLayer, *aHit;
  for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
    const OMTFinput::vector1D& layerDataPhi = aInput.getLayerData(iLayer);
    const OMTFinput::vector1D& layerDataEta = aInput.getLayerData(iLayer, true);

    aLayer = theDoc->createElement(_toDOMS("Layer"));
    stringStr.str("");
    stringStr << iLayer;
    aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
    for (unsigned int iHit = 0; iHit < layerDataPhi.size(); ++iHit) {
      aHit = theDoc->createElement(_toDOMS("Hit"));
      stringStr.str("");
      stringStr << iHit;
      aHit->setAttribute(_toDOMS("iInput"), _toDOMS(stringStr.str()));
      stringStr.str("");
      stringStr << layerDataPhi[iHit];
      aHit->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
      stringStr.str("");
      stringStr << eta2Bits(abs(layerDataEta[iHit]));
      aHit->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
      if (layerDataPhi[iHit] >= (int)myOMTFConfig->nPhiBins())
        continue;
      aLayer->appendChild(aHit);
    }
    if (aLayer->getChildNodes()->getLength())
      aProcessor->appendChild(aLayer);
  }

  aTopElement->appendChild(aProcessor);
  return aProcessor;
}
void XMLConfigWriter::writeAlgoMuon(xercesc::DOMElement* aTopElement, unsigned int iRefHit, const AlgoMuon& aCand) {
  xercesc::DOMElement* aResult = theDoc->createElement(_toDOMS("AlgoMuon"));
  std::ostringstream stringStr;
  stringStr.str("");
  stringStr << iRefHit;
  aResult->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.getPt();
  aResult->setAttribute(_toDOMS("ptCode"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.getPhi();
  aResult->setAttribute(_toDOMS("phiCode"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << eta2Bits(abs(aCand.getEta()));
  aResult->setAttribute(_toDOMS("etaCode"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.getCharge();
  aResult->setAttribute(_toDOMS("charge"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.getQ();
  aResult->setAttribute(_toDOMS("nHits"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.getDisc();
  aResult->setAttribute(_toDOMS("disc"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.getRefLayer();
  aResult->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << std::bitset<18>(aCand.getHits());
  aResult->setAttribute(_toDOMS("layers"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.getPhiRHit();
  aResult->setAttribute(_toDOMS("phiRHit"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.getPatternNumber();
  aResult->setAttribute(_toDOMS("patNum"), _toDOMS(stringStr.str()));

  aTopElement->appendChild(aResult);
}
void XMLConfigWriter::writeCandMuon(xercesc::DOMElement* aTopElement, const l1t::RegionalMuonCand& aCand) {
  xercesc::DOMElement* aResult = theDoc->createElement(_toDOMS("CandMuon"));
  std::ostringstream stringStr;
  stringStr.str("");
  stringStr << aCand.hwPt();
  aResult->setAttribute(_toDOMS("hwPt"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.hwPhi();
  aResult->setAttribute(_toDOMS("hwPhi"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.hwEta();
  aResult->setAttribute(_toDOMS("hwEta"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.hwSign();
  aResult->setAttribute(_toDOMS("hwSign"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.hwSignValid();
  aResult->setAttribute(_toDOMS("hwSignValid"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.hwQual();
  aResult->setAttribute(_toDOMS("hwQual"), _toDOMS(stringStr.str()));
  stringStr.str("");
  std::map<int, int> hwAddrMap = aCand.trackAddress();
  stringStr << std::bitset<29>(hwAddrMap[0]);
  aResult->setAttribute(_toDOMS("hwTrackAddress"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.link();
  aResult->setAttribute(_toDOMS("link"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aCand.processor();
  aResult->setAttribute(_toDOMS("processor"), _toDOMS(stringStr.str()));
  stringStr.str("");
  if (aCand.trackFinderType() == l1t::omtf_neg)
    stringStr << "OMTF_NEG";
  else if (aCand.trackFinderType() == l1t::omtf_pos)
    stringStr << "OMTF_POS";
  else
    stringStr << aCand.trackFinderType();
  aResult->setAttribute(_toDOMS("trackFinderType"), _toDOMS(stringStr.str()));
  aTopElement->appendChild(aResult);
}
void XMLConfigWriter::writeResultsData(xercesc::DOMElement* aTopElement,
                                       unsigned int iRegion,
                                       const Key& aKey,
                                       const OMTFResult& aResult) {
  OMTFResult::vector2D results = aResult.getResults();

  std::ostringstream stringStr;
  xercesc::DOMElement* aGP = theDoc->createElement(_toDOMS("GP"));
  stringStr.str("");
  stringStr << aKey.thePtCode;
  aGP->setAttribute(_toDOMS("iPt"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aKey.theEtaCode;
  aGP->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << "0";
  aGP->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aKey.theCharge;
  aGP->setAttribute(_toDOMS("iCharge"), _toDOMS(stringStr.str()));
  for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
    xercesc::DOMElement* aRefLayer = theDoc->createElement(_toDOMS("Result"));
    stringStr.str("");
    stringStr << iRefLayer;
    aRefLayer->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
    stringStr.str("");
    stringStr << iRegion;
    aRefLayer->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));
    stringStr.str("");
    stringStr << myOMTFConfig->getRefToLogicNumber()[iRefLayer];
    aRefLayer->setAttribute(_toDOMS("iLogicLayer"), _toDOMS(stringStr.str()));
    for (unsigned int iLogicLayer = 0; iLogicLayer < myOMTFConfig->nLayers(); ++iLogicLayer) {
      xercesc::DOMElement* aLayer = theDoc->createElement(_toDOMS("Layer"));
      stringStr.str("");
      stringStr << iLogicLayer;
      aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
      stringStr.str("");
      stringStr << results[iLogicLayer][iRefLayer];
      aLayer->setAttribute(_toDOMS("value"), _toDOMS(stringStr.str()));
      if (results[iLogicLayer][iRefLayer])
        aRefLayer->appendChild(aLayer);
    }
    if (aRefLayer->getChildNodes()->getLength())
      aGP->appendChild(aRefLayer);
  }
  if (aGP->getChildNodes()->getLength())
    aTopElement->appendChild(aGP);
}
void XMLConfigWriter::writeGPData(const GoldenPattern& aGP) {
  std::ostringstream stringStr;
  xercesc::DOMElement *aLayer = nullptr, *aRefLayer = nullptr, *aPdf = nullptr;

  xercesc::DOMElement* aGPElement = theDoc->createElement(_toDOMS("GP"));
  stringStr.str("");
  stringStr << aGP.key().thePtCode;
  aGPElement->setAttribute(_toDOMS("iPt"), _toDOMS(stringStr.str()));
  stringStr.str("");
  //stringStr<<aGP.key().theEtaCode;
  stringStr << "0";  //No eta code at the moment
  aGPElement->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << 0;  //No phi code is assigned to GP for the moment.
  aGPElement->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aGP.key().theCharge;
  aGPElement->setAttribute(_toDOMS("iCharge"), _toDOMS(stringStr.str()));

  for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
    int nOfPhis = 0;
    aLayer = theDoc->createElement(_toDOMS("Layer"));
    stringStr.str("");
    stringStr << iLayer;
    aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
    stringStr.str("");
    stringStr << nOfPhis;
    aLayer->setAttribute(_toDOMS("nOfPhis"), _toDOMS(stringStr.str()));
    for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
      aRefLayer = theDoc->createElement(_toDOMS("RefLayer"));
      int meanDistPhi = aGP.meanDistPhiValue(iLayer, iRefLayer);
      stringStr.str("");
      stringStr << meanDistPhi;
      aRefLayer->setAttribute(_toDOMS("meanDistPhi"), _toDOMS(stringStr.str()));
      int selDistPhi = 0;
      stringStr.str("");
      stringStr << selDistPhi;
      aRefLayer->setAttribute(_toDOMS("selDistPhi"), _toDOMS(stringStr.str()));
      int selDistPhiShift = 0;
      stringStr.str("");
      stringStr << selDistPhiShift;
      aRefLayer->setAttribute(_toDOMS("selDistPhiShift"), _toDOMS(stringStr.str()));
      int distMsbPhiShift = 0;
      stringStr.str("");
      stringStr << distMsbPhiShift;
      aRefLayer->setAttribute(_toDOMS("distMsbPhiShift"), _toDOMS(stringStr.str()));
      aLayer->appendChild(aRefLayer);
    }
    for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
      for (unsigned int iPdf = 0; iPdf < exp2(myOMTFConfig->nPdfAddrBits()); ++iPdf) {
        aPdf = theDoc->createElement(_toDOMS("PDF"));
        stringStr.str("");
        stringStr << aGP.pdfValue(iLayer, iRefLayer, iPdf);
        aPdf->setAttribute(_toDOMS("value"), _toDOMS(stringStr.str()));
        aLayer->appendChild(aPdf);
      }
    }
    aGPElement->appendChild(aLayer);
  }
  theTopElement->appendChild(aGPElement);
}
void XMLConfigWriter::writeGPData(const GoldenPattern& aGP1,
                                  const GoldenPattern& aGP2,
                                  const GoldenPattern& aGP3,
                                  const GoldenPattern& aGP4) {
  std::ostringstream stringStr;
  xercesc::DOMElement *aLayer = nullptr, *aRefLayer = nullptr, *aPdf = nullptr;

  xercesc::DOMElement* aGPElement = theDoc->createElement(_toDOMS("GP"));
  stringStr.str("");

  stringStr << aGP1.key().thePtCode;
  aGPElement->setAttribute(_toDOMS("iPt1"), _toDOMS(stringStr.str()));
  stringStr.str("");

  stringStr << aGP2.key().thePtCode;
  aGPElement->setAttribute(_toDOMS("iPt2"), _toDOMS(stringStr.str()));
  stringStr.str("");

  stringStr << aGP3.key().thePtCode;
  aGPElement->setAttribute(_toDOMS("iPt3"), _toDOMS(stringStr.str()));
  stringStr.str("");

  stringStr << aGP4.key().thePtCode;
  aGPElement->setAttribute(_toDOMS("iPt4"), _toDOMS(stringStr.str()));

  stringStr.str("");
  //stringStr<<aGP1.key().theEtaCode;
  stringStr << "0";  //No eta code at the moment
  aGPElement->setAttribute(_toDOMS("iEta"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << "0";  //No phi code is assigned to GP for the moment.
  aGPElement->setAttribute(_toDOMS("iPhi"), _toDOMS(stringStr.str()));
  stringStr.str("");
  stringStr << aGP1.key().theCharge;

  aGPElement->setAttribute(_toDOMS("iCharge"), _toDOMS(stringStr.str()));

  for (unsigned int iLayer = 0; iLayer < myOMTFConfig->nLayers(); ++iLayer) {
    int nOfPhis = 0;
    aLayer = theDoc->createElement(_toDOMS("Layer"));
    stringStr.str("");
    stringStr << iLayer;
    aLayer->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
    stringStr.str("");
    stringStr << nOfPhis;
    aLayer->setAttribute(_toDOMS("nOfPhis"), _toDOMS(stringStr.str()));
    for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
      aRefLayer = theDoc->createElement(_toDOMS("RefLayer"));
      int meanDistPhi = aGP1.meanDistPhiValue(iLayer, iRefLayer);

      stringStr.str("");
      stringStr << meanDistPhi;
      aRefLayer->setAttribute(_toDOMS("meanDistPhi"), _toDOMS(stringStr.str()));

      //int meanDistPhi2 = aGP2.meanDistPhiValue(iLayer,iRefLayer);
      //stringStr.str("");
      //stringStr<<meanDistPhi2;
      //aRefLayer->setAttribute(_toDOMS("meanDistPhi2"), _toDOMS(stringStr.str()));

      int selDistPhi = 0;
      stringStr.str("");
      stringStr << selDistPhi;
      aRefLayer->setAttribute(_toDOMS("selDistPhi"), _toDOMS(stringStr.str()));
      int selDistPhiShift = 0;
      stringStr.str("");
      stringStr << selDistPhiShift;
      aRefLayer->setAttribute(_toDOMS("selDistPhiShift"), _toDOMS(stringStr.str()));
      int distMsbPhiShift = 0;
      stringStr.str("");
      stringStr << distMsbPhiShift;
      aRefLayer->setAttribute(_toDOMS("distMsbPhiShift"), _toDOMS(stringStr.str()));
      aLayer->appendChild(aRefLayer);
    }
    for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
      for (unsigned int iPdf = 0; iPdf < exp2(myOMTFConfig->nPdfAddrBits()); ++iPdf) {
        aPdf = theDoc->createElement(_toDOMS("PDF"));
        stringStr.str("");
        stringStr << aGP1.pdfValue(iLayer, iRefLayer, iPdf);
        aPdf->setAttribute(_toDOMS("value1"), _toDOMS(stringStr.str()));
        stringStr.str("");
        stringStr << aGP2.pdfValue(iLayer, iRefLayer, iPdf);
        aPdf->setAttribute(_toDOMS("value2"), _toDOMS(stringStr.str()));
        stringStr.str("");
        stringStr << aGP3.pdfValue(iLayer, iRefLayer, iPdf);
        aPdf->setAttribute(_toDOMS("value3"), _toDOMS(stringStr.str()));
        stringStr.str("");
        stringStr << aGP4.pdfValue(iLayer, iRefLayer, iPdf);
        aPdf->setAttribute(_toDOMS("value4"), _toDOMS(stringStr.str()));
        aLayer->appendChild(aPdf);
      }
    }
    aGPElement->appendChild(aLayer);
  }
  theTopElement->appendChild(aGPElement);
}
void XMLConfigWriter::writeConnectionsData(
    const std::vector<std::vector<OMTFConfiguration::vector2D> >& measurements4D) {
  std::ostringstream stringStr;

  for (unsigned int iProcessor = 0; iProcessor < 6; ++iProcessor) {
    xercesc::DOMElement* aProcessorElement = theDoc->createElement(_toDOMS("Processor"));
    stringStr.str("");
    stringStr << iProcessor;
    aProcessorElement->setAttribute(_toDOMS("iProcessor"), _toDOMS(stringStr.str()));
    for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
      xercesc::DOMElement* aRefLayerElement = theDoc->createElement(_toDOMS("RefLayer"));
      stringStr.str("");
      stringStr << iRefLayer;
      aRefLayerElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));
      stringStr.str("");
      stringStr << myOMTFConfig->getProcessorPhiVsRefLayer()[iProcessor][iRefLayer];
      aRefLayerElement->setAttribute(_toDOMS("iGlobalPhiStart"), _toDOMS(stringStr.str()));
      aProcessorElement->appendChild(aRefLayerElement);
    }
    unsigned int iRefHit = 0;
    for (unsigned int iRefLayer = 0; iRefLayer < myOMTFConfig->nRefLayers(); ++iRefLayer) {
      for (unsigned int iRegion = 0; iRegion < 6; ++iRegion) {
        unsigned int maxHitCount = 0;
        for (unsigned int iInput = 0; iInput < 14; ++iInput) {
          if ((int)maxHitCount < myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput])
            maxHitCount = myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput];
        }
        for (unsigned int iInput = 0; iInput < 14; ++iInput) {
          unsigned int hitCount = myOMTFConfig->getMeasurements4Dref()[iProcessor][iRegion][iRefLayer][iInput];
          if (hitCount < maxHitCount * 0.1)
            continue;
          xercesc::DOMElement* aRefHitElement = theDoc->createElement(_toDOMS("RefHit"));
          stringStr.str("");
          stringStr << iRefHit;
          aRefHitElement->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
          stringStr.str("");
          stringStr << iRefLayer;
          aRefHitElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));

          stringStr.str("");
          stringStr << iRegion;
          aRefHitElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));

          stringStr.str("");
          stringStr << iInput;
          aRefHitElement->setAttribute(_toDOMS("iInput"), _toDOMS(stringStr.str()));
          unsigned int logicRegionSize = 10 / 360.0 * myOMTFConfig->nPhiBins();
          int lowScaleEnd = std::pow(2, myOMTFConfig->nPhiBits() - 1);
          int iPhiMin = myOMTFConfig->getProcessorPhiVsRefLayer()[iProcessor][iRefLayer] -
                        myOMTFConfig->globalPhiStart(iProcessor) - lowScaleEnd;
          int iPhiMax = iPhiMin + logicRegionSize - 1;

          iPhiMin += iRegion * logicRegionSize;
          iPhiMax += iRegion * logicRegionSize;

          stringStr.str("");
          stringStr << iPhiMin;
          aRefHitElement->setAttribute(_toDOMS("iPhiMin"), _toDOMS(stringStr.str()));

          stringStr.str("");
          stringStr << iPhiMax;
          aRefHitElement->setAttribute(_toDOMS("iPhiMax"), _toDOMS(stringStr.str()));
          if (iRefHit < myOMTFConfig->nRefHits())
            aProcessorElement->appendChild(aRefHitElement);
          ++iRefHit;
        }
        for (; iRegion == 5 && iRefLayer == 7 && iRefHit < myOMTFConfig->nRefHits(); ++iRefHit) {
          xercesc::DOMElement* aRefHitElement = theDoc->createElement(_toDOMS("RefHit"));
          stringStr.str("");
          stringStr << iRefHit;
          aRefHitElement->setAttribute(_toDOMS("iRefHit"), _toDOMS(stringStr.str()));
          stringStr.str("");
          stringStr << 0;
          aRefHitElement->setAttribute(_toDOMS("iRefLayer"), _toDOMS(stringStr.str()));

          stringStr.str("");
          stringStr << 0;
          aRefHitElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));

          stringStr.str("");
          stringStr << 0;
          aRefHitElement->setAttribute(_toDOMS("iInput"), _toDOMS(stringStr.str()));

          int iPhiMin = 0;
          int iPhiMax = 1;

          stringStr.str("");
          stringStr << iPhiMin;
          aRefHitElement->setAttribute(_toDOMS("iPhiMin"), _toDOMS(stringStr.str()));

          stringStr.str("");
          stringStr << iPhiMax;
          aRefHitElement->setAttribute(_toDOMS("iPhiMax"), _toDOMS(stringStr.str()));

          aProcessorElement->appendChild(aRefHitElement);
        }
      }
    }
    for (unsigned int iRegion = 0; iRegion < 6; ++iRegion) {
      xercesc::DOMElement* aRegionElement = theDoc->createElement(_toDOMS("LogicRegion"));
      stringStr.str("");
      stringStr << iRegion;
      aRegionElement->setAttribute(_toDOMS("iRegion"), _toDOMS(stringStr.str()));

      for (unsigned int iLogicLayer = 0; iLogicLayer < myOMTFConfig->nLayers(); ++iLogicLayer) {
        xercesc::DOMElement* aLayerElement = theDoc->createElement(_toDOMS("Layer"));
        stringStr.str("");
        stringStr << iLogicLayer;
        aLayerElement->setAttribute(_toDOMS("iLayer"), _toDOMS(stringStr.str()));
        const OMTFConfiguration::vector1D& myCounts =
            myOMTFConfig->getMeasurements4D()[iProcessor][iRegion][iLogicLayer];
        unsigned int maxInput = findMaxInput(myCounts);
        unsigned int begin = 0, end = 0;
        if ((int)maxInput - 2 >= 0)
          begin = maxInput - 2;
        else
          begin = maxInput;
        end = maxInput + 3;
        stringStr.str("");
        stringStr << begin;
        aLayerElement->setAttribute(_toDOMS("iFirstInput"), _toDOMS(stringStr.str()));
        stringStr.str("");
        stringStr << end - begin + 1;
        aLayerElement->setAttribute(_toDOMS("nInputs"), _toDOMS(stringStr.str()));
        aRegionElement->appendChild(aLayerElement);
      }
      aProcessorElement->appendChild(aRegionElement);
    }
    theTopElement->appendChild(aProcessorElement);
  }
}
unsigned int XMLConfigWriter::findMaxInput(const OMTFConfiguration::vector1D& myCounts) {
  unsigned int max = 0;
  unsigned int maxInput = 0;
  for (unsigned int iInput = 0; iInput < 14; ++iInput) {
    if (myCounts[iInput] > (int)max) {
      max = myCounts[iInput];
      maxInput = iInput;
    }
  }
  return maxInput;
}