#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)
const std::string &	gtAlgorithmImplementation () const
const AlgorithmMap &	gtAlgorithmMap () const
	get / set the algorithm map (by name)
const std::vector< ConditionMap > &	gtConditionMap () const
	get / set / build the condition maps
const unsigned int	gtNumberConditionChips () const
	get / set the number of condition chips in GTL
const unsigned int	gtNumberL1JetCounts () const
	get / set the number of L1 jet counts received by GT
const unsigned int	gtNumberPhysTriggers () const
	get / set the number of physics trigger algorithms
const unsigned int	gtNumberTechTriggers () const
	get / set the number of technical triggers
std::vector< int >	gtOrderConditionChip () const
const unsigned int	gtPinsOnConditionChip () const
	get / set the number of pins on the GTL condition chips
const std::string &	gtScaleDbKey () const
	menu associated scale key
const AlgorithmMap &	gtTechnicalTriggerMap () const
	get / set the technical trigger map
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
const std::string &	gtTriggerMenuInterfaceAuthor () const
const std::string &	gtTriggerMenuInterfaceDate () const
	get / set the XML parser creation date, author, description for menu interface, menu
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
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
virtual	~L1GtTriggerMenuXmlParser ()
	destructor
Private Member Functions
void	cleanupXML (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	shutdown the xml utils and deallocate parser and error handler
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
XERCES_CPP_NAMESPACE::DOMNode *	findXMLChild (XERCES_CPP_NAMESPACE::DOMNode startChild, const std::string &tagName, bool beginOnly=false, std::string rest=0)
	find a named child of a xml node
int	getBitFromNode (XERCES_CPP_NAMESPACE::DOMNode *node)
	get bit from a bit node
bool	getConditionChildValues (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &childName, unsigned int num, std::vector< boost::uint64_t > &dst)
	get values from a child of a condition
int	getGEqFlag (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &nodeName)
	getGEqFlag - get the "greater or equal flag" from a condition
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
int	getNumFromType (const std::string &type)
	get number of particles from condition type
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
bool	getXMLHexTextValue (XERCES_CPP_NAMESPACE::DOMNode *node, boost::uint64_t &dst)
	get a hexadecimal value of a xml node containing text
bool	getXMLHexTextValue128 (XERCES_CPP_NAMESPACE::DOMNode *node, boost::uint64_t &dstL, boost::uint64_t &dstH)
	get a hexadecimal value of a xml node containing text with up to 128 bit
std::string	getXMLTextValue (XERCES_CPP_NAMESPACE::DOMNode *node)
	get the text value of a xml node as string
bool	hexString2UInt128 (const std::string &hexString, boost::uint64_t &dstL, boost::uint64_t &dstH)
	convert a hexadecimal string with up to 128 to 2 boost::uint64_t
XERCES_CPP_NAMESPACE::XercesDOMParser *	initXML (const std::string &xmlFile)
	init xml system
bool	insertAlgorithmIntoMap (const L1GtAlgorithm &alg)
	insert an algorithm into algorithm map
bool	insertConditionIntoMap (L1GtCondition &cond, const int chipNr)
bool	insertTechTriggerIntoMap (const L1GtAlgorithm &alg)
	insert a technical trigger into technical trigger map
bool	parseAlgorithms (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse all algorithms
bool	parseBptx (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a Bptx condition
bool	parseCalo (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0, const bool corrFlag=false)
	parse a calorimeter condition
bool	parseCastor (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a CASTOR condition
bool	parseConditions (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse all conditions
bool	parseCorrelation (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a correlation condition
bool	parseEnergySum (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0, const bool corrFlag=false)
	parse an "energy sum" condition
bool	parseExternal (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse an External condition
bool	parseHfBitCounts (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a HfBitCounts condition
bool	parseHfRingEtSums (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a HfRingEtSums condition
bool	parseId (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse all parse all identification attributes (trigger menu names, scale DB key, etc)
bool	parseJetCounts (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0)
	parse a "jet counts" condition
bool	parseMuon (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr=0, const bool corrFlag=false)
	parse a muon condition
bool	parseTechTriggers (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse all algorithms
bool	parseVmeXML (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	parse the vme xml file
bool	workAlgorithm (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr)
	parse an algorithm and insert it into algorithm map.
bool	workCondition (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name, unsigned int chipNr)
	choose the parser for a particular condition
bool	workTechTrigger (XERCES_CPP_NAMESPACE::DOMNode *node, const std::string &name)
	parse an algorithm and insert it into algorithm map.
bool	workXML (XERCES_CPP_NAMESPACE::XercesDOMParser *parser)
	do all the steps for filling a trigger menu
Private Attributes
AlgorithmMap	m_algorithmAliasMap
	map containing the physics algorithms (by alias)
std::string	m_algorithmImplementation
AlgorithmMap	m_algorithmMap
	map containing the physics algorithms (by name)
std::vector< ConditionMap >	m_conditionMap
	map containing the conditions (per condition chip) - transient
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
unsigned int	m_numberL1JetCounts
	jet counts
unsigned int	m_numberPhysTriggers
	number of physics trigger algorithms
unsigned int	m_numberTechTriggers
	number of technical triggers
std::vector< int >	m_orderConditionChip
unsigned int	m_pinsOnConditionChip
	number of pins on the GTL condition chips
std::string	m_scaleDbKey
	menu associated scale key
AlgorithmMap	m_technicalTriggerMap
	map containing the technical triggers
std::string	m_triggerMenuAuthor
std::string	m_triggerMenuDate
std::string	m_triggerMenuDescription
std::string	m_triggerMenuImplementation
std::string	m_triggerMenuInterface
	menu names
std::string	m_triggerMenuInterfaceAuthor
std::string	m_triggerMenuInterfaceDate
	members for XML parser only (do not appear in CondFormats)
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

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

$Date$ $Revision$

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

Implementation: <TODO: enter implementation details>

Author:: : Vasile Mihai Ghete - HEPHY Vienna

$Date$ $Revision$

Definition at line 54 of file L1GtTriggerMenuXmlParser.h.

Constructor & Destructor Documentation

L1GtTriggerMenuXmlParser::L1GtTriggerMenuXmlParser ( )

constructor empty

Definition at line 41 of file L1GtTriggerMenuXmlParser.cc.

                                                   :
    L1GtXmlParserTags(), m_xmlErrHandler(0), 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 ( ) [virtual]

destructor

Definition at line 54 of file L1GtTriggerMenuXmlParser.cc.

References clearMaps().

                                                    {

    clearMaps();

}

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 901 of file L1GtTriggerMenuXmlParser.cc.

References m_xmlErrHandler, and geometryXMLtoCSV::parser.

Referenced by parseXmlFile().

                                                                                     {

    XERCES_CPP_NAMESPACE_USE

    if (parser != 0) {
        delete parser;
    }

    if (m_xmlErrHandler != 0) {
        delete m_xmlErrHandler;
        m_xmlErrHandler = 0;
    }

    XMLPlatformUtils::Terminate();

}

void L1GtTriggerMenuXmlParser::clearMaps ( ) [private]

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

Definition at line 982 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 246 of file L1GtTriggerMenuXmlParser.h.

References m_corCaloTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                  {
        return m_corCaloTemplate;
    }

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

Definition at line 253 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 239 of file L1GtTriggerMenuXmlParser.h.

References m_corMuonTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                  {
        return m_corMuonTemplate;
    }

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 714 of file L1GtTriggerMenuXmlParser.cc.

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

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

                                                   {

    XERCES_CPP_NAMESPACE_USE

    // should never happen...
    if (node == 0) {

        LogDebug("L1GtTriggerMenuXmlParser")
        << "node == 0 in " << __PRETTY_FUNCTION__ << std::endl;

        return false;
    }

    DOMNode* n1 = findXMLChild(node->getFirstChild(), childName);

    if (n1 == 0) {

        LogDebug("L1GtTriggerMenuXmlParser") << "Child of condition not found ( " << childName
            << ")" << std::endl;

        return false;
    }

    DOMNode* n2 = findXMLChild(n1->getFirstChild(), m_xmlTagValue);

    if (n2 == 0) {

        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

    boost::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 = `0`
	)		`[private]`

find a named child of a xml node

Definition at line 419 of file L1GtTriggerMenuXmlParser.cc.

References fetchall_from_DQM_v2::release.

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

                     {

    XERCES_CPP_NAMESPACE_USE

    char* nodeName = 0;

    DOMNode *n1 = startChild;
    if (n1 == 0) {
        return 0;
    }

    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 == 0) {
                    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 == 0) {
                    break;
                }

                nodeName = XMLString::transcode(n1->getNodeName());
            }
            if (n1 != 0 && rest != 0) {
                *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 == 0) {
                break;
            }

        }
        if (n1 != 0 && rest != 0) {
            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 1260 of file L1GtTriggerMenuXmlParser.cc.

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

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< boost::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 boost::uint64_t where the results are written.

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

Definition at line 836 of file L1GtTriggerMenuXmlParser.cc.

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

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

                                                                                 {

    XERCES_CPP_NAMESPACE_USE

    if (node == 0) {

        LogDebug("L1GtTriggerMenuXmlParser")
        << "node == 0 in " << __PRETTY_FUNCTION__
        << std::endl;

        return false;
    }

    DOMNode* n1 = findXMLChild(node->getFirstChild(), childName);

    // if child not found
    if (n1 == 0) {

        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 == 0) {

            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 1292 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 == 0) {

        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 != 0) {
        n1 = findXMLChild(n1->getFirstChild(), m_xmlTagGEq);
        if (n1 == 0) {

            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 1342 of file L1GtTriggerMenuXmlParser.cc.

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

Referenced by parseMuon().

                                {

    XERCES_CPP_NAMESPACE_USE

    if (node == 0) {
        return false;
    }

    // find ptLowThreshold child
    DOMNode* n1 = findXMLChild(node->getFirstChild(), m_xmlTagPtLowThreshold);

    if (n1 == 0) {
        return false;
    }

    // get first value tag
    n1 = findXMLChild(n1->getFirstChild(), m_xmlTagValue);

    for (unsigned int i = 0; i < num; i++) {

        if (n1 == 0) {
            return false;
        }

        // MIP bit

        DOMNode* bitnode = findXMLChild(n1->getFirstChild(), m_xmlTagEnableMip);
        if (bitnode == 0) {
            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 == 0) {
            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 == 0) {
            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 1223 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 1185 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 493 of file L1GtTriggerMenuXmlParser.cc.

References asciidump::attributes, fetchall_from_DQM_v2::release, and run_regression::ret.

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 == 0) {
        return ret;
    }

    // get attribute node
    XMLCh* attrName = XMLString::transcode(name.c_str());
    DOMNode* attribNode = attributes->getNamedItem(attrName);

    XMLString::release(&attrName);
    if (attribNode == 0) {
        return ret;
    }

    char* retCstr = XMLString::transcode(attribNode->getNodeValue());
    ret = retCstr;
    XMLString::release(&retCstr);

    return ret;
}

bool L1GtTriggerMenuXmlParser::getXMLHexTextValue	(	XERCES_CPP_NAMESPACE::DOMNode *	node,
		boost::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 683 of file L1GtTriggerMenuXmlParser.cc.

References getXMLHexTextValue128().

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

                        {

    boost::uint64_t dummyH; // dummy for eventual higher 64bit
    boost::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,
		boost::uint64_t &	dstL,
		boost::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 649 of file L1GtTriggerMenuXmlParser.cc.

References getXMLTextValue(), hexString2UInt128(), and LogDebug.

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

                                              {

    if (node == 0) {

        LogDebug("L1GtTriggerMenuXmlParser") << "node == 0 in " << __PRETTY_FUNCTION__ << std::endl;

        return false;
    }

    boost::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 530 of file L1GtTriggerMenuXmlParser.cc.

References python::Node::node, fetchall_from_DQM_v2::release, and run_regression::ret.

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

                                                                                     {

    XERCES_CPP_NAMESPACE_USE

    std::string ret;

    DOMNode* n1 = node;
    if (n1 == 0) {
        return ret;
    }

    const XMLCh* retXmlCh = n1->getTextContent();
    if (retXmlCh == 0) {
        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 269 of file L1GtTriggerMenuXmlParser.h.

References m_algorithmAliasMap.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                           {
        return m_algorithmAliasMap;
    }

const std::string& L1GtTriggerMenuXmlParser::gtAlgorithmImplementation ( ) const [inline]

Definition at line 330 of file L1GtTriggerMenuXmlParser.h.

References m_algorithmImplementation.

                                                              {
        return m_algorithmImplementation;
    }

const AlgorithmMap& L1GtTriggerMenuXmlParser::gtAlgorithmMap ( ) const [inline]

get / set the algorithm map (by name)

Definition at line 262 of file L1GtTriggerMenuXmlParser.h.

References m_algorithmMap.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                      {
        return m_algorithmMap;
    }

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

get / set / build the condition maps

Definition at line 114 of file L1GtTriggerMenuXmlParser.h.

References m_conditionMap.

                                                                 {
        return m_conditionMap;
    }

const unsigned int L1GtTriggerMenuXmlParser::gtNumberConditionChips ( ) const [inline]

get / set the number of condition chips in GTL

Definition at line 69 of file L1GtTriggerMenuXmlParser.h.

References m_numberConditionChips.

                                                             {
        return m_numberConditionChips;
    }

const unsigned int L1GtTriggerMenuXmlParser::gtNumberL1JetCounts ( ) const [inline]

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

Definition at line 105 of file L1GtTriggerMenuXmlParser.h.

References m_numberL1JetCounts.

                                                          {
        return m_numberL1JetCounts;
    }

const unsigned int L1GtTriggerMenuXmlParser::gtNumberPhysTriggers ( ) const [inline]

get / set the number of physics trigger algorithms

Definition at line 91 of file L1GtTriggerMenuXmlParser.h.

References m_numberPhysTriggers.

                                                           {
        return m_numberPhysTriggers;
    }

const unsigned int L1GtTriggerMenuXmlParser::gtNumberTechTriggers ( ) const [inline]

get / set the number of technical triggers

Definition at line 98 of file L1GtTriggerMenuXmlParser.h.

References m_numberTechTriggers.

                                                           {
        return m_numberTechTriggers;
    }

std::vector<int> L1GtTriggerMenuXmlParser::gtOrderConditionChip ( ) const [inline]

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

Definition at line 84 of file L1GtTriggerMenuXmlParser.h.

References m_orderConditionChip.

                                                       {
        return m_orderConditionChip;
    }

const unsigned int L1GtTriggerMenuXmlParser::gtPinsOnConditionChip ( ) const [inline]

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

Definition at line 76 of file L1GtTriggerMenuXmlParser.h.

References m_pinsOnConditionChip.

                                                            {
        return m_pinsOnConditionChip;
    }

const std::string& L1GtTriggerMenuXmlParser::gtScaleDbKey ( ) const [inline]

menu associated scale key

Definition at line 142 of file L1GtTriggerMenuXmlParser.h.

References m_scaleDbKey.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                 {
        return m_scaleDbKey;
    }

const AlgorithmMap& L1GtTriggerMenuXmlParser::gtTechnicalTriggerMap ( ) const [inline]

get / set the technical trigger map

Definition at line 276 of file L1GtTriggerMenuXmlParser.h.

References m_technicalTriggerMap.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                             {
        return m_technicalTriggerMap;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuAuthor ( ) const [inline]

Definition at line 317 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuAuthor.

                                                        {
        return m_triggerMenuAuthor;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuDate ( ) const [inline]

Definition at line 311 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuDate.

                                                      {
        return m_triggerMenuDate;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuDescription ( ) const [inline]

Definition at line 323 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuDescription.

                                                             {
        return m_triggerMenuDescription;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuImplementation ( ) const [inline]

Definition at line 135 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuImplementation.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                {
        return m_triggerMenuImplementation;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuInterface ( ) const [inline]

get / set the trigger menu names

Definition at line 121 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuInterface.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                           {
        return m_triggerMenuInterface;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuInterfaceAuthor ( ) const [inline]

Definition at line 297 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuInterfaceAuthor.

                                                                 {
        return m_triggerMenuInterfaceAuthor;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuInterfaceDate ( ) const [inline]

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

Definition at line 291 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuInterfaceDate.

                                                               {
        return m_triggerMenuInterfaceDate;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuInterfaceDescription ( ) const [inline]

Definition at line 303 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuInterfaceDescription.

                                                                      {
        return m_triggerMenuInterfaceDescription;
    }

const std::string& L1GtTriggerMenuXmlParser::gtTriggerMenuName ( ) const [inline]

Definition at line 128 of file L1GtTriggerMenuXmlParser.h.

References m_triggerMenuName.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                      {
        return m_triggerMenuName;
    }

bool L1GtTriggerMenuXmlParser::hexString2UInt128	(	const std::string &	hexString,
		boost::uint64_t &	dstL,
		boost::uint64_t &	dstH
	)		`[private]`

convert a hexadecimal string with up to 128 to 2 boost::uint64_t

hexString2UInt128 converts an up to 128 bit hexadecimal string to two boost::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 565 of file L1GtTriggerMenuXmlParser.cc.

References LogDebug.

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();
    boost::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();
    boost::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 342 of file L1GtTriggerMenuXmlParser.cc.

References m_xmlErrHandler, python::rootplot::argparse::message, geometryXMLtoCSV::parser, and fetchall_from_DQM_v2::release.

Referenced by parseXmlFile().

                                                                                               {

    XERCES_CPP_NAMESPACE_USE

    // try to initialize
    try {
        XMLPlatformUtils::Initialize();
    }
    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 0;
    }

    XercesDOMParser* parser = new XercesDOMParser();
    parser->setValidationScheme(XercesDOMParser::Val_Always);
    parser->setDoNamespaces(false); // we got no dtd

    if (m_xmlErrHandler == 0) { // 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 = 0;
        return 0;
    }
    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 = 0;
        return 0;
    }
    catch (...) {

        edm::LogError("L1GtTriggerMenuXmlParser")
        << "Unexpected Exception while parsing XML!"
        << std::endl;

        delete parser;
        delete m_xmlErrHandler;
        m_xmlErrHandler = 0;
        return 0;
    }

    return parser;
}

bool L1GtTriggerMenuXmlParser::insertAlgorithmIntoMap ( const L1GtAlgorithm & alg ) [private]

insert an algorithm into algorithm map

Definition at line 1026 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, and m_pinsOnConditionChip.

Referenced by workAlgorithm().

                                                                              {

    std::string algName = alg.algoName();
    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 1002 of file L1GtTriggerMenuXmlParser.cc.

References L1GtCondition::condName(), prof2calltree::count, LogTrace, and m_conditionMap.

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 1117 of file L1GtTriggerMenuXmlParser.cc.

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

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 3636 of file L1GtTriggerMenuXmlParser.cc.

References asciidump::doc, findXMLChild(), m_numberConditionChips, L1GtXmlParserTags::m_xmlTagAlgorithms, L1GtXmlParserTags::m_xmlTagChip, L1GtXmlParserTags::m_xmlTagDef, python::Node::node, 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 == 0) {
        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 == 0) {
        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 == 0) {
            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 != 0) {
            //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 != 0 && 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 2652 of file L1GtTriggerMenuXmlParser.cc.

References getXMLAttribute(), insertConditionIntoMap(), LogTrace, m_vecBptxTemplate, L1GtXmlParserTags::m_xmlConditionAttrCondition, L1GtXmlParserTags::m_xmlConditionAttrObject, L1GtXmlParserTags::m_xmlConditionAttrObjectBptx, L1GtXmlParserTags::m_xmlConditionAttrType, L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtCondition::setCondType(), 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 1720 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<boost::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 2314 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(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtCondition::setCondType(), 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 3428 of file L1GtTriggerMenuXmlParser.cc.

References asciidump::doc, findXMLChild(), LogTrace, m_numberConditionChips, L1GtXmlParserTags::m_xmlTagChip, L1GtXmlParserTags::m_xmlTagConditions, L1GtXmlParserTags::m_xmlTagDef, fetchall_from_DQM_v2::release, 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 == 0) {

        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 == 0) {

        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 == 0) {

            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 != 0) {

            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 != 0 && 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 2788 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<boost::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 == 0) {
        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 == 0) {
        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 1932 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<boost::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)) == 0) {
            edm::LogError("L1GtTriggerMenuXmlParser")
                << "    Could not get energyOverflow for EnergySum condition (" << name << ")"
                << std::endl;
            return false;
        }
        if ( (n1 = findXMLChild(n1->getFirstChild(), m_xmlTagEnergyOverflow)) == 0) {
            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 2720 of file L1GtTriggerMenuXmlParser.cc.

References getXMLAttribute(), insertConditionIntoMap(), LogTrace, m_vecExternalTemplate, L1GtXmlParserTags::m_xmlConditionAttrCondition, L1GtXmlParserTags::m_xmlConditionAttrObject, L1GtXmlParserTags::m_xmlConditionAttrObjectGtExternal, L1GtXmlParserTags::m_xmlConditionAttrType, L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtCondition::setCondType(), 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 2389 of file L1GtTriggerMenuXmlParser.cc.

References getConditionChildValues(), getGEqFlag(), getXMLAttribute(), HfBitCounts, 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(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtHfBitCountsTemplate::setConditionParameter(), L1GtCondition::setCondType(), L1GtCondition::setObjectType(), 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 = const_cast<char*>(type.c_str());
    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<boost::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 2521 of file L1GtTriggerMenuXmlParser.cc.

References getConditionChildValues(), getGEqFlag(), getXMLAttribute(), HfRingEtSums, 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(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtHfRingEtSumsTemplate::setConditionParameter(), L1GtCondition::setCondType(), L1GtCondition::setObjectType(), 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 = const_cast<char*>(type.c_str());
    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<boost::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 3115 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 == 0) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "Error: No child of <" << m_xmlTagDef
                << "> tag found." << std::endl;
        return false;
    }

    headerNode = findXMLChild(headerNode, m_xmlTagHeader);
    if (headerNode == 0) {

        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 == 0) {

            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 == 0) {

            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 == 0) {

            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 == 0) {

            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 == 0) {

            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 == 0) {

            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 == 0) {

            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 == 0) {

            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 == 0) {

            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 != "") {
            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 2141 of file L1GtTriggerMenuXmlParser.cc.

References getConditionChildValues(), getGEqFlag(), getXMLAttribute(), 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(), L1GtCondition::setCondChipNr(), L1GtCondition::setCondGEq(), L1GtJetCountsTemplate::setConditionParameter(), L1GtCondition::setCondType(), L1GtCondition::setObjectType(), 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 = const_cast<char*>(type.c_str());
    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<boost::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 1439 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<boost::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 3807 of file L1GtTriggerMenuXmlParser.cc.

References asciidump::doc, findXMLChild(), L1GtXmlParserTags::m_xmlTagDef, L1GtXmlParserTags::m_xmlTagTechTriggers, python::Node::node, 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 == 0) {
        edm::LogError("L1GtTriggerMenuXmlParser")
                << "  Error: No child found for " << m_xmlTagDef << std::endl;
        return false;
    }

    algNode = findXMLChild(algNode, m_xmlTagTechTriggers);
    if (algNode == 0) {
        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 != 0) {
        //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 931 of file L1GtTriggerMenuXmlParser.cc.

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

                                                                                      {

    XERCES_CPP_NAMESPACE_USE

    DOMDocument* doc = parser->getDocument();
    DOMNode* n1 = doc->getFirstChild();

    if (n1 == 0) {

        edm::LogError("L1GtTriggerMenuXmlParser") << "Error: Found no XML child" << std::endl;

        return false;
    }

    // find "vme"-tag
    n1 = findXMLChild(n1, m_xmlTagVme);
    if (n1 == 0) {

        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 == 0) {
            // 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 234 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, geometryXMLtoCSV::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 = 0;

    XercesDOMParser* parser;

    LogTrace("L1GtTriggerMenuXmlParser") << "\nOpening XML-File: \n  " << defXmlFile << std::endl;

    if ((parser = initXML(defXmlFile)) != 0) {
        workXML(parser);
    }
    cleanupXML(parser);

}

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

Definition at line 200 of file L1GtTriggerMenuXmlParser.cc.

References m_corCaloTemplate.

                                                                     {

    m_corCaloTemplate = corCaloTempl;
}

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

Definition at line 206 of file L1GtTriggerMenuXmlParser.cc.

References m_corEnergySumTemplate.

                                                                               {

    m_corEnergySumTemplate = corEnergySumTempl;
}

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

Definition at line 194 of file L1GtTriggerMenuXmlParser.cc.

References m_corMuonTemplate.

                                                                     {

    m_corMuonTemplate = corMuonTempl;
}

void L1GtTriggerMenuXmlParser::setGtAlgorithmAliasMap ( const AlgorithmMap & algoMap )

Definition at line 221 of file L1GtTriggerMenuXmlParser.cc.

References m_algorithmAliasMap.

                                                                                 {
    m_algorithmAliasMap = algoMap;
}

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

Definition at line 323 of file L1GtTriggerMenuXmlParser.cc.

References m_algorithmImplementation.

                                                                                {

    m_algorithmImplementation = val;

}

void L1GtTriggerMenuXmlParser::setGtAlgorithmMap ( const AlgorithmMap & algoMap )

Definition at line 216 of file L1GtTriggerMenuXmlParser.cc.

References m_algorithmMap.

                                                                            {
    m_algorithmMap = algoMap;
}

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

Definition at line 109 of file L1GtTriggerMenuXmlParser.cc.

References m_conditionMap.

                                                                                       {
    m_conditionMap = condMap;
}

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

Definition at line 61 of file L1GtTriggerMenuXmlParser.cc.

References m_numberConditionChips.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                   {

    m_numberConditionChips = numberConditionChipsValue;

}

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

Definition at line 101 of file L1GtTriggerMenuXmlParser.cc.

References m_numberL1JetCounts.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                {

    m_numberL1JetCounts = numberL1JetCountsValue;

}

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

Definition at line 85 of file L1GtTriggerMenuXmlParser.cc.

References m_numberPhysTriggers.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                     {

    m_numberPhysTriggers = numberPhysTriggersValue;

}

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

Definition at line 93 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 77 of file L1GtTriggerMenuXmlParser.cc.

References m_orderConditionChip.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                   {

    m_orderConditionChip = orderConditionChipValue;

}

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

Definition at line 69 of file L1GtTriggerMenuXmlParser.cc.

References m_pinsOnConditionChip.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                                    {

    m_pinsOnConditionChip = pinsOnConditionChipValue;

}

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

Definition at line 127 of file L1GtTriggerMenuXmlParser.cc.

References m_scaleDbKey.

                                                                        {
    m_scaleDbKey = scaleKey;
}

void L1GtTriggerMenuXmlParser::setGtTechnicalTriggerMap ( const AlgorithmMap & ttMap )

Definition at line 226 of file L1GtTriggerMenuXmlParser.cc.

References m_technicalTriggerMap.

                                                                                 {
    m_technicalTriggerMap = ttMap;
}

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

Definition at line 311 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuAuthor.

                                                                          {

    m_triggerMenuAuthor = val;

}

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

Definition at line 305 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuDate.

                                                                        {

    m_triggerMenuDate = val;

}

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

Definition at line 317 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuDescription.

                                                                               {

    m_triggerMenuDescription = val;

}

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

Definition at line 122 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuImplementation.

                                                                                                 {
    m_triggerMenuImplementation = menuImplementation;
}

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

Definition at line 114 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuInterface.

                                                                                       {
    m_triggerMenuInterface = menuInterface;
}

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

Definition at line 292 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuInterfaceAuthor.

                                                                                   {

    m_triggerMenuInterfaceAuthor = val;

}

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

Definition at line 286 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuInterfaceDate.

                                                                                 {

    m_triggerMenuInterfaceDate = val;

}

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

Definition at line 298 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuInterfaceDescription.

                                                                                        {

    m_triggerMenuInterfaceDescription = val;

}

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

Definition at line 118 of file L1GtTriggerMenuXmlParser.cc.

References m_triggerMenuName.

                                                                             {
    m_triggerMenuName = menuName;
}

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

Definition at line 174 of file L1GtTriggerMenuXmlParser.cc.

References m_vecBptxTemplate.

                                                                     {

    m_vecBptxTemplate = vecBptxTempl;
}

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

Definition at line 138 of file L1GtTriggerMenuXmlParser.cc.

References m_vecCaloTemplate.

                                                                     {

    m_vecCaloTemplate = vecCaloTempl;
}

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

Definition at line 156 of file L1GtTriggerMenuXmlParser.cc.

References m_vecCastorTemplate.

                                                                         {

    m_vecCastorTemplate = vecCastorTempl;
}

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

Definition at line 186 of file L1GtTriggerMenuXmlParser.cc.

References m_vecCorrelationTemplate.

                                                                                   {

    m_vecCorrelationTemplate = vecCorrelationTempl;
}

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

Definition at line 144 of file L1GtTriggerMenuXmlParser.cc.

References m_vecEnergySumTemplate.

                                                                               {

    m_vecEnergySumTemplate = vecEnergySumTempl;
}

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

Definition at line 180 of file L1GtTriggerMenuXmlParser.cc.

References m_vecExternalTemplate.

                                                                             {

    m_vecExternalTemplate = vecExternalTempl;
}

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

Definition at line 162 of file L1GtTriggerMenuXmlParser.cc.

References m_vecHfBitCountsTemplate.

                                                                                   {

    m_vecHfBitCountsTemplate = vecHfBitCountsTempl;
}

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

Definition at line 168 of file L1GtTriggerMenuXmlParser.cc.

References m_vecHfRingEtSumsTemplate.

                                                                                     {

    m_vecHfRingEtSumsTemplate = vecHfRingEtSumsTempl;
}

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

Definition at line 150 of file L1GtTriggerMenuXmlParser.cc.

References m_vecJetCountsTemplate.

                                                                               {

    m_vecJetCountsTemplate = vecJetCountsTempl;
}

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

Definition at line 132 of file L1GtTriggerMenuXmlParser.cc.

References m_vecMuonTemplate.

                                                                     {

    m_vecMuonTemplate = vecMuonTempl;
}

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

Definition at line 210 of file L1GtTriggerMenuXmlParser.h.

References m_vecBptxTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                {

        return m_vecBptxTemplate;
    }

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

Definition at line 155 of file L1GtTriggerMenuXmlParser.h.

References m_vecCaloTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                  {
        return m_vecCaloTemplate;
    }

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

Definition at line 180 of file L1GtTriggerMenuXmlParser.h.

References m_vecCastorTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                      {

        return m_vecCastorTemplate;
    }

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

Definition at line 229 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 162 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 220 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 190 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 200 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 171 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 149 of file L1GtTriggerMenuXmlParser.h.

References m_vecMuonTemplate.

Referenced by L1GtTriggerMenuXmlProducer::produceGtTriggerMenu().

                                                                                  {
        return m_vecMuonTemplate;
    }

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 3518 of file L1GtTriggerMenuXmlParser.cc.

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

Referenced by parseAlgorithms().

                                                   {

    XERCES_CPP_NAMESPACE_USE

    if (node == 0) {
        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 == "") {
        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) ) != 0) {
        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 == 0) {
        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 3352 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 3717 of file L1GtTriggerMenuXmlParser.cc.

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

Referenced by parseTechTriggers().

                              {

    XERCES_CPP_NAMESPACE_USE

    if (node == 0) {
        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) ) != 0) {
        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 == 0) {
        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 3862 of file L1GtTriggerMenuXmlParser.cc.

References clearMaps(), asciidump::doc, 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 == 0) {

        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;

}