XMLConfigReader Class Reference

#include <XMLConfigReader.h>

Public Member Functions
template<class GoldenPatternType >
std::unique_ptr< GoldenPatternType >	buildGP (DOMElement *aGPElement, const L1TMuonOverlapParams &aConfig, unsigned int patternGroup, unsigned int index, unsigned int aGPNumber)
unsigned int	getPatternsVersion () const
unsigned int	getPatternsVersion () const
void	readConfig (const std::string fName)
void	readConfig (const std::string fName)
void	readConfig (L1TMuonOverlapParams *aConfig) const
void	readConfig (L1TMuonOverlapParams *aConfig) const
std::vector< std::vector< int > >	readEvent (unsigned int iEvent=0, unsigned int iProcessor=0, bool readEta=false)
std::vector< std::vector< int > >	readEvent (unsigned int iEvent=0, unsigned int iProcessor=0, bool readEta=false)
void	readLUTs (std::vector< l1t::LUT *> luts, const L1TMuonOverlapParams &aConfig, const std::vector< std::string > &types)
void	readLUTs (std::vector< l1t::LUT *> luts, const L1TMuonOverlapParams &aConfig, const std::vector< std::string > &types)
std::vector< std::shared_ptr< GoldenPattern > >	readPatterns (const L1TMuonOverlapParams &aConfig)
template<class GoldenPatternType >
GoldenPatternVec< GoldenPatternType >	readPatterns (const L1TMuonOverlapParams &aConfig, const std::string &patternsFile, bool buildEmptyPatterns, bool resetNumbering=true)
template<class GoldenPatternType >
GoldenPatternVec< GoldenPatternType >	readPatterns (const L1TMuonOverlapParams &aConfig, const std::vector< std::string > &patternsFiles, bool buildEmptyPatterns)
void	setConfigFile (const std::string &fName)
void	setConfigFile (const std::string &fName)
void	setEventsFile (const std::string &fName)
void	setEventsFile (const std::string &fName)
void	setPatternsFile (const std::string &fName)
void	setPatternsFiles (std::vector< std::string > &fNames)
	XMLConfigReader ()
	XMLConfigReader ()
	~XMLConfigReader ()
	~XMLConfigReader ()

Private Member Functions
std::unique_ptr< GoldenPattern >	buildGP (xercesc::DOMElement *aGPElement, const L1TMuonOverlapParams &aConfig, unsigned int index=0, unsigned int aGPNumber=999)
template<class GoldenPatternType >
std::unique_ptr< GoldenPatternType >	buildGP (xercesc::DOMElement *aGPElement, const L1TMuonOverlapParams &aConfig, unsigned int patternGroup, unsigned int index=0, unsigned int aGPNumber=999)

Private Attributes
std::vector< std::shared_ptr< GoldenPattern > >	aGPs
	Cache with GPs read. More...
std::string	configFile
std::string	eventsFile
unsigned int	iGPNumber = 0
unsigned int	iPatternGroup = 0
std::string	patternsFile
std::vector< std::string >	patternsFiles

Detailed Description

Definition at line 26 of file XMLConfigReader.h.

Constructor & Destructor Documentation

XMLConfigReader() [1/2]

XMLConfigReader::XMLConfigReader

(

)

Initialise XML parser

Definition at line 42 of file XMLConfigReader.cc.

                                 {
  //XMLPlatformUtils::Initialize();

  //parser = new XercesDOMParser();
  //parser->setValidationScheme(XercesDOMParser::Val_Auto);
  //parser->setDoNamespaces(false);

  //doc = 0;
}

~XMLConfigReader() [1/2]

XMLConfigReader::~XMLConfigReader

(

)

Definition at line 53 of file XMLConfigReader.cc.

                                  {
  //  delete parser;
  //XMLPlatformUtils::Terminate();
}

XMLConfigReader() [2/2]

XMLConfigReader::XMLConfigReader

(

)

~XMLConfigReader() [2/2]

XMLConfigReader::~XMLConfigReader

(

)

Member Function Documentation

buildGP() [1/3]

std::unique_ptr<GoldenPattern> XMLConfigReader::buildGP ( xercesc::DOMElement *  aGPElement, const L1TMuonOverlapParams &  aConfig, unsigned int  index = 0, unsigned int  aGPNumber = 999  )

private

Referenced by readPatterns().

buildGP() [2/3]

template<class GoldenPatternType >

std::unique_ptr<GoldenPatternType> XMLConfigReader::buildGP ( xercesc::DOMElement *  aGPElement, const L1TMuonOverlapParams &  aConfig, unsigned int  patternGroup, unsigned int  index = 0, unsigned int  aGPNumber = 999  )

private

buildGP() [3/3]

template<class GoldenPatternType >

std::unique_ptr<GoldenPatternType> XMLConfigReader::buildGP	(	DOMElement *	aGPElement,
		const L1TMuonOverlapParams &	aConfig,
		unsigned int	patternGroup,
		unsigned int	index,
		unsigned int	aGPNumber
	)

Build empty GP

Loop over layers

MeanDistPhi vector

PDF vector

Definition at line 331 of file XMLConfigReader.cc.

References _toDOMS(), _toString(), cms::cuda::assert(), Exception, l1tPhase2CaloJetEmulator_cfi::iEta, MuonTCMETValueMapProducer_cff::nLayers, L1TMuonOverlapParams::nLayers(), L1TMuonOverlapParams::nPdfAddrBits(), L1TMuonOverlapParams::nRefLayers(), fetchall_from_DQM_v2::release, AlCaHLTBitMon_QueryRunRegistry::string, Key::theGroup, Key::theIndexInGroup, particleFlowZeroSuppressionECAL_cff::thresholds, and heppy_batch::val.

                                                                                    {
  XMLCh *xmliEta = _toDOMS("iEta");
  //index 0 means no number at the end
  std::ostringstream stringStr;
  if (index > 0)
    stringStr << "iPt" << index;
  else
    stringStr.str("iPt");
  XMLCh *xmliPt = _toDOMS(stringStr.str());
  stringStr.str("");

  if (index > 0)
    stringStr << "value" << index;
  else
    stringStr.str("value");
  XMLCh *xmlValue = _toDOMS(stringStr.str());

  XMLCh *xmliCharge = _toDOMS("iCharge");
  XMLCh *xmlLayer = _toDOMS("Layer");
  XMLCh *xmlRefLayer = _toDOMS("RefLayer");
  XMLCh *xmlmeanDistPhi = _toDOMS("meanDistPhi");  //for old version

  XMLCh *xmlmeanDistPhi0 = _toDOMS("meanDistPhi0");  //for new version
  XMLCh *xmlmeanDistPhi1 = _toDOMS("meanDistPhi1");  //for new version

  XMLCh *xmlSelDistPhiShift = _toDOMS("selDistPhiShift");

  XMLCh *xmlPDF = _toDOMS("PDF");

  unsigned int iPt = std::atoi(_toString(aGPElement->getAttribute(xmliPt)).c_str());
  int iEta = std::atoi(_toString(aGPElement->getAttribute(xmliEta)).c_str());
  int iCharge = std::atoi(_toString(aGPElement->getAttribute(xmliCharge)).c_str());
  unsigned int nLayers = aGPElement->getElementsByTagName(xmlLayer)->getLength();

  if (nLayers)
    assert(nLayers == (unsigned)aConfig.nLayers());

  DOMNode *aNode = nullptr;
  DOMElement *aLayerElement = nullptr;
  DOMElement *aItemElement = nullptr;

  if (iPt == 0) {  
    Key aKey(iEta, iPt, iCharge, aGPNumber);
    auto aGP =
        std::make_unique<GoldenPatternType>(aKey, aConfig.nLayers(), aConfig.nRefLayers(), aConfig.nPdfAddrBits());
    return aGP;
  }

  stringStr.str("");
  XMLCh *xmlRefLayerThresh = _toDOMS("RefLayerThresh");
  if (index > 0)
    stringStr << "tresh" << index;
  else
    stringStr.str("tresh");
  XMLCh *xmlTresh = _toDOMS(stringStr.str());
  stringStr.str("");

  std::vector<PdfValueType> thresholds(aConfig.nRefLayers(), 0);
  unsigned int nItems = aGPElement->getElementsByTagName(xmlRefLayerThresh)->getLength();
  if (nItems > 0 && nItems != thresholds.size()) {
    throw cms::Exception("OMTF::XMLConfigReader: nItems != thresholds.size()");
  }
  for (unsigned int iItem = 0; iItem < nItems; ++iItem) {
    aNode = aGPElement->getElementsByTagName(xmlRefLayerThresh)->item(iItem);
    aItemElement = dynamic_cast<DOMElement *>(aNode);
    if (aItemElement == nullptr)
      throw cms::Exception("OMTF::XMLConfigReader: aItemElement is 0");
    std::string strVal = _toString(aItemElement->getAttribute(xmlTresh));
    thresholds[iItem] = std::stof(strVal);
  }

  Key aKey(iEta, iPt, iCharge, aGPNumber);
  aKey.theGroup = patternGroup;
  aKey.theIndexInGroup = index;
  auto aGP = std::make_unique<GoldenPatternType>(aKey, aConfig.nLayers(), aConfig.nRefLayers(), aConfig.nPdfAddrBits());
  if (dynamic_cast<GoldenPatternWithThresh *>(aGP.get())) {
    dynamic_cast<GoldenPatternWithThresh *>(aGP.get())->setThresholds(thresholds);
  }
  for (unsigned int iLayer = 0; iLayer < nLayers; ++iLayer) {
    aNode = aGPElement->getElementsByTagName(xmlLayer)->item(iLayer);
    aLayerElement = static_cast<DOMElement *>(aNode);
    unsigned int nItems = aLayerElement->getElementsByTagName(xmlRefLayer)->getLength();
    assert(nItems == (unsigned)aConfig.nRefLayers());
    for (unsigned int iItem = 0; iItem < nItems; ++iItem) {
      aNode = aLayerElement->getElementsByTagName(xmlRefLayer)->item(iItem);
      aItemElement = static_cast<DOMElement *>(aNode);

      std::string strVal = _toString(aItemElement->getAttribute(xmlmeanDistPhi));
      if (!strVal.empty()) {
        aGP->setMeanDistPhiValue(std::stoi(strVal), iLayer, iItem, 0);
      } else {
        strVal = _toString(aItemElement->getAttribute(xmlmeanDistPhi0));
        aGP->setMeanDistPhiValue(std::stoi(strVal), iLayer, iItem, 0);
        strVal = _toString(aItemElement->getAttribute(xmlmeanDistPhi1));
        aGP->setMeanDistPhiValue(std::stoi(strVal), iLayer, iItem, 1);
      }

      strVal = _toString(aItemElement->getAttribute(xmlSelDistPhiShift));
      if (!strVal.empty()) {
        aGP->setDistPhiBitShift(std::stoi(strVal), iLayer, iItem);
      }
    }

    nItems = aLayerElement->getElementsByTagName(xmlPDF)->getLength();

    assert(nItems == aConfig.nRefLayers() * exp2(aConfig.nPdfAddrBits()));
    for (unsigned int iRefLayer = 0; iRefLayer < (unsigned)aConfig.nRefLayers(); ++iRefLayer) {
      for (unsigned int iPdf = 0; iPdf < exp2(aConfig.nPdfAddrBits()); ++iPdf) {
        aNode = aLayerElement->getElementsByTagName(xmlPDF)->item(iRefLayer * exp2(aConfig.nPdfAddrBits()) + iPdf);
        aItemElement = static_cast<DOMElement *>(aNode);
        PdfValueType val = std::atof(_toString(aItemElement->getAttribute(xmlValue)).c_str());
        aGP->setPdfValue(val, iLayer, iRefLayer, iPdf);
      }
    }
  }
  XMLString::release(&xmliEta);
  XMLString::release(&xmliPt);
  XMLString::release(&xmliCharge);
  XMLString::release(&xmlLayer);
  XMLString::release(&xmlRefLayer);
  XMLString::release(&xmlmeanDistPhi);
  XMLString::release(&xmlPDF);
  XMLString::release(&xmlValue);

  return aGP;
}

getPatternsVersion() [1/2]

unsigned int XMLConfigReader::getPatternsVersion

(

)

const

Definition at line 132 of file XMLConfigReader.cc.

References _toDOMS(), _toString(), cms::cuda::assert(), ALCARECOEcalPhiSym_cff::doc, writedatasetfile::parser, patternsFile, fetchall_from_DQM_v2::release, and relval_steps::version.

Referenced by L1TMuonOverlapParamsESProducer::L1TMuonOverlapParamsESProducer(), and L1TMuonOverlapPhase1ParamsESProducer::L1TMuonOverlapPhase1ParamsESProducer().

                                                       {
  if (patternsFile.empty())
    return 0;

  unsigned int version = 0;
  XMLPlatformUtils::Initialize();
  {
    XercesDOMParser parser;
    parser.setValidationScheme(XercesDOMParser::Val_Auto);
    parser.setDoNamespaces(false);

    parser.parse(patternsFile.c_str());
    xercesc::DOMDocument *doc = parser.getDocument();
    assert(doc);

    XMLCh *xmlOmtf = _toDOMS("OMTF");
    XMLCh *xmlVersion = _toDOMS("version");
    DOMNode *aNode = doc->getElementsByTagName(xmlOmtf)->item(0);
    DOMElement *aOMTFElement = static_cast<DOMElement *>(aNode);

    version = std::stoul(_toString(aOMTFElement->getAttribute(xmlVersion)), nullptr, 16);
    XMLString::release(&xmlOmtf);
    XMLString::release(&xmlVersion);
    parser.resetDocumentPool();
  }
  XMLPlatformUtils::Terminate();

  return version;
}

getPatternsVersion() [2/2]

unsigned int XMLConfigReader::getPatternsVersion

(

)

const

readConfig() [1/4]

void XMLConfigReader::readConfig

(

const std::string

fName

)

Referenced by OMTFReconstruction::beginRun(), L1TMuonOverlapParamsESProducer::readConnectionsXML(), and L1TMuonOverlapPhase1ParamsESProducer::readConnectionsXML().

readConfig() [2/4]

void XMLConfigReader::readConfig

(

const std::string

fName

)

readConfig() [3/4]

void XMLConfigReader::readConfig

(

L1TMuonOverlapParams *

aConfig

)

const

Addresing bits numbers

Chamber sectors connections to logic processros. Start/End values for all processors, and chamber types are put into a single vector

hw <-> logic numbering map

ref<->logic numberig map

Definition at line 340 of file XMLConfigReader.cc.

References _toDOMS(), _toString(), cms::cuda::assert(), L1TMuonOverlapParams::LayerMapNode::bendingLayer, configFile, L1TMuonOverlapParams::LayerMapNode::connectedToLayer, ALCARECOEcalPhiSym_cff::doc, L1TMuonOverlapParams::GENERAL_ADDRBITS, L1TMuonOverlapParams::GENERAL_HITSPERLAYER, L1TMuonOverlapParams::GENERAL_NCONFIG, L1TMuonOverlapParams::GENERAL_NGOLDENPATTERNS, L1TMuonOverlapParams::GENERAL_NINPUTS, L1TMuonOverlapParams::GENERAL_NLAYERS, L1TMuonOverlapParams::GENERAL_NLOGIC_REGIONS, L1TMuonOverlapParams::GENERAL_NPROCESSORS, L1TMuonOverlapParams::GENERAL_NREFHITS, L1TMuonOverlapParams::GENERAL_NREFLAYERS, L1TMuonOverlapParams::GENERAL_NTESTREFHITS, L1TMuonOverlapParams::GENERAL_PHIBINS, L1TMuonOverlapParams::GENERAL_PHIBITS, L1TMuonOverlapParams::GENERAL_VALBITS, L1TMuonOverlapParams::LayerMapNode::hwNumber, mps_fire::i, L1TMuonOverlapParams::LayerInputNode::iFirstInput, cuy::ii, L1TMuonOverlapParams::RefHitNode::iInput, L1TMuonOverlapParams::LayerInputNode::iLayer, L1TMuonOverlapParams::RefHitNode::iPhiMax, L1TMuonOverlapParams::RefHitNode::iPhiMin, L1TMuonOverlapParams::RefHitNode::iRefHit, L1TMuonOverlapParams::RefHitNode::iRefLayer, L1TMuonOverlapParams::RefHitNode::iRegion, L1TMuonOverlapParams::LayerMapNode::logicNumber, L1TMuonOverlapParams::RefLayerMapNode::logicNumber, L1TMuonOverlapParams::LayerInputNode::nInputs, MuonTCMETValueMapProducer_cff::nLayers, ecaldqm::binning::nPhiBins, writedatasetfile::parser, L1TMuonOverlapParams::RefLayerMapNode::refLayer, fetchall_from_DQM_v2::release, L1TMuonOverlapParams::setConnectedSectorsEnd(), L1TMuonOverlapParams::setConnectedSectorsStart(), L1TMuonOverlapParams::setFwVersion(), L1TMuonOverlapParams::setGeneralParams(), L1TMuonOverlapParams::setGlobalPhiStartMap(), L1TMuonOverlapParams::setLayerInputMap(), L1TMuonOverlapParams::setLayerMap(), L1TMuonOverlapParams::setRefHitMap(), L1TMuonOverlapParams::setRefLayerMap(), and relval_steps::version.

                                                                    {
  XMLPlatformUtils::Initialize();
  {
    XercesDOMParser parser;
    parser.setValidationScheme(XercesDOMParser::Val_Auto);
    parser.setDoNamespaces(false);

    XMLCh *xmlOMTF = _toDOMS("OMTF");
    XMLCh *xmlversion = _toDOMS("version");
    XMLCh *xmlGlobalData = _toDOMS("GlobalData");
    XMLCh *xmlnPdfAddrBits = _toDOMS("nPdfAddrBits");
    XMLCh *xmlnPdfValBits = _toDOMS("nPdfValBits");
    XMLCh *xmlnPhiBits = _toDOMS("nPhiBits");
    XMLCh *xmlnPhiBins = _toDOMS("nPhiBins");
    XMLCh *xmlnProcessors = _toDOMS("nProcessors");
    XMLCh *xmlnLogicRegions = _toDOMS("nLogicRegions");
    XMLCh *xmlnInputs = _toDOMS("nInputs");
    XMLCh *xmlnLayers = _toDOMS("nLayers");
    XMLCh *xmlnRefLayers = _toDOMS("nRefLayers");
    XMLCh *xmliProcessor = _toDOMS("iProcessor");
    XMLCh *xmlbarrelMin = _toDOMS("barrelMin");
    XMLCh *xmlbarrelMax = _toDOMS("barrelMax");
    XMLCh *xmlendcap10DegMin = _toDOMS("endcap10DegMin");
    XMLCh *xmlendcap10DegMax = _toDOMS("endcap10DegMax");
    XMLCh *xmlendcap20DegMin = _toDOMS("endcap20DegMin");
    XMLCh *xmlendcap20DegMax = _toDOMS("endcap20DegMax");
    XMLCh *xmlLayerMap = _toDOMS("LayerMap");
    XMLCh *xmlhwNumber = _toDOMS("hwNumber");
    XMLCh *xmllogicNumber = _toDOMS("logicNumber");
    XMLCh *xmlbendingLayer = _toDOMS("bendingLayer");
    XMLCh *xmlconnectedToLayer = _toDOMS("connectedToLayer");
    XMLCh *xmlRefLayerMap = _toDOMS("RefLayerMap");
    XMLCh *xmlrefLayer = _toDOMS("refLayer");
    XMLCh *xmlProcessor = _toDOMS("Processor");
    XMLCh *xmlRefLayer = _toDOMS("RefLayer");
    XMLCh *xmliRefLayer = _toDOMS("iRefLayer");
    XMLCh *xmliGlobalPhiStart = _toDOMS("iGlobalPhiStart");
    XMLCh *xmlRefHit = _toDOMS("RefHit");
    XMLCh *xmliRefHit = _toDOMS("iRefHit");
    XMLCh *xmliPhiMin = _toDOMS("iPhiMin");
    XMLCh *xmliPhiMax = _toDOMS("iPhiMax");
    XMLCh *xmliInput = _toDOMS("iInput");
    XMLCh *xmliRegion = _toDOMS("iRegion");
    XMLCh *xmlLogicRegion = _toDOMS("LogicRegion");
    XMLCh *xmlLayer = _toDOMS("Layer");
    XMLCh *xmliLayer = _toDOMS("iLayer");
    XMLCh *xmliFirstInput = _toDOMS("iFirstInput");
    XMLCh *xmlnHitsPerLayer = _toDOMS("nHitsPerLayer");
    XMLCh *xmlnRefHits = _toDOMS("nRefHits");
    XMLCh *xmlnTestRefHits = _toDOMS("nTestRefHits");
    XMLCh *xmlnGoldenPatterns = _toDOMS("nGoldenPatterns");
    XMLCh *xmlConnectionMap = _toDOMS("ConnectionMap");
    parser.parse(configFile.c_str());
    xercesc::DOMDocument *doc = parser.getDocument();
    assert(doc);
    unsigned int nElem = doc->getElementsByTagName(xmlOMTF)->getLength();
    if (nElem != 1) {
      edm::LogError("critical") << "Problem parsing XML file " << configFile << std::endl;
      assert(nElem == 1);
    }
    DOMNode *aNode = doc->getElementsByTagName(xmlOMTF)->item(0);
    DOMElement *aOMTFElement = static_cast<DOMElement *>(aNode);

    unsigned int version = std::stoul(_toString(aOMTFElement->getAttribute(xmlversion)), nullptr, 16);
    aConfig->setFwVersion(version);

    nElem = aOMTFElement->getElementsByTagName(xmlGlobalData)->getLength();
    assert(nElem == 1);
    aNode = aOMTFElement->getElementsByTagName(xmlGlobalData)->item(0);
    DOMElement *aElement = static_cast<DOMElement *>(aNode);

    unsigned int nPdfAddrBits = std::atoi(_toString(aElement->getAttribute(xmlnPdfAddrBits)).c_str());
    unsigned int nPdfValBits = std::atoi(_toString(aElement->getAttribute(xmlnPdfValBits)).c_str());
    unsigned int nHitsPerLayer = std::atoi(_toString(aElement->getAttribute(xmlnHitsPerLayer)).c_str());
    unsigned int nPhiBits = std::atoi(_toString(aElement->getAttribute(xmlnPhiBits)).c_str());
    unsigned int nPhiBins = std::atoi(_toString(aElement->getAttribute(xmlnPhiBins)).c_str());

    unsigned int nRefHits = std::atoi(_toString(aElement->getAttribute(xmlnRefHits)).c_str());
    unsigned int nTestRefHits = std::atoi(_toString(aElement->getAttribute(xmlnTestRefHits)).c_str());
    unsigned int nProcessors = std::atoi(_toString(aElement->getAttribute(xmlnProcessors)).c_str());
    unsigned int nLogicRegions = std::atoi(_toString(aElement->getAttribute(xmlnLogicRegions)).c_str());
    unsigned int nInputs = std::atoi(_toString(aElement->getAttribute(xmlnInputs)).c_str());
    unsigned int nLayers = std::atoi(_toString(aElement->getAttribute(xmlnLayers)).c_str());
    unsigned int nRefLayers = std::atoi(_toString(aElement->getAttribute(xmlnRefLayers)).c_str());
    unsigned int nGoldenPatterns = std::atoi(_toString(aElement->getAttribute(xmlnGoldenPatterns)).c_str());

    std::vector<int> paramsVec(L1TMuonOverlapParams::GENERAL_NCONFIG);
    paramsVec[L1TMuonOverlapParams::GENERAL_ADDRBITS] = nPdfAddrBits;
    paramsVec[L1TMuonOverlapParams::GENERAL_VALBITS] = nPdfValBits;
    paramsVec[L1TMuonOverlapParams::GENERAL_HITSPERLAYER] = nHitsPerLayer;
    paramsVec[L1TMuonOverlapParams::GENERAL_PHIBITS] = nPhiBits;
    paramsVec[L1TMuonOverlapParams::GENERAL_PHIBINS] = nPhiBins;
    paramsVec[L1TMuonOverlapParams::GENERAL_NREFHITS] = nRefHits;
    paramsVec[L1TMuonOverlapParams::GENERAL_NTESTREFHITS] = nTestRefHits;
    paramsVec[L1TMuonOverlapParams::GENERAL_NPROCESSORS] = nProcessors;
    paramsVec[L1TMuonOverlapParams::GENERAL_NLOGIC_REGIONS] = nLogicRegions;
    paramsVec[L1TMuonOverlapParams::GENERAL_NINPUTS] = nInputs;
    paramsVec[L1TMuonOverlapParams::GENERAL_NLAYERS] = nLayers;
    paramsVec[L1TMuonOverlapParams::GENERAL_NREFLAYERS] = nRefLayers;
    paramsVec[L1TMuonOverlapParams::GENERAL_NGOLDENPATTERNS] = nGoldenPatterns;
    aConfig->setGeneralParams(paramsVec);

    std::vector<int> sectorsStart(3 * nProcessors), sectorsEnd(3 * nProcessors);
    nElem = aOMTFElement->getElementsByTagName(xmlConnectionMap)->getLength();
    DOMElement *aConnectionElement = nullptr;
    for (unsigned int i = 0; i < nElem; ++i) {
      aNode = aOMTFElement->getElementsByTagName(xmlConnectionMap)->item(i);
      aConnectionElement = static_cast<DOMElement *>(aNode);
      unsigned int iProcessor = std::atoi(_toString(aConnectionElement->getAttribute(xmliProcessor)).c_str());
      unsigned int barrelMin = std::atoi(_toString(aConnectionElement->getAttribute(xmlbarrelMin)).c_str());
      unsigned int barrelMax = std::atoi(_toString(aConnectionElement->getAttribute(xmlbarrelMax)).c_str());
      unsigned int endcap10DegMin = std::atoi(_toString(aConnectionElement->getAttribute(xmlendcap10DegMin)).c_str());
      unsigned int endcap10DegMax = std::atoi(_toString(aConnectionElement->getAttribute(xmlendcap10DegMax)).c_str());
      unsigned int endcap20DegMin = std::atoi(_toString(aConnectionElement->getAttribute(xmlendcap20DegMin)).c_str());
      unsigned int endcap20DegMax = std::atoi(_toString(aConnectionElement->getAttribute(xmlendcap20DegMax)).c_str());

      sectorsStart[iProcessor] = barrelMin;
      sectorsStart[iProcessor + nProcessors] = endcap10DegMin;
      sectorsStart[iProcessor + 2 * nProcessors] = endcap20DegMin;

      sectorsEnd[iProcessor] = barrelMax;
      sectorsEnd[iProcessor + nProcessors] = endcap10DegMax;
      sectorsEnd[iProcessor + 2 * nProcessors] = endcap20DegMax;
    }
    aConfig->setConnectedSectorsStart(sectorsStart);
    aConfig->setConnectedSectorsEnd(sectorsEnd);

    std::vector<L1TMuonOverlapParams::LayerMapNode> aLayerMapVec;
    L1TMuonOverlapParams::LayerMapNode aLayerMapNode;

    nElem = aOMTFElement->getElementsByTagName(xmlLayerMap)->getLength();
    DOMElement *aLayerElement = nullptr;
    for (unsigned int i = 0; i < nElem; ++i) {
      aNode = aOMTFElement->getElementsByTagName(xmlLayerMap)->item(i);
      aLayerElement = static_cast<DOMElement *>(aNode);
      unsigned int hwNumber = std::atoi(_toString(aLayerElement->getAttribute(xmlhwNumber)).c_str());
      unsigned int logicNumber = std::atoi(_toString(aLayerElement->getAttribute(xmllogicNumber)).c_str());
      unsigned int isBendingLayer = std::atoi(_toString(aLayerElement->getAttribute(xmlbendingLayer)).c_str());
      unsigned int iConnectedLayer = std::atoi(_toString(aLayerElement->getAttribute(xmlconnectedToLayer)).c_str());
      aLayerMapNode.logicNumber = logicNumber;
      aLayerMapNode.hwNumber = hwNumber;
      aLayerMapNode.connectedToLayer = iConnectedLayer;
      aLayerMapNode.bendingLayer = isBendingLayer;
      aLayerMapVec.push_back(aLayerMapNode);
    }
    aConfig->setLayerMap(aLayerMapVec);

    std::vector<L1TMuonOverlapParams::RefLayerMapNode> aRefLayerMapVec;
    L1TMuonOverlapParams::RefLayerMapNode aRefLayerNode;

    nElem = aOMTFElement->getElementsByTagName(xmlRefLayerMap)->getLength();
    DOMElement *aRefLayerElement = nullptr;
    for (unsigned int i = 0; i < nElem; ++i) {
      aNode = aOMTFElement->getElementsByTagName(xmlRefLayerMap)->item(i);
      aRefLayerElement = static_cast<DOMElement *>(aNode);
      unsigned int refLayer = std::atoi(_toString(aRefLayerElement->getAttribute(xmlrefLayer)).c_str());
      unsigned int logicNumber = std::atoi(_toString(aRefLayerElement->getAttribute(xmllogicNumber)).c_str());
      aRefLayerNode.refLayer = refLayer;
      aRefLayerNode.logicNumber = logicNumber;
      aRefLayerMapVec.push_back(aRefLayerNode);
    }
    aConfig->setRefLayerMap(aRefLayerMapVec);

    std::vector<int> aGlobalPhiStartVec(nProcessors * nRefLayers);

    std::vector<L1TMuonOverlapParams::RefHitNode> aRefHitMapVec(nProcessors * nRefHits);
    L1TMuonOverlapParams::RefHitNode aRefHitNode;

    std::vector<L1TMuonOverlapParams::LayerInputNode> aLayerInputMapVec(nProcessors * nLogicRegions * nLayers);
    L1TMuonOverlapParams::LayerInputNode aLayerInputNode;

    nElem = aOMTFElement->getElementsByTagName(xmlProcessor)->getLength();
    assert(nElem == nProcessors);
    DOMElement *aProcessorElement = nullptr;
    for (unsigned int i = 0; i < nElem; ++i) {
      aNode = aOMTFElement->getElementsByTagName(xmlProcessor)->item(i);
      aProcessorElement = static_cast<DOMElement *>(aNode);
      unsigned int iProcessor = std::atoi(_toString(aProcessorElement->getAttribute(xmliProcessor)).c_str());
      unsigned int nElem1 = aProcessorElement->getElementsByTagName(xmlRefLayer)->getLength();
      assert(nElem1 == nRefLayers);
      DOMElement *aRefLayerElement = nullptr;
      for (unsigned int ii = 0; ii < nElem1; ++ii) {
        aNode = aProcessorElement->getElementsByTagName(xmlRefLayer)->item(ii);
        aRefLayerElement = static_cast<DOMElement *>(aNode);
        unsigned int iRefLayer = std::atoi(_toString(aRefLayerElement->getAttribute(xmliRefLayer)).c_str());
        int iPhi = std::atoi(_toString(aRefLayerElement->getAttribute(xmliGlobalPhiStart)).c_str());
        aGlobalPhiStartVec[iRefLayer + iProcessor * nRefLayers] = iPhi;
      }
      nElem1 = aProcessorElement->getElementsByTagName(xmlRefHit)->getLength();
      assert((iProcessor == 0 && nElem1 == nRefHits) || (iProcessor != 0 && nElem1 == 0));
      DOMElement *aRefHitElement = nullptr;
      for (unsigned int ii = 0; ii < nElem1; ++ii) {
        aNode = aProcessorElement->getElementsByTagName(xmlRefHit)->item(ii);
        aRefHitElement = static_cast<DOMElement *>(aNode);
        unsigned int iRefHit = std::atoi(_toString(aRefHitElement->getAttribute(xmliRefHit)).c_str());
        int iPhiMin = std::atoi(_toString(aRefHitElement->getAttribute(xmliPhiMin)).c_str());
        int iPhiMax = std::atoi(_toString(aRefHitElement->getAttribute(xmliPhiMax)).c_str());
        unsigned int iInput = std::atoi(_toString(aRefHitElement->getAttribute(xmliInput)).c_str());
        unsigned int iRegion = std::atoi(_toString(aRefHitElement->getAttribute(xmliRegion)).c_str());
        unsigned int iRefLayer = std::atoi(_toString(aRefHitElement->getAttribute(xmliRefLayer)).c_str());

        aRefHitNode.iRefHit = iRefHit;
        aRefHitNode.iPhiMin = iPhiMin;
        aRefHitNode.iPhiMax = iPhiMax;
        aRefHitNode.iInput = iInput;
        aRefHitNode.iRegion = iRegion;
        aRefHitNode.iRefLayer = iRefLayer;
        for (unsigned int iProcessor = 0; iProcessor < nProcessors; iProcessor++)
          aRefHitMapVec[iRefHit + iProcessor * nRefHits] = aRefHitNode;
      }
      unsigned int nElem2 = aProcessorElement->getElementsByTagName(xmlLogicRegion)->getLength();
      assert((iProcessor == 0 && nElem2 == nLogicRegions) || (iProcessor != 0 && nElem2 == 0));
      DOMElement *aRegionElement = nullptr;
      for (unsigned int ii = 0; ii < nElem2; ++ii) {
        aNode = aProcessorElement->getElementsByTagName(xmlLogicRegion)->item(ii);
        aRegionElement = static_cast<DOMElement *>(aNode);
        unsigned int iRegion = std::atoi(_toString(aRegionElement->getAttribute(xmliRegion)).c_str());
        unsigned int nElem3 = aRegionElement->getElementsByTagName(xmlLayer)->getLength();
        assert(nElem3 == nLayers);
        DOMElement *aLayerElement = nullptr;
        for (unsigned int iii = 0; iii < nElem3; ++iii) {
          aNode = aRegionElement->getElementsByTagName(xmlLayer)->item(iii);
          aLayerElement = static_cast<DOMElement *>(aNode);
          unsigned int iLayer = std::atoi(_toString(aLayerElement->getAttribute(xmliLayer)).c_str());
          unsigned int iFirstInput = std::atoi(_toString(aLayerElement->getAttribute(xmliFirstInput)).c_str());
          unsigned int nInputs = std::atoi(_toString(aLayerElement->getAttribute(xmlnInputs)).c_str());
          aLayerInputNode.iLayer = iLayer;
          aLayerInputNode.iFirstInput = iFirstInput;
          aLayerInputNode.nInputs = nInputs;
          for (unsigned int iProcessor = 0; iProcessor < nProcessors; ++iProcessor)
            aLayerInputMapVec[iLayer + iRegion * nLayers + iProcessor * nLayers * nLogicRegions] = aLayerInputNode;
        }
      }
    }

    aConfig->setGlobalPhiStartMap(aGlobalPhiStartVec);
    aConfig->setLayerInputMap(aLayerInputMapVec);
    aConfig->setRefHitMap(aRefHitMapVec);

    // Reset the documents vector pool and release all the associated memory back to the system.
    parser.resetDocumentPool();

    XMLString::release(&xmlOMTF);
    XMLString::release(&xmlversion);
    XMLString::release(&xmlGlobalData);
    XMLString::release(&xmlnPdfAddrBits);
    XMLString::release(&xmlnPdfValBits);
    XMLString::release(&xmlnPhiBits);
    XMLString::release(&xmlnPhiBins);
    XMLString::release(&xmlnProcessors);
    XMLString::release(&xmlnLogicRegions);
    XMLString::release(&xmlnInputs);
    XMLString::release(&xmlnLayers);
    XMLString::release(&xmlnRefLayers);
    XMLString::release(&xmliProcessor);
    XMLString::release(&xmlbarrelMin);
    XMLString::release(&xmlbarrelMax);
    XMLString::release(&xmlendcap10DegMin);
    XMLString::release(&xmlendcap10DegMax);
    XMLString::release(&xmlendcap20DegMin);
    XMLString::release(&xmlendcap20DegMax);
    XMLString::release(&xmlLayerMap);
    XMLString::release(&xmlhwNumber);
    XMLString::release(&xmllogicNumber);
    XMLString::release(&xmlbendingLayer);
    XMLString::release(&xmlconnectedToLayer);
    XMLString::release(&xmlRefLayerMap);
    XMLString::release(&xmlrefLayer);
    XMLString::release(&xmlProcessor);
    XMLString::release(&xmlRefLayer);
    XMLString::release(&xmliRefLayer);
    XMLString::release(&xmliGlobalPhiStart);
    XMLString::release(&xmlRefHit);
    XMLString::release(&xmliRefHit);
    XMLString::release(&xmliPhiMin);
    XMLString::release(&xmliPhiMax);
    XMLString::release(&xmliInput);
    XMLString::release(&xmliRegion);
    XMLString::release(&xmlLogicRegion);
    XMLString::release(&xmlLayer);
    XMLString::release(&xmliLayer);
    XMLString::release(&xmliFirstInput);
    XMLString::release(&xmlnHitsPerLayer);
    XMLString::release(&xmlnRefHits);
    XMLString::release(&xmlnTestRefHits);
    XMLString::release(&xmlnGoldenPatterns);
    XMLString::release(&xmlConnectionMap);
  }
  XMLPlatformUtils::Terminate();
}

readConfig() [4/4]

void XMLConfigReader::readConfig

(

L1TMuonOverlapParams *

aConfig

)

const

readEvent() [1/2]

std::vector< std::vector< int > > XMLConfigReader::readEvent	(	unsigned int	iEvent = 0,
		unsigned int	iProcessor = 0,
		bool	readEta = false
	)

Definition at line 335 of file XMLConfigReader.cc.

Referenced by OMTFinput::readData().

                                                                                                               {
  return OMTFinput::vector2D();
}

readEvent() [2/2]

std::vector<std::vector<int> > XMLConfigReader::readEvent	(	unsigned int	iEvent = 0,
		unsigned int	iProcessor = 0,
		bool	readEta = false
	)

readLUTs() [1/2]

void XMLConfigReader::readLUTs	(	std::vector< l1t::LUT *>	luts,
		const L1TMuonOverlapParams &	aConfig,
		const std::vector< std::string > &	types
	)

Fill payload string

Prepare the header

Read the data into LUT

Definition at line 59 of file XMLConfigReader.cc.

References aGPs, mps_fire::i, recoMuon::in, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, L1TMuonOverlapParams::nLayers(), L1TMuonOverlapParams::nPdfAddrBits(), L1TMuonOverlapParams::nRefLayers(), MillePedeFileConverter_cfg::out, l1t::LUT::read(), readPatterns(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by L1TMuonOverlapParamsESProducer::readPatternsXML(), and L1TMuonOverlapPhase1ParamsESProducer::readPatternsXML().

                                                                  {
  auto const &aGPs = readPatterns(aConfig);

  for (unsigned int i = 0; i < luts.size(); i++) {
    l1t::LUT *lut = luts[i];
    const std::string &type = types[i];

    std::stringstream strStream;
    int totalInWidth = 7;  //Number of bits used to address LUT
    int outWidth = 6;      //Number of bits used to store LUT value

    if (type == "iCharge")
      outWidth = 1;
    if (type == "iEta")
      outWidth = 2;
    if (type == "iPt")
      outWidth = 9;
    if (type == "meanDistPhi") {
      outWidth = 11;
      totalInWidth = 14;
    }
    if (type == "pdf") {
      outWidth = 6;
      totalInWidth = 21;
    }

    strStream << "#<header> V1 " << totalInWidth << " " << outWidth << " </header> " << std::endl;

    unsigned int in = 0;
    int out = 0;
    for (const auto &it : aGPs) {
      if (type == "iCharge")
        out = it->key().theCharge == -1 ? 0 : 1;
      if (type == "iEta")
        out = it->key().theEtaCode;
      if (type == "iPt")
        out = it->key().thePtCode;
      if (type == "meanDistPhi") {
        for (unsigned int iLayer = 0; iLayer < (unsigned)aConfig.nLayers(); ++iLayer) {
          for (unsigned int iRefLayer = 0; iRefLayer < (unsigned)aConfig.nRefLayers(); ++iRefLayer) {
            out = (1 << (outWidth - 1)) + it->meanDistPhiValue(iLayer, iRefLayer);
            strStream << in << " " << out << std::endl;
            ++in;
          }
        }
      }
      if (type == "pdf") {
        for (unsigned int iLayer = 0; iLayer < (unsigned)aConfig.nLayers(); ++iLayer) {
          for (unsigned int iRefLayer = 0; iRefLayer < (unsigned)aConfig.nRefLayers(); ++iRefLayer) {
            for (unsigned int iPdf = 0; iPdf < exp2(aConfig.nPdfAddrBits()); ++iPdf) {
              out = it->pdfValue(iLayer, iRefLayer, iPdf);
              strStream << in << " " << out << std::endl;
              ++in;
            }
          }
        }
      }
      if (type != "meanDistPhi" && type != "pdf") {
        strStream << in << " " << out << std::endl;
        ++in;
      }
    }

    lut->read(strStream);
  }
}

readLUTs() [2/2]

void XMLConfigReader::readLUTs	(	std::vector< l1t::LUT *>	luts,
		const L1TMuonOverlapParams &	aConfig,
		const std::vector< std::string > &	types
	)

readPatterns() [1/3]

std::vector< std::shared_ptr< GoldenPattern > > XMLConfigReader::readPatterns

(

const L1TMuonOverlapParams &

aConfig

)

Patterns XML format backward compatibility. Can use both packed by 4, or by 1 XML files.

Definition at line 163 of file XMLConfigReader.cc.

References _toDOMS(), aGPs, cms::cuda::assert(), buildGP(), ALCARECOEcalPhiSym_cff::doc, iGPNumber, eostools::move(), writedatasetfile::parser, patternsFile, and fetchall_from_DQM_v2::release.

Referenced by OMTFReconstruction::beginRun(), and readLUTs().

                                                                                                         {
  aGPs.clear();

  XMLPlatformUtils::Initialize();

  XMLCh *xmlGP = _toDOMS("GP");
  std::array<XMLCh *, 4> xmliPt = {{_toDOMS("iPt1"), _toDOMS("iPt2"), _toDOMS("iPt3"), _toDOMS("iPt4")}};

  {
    XercesDOMParser parser;
    parser.setValidationScheme(XercesDOMParser::Val_Auto);
    parser.setDoNamespaces(false);

    parser.parse(patternsFile.c_str());
    xercesc::DOMDocument *doc = parser.getDocument();
    assert(doc);

    unsigned int nElem = doc->getElementsByTagName(xmlGP)->getLength();
    if (nElem < 1) {
      edm::LogError("critical") << "Problem parsing XML file " << patternsFile << std::endl;
      edm::LogError("critical") << "No GoldenPattern items: GP found" << std::endl;
      return aGPs;
    }

    DOMNode *aNode = nullptr;
    DOMElement *aGPElement = nullptr;
    unsigned int iGPNumber = 0;

    for (unsigned int iItem = 0; iItem < nElem; ++iItem) {
      aNode = doc->getElementsByTagName(xmlGP)->item(iItem);
      aGPElement = static_cast<DOMElement *>(aNode);

      std::unique_ptr<GoldenPattern> aGP;
      for (unsigned int index = 1; index < 5; ++index) {
        if (aGPElement->getAttributeNode(xmliPt[index - 1])) {
          aGP = buildGP(aGPElement, aConfig, index, iGPNumber);
          if (aGP) {
            aGPs.emplace_back(std::move(aGP));
            iGPNumber++;
          }
        } else {
          aGP = buildGP(aGPElement, aConfig);
          if (aGP) {
            aGPs.emplace_back(std::move(aGP));
            iGPNumber++;
          }
          break;
        }
      }
    }

    // Reset the documents vector pool and release all the associated memory back to the system.
    //parser->resetDocumentPool();
    parser.resetDocumentPool();
  }
  XMLString::release(&xmlGP);
  XMLString::release(&xmliPt[0]);
  XMLString::release(&xmliPt[1]);
  XMLString::release(&xmliPt[2]);
  XMLString::release(&xmliPt[3]);

  XMLPlatformUtils::Terminate();

  return aGPs;
}

readPatterns() [2/3]

template<class GoldenPatternType >

GoldenPatternVec< GoldenPatternType > XMLConfigReader::readPatterns	(	const L1TMuonOverlapParams &	aConfig,
		const std::string &	patternsFile,
		bool	buildEmptyPatterns,
		bool	resetNumbering = true
	)

Patterns XML format backward compatibility. Can use both packed by 4, or by 1 XML files.

Definition at line 237 of file XMLConfigReader.cc.

References _toDOMS(), aGPs, cms::cuda::assert(), ALCARECOEcalPhiSym_cff::doc, iGPNumber, iPatternGroup, eostools::move(), writedatasetfile::parser, patternsFile, and fetchall_from_DQM_v2::release.

                                                                                       {
  GoldenPatternVec<GoldenPatternType> aGPs;
  aGPs.clear();

  XMLPlatformUtils::Initialize();

  if (resetNumbering) {
    iGPNumber = 0;
    iPatternGroup = 0;
  }

  XMLCh *xmlGP = _toDOMS("GP");
  std::array<XMLCh *, 4> xmliPt = {{_toDOMS("iPt1"), _toDOMS("iPt2"), _toDOMS("iPt3"), _toDOMS("iPt4")}};

  {
    XercesDOMParser parser;
    parser.setValidationScheme(XercesDOMParser::Val_Auto);
    parser.setDoNamespaces(false);

    parser.parse(patternsFile.c_str());
    xercesc::DOMDocument *doc = parser.getDocument();
    assert(doc);

    unsigned int nElem = doc->getElementsByTagName(xmlGP)->getLength();
    if (nElem < 1) {
      edm::LogError("critical") << "Problem parsing XML file " << patternsFile << std::endl;
      edm::LogError("critical") << "No GoldenPattern items: GP found" << std::endl;
      return aGPs;
    }

    DOMNode *aNode = nullptr;
    DOMElement *aGPElement = nullptr;
    //unsigned int iGPNumber=0;

    for (unsigned int iItem = 0; iItem < nElem; ++iItem, ++iPatternGroup) {
      aNode = doc->getElementsByTagName(xmlGP)->item(iItem);
      aGPElement = static_cast<DOMElement *>(aNode);

      for (unsigned int index = 1; index < 5; ++index) {
        if (aGPElement->getAttributeNode(xmliPt[index - 1])) {
          std::unique_ptr<GoldenPatternType> aGP =
              buildGP<GoldenPatternType>(aGPElement, aConfig, iPatternGroup, index, iGPNumber);
          if (aGP && (aGP->key().thePt || buildEmptyPatterns)) {
            aGPs.emplace_back(std::move(aGP));
            iGPNumber++;
          }
        } else {
          std::unique_ptr<GoldenPatternType> aGP = buildGP<GoldenPatternType>(aGPElement, aConfig, iPatternGroup);
          if (aGP && (aGP->key().thePt || buildEmptyPatterns)) {
            aGPs.emplace_back(std::move(aGP));
            iGPNumber++;
          }
          break;
        }
      }
    }

    // Reset the documents vector pool and release all the associated memory back to the system.
    //parser->resetDocumentPool();
    parser.resetDocumentPool();
  }
  XMLString::release(&xmlGP);
  XMLString::release(&xmliPt[0]);
  XMLString::release(&xmliPt[1]);
  XMLString::release(&xmliPt[2]);
  XMLString::release(&xmliPt[3]);

  XMLPlatformUtils::Terminate();

  return aGPs;
}

readPatterns() [3/3]

template<class GoldenPatternType >

GoldenPatternVec< GoldenPatternType > XMLConfigReader::readPatterns	(	const L1TMuonOverlapParams &	aConfig,
		const std::vector< std::string > &	patternsFiles,
		bool	buildEmptyPatterns
	)

Definition at line 315 of file XMLConfigReader.cc.

References aGPs, runTauDisplay::gp, iGPNumber, iPatternGroup, eostools::move(), and patternsFiles.

                                                                                           {
  iGPNumber = 0;
  iPatternGroup = 0;
  GoldenPatternVec<GoldenPatternType> aGPs;
  for (const auto &aPatternsFile : patternsFiles) {
    auto tmpGPs = readPatterns<GoldenPatternType>(aConfig, aPatternsFile, buildEmptyPatterns, false);
    for (auto &gp : tmpGPs)
      aGPs.push_back(std::move(gp));
  }
  return aGPs;
}

setConfigFile() [1/2]

void XMLConfigReader::setConfigFile ( const std::string &  fName )

inline

Definition at line 33 of file XMLConfigReader.h.

References configFile, and isotrackTrainRegressor::fName.

Referenced by OMTFReconstruction::beginRun(), L1TMuonOverlapParamsESProducer::L1TMuonOverlapParamsESProducer(), and L1TMuonOverlapPhase1ParamsESProducer::L1TMuonOverlapPhase1ParamsESProducer().

{ configFile = fName; }

setConfigFile() [2/2]

void XMLConfigReader::setConfigFile ( const std::string &  fName )

inline

Definition at line 35 of file XMLConfigReader.h.

References configFile, and isotrackTrainRegressor::fName.

{ configFile = fName; }

setEventsFile() [1/2]

void XMLConfigReader::setEventsFile ( const std::string &  fName )

inline

Definition at line 37 of file XMLConfigReader.h.

References eventsFile, and isotrackTrainRegressor::fName.

{ eventsFile = fName; }

setEventsFile() [2/2]

void XMLConfigReader::setEventsFile ( const std::string &  fName )

inline

Definition at line 39 of file XMLConfigReader.h.

References eventsFile, and isotrackTrainRegressor::fName.

{ eventsFile = fName; }

setPatternsFile()

void XMLConfigReader::setPatternsFile ( const std::string &  fName )

inline

Definition at line 35 of file XMLConfigReader.h.

References isotrackTrainRegressor::fName, and patternsFile.

Referenced by L1TMuonOverlapParamsESProducer::L1TMuonOverlapParamsESProducer().

{ patternsFile = fName; }

setPatternsFiles()

void XMLConfigReader::setPatternsFiles ( std::vector< std::string > &  fNames )

inline

Definition at line 37 of file XMLConfigReader.h.

References patternsFiles.

Referenced by L1TMuonOverlapPhase1ParamsESProducer::L1TMuonOverlapPhase1ParamsESProducer().

{ patternsFiles = fNames; }

Member Data Documentation

aGPs

std::vector<std::shared_ptr<GoldenPattern> > XMLConfigReader::aGPs

private

Cache with GPs read.

Definition at line 65 of file XMLConfigReader.h.

Referenced by readLUTs(), and readPatterns().

configFile

std::string XMLConfigReader::configFile

private

Definition at line 52 of file XMLConfigReader.h.

Referenced by readConfig(), cmsswPreprocessor.CmsswPreprocessor::run(), and setConfigFile().

eventsFile

std::string XMLConfigReader::eventsFile

private

Definition at line 54 of file XMLConfigReader.h.

Referenced by setEventsFile().

iGPNumber

unsigned int XMLConfigReader::iGPNumber = 0

private

Definition at line 78 of file XMLConfigReader.h.

Referenced by readPatterns().

iPatternGroup

unsigned int XMLConfigReader::iPatternGroup = 0

private

Definition at line 79 of file XMLConfigReader.h.

Referenced by readPatterns().

patternsFile

std::string XMLConfigReader::patternsFile

private

Definition at line 53 of file XMLConfigReader.h.

Referenced by getPatternsVersion(), readPatterns(), and setPatternsFile().

patternsFiles

std::vector<std::string> XMLConfigReader::patternsFiles

private

Definition at line 68 of file XMLConfigReader.h.

Referenced by readPatterns(), and setPatternsFiles().