#include <L1GtTriggerMenuXmlParser.h>

Inheritance diagram for L1GtTriggerMenuXmlParser:

Public Member Functions
const std::vector< std::vector < L1GtCaloTemplate > > &	corCaloTemplate () const

const std::vector< std::vector < L1GtEnergySumTemplate > > &	corEnergySumTemplate () const

const std::vector< std::vector < L1GtMuonTemplate > > &	corMuonTemplate () const

const AlgorithmMap &	gtAlgorithmAliasMap () const
	get / set the algorithm map (by alias) More...

const std::string &	gtAlgorithmImplementation () const

const AlgorithmMap &	gtAlgorithmMap () const
	get / set the algorithm map (by name) More...

const std::vector< ConditionMap > &	gtConditionMap () const
	get / set / build the condition maps More...

const unsigned int	gtNumberConditionChips () const
	get / set the number of condition chips in GTL More...

const unsigned int	gtNumberL1JetCounts () const
	get / set the number of L1 jet counts received by GT More...

const unsigned int	gtNumberPhysTriggers () const
	get / set the number of physics trigger algorithms More...

const unsigned int	gtNumberTechTriggers () const
	get / set the number of technical triggers More...

std::vector< int >	gtOrderConditionChip () const

const unsigned int	gtPinsOnConditionChip () const
	get / set the number of pins on the GTL condition chips More...

const std::string &	gtScaleDbKey () const
	menu associated scale key More...

const AlgorithmMap &	gtTechnicalTriggerMap () const
	get / set the technical trigger map More...

const std::string &	gtTriggerMenuAuthor () const

const std::string &	gtTriggerMenuDate () const

const std::string &	gtTriggerMenuDescription () const

const std::string &	gtTriggerMenuImplementation () const

const std::string &	gtTriggerMenuInterface () const
	get / set the trigger menu names More...

const std::string &	gtTriggerMenuInterfaceAuthor () const

const std::string &	gtTriggerMenuInterfaceDate () const
	get / set the XML parser creation date, author, description for menu interface, menu More...

const std::string &	gtTriggerMenuInterfaceDescription () const

const std::string &	gtTriggerMenuName () const

	L1GtTriggerMenuXmlParser ()

void	parseXmlFile (const std::string &defXmlFile, const std::string &vmeXmlFile)
	parse def.xml and vme.xml files More...

void	setCorCaloTemplate (const std::vector< std::vector< L1GtCaloTemplate > > &)

void	setCorEnergySumTemplate (const std::vector< std::vector< L1GtEnergySumTemplate > > &)

void	setCorMuonTemplate (const std::vector< std::vector< L1GtMuonTemplate > > &)

void	setGtAlgorithmAliasMap (const AlgorithmMap &)

void	setGtAlgorithmImplementation (const std::string &)

void	setGtAlgorithmMap (const AlgorithmMap &)

void	setGtConditionMap (const std::vector< ConditionMap > &)

void	setGtNumberConditionChips (const unsigned int &)

void	setGtNumberL1JetCounts (const unsigned int &)

void	setGtNumberPhysTriggers (const unsigned int &)

void	setGtNumberTechTriggers (const unsigned int &)

void	setGtOrderConditionChip (const std::vector< int > &)

void	setGtPinsOnConditionChip (const unsigned int &)

void	setGtScaleDbKey (const std::string &)

void	setGtTechnicalTriggerMap (const AlgorithmMap &)

void	setGtTriggerMenuAuthor (const std::string &)

void	setGtTriggerMenuDate (const std::string &)

void	setGtTriggerMenuDescription (const std::string &)

void	setGtTriggerMenuImplementation (const std::string &)

void	setGtTriggerMenuInterface (const std::string &)

void	setGtTriggerMenuInterfaceAuthor (const std::string &)

void	setGtTriggerMenuInterfaceDate (const std::string &)

void	setGtTriggerMenuInterfaceDescription (const std::string &)

void	setGtTriggerMenuName (const std::string &)

void	setVecBptxTemplate (const std::vector< std::vector< L1GtBptxTemplate > > &)

void	setVecCaloTemplate (const std::vector< std::vector< L1GtCaloTemplate > > &)

void	setVecCastorTemplate (const std::vector< std::vector< L1GtCastorTemplate > > &)

void	setVecCorrelationTemplate (const std::vector< std::vector< L1GtCorrelationTemplate > > &)

void	setVecEnergySumTemplate (const std::vector< std::vector< L1GtEnergySumTemplate > > &)

void	setVecExternalTemplate (const std::vector< std::vector< L1GtExternalTemplate > > &)

void	setVecHfBitCountsTemplate (const std::vector< std::vector< L1GtHfBitCountsTemplate > > &)

void	setVecHfRingEtSumsTemplate (const std::vector< std::vector< L1GtHfRingEtSumsTemplate > > &)

void	setVecJetCountsTemplate (const std::vector< std::vector< L1GtJetCountsTemplate > > &)

void	setVecMuonTemplate (const std::vector< std::vector< L1GtMuonTemplate > > &)

const std::vector< std::vector < L1GtBptxTemplate > > &	vecBptxTemplate () const

const std::vector< std::vector < L1GtCaloTemplate > > &	vecCaloTemplate () const

const std::vector< std::vector < L1GtCastorTemplate > > &	vecCastorTemplate () const

const std::vector< std::vector < L1GtCorrelationTemplate > > &	vecCorrelationTemplate () const

const std::vector< std::vector < L1GtEnergySumTemplate > > &	vecEnergySumTemplate () const

const std::vector< std::vector < L1GtExternalTemplate > > &	vecExternalTemplate () const

const std::vector< std::vector < L1GtHfBitCountsTemplate > > &	vecHfBitCountsTemplate () const

const std::vector< std::vector < L1GtHfRingEtSumsTemplate > > &	vecHfRingEtSumsTemplate () const

const std::vector< std::vector < L1GtJetCountsTemplate > > &	vecJetCountsTemplate () const

const std::vector< std::vector < L1GtMuonTemplate > > &	vecMuonTemplate () const
	get / set the vectors containing the conditions More...

	~L1GtTriggerMenuXmlParser () override
	destructor More...

Public Member Functions inherited from L1GtXmlParserTags
	L1GtXmlParserTags ()
	constructor More...

virtual	~L1GtXmlParserTags ()
	destructor More...

Private Member Functions
void	cleanupXML (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	shutdown the xml utils and deallocate parser and error handler More...

void	clearMaps ()

bool	countConditionChildMaxBits (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &childName, unsigned int &dst)
	get the number of bits in the max attribute of a condition child More...

XERCES_CPP_NAMESPACE::DOMNode *	findXMLChild (XERCES_CPP_NAMESPACE::DOMNode startChild, const std::string &tagName, bool beginOnly=false, std::string rest=nullptr)
	find a named child of a xml node More...

int	getBitFromNode (XERCES_CPP_NAMESPACE::DOMNode *node)
	get bit from a bit node More...

bool	getConditionChildValues (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &childName, unsigned int num, std::vector< uint64_t > &dst)
	get values from a child of a condition More...

int	getGEqFlag (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &nodeName)
	getGEqFlag - get the "greater or equal flag" from a condition More...

bool	getMuonMipIsoBits (XERCES_CPP_NAMESPACE::DOMNode *node, unsigned int num, std::vector< bool > &mipDst, std::vector< bool > &isoEnDst, std::vector< bool > &isoReqDst)
	get MIP and Isolation bits from a muon More...

int	getNumFromType (const std::string &type)
	get number of particles from condition type More...

L1GtConditionType	getTypeFromType (const std::string &type)

std::string	getXMLAttribute (const XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name)
	get a named attribute for an xml node as string More...

bool	getXMLHexTextValue (XERCES_CPP_NAMESPACE::DOMNode *node, uint64_t &dst)
	get a hexadecimal value of a xml node containing text More...

bool	getXMLHexTextValue128 (XERCES_CPP_NAMESPACE::DOMNode *node, uint64_t &dstL, uint64_t &dstH)
	get a hexadecimal value of a xml node containing text with up to 128 bit More...

std::string	getXMLTextValue (XERCES_CPP_NAMESPACE::DOMNode *node)
	get the text value of a xml node as string More...

bool	hexString2UInt128 (const std::string &hexString, uint64_t &dstL, uint64_t &dstH)
	convert a hexadecimal string with up to 128 to 2 uint64_t More...

XERCES_CPP_NAMESPACE::XercesDOMParser *	initXML (const std::string &xmlFile)
	init xml system More...

bool	insertAlgorithmIntoMap (const L1GtAlgorithm &alg)
	insert an algorithm into algorithm map More...

bool	insertConditionIntoMap (L1GtCondition &cond, const int chipNr)

bool	insertTechTriggerIntoMap (const L1GtAlgorithm &alg)
	insert a technical trigger into technical trigger map More...

bool	parseAlgorithms (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse all algorithms More...

bool	parseBptx (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a Bptx condition More...

bool	parseCalo (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0, const bool corrFlag=false)
	parse a calorimeter condition More...

bool	parseCastor (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a CASTOR condition More...

bool	parseConditions (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse all conditions More...

bool	parseCorrelation (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a correlation condition More...

bool	parseEnergySum (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0, const bool corrFlag=false)
	parse an "energy sum" condition More...

bool	parseExternal (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse an External condition More...

bool	parseHfBitCounts (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a HfBitCounts condition More...

bool	parseHfRingEtSums (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a HfRingEtSums condition More...

bool	parseId (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse all parse all identification attributes (trigger menu names, scale DB key, etc) More...

bool	parseJetCounts (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a "jet counts" condition More...

bool	parseMuon (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0, const bool corrFlag=false)
	parse a muon condition More...

bool	parseTechTriggers (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse all algorithms More...

bool	parseVmeXML (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse the vme xml file More...

bool	workAlgorithm (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr)
	parse an algorithm and insert it into algorithm map. More...

bool	workCondition (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr)
	choose the parser for a particular condition More...

bool	workTechTrigger (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name)
	parse an algorithm and insert it into algorithm map. More...

bool	workXML (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	do all the steps for filling a trigger menu More...

Private Attributes
AlgorithmMap	m_algorithmAliasMap
	map containing the physics algorithms (by alias) More...

std::string	m_algorithmImplementation

AlgorithmMap	m_algorithmMap
	map containing the physics algorithms (by name) More...

std::vector< ConditionMap >	m_conditionMap
	map containing the conditions (per condition chip) - transient More...

std::vector< std::vector < L1GtCaloTemplate > >	m_corCaloTemplate

std::vector< std::vector < L1GtEnergySumTemplate > >	m_corEnergySumTemplate

std::vector< std::vector < L1GtMuonTemplate > >	m_corMuonTemplate

unsigned int	m_numberConditionChips
	hardware limits More...

unsigned int	m_numberL1JetCounts
	jet counts More...

unsigned int	m_numberPhysTriggers
	number of physics trigger algorithms More...

unsigned int	m_numberTechTriggers
	number of technical triggers More...

std::vector< int >	m_orderConditionChip

unsigned int	m_pinsOnConditionChip
	number of pins on the GTL condition chips More...

std::string	m_scaleDbKey
	menu associated scale key More...

AlgorithmMap	m_technicalTriggerMap
	map containing the technical triggers More...

std::string	m_triggerMenuAuthor

std::string	m_triggerMenuDate

std::string	m_triggerMenuDescription

std::string	m_triggerMenuImplementation

std::string	m_triggerMenuInterface
	menu names More...

std::string	m_triggerMenuInterfaceAuthor

std::string	m_triggerMenuInterfaceDate
	members for XML parser only (do not appear in CondFormats) More...

std::string	m_triggerMenuInterfaceDescription

std::string	m_triggerMenuName

std::vector< std::vector < L1GtBptxTemplate > >	m_vecBptxTemplate

std::vector< std::vector < L1GtCaloTemplate > >	m_vecCaloTemplate

std::vector< std::vector < L1GtCastorTemplate > >	m_vecCastorTemplate

std::vector< std::vector < L1GtCorrelationTemplate > >	m_vecCorrelationTemplate

std::vector< std::vector < L1GtEnergySumTemplate > >	m_vecEnergySumTemplate

std::vector< std::vector < L1GtExternalTemplate > >	m_vecExternalTemplate

std::vector< std::vector < L1GtHfBitCountsTemplate > >	m_vecHfBitCountsTemplate

std::vector< std::vector < L1GtHfRingEtSumsTemplate > >	m_vecHfRingEtSumsTemplate

std::vector< std::vector < L1GtJetCountsTemplate > >	m_vecJetCountsTemplate

std::vector< std::vector < L1GtMuonTemplate > >	m_vecMuonTemplate

XERCES_CPP_NAMESPACE::ErrorHandler *	m_xmlErrHandler
	error handler for xml-parser More...

Additional Inherited Members
Static Protected Attributes inherited from L1GtXmlParserTags
static const std::string	m_xmlAlgorithmAttrAlias

static const std::string	m_xmlAttrMax

static const std::string	m_xmlAttrMode

static const std::string	m_xmlAttrModeBit

static const std::string	m_xmlAttrNr

static const std::string	m_xmlAttrPin

static const std::string	m_xmlAttrPinA

static const std::string	m_xmlConditionAttrCondition

static const std::string	m_xmlConditionAttrConditionBptx

static const std::string	m_xmlConditionAttrConditionCalo

static const std::string	m_xmlConditionAttrConditionCastor

static const std::string	m_xmlConditionAttrConditionCorrelation

static const std::string	m_xmlConditionAttrConditionEnergySum

static const std::string	m_xmlConditionAttrConditionExternal

static const std::string	m_xmlConditionAttrConditionHfBitCounts

static const std::string	m_xmlConditionAttrConditionHfRingEtSums

static const std::string	m_xmlConditionAttrConditionJetCounts

static const std::string	m_xmlConditionAttrConditionMuon

static const std::string	m_xmlConditionAttrObject

static const std::string	m_xmlConditionAttrObjectBptx

static const std::string	m_xmlConditionAttrObjectCastor

static const std::string	m_xmlConditionAttrObjectCenJet

static const std::string	m_xmlConditionAttrObjectETM

static const std::string	m_xmlConditionAttrObjectETT

static const std::string	m_xmlConditionAttrObjectForJet

static const std::string	m_xmlConditionAttrObjectGtExternal

static const std::string	m_xmlConditionAttrObjectHfBitCounts

static const std::string	m_xmlConditionAttrObjectHfRingEtSums

static const std::string	m_xmlConditionAttrObjectHTM

static const std::string	m_xmlConditionAttrObjectHTT

static const std::string	m_xmlConditionAttrObjectIsoEG

static const std::string	m_xmlConditionAttrObjectJetCounts

static const std::string	m_xmlConditionAttrObjectMu

static const std::string	m_xmlConditionAttrObjectNoIsoEG

static const std::string	m_xmlConditionAttrObjectTauJet

static const std::string	m_xmlConditionAttrType

static const std::string	m_xmlConditionAttrType1s

static const std::string	m_xmlConditionAttrType2cor

static const std::string	m_xmlConditionAttrType2s

static const std::string	m_xmlConditionAttrType2wsc

static const std::string	m_xmlConditionAttrType3s

static const std::string	m_xmlConditionAttrType4s

static const std::string	m_xmlConditionAttrTypeBptx

static const std::string	m_xmlConditionAttrTypeCastor

static const std::string	m_xmlConditionAttrTypeExternal

static const std::string	m_xmlTagAlgorithms

static const std::string	m_xmlTagCa

static const std::string	m_xmlTagChargeCorrelation

static const std::string	m_xmlTagChip

static const std::string	m_xmlTagChip1

static const std::string	m_xmlTagChipDef

static const std::string	m_xmlTagConditions

static const std::string	m_xmlTagCountOverflow

static const std::string	m_xmlTagCountThreshold

static const std::string	m_xmlTagDef

static const std::string	m_xmlTagDeltaEta

static const std::string	m_xmlTagDeltaPhi

static const std::string	m_xmlTagEnableIso

static const std::string	m_xmlTagEnableMip

static const std::string	m_xmlTagEnergyOverflow

static const std::string	m_xmlTagEta

static const std::string	m_xmlTagEtThreshold

static const std::string	m_xmlTagGEq

static const std::string	m_xmlTagHeader

static const std::string	m_xmlTagMenuAlgImpl

static const std::string	m_xmlTagMenuAuthor

static const std::string	m_xmlTagMenuDate

static const std::string	m_xmlTagMenuDescription

static const std::string	m_xmlTagMenuInterface

static const std::string	m_xmlTagMenuInterfaceAuthor

static const std::string	m_xmlTagMenuInterfaceDate

static const std::string	m_xmlTagMenuInterfaceDescription

static const std::string	m_xmlTagOutput

static const std::string	m_xmlTagOutputPin

static const std::string	m_xmlTagPhi

static const std::string	m_xmlTagPhiHigh

static const std::string	m_xmlTagPhiLow

static const std::string	m_xmlTagPtHighThreshold

static const std::string	m_xmlTagPtLowThreshold

static const std::string	m_xmlTagQuality

static const std::string	m_xmlTagRequestIso

static const std::string	m_xmlTagScaleDbKey

static const std::string	m_xmlTagTechTriggers

static const std::string	m_xmlTagValue

static const std::string	m_xmlTagVme

static const std::string	m_xmlTagVmeAddress

Detailed Description

Description: Xerces-C XML parser for the L1 Trigger menu.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna; M. Eder - HEPHY Vienna - ORCA version, reduced functionality

Description: Xerces-C XML parser for the L1 Trigger menu.

Implementation: <TODO: enter implementation details>

Author: : Vasile Mihai Ghete - HEPHY Vienna

Definition at line 51 of file L1GtTriggerMenuXmlParser.h.

Constructor & Destructor Documentation

L1GtTriggerMenuXmlParser::L1GtTriggerMenuXmlParser ( )

constructor empty

Definition at line 39 of file L1GtTriggerMenuXmlParser.cc.

     : L1GtXmlParserTags(),
       m_xmlErrHandler(nullptr),
       m_triggerMenuInterface("NULL"),
       m_triggerMenuName("NULL"),
       m_triggerMenuImplementation("NULL"),
       m_scaleDbKey("NULL")
 
 {
   // menu names, scale key initialized to NULL due to ORACLE treatment of strings
 
   // empty
 }

L1GtTriggerMenuXmlParser::~L1GtTriggerMenuXmlParser ( )

override

destructor

Definition at line 54 of file L1GtTriggerMenuXmlParser.cc.

References clearMaps().

54 { clearMaps(); }

L1GtTriggerMenuXmlParser::clearMaps

void clearMaps()

Definition: L1GtTriggerMenuXmlParser.cc:834

Member Function Documentation

void L1GtTriggerMenuXmlParser::cleanupXML ( XERCES_CPP_NAMESPACE::XercesDOMParser * parser )

private

shutdown the xml utils and deallocate parser and error handler

cleanupXML - Delete parser and error handler. Shutdown XMLPlatformUtils.

Parameters

parser A reference to the parser to be deleted.

Definition at line 762 of file L1GtTriggerMenuXmlParser.cc.

References m_xmlErrHandler, writedatasetfile::parser, and cms::concurrency::xercesTerminate().

Referenced by parseXmlFile().

                                                                                      {
   XERCES_CPP_NAMESPACE_USE
 
   if (parser != nullptr) {
     delete parser;
   }
 
   if (m_xmlErrHandler != nullptr) {
     delete m_xmlErrHandler;
     m_xmlErrHandler = nullptr;
   }
 
   cms::concurrency::xercesTerminate();
 }

void L1GtTriggerMenuXmlParser::clearMaps ( )

private

clearMaps - delete all conditions and algorithms in the maps and clear the maps.

Definition at line 834 of file L1GtTriggerMenuXmlParser.cc.

References m_algorithmMap, and m_conditionMap.

Referenced by workXML(), and ~L1GtTriggerMenuXmlParser().

                                          {
   // loop over condition maps (one map per condition chip)
   // then loop over conditions in the map
   for (std::vector<ConditionMap>::iterator itCondOnChip = m_conditionMap.begin(); itCondOnChip != m_conditionMap.end();
        itCondOnChip++) {
     // the conditions in the maps are deleted in L1GtTriggerMenu, not here
 
     itCondOnChip->clear();
   }
 
   // the algorithms in the maps are deleted in L1GtTriggerMenu, not here
   m_algorithmMap.clear();
 }

const std::vector<std::vector<L1GtCaloTemplate> >& L1GtTriggerMenuXmlParser::corCaloTemplate ( ) const

inline

Definition at line 186 of file L1GtTriggerMenuXmlParser.h.

References m_corCaloTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

186 { return m_corCaloTemplate; }

L1GtTriggerMenuXmlParser::m_corCaloTemplate

std::vector< std::vector< L1GtCaloTemplate > > m_corCaloTemplate

Definition: L1GtTriggerMenuXmlParser.h:458

const std::vector<std::vector<L1GtEnergySumTemplate> >& L1GtTriggerMenuXmlParser::corEnergySumTemplate ( ) const

inline

Definition at line 191 of file L1GtTriggerMenuXmlParser.h.

References m_corEnergySumTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                           {
     return m_corEnergySumTemplate;
   }

const std::vector<std::vector<L1GtMuonTemplate> >& L1GtTriggerMenuXmlParser::corMuonTemplate ( ) const

inline

Definition at line 181 of file L1GtTriggerMenuXmlParser.h.

References m_corMuonTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

181 { return m_corMuonTemplate; }

L1GtTriggerMenuXmlParser::m_corMuonTemplate

std::vector< std::vector< L1GtMuonTemplate > > m_corMuonTemplate

Definition: L1GtTriggerMenuXmlParser.h:457

bool L1GtTriggerMenuXmlParser::countConditionChildMaxBits	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	childName,
		unsigned int &	dst
	)

private

get the number of bits in the max attribute of a condition child

countConditionChildMaxBits Count the set bits in the max attribute. Needed for the wsc-values to determine 180 degree.

Parameters

node	The xml node of the condition.
childName	The name of the child
dst	The destination to write the number of bits.

Returns: true if the bits could be determined, otherwise false.

Definition at line 595 of file L1GtTriggerMenuXmlParser.cc.

References counter, findXMLChild(), getXMLAttribute(), hexString2UInt128(), LogDebug, L1GtXmlParserTags::m_xmlAttrMax, L1GtXmlParserTags::m_xmlTagValue, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parseCalo(), parseCorrelation(), and parseMuon().

                                                                              {
   XERCES_CPP_NAMESPACE_USE
 
   // should never happen...
   if (node == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "node == 0 in " << __PRETTY_FUNCTION__ << std::endl;
 
     return false;
   }
 
   DOMNode* n1 = findXMLChild(node->getFirstChild(), childName);
 
   if (n1 == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Child of condition not found ( " << childName << ")" << std::endl;
 
     return false;
   }
 
   DOMNode* n2 = findXMLChild(n1->getFirstChild(), m_xmlTagValue);
 
   if (n2 == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "No value tag found for child " << childName << " in "
                                          << __PRETTY_FUNCTION__ << std::endl;
 
     return false;
   }
 
   // first try direct
   std::string maxString = getXMLAttribute(n1, m_xmlAttrMax);  // string for the maxbits
 
   if (maxString.empty()) {
     maxString = getXMLAttribute(n2, m_xmlAttrMax);  // try next value tag
     // if no max was found neither in value nor in the childName tag
     if (maxString.empty()) {
       LogDebug("L1GtTriggerMenuXmlParser") << "No Max value found for " << childName << std::endl;
 
       return false;
     }
   }
 
   // do the hex conversion
 
   uint64_t maxBitsL, maxBitsH;
   if (!hexString2UInt128(maxString, maxBitsL, maxBitsH)) {
     return false;
   }
 
   // count the bits
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< std::dec
   //<< "        words: dec: high (MSB) word = " << maxBitsH << " low word = " << maxBitsL
   //<< std::hex << "\n"
   //<< "        words: hex: high (MSB) word = " << maxBitsH << " low word = " << maxBitsL
   //<< std::dec
   //<< std::endl;
 
   unsigned int counter = 0;
 
   while (maxBitsL != 0) {
     // check if bits set countinously
     if ((maxBitsL & 1) == 0) {
       edm::LogError("L1GtTriggerMenuXmlParser") << "      Confused by not continous set bits for max value "
                                                 << maxString << "(child=" << childName << ")" << std::endl;
 
       return false;
     }
 
     maxBitsL >>= 1;
     counter++;
   }
 
   if ((maxBitsH != 0) && (counter != 64)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "      Confused by not continous set bits for max value " << maxString
                                               << "(child=" << childName << ")" << std::endl;
 
     return false;
   }
 
   while (maxBitsH != 0) {
     //check if bits set countinously
     if ((maxBitsH & 1) == 0) {
       edm::LogError("L1GtTriggerMenuXmlParser") << "      Confused by not continous set bits for max value "
                                                 << maxString << "(child=" << childName << ")" << std::endl;
 
       return false;
     }
 
     maxBitsH >>= 1;
     counter++;
   }
 
   dst = counter;
   return true;
 }

XERCES_CPP_NAMESPACE::DOMNode * L1GtTriggerMenuXmlParser::findXMLChild	(	XERCES_CPP_NAMESPACE::DOMNode *	startChild,
		const std::string &	tagName,
		bool	beginOnly = `false`,
		std::string *	rest = `nullptr`
	)

private

find a named child of a xml node

Definition at line 320 of file L1GtTriggerMenuXmlParser.cc.

References fetchall_from_DQM_v2::release, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by countConditionChildMaxBits(), getConditionChildValues(), getGEqFlag(), getMuonMipIsoBits(), parseAlgorithms(), parseConditions(), parseCorrelation(), parseEnergySum(), parseId(), parseMuon(), parseTechTriggers(), parseVmeXML(), workAlgorithm(), and workTechTrigger().

                                                                                        {
   XERCES_CPP_NAMESPACE_USE
 
   char* nodeName = nullptr;
 
   DOMNode* n1 = startChild;
   if (n1 == nullptr) {
     return nullptr;
   }
 
   if (!tagName.empty()) {
     nodeName = XMLString::transcode(n1->getNodeName());
 
     if (!beginOnly) {
       //match the whole tag
       while (XMLString::compareIString(nodeName, tagName.c_str())) {
         XMLString::release(&nodeName);
         n1 = n1->getNextSibling();
         if (n1 == nullptr) {
           break;
         }
 
         nodeName = XMLString::transcode(n1->getNodeName());
       }
     } else {
       // match only the beginning
       while (XMLString::compareNIString(nodeName, tagName.c_str(), tagName.length())) {
         XMLString::release(&nodeName);
         n1 = n1->getNextSibling();
         if (n1 == nullptr) {
           break;
         }
 
         nodeName = XMLString::transcode(n1->getNodeName());
       }
       if (n1 != nullptr && rest != nullptr) {
         *rest = std::string(nodeName).substr(tagName.length(), strlen(nodeName) - tagName.length());
       }
     }
   } else {  // empty string given
     while (n1->getNodeType() != DOMNode::ELEMENT_NODE) {
       n1 = n1->getNextSibling();
       if (n1 == nullptr) {
         break;
       }
     }
     if (n1 != nullptr && rest != nullptr) {
       nodeName = XMLString::transcode(n1->getNodeName());
       *rest = std::string(nodeName);
     }
   }
 
   XMLString::release(&nodeName);
 
   return n1;
 }

int L1GtTriggerMenuXmlParser::getBitFromNode ( XERCES_CPP_NAMESPACE::DOMNode * node )

private

get bit from a bit node

getBitFromNode Get a bit from a specified bitvalue node.

Parameters

node	The xml node.

Returns: The value of the bit or -1 if an error occurred.

Definition at line 1084 of file L1GtTriggerMenuXmlParser.cc.

References getXMLAttribute(), getXMLTextValue(), L1GtXmlParserTags::m_xmlAttrMode, L1GtXmlParserTags::m_xmlAttrModeBit, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getGEqFlag(), getMuonMipIsoBits(), and parseEnergySum().

                                                                               {
   if (getXMLAttribute(node, m_xmlAttrMode) != m_xmlAttrModeBit) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Invalid mode for single bit" << std::endl;
 
     return -1;
   }
 
   std::string tmpStr = getXMLTextValue(node);
   if (tmpStr == "0") {
     return 0;
   } else if (tmpStr == "1") {
     return 1;
   } else {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Bad bit value (" << tmpStr << ")" << std::endl;
     return -1;
   }
 }

bool L1GtTriggerMenuXmlParser::getConditionChildValues	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	childName,
		unsigned int	num,
		std::vector< uint64_t > &	dst
	)

private

get values from a child of a condition

getConditionChildValues - Get values from a child of a condition.

Parameters

node	The xml node of the condition.
childName	The name of the child the values should be extracted from.
num	The number of values needed.
dst	A pointer to a vector of uint64_t where the results are written.

Returns: true if succeeded. false if an error occurred or not enough values found.

Definition at line 703 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), getXMLHexTextValue(), mps_fire::i, LogDebug, L1GtXmlParserTags::m_xmlTagValue, and pileupDistInMC::num.

Referenced by parseCalo(), parseEnergySum(), parseHfBitCounts(), parseHfRingEtSums(), parseJetCounts(), and parseMuon().

                                                                                  {
   XERCES_CPP_NAMESPACE_USE
 
   if (node == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "node == 0 in " << __PRETTY_FUNCTION__ << std::endl;
 
     return false;
   }
 
   DOMNode* n1 = findXMLChild(node->getFirstChild(), childName);
 
   // if child not found
   if (n1 == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Child of condition not found ( " << childName << ")" << std::endl;
 
     return false;
   }
 
   // no values are sucessfull
   if (num == 0) {
     return true;
   }
 
   //
   dst.reserve(num);
 
   //
   n1 = findXMLChild(n1->getFirstChild(), m_xmlTagValue);
   for (unsigned int i = 0; i < num; i++) {
     if (n1 == nullptr) {
       LogDebug("L1GtTriggerMenuXmlParser")
           << "Not enough values in condition child ( " << childName << ")" << std::endl;
 
       return false;
     }
 
     if (!getXMLHexTextValue(n1, dst[i])) {
       edm::LogError("L1GtTriggerMenuXmlParser")
           << "Error converting condition child ( " << childName << ") value." << std::endl;
 
       return false;
     }
 
     n1 = findXMLChild(n1->getNextSibling(), m_xmlTagValue);  // next child
   }
 
   return true;
 }

int L1GtTriggerMenuXmlParser::getGEqFlag	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	nodeName
	)

private

getGEqFlag - get the "greater or equal flag" from a condition

Parameters

node	The xml node of the condition. The name of the node from which the flag is a subchild.

Returns: The value of the flag or -1 if no flag was found.

Definition at line 1111 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), getBitFromNode(), LogDebug, and L1GtXmlParserTags::m_xmlTagGEq.

Referenced by parseCalo(), parseCorrelation(), parseEnergySum(), parseHfBitCounts(), parseHfRingEtSums(), parseJetCounts(), and parseMuon().

                                                                                                      {
   XERCES_CPP_NAMESPACE_USE
 
   if (node == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "node == 0 in " << __PRETTY_FUNCTION__ << std::endl;
 
     return -1;
   }
 
   // usually the GEq flag is a child of the first child (the first element node)
   DOMNode* n1 = node->getFirstChild();
   n1 = findXMLChild(n1, nodeName);
 
   if (n1 != nullptr) {
     n1 = findXMLChild(n1->getFirstChild(), m_xmlTagGEq);
     if (n1 == nullptr) {
       LogDebug("L1GtTriggerMenuXmlParser") << "No \"greater or equal\" tag found" << std::endl;
 
       return -1;
     }
 
     return getBitFromNode(n1);
   } else {
     return -1;
   }
 }

bool L1GtTriggerMenuXmlParser::getMuonMipIsoBits	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		unsigned int	num,
		std::vector< bool > &	mipDst,
		std::vector< bool > &	isoEnDst,
		std::vector< bool > &	isoReqDst
	)

private

get MIP and Isolation bits from a muon

getMuonMipIsoBits - get MIP and Isolation bits from a muon.

Parameters

node	The node of the condition.
num	The number of bits required.
mipDst	A pointer to the vector of the MIP bits.
isoEnDst	A pointer to the vector of the "enable isolation" bits.
isoReqDst	A pointer to the vector of the "request isolation" bits.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 1150 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), getBitFromNode(), mps_fire::i, L1GtXmlParserTags::m_xmlTagEnableIso, L1GtXmlParserTags::m_xmlTagEnableMip, L1GtXmlParserTags::m_xmlTagPtLowThreshold, L1GtXmlParserTags::m_xmlTagRequestIso, L1GtXmlParserTags::m_xmlTagValue, and pileupDistInMC::num.

Referenced by parseMuon().

                                                                              {
   XERCES_CPP_NAMESPACE_USE
 
   if (node == nullptr) {
     return false;
   }
 
   // find ptLowThreshold child
   DOMNode* n1 = findXMLChild(node->getFirstChild(), m_xmlTagPtLowThreshold);
 
   if (n1 == nullptr) {
     return false;
   }
 
   // get first value tag
   n1 = findXMLChild(n1->getFirstChild(), m_xmlTagValue);
 
   for (unsigned int i = 0; i < num; i++) {
     if (n1 == nullptr) {
       return false;
     }
 
     // MIP bit
 
     DOMNode* bitnode = findXMLChild(n1->getFirstChild(), m_xmlTagEnableMip);
     if (bitnode == nullptr) {
       return true;
     }
 
     int tmpint = getBitFromNode(bitnode);
     if (tmpint < 0) {
       return false;
     }
 
     mipDst[i] = (tmpint != 0);
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      MIP bit value for muon " << i << " = " << mipDst[i]
     //<< std::endl;
 
     // enable iso bit
     bitnode = findXMLChild(n1->getFirstChild(), m_xmlTagEnableIso);
     if (bitnode == nullptr) {
       return true;
     }
 
     tmpint = getBitFromNode(bitnode);
     if (tmpint < 0) {
       return false;
     }
 
     isoEnDst[i] = (tmpint != 0);
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      Enabled iso bit value for muon " << i << " = " << isoEnDst[i]
     //<< std::endl;
 
     // request iso bit
     bitnode = findXMLChild(n1->getFirstChild(), m_xmlTagRequestIso);
     if (bitnode == nullptr) {
       return true;
     }
 
     tmpint = getBitFromNode(bitnode);
     if (tmpint < 0) {
       return false;
     }
 
     isoReqDst[i] = (tmpint != 0);
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      Request iso bit value for muon " << i << " = " << isoReqDst[i]
     //<< std::endl;
 
     //
     n1 = findXMLChild(n1->getNextSibling(), m_xmlTagValue);  // next value
   }
 
   return true;
 }

int L1GtTriggerMenuXmlParser::getNumFromType ( const std::string & type )

private

get number of particles from condition type

getNumFromType - get the number of particles from a specified type name (for calorimeter objects and muons)

Parameters

type	The name of the type

Returns: The number of particles in this condition. -1 if type not found.

Definition at line 1048 of file L1GtTriggerMenuXmlParser.cc.

References L1GtXmlParserTags::m_xmlConditionAttrType1s, L1GtXmlParserTags::m_xmlConditionAttrType2cor, L1GtXmlParserTags::m_xmlConditionAttrType2s, L1GtXmlParserTags::m_xmlConditionAttrType2wsc, L1GtXmlParserTags::m_xmlConditionAttrType3s, and L1GtXmlParserTags::m_xmlConditionAttrType4s.

Referenced by parseCalo(), and parseMuon().

                                                                   {
   if (type == m_xmlConditionAttrType1s) {
     return 1;
   }
 
   if (type == m_xmlConditionAttrType2s) {
     return 2;
   }
 
   if (type == m_xmlConditionAttrType3s) {
     return 3;
   }
 
   if (type == m_xmlConditionAttrType4s) {
     return 4;
   }
 
   if (type == m_xmlConditionAttrType2wsc) {
     return 2;
   }
 
   if (type == m_xmlConditionAttrType2cor) {
     return 2;
   }
 
   return -1;
 }

L1GtConditionType L1GtTriggerMenuXmlParser::getTypeFromType ( const std::string & type )

private

get the type of the condition, as defined in enum, from the condition type as defined in the XML file

Definition at line 1011 of file L1GtTriggerMenuXmlParser.cc.

References L1GtXmlParserTags::m_xmlConditionAttrType1s, L1GtXmlParserTags::m_xmlConditionAttrType2cor, L1GtXmlParserTags::m_xmlConditionAttrType2s, L1GtXmlParserTags::m_xmlConditionAttrType2wsc, L1GtXmlParserTags::m_xmlConditionAttrType3s, L1GtXmlParserTags::m_xmlConditionAttrType4s, Type1s, Type2cor, Type2s, Type2wsc, Type3s, Type4s, and TypeNull.

Referenced by parseCalo(), and parseMuon().

                                                                                  {
   if (type == m_xmlConditionAttrType1s) {
     return Type1s;
   }
 
   if (type == m_xmlConditionAttrType2s) {
     return Type2s;
   }
 
   if (type == m_xmlConditionAttrType3s) {
     return Type3s;
   }
 
   if (type == m_xmlConditionAttrType4s) {
     return Type4s;
   }
 
   if (type == m_xmlConditionAttrType2wsc) {
     return Type2wsc;
   }
 
   if (type == m_xmlConditionAttrType2cor) {
     return Type2cor;
   }
 
   return TypeNull;
 }

std::string L1GtTriggerMenuXmlParser::getXMLAttribute	(	const XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name
	)

private

get a named attribute for an xml node as string

getXMLAttribute - get a named attribute from a node

Parameters

node	The node to get the attribute from
name	The name of the attribut to get

Returns: The value of the attribute or empty string if an error occurred.

Definition at line 389 of file L1GtTriggerMenuXmlParser.cc.

References fetchall_from_DQM_v2::release, runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by countConditionChildMaxBits(), getBitFromNode(), parseBptx(), parseCalo(), parseCastor(), parseCorrelation(), parseEnergySum(), parseExternal(), parseHfBitCounts(), parseHfRingEtSums(), parseJetCounts(), parseMuon(), workAlgorithm(), workCondition(), and workTechTrigger().

                                                                              {
   XERCES_CPP_NAMESPACE_USE
 
   std::string ret;
 
   // get attributes list
   DOMNamedNodeMap* attributes = node->getAttributes();
   if (attributes == nullptr) {
     return ret;
   }
 
   // get attribute node
   XMLCh* attrName = XMLString::transcode(name.c_str());
   DOMNode* attribNode = attributes->getNamedItem(attrName);
 
   XMLString::release(&attrName);
   if (attribNode == nullptr) {
     return ret;
   }
 
   char* retCstr = XMLString::transcode(attribNode->getNodeValue());
   ret = retCstr;
   XMLString::release(&retCstr);
 
   return ret;
 }

bool L1GtTriggerMenuXmlParser::getXMLHexTextValue	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		uint64_t &	dst
	)

private

get a hexadecimal value of a xml node containing text

getXMLHexTextValue Get the integer representation of a xml text child representing a hex value

Parameters

node	The xml node to get the value from.
dst	The destination the value is written to.

Returns: true if succeeded, false if an error occurred

Definition at line 566 of file L1GtTriggerMenuXmlParser.cc.

References getXMLHexTextValue128().

Referenced by getConditionChildValues(), parseEnergySum(), and parseMuon().

                                                                                                   {
   uint64_t dummyH;    // dummy for eventual higher 64bit
   uint64_t tempUInt;  // temporary unsigned integer
 
   if (!getXMLHexTextValue128(node, tempUInt, dummyH)) {
     return false;
   }
 
   if (dummyH != 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Too large hex-value!" << std::endl;
     return false;
   }
 
   dst = tempUInt;
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::getXMLHexTextValue128	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		uint64_t &	dstL,
		uint64_t &	dstH
	)

private

get a hexadecimal value of a xml node containing text with up to 128 bit

getXMLHexTextValue128 Get the integer representation of a xml-node containing a hexadecimal value. The value may contain up to 128 bits.

node - The reference to the node to get the value from. dstL - The destination for the lower 64bit dstH - The destination for the higher 64bit

Definition at line 533 of file L1GtTriggerMenuXmlParser.cc.

References getXMLTextValue(), hexString2UInt128(), LogDebug, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getXMLHexTextValue(), parseEnergySum(), and parseMuon().

                                                                      {
   if (node == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "node == 0 in " << __PRETTY_FUNCTION__ << std::endl;
 
     return false;
   }
 
   uint64_t tempUIntH, tempUIntL;
 
   std::string tempStr = getXMLTextValue(node);
   if (!hexString2UInt128(tempStr, tempUIntL, tempUIntH)) {
     return false;
   }
 
   dstL = tempUIntL;
   dstH = tempUIntH;
 
   return true;
 }

std::string L1GtTriggerMenuXmlParser::getXMLTextValue ( XERCES_CPP_NAMESPACE::DOMNode * node )

private

get the text value of a xml node as string

getXMLTextValue - get the textvalue from a specified node

Parameters

node	The reference to the node.

Returns: The textvalue of the node or an empty std::string if no textvalue is available.

Definition at line 425 of file L1GtTriggerMenuXmlParser.cc.

References fetchall_from_DQM_v2::release, runTheMatrix::ret, AlCaHLTBitMon_QueryRunRegistry::string, and trim().

Referenced by getBitFromNode(), getXMLHexTextValue128(), parseCorrelation(), parseId(), workAlgorithm(), and workTechTrigger().

                                                                                      {
   XERCES_CPP_NAMESPACE_USE
 
   std::string ret;
 
   DOMNode* n1 = node;
   if (n1 == nullptr) {
     return ret;
   }
 
   const XMLCh* retXmlCh = n1->getTextContent();
   if (retXmlCh == nullptr) {
     return ret;
   }
 
   char* retCstr = XMLString::transcode(retXmlCh);
   XMLString::trim(retCstr);  // trim spaces
 
   ret = retCstr;
   XMLString::release(&retCstr);
 
   return ret;
 }

const AlgorithmMap& L1GtTriggerMenuXmlParser::gtAlgorithmAliasMap ( ) const

inline

get / set the algorithm map (by alias)

Definition at line 203 of file L1GtTriggerMenuXmlParser.h.

References m_algorithmAliasMap.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

203 { return m_algorithmAliasMap; }

L1GtTriggerMenuXmlParser::m_algorithmAliasMap

AlgorithmMap m_algorithmAliasMap

map containing the physics algorithms (by alias)

Definition: L1GtTriggerMenuXmlParser.h:465

const std::string& L1GtTriggerMenuXmlParser::gtAlgorithmImplementation ( ) const

inline

Definition at line 244 of file L1GtTriggerMenuXmlParser.h.

References m_algorithmImplementation.

244 { return m_algorithmImplementation; }

L1GtTriggerMenuXmlParser::m_algorithmImplementation

std::string m_algorithmImplementation

Definition: L1GtTriggerMenuXmlParser.h:429

const AlgorithmMap& L1GtTriggerMenuXmlParser::gtAlgorithmMap ( ) const

inline

get / set the algorithm map (by name)

Definition at line 198 of file L1GtTriggerMenuXmlParser.h.

References m_algorithmMap.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

198 { return m_algorithmMap; }

L1GtTriggerMenuXmlParser::m_algorithmMap

AlgorithmMap m_algorithmMap

map containing the physics algorithms (by name)

Definition: L1GtTriggerMenuXmlParser.h:462

const std::vector<ConditionMap>& L1GtTriggerMenuXmlParser::gtConditionMap ( ) const

inline

get / set / build the condition maps

Definition at line 94 of file L1GtTriggerMenuXmlParser.h.

References m_conditionMap.

94 { return m_conditionMap; }

L1GtTriggerMenuXmlParser::m_conditionMap

std::vector< ConditionMap > m_conditionMap

map containing the conditions (per condition chip) - transient

Definition: L1GtTriggerMenuXmlParser.h:433

const unsigned int L1GtTriggerMenuXmlParser::gtNumberConditionChips ( ) const

inline

get / set the number of condition chips in GTL

Definition at line 62 of file L1GtTriggerMenuXmlParser.h.

References m_numberConditionChips.

62 { return m_numberConditionChips; }

L1GtTriggerMenuXmlParser::m_numberConditionChips

unsigned int m_numberConditionChips

hardware limits

Definition: L1GtTriggerMenuXmlParser.h:400

const unsigned int L1GtTriggerMenuXmlParser::gtNumberL1JetCounts ( ) const

inline

get / set the number of L1 jet counts received by GT

Definition at line 88 of file L1GtTriggerMenuXmlParser.h.

References m_numberL1JetCounts.

88 { return m_numberL1JetCounts; }

L1GtTriggerMenuXmlParser::m_numberL1JetCounts

unsigned int m_numberL1JetCounts

jet counts

Definition: L1GtTriggerMenuXmlParser.h:416

const unsigned int L1GtTriggerMenuXmlParser::gtNumberPhysTriggers ( ) const

inline

get / set the number of physics trigger algorithms

Definition at line 78 of file L1GtTriggerMenuXmlParser.h.

References m_numberPhysTriggers.

78 { return m_numberPhysTriggers; }

L1GtTriggerMenuXmlParser::m_numberPhysTriggers

unsigned int m_numberPhysTriggers

number of physics trigger algorithms

Definition: L1GtTriggerMenuXmlParser.h:410

const unsigned int L1GtTriggerMenuXmlParser::gtNumberTechTriggers ( ) const

inline

get / set the number of technical triggers

Definition at line 83 of file L1GtTriggerMenuXmlParser.h.

References m_numberTechTriggers.

83 { return m_numberTechTriggers; }

L1GtTriggerMenuXmlParser::m_numberTechTriggers

unsigned int m_numberTechTriggers

number of technical triggers

Definition: L1GtTriggerMenuXmlParser.h:413

std::vector<int> L1GtTriggerMenuXmlParser::gtOrderConditionChip ( ) const

inline

get / set the correspondence "condition chip - GTL algorithm word" in the hardware

Definition at line 73 of file L1GtTriggerMenuXmlParser.h.

References m_orderConditionChip.

73 { return m_orderConditionChip; }

L1GtTriggerMenuXmlParser::m_orderConditionChip

std::vector< int > m_orderConditionChip

Definition: L1GtTriggerMenuXmlParser.h:407

const unsigned int L1GtTriggerMenuXmlParser::gtPinsOnConditionChip ( ) const

inline

get / set the number of pins on the GTL condition chips

Definition at line 67 of file L1GtTriggerMenuXmlParser.h.

References m_pinsOnConditionChip.

67 { return m_pinsOnConditionChip; }

L1GtTriggerMenuXmlParser::m_pinsOnConditionChip

unsigned int m_pinsOnConditionChip

number of pins on the GTL condition chips

Definition: L1GtTriggerMenuXmlParser.h:403

const std::string& L1GtTriggerMenuXmlParser::gtScaleDbKey ( ) const

inline

menu associated scale key

Definition at line 114 of file L1GtTriggerMenuXmlParser.h.

References m_scaleDbKey.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

114 { return m_scaleDbKey; }

L1GtTriggerMenuXmlParser::m_scaleDbKey

std::string m_scaleDbKey

menu associated scale key

Definition: L1GtTriggerMenuXmlParser.h:442

const AlgorithmMap& L1GtTriggerMenuXmlParser::gtTechnicalTriggerMap ( ) const

inline

get / set the technical trigger map

Definition at line 208 of file L1GtTriggerMenuXmlParser.h.

References m_technicalTriggerMap.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

208 { return m_technicalTriggerMap; }

L1GtTriggerMenuXmlParser::m_technicalTriggerMap

AlgorithmMap m_technicalTriggerMap

map containing the technical triggers

Definition: L1GtTriggerMenuXmlParser.h:468

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuAuthor ( ) const

inline

Definition at line 236 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuAuthor.

236 { return m_triggerMenuAuthor; }

L1GtTriggerMenuXmlParser::m_triggerMenuAuthor

std::string m_triggerMenuAuthor

Definition: L1GtTriggerMenuXmlParser.h:426

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuDate ( ) const

inline

Definition at line 232 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuDate.

232 { return m_triggerMenuDate; }

L1GtTriggerMenuXmlParser::m_triggerMenuDate

std::string m_triggerMenuDate

Definition: L1GtTriggerMenuXmlParser.h:425

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuDescription ( ) const

inline

Definition at line 240 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuDescription.

240 { return m_triggerMenuDescription; }

L1GtTriggerMenuXmlParser::m_triggerMenuDescription

std::string m_triggerMenuDescription

Definition: L1GtTriggerMenuXmlParser.h:427

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuImplementation ( ) const

inline

Definition at line 109 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuImplementation.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

109 { return m_triggerMenuImplementation; }

L1GtTriggerMenuXmlParser::m_triggerMenuImplementation

std::string m_triggerMenuImplementation

Definition: L1GtTriggerMenuXmlParser.h:439

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuInterface ( ) const

inline

get / set the trigger menu names

Definition at line 99 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuInterface.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

99 { return m_triggerMenuInterface; }

L1GtTriggerMenuXmlParser::m_triggerMenuInterface

std::string m_triggerMenuInterface

menu names

Definition: L1GtTriggerMenuXmlParser.h:437

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuInterfaceAuthor ( ) const

inline

Definition at line 222 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuInterfaceAuthor.

222 { return m_triggerMenuInterfaceAuthor; }

L1GtTriggerMenuXmlParser::m_triggerMenuInterfaceAuthor

std::string m_triggerMenuInterfaceAuthor

Definition: L1GtTriggerMenuXmlParser.h:422

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuInterfaceDate ( ) const

inline

get / set the XML parser creation date, author, description for menu interface, menu

Definition at line 218 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuInterfaceDate.

218 { return m_triggerMenuInterfaceDate; }

L1GtTriggerMenuXmlParser::m_triggerMenuInterfaceDate

std::string m_triggerMenuInterfaceDate

members for XML parser only (do not appear in CondFormats)

Definition: L1GtTriggerMenuXmlParser.h:421

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuInterfaceDescription ( ) const

inline

Definition at line 226 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuInterfaceDescription.

226 { return m_triggerMenuInterfaceDescription; }

L1GtTriggerMenuXmlParser::m_triggerMenuInterfaceDescription

std::string m_triggerMenuInterfaceDescription

Definition: L1GtTriggerMenuXmlParser.h:423

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuName ( ) const

inline

Definition at line 104 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuName.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

104 { return m_triggerMenuName; }

L1GtTriggerMenuXmlParser::m_triggerMenuName

std::string m_triggerMenuName

Definition: L1GtTriggerMenuXmlParser.h:438

bool L1GtTriggerMenuXmlParser::hexString2UInt128	(	const std::string &	hexString,
		uint64_t &	dstL,
		uint64_t &	dstH
	)

private

convert a hexadecimal string with up to 128 to 2 uint64_t

hexString2UInt128 converts an up to 128 bit hexadecimal string to two uint64_t

Parameters

hex	The string to be converted.
dstL	The target for the lower 64 bit.
dstH	The target for the upper 64 bit.

Returns: true if conversion succeeded, false if an error occurred.

Definition at line 459 of file L1GtTriggerMenuXmlParser.cc.

References LogDebug, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by countConditionChildMaxBits(), and getXMLHexTextValue128().

                                                                                                            {
   // string to determine start of hex value, do not ignore leading zeros
   static const std::string valid_hex_start("0123456789ABCDEFabcdef");
 
   // string to determine end of hex value
   static const std::string valid_hex_end("0123456789ABCDEFabcdef");
 
   std::string tempStr = hexString;
 
   // start / end position of the hex value in the string
   unsigned int hexStart = tempStr.find_first_of(valid_hex_start);
   unsigned int hexEnd = tempStr.find_first_not_of(valid_hex_end, hexStart);
 
   if (hexStart == hexEnd) {
     LogDebug("L1GtTriggerMenuXmlParser") << "No hex value found in: " << tempStr << std::endl;
 
     return false;
   }
 
   tempStr = tempStr.substr(hexStart, hexEnd - hexStart);
 
   if (tempStr.empty()) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Empty value in " << __PRETTY_FUNCTION__ << std::endl;
 
     return false;
   }
 
   // split the string
   std::string tempStrH, tempStrL;
 
   if (tempStr.length() > 16) {  // more than 64 bit
     tempStrL = tempStr.substr(tempStr.length() - 16, 16);
     tempStrH = tempStr.substr(0, tempStr.length() - 16);
   } else {
     tempStrL = tempStr;
     tempStrH = "0";
   }
 
   // convert lower 64bit
   char* endPtr = (char*)tempStrL.c_str();
   uint64_t tempUIntL = strtoull(tempStrL.c_str(), &endPtr, 16);
 
   if (*endPtr != 0) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Unable to convert " << tempStr << " to hex." << std::endl;
 
     return false;
   }
 
   // convert higher64 bit
   endPtr = (char*)tempStrH.c_str();
   uint64_t tempUIntH = strtoull(tempStrH.c_str(), &endPtr, 16);
 
   if (*endPtr != 0) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Unable to convert " << tempStr << " to hex." << std::endl;
 
     return false;
   }
 
   dstL = tempUIntL;
   dstH = tempUIntH;
 
   return true;
 }

XERCES_CPP_NAMESPACE::XercesDOMParser * L1GtTriggerMenuXmlParser::initXML ( const std::string & xmlFile )

private

init xml system

initXML - Initialize XML-utilities and try to create a parser for the specified file.

Parameters

xmlFile Filename of the XML-File

Returns: A reference to a XercesDOMParser object if succeeded. 0 if an error occurred.

Definition at line 258 of file L1GtTriggerMenuXmlParser.cc.

References m_xmlErrHandler, writedatasetfile::parser, fetchall_from_DQM_v2::release, and cms::concurrency::xercesInitialize().

Referenced by parseXmlFile().

                                                                                                {
   XERCES_CPP_NAMESPACE_USE
 
   // try to initialize
   try {
     cms::concurrency::xercesInitialize();
   } catch (const XMLException& toCatch) {
     char* message = XMLString::transcode(toCatch.getMessage());
 
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error during Xerces-c initialization! :" << message << std::endl;
 
     XMLString::release(&message);
     return nullptr;
   }
 
   XercesDOMParser* parser = new XercesDOMParser();
   parser->setValidationScheme(XercesDOMParser::Val_Always);
   parser->setDoNamespaces(false);  // we got no dtd
 
   if (m_xmlErrHandler == nullptr) {  // redundant check
     m_xmlErrHandler = (ErrorHandler*)new HandlerBase();
   } else {
     // TODO ASSERTION
   }
   parser->setErrorHandler(m_xmlErrHandler);
 
   // try to parse the file
   try {
     parser->parse(xmlFile.c_str());
   } catch (const XMLException& toCatch) {
     char* message = XMLString::transcode(toCatch.getMessage());
 
     edm::LogError("L1GtTriggerMenuXmlParser") << "Exception while parsing XML: \n" << message << std::endl;
 
     XMLString::release(&message);
     delete parser;
     delete m_xmlErrHandler;
     m_xmlErrHandler = nullptr;
     return nullptr;
   } catch (const DOMException& toCatch) {
     char* message = XMLString::transcode(toCatch.msg);
 
     edm::LogError("L1GtTriggerMenuXmlParser") << "DOM-Exception while parsing XML: \n" << message << std::endl;
 
     XMLString::release(&message);
     delete parser;
     delete m_xmlErrHandler;
     m_xmlErrHandler = nullptr;
     return nullptr;
   } catch (...) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Unexpected Exception while parsing XML!" << std::endl;
 
     delete parser;
     delete m_xmlErrHandler;
     m_xmlErrHandler = nullptr;
     return nullptr;
   }
 
   return parser;
 }

bool L1GtTriggerMenuXmlParser::insertAlgorithmIntoMap ( const L1GtAlgorithm & alg )

private

insert an algorithm into algorithm map

Definition at line 871 of file L1GtTriggerMenuXmlParser.cc.

References L1GtAlgorithm::algoAlias(), L1GtAlgorithm::algoBitNumber(), L1GtAlgorithm::algoChipNumber(), L1GtAlgorithm::algoName(), L1GtAlgorithm::algoOutputPin(), LogTrace, m_algorithmAliasMap, m_algorithmMap, m_numberConditionChips, m_numberPhysTriggers, m_orderConditionChip, m_pinsOnConditionChip, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by workAlgorithm().

                                                                               {
   std::string algName = alg.algoName();
   const std::string& algAlias = alg.algoAlias();
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "    Trying to insert algorithm \"" << algName << "\" in the algorithm map." ;
 
   // no algorithm name has to appear twice!
   if (m_algorithmMap.count(algName) != 0) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      Algorithm \"" << algName
                                          << "\"already exists in the algorithm map- not inserted!" << std::endl;
     return false;
   }
 
   if (m_algorithmAliasMap.count(algAlias) != 0) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      Algorithm alias \"" << algAlias
                                          << "\"already exists in the algorithm alias map- not inserted!" << std::endl;
     return false;
   }
 
   // bit number less than zero or greater than maximum number of algorithms
   int bitNumber = alg.algoBitNumber();
   if ((bitNumber < 0) || (bitNumber >= static_cast<int>(m_numberPhysTriggers))) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      Bit number " << bitNumber << " outside allowed range [0, "
                                          << m_numberPhysTriggers << ") - algorithm not inserted!" << std::endl;
     return false;
   }
 
   // maximum number of algorithms
   if (m_algorithmMap.size() >= m_numberPhysTriggers) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      More than maximum allowed " << m_numberPhysTriggers
                                          << " algorithms in the algorithm map - not inserted!" << std::endl;
     return false;
   }
 
   // chip number outside allowed values
   int chipNr = alg.algoChipNumber(
       static_cast<int>(m_numberConditionChips), static_cast<int>(m_pinsOnConditionChip), m_orderConditionChip);
 
   if ((chipNr < 0) || (chipNr > static_cast<int>(m_numberConditionChips))) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      Chip number " << chipNr << " outside allowed range [0, "
                                          << m_numberConditionChips << ") - algorithm not inserted!" << std::endl;
     return false;
   }
 
   // output pin outside allowed values
   int outputPin = alg.algoOutputPin(
       static_cast<int>(m_numberConditionChips), static_cast<int>(m_pinsOnConditionChip), m_orderConditionChip);
 
   if ((outputPin < 0) || (outputPin > static_cast<int>(m_pinsOnConditionChip))) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      Output pin " << outputPin << " outside allowed range [0, "
                                          << m_pinsOnConditionChip << "] - algorithm not inserted!" << std::endl;
     return false;
   }
 
   // no two algorithms on the same chip can have the same output pin
   for (CItAlgo itAlgo = m_algorithmMap.begin(); itAlgo != m_algorithmMap.end(); itAlgo++) {
     int iPin = (itAlgo->second)
                    .algoOutputPin(static_cast<int>(m_numberConditionChips),
                                   static_cast<int>(m_pinsOnConditionChip),
                                   m_orderConditionChip);
     std::string iName = itAlgo->first;
     int iChip = (itAlgo->second)
                     .algoChipNumber(static_cast<int>(m_numberConditionChips),
                                     static_cast<int>(m_pinsOnConditionChip),
                                     m_orderConditionChip);
 
     if ((outputPin == iPin) && (chipNr == iChip)) {
       LogTrace("L1GtTriggerMenuXmlParser")
           << "      Output pin " << outputPin << " is the same as for algorithm " << iName
           << "\n      from the same chip number " << chipNr << " - algorithm not inserted!" << std::endl;
       return false;
     }
   }
 
   // insert algorithm
   m_algorithmMap[algName] = alg;
   m_algorithmAliasMap[algAlias] = alg;
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      OK - algorithm inserted!"
   //<< std::endl;
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::insertConditionIntoMap	(	L1GtCondition &	cond,
		const int	chipNr
	)

private

insertConditionIntoMap - safe insert of condition into condition map. if the condition name already exists, do not insert it and return false

Definition at line 850 of file L1GtTriggerMenuXmlParser.cc.

References L1GtCondition::condName(), submitPVResolutionJobs::count, LogTrace, m_conditionMap, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parseBptx(), parseCalo(), parseCastor(), parseCorrelation(), parseEnergySum(), parseExternal(), parseHfBitCounts(), parseHfRingEtSums(), parseJetCounts(), and parseMuon().

                                                                                            {
   std::string cName = cond.condName();
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "    Trying to insert condition \"" << cName << "\" in the condition map." ;
 
   // no condition name has to appear twice!
   if ((m_conditionMap[chipNr]).count(cName) != 0) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      Condition " << cName << " already exists - not inserted!"
                                          << std::endl;
     return false;
   }
 
   (m_conditionMap[chipNr])[cName] = &cond;
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      OK - condition inserted!"
   //<< std::endl;
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::insertTechTriggerIntoMap ( const L1GtAlgorithm & alg )

private

insert a technical trigger into technical trigger map

Definition at line 957 of file L1GtTriggerMenuXmlParser.cc.

References L1GtAlgorithm::algoBitNumber(), L1GtAlgorithm::algoName(), LogTrace, m_numberTechTriggers, m_technicalTriggerMap, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by workTechTrigger().

                                                                                 {
   std::string algName = alg.algoName();
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "    Trying to insert technical trigger \"" << algName
   //<< "\" in the technical trigger map." ;
 
   // no technical trigger name has to appear twice!
   if (m_technicalTriggerMap.count(algName) != 0) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      Technical trigger \"" << algName
                                          << "\"already exists in the technical trigger map- not inserted!" << std::endl;
     return false;
   }
 
   // bit number less than zero or greater than maximum number of technical triggers
   int bitNumber = alg.algoBitNumber();
   if ((bitNumber < 0) || (bitNumber >= static_cast<int>(m_numberTechTriggers))) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      Bit number " << bitNumber << " outside allowed range [0, "
                                          << m_numberTechTriggers << ") - technical trigger not inserted!" << std::endl;
     return false;
   }
 
   // no two technical triggers can have the same bit number
   for (CItAlgo itAlgo = m_technicalTriggerMap.begin(); itAlgo != m_technicalTriggerMap.end(); itAlgo++) {
     int iBitNumber = (itAlgo->second).algoBitNumber();
     std::string iName = itAlgo->first;
 
     if (iBitNumber == bitNumber) {
       LogTrace("L1GtTriggerMenuXmlParser")
           << "      Bit number " << iBitNumber << " is the same as for technical trigger " << iName
           << " - technical trigger not inserted!" << std::endl;
       return false;
     }
   }
 
   // maximum number of technical triggers
   if (m_technicalTriggerMap.size() >= m_numberTechTriggers) {
     LogTrace("L1GtTriggerMenuXmlParser") << "      More than maximum allowed " << m_numberTechTriggers
                                          << " technical triggers in the technical trigger map - not inserted!"
                                          << std::endl;
     return false;
   }
 
   // insert technical trigger
   m_technicalTriggerMap[algName] = alg;
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      OK - technical trigger inserted!"
   //<< std::endl;
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseAlgorithms ( XERCES_CPP_NAMESPACE::XercesDOMParser * parser )

private

parse all algorithms

Definition at line 3193 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), m_numberConditionChips, L1GtXmlParserTags::m_xmlTagAlgorithms, L1GtXmlParserTags::m_xmlTagChip, L1GtXmlParserTags::m_xmlTagDef, AlCaHLTBitMon_QueryRunRegistry::string, and workAlgorithm().

Referenced by workXML().

                                                                                           {
   XERCES_CPP_NAMESPACE_USE
 
   //LogTrace("L1GtTriggerMenuXmlParser") << "\nParsing algorithms" << std::endl;
 
   DOMNode* doc = parser->getDocument();
   DOMNode* node = doc->getFirstChild();
 
   DOMNode* chipNode = node->getFirstChild();
   if (chipNode == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "  Error: No child found for " << m_xmlTagDef << std::endl;
     return false;
   }
 
   // find first chip
   std::string chipName;
   chipNode = findXMLChild(chipNode, m_xmlTagChip, true, &chipName);
   if (chipNode == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "  Error: Could not find <" << m_xmlTagChip << std::endl;
     return false;
   }
 
   unsigned int chipNr = 0;
   do {
     //LogTrace("L1GtTriggerMenuXmlParser") << std::endl;
 
     std::string nodeName = m_xmlTagChip + chipName;
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "  Chip: " << nodeName << " Name: " << chipName
     //<< std::endl;
 
     // find algorithms
     DOMNode* algNode = chipNode->getFirstChild();
     algNode = findXMLChild(algNode, m_xmlTagAlgorithms);
     if (algNode == nullptr) {
       edm::LogError("L1GtTriggerMenuXmlParser")
           << "    Error: No <" << m_xmlTagAlgorithms << "> child found in chip " << chipName << std::endl;
       return false;
     }
 
     // walk through algorithms
     DOMNode* algNameNode = algNode->getFirstChild();
     std::string algNameNodeName;
     algNameNode = findXMLChild(algNameNode, "", true, &algNameNodeName);
 
     while (algNameNode != nullptr) {
       //LogTrace("L1GtTriggerMenuXmlParser")
       //<< "    Found an algorithm with name: " << algNameNodeName
       //<< std::endl;
 
       if (!workAlgorithm(algNameNode, algNameNodeName, chipNr)) {
         return false;
       }
 
       algNameNode = findXMLChild(algNameNode->getNextSibling(), "", true, &algNameNodeName);
     }
 
     // next chip
     chipNode = findXMLChild(chipNode->getNextSibling(), m_xmlTagChip, true, &chipName);
     chipNr++;
 
   } while (chipNode != nullptr && chipNr < m_numberConditionChips);
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseBptx	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`
	)

private

parse a Bptx condition

parseBptx Parse a BPTX condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 2352 of file L1GtTriggerMenuXmlParser.cc.

References getXMLAttribute(), insertConditionIntoMap(), LogTrace, m_vecBptxTemplate, L1GtXmlParserTags::m_xmlConditionAttrCondition, L1GtXmlParserTags::m_xmlConditionAttrObject, L1GtXmlParserTags::m_xmlConditionAttrObjectBptx, L1GtXmlParserTags::m_xmlConditionAttrType, push_back(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtCondition::setCondType(), AlCaHLTBitMon_QueryRunRegistry::string, and TypeBptx.

Referenced by workCondition().

                                                               {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   if (particle != m_xmlConditionAttrObjectBptx) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "\nError: wrong particle for Bptx condition (" << particle << ")" << std::endl;
     return false;
   }
 
   // object type and condition type
   // object type - irrelevant for BPTX conditions
   L1GtConditionType cType = TypeBptx;
 
   // no objects for BPTX conditions
 
   // set the boolean value for the ge_eq mode - irrelevant for BPTX conditions
   bool gEq = false;
 
   // now create a new BPTX condition
 
   L1GtBptxTemplate bptxCond(name);
 
   bptxCond.setCondType(cType);
   bptxCond.setCondGEq(gEq);
   bptxCond.setCondChipNr(chipNr);
 
   LogTrace("L1GtTriggerMenuXmlParser") << bptxCond << "\n" << std::endl;
 
   // insert condition into the map
   if (!insertConditionIntoMap(bptxCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
 
     return false;
   } else {
     (m_vecBptxTemplate[chipNr]).push_back(bptxCond);
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseCalo	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`,
		const bool	corrFlag = `false`
	)

private

parse a calorimeter condition

parseCalo Parse a calo condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 1513 of file L1GtTriggerMenuXmlParser.cc.

Referenced by parseCorrelation(), and workCondition().

                                                               {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   // determine object type type
   L1GtObject caloObjType;
 
   if (particle == m_xmlConditionAttrObjectNoIsoEG) {
     caloObjType = NoIsoEG;
   } else if (particle == m_xmlConditionAttrObjectIsoEG) {
     caloObjType = IsoEG;
   } else if (particle == m_xmlConditionAttrObjectCenJet) {
     caloObjType = CenJet;
   } else if (particle == m_xmlConditionAttrObjectTauJet) {
     caloObjType = TauJet;
   } else if (particle == m_xmlConditionAttrObjectForJet) {
     caloObjType = ForJet;
   } else {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Wrong particle for calo-condition (" << particle << ")" << std::endl;
     return false;
   }
 
   int nrObj = getNumFromType(type);
   if (nrObj < 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Unknown type for calo-condition (" << type << ")"
                                               << "\nCan not determine number of trigger objects. " << std::endl;
     return false;
   }
 
   // get greater equal flag
 
   int intGEq = getGEqFlag(node, m_xmlTagEtThreshold);
   if (intGEq < 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag" << std::endl;
     return false;
   }
   // set the boolean value for the ge_eq mode
   bool gEq = (intGEq != 0);
 
   // get values
 
   // temporary storage of the parameters
   std::vector<L1GtCaloTemplate::ObjectParameter> objParameter(nrObj);
   L1GtCaloTemplate::CorrelationParameter corrParameter;
 
   // need at least one value for deltaPhiRange
   std::vector<uint64_t> tmpValues((nrObj > 1) ? nrObj : 1);
 
   // get etThreshold values and fill into structure
   if (!getConditionChildValues(node, m_xmlTagEtThreshold, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].etThreshold = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      Calo ET high threshold (hex) for calo object " << i << " = "
     //<< std::hex << objParameter[i].etThreshold << std::dec
     //<< std::endl;
   }
 
   // get etaRange and fill into structure
   if (!getConditionChildValues(node, m_xmlTagEta, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].etaRange = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      etaRange (hex) for calo object " << i << " = "
     //<< std::hex << objParameter[i].etaRange << std::dec
     //<< std::endl;
   }
 
   // get phiRange values and fill into structure
   if (!getConditionChildValues(node, m_xmlTagPhi, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].phiRange = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      phiRange (hex) for calo object " << i << " = "
     //<< std::hex << objParameter[i].phiRange << std::dec
     //<< std::endl;
   }
 
   // indicates if a correlation is used
   bool wscVal = (type == m_xmlConditionAttrType2wsc);
 
   if (wscVal) {
     // get deltaEtaRange
     if (!getConditionChildValues(node, m_xmlTagDeltaEta, 1, tmpValues)) {
       return false;
     }
 
     corrParameter.deltaEtaRange = tmpValues[0];
 
     // get deltaPhiRange
     if (!getConditionChildValues(node, m_xmlTagDeltaPhi, 1, tmpValues)) {
       return false;
     }
 
     corrParameter.deltaPhiRange = tmpValues[0];
 
     // get maximum number of bits for delta phi
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      Counting deltaPhiMaxbits"
     //<< std::endl;
 
     unsigned int maxbits;
 
     if (!countConditionChildMaxBits(node, m_xmlTagDeltaPhi, maxbits)) {
       return false;
     }
 
     corrParameter.deltaPhiMaxbits = maxbits;
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "        deltaPhiMaxbits (dec) = " << maxbits
     //<< std::endl;
   }
 
   // get the type of the condition, as defined in enum, from the condition type
   // as defined in the XML file
   L1GtConditionType cType = getTypeFromType(type);
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Condition type (enum value) = " << cType
   //<< std::endl;
 
   if (cType == TypeNull) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "Type for calo condition id TypeNull - it means not defined in the XML file."
         << "\nNumber of trigger objects is set to zero. " << std::endl;
     return false;
   }
 
   // object types - all same caloObjType
   std::vector<L1GtObject> objType(nrObj, caloObjType);
 
   // now create a new calo condition
 
   L1GtCaloTemplate caloCond(name);
 
   caloCond.setCondType(cType);
   caloCond.setObjectType(objType);
   caloCond.setCondGEq(gEq);
   caloCond.setCondChipNr(chipNr);
 
   caloCond.setConditionParameter(objParameter, corrParameter);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     caloCond.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert condition into the map
   if (!insertConditionIntoMap(caloCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
 
     return false;
   } else {
     if (corrFlag) {
       (m_corCaloTemplate[chipNr]).push_back(caloCond);
     } else {
       (m_vecCaloTemplate[chipNr]).push_back(caloCond);
     }
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseCastor	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`
	)

private

parse a CASTOR condition

parseCastor Parse a CASTOR condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 2048 of file L1GtTriggerMenuXmlParser.cc.

References getXMLAttribute(), insertConditionIntoMap(), edm::isDebugEnabled(), LogTrace, m_vecCastorTemplate, L1GtXmlParserTags::m_xmlConditionAttrCondition, L1GtXmlParserTags::m_xmlConditionAttrObject, L1GtXmlParserTags::m_xmlConditionAttrObjectCastor, L1GtXmlParserTags::m_xmlConditionAttrType, L1GtCastorTemplate::print(), push_back(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtCondition::setCondType(), AlCaHLTBitMon_QueryRunRegistry::string, and TypeCastor.

Referenced by workCondition().

                                                                 {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   if (particle != m_xmlConditionAttrObjectCastor) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "\nError: wrong particle for Castor condition (" << particle << ")" << std::endl;
     return false;
   }
 
   // object type and condition type
   // object type - irrelevant for CASTOR conditions
   L1GtConditionType cType = TypeCastor;
 
   // no objects for CASTOR conditions
 
   // set the boolean value for the ge_eq mode - irrelevant for CASTOR conditions
   bool gEq = false;
 
   // now create a new CASTOR condition
 
   L1GtCastorTemplate castorCond(name);
 
   castorCond.setCondType(cType);
   castorCond.setCondGEq(gEq);
   castorCond.setCondChipNr(chipNr);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     castorCond.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert condition into the map
   if (!insertConditionIntoMap(castorCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
 
     return false;
   } else {
     (m_vecCastorTemplate[chipNr]).push_back(castorCond);
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseConditions ( XERCES_CPP_NAMESPACE::XercesDOMParser * parser )

private

parse all conditions

parseConditions - look for conditions and call the workCondition function for each node

Parameters

parser The parser to parse the XML file with.

Returns: "true" if succeeded. "false" if an error occurred.

Definition at line 3008 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), LogTrace, m_numberConditionChips, L1GtXmlParserTags::m_xmlTagChip, L1GtXmlParserTags::m_xmlTagConditions, L1GtXmlParserTags::m_xmlTagDef, fetchall_from_DQM_v2::release, AlCaHLTBitMon_QueryRunRegistry::string, and workCondition().

Referenced by workXML().

                                                                                           {
   XERCES_CPP_NAMESPACE_USE
 
   LogTrace("L1GtTriggerMenuXmlParser") << "\nParsing conditions" << std::endl;
 
   DOMNode* doc = parser->getDocument();
   DOMNode* n1 = doc->getFirstChild();
 
   // we assume that the first child is m_xmlTagDef because it was checked in workXML
 
   DOMNode* chipNode = n1->getFirstChild();
   if (chipNode == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error: No child of <" << m_xmlTagDef << "> tag found." << std::endl;
 
     return false;
   }
 
   // find chip
 
   std::string chipName;  // name of the actual chip
   chipNode = findXMLChild(chipNode, m_xmlTagChip, true, &chipName);
   if (chipNode == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "  Error: Could not find <" << m_xmlTagChip << "> tag" << std::endl;
 
     return false;
   }
 
   unsigned int chipNr = 0;
   do {
     // find conditions
     DOMNode* conditionsNode = chipNode->getFirstChild();
     conditionsNode = findXMLChild(conditionsNode, m_xmlTagConditions);
     if (conditionsNode == nullptr) {
       edm::LogError("L1GtTriggerMenuXmlParser")
           << "Error: No <" << m_xmlTagConditions << "> child found in Chip " << chipName << std::endl;
 
       return false;
     }
 
     char* nodeName = XMLString::transcode(chipNode->getNodeName());
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "\n  Found Chip: " << nodeName << " Name: " << chipName
     //<< std::endl;
 
     XMLString::release(&nodeName);
 
     // walk through conditions
     DOMNode* conditionNameNode = conditionsNode->getFirstChild();
     std::string conditionNameNodeName;
     conditionNameNode = findXMLChild(conditionNameNode, "", true, &conditionNameNodeName);
     while (conditionNameNode != nullptr) {
       LogTrace("L1GtTriggerMenuXmlParser")
           << "\n    Found a condition with name: " << conditionNameNodeName << std::endl;
 
       if (!workCondition(conditionNameNode, conditionNameNodeName, chipNr)) {
         return false;
       }
       conditionNameNode = findXMLChild(conditionNameNode->getNextSibling(), "", true, &conditionNameNodeName);
     }
     // next chip
     chipNode = findXMLChild(chipNode->getNextSibling(), m_xmlTagChip, true, &chipName);
     chipNr++;
 
   } while (chipNode != nullptr && chipNr < m_numberConditionChips);
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseCorrelation	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`
	)

private

parse a correlation condition

parseCorrelation Parse a correlation condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 2472 of file L1GtTriggerMenuXmlParser.cc.

Referenced by workCondition().

                                                                      {
   XERCES_CPP_NAMESPACE_USE
 
   // create a new correlation condition
   L1GtCorrelationTemplate correlationCond(name);
 
   // check that the condition does not exist already in the map
   if (!insertConditionIntoMap(correlationCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "    Error: duplicate correlation condition (" << name << ")" << std::endl;
 
     return false;
   }
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   LogTrace("L1GtTriggerMenuXmlParser") << "    Condition category: " << condition << ", particle: " << particle
                                        << ", type: " << type << "\n"
                                        << std::endl;
 
   // condition type
   L1GtConditionType cType = Type2cor;
 
   // two objects (for sure)
   const int nrObj = 2;
 
   // object types and greater equal flag - filled in the loop
   int intGEq[nrObj] = {-1, -1};
   std::vector<L1GtObject> objType(nrObj);
   std::vector<L1GtConditionCategory> condCateg(nrObj);
 
   // correlation flag and index in the cor*vector
   const bool corrFlag = true;
   int corrIndexVal[nrObj] = {-1, -1};
 
   // get the subconditions
 
   DOMNode* conditionsNode = node->getFirstChild();
   std::string conditionNameNodeName;
   conditionsNode = findXMLChild(conditionsNode, "", true, &conditionNameNodeName);
 
   for (int iSubCond = 0; iSubCond < nrObj; ++iSubCond) {
     // get for sub-condition:  category, object name and type name and condition name
     condition = getXMLAttribute(conditionsNode, m_xmlConditionAttrCondition);
     particle = getXMLAttribute(conditionsNode, m_xmlConditionAttrObject);
     type = getXMLAttribute(conditionsNode, m_xmlConditionAttrType);
 
     LogTrace("L1GtTriggerMenuXmlParser") << "    Sub-condition category: " << condition << ", particle: " << particle
                                          << ", type: " << type << ", name: " << conditionNameNodeName << "\n"
                                          << std::endl;
 
     // call the appropriate function for this condition
     if (condition == m_xmlConditionAttrConditionMuon) {
       if (!parseMuon(conditionsNode, conditionNameNodeName, chipNr, corrFlag)) {
         edm::LogError("L1GtTriggerMenuXmlParser") << "Error parsing sub-condition " << condition << ")"
                                                   << " with name " << conditionNameNodeName << std::endl;
       }
 
       // get greater equal flag
       intGEq[iSubCond] = getGEqFlag(conditionsNode, m_xmlTagPtHighThreshold);
       if (intGEq[iSubCond] < 0) {
         edm::LogError("L1GtTriggerMenuXmlParser")
             << "Error getting \"greater or equal\" flag"
             << " for sub-condition " << conditionNameNodeName << " for the correlation condition " << name << std::endl;
         return false;
       }
 
       // set object type and sub-condition category
       objType[iSubCond] = Mu;
       condCateg[iSubCond] = CondMuon;
       corrIndexVal[iSubCond] = (m_corMuonTemplate[chipNr]).size() - 1;
 
     } else if (condition == m_xmlConditionAttrConditionCalo) {
       if (!parseCalo(conditionsNode, conditionNameNodeName, chipNr, corrFlag)) {
         edm::LogError("L1GtTriggerMenuXmlParser") << "Error parsing sub-condition " << condition << ")"
                                                   << " with name " << conditionNameNodeName << std::endl;
       }
 
       // get greater equal flag
       intGEq[iSubCond] = getGEqFlag(conditionsNode, m_xmlTagEtThreshold);
       if (intGEq[iSubCond] < 0) {
         edm::LogError("L1GtTriggerMenuXmlParser")
             << "Error getting \"greater or equal\" flag"
             << " for sub-condition " << conditionNameNodeName << " for the correlation condition " << name << std::endl;
         return false;
       }
 
       // set object type and sub-condition category
       if (particle == m_xmlConditionAttrObjectNoIsoEG) {
         objType[iSubCond] = NoIsoEG;
       } else if (particle == m_xmlConditionAttrObjectIsoEG) {
         objType[iSubCond] = IsoEG;
       } else if (particle == m_xmlConditionAttrObjectCenJet) {
         objType[iSubCond] = CenJet;
       } else if (particle == m_xmlConditionAttrObjectTauJet) {
         objType[iSubCond] = TauJet;
       } else if (particle == m_xmlConditionAttrObjectForJet) {
         objType[iSubCond] = ForJet;
       } else {
         edm::LogError("L1GtTriggerMenuXmlParser")
             << "Wrong object type " << particle << " for sub-condition " << conditionNameNodeName
             << " from the correlation condition " << name << std::endl;
         return false;
       }
 
       condCateg[iSubCond] = CondCalo;
       corrIndexVal[iSubCond] = (m_corCaloTemplate[chipNr]).size() - 1;
 
     } else if (condition == m_xmlConditionAttrConditionEnergySum) {
       if (!parseEnergySum(conditionsNode, conditionNameNodeName, chipNr, corrFlag)) {
         edm::LogError("L1GtTriggerMenuXmlParser") << "Error parsing sub-condition " << condition << ")"
                                                   << " with name " << conditionNameNodeName << std::endl;
       }
 
       // get greater equal flag
       intGEq[iSubCond] = getGEqFlag(conditionsNode, m_xmlTagEtThreshold);
       if (intGEq[iSubCond] < 0) {
         edm::LogError("L1GtTriggerMenuXmlParser")
             << "Error getting \"greater or equal\" flag"
             << " for sub-condition " << conditionNameNodeName << " for the correlation condition " << name << std::endl;
         return false;
       }
 
       // set object type and sub-condition category
       if (particle == m_xmlConditionAttrObjectETM) {
         objType[iSubCond] = ETM;
       } else if (particle == m_xmlConditionAttrObjectETT) {
         objType[iSubCond] = ETT;
       } else if (particle == m_xmlConditionAttrObjectHTT) {
         objType[iSubCond] = HTT;
       } else if (particle == m_xmlConditionAttrObjectHTM) {
         objType[iSubCond] = HTM;
       } else {
         edm::LogError("L1GtTriggerMenuXmlParser")
             << "Wrong object type " << particle << " for sub-condition " << conditionNameNodeName
             << " from the correlation condition " << name << std::endl;
         return false;
       }
 
       condCateg[iSubCond] = CondEnergySum;
       corrIndexVal[iSubCond] = (m_corEnergySumTemplate[chipNr]).size() - 1;
 
     } else {
       edm::LogError("L1GtTriggerMenuXmlParser")
           << "Unknown or un-adequate sub-condition (" << condition << ")"
           << " with name " << conditionNameNodeName << " for the correlation condition " << name << std::endl;
 
       return false;
     }
 
     conditionsNode = findXMLChild(conditionsNode->getNextSibling(), "", true, &conditionNameNodeName);
   }
 
   // get greater equal flag for the correlation condition
   bool gEq = true;
   if (intGEq[0] != intGEq[1]) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "Inconsistent GEq flags for sub-conditions (" << condition << ")"
         << " with name " << conditionNameNodeName << " for the correlation condition " << name << std::endl;
     return false;
 
   } else {
     gEq = (intGEq[0] != 0);
   }
 
   // correlation parameters
 
   // temporary storage of the parameters
   L1GtCorrelationTemplate::CorrelationParameter corrParameter;
   std::vector<uint64_t> tmpValues(nrObj);
 
   // get deltaEtaRange
   //    if ( !getConditionChildValues(node, m_xmlTagDeltaEta, 1, tmpValues) ) {
   //        return false;
   //    }
   //
   //    corrParameter.deltaEtaRange = tmpValues[0];
 
   XERCES_CPP_NAMESPACE::DOMNode* node1 = findXMLChild(node->getFirstChild(), m_xmlTagDeltaEta);
 
   std::string valString;
 
   if (node1 == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "    Could not get deltaEta for correlation condition " << name << ". " << std::endl;
     return false;
   } else {
     valString = getXMLTextValue(node1);
   }
 
   corrParameter.deltaEtaRange = valString;
 
   //    // deltaPhi is larger than 64bit
   //    if ( !getXMLHexTextValue128(findXMLChild(node->getFirstChild(), m_xmlTagDeltaPhi),
   //        tmpValues[0], tmpValues[1])) {
   //        edm::LogError("L1GtTriggerMenuXmlParser")
   //            << "    Could not get deltaPhi for correlation condition " << name << ". "
   //            << std::endl;
   //        return false;
   //    }
   //
   //    corrParameter.deltaPhiRange = tmpValues[0];
 
   node1 = findXMLChild(node->getFirstChild(), m_xmlTagDeltaPhi);
 
   if (node1 == nullptr) {
     return false;
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "    Could not get deltaPhi for correlation condition " << name << ". " << std::endl;
   } else {
     valString = getXMLTextValue(node1);
   }
 
   corrParameter.deltaPhiRange = valString;
 
   // get maximum number of bits for delta phi
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Counting deltaPhiMaxbits"
   //<< std::endl;
 
   unsigned int maxbits;
 
   if (!countConditionChildMaxBits(node, m_xmlTagDeltaPhi, maxbits)) {
     return false;
   }
 
   corrParameter.deltaPhiMaxbits = maxbits;
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "        deltaPhiMaxbits (dec) = " << maxbits
   //<< std::endl;
 
   // fill the correlation condition
   correlationCond.setCondType(cType);
   correlationCond.setObjectType(objType);
   correlationCond.setCondGEq(gEq);
   correlationCond.setCondChipNr(chipNr);
 
   correlationCond.setCond0Category(condCateg[0]);
   correlationCond.setCond1Category(condCateg[1]);
 
   correlationCond.setCond0Index(corrIndexVal[0]);
   correlationCond.setCond1Index(corrIndexVal[1]);
 
   correlationCond.setCorrelationParameter(corrParameter);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     correlationCond.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert condition into the map
   // condition is not duplicate, check was done at the beginning
 
   (m_vecCorrelationTemplate[chipNr]).push_back(correlationCond);
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseEnergySum	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`,
		const bool	corrFlag = `false`
	)

private

parse an "energy sum" condition

parseEnergySum Parse an "energy sum" condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 1707 of file L1GtTriggerMenuXmlParser.cc.

Referenced by parseCorrelation(), and workCondition().

                                                                    {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   // determine object type type
   L1GtObject energySumObjType;
   L1GtConditionType cType;
 
   if ((particle == m_xmlConditionAttrObjectETM) && (type == m_xmlConditionAttrObjectETM)) {
     energySumObjType = ETM;
     cType = TypeETM;
 
   } else if ((particle == m_xmlConditionAttrObjectETT) && (type == m_xmlConditionAttrObjectETT)) {
     energySumObjType = ETT;
     cType = TypeETT;
 
   } else if ((particle == m_xmlConditionAttrObjectHTT) && (type == m_xmlConditionAttrObjectHTT)) {
     energySumObjType = HTT;
     cType = TypeHTT;
 
   } else if ((particle == m_xmlConditionAttrObjectHTM) && (type == m_xmlConditionAttrObjectHTM)) {
     energySumObjType = HTM;
     cType = TypeHTM;
 
   } else {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "Wrong particle or type for energy-sum condition (" << particle << ", " << type << ")" << std::endl;
     return false;
   }
 
   // global object
   int nrObj = 1;
 
   // get greater equal flag
 
   int intGEq = getGEqFlag(node, m_xmlTagEtThreshold);
   if (intGEq < 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag" << std::endl;
     return false;
   }
   // set the boolean value for the ge_eq mode
   bool gEq = (intGEq != 0);
 
   // get values
 
   // temporary storage of the parameters
   std::vector<L1GtEnergySumTemplate::ObjectParameter> objParameter(nrObj);
 
   // need at least two values for phi
   std::vector<uint64_t> tmpValues((nrObj > 2) ? nrObj : 2);
 
   // get etThreshold values and fill into structure
   if (!getConditionChildValues(node, m_xmlTagEtThreshold, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].etThreshold = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      EnergySum ET high threshold (hex) for energySum object " << i << " = "
     //<< std::hex << objParameter[i].etThreshold << std::dec
     //<< std::endl;
 
     // for ETM and HTM read phi value
     // phi is larger than 64 bits for ETM - it needs two 64bits words
     // phi is less than 64 bits for HTM   - it needs one 64bits word
     if (energySumObjType == ETM) {
       if (!getXMLHexTextValue128(findXMLChild(node->getFirstChild(), m_xmlTagPhi), tmpValues[0], tmpValues[1])) {
         edm::LogError("L1GtTriggerMenuXmlParser")
             << "    Could not get phi for ETM condition (" << name << ")" << std::endl;
         return false;
       }
 
       objParameter[i].phiRange0Word = tmpValues[0];
       objParameter[i].phiRange1Word = tmpValues[1];
 
     } else if (energySumObjType == HTM) {
       if (!getXMLHexTextValue(findXMLChild(node->getFirstChild(), m_xmlTagPhi), tmpValues[0])) {
         edm::LogError("L1GtTriggerMenuXmlParser")
             << "    Could not get phi for HTM condition (" << name << ")" << std::endl;
         return false;
       }
 
       objParameter[i].phiRange0Word = tmpValues[0];
     }
 
     // get energyOverflow logical flag and fill into structure
     DOMNode* n1;
     if ((n1 = findXMLChild(node->getFirstChild(), m_xmlTagEtThreshold)) == nullptr) {
       edm::LogError("L1GtTriggerMenuXmlParser")
           << "    Could not get energyOverflow for EnergySum condition (" << name << ")" << std::endl;
       return false;
     }
     if ((n1 = findXMLChild(n1->getFirstChild(), m_xmlTagEnergyOverflow)) == nullptr) {
       edm::LogError("L1GtTriggerMenuXmlParser")
           << "    Could not get energyOverflow for EnergySum condition (" << name << ")" << std::endl;
       return false;
     }
 
     int tmpInt = getBitFromNode(n1);
     if (tmpInt == 0) {
       objParameter[i].energyOverflow = false;
 
       //LogTrace("L1GtTriggerMenuXmlParser")
       //<< "      EnergySum energyOverflow logical flag (hex) = "
       //<< std::hex << objParameter[i].energyOverflow << std::dec
       //<< std::endl;
     } else if (tmpInt == 1) {
       objParameter[i].energyOverflow = true;
 
       //LogTrace("L1GtTriggerMenuXmlParser")
       //<< "      EnergySum energyOverflow logical flag (hex) = "
       //<< std::hex << objParameter[i].energyOverflow << std::dec
       //<< std::endl;
     } else {
       LogTrace("L1GtTriggerMenuXmlParser") << "      EnergySum energyOverflow logical flag (hex) = " << std::hex
                                            << tmpInt << std::dec << " - wrong value! " << std::endl;
       return false;
     }
   }
 
   // object types - all same energySumObjType
   std::vector<L1GtObject> objType(nrObj, energySumObjType);
 
   // now create a new energySum condition
 
   L1GtEnergySumTemplate energySumCond(name);
 
   energySumCond.setCondType(cType);
   energySumCond.setObjectType(objType);
   energySumCond.setCondGEq(gEq);
   energySumCond.setCondChipNr(chipNr);
 
   energySumCond.setConditionParameter(objParameter);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     energySumCond.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert condition into the map
   if (!insertConditionIntoMap(energySumCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
 
     return false;
   } else {
     if (corrFlag) {
       (m_corEnergySumTemplate[chipNr]).push_back(energySumCond);
 
     } else {
       (m_vecEnergySumTemplate[chipNr]).push_back(energySumCond);
     }
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseExternal	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`
	)

private

parse an External condition

parseExternal Parse an External condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 2412 of file L1GtTriggerMenuXmlParser.cc.

References getXMLAttribute(), insertConditionIntoMap(), LogTrace, m_vecExternalTemplate, L1GtXmlParserTags::m_xmlConditionAttrCondition, L1GtXmlParserTags::m_xmlConditionAttrObject, L1GtXmlParserTags::m_xmlConditionAttrObjectGtExternal, L1GtXmlParserTags::m_xmlConditionAttrType, push_back(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtCondition::setCondType(), AlCaHLTBitMon_QueryRunRegistry::string, and TypeExternal.

Referenced by workCondition().

                                                                   {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   if (particle != m_xmlConditionAttrObjectGtExternal) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "\nError: wrong particle for External condition (" << particle << ")" << std::endl;
     return false;
   }
 
   // object type and condition type
   // object type - irrelevant for External conditions
   L1GtConditionType cType = TypeExternal;
 
   // no objects for External conditions
 
   // set the boolean value for the ge_eq mode - irrelevant for External conditions
   bool gEq = false;
 
   // now create a new External condition
 
   L1GtExternalTemplate externalCond(name);
 
   externalCond.setCondType(cType);
   externalCond.setCondGEq(gEq);
   externalCond.setCondChipNr(chipNr);
 
   LogTrace("L1GtTriggerMenuXmlParser") << externalCond << "\n" << std::endl;
 
   // insert condition into the map
   if (!insertConditionIntoMap(externalCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
 
     return false;
   } else {
     (m_vecExternalTemplate[chipNr]).push_back(externalCond);
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseHfBitCounts	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`
	)

private

parse a HfBitCounts condition

parseHfBitCounts Parse a "HF bit counts" condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 2112 of file L1GtTriggerMenuXmlParser.cc.

References getConditionChildValues(), getGEqFlag(), getXMLAttribute(), HfBitCounts, mps_fire::i, insertConditionIntoMap(), edm::isDebugEnabled(), LogDebug, LogTrace, m_vecHfBitCountsTemplate, L1GtXmlParserTags::m_xmlConditionAttrCondition, L1GtXmlParserTags::m_xmlConditionAttrObject, L1GtXmlParserTags::m_xmlConditionAttrObjectHfBitCounts, L1GtXmlParserTags::m_xmlConditionAttrType, L1GtXmlParserTags::m_xmlTagCountThreshold, L1GtHfBitCountsTemplate::print(), push_back(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtHfBitCountsTemplate::setConditionParameter(), L1GtCondition::setCondType(), L1GtCondition::setObjectType(), AlCaHLTBitMon_QueryRunRegistry::string, and TypeHfBitCounts.

Referenced by workCondition().

                                                                      {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   if (particle != m_xmlConditionAttrObjectHfBitCounts) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "Wrong particle for HfBitCounts condition (" << particle << ")" << std::endl;
     return false;
   }
 
   // object type and condition type
   L1GtObject hfBitCountsObjType = HfBitCounts;
   L1GtConditionType cType = TypeHfBitCounts;
 
   // global object
   int nrObj = 1;
 
   // get greater equal flag
 
   int intGEq = getGEqFlag(node, m_xmlTagCountThreshold);
   if (intGEq < 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag" << std::endl;
     return false;
   }
   // set the boolean value for the ge_eq mode
   bool gEq = (intGEq != 0);
 
   // get values
 
   // temporary storage of the parameters
   std::vector<L1GtHfBitCountsTemplate::ObjectParameter> objParameter(nrObj);
 
   // get countIndex value and fill into structure
   // they are expressed in  base 10
   char* endPtr = nullptr;
   long int typeInt = strtol(type.c_str(), &endPtr, 10);  // base = 10
 
   if (*endPtr != 0) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Unable to convert " << type << " to dec." << std::endl;
 
     return false;
   }
 
   // test if count index is out of range FIXME introduce m_numberL1HfBitCounts?
   //if ((typeInt < 0) || (typeInt > static_cast<int>(m_numberL1HfBitCounts))) {
   //    LogDebug("L1GtTriggerMenuXmlParser") << "Count index " << typeInt
   //        << " outside range [0, " << m_numberL1HfBitCounts << "]" << std::endl;
   //
   //    return false;
   //}
 
   objParameter[0].countIndex = static_cast<unsigned int>(typeInt);
 
   // get count threshold values and fill into structure
   std::vector<uint64_t> tmpValues(nrObj);
 
   if (!getConditionChildValues(node, m_xmlTagCountThreshold, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].countThreshold = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      HfBitCounts count threshold (hex) for HfBitCounts object " << i << " = "
     //<< std::hex << objParameter[i].countThreshold << std::dec
     //<< std::endl;
   }
 
   // object types - all same objType
   std::vector<L1GtObject> objType(nrObj, hfBitCountsObjType);
 
   // now create a new HfBitCounts condition
 
   L1GtHfBitCountsTemplate hfBitCountsCond(name);
 
   hfBitCountsCond.setCondType(cType);
   hfBitCountsCond.setObjectType(objType);
   hfBitCountsCond.setCondGEq(gEq);
   hfBitCountsCond.setCondChipNr(chipNr);
 
   hfBitCountsCond.setConditionParameter(objParameter);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     hfBitCountsCond.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert condition into the map
   if (!insertConditionIntoMap(hfBitCountsCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
 
     return false;
   } else {
     (m_vecHfBitCountsTemplate[chipNr]).push_back(hfBitCountsCond);
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseHfRingEtSums	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`
	)

private

parse a HfRingEtSums condition

parseHfRingEtSums Parse a "HF Ring ET sums" condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 2232 of file L1GtTriggerMenuXmlParser.cc.

References getConditionChildValues(), getGEqFlag(), getXMLAttribute(), HfRingEtSums, mps_fire::i, insertConditionIntoMap(), edm::isDebugEnabled(), LogDebug, LogTrace, m_vecHfRingEtSumsTemplate, L1GtXmlParserTags::m_xmlConditionAttrCondition, L1GtXmlParserTags::m_xmlConditionAttrObject, L1GtXmlParserTags::m_xmlConditionAttrObjectHfRingEtSums, L1GtXmlParserTags::m_xmlConditionAttrType, L1GtXmlParserTags::m_xmlTagEtThreshold, L1GtHfRingEtSumsTemplate::print(), push_back(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtHfRingEtSumsTemplate::setConditionParameter(), L1GtCondition::setCondType(), L1GtCondition::setObjectType(), AlCaHLTBitMon_QueryRunRegistry::string, and TypeHfRingEtSums.

Referenced by workCondition().

                                                                       {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   if (particle != m_xmlConditionAttrObjectHfRingEtSums) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "Wrong particle for HfRingEtSums condition (" << particle << ")" << std::endl;
     return false;
   }
 
   // object type and condition type
   L1GtObject hfRingEtSumsObjType = HfRingEtSums;
   L1GtConditionType cType = TypeHfRingEtSums;
 
   // global object
   int nrObj = 1;
 
   // get greater equal flag
 
   int intGEq = getGEqFlag(node, m_xmlTagEtThreshold);
   if (intGEq < 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag" << std::endl;
     return false;
   }
   // set the boolean value for the ge_eq mode
   bool gEq = (intGEq != 0);
 
   // get values
 
   // temporary storage of the parameters
   std::vector<L1GtHfRingEtSumsTemplate::ObjectParameter> objParameter(nrObj);
 
   // get etSumIndex value and fill into structure
   // they are expressed in  base 10
   char* endPtr = nullptr;
   long int typeInt = strtol(type.c_str(), &endPtr, 10);  // base = 10
 
   if (*endPtr != 0) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Unable to convert " << type << " to dec." << std::endl;
 
     return false;
   }
 
   // test if ET sum index is out of range FIXME introduce m_numberL1HfRingEtSums?
   //if ((typeInt < 0) || (typeInt > static_cast<int>(m_numberL1HfRingEtSums))) {
   //    LogDebug("L1GtTriggerMenuXmlParser") << "Count index " << typeInt
   //        << " outside range [0, " << m_numberL1HfRingEtSums << "]" << std::endl;
   //
   //    return false;
   //}
 
   objParameter[0].etSumIndex = static_cast<unsigned int>(typeInt);
 
   // get ET sum threshold values and fill into structure
   std::vector<uint64_t> tmpValues(nrObj);
 
   if (!getConditionChildValues(node, m_xmlTagEtThreshold, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].etSumThreshold = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      HfRingEtSums count threshold (hex) for HfRingEtSums object " << i << " = "
     //<< std::hex << objParameter[i].etSumThreshold << std::dec
     //<< std::endl;
   }
 
   // object types - all same objType
   std::vector<L1GtObject> objType(nrObj, hfRingEtSumsObjType);
 
   // now create a new HfRingEtSums condition
 
   L1GtHfRingEtSumsTemplate hfRingEtSumsCond(name);
 
   hfRingEtSumsCond.setCondType(cType);
   hfRingEtSumsCond.setObjectType(objType);
   hfRingEtSumsCond.setCondGEq(gEq);
   hfRingEtSumsCond.setCondChipNr(chipNr);
 
   hfRingEtSumsCond.setConditionParameter(objParameter);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     hfRingEtSumsCond.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert condition into the map
   if (!insertConditionIntoMap(hfRingEtSumsCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
 
     return false;
   } else {
     (m_vecHfRingEtSumsTemplate[chipNr]).push_back(hfRingEtSumsCond);
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseId ( XERCES_CPP_NAMESPACE::XercesDOMParser * parser )

private

parse all parse all identification attributes (trigger menu names, scale DB key, etc)

parseId - parse all identification attributes (trigger menu names, scale DB key, etc)

Parameters

parser The parser to parse the XML file with.

Returns: "true" if succeeded. "false" if an error occurred.

Definition at line 2745 of file L1GtTriggerMenuXmlParser.cc.

Referenced by workXML().

                                                                                   {
   XERCES_CPP_NAMESPACE_USE
 
   DOMNode* doc = parser->getDocument();
   DOMNode* n1 = doc->getFirstChild();
 
   // we assume that the first child is m_xmlTagDef because it was checked in workXML
 
   DOMNode* headerNode = n1->getFirstChild();
   if (headerNode == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error: No child of <" << m_xmlTagDef << "> tag found." << std::endl;
     return false;
   }
 
   headerNode = findXMLChild(headerNode, m_xmlTagHeader);
   if (headerNode == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagHeader << "> tag"
                                          << "\n   - No header information." << std::endl;
 
   } else {
     DOMNode* idNode = headerNode->getFirstChild();
 
     // find menu interface name
     idNode = findXMLChild(idNode, m_xmlTagMenuInterface);
     if (idNode == nullptr) {
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagMenuInterface << "> tag"
                                            << "\n   - Trigger menu interface name derived from file name." << std::endl;
 
       // set the name of the trigger menu interface: from beginning of file names
       // until beginning of "_L1T_Scales"
       size_t xmlPos = m_triggerMenuName.find("_L1T_Scales", 0);
       if (xmlPos == std::string::npos) {
         LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find \"_L1T_Scales\" "
                                              << "string in file name"
                                              << "\n   - Trigger menu interface name set to file name." << std::endl;
         m_triggerMenuInterface = m_triggerMenuName;
 
       } else {
         m_triggerMenuInterface = m_triggerMenuName;
         m_triggerMenuInterface.erase(m_triggerMenuInterface.begin(), m_triggerMenuInterface.begin() + xmlPos);
       }
 
     } else {
       m_triggerMenuInterface = getXMLTextValue(idNode);
     }
 
     // find menu interface creation date
     idNode = headerNode->getFirstChild();
     idNode = findXMLChild(idNode, m_xmlTagMenuInterfaceDate);
 
     if (idNode == nullptr) {
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagMenuInterfaceDate << "> tag"
                                            << "\n   - No creation date." << m_triggerMenuInterfaceDate << std::endl;
 
     } else {
       m_triggerMenuInterfaceDate = getXMLTextValue(idNode);
     }
 
     // find menu interface creation author
     idNode = headerNode->getFirstChild();
     idNode = findXMLChild(idNode, m_xmlTagMenuInterfaceAuthor);
 
     if (idNode == nullptr) {
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagMenuInterfaceAuthor << "> tag"
                                            << "\n   - No creation author." << m_triggerMenuInterfaceAuthor << std::endl;
 
     } else {
       m_triggerMenuInterfaceAuthor = getXMLTextValue(idNode);
     }
 
     // find menu interface description
     idNode = headerNode->getFirstChild();
     idNode = findXMLChild(idNode, m_xmlTagMenuInterfaceDescription);
 
     if (idNode == nullptr) {
       LogTrace("L1GtTriggerMenuXmlParser")
           << "\n  Warning: Could not find <" << m_xmlTagMenuInterfaceDescription << "> tag"
           << "\n   - No description." << m_triggerMenuInterfaceDescription << std::endl;
 
     } else {
       m_triggerMenuInterfaceDescription = getXMLTextValue(idNode);
     }
 
     // find menu creation date
     idNode = headerNode->getFirstChild();
     idNode = findXMLChild(idNode, m_xmlTagMenuDate);
 
     if (idNode == nullptr) {
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagMenuDate << "> tag"
                                            << "\n   - No creation date." << m_triggerMenuDate << std::endl;
 
     } else {
       m_triggerMenuDate = getXMLTextValue(idNode);
     }
 
     // find menu creation author
     idNode = headerNode->getFirstChild();
     idNode = findXMLChild(idNode, m_xmlTagMenuAuthor);
 
     if (idNode == nullptr) {
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagMenuAuthor << "> tag"
                                            << "\n   - No creation author." << m_triggerMenuAuthor << std::endl;
 
     } else {
       m_triggerMenuAuthor = getXMLTextValue(idNode);
     }
 
     // find menu description
     idNode = headerNode->getFirstChild();
     idNode = findXMLChild(idNode, m_xmlTagMenuDescription);
 
     if (idNode == nullptr) {
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagMenuDescription << "> tag"
                                            << "\n   - No description." << m_triggerMenuDescription << std::endl;
 
     } else {
       m_triggerMenuDescription = getXMLTextValue(idNode);
     }
 
     // find algorithm implementation tag
 
     idNode = headerNode->getFirstChild();
 
     idNode = findXMLChild(idNode, m_xmlTagMenuAlgImpl);
     if (idNode == nullptr) {
       m_algorithmImplementation = "";
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagMenuAlgImpl << "> tag"
                                            << "\n   - Algorithm implementation tag set to empty string." << std::endl;
 
     } else {
       m_algorithmImplementation = getXMLTextValue(idNode);
     }
 
     // find DB key for L1 scales
 
     idNode = headerNode->getFirstChild();
 
     idNode = findXMLChild(idNode, m_xmlTagScaleDbKey);
     if (idNode == nullptr) {
       m_scaleDbKey = "NULL";
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagScaleDbKey << "> tag"
                                            << "\n   - Scale key set to " << m_scaleDbKey << " string." << std::endl;
 
     } else {
       m_scaleDbKey = getXMLTextValue(idNode);
     }
   }
 
   LogDebug("L1GtTriggerMenuXmlParser") << "\n  Parsed values from XML file"
                                        << "\nL1 MenuInterface:                   " << m_triggerMenuInterface
                                        << "\nL1 MenuInterface - Creation date:   " << m_triggerMenuInterfaceDate
                                        << "\nL1 MenuInterface - Creation author: " << m_triggerMenuInterfaceAuthor
                                        << "\nL1 MenuInterface - Description:     " << m_triggerMenuInterfaceDescription
                                        << "\n"
                                        << "\nAlgorithm implementation tag:       " << m_algorithmImplementation << "\n"
                                        << "\nL1 Menu - Creation date:            " << m_triggerMenuDate
                                        << "\nL1 Menu - Creation author:          " << m_triggerMenuAuthor
                                        << "\nL1 Menu - Description:              " << m_triggerMenuDescription
                                        << std::endl;
 
   // set the trigger menu name
   // format:
   // L1MenuInterface/ScaleDbKey/AlgorithmImplementationTag
 
   std::string menuName = m_triggerMenuInterface + "/" + m_scaleDbKey + "/" + m_algorithmImplementation;
 
   if (menuName != m_triggerMenuName) {
     LogDebug("L1GtTriggerMenuXmlParser") << "\n  Warning: Inconsistent L1 menu name:"
                                          << "\n    from XML file name: " << m_triggerMenuName
                                          << "\n    from XML tag:       " << menuName << std::endl;
 
     if (!m_triggerMenuInterface.empty()) {
       if (m_scaleDbKey == "NULL") {
         m_triggerMenuName = m_triggerMenuInterface;
       } else {
         m_triggerMenuName = menuName;
       }
 
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  L1 menu name set to value from XML tag!"
                                            << "\n  L1 Menu name: " << m_triggerMenuName << std::endl;
 
     } else {
       LogTrace("L1GtTriggerMenuXmlParser") << "\n  L1 menu name set to file name!"
                                            << "\n  L1 Menu name: " << m_triggerMenuName << std::endl;
     }
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseJetCounts	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`
	)

private

parse a "jet counts" condition

parseJetCounts Parse a "jet counts" condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 1886 of file L1GtTriggerMenuXmlParser.cc.

References getConditionChildValues(), getGEqFlag(), getXMLAttribute(), mps_fire::i, insertConditionIntoMap(), edm::isDebugEnabled(), JetCounts, LogDebug, LogTrace, m_numberL1JetCounts, m_vecJetCountsTemplate, L1GtXmlParserTags::m_xmlConditionAttrCondition, L1GtXmlParserTags::m_xmlConditionAttrObject, L1GtXmlParserTags::m_xmlConditionAttrObjectJetCounts, L1GtXmlParserTags::m_xmlConditionAttrType, L1GtXmlParserTags::m_xmlTagCountThreshold, L1GtJetCountsTemplate::print(), push_back(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtJetCountsTemplate::setConditionParameter(), L1GtCondition::setCondType(), L1GtCondition::setObjectType(), AlCaHLTBitMon_QueryRunRegistry::string, and TypeJetCounts.

Referenced by workCondition().

                                                                    {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   if (particle != m_xmlConditionAttrObjectJetCounts) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "Wrong particle for JetCounts condition (" << particle << ")" << std::endl;
     return false;
   }
 
   // object type and condition type
   L1GtObject jetCountsObjType = JetCounts;
   L1GtConditionType cType = TypeJetCounts;
 
   // global object
   int nrObj = 1;
 
   // get greater equal flag
 
   int intGEq = getGEqFlag(node, m_xmlTagCountThreshold);
   if (intGEq < 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag" << std::endl;
     return false;
   }
   // set the boolean value for the ge_eq mode
   bool gEq = (intGEq != 0);
 
   // get values
 
   // temporary storage of the parameters
   std::vector<L1GtJetCountsTemplate::ObjectParameter> objParameter(nrObj);
 
   // get countIndex value and fill into structure
   // they are expressed in  base 10  (values: 0 - m_numberL1JetCounts)
   char* endPtr = nullptr;
   long int typeInt = strtol(type.c_str(), &endPtr, 10);  // base = 10
 
   if (*endPtr != 0) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Unable to convert " << type << " to dec." << std::endl;
 
     return false;
   }
 
   // test if count index is out of range
   if ((typeInt < 0) || (typeInt > static_cast<int>(m_numberL1JetCounts))) {
     LogDebug("L1GtTriggerMenuXmlParser") << "Count index " << typeInt << " outside range [0, " << m_numberL1JetCounts
                                          << "]" << std::endl;
 
     return false;
   }
 
   objParameter[0].countIndex = static_cast<unsigned int>(typeInt);
 
   // get count threshold values and fill into structure
   std::vector<uint64_t> tmpValues(nrObj);
 
   if (!getConditionChildValues(node, m_xmlTagCountThreshold, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].countThreshold = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      JetCounts count threshold (hex) for JetCounts object " << i << " = "
     //<< std::hex << objParameter[i].countThreshold << std::dec
     //<< std::endl;
 
     // TODO FIXME un-comment when tag available in XML file
 
     //        // get countOverflow logical flag and fill into structure
     //        DOMNode* n1;
     //        if ( (n1 = findXMLChild(node->getFirstChild(), m_xmlTagCountThreshold)) == 0) {
     //            edm::LogError("L1GtTriggerMenuXmlParser")
     //            << "    Could not get countOverflow for JetCounts condition ("
     //            << name << ")"
     //            << std::endl;
     //            return false;
     //        }
     //        if ( (n1 = findXMLChild(n1->getFirstChild(), m_xmlTagCountThreshold)) == 0) {
     //            edm::LogError("L1GtTriggerMenuXmlParser")
     //            << "    Could not get countOverflow for JetCounts condition ("
     //            << name << ")"
     //            << std::endl;
     //            return false;
     //        }
     //
     //        int tmpInt = getBitFromNode(n1);
     //        if (tmpInt == 0) {
     //            objParameter[i].countOverflow = false;
     //
     //            LogTrace("L1GtTriggerMenuXmlParser")
     //            << "      JetCounts countOverflow logical flag (hex) = "
     //            << std::hex << objParameter[i].countOverflow << std::dec
     //            << std::endl;
     //        } else if (tmpInt == 1) {
     //            objParameter[i].countOverflow = true;
     //
     //            LogTrace("L1GtTriggerMenuXmlParser")
     //            << "      JetCounts countOverflow logical flag (hex) = "
     //            << std::hex << objParameter[i].countOverflow << std::dec
     //            << std::endl;
     //        } else {
     //            LogTrace("L1GtTriggerMenuXmlParser")
     //            << "      JetCounts countOverflow logical flag (hex) = "
     //            << std::hex << tmpInt << std::dec << " - wrong value! "
     //            << std::endl;
     //            return false;
     //        }
   }
 
   // object types - all same objType
   std::vector<L1GtObject> objType(nrObj, jetCountsObjType);
 
   // now create a new JetCounts condition
 
   L1GtJetCountsTemplate jetCountsCond(name);
 
   jetCountsCond.setCondType(cType);
   jetCountsCond.setObjectType(objType);
   jetCountsCond.setCondGEq(gEq);
   jetCountsCond.setCondChipNr(chipNr);
 
   jetCountsCond.setConditionParameter(objParameter);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     jetCountsCond.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert condition into the map
   if (!insertConditionIntoMap(jetCountsCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
 
     return false;
   } else {
     (m_vecJetCountsTemplate[chipNr]).push_back(jetCountsCond);
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseMuon	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr = `0`,
		const bool	corrFlag = `false`
	)

private

parse a muon condition

parseMuon Parse a muon condition and insert an entry to the conditions map

Parameters

node	The corresponding node.
name	The name of the condition.
chipNr	The number of the chip this condition is located.

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 1246 of file L1GtTriggerMenuXmlParser.cc.

Referenced by parseCorrelation(), and workCondition().

                                                               {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name (must be muon) and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   if (particle != m_xmlConditionAttrObjectMu) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Wrong particle for muon-condition (" << particle << ")" << std::endl;
     return false;
   }
 
   int nrObj = getNumFromType(type);
   if (nrObj < 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Unknown type for muon-condition (" << type << ")"
                                               << "\nCan not determine number of trigger objects. " << std::endl;
     return false;
   }
 
   // get greater equal flag
 
   int intGEq = getGEqFlag(node, m_xmlTagPtHighThreshold);
   if (intGEq < 0) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag" << std::endl;
     return false;
   }
   // set the boolean value for the ge_eq mode
   bool gEq = (intGEq != 0);
 
   // get values
 
   // temporary storage of the parameters
   std::vector<L1GtMuonTemplate::ObjectParameter> objParameter(nrObj);
   L1GtMuonTemplate::CorrelationParameter corrParameter;
 
   // need at least two values for deltaPhi
   std::vector<uint64_t> tmpValues((nrObj > 2) ? nrObj : 2);
 
   // get ptHighThreshold values and fill into structure
   if (!getConditionChildValues(node, m_xmlTagPtHighThreshold, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].ptHighThreshold = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      Muon pT high threshold (hex) for muon " << i << " = "
     //<< std::hex << objParameter[i].ptHighThreshold << std::dec
     //<< std::endl;
   }
 
   // get ptLowThreshold values  and fill into structure
   if (!getConditionChildValues(node, m_xmlTagPtLowThreshold, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "        Muon pT low threshold word (hex) for muon " << i << " = "
     //<< std::hex << tmpValues[i] << std::dec
     //<< std::endl;
 
     // TODO FIXME stupid format in def.xml...
     // one takes mip bit also, therefore one divide by 16
     tmpValues[i] = (tmpValues[i]) / 16;
 
     objParameter[i].ptLowThreshold = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      Muon pT low threshold (hex) for muon  " << i << " = "
     //<< std::hex << objParameter[i].ptLowThreshold << std::dec
     //<< std::endl;
   }
 
   // get qualityRange and fill into structure
   if (!getConditionChildValues(node, m_xmlTagQuality, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].qualityRange = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      qualityRange mask (hex) for muon " << i << " = "
     //<< std::hex << objParameter[i].qualityRange << std::dec
     //<< std::endl;
   }
 
   // get etaRange and fill into structure
   if (!getConditionChildValues(node, m_xmlTagEta, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].etaRange = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      etaRange (hex) for muon " << i << " = "
     //<< std::hex << objParameter[i].etaRange << std::dec
     //<< std::endl;
   }
 
   // get phiHigh values and fill into structure
   if (!getConditionChildValues(node, m_xmlTagPhiHigh, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].phiHigh = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      phiHigh (hex) for muon " << i << " = "
     //<< std::hex << objParameter[i].phiHigh << std::dec
     //<< std::endl;
   }
 
   // get phiLow values and fill into structure
   if (!getConditionChildValues(node, m_xmlTagPhiLow, nrObj, tmpValues)) {
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].phiLow = tmpValues[i];
 
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      phiLow (hex) for muon " << i << " = "
     //<< std::hex << objParameter[i].phiLow << std::dec
     //<< std::endl;
   }
 
   // get charge correlation and fill into structure
   if (!getXMLHexTextValue(findXMLChild(node->getFirstChild(), m_xmlTagChargeCorrelation), tmpValues[0])) {
     LogDebug("L1GtTriggerMenuXmlParser") << "    Error getting charge correlation from muon condition (" << name << ")"
                                          << std::endl;
     return false;
   }
 
   corrParameter.chargeCorrelation = tmpValues[0];
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      charge correlation" << " = "
   //<< std::hex << corrParameter.chargeCorrelation << std::dec
   //<< std::endl;
 
   // get mip and iso bits and fill into structure
 
   std::vector<bool> tmpMip(nrObj);
   std::vector<bool> tmpEnableIso(nrObj);
   std::vector<bool> tmpRequestIso(nrObj);
 
   if (!getMuonMipIsoBits(node, nrObj, tmpMip, tmpEnableIso, tmpRequestIso)) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "    Could not get mip and iso bits from muon condition (" << name << ")" << std::endl;
     return false;
   }
 
   for (int i = 0; i < nrObj; i++) {
     objParameter[i].enableMip = tmpMip[i];
     objParameter[i].enableIso = tmpEnableIso[i];
     objParameter[i].requestIso = tmpRequestIso[i];
   }
 
   // indicates if a correlation is used
   bool wscVal = (type == m_xmlConditionAttrType2wsc);
 
   if (wscVal) {
     // get deltaEtaRange
     if (!getConditionChildValues(node, m_xmlTagDeltaEta, 1, tmpValues)) {
       return false;
     }
 
     corrParameter.deltaEtaRange = tmpValues[0];
 
     // deltaPhi is larger than 64bit
     if (!getXMLHexTextValue128(findXMLChild(node->getFirstChild(), m_xmlTagDeltaPhi), tmpValues[0], tmpValues[1])) {
       edm::LogError("L1GtTriggerMenuXmlParser")
           << "    Could not get deltaPhi for muon condition with wsc (" << name << ")" << std::endl;
       return false;
     }
 
     corrParameter.deltaPhiRange0Word = tmpValues[0];
     corrParameter.deltaPhiRange1Word = tmpValues[1];
 
     // get maximum number of bits for delta phi
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "      Counting deltaPhiMaxbits"
     //<< std::endl;
 
     unsigned int maxbits;
 
     if (!countConditionChildMaxBits(node, m_xmlTagDeltaPhi, maxbits)) {
       return false;
     }
 
     corrParameter.deltaPhiMaxbits = maxbits;
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "        deltaPhiMaxbits (dec) = " << maxbits
     //<< std::endl;
   }
 
   // get the type of the condition, as defined in enum, from the condition type
   // as defined in the XML file
   L1GtConditionType cType = getTypeFromType(type);
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Condition type (enum value) = " << cType
   //<< std::endl;
 
   if (cType == TypeNull) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "Type for muon condition id TypeNull - it means not defined in the XML file."
         << "\nNumber of trigger objects is set to zero. " << std::endl;
     return false;
   }
 
   // object types - all muons
   std::vector<L1GtObject> objType(nrObj, Mu);
 
   // now create a new CondMuonition
 
   L1GtMuonTemplate muonCond(name);
 
   muonCond.setCondType(cType);
   muonCond.setObjectType(objType);
   muonCond.setCondGEq(gEq);
   muonCond.setCondChipNr(chipNr);
 
   muonCond.setConditionParameter(objParameter, corrParameter);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     muonCond.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert condition into the map and into muon template vector
   if (!insertConditionIntoMap(muonCond, chipNr)) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: duplicate condition (" << name << ")" << std::endl;
     return false;
   } else {
     if (corrFlag) {
       (m_corMuonTemplate[chipNr]).push_back(muonCond);
 
     } else {
       (m_vecMuonTemplate[chipNr]).push_back(muonCond);
     }
   }
 
   //
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseTechTriggers ( XERCES_CPP_NAMESPACE::XercesDOMParser * parser )

private

parse all algorithms

Definition at line 3347 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), L1GtXmlParserTags::m_xmlTagDef, L1GtXmlParserTags::m_xmlTagTechTriggers, AlCaHLTBitMon_QueryRunRegistry::string, and workTechTrigger().

Referenced by workXML().

                                                                                             {
   XERCES_CPP_NAMESPACE_USE
 
   //LogTrace("L1GtTriggerMenuXmlParser") << "\nParsing technical triggers" << std::endl;
 
   DOMNode* doc = parser->getDocument();
   DOMNode* node = doc->getFirstChild();
 
   DOMNode* algNode = node->getFirstChild();
   if (algNode == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "  Error: No child found for " << m_xmlTagDef << std::endl;
     return false;
   }
 
   algNode = findXMLChild(algNode, m_xmlTagTechTriggers);
   if (algNode == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "    Error: No <" << m_xmlTagTechTriggers << "> child found." << std::endl;
     return false;
   }
 
   // walk through technical triggers
   DOMNode* algNameNode = algNode->getFirstChild();
   std::string algNameNodeName;
   algNameNode = findXMLChild(algNameNode, "", true, &algNameNodeName);
 
   while (algNameNode != nullptr) {
     //LogTrace("L1GtTriggerMenuXmlParser")
     //<< "    Found an technical trigger with name: " << algNameNodeName
     //<< std::endl;
 
     if (!workTechTrigger(algNameNode, algNameNodeName)) {
       return false;
     }
 
     algNameNode = findXMLChild(algNameNode->getNextSibling(), "", true, &algNameNodeName);
   }
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::parseVmeXML ( XERCES_CPP_NAMESPACE::XercesDOMParser * parser )

private

parse the vme xml file

parseVmeXML parse a xml file

Parameters

parser The parser to use for parsing the file.

Returns: true if succeeded, false if an error occurred.

Definition at line 788 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), m_numberConditionChips, L1GtXmlParserTags::m_xmlTagChip, and L1GtXmlParserTags::m_xmlTagVme.

                                                                                       {
   XERCES_CPP_NAMESPACE_USE
 
   DOMDocument* doc = parser->getDocument();
   DOMNode* n1 = doc->getFirstChild();
 
   if (n1 == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error: Found no XML child" << std::endl;
 
     return false;
   }
 
   // find "vme"-tag
   n1 = findXMLChild(n1, m_xmlTagVme);
   if (n1 == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error: No vme tag found." << std::endl;
     return false;
   }
 
   n1 = n1->getFirstChild();
 
   unsigned int chipCounter = 0;  // count chips
 
   while (chipCounter < m_numberConditionChips) {
     n1 = findXMLChild(n1, m_xmlTagChip, true);
     if (n1 == nullptr) {
       // just break if no more chips found
       break;
     }
 
     // node for a particle
     //DOMNode* particleNode = n1->getFirstChild(); // FIXME un-comment
 
     // FIXME parse vme.xml, modify the menu
 
     n1 = n1->getNextSibling();
     chipCounter++;
   }  // end while chipCounter
 
   return true;
 }

void L1GtTriggerMenuXmlParser::parseXmlFile	(	const std::string &	defXmlFile,
		const std::string &	vmeXmlFile
	)

parse def.xml and vme.xml files

Definition at line 179 of file L1GtTriggerMenuXmlParser.cc.

References cleanupXML(), initXML(), LogTrace, m_conditionMap, m_corCaloTemplate, m_corEnergySumTemplate, m_corMuonTemplate, m_numberConditionChips, m_triggerMenuName, m_vecBptxTemplate, m_vecCaloTemplate, m_vecCastorTemplate, m_vecCorrelationTemplate, m_vecEnergySumTemplate, m_vecExternalTemplate, m_vecHfBitCountsTemplate, m_vecHfRingEtSumsTemplate, m_vecJetCountsTemplate, m_vecMuonTemplate, m_xmlErrHandler, writedatasetfile::parser, and workXML().

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                     {
   XERCES_CPP_NAMESPACE_USE
 
   // resize the vector of condition maps
   // the number of condition chips should be correctly set before calling parseXmlFile
   m_conditionMap.resize(m_numberConditionChips);
 
   m_vecMuonTemplate.resize(m_numberConditionChips);
   m_vecCaloTemplate.resize(m_numberConditionChips);
   m_vecEnergySumTemplate.resize(m_numberConditionChips);
   m_vecJetCountsTemplate.resize(m_numberConditionChips);
   m_vecCastorTemplate.resize(m_numberConditionChips);
   m_vecHfBitCountsTemplate.resize(m_numberConditionChips);
   m_vecHfRingEtSumsTemplate.resize(m_numberConditionChips);
   m_vecBptxTemplate.resize(m_numberConditionChips);
   m_vecExternalTemplate.resize(m_numberConditionChips);
 
   m_vecCorrelationTemplate.resize(m_numberConditionChips);
   m_corMuonTemplate.resize(m_numberConditionChips);
   m_corCaloTemplate.resize(m_numberConditionChips);
   m_corEnergySumTemplate.resize(m_numberConditionChips);
 
   // set the name of the trigger menu name:
   //     defXmlFile, stripped of absolute path and .xml
   // will be overwritten by the value read from the xml file, with a warning if
   // they are not the same
   m_triggerMenuName = defXmlFile;
   size_t xmlPos = m_triggerMenuName.find_last_of('/');
   m_triggerMenuName.erase(m_triggerMenuName.begin(), m_triggerMenuName.begin() + xmlPos + 1);
 
   xmlPos = m_triggerMenuName.find_last_of('.');
   m_triggerMenuName.erase(m_triggerMenuName.begin() + xmlPos, m_triggerMenuName.end());
 
   // error handler for xml-parser
   m_xmlErrHandler = nullptr;
 
   XercesDOMParser* parser;
 
   LogTrace("L1GtTriggerMenuXmlParser") << "\nOpening XML-File: \n  " << defXmlFile << std::endl;
 
   if ((parser = initXML(defXmlFile)) != nullptr) {
     workXML(parser);
   }
   cleanupXML(parser);
 }

void L1GtTriggerMenuXmlParser::setCorCaloTemplate ( const std::vector< std::vector< L1GtCaloTemplate > > & corCaloTempl )

Definition at line 158 of file L1GtTriggerMenuXmlParser.cc.

References m_corCaloTemplate.

                                                                                                              {
   m_corCaloTemplate = corCaloTempl;
 }

void L1GtTriggerMenuXmlParser::setCorEnergySumTemplate ( const std::vector< std::vector< L1GtEnergySumTemplate > > & corEnergySumTempl )

Definition at line 162 of file L1GtTriggerMenuXmlParser.cc.

References m_corEnergySumTemplate.

                                                                            {
   m_corEnergySumTemplate = corEnergySumTempl;
 }

void L1GtTriggerMenuXmlParser::setCorMuonTemplate ( const std::vector< std::vector< L1GtMuonTemplate > > & corMuonTempl )

Definition at line 154 of file L1GtTriggerMenuXmlParser.cc.

References m_corMuonTemplate.

                                                                                                              {
   m_corMuonTemplate = corMuonTempl;
 }

void L1GtTriggerMenuXmlParser::setGtAlgorithmAliasMap ( const AlgorithmMap & algoMap )

Definition at line 171 of file L1GtTriggerMenuXmlParser.cc.

References m_algorithmAliasMap.

171 { m_algorithmAliasMap = algoMap; }

L1GtTriggerMenuXmlParser::m_algorithmAliasMap

AlgorithmMap m_algorithmAliasMap

map containing the physics algorithms (by alias)

Definition: L1GtTriggerMenuXmlParser.h:465

void L1GtTriggerMenuXmlParser::setGtAlgorithmImplementation ( const std::string & val )

Definition at line 245 of file L1GtTriggerMenuXmlParser.cc.

References m_algorithmImplementation, and hgcalPerformanceValidation::val.

245 { m_algorithmImplementation = val; }

L1GtTriggerMenuXmlParser::m_algorithmImplementation

std::string m_algorithmImplementation

Definition: L1GtTriggerMenuXmlParser.h:429

hgcalPerformanceValidation.val

tuple val

Definition: hgcalPerformanceValidation.py:393

void L1GtTriggerMenuXmlParser::setGtAlgorithmMap ( const AlgorithmMap & algoMap )

Definition at line 168 of file L1GtTriggerMenuXmlParser.cc.

References m_algorithmMap.

168 { m_algorithmMap = algoMap; }

L1GtTriggerMenuXmlParser::m_algorithmMap

AlgorithmMap m_algorithmMap

map containing the physics algorithms (by name)

Definition: L1GtTriggerMenuXmlParser.h:462

void L1GtTriggerMenuXmlParser::setGtConditionMap ( const std::vector< ConditionMap > & condMap )

Definition at line 88 of file L1GtTriggerMenuXmlParser.cc.

References m_conditionMap.

88 { m_conditionMap = condMap; }

L1GtTriggerMenuXmlParser::m_conditionMap

std::vector< ConditionMap > m_conditionMap

map containing the conditions (per condition chip) - transient

Definition: L1GtTriggerMenuXmlParser.h:433

void L1GtTriggerMenuXmlParser::setGtNumberConditionChips ( const unsigned int & numberConditionChipsValue )

Definition at line 57 of file L1GtTriggerMenuXmlParser.cc.

References m_numberConditionChips.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                       {
   m_numberConditionChips = numberConditionChipsValue;
 }

void L1GtTriggerMenuXmlParser::setGtNumberL1JetCounts ( const unsigned int & numberL1JetCountsValue )

Definition at line 83 of file L1GtTriggerMenuXmlParser.cc.

References m_numberL1JetCounts.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                 {
   m_numberL1JetCounts = numberL1JetCountsValue;
 }

void L1GtTriggerMenuXmlParser::setGtNumberPhysTriggers ( const unsigned int & numberPhysTriggersValue )

Definition at line 73 of file L1GtTriggerMenuXmlParser.cc.

References m_numberPhysTriggers.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                   {
   m_numberPhysTriggers = numberPhysTriggersValue;
 }

void L1GtTriggerMenuXmlParser::setGtNumberTechTriggers ( const unsigned int & numberTechTriggersValue )

Definition at line 78 of file L1GtTriggerMenuXmlParser.cc.

References m_numberTechTriggers.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                   {
   m_numberTechTriggers = numberTechTriggersValue;
 }

void L1GtTriggerMenuXmlParser::setGtOrderConditionChip ( const std::vector< int > & orderConditionChipValue )

Definition at line 68 of file L1GtTriggerMenuXmlParser.cc.

References m_orderConditionChip.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                     {
   m_orderConditionChip = orderConditionChipValue;
 }

void L1GtTriggerMenuXmlParser::setGtPinsOnConditionChip ( const unsigned int & pinsOnConditionChipValue )

Definition at line 62 of file L1GtTriggerMenuXmlParser.cc.

References m_pinsOnConditionChip.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                     {
   m_pinsOnConditionChip = pinsOnConditionChipValue;
 }

void L1GtTriggerMenuXmlParser::setGtScaleDbKey ( const std::string & scaleKey )

Definition at line 102 of file L1GtTriggerMenuXmlParser.cc.

References m_scaleDbKey.

102 { m_scaleDbKey = scaleKey; }

L1GtTriggerMenuXmlParser::m_scaleDbKey

std::string m_scaleDbKey

menu associated scale key

Definition: L1GtTriggerMenuXmlParser.h:442

void L1GtTriggerMenuXmlParser::setGtTechnicalTriggerMap ( const AlgorithmMap & ttMap )

Definition at line 174 of file L1GtTriggerMenuXmlParser.cc.

References m_technicalTriggerMap.

174 { m_technicalTriggerMap = ttMap; }

L1GtTriggerMenuXmlParser::m_technicalTriggerMap

AlgorithmMap m_technicalTriggerMap

map containing the technical triggers

Definition: L1GtTriggerMenuXmlParser.h:468

void L1GtTriggerMenuXmlParser::setGtTriggerMenuAuthor ( const std::string & val )

Definition at line 241 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuAuthor, and hgcalPerformanceValidation::val.

241 { m_triggerMenuAuthor = val; }

hgcalPerformanceValidation.val

tuple val

Definition: hgcalPerformanceValidation.py:393

L1GtTriggerMenuXmlParser::m_triggerMenuAuthor

std::string m_triggerMenuAuthor

Definition: L1GtTriggerMenuXmlParser.h:426

void L1GtTriggerMenuXmlParser::setGtTriggerMenuDate ( const std::string & val )

Definition at line 239 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuDate, and hgcalPerformanceValidation::val.

239 { m_triggerMenuDate = val; }

hgcalPerformanceValidation.val

tuple val

Definition: hgcalPerformanceValidation.py:393

L1GtTriggerMenuXmlParser::m_triggerMenuDate

std::string m_triggerMenuDate

Definition: L1GtTriggerMenuXmlParser.h:425

void L1GtTriggerMenuXmlParser::setGtTriggerMenuDescription ( const std::string & val )

Definition at line 243 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuDescription, and hgcalPerformanceValidation::val.

243 { m_triggerMenuDescription = val; }

hgcalPerformanceValidation.val

tuple val

Definition: hgcalPerformanceValidation.py:393

L1GtTriggerMenuXmlParser::m_triggerMenuDescription

std::string m_triggerMenuDescription

Definition: L1GtTriggerMenuXmlParser.h:427

void L1GtTriggerMenuXmlParser::setGtTriggerMenuImplementation ( const std::string & menuImplementation )

Definition at line 97 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuImplementation.

                                                                                                  {
   m_triggerMenuImplementation = menuImplementation;
 }

void L1GtTriggerMenuXmlParser::setGtTriggerMenuInterface ( const std::string & menuInterface )

Definition at line 91 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuInterface.

                                                                                        {
   m_triggerMenuInterface = menuInterface;
 }

void L1GtTriggerMenuXmlParser::setGtTriggerMenuInterfaceAuthor ( const std::string & val )

Definition at line 231 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuInterfaceAuthor, and hgcalPerformanceValidation::val.

                                                                                    {
   m_triggerMenuInterfaceAuthor = val;
 }

void L1GtTriggerMenuXmlParser::setGtTriggerMenuInterfaceDate ( const std::string & val )

Definition at line 227 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuInterfaceDate, and hgcalPerformanceValidation::val.

                                                                                  {
   m_triggerMenuInterfaceDate = val;
 }

void L1GtTriggerMenuXmlParser::setGtTriggerMenuInterfaceDescription ( const std::string & val )

Definition at line 235 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuInterfaceDescription, and hgcalPerformanceValidation::val.

                                                                                         {
   m_triggerMenuInterfaceDescription = val;
 }

void L1GtTriggerMenuXmlParser::setGtTriggerMenuName ( const std::string & menuName )

Definition at line 95 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuName.

95 { m_triggerMenuName = menuName; }

L1GtTriggerMenuXmlParser::m_triggerMenuName

std::string m_triggerMenuName

Definition: L1GtTriggerMenuXmlParser.h:438

void L1GtTriggerMenuXmlParser::setVecBptxTemplate ( const std::vector< std::vector< L1GtBptxTemplate > > & vecBptxTempl )

Definition at line 138 of file L1GtTriggerMenuXmlParser.cc.

References m_vecBptxTemplate.

                                                                                                              {
   m_vecBptxTemplate = vecBptxTempl;
 }

void L1GtTriggerMenuXmlParser::setVecCaloTemplate ( const std::vector< std::vector< L1GtCaloTemplate > > & vecCaloTempl )

Definition at line 109 of file L1GtTriggerMenuXmlParser.cc.

References m_vecCaloTemplate.

                                                                                                              {
   m_vecCaloTemplate = vecCaloTempl;
 }

void L1GtTriggerMenuXmlParser::setVecCastorTemplate ( const std::vector< std::vector< L1GtCastorTemplate > > & vecCastorTempl )

Definition at line 123 of file L1GtTriggerMenuXmlParser.cc.

References m_vecCastorTemplate.

                                                                      {
   m_vecCastorTemplate = vecCastorTempl;
 }

void L1GtTriggerMenuXmlParser::setVecCorrelationTemplate ( const std::vector< std::vector< L1GtCorrelationTemplate > > & vecCorrelationTempl )

Definition at line 147 of file L1GtTriggerMenuXmlParser.cc.

References m_vecCorrelationTemplate.

                                                                                {
   m_vecCorrelationTemplate = vecCorrelationTempl;
 }

void L1GtTriggerMenuXmlParser::setVecEnergySumTemplate ( const std::vector< std::vector< L1GtEnergySumTemplate > > & vecEnergySumTempl )

Definition at line 113 of file L1GtTriggerMenuXmlParser.cc.

References m_vecEnergySumTemplate.

                                                                            {
   m_vecEnergySumTemplate = vecEnergySumTempl;
 }

void L1GtTriggerMenuXmlParser::setVecExternalTemplate ( const std::vector< std::vector< L1GtExternalTemplate > > & vecExternalTempl )

Definition at line 142 of file L1GtTriggerMenuXmlParser.cc.

References m_vecExternalTemplate.

                                                                          {
   m_vecExternalTemplate = vecExternalTempl;
 }

void L1GtTriggerMenuXmlParser::setVecHfBitCountsTemplate ( const std::vector< std::vector< L1GtHfBitCountsTemplate > > & vecHfBitCountsTempl )

Definition at line 128 of file L1GtTriggerMenuXmlParser.cc.

References m_vecHfBitCountsTemplate.

                                                                                {
   m_vecHfBitCountsTemplate = vecHfBitCountsTempl;
 }

void L1GtTriggerMenuXmlParser::setVecHfRingEtSumsTemplate ( const std::vector< std::vector< L1GtHfRingEtSumsTemplate > > & vecHfRingEtSumsTempl )

Definition at line 133 of file L1GtTriggerMenuXmlParser.cc.

References m_vecHfRingEtSumsTemplate.

                                                                                  {
   m_vecHfRingEtSumsTemplate = vecHfRingEtSumsTempl;
 }

void L1GtTriggerMenuXmlParser::setVecJetCountsTemplate ( const std::vector< std::vector< L1GtJetCountsTemplate > > & vecJetCountsTempl )

Definition at line 118 of file L1GtTriggerMenuXmlParser.cc.

References m_vecJetCountsTemplate.

                                                                            {
   m_vecJetCountsTemplate = vecJetCountsTempl;
 }

void L1GtTriggerMenuXmlParser::setVecMuonTemplate ( const std::vector< std::vector< L1GtMuonTemplate > > & vecMuonTempl )

Definition at line 105 of file L1GtTriggerMenuXmlParser.cc.

References m_vecMuonTemplate.

                                                                                                              {
   m_vecMuonTemplate = vecMuonTempl;
 }

const std::vector<std::vector<L1GtBptxTemplate> >& L1GtTriggerMenuXmlParser::vecBptxTemplate ( ) const

inline

Definition at line 161 of file L1GtTriggerMenuXmlParser.h.

References m_vecBptxTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

161 { return m_vecBptxTemplate; }

L1GtTriggerMenuXmlParser::m_vecBptxTemplate

std::vector< std::vector< L1GtBptxTemplate > > m_vecBptxTemplate

Definition: L1GtTriggerMenuXmlParser.h:453

const std::vector<std::vector<L1GtCaloTemplate> >& L1GtTriggerMenuXmlParser::vecCaloTemplate ( ) const

inline

Definition at line 123 of file L1GtTriggerMenuXmlParser.h.

References m_vecCaloTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

123 { return m_vecCaloTemplate; }

L1GtTriggerMenuXmlParser::m_vecCaloTemplate

std::vector< std::vector< L1GtCaloTemplate > > m_vecCaloTemplate

Definition: L1GtTriggerMenuXmlParser.h:447

const std::vector<std::vector<L1GtCastorTemplate> >& L1GtTriggerMenuXmlParser::vecCastorTemplate ( ) const

inline

Definition at line 142 of file L1GtTriggerMenuXmlParser.h.

References m_vecCastorTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

142 { return m_vecCastorTemplate; }

L1GtTriggerMenuXmlParser::m_vecCastorTemplate

std::vector< std::vector< L1GtCastorTemplate > > m_vecCastorTemplate

Definition: L1GtTriggerMenuXmlParser.h:450

const std::vector<std::vector<L1GtCorrelationTemplate> >& L1GtTriggerMenuXmlParser::vecCorrelationTemplate ( ) const

inline

Definition at line 173 of file L1GtTriggerMenuXmlParser.h.

References m_vecCorrelationTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                               {
     return m_vecCorrelationTemplate;
   }

const std::vector<std::vector<L1GtEnergySumTemplate> >& L1GtTriggerMenuXmlParser::vecEnergySumTemplate ( ) const

inline

Definition at line 128 of file L1GtTriggerMenuXmlParser.h.

References m_vecEnergySumTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                           {
     return m_vecEnergySumTemplate;
   }

const std::vector<std::vector<L1GtExternalTemplate> >& L1GtTriggerMenuXmlParser::vecExternalTemplate ( ) const

inline

Definition at line 166 of file L1GtTriggerMenuXmlParser.h.

References m_vecExternalTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                         {
     return m_vecExternalTemplate;
   }

const std::vector<std::vector<L1GtHfBitCountsTemplate> >& L1GtTriggerMenuXmlParser::vecHfBitCountsTemplate ( ) const

inline

Definition at line 147 of file L1GtTriggerMenuXmlParser.h.

References m_vecHfBitCountsTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                               {
     return m_vecHfBitCountsTemplate;
   }

const std::vector<std::vector<L1GtHfRingEtSumsTemplate> >& L1GtTriggerMenuXmlParser::vecHfRingEtSumsTemplate ( ) const

inline

Definition at line 154 of file L1GtTriggerMenuXmlParser.h.

References m_vecHfRingEtSumsTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                 {
     return m_vecHfRingEtSumsTemplate;
   }

const std::vector<std::vector<L1GtJetCountsTemplate> >& L1GtTriggerMenuXmlParser::vecJetCountsTemplate ( ) const

inline

Definition at line 135 of file L1GtTriggerMenuXmlParser.h.

References m_vecJetCountsTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                           {
     return m_vecJetCountsTemplate;
   }

const std::vector<std::vector<L1GtMuonTemplate> >& L1GtTriggerMenuXmlParser::vecMuonTemplate ( ) const

inline

get / set the vectors containing the conditions

Definition at line 119 of file L1GtTriggerMenuXmlParser.h.

References m_vecMuonTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

119 { return m_vecMuonTemplate; }

L1GtTriggerMenuXmlParser::m_vecMuonTemplate

std::vector< std::vector< L1GtMuonTemplate > > m_vecMuonTemplate

Definition: L1GtTriggerMenuXmlParser.h:446

bool L1GtTriggerMenuXmlParser::workAlgorithm	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	algName,
		unsigned int	chipNr
	)

private

parse an algorithm and insert it into algorithm map.

workAlgorithm - parse the algorithm and insert it into algorithm map.

Parameters

node	The corresponding node to the algorithm.
name	The name of the algorithm.
chipNr	The number of the chip the conditions for that algorithm are located on.

Returns: "true" on success, "false" if an error occurred.

Definition at line 3087 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), getXMLAttribute(), getXMLTextValue(), insertAlgorithmIntoMap(), edm::isDebugEnabled(), LogDebug, LogTrace, m_orderConditionChip, m_pinsOnConditionChip, L1GtXmlParserTags::m_xmlAlgorithmAttrAlias, L1GtXmlParserTags::m_xmlAttrNr, L1GtXmlParserTags::m_xmlTagOutput, L1GtXmlParserTags::m_xmlTagOutputPin, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parseAlgorithms().

                                                                   {
   XERCES_CPP_NAMESPACE_USE
 
   if (node == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "    Node is 0 in " << __PRETTY_FUNCTION__
                                          << " can not parse the algorithm " << algName << std::endl;
     return false;
   }
 
   // get alias
   std::string algAlias = getXMLAttribute(node, m_xmlAlgorithmAttrAlias);
 
   if (algAlias.empty()) {
     algAlias = algName;
     LogDebug("L1GtTriggerMenuXmlParser") << "\n    No alias defined for algorithm. Alias set to algorithm name."
                                          << "\n    Algorithm name:  " << algName
                                          << "\n    Algorithm alias: " << algAlias << std::endl;
   } else {
     LogDebug("L1GtTriggerMenuXmlParser") << "\n    Alias defined for algorithm."
                                          << "\n    Algorithm name:  " << algName
                                          << "\n    Algorithm alias: " << algAlias << std::endl;
   }
 
   // get the logical expression from the node
   std::string logExpression = getXMLTextValue(node);
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Logical expression: " << logExpression
   //<< std::endl;
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Chip number:        " << chipNr
   //<< std::endl;
 
   // determine output pin
   DOMNode* pinNode = findXMLChild(node->getFirstChild(), m_xmlTagOutput);
   std::string pinString;
   int outputPin = 0;
 
   pinNode = node->getFirstChild();
   if ((pinNode = findXMLChild(pinNode, m_xmlTagOutputPin)) != nullptr) {
     pinString = getXMLAttribute(pinNode, m_xmlAttrNr);
 
     // convert pinString to integer
     std::istringstream opStream(pinString);
 
     if ((opStream >> outputPin).fail()) {
       LogDebug("L1GtTriggerMenuXmlParser")
           << "    Unable to convert pin string " << pinString << " to int for algorithm : " << algName << std::endl;
 
       return false;
     }
   }
 
   if (pinNode == nullptr) {
     LogTrace("L1GtTriggerMenuXmlParser") << "    Warning: No pin number found for algorithm: " << algName << std::endl;
 
     return false;
   }
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Output pin:         " << outputPin
   //<< std::endl;
 
   // compute the bit number from chip number, output pin and order of the chips
   // pin numbering start with 1, bit numbers with 0
   int bitNumber = outputPin + (m_orderConditionChip[chipNr] - 1) * m_pinsOnConditionChip - 1;
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Bit number:         " << bitNumber
   //<< std::endl;
 
   // create a new algorithm and insert it into algorithm map
   L1GtAlgorithm alg(algName, logExpression, bitNumber);
   alg.setAlgoChipNumber(static_cast<int>(chipNr));
   alg.setAlgoAlias(algAlias);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     alg.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert algorithm into the map
   if (!insertAlgorithmIntoMap(alg)) {
     return false;
   }
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::workCondition	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	name,
		unsigned int	chipNr
	)

private

choose the parser for a particular condition

workCondition - call the appropriate function to parse this condition.

Parameters

node	The corresponding node to the condition.
name	The name of the condition.
chipNr	The number of the chip the condition is located on.

Returns: "true" on success, "false" if an error occurred.

Definition at line 2947 of file L1GtTriggerMenuXmlParser.cc.

Referenced by parseConditions().

                                                                   {
   XERCES_CPP_NAMESPACE_USE
 
   // get condition, particle name and type name
   std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
   std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
   std::string type = getXMLAttribute(node, m_xmlConditionAttrType);
 
   if (condition.empty() || particle.empty() || type.empty()) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Missing attributes for condition " << name << std::endl;
 
     return false;
   }
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "    condition: " << condition << ", particle: " << particle
   //<< ", type: " << type << std::endl;
 
   // call the appropiate function for this condition
 
   if (condition == m_xmlConditionAttrConditionMuon) {
     return parseMuon(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionCalo) {
     return parseCalo(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionEnergySum) {
     return parseEnergySum(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionJetCounts) {
     return parseJetCounts(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionCastor) {
     return parseCastor(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionHfBitCounts) {
     return parseHfBitCounts(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionHfRingEtSums) {
     return parseHfRingEtSums(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionBptx) {
     return parseBptx(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionExternal) {
     return parseExternal(node, name, chipNr);
   } else if (condition == m_xmlConditionAttrConditionCorrelation) {
     return parseCorrelation(node, name, chipNr);
   } else {
     edm::LogError("L1GtTriggerMenuXmlParser") << "\n Error: unknown condition (" << condition << ")" << std::endl;
 
     return false;
   }
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::workTechTrigger	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		const std::string &	algName
	)

private

parse an algorithm and insert it into algorithm map.

workTechTrigger - parse the technical trigger and insert it into technical trigger map.

Parameters

node	The corresponding node to the technical trigger.
name	The name of the technical trigger.

Returns: "true" on success, "false" if an error occurred.

Definition at line 3269 of file L1GtTriggerMenuXmlParser.cc.

References findXMLChild(), getXMLAttribute(), getXMLTextValue(), insertTechTriggerIntoMap(), edm::isDebugEnabled(), LogDebug, LogTrace, L1GtXmlParserTags::m_xmlAttrNr, L1GtXmlParserTags::m_xmlTagOutput, L1GtXmlParserTags::m_xmlTagOutputPin, L1GtAlgorithm::print(), L1GtAlgorithm::setAlgoAlias(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parseTechTriggers().

                                                                                                           {
   XERCES_CPP_NAMESPACE_USE
 
   if (node == nullptr) {
     LogDebug("L1GtTriggerMenuXmlParser") << "    Node is 0 in " << __PRETTY_FUNCTION__
                                          << " can not parse the technical trigger " << algName << std::endl;
     return false;
   }
 
   // get the logical expression from the node
   std::string logExpression = getXMLTextValue(node);
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Logical expression: " << logExpression
   //<< std::endl;
 
   // determine bit number (use output pin tag)
   DOMNode* pinNode = findXMLChild(node->getFirstChild(), m_xmlTagOutput);
   std::string pinString;
   int outputPin = 0;
 
   pinNode = node->getFirstChild();
   if ((pinNode = findXMLChild(pinNode, m_xmlTagOutputPin)) != nullptr) {
     pinString = getXMLAttribute(pinNode, m_xmlAttrNr);
 
     // convert pinString to integer
     std::istringstream opStream(pinString);
 
     if ((opStream >> outputPin).fail()) {
       LogDebug("L1GtTriggerMenuXmlParser") << "    Unable to convert pin string " << pinString
                                            << " to int for technical trigger : " << algName << std::endl;
 
       return false;
     }
   }
 
   if (pinNode == nullptr) {
     LogTrace("L1GtTriggerMenuXmlParser") << "    Warning: No pin number found for technical trigger: " << algName
                                          << std::endl;
 
     return false;
   }
 
   // set the bit number
   int bitNumber = outputPin;
 
   //LogTrace("L1GtTriggerMenuXmlParser")
   //<< "      Bit number:         " << bitNumber
   //<< std::endl;
 
   // create a new technical trigger and insert it into technical trigger map
   // alias set automatically to name
   L1GtAlgorithm alg(algName, logExpression, bitNumber);
   alg.setAlgoAlias(algName);
 
   if (edm::isDebugEnabled()) {
     std::ostringstream myCoutStream;
     alg.print(myCoutStream);
     LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;
   }
 
   // insert technical trigger into the map
   if (!insertTechTriggerIntoMap(alg)) {
     return false;
   }
 
   return true;
 }

bool L1GtTriggerMenuXmlParser::workXML ( XERCES_CPP_NAMESPACE::XercesDOMParser * parser )

private

do all the steps for filling a trigger menu

workXML parse the XML-File

Parameters

parser The parser to use for parsing the XML-File

Returns: "true" if succeeded, "false" if an error occurred.

Definition at line 3396 of file L1GtTriggerMenuXmlParser.cc.

References clearMaps(), LogTrace, L1GtXmlParserTags::m_xmlTagDef, parseAlgorithms(), parseConditions(), parseId(), parseTechTriggers(), and fetchall_from_DQM_v2::release.

Referenced by parseXmlFile().

                                                                                   {
   XERCES_CPP_NAMESPACE_USE
 
   DOMDocument* doc = parser->getDocument();
   DOMNode* n1 = doc->getFirstChild();
 
   if (n1 == nullptr) {
     edm::LogError("L1GtTriggerMenuXmlParser") << "Error: Found no XML child" << std::endl;
 
     return false;
   }
 
   char* nodeName = XMLString::transcode(n1->getNodeName());
 
   if (XMLString::compareIString(nodeName, m_xmlTagDef.c_str())) {
     edm::LogError("L1GtTriggerMenuXmlParser")
         << "Error: First XML child is not \" " << m_xmlTagDef << "\" " << std::endl;
 
     return false;
   }
 
   LogTrace("L1GtTriggerMenuXmlParser") << "\nFirst node name is: " << nodeName << std::endl;
   XMLString::release(&nodeName);
 
   // clear possible old maps
   clearMaps();
 
   if (!parseId(parser)) {
     clearMaps();
     return false;
   }
 
   if (!parseConditions(parser)) {
     clearMaps();
     return false;
   }
 
   if (!parseAlgorithms(parser)) {
     clearMaps();
     return false;
   }
 
   if (!parseTechTriggers(parser)) {
     clearMaps();
     return false;
   }
 
   return true;
 }