L1GtTriggerMenuXmlParser.cc

Go to the documentation of this file.

// this class header
#include "L1TriggerConfig/L1GtConfigProducers/interface/L1GtTriggerMenuXmlParser.h"

// system include files
#include <string>
#include <vector>

#include <iostream>
#include <fstream>
#include <iomanip>

#include <boost/cstdint.hpp>

// user include files
// base class
#include "L1TriggerConfig/L1GtConfigProducers/interface/L1GtXmlParserTags.h"

#include "CondFormats/L1TObjects/interface/L1GtCondition.h"
#include "CondFormats/L1TObjects/interface/L1GtAlgorithm.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"
#include "FWCore/Concurrency/interface/Xerces.h"

// constructor
L1GtTriggerMenuXmlParser::L1GtTriggerMenuXmlParser() :
    L1GtXmlParserTags(), m_xmlErrHandler(nullptr), m_triggerMenuInterface("NULL"),
    m_triggerMenuName("NULL"), m_triggerMenuImplementation("NULL"), m_scaleDbKey("NULL")

{

    // menu names, scale key initialized to NULL due to ORACLE treatment of strings

    // empty

}

// destructor
L1GtTriggerMenuXmlParser::~L1GtTriggerMenuXmlParser() {

    clearMaps();

}

// set the number of condition chips in GTL
void L1GtTriggerMenuXmlParser::setGtNumberConditionChips(
    const unsigned int& numberConditionChipsValue) {

    m_numberConditionChips = numberConditionChipsValue;

}

// set the number of pins on the GTL condition chips
void L1GtTriggerMenuXmlParser::setGtPinsOnConditionChip(const unsigned int& pinsOnConditionChipValue) {

    m_pinsOnConditionChip = pinsOnConditionChipValue;

}

// set the correspondence "condition chip - GTL algorithm word"
// in the hardware
void L1GtTriggerMenuXmlParser::setGtOrderConditionChip(
    const std::vector<int>& orderConditionChipValue) {

    m_orderConditionChip = orderConditionChipValue;

}

// set the number of physics trigger algorithms
void L1GtTriggerMenuXmlParser::setGtNumberPhysTriggers(
        const unsigned int& numberPhysTriggersValue) {

    m_numberPhysTriggers = numberPhysTriggersValue;

}

// set the number of technical triggers
void L1GtTriggerMenuXmlParser::setGtNumberTechTriggers(
        const unsigned int& numberTechTriggersValue) {

    m_numberTechTriggers = numberTechTriggersValue;

}

// set the number of L1 jet counts received by GT
void L1GtTriggerMenuXmlParser::setGtNumberL1JetCounts(const unsigned int& numberL1JetCountsValue) {

    m_numberL1JetCounts = numberL1JetCountsValue;

}


// set the condition maps
void L1GtTriggerMenuXmlParser::setGtConditionMap(const std::vector<ConditionMap>& condMap) {
    m_conditionMap = condMap;
}

// set the trigger menu name
void L1GtTriggerMenuXmlParser::setGtTriggerMenuInterface(const std::string& menuInterface) {
    m_triggerMenuInterface = menuInterface;
}

void L1GtTriggerMenuXmlParser::setGtTriggerMenuName(const std::string& menuName) {
    m_triggerMenuName = menuName;
}

void L1GtTriggerMenuXmlParser::setGtTriggerMenuImplementation(const std::string& menuImplementation) {
    m_triggerMenuImplementation = menuImplementation;
}

// set menu associated scale key
void L1GtTriggerMenuXmlParser::setGtScaleDbKey(const std::string& scaleKey) {
    m_scaleDbKey = scaleKey;
}

// set the vectors containing the conditions
void L1GtTriggerMenuXmlParser::setVecMuonTemplate(
        const std::vector<std::vector<L1GtMuonTemplate> >& vecMuonTempl) {

    m_vecMuonTemplate = vecMuonTempl;
}

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

    m_vecCaloTemplate = vecCaloTempl;
}

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

    m_vecEnergySumTemplate = vecEnergySumTempl;
}

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

    m_vecJetCountsTemplate = vecJetCountsTempl;
}

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

    m_vecCastorTemplate = vecCastorTempl;
}

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

    m_vecHfBitCountsTemplate = vecHfBitCountsTempl;
}

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

    m_vecHfRingEtSumsTemplate = vecHfRingEtSumsTempl;
}

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

    m_vecBptxTemplate = vecBptxTempl;
}

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

    m_vecExternalTemplate = vecExternalTempl;
}

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

    m_vecCorrelationTemplate = vecCorrelationTempl;
}

// set the vectors containing the conditions for correlation templates
//
void L1GtTriggerMenuXmlParser::setCorMuonTemplate(
        const std::vector<std::vector<L1GtMuonTemplate> >& corMuonTempl) {

    m_corMuonTemplate = corMuonTempl;
}

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

    m_corCaloTemplate = corCaloTempl;
}

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

    m_corEnergySumTemplate = corEnergySumTempl;
}




// set the algorithm map (by algorithm names)
void L1GtTriggerMenuXmlParser::setGtAlgorithmMap(const AlgorithmMap& algoMap) {
    m_algorithmMap = algoMap;
}

// set the algorithm map (by algorithm aliases)
void L1GtTriggerMenuXmlParser::setGtAlgorithmAliasMap(const AlgorithmMap& algoMap) {
    m_algorithmAliasMap = algoMap;
}

// set the technical trigger map
void L1GtTriggerMenuXmlParser::setGtTechnicalTriggerMap(const AlgorithmMap& ttMap) {
    m_technicalTriggerMap = ttMap;
}

//


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

    XERCES_CPP_NAMESPACE_USE

    // resize the vector of condition maps
    // the number of condition chips should be correctly set before calling parseXmlFile
    m_conditionMap.resize(m_numberConditionChips);

    m_vecMuonTemplate.resize(m_numberConditionChips);
    m_vecCaloTemplate.resize(m_numberConditionChips);
    m_vecEnergySumTemplate.resize(m_numberConditionChips);
    m_vecJetCountsTemplate.resize(m_numberConditionChips);
    m_vecCastorTemplate.resize(m_numberConditionChips);
    m_vecHfBitCountsTemplate.resize(m_numberConditionChips);
    m_vecHfRingEtSumsTemplate.resize(m_numberConditionChips);
    m_vecBptxTemplate.resize(m_numberConditionChips);
    m_vecExternalTemplate.resize(m_numberConditionChips);

    m_vecCorrelationTemplate.resize(m_numberConditionChips);
    m_corMuonTemplate.resize(m_numberConditionChips);
    m_corCaloTemplate.resize(m_numberConditionChips);
    m_corEnergySumTemplate.resize(m_numberConditionChips);

    // set the name of the trigger menu name:
    //     defXmlFile, stripped of absolute path and .xml
    // will be overwritten by the value read from the xml file, with a warning if
    // they are not the same
    m_triggerMenuName = defXmlFile;
    size_t xmlPos = m_triggerMenuName.find_last_of("/");
    m_triggerMenuName.erase(m_triggerMenuName.begin(), m_triggerMenuName.begin()
            + xmlPos + 1);

    xmlPos = m_triggerMenuName.find_last_of(".");
    m_triggerMenuName.erase(m_triggerMenuName.begin() + xmlPos, m_triggerMenuName.end());

    // error handler for xml-parser
    m_xmlErrHandler = nullptr;

    XercesDOMParser* parser;

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

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

}

//

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

    m_triggerMenuInterfaceDate = val;

}

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

    m_triggerMenuInterfaceAuthor = val;

}

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

    m_triggerMenuInterfaceDescription = val;

}


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

    m_triggerMenuDate = val;

}

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

    m_triggerMenuAuthor = val;

}

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

    m_triggerMenuDescription = val;

}

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

    m_algorithmImplementation = val;

}

// private methods



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

    XERCES_CPP_NAMESPACE_USE

    // try to initialize
    try {
        cms::concurrency::xercesInitialize();
    }
    catch (const XMLException& toCatch) {
        char* message = XMLString::transcode(toCatch.getMessage());

        edm::LogError("L1GtTriggerMenuXmlParser")
        << "Error during Xerces-c initialization! :"
        << message << std::endl;

        XMLString::release(&message);
        return nullptr;
    }

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

    if (m_xmlErrHandler == nullptr) { // redundant check
        m_xmlErrHandler = (ErrorHandler*) new HandlerBase();
    }
    else {
        // TODO ASSERTION
    }
    parser->setErrorHandler(m_xmlErrHandler);

    // try to parse the file
    try {
        parser->parse(xmlFile.c_str());
    }
    catch(const XMLException &toCatch) {
        char* message = XMLString::transcode(toCatch.getMessage());

        edm::LogError("L1GtTriggerMenuXmlParser")
        << "Exception while parsing XML: \n"
        << message << std::endl;

        XMLString::release(&message);
        delete parser;
        delete m_xmlErrHandler;
        m_xmlErrHandler = nullptr;
        return nullptr;
    }
    catch (const DOMException &toCatch) {
        char *message = XMLString::transcode(toCatch.msg);

        edm::LogError("L1GtTriggerMenuXmlParser")
        << "DOM-Exception while parsing XML: \n"
        << message << std::endl;

        XMLString::release(&message);
        delete parser;
        delete m_xmlErrHandler;
        m_xmlErrHandler = nullptr;
        return nullptr;
    }
    catch (...) {

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

        delete parser;
        delete m_xmlErrHandler;
        m_xmlErrHandler = nullptr;
        return nullptr;
    }

    return parser;
}

// find a named child of a xml node
XERCES_CPP_NAMESPACE::DOMNode* L1GtTriggerMenuXmlParser::findXMLChild(
    XERCES_CPP_NAMESPACE::DOMNode* startChild, const std::string& tagName, bool beginOnly,
    std::string* rest) {

    XERCES_CPP_NAMESPACE_USE

    char* nodeName = nullptr;

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

    if ( !tagName.empty() ) {
        nodeName = XMLString::transcode(n1->getNodeName());

        if (!beginOnly) {
            //match the whole tag
            while (XMLString::compareIString(nodeName, tagName.c_str())) {

                XMLString::release(&nodeName);
                n1 = n1->getNextSibling();
                if (n1 == nullptr) {
                    break;
                }

                nodeName = XMLString::transcode(n1->getNodeName());
            }
        }
        else {
            // match only the beginning
            while (XMLString::compareNIString(nodeName, tagName.c_str(), tagName.length())) {
                XMLString::release(&nodeName);
                n1 = n1->getNextSibling();
                if (n1 == nullptr) {
                    break;
                }

                nodeName = XMLString::transcode(n1->getNodeName());
            }
            if (n1 != nullptr && rest != nullptr) {
                *rest = std::string(nodeName).substr(tagName.length(), strlen(nodeName) - tagName.length());
            }
        }
    }
    else { // empty string given
        while (n1->getNodeType() != DOMNode::ELEMENT_NODE) {
            n1 = n1->getNextSibling();
            if (n1 == nullptr) {
                break;
            }

        }
        if (n1 != nullptr && rest != nullptr) {
            nodeName = XMLString::transcode(n1->getNodeName());
            *rest = std::string(nodeName);
        }
    }

    XMLString::release(&nodeName);

    return n1;

}

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

    XERCES_CPP_NAMESPACE_USE

    std::string ret;

    // get attributes list
    DOMNamedNodeMap* attributes = node->getAttributes();
    if (attributes == nullptr) {
        return ret;
    }

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

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

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

    return ret;
}

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

    XERCES_CPP_NAMESPACE_USE

    std::string ret;

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

    const XMLCh* retXmlCh = n1->getTextContent();
    if (retXmlCh == nullptr) {
        return ret;
    }

    char* retCstr = XMLString::transcode(retXmlCh);
    XMLString::trim(retCstr); // trim spaces

    ret = retCstr;
    XMLString::release(&retCstr);

    return ret;
}

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

    // 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;
}

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

    if (node == nullptr) {

        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;
}

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

    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::countConditionChildMaxBits(XERCES_CPP_NAMESPACE::DOMNode* node,
    const std::string& childName, unsigned int& dst) {

    XERCES_CPP_NAMESPACE_USE

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

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

        return false;
    }

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

    if (n1 == nullptr) {

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

        return false;
    }

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

    if (n2 == nullptr) {

        LogDebug("L1GtTriggerMenuXmlParser") << "No value tag found for child " << childName
            << " in " << __PRETTY_FUNCTION__ << std::endl;

        return false;
    }

    // first try direct
    std::string maxString = getXMLAttribute(n1, m_xmlAttrMax); // string for the maxbits

    if (maxString.empty() ) {
        maxString = getXMLAttribute(n2, m_xmlAttrMax); // try next value tag
        // if no max was found neither in value nor in the childName tag
        if (maxString.empty() ) {

            LogDebug("L1GtTriggerMenuXmlParser") << "No Max value found for " << childName
                << std::endl;

            return false;
        }
    }

    // do the hex conversion

    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;

}

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

    XERCES_CPP_NAMESPACE_USE

    if (node == nullptr) {

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

        return false;
    }

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

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

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

        return false;
    }

    // no values are sucessfull
    if (num == 0) {
        return true;
    }

    //
    dst.reserve(num);

    //
    n1 = findXMLChild(n1->getFirstChild(), m_xmlTagValue);
    for (unsigned int i = 0; i < num; i++) {
        if (n1 == nullptr) {

            LogDebug("L1GtTriggerMenuXmlParser") << "Not enough values in condition child ( "
                << childName << ")" << std::endl;

            return false;
        }

        if ( !getXMLHexTextValue(n1, dst[i]) ) {

            edm::LogError("L1GtTriggerMenuXmlParser") << "Error converting condition child ( "
                << childName << ") value." << std::endl;

            return false;
        }

        n1 = findXMLChild(n1->getNextSibling(), m_xmlTagValue); // next child
    }

    return true;
}

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

    XERCES_CPP_NAMESPACE_USE

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

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

    cms::concurrency::xercesTerminate();

}


// methods for the VME file


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

    XERCES_CPP_NAMESPACE_USE

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

    if (n1 == nullptr) {

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

        return false;
    }

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

        edm::LogError("L1GtTriggerMenuXmlParser") << "Error: No vme tag found." << std::endl;
        return false;
    }

    n1 = n1->getFirstChild();

    unsigned int chipCounter = 0; // count chips

    while (chipCounter < m_numberConditionChips) {

        n1 = findXMLChild(n1, m_xmlTagChip, true);
        if (n1 == nullptr) {
            // just break if no more chips found
            break;
        }

        // node for a particle
        //DOMNode* particleNode = n1->getFirstChild(); // FIXME un-comment

        // FIXME parse vme.xml, modify the menu

        n1 = n1->getNextSibling();
        chipCounter++;
    } // end while chipCounter

    return true;

}

// methods for conditions and algorithms

// clearMaps - delete all conditions and algorithms in
// the maps and clear the maps.
void L1GtTriggerMenuXmlParser::clearMaps() {

    // 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();

}

// insertConditionIntoMap - safe insert of condition into condition map.
// if the condition name already exists, do not insert it and return false
bool L1GtTriggerMenuXmlParser::insertConditionIntoMap(L1GtCondition& cond, const int chipNr) {

    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;

}

// insert an algorithm into algorithm map
bool L1GtTriggerMenuXmlParser::insertAlgorithmIntoMap(const L1GtAlgorithm& alg) {

    std::string algName = alg.algoName();
    const std::string& algAlias = alg.algoAlias();
    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "    Trying to insert algorithm \"" << algName << "\" in the algorithm map." ;

    // no algorithm name has to appear twice!
    if (m_algorithmMap.count(algName) != 0) {
        LogTrace("L1GtTriggerMenuXmlParser") << "      Algorithm \"" << algName
            << "\"already exists in the algorithm map- not inserted!" << std::endl;
        return false;
    }

    if (m_algorithmAliasMap.count(algAlias) != 0) {
        LogTrace("L1GtTriggerMenuXmlParser") << "      Algorithm alias \"" << algAlias
            << "\"already exists in the algorithm alias map- not inserted!" << std::endl;
        return false;
    }

    // bit number less than zero or greater than maximum number of algorithms
    int bitNumber = alg.algoBitNumber();
    if ((bitNumber < 0) || (bitNumber >= static_cast<int>(m_numberPhysTriggers))) {
        LogTrace("L1GtTriggerMenuXmlParser") << "      Bit number " << bitNumber
            << " outside allowed range [0, " << m_numberPhysTriggers
            << ") - algorithm not inserted!" << std::endl;
        return false;
    }

    // maximum number of algorithms
    if (m_algorithmMap.size() >= m_numberPhysTriggers) {
        LogTrace("L1GtTriggerMenuXmlParser") << "      More than maximum allowed "
            << m_numberPhysTriggers << " algorithms in the algorithm map - not inserted!"
            << std::endl;
        return false;
    }

    // chip number outside allowed values
    int chipNr = alg.algoChipNumber(static_cast<int>(m_numberConditionChips),
        static_cast<int>(m_pinsOnConditionChip), m_orderConditionChip);

    if ((chipNr < 0) || (chipNr > static_cast<int>(m_numberConditionChips))) {
        LogTrace("L1GtTriggerMenuXmlParser") << "      Chip number " << chipNr
            << " outside allowed range [0, " << m_numberConditionChips
            << ") - algorithm not inserted!" << std::endl;
        return false;
    }

    // output pin outside allowed values
    int outputPin = alg.algoOutputPin(static_cast<int>(m_numberConditionChips),
        static_cast<int>(m_pinsOnConditionChip), m_orderConditionChip);

    if ((outputPin < 0) || (outputPin > static_cast<int>(m_pinsOnConditionChip))) {
        LogTrace("L1GtTriggerMenuXmlParser") << "      Output pin " << outputPin
            << " outside allowed range [0, " << m_pinsOnConditionChip
            << "] - algorithm not inserted!" << std::endl;
        return false;
    }

    // no two algorithms on the same chip can have the same output pin
    for (CItAlgo itAlgo = m_algorithmMap.begin(); itAlgo != m_algorithmMap.end(); itAlgo++) {

        int iPin = (itAlgo->second).algoOutputPin( static_cast<int>(m_numberConditionChips),
            static_cast<int>(m_pinsOnConditionChip), m_orderConditionChip);
        std::string iName = itAlgo->first;
        int iChip = (itAlgo->second).algoChipNumber(static_cast<int>(m_numberConditionChips),
            static_cast<int>(m_pinsOnConditionChip), m_orderConditionChip);

        if ( (outputPin == iPin) && (chipNr == iChip)) {
            LogTrace("L1GtTriggerMenuXmlParser") << "      Output pin " << outputPin
                << " is the same as for algorithm " << iName
                << "\n      from the same chip number " << chipNr << " - algorithm not inserted!"
                << std::endl;
            return false;
        }

    }

    // insert algorithm
    m_algorithmMap[algName] = alg;
    m_algorithmAliasMap[algAlias] = alg;

    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "      OK - algorithm inserted!"
    //<< std::endl;

    return true;

}

// insert a technical trigger into technical trigger map
bool L1GtTriggerMenuXmlParser::insertTechTriggerIntoMap(const L1GtAlgorithm& alg) {

    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;

}



// get the type of the condition, as defined in enum, from the condition type
// as defined in the XML file
L1GtConditionType L1GtTriggerMenuXmlParser::getTypeFromType(const std::string& type) {

    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;
}

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

    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;
}

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

    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;
    }
}

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

    XERCES_CPP_NAMESPACE_USE

    if (node == nullptr) {

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

        return -1;
    }

    // usually the GEq flag is a child of the first child (the first element node)
    DOMNode* n1 = node->getFirstChild();
    n1 = findXMLChild(n1, nodeName);

    if (n1 != nullptr) {
        n1 = findXMLChild(n1->getFirstChild(), m_xmlTagGEq);
        if (n1 == nullptr) {

            LogDebug("L1GtTriggerMenuXmlParser") << "No \"greater or equal\" tag found"
                << std::endl;

            return -1;
        }

        return getBitFromNode(n1);
    }
    else {

        return -1;

    }

}

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

    XERCES_CPP_NAMESPACE_USE

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

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

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

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

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

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

        // MIP bit

        DOMNode* bitnode = findXMLChild(n1->getFirstChild(), m_xmlTagEnableMip);
        if (bitnode == nullptr) {
            return true;
        }

        int tmpint = getBitFromNode(bitnode);
        if (tmpint < 0) {
            return false;
        }

        mipDst[i] = (tmpint != 0);

        //LogTrace("L1GtTriggerMenuXmlParser")
        //<< "      MIP bit value for muon " << i << " = " << mipDst[i]
        //<< std::endl;


        // enable iso bit
        bitnode = findXMLChild(n1->getFirstChild(), m_xmlTagEnableIso);
        if (bitnode == nullptr) {
            return true;
        }

        tmpint = getBitFromNode(bitnode);
        if (tmpint < 0) {
            return false;
        }

        isoEnDst[i] = (tmpint != 0);

        //LogTrace("L1GtTriggerMenuXmlParser")
        //<< "      Enabled iso bit value for muon " << i << " = " << isoEnDst[i]
        //<< std::endl;

        // request iso bit
        bitnode = findXMLChild(n1->getFirstChild(), m_xmlTagRequestIso);
        if (bitnode == nullptr) {
            return true;
        }

        tmpint = getBitFromNode(bitnode);
        if (tmpint < 0) {
            return false;
        }

        isoReqDst[i] = (tmpint != 0);

        //LogTrace("L1GtTriggerMenuXmlParser")
        //<< "      Request iso bit value for muon " << i << " = " << isoReqDst[i]
        //<< std::endl;

        //
        n1 = findXMLChild(n1->getNextSibling(), m_xmlTagValue); // next value
    }

    return true;
}

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

    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::parseCalo(XERCES_CPP_NAMESPACE::DOMNode* node,
        const std::string& name, unsigned int chipNr, const bool corrFlag) {

    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::parseEnergySum(
        XERCES_CPP_NAMESPACE::DOMNode* node, const std::string& name,
        unsigned int chipNr, const bool corrFlag) {

    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)) == nullptr) {
            edm::LogError("L1GtTriggerMenuXmlParser")
                << "    Could not get energyOverflow for EnergySum condition (" << name << ")"
                << std::endl;
            return false;
        }
        if ( (n1 = findXMLChild(n1->getFirstChild(), m_xmlTagEnergyOverflow)) == nullptr) {
            edm::LogError("L1GtTriggerMenuXmlParser")
                << "    Could not get energyOverflow for EnergySum condition (" << name << ")"
                << std::endl;
            return false;
        }

        int tmpInt = getBitFromNode(n1);
        if (tmpInt == 0) {
            objParameter[i].energyOverflow = false;

            //LogTrace("L1GtTriggerMenuXmlParser")
            //<< "      EnergySum energyOverflow logical flag (hex) = "
            //<< std::hex << objParameter[i].energyOverflow << std::dec
            //<< std::endl;
        }
        else if (tmpInt == 1) {
            objParameter[i].energyOverflow = true;

            //LogTrace("L1GtTriggerMenuXmlParser")
            //<< "      EnergySum energyOverflow logical flag (hex) = "
            //<< std::hex << objParameter[i].energyOverflow << std::dec
            //<< std::endl;
        }
        else {
            LogTrace("L1GtTriggerMenuXmlParser")
                << "      EnergySum energyOverflow logical flag (hex) = " << std::hex << tmpInt
                << std::dec << " - wrong value! " << std::endl;
            return false;
        }

    }

    // object types - all same energySumObjType
    std::vector<L1GtObject> objType(nrObj, energySumObjType);

    // now create a new energySum condition

    L1GtEnergySumTemplate energySumCond(name);

    energySumCond.setCondType(cType);
    energySumCond.setObjectType(objType);
    energySumCond.setCondGEq(gEq);
    energySumCond.setCondChipNr(chipNr);

    energySumCond.setConditionParameter(objParameter);

    if (edm::isDebugEnabled() ) {

        std::ostringstream myCoutStream;
        energySumCond.print(myCoutStream);
        LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;

    }

    // insert condition into the map
    if ( !insertConditionIntoMap(energySumCond, chipNr)) {

        edm::LogError("L1GtTriggerMenuXmlParser")
                << "    Error: duplicate condition (" << name << ")"
                << std::endl;

        return false;
    }
    else {

        if (corrFlag) {
            (m_corEnergySumTemplate[chipNr]).push_back(energySumCond);

        }
        else {
            (m_vecEnergySumTemplate[chipNr]).push_back(energySumCond);
        }

    }


    //
    return true;
}

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

    XERCES_CPP_NAMESPACE_USE

    // get condition, particle name and type name
    std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
    std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
    std::string type = getXMLAttribute(node, m_xmlConditionAttrType);

    if (particle != m_xmlConditionAttrObjectJetCounts) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "Wrong particle for JetCounts condition ("
            << particle << ")" << std::endl;
        return false;
    }

    // object type and condition type
    L1GtObject jetCountsObjType = JetCounts;
    L1GtConditionType cType = TypeJetCounts;

    // global object
    int nrObj = 1;

    // get greater equal flag

    int intGEq = getGEqFlag(node, m_xmlTagCountThreshold);
    if (intGEq < 0) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag"
            << std::endl;
        return false;
    }
    // set the boolean value for the ge_eq mode
    bool gEq = (intGEq != 0);

    // get values

    // temporary storage of the parameters
    std::vector<L1GtJetCountsTemplate::ObjectParameter> objParameter(nrObj);

    // get countIndex value and fill into structure
    // they are expressed in  base 10  (values: 0 - m_numberL1JetCounts)
    char* endPtr = nullptr;
    long int typeInt = strtol(type.c_str(), &endPtr, 10); // base = 10

    if (*endPtr != 0) {

        LogDebug("L1GtTriggerMenuXmlParser") << "Unable to convert " << type << " to dec."
            << std::endl;

        return false;
    }

    // test if count index is out of range
    if ((typeInt < 0) || (typeInt > static_cast<int>(m_numberL1JetCounts))) {
        LogDebug("L1GtTriggerMenuXmlParser") << "Count index " << typeInt
            << " outside range [0, " << m_numberL1JetCounts << "]" << std::endl;

        return false;
    }

    objParameter[0].countIndex = static_cast<unsigned int>(typeInt);

    // get count threshold values and fill into structure
    std::vector<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::parseCastor(XERCES_CPP_NAMESPACE::DOMNode* node,
    const std::string& name, unsigned int chipNr) {

    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::parseHfBitCounts(XERCES_CPP_NAMESPACE::DOMNode* node,
    const std::string& name, unsigned int chipNr) {

    XERCES_CPP_NAMESPACE_USE

    // get condition, particle name and type name
    std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
    std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
    std::string type = getXMLAttribute(node, m_xmlConditionAttrType);

    if (particle != m_xmlConditionAttrObjectHfBitCounts) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "Wrong particle for HfBitCounts condition ("
            << particle << ")" << std::endl;
        return false;
    }

    // object type and condition type
    L1GtObject hfBitCountsObjType = HfBitCounts;
    L1GtConditionType cType = TypeHfBitCounts;

    // global object
    int nrObj = 1;

    // get greater equal flag

    int intGEq = getGEqFlag(node, m_xmlTagCountThreshold);
    if (intGEq < 0) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag"
            << std::endl;
        return false;
    }
    // set the boolean value for the ge_eq mode
    bool gEq = (intGEq != 0);

    // get values

    // temporary storage of the parameters
    std::vector<L1GtHfBitCountsTemplate::ObjectParameter> objParameter(nrObj);

    // get countIndex value and fill into structure
    // they are expressed in  base 10
    char* endPtr = nullptr;
    long int typeInt = strtol(type.c_str(), &endPtr, 10); // base = 10

    if (*endPtr != 0) {

        LogDebug("L1GtTriggerMenuXmlParser") << "Unable to convert " << type << " to dec."
            << std::endl;

        return false;
    }

    // test if count index is out of range FIXME introduce m_numberL1HfBitCounts?
    //if ((typeInt < 0) || (typeInt > static_cast<int>(m_numberL1HfBitCounts))) {
    //    LogDebug("L1GtTriggerMenuXmlParser") << "Count index " << typeInt
    //        << " outside range [0, " << m_numberL1HfBitCounts << "]" << std::endl;
    //
    //    return false;
    //}

    objParameter[0].countIndex = static_cast<unsigned int>(typeInt);

    // get count threshold values and fill into structure
    std::vector<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) {

    XERCES_CPP_NAMESPACE_USE

    // get condition, particle name and type name
    std::string condition = getXMLAttribute(node, m_xmlConditionAttrCondition);
    std::string particle = getXMLAttribute(node, m_xmlConditionAttrObject);
    std::string type = getXMLAttribute(node, m_xmlConditionAttrType);

    if (particle != m_xmlConditionAttrObjectHfRingEtSums) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "Wrong particle for HfRingEtSums condition ("
            << particle << ")" << std::endl;
        return false;
    }

    // object type and condition type
    L1GtObject hfRingEtSumsObjType = HfRingEtSums;
    L1GtConditionType cType = TypeHfRingEtSums;

    // global object
    int nrObj = 1;

    // get greater equal flag

    int intGEq = getGEqFlag(node, m_xmlTagEtThreshold);
    if (intGEq < 0) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "Error getting \"greater or equal\" flag"
            << std::endl;
        return false;
    }
    // set the boolean value for the ge_eq mode
    bool gEq = (intGEq != 0);

    // get values

    // temporary storage of the parameters
    std::vector<L1GtHfRingEtSumsTemplate::ObjectParameter> objParameter(nrObj);

    // get etSumIndex value and fill into structure
    // they are expressed in  base 10
    char* endPtr = nullptr;
    long int typeInt = strtol(type.c_str(), &endPtr, 10); // base = 10

    if (*endPtr != 0) {

        LogDebug("L1GtTriggerMenuXmlParser") << "Unable to convert " << type << " to dec."
            << std::endl;

        return false;
    }

    // test if ET sum index is out of range FIXME introduce m_numberL1HfRingEtSums?
    //if ((typeInt < 0) || (typeInt > static_cast<int>(m_numberL1HfRingEtSums))) {
    //    LogDebug("L1GtTriggerMenuXmlParser") << "Count index " << typeInt
    //        << " outside range [0, " << m_numberL1HfRingEtSums << "]" << std::endl;
    //
    //    return false;
    //}

    objParameter[0].etSumIndex = static_cast<unsigned int>(typeInt);

    // get ET sum threshold values and fill into structure
    std::vector<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::parseBptx(XERCES_CPP_NAMESPACE::DOMNode* node,
    const std::string& name, unsigned int chipNr) {

    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::parseExternal(XERCES_CPP_NAMESPACE::DOMNode* node,
    const std::string& name, unsigned int chipNr) {

    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::parseCorrelation(
        XERCES_CPP_NAMESPACE::DOMNode* node, const std::string& name,
        unsigned int chipNr) {

    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 == nullptr) {
        edm::LogError("L1GtTriggerMenuXmlParser")
                << "    Could not get deltaEta for correlation condition "
                << name << ". " << std::endl;
        return false;
    }
    else {
        valString = getXMLTextValue(node1);
    }

    corrParameter.deltaEtaRange = valString;

//    // deltaPhi is larger than 64bit
//    if ( !getXMLHexTextValue128(findXMLChild(node->getFirstChild(), m_xmlTagDeltaPhi),
//        tmpValues[0], tmpValues[1])) {
//        edm::LogError("L1GtTriggerMenuXmlParser")
//            << "    Could not get deltaPhi for correlation condition " << name << ". "
//            << std::endl;
//        return false;
//    }
//
//    corrParameter.deltaPhiRange = tmpValues[0];

   node1 = findXMLChild(node->getFirstChild(), m_xmlTagDeltaPhi);

    if (node1 == nullptr) {
        return false;
        edm::LogError("L1GtTriggerMenuXmlParser")
                << "    Could not get deltaPhi for correlation condition "
                << name << ". " << std::endl;
    }
    else {
        valString = getXMLTextValue(node1);
    }

    corrParameter.deltaPhiRange = valString;

    // get maximum number of bits for delta phi
    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "      Counting deltaPhiMaxbits"
    //<< std::endl;

    unsigned int maxbits;

    if ( !countConditionChildMaxBits(node, m_xmlTagDeltaPhi, maxbits) ) {
        return false;
    }

    corrParameter.deltaPhiMaxbits = maxbits;
    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "        deltaPhiMaxbits (dec) = " << maxbits
    //<< std::endl;


    // fill the correlation condition
    correlationCond.setCondType(cType);
    correlationCond.setObjectType(objType);
    correlationCond.setCondGEq(gEq);
    correlationCond.setCondChipNr(chipNr);

    correlationCond.setCond0Category(condCateg[0]);
    correlationCond.setCond1Category(condCateg[1]);

    correlationCond.setCond0Index(corrIndexVal[0]);
    correlationCond.setCond1Index(corrIndexVal[1]);

    correlationCond.setCorrelationParameter(corrParameter);

    if (edm::isDebugEnabled() ) {

        std::ostringstream myCoutStream;
        correlationCond.print(myCoutStream);
        LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n"
                << std::endl;

    }

    // insert condition into the map
    // condition is not duplicate, check was done at the beginning

    (m_vecCorrelationTemplate[chipNr]).push_back(correlationCond);

    //
    return true;
}

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

    XERCES_CPP_NAMESPACE_USE

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

    // we assume that the first child is m_xmlTagDef because it was checked in workXML

    DOMNode* headerNode = n1->getFirstChild();
    if (headerNode == nullptr) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "Error: No child of <" << m_xmlTagDef
                << "> tag found." << std::endl;
        return false;
    }

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

        LogDebug("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <" << m_xmlTagHeader
                << "> tag" << "\n   - No header information." << std::endl;

    } else {

        DOMNode* idNode = headerNode->getFirstChild();

        // find menu interface name
        idNode = findXMLChild(idNode, m_xmlTagMenuInterface);
        if (idNode == nullptr) {

            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagMenuInterface << "> tag"
                    << "\n   - Trigger menu interface name derived from file name." << std::endl;

            // set the name of the trigger menu interface: from beginning of file names
            // until beginning of "_L1T_Scales"
            size_t xmlPos = m_triggerMenuName.find("_L1T_Scales", 0);
            if (xmlPos == std::string::npos) {
                LogTrace("L1GtTriggerMenuXmlParser")
                        << "\n  Warning: Could not find \"_L1T_Scales\" " << "string in file name"
                        << "\n   - Trigger menu interface name set to file name." << std::endl;
                m_triggerMenuInterface = m_triggerMenuName;

            } else {
                m_triggerMenuInterface = m_triggerMenuName;
                m_triggerMenuInterface.erase(
                        m_triggerMenuInterface.begin(), m_triggerMenuInterface.begin() + xmlPos);
            }

        } else {
            m_triggerMenuInterface = getXMLTextValue(idNode);
        }

        // find menu interface creation date
        idNode = headerNode->getFirstChild();
        idNode = findXMLChild(idNode, m_xmlTagMenuInterfaceDate);

        if (idNode == nullptr) {

            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagMenuInterfaceDate << "> tag" << "\n   - No creation date."
                    << m_triggerMenuInterfaceDate << std::endl;

        } else {

            m_triggerMenuInterfaceDate = getXMLTextValue(idNode);
        }

        // find menu interface creation author
        idNode = headerNode->getFirstChild();
        idNode = findXMLChild(idNode, m_xmlTagMenuInterfaceAuthor);

        if (idNode == nullptr) {

            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagMenuInterfaceAuthor << "> tag" << "\n   - No creation author."
                    << m_triggerMenuInterfaceAuthor << std::endl;

        } else {

            m_triggerMenuInterfaceAuthor = getXMLTextValue(idNode);
        }

        // find menu interface description
        idNode = headerNode->getFirstChild();
        idNode = findXMLChild(idNode, m_xmlTagMenuInterfaceDescription);

        if (idNode == nullptr) {

            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagMenuInterfaceDescription << "> tag" << "\n   - No description."
                    << m_triggerMenuInterfaceDescription << std::endl;

        } else {

            m_triggerMenuInterfaceDescription = getXMLTextValue(idNode);
        }

        // find menu creation date
        idNode = headerNode->getFirstChild();
        idNode = findXMLChild(idNode, m_xmlTagMenuDate);

        if (idNode == nullptr) {

            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagMenuDate << "> tag" << "\n   - No creation date."
                    << m_triggerMenuDate << std::endl;

        } else {

            m_triggerMenuDate = getXMLTextValue(idNode);
        }

        // find menu creation author
        idNode = headerNode->getFirstChild();
        idNode = findXMLChild(idNode, m_xmlTagMenuAuthor);

        if (idNode == nullptr) {

            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagMenuAuthor << "> tag" << "\n   - No creation author."
                    << m_triggerMenuAuthor << std::endl;

        } else {

            m_triggerMenuAuthor = getXMLTextValue(idNode);
        }

        // find menu description
        idNode = headerNode->getFirstChild();
        idNode = findXMLChild(idNode, m_xmlTagMenuDescription);

        if (idNode == nullptr) {

            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagMenuDescription << "> tag" << "\n   - No description."
                    << m_triggerMenuDescription << std::endl;

        } else {

            m_triggerMenuDescription = getXMLTextValue(idNode);
        }

        // find algorithm implementation tag

        idNode = headerNode->getFirstChild();

        idNode = findXMLChild(idNode, m_xmlTagMenuAlgImpl);
        if (idNode == nullptr) {

            m_algorithmImplementation = "";
            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagMenuAlgImpl << "> tag"
                    << "\n   - Algorithm implementation tag set to empty string." << std::endl;

        } else {

            m_algorithmImplementation = getXMLTextValue(idNode);
        }

        // find DB key for L1 scales

        idNode = headerNode->getFirstChild();

        idNode = findXMLChild(idNode, m_xmlTagScaleDbKey);
        if (idNode == nullptr) {

            m_scaleDbKey = "NULL";
            LogTrace("L1GtTriggerMenuXmlParser") << "\n  Warning: Could not find <"
                    << m_xmlTagScaleDbKey << "> tag" << "\n   - Scale key set to " << m_scaleDbKey
                    << " string." << std::endl;

        } else {
            m_scaleDbKey = getXMLTextValue(idNode);
        }

    }

    LogDebug("L1GtTriggerMenuXmlParser")
    << "\n  Parsed values from XML file"
    << "\nL1 MenuInterface:                   " << m_triggerMenuInterface
    << "\nL1 MenuInterface - Creation date:   " << m_triggerMenuInterfaceDate
    << "\nL1 MenuInterface - Creation author: " << m_triggerMenuInterfaceAuthor
    << "\nL1 MenuInterface - Description:     " << m_triggerMenuInterfaceDescription
    << "\n"
    << "\nAlgorithm implementation tag:       " << m_algorithmImplementation
    << "\n"
    << "\nL1 Menu - Creation date:            " << m_triggerMenuDate
    << "\nL1 Menu - Creation author:          " << m_triggerMenuAuthor
    << "\nL1 Menu - Description:              " << m_triggerMenuDescription
    << std::endl;


    // set the trigger menu name
    // format:
    // L1MenuInterface/ScaleDbKey/AlgorithmImplementationTag

    std::string menuName = m_triggerMenuInterface + "/" + m_scaleDbKey + "/" + m_algorithmImplementation;

    if (menuName != m_triggerMenuName) {

        LogDebug("L1GtTriggerMenuXmlParser") << "\n  Warning: Inconsistent L1 menu name:"
                << "\n    from XML file name: " << m_triggerMenuName
                << "\n    from XML tag:       " << menuName << std::endl;

        if (m_triggerMenuInterface != "") {
            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::workCondition(XERCES_CPP_NAMESPACE::DOMNode* node,
    const std::string& name, unsigned int chipNr) {

    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::parseConditions(XERCES_CPP_NAMESPACE::XercesDOMParser* parser) {

    XERCES_CPP_NAMESPACE_USE

    LogTrace("L1GtTriggerMenuXmlParser") << "\nParsing conditions" << std::endl;

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

    // we assume that the first child is m_xmlTagDef because it was checked in workXML

    DOMNode* chipNode = n1->getFirstChild();
    if (chipNode == nullptr) {

        edm::LogError("L1GtTriggerMenuXmlParser") << "Error: No child of <" << m_xmlTagDef
            << "> tag found." << std::endl;

        return false;
    }

    // find chip

    std::string chipName; // name of the actual chip
    chipNode = findXMLChild(chipNode, m_xmlTagChip, true, &chipName);
    if (chipNode == nullptr) {

        edm::LogError("L1GtTriggerMenuXmlParser") << "  Error: Could not find <" << m_xmlTagChip
            << "> tag" << std::endl;

        return false;
    }

    unsigned int chipNr = 0;
    do {

        // find conditions
        DOMNode* conditionsNode = chipNode->getFirstChild();
        conditionsNode = findXMLChild(conditionsNode, m_xmlTagConditions);
        if (conditionsNode == nullptr) {

            edm::LogError("L1GtTriggerMenuXmlParser") << "Error: No <" << m_xmlTagConditions
                << "> child found in Chip " << chipName << std::endl;

            return false;
        }

        char* nodeName = XMLString::transcode(chipNode->getNodeName());
        //LogTrace("L1GtTriggerMenuXmlParser")
        //<< "\n  Found Chip: " << nodeName << " Name: " << chipName
        //<< std::endl;

        XMLString::release(&nodeName);

        // walk through conditions
        DOMNode* conditionNameNode = conditionsNode->getFirstChild();
        std::string conditionNameNodeName;
        conditionNameNode = findXMLChild(conditionNameNode, "", true, &conditionNameNodeName);
        while (conditionNameNode != nullptr) {

            LogTrace("L1GtTriggerMenuXmlParser")
            << "\n    Found a condition with name: " << conditionNameNodeName
            << std::endl;

            if ( !workCondition(conditionNameNode, conditionNameNodeName, chipNr) ) {
                return false;
            }
            conditionNameNode = findXMLChild(conditionNameNode->getNextSibling(), "", true,
                &conditionNameNodeName);

        }
        // next chip
        chipNode = findXMLChild(chipNode->getNextSibling(), m_xmlTagChip, true, &chipName);
        chipNr++;

    } while (chipNode != nullptr && chipNr < m_numberConditionChips);

    return true;
}

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

    XERCES_CPP_NAMESPACE_USE

    if (node == nullptr) {
        LogDebug("L1GtTriggerMenuXmlParser")
        << "    Node is 0 in " << __PRETTY_FUNCTION__
        << " can not parse the algorithm " << algName
        << std::endl;
        return false;
    }

    // get alias
    std::string algAlias = getXMLAttribute(node, m_xmlAlgorithmAttrAlias);

    if (algAlias == "") {
        algAlias = algName;
        LogDebug("L1GtTriggerMenuXmlParser")
                << "\n    No alias defined for algorithm. Alias set to algorithm name."
                << "\n    Algorithm name:  " << algName << "\n    Algorithm alias: " << algAlias
                << std::endl;
    } else {
        LogDebug("L1GtTriggerMenuXmlParser") << "\n    Alias defined for algorithm."
                << "\n    Algorithm name:  " << algName << "\n    Algorithm alias: " << algAlias
                << std::endl;
    }

    // get the logical expression from the node
    std::string logExpression = getXMLTextValue(node);

    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "      Logical expression: " << logExpression
    //<< std::endl;

    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "      Chip number:        " << chipNr
    //<< std::endl;

    // determine output pin
    DOMNode* pinNode = findXMLChild(node->getFirstChild(), m_xmlTagOutput);
    std::string pinString;
    int outputPin = 0;

    pinNode = node->getFirstChild();
    if ( (pinNode = findXMLChild(pinNode, m_xmlTagOutputPin) ) != nullptr) {
        pinString = getXMLAttribute(pinNode, m_xmlAttrNr);

        // convert pinString to integer
        std::istringstream opStream(pinString);

        if ((opStream >> outputPin).fail()) {
            LogDebug("L1GtTriggerMenuXmlParser")
                    << "    Unable to convert pin string " << pinString
                    << " to int for algorithm : " << algName
                    << std::endl;

            return false;
        }

    }

    if (pinNode == nullptr) {
        LogTrace("L1GtTriggerMenuXmlParser") << "    Warning: No pin number found for algorithm: "
            << algName << std::endl;

        return false;
    }

    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "      Output pin:         " << outputPin
    //<< std::endl;


    // compute the bit number from chip number, output pin and order of the chips
    // pin numbering start with 1, bit numbers with 0
    int bitNumber = outputPin + (m_orderConditionChip[chipNr] -1)*m_pinsOnConditionChip -1;

    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "      Bit number:         " << bitNumber
    //<< std::endl;

    // create a new algorithm and insert it into algorithm map
    L1GtAlgorithm alg(algName, logExpression, bitNumber);
    alg.setAlgoChipNumber(static_cast<int>(chipNr));
    alg.setAlgoAlias(algAlias);

    if (edm::isDebugEnabled() ) {

        std::ostringstream myCoutStream;
        alg.print(myCoutStream);
        LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;

    }

    // insert algorithm into the map
    if ( !insertAlgorithmIntoMap(alg)) {

        return false;
    }

    return true;

}

/*
 * parseAlgorithms Parse the algorithms
 * NOTE: the algorithms used here are equivalent to "prealgo" from XML file
 *       for the VERSION_FINAL
 *       The "VERSION_PROTOTYPE algo" will be phased out later in the XML file
 *       See L1GlobalTriggerConfig.h (in the attic)
 *
 * @param parser A reference to the XercesDOMParser to use.
 *
 * @return "true" if succeeded, "false" if an error occurred.
 *
 */

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

    XERCES_CPP_NAMESPACE_USE

    //LogTrace("L1GtTriggerMenuXmlParser") << "\nParsing algorithms" << std::endl;

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

    DOMNode* chipNode = node->getFirstChild();
    if (chipNode == nullptr) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "  Error: No child found for " << m_xmlTagDef
            << std::endl;
        return false;
    }

    // find first chip
    std::string chipName;
    chipNode = findXMLChild(chipNode, m_xmlTagChip, true, &chipName);
    if (chipNode == nullptr) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "  Error: Could not find <" << m_xmlTagChip
            << std::endl;
        return false;
    }

    unsigned int chipNr = 0;
    do {

        //LogTrace("L1GtTriggerMenuXmlParser") << std::endl;

        std::string nodeName = m_xmlTagChip + chipName;
        //LogTrace("L1GtTriggerMenuXmlParser")
        //<< "  Chip: " << nodeName << " Name: " << chipName
        //<< std::endl;

        // find algorithms
        DOMNode* algNode = chipNode->getFirstChild();
        algNode = findXMLChild(algNode, m_xmlTagAlgorithms);
        if (algNode == nullptr) {
            edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: No <" << m_xmlTagAlgorithms
                << "> child found in chip " << chipName << std::endl;
            return false;
        }

        // walk through algorithms
        DOMNode* algNameNode = algNode->getFirstChild();
        std::string algNameNodeName;
        algNameNode = findXMLChild(algNameNode, "", true, &algNameNodeName);

        while (algNameNode != nullptr) {
            //LogTrace("L1GtTriggerMenuXmlParser")
            //<< "    Found an algorithm with name: " << algNameNodeName
            //<< std::endl;

            if ( !workAlgorithm(algNameNode, algNameNodeName, chipNr)) {
                return false;
            }

            algNameNode = findXMLChild(algNameNode->getNextSibling(), "", true, &algNameNodeName);

        }

        // next chip
        chipNode = findXMLChild(chipNode->getNextSibling(), m_xmlTagChip, true, &chipName);
        chipNr++;

    } while (chipNode != nullptr && chipNr < m_numberConditionChips);

    return true;
}

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

    XERCES_CPP_NAMESPACE_USE

    if (node == nullptr) {
        LogDebug("L1GtTriggerMenuXmlParser")
        << "    Node is 0 in " << __PRETTY_FUNCTION__
        << " can not parse the technical trigger " << algName
        << std::endl;
        return false;
    }

    // get the logical expression from the node
    std::string logExpression = getXMLTextValue(node);

    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "      Logical expression: " << logExpression
    //<< std::endl;

    // determine bit number (use output pin tag)
    DOMNode* pinNode = findXMLChild(node->getFirstChild(), m_xmlTagOutput);
    std::string pinString;
    int outputPin = 0;

    pinNode = node->getFirstChild();
    if ( (pinNode = findXMLChild(pinNode, m_xmlTagOutputPin) ) != nullptr) {
        pinString = getXMLAttribute(pinNode, m_xmlAttrNr);

        // convert pinString to integer
        std::istringstream opStream(pinString);

        if ((opStream >> outputPin).fail()) {
            LogDebug("L1GtTriggerMenuXmlParser")
                    << "    Unable to convert pin string " << pinString
                    << " to int for technical trigger : " << algName
                    << std::endl;

            return false;
        }

    }

    if (pinNode == nullptr) {
        LogTrace("L1GtTriggerMenuXmlParser")
            << "    Warning: No pin number found for technical trigger: "
            << algName << std::endl;

        return false;
    }

    // set the bit number
    int bitNumber = outputPin;

    //LogTrace("L1GtTriggerMenuXmlParser")
    //<< "      Bit number:         " << bitNumber
    //<< std::endl;

    // create a new technical trigger and insert it into technical trigger map
    // alias set automatically to name
    L1GtAlgorithm alg(algName, logExpression, bitNumber);
    alg.setAlgoAlias(algName);

    if (edm::isDebugEnabled() ) {

        std::ostringstream myCoutStream;
        alg.print(myCoutStream);
        LogTrace("L1GtTriggerMenuXmlParser") << myCoutStream.str() << "\n" << std::endl;

    }

    // insert technical trigger into the map
    if ( !insertTechTriggerIntoMap(alg)) {

        return false;
    }

    return true;

}

/*
 * parseTechTriggers Parse the technical triggers
 *
 * @param parser A reference to the XercesDOMParser to use.
 *
 * @return "true" if succeeded, "false" if an error occurred.
 *
 */

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

    XERCES_CPP_NAMESPACE_USE

    //LogTrace("L1GtTriggerMenuXmlParser") << "\nParsing technical triggers" << std::endl;

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

    DOMNode* algNode = node->getFirstChild();
    if (algNode == nullptr) {
        edm::LogError("L1GtTriggerMenuXmlParser")
                << "  Error: No child found for " << m_xmlTagDef << std::endl;
        return false;
    }

    algNode = findXMLChild(algNode, m_xmlTagTechTriggers);
    if (algNode == nullptr) {
        edm::LogError("L1GtTriggerMenuXmlParser") << "    Error: No <"
                << m_xmlTagTechTriggers << "> child found."
                << std::endl;
        return false;
    }

    // walk through technical triggers
    DOMNode* algNameNode = algNode->getFirstChild();
    std::string algNameNodeName;
    algNameNode = findXMLChild(algNameNode, "", true, &algNameNodeName);

    while (algNameNode != nullptr) {
        //LogTrace("L1GtTriggerMenuXmlParser")
        //<< "    Found an technical trigger with name: " << algNameNodeName
        //<< std::endl;

        if ( !workTechTrigger(algNameNode, algNameNodeName)) {
            return false;
        }

        algNameNode = findXMLChild(algNameNode->getNextSibling(), "", true,
                &algNameNodeName);

    }

    return true;
}


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

    XERCES_CPP_NAMESPACE_USE

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

    if (n1 == nullptr) {

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

        return false;
    }

    char* nodeName = XMLString::transcode(n1->getNodeName());

    if (XMLString::compareIString(nodeName, m_xmlTagDef.c_str())) {

        edm::LogError("L1GtTriggerMenuXmlParser") << "Error: First XML child is not \" "
            << m_xmlTagDef << "\" " << std::endl;

        return false;
    }

    LogTrace("L1GtTriggerMenuXmlParser")
    << "\nFirst node name is: " << nodeName
    << std::endl;
    XMLString::release(&nodeName);

    // clear possible old maps
    clearMaps();

    if ( !parseId(parser) ) {
        clearMaps();
        return false;
    }


    if ( !parseConditions(parser) ) {
        clearMaps();
        return false;
    }

    if ( !parseAlgorithms(parser) ) {
        clearMaps();
        return false;
    }

    if ( !parseTechTriggers(parser) ) {
        clearMaps();
        return false;
    }

    return true;

}


// static class members