L1GtFdlWord.cc

Go to the documentation of this file.

// this class header
#include "DataFormats/L1GlobalTrigger/interface/L1GtFdlWord.h"

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

// user include files

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

// constructors

// empty constructor, all members set to zero;
L1GtFdlWord::L1GtFdlWord()
{

    m_boardId = 0;
    m_bxInEvent = 0;
    m_bxNr = 0;
    m_eventNr = 0;

    // technical triggers std::vector<bool>
    m_gtTechnicalTriggerWord.reserve(
        L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers);
    m_gtTechnicalTriggerWord.assign(
        L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers, false);

    // decision word  std::vector<bool>
    m_gtDecisionWord.reserve(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggers);
    m_gtDecisionWord.assign(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggers, false);

    // extended decision word  std::vector<bool>
    m_gtDecisionWordExtended.reserve(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggersExtended);
    m_gtDecisionWordExtended.assign(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggersExtended, false);

    m_physicsDeclared = 0;
    m_gtPrescaleFactorIndexTech = 0;
    m_gtPrescaleFactorIndexAlgo = 0;

    m_noAlgo = 0;

    m_finalOR = 0;


    m_orbitNr = 0;
    m_lumiSegmentNr = 0;
    m_localBxNr = 0;

}

// constructor from unpacked values;
L1GtFdlWord::L1GtFdlWord(cms_uint16_t boardIdValue, int bxInEventValue,
        cms_uint16_t bxNrValue, cms_uint32_t eventNrValue,
        const TechnicalTriggerWord& gtTechnicalTriggerWordValue,
        const DecisionWord& gtDecisionWordValue,
        const DecisionWordExtended& gtDecisionWordExtendedValue,
        cms_uint16_t gtPrescaleFactorIndexTechValue,
        cms_uint16_t gtPrescaleFactorIndexAlgoValue,
        cms_uint16_t noAlgoValue, cms_uint16_t finalORValue,
        cms_uint32_t orbitNrValue, cms_uint16_t lumiSegmentNrValue,
        cms_uint16_t localBxNrValue) :
    m_boardId(boardIdValue), m_bxInEvent(bxInEventValue), m_bxNr(bxNrValue),
            m_eventNr(eventNrValue),
            m_gtTechnicalTriggerWord(gtTechnicalTriggerWordValue),
            m_gtDecisionWord(gtDecisionWordValue),
            m_gtDecisionWordExtended(gtDecisionWordExtendedValue),
            m_gtPrescaleFactorIndexTech(gtPrescaleFactorIndexTechValue),
            m_gtPrescaleFactorIndexAlgo(gtPrescaleFactorIndexAlgoValue),
            m_noAlgo(noAlgoValue), m_finalOR(finalORValue),
            m_orbitNr(orbitNrValue), m_lumiSegmentNr(lumiSegmentNrValue),
            m_localBxNr(localBxNrValue)

{
    m_physicsDeclared = 0;

    // the rest done in initialization list
}

// destructor
L1GtFdlWord::~L1GtFdlWord()
{

    // empty now
}

// equal operator
bool L1GtFdlWord::operator==(const L1GtFdlWord& result) const
{

    if (m_boardId   != result.m_boardId) {
        return false;
    }

    if (m_bxInEvent != result.m_bxInEvent) {
        return false;
    }

    if (m_bxNr      != result.m_bxNr) {
        return false;
    }
    if (m_eventNr   != result.m_eventNr) {
        return false;
    }

    if (m_gtTechnicalTriggerWord != result.m_gtTechnicalTriggerWord) {
        return false;
    }

    if (m_gtDecisionWord         != result.m_gtDecisionWord) {
        return false;
    }

    if (m_gtDecisionWordExtended != result.m_gtDecisionWordExtended) {
        return false;
    }

    if (m_physicsDeclared != result.m_physicsDeclared) {
        return false;
    }

    if (m_gtPrescaleFactorIndexTech != result.m_gtPrescaleFactorIndexTech) {
        return false;
    }

    if (m_gtPrescaleFactorIndexAlgo != result.m_gtPrescaleFactorIndexAlgo) {
        return false;
    }

    if (m_noAlgo                != result.m_noAlgo) {
        return false;
    }

    if (m_finalOR               != result.m_finalOR) {
        return false;
    }

    if (m_orbitNr != result.m_orbitNr) {
        return false;
    }

    if (m_lumiSegmentNr != result.m_lumiSegmentNr) {
        return false;
    }

    if (m_localBxNr != result.m_localBxNr) {
        return false;
    }

    // all members identical
    return true;

}

// unequal operator
bool L1GtFdlWord::operator!=(const L1GtFdlWord& result) const
{

    return !( result == *this);

}


// methods

// set the BoardId value from a 64-bits word
void L1GtFdlWord::setBoardId(const cms_uint64_t& word64)
{
    m_boardId = (word64 & BoardIdMask) >> BoardIdShift;

}

// set the BoardId value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setBoardIdWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == BoardIdWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_boardId) << BoardIdShift);
    }

}


// set the BxInEvent value from a 64-bits word
void L1GtFdlWord::setBxInEvent(const cms_uint64_t& word64)
{
    int baseValue = 16; // using hexadecimal values;
    int hexBxInEvent = (word64 & BxInEventMask) >> BxInEventShift;
    m_bxInEvent = (hexBxInEvent + baseValue/2)%baseValue - baseValue/2;

}

// set the BxInEvent value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setBxInEventWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == BxInEventWord) {
        int baseValue = 16; // using hexadecimal values;
        int hexBxInEvent = (m_bxInEvent + baseValue)%baseValue;
        word64 = word64 | (static_cast<cms_uint64_t> (hexBxInEvent)
                           << BxInEventShift);
    }

}


// set the BxNr value from a 64-bits word
void L1GtFdlWord::setBxNr(const cms_uint64_t& word64)
{
    m_bxNr = (word64 & BxNrMask) >> BxNrShift;

}

// set the BxNr value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setBxNrWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == BxNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_bxNr) << BxNrShift);
    }

}


// set the EventNr value from a 64-bits word
void L1GtFdlWord::setEventNr(const cms_uint64_t& word64)
{
    m_eventNr = (word64 & EventNrMask) >> EventNrShift;

}

// set the EventNr value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setEventNrWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == EventNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_eventNr) << EventNrShift);
    }

}


// print GT technical trigger word in bitset style
//    depend on the type of TechnicalTriggerWord
//    this version: <vector<bool>
void L1GtFdlWord::printGtTechnicalTriggerWord(std::ostream& myCout) const
{

    myCout << "  Technical triggers (bitset style):    \n  " ;

    int sizeW64 = 64; // 64 bits words
    int iBit = 0;

    for (std::vector<bool>::const_reverse_iterator ritBit = m_gtTechnicalTriggerWord.rbegin();
            ritBit != m_gtTechnicalTriggerWord.rend(); ++ritBit) {

        myCout << (*ritBit ? '1' : '0');

        if ( (((iBit + 1)%16) == (sizeW64%16)) && (iBit != 63) ) {
            myCout << " ";
        }

        iBit++;
    }


}

// set the GtTechnicalTriggerWord value from a 64-bits word
void L1GtFdlWord::setGtTechnicalTriggerWord(const cms_uint64_t& word64)
{

    int word64Size = sizeof(word64)*8;
    cms_uint64_t wordTT = (word64 & GtTechnicalTriggerWordMask)
                             >> GtTechnicalTriggerWordShift;

    cms_uint64_t one64 = 1ULL;
    for (int iBit = 0; iBit < word64Size; ++iBit) {
        m_gtTechnicalTriggerWord.at(iBit) = wordTT & (one64 << iBit);
    }

}

// set the GtTechnicalTriggerWord value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setGtTechnicalTriggerWordWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == GtTechnicalTriggerWordWord) {

        int word64Size = sizeof(word64)*8;
        cms_uint64_t wordTT = 0x0000000000000000ULL;

        int iBit = 0;
        cms_uint64_t iDecision = 0ULL;

        for (std::vector<bool>::const_iterator itBit = m_gtTechnicalTriggerWord.begin();
                itBit != m_gtTechnicalTriggerWord.end(); ++itBit) {

            iDecision = static_cast<cms_uint64_t> (*itBit);//(*itBit ? 1 : 0);
            wordTT = wordTT | (iDecision << iBit);

            iBit++;
            if (iBit >= word64Size) {
                break;
            }

        }

        word64 = word64 | (wordTT << GtTechnicalTriggerWordShift);

    }

}


// print GT decision word in bitset style
//    depend on the type of DecisionWord
//    this version: <vector<bool>
void L1GtFdlWord::printGtDecisionWord(std::ostream& myCout) const
{

    // decision word (in 64bits words)
    int sizeW64 = 64; // 64 bits words

    int iBit = 0;
    int jBit = m_gtDecisionWord.size();
    int nrDecWord = m_gtDecisionWord.size()/sizeW64;

    std::ostringstream stream64;

    std::vector<std::string> decWord;
    decWord.reserve(nrDecWord);

    for (std::vector<bool>::const_reverse_iterator ritBit = m_gtDecisionWord.rbegin();
            ritBit != m_gtDecisionWord.rend(); ++ritBit) {

        stream64 << (*ritBit ? '1' : '0');

        if ( (((iBit + 1)%16) == (sizeW64%16)) ) {
            stream64  << " ";
        }

        if ( ((iBit + 1)%sizeW64) == 0) {
            std::string iW = stream64.str();
            stream64.str("");

            decWord.push_back(iW);
        }


        iBit++;
        jBit--;
    }

    int iWord = 0;

    for (std::vector<std::string>::reverse_iterator ritWord = decWord.rbegin();
            ritWord != decWord.rend(); ++ritWord) {

        myCout << std::endl;
        myCout << "  DecisionWord (bitset style): bits "
        << iWord*sizeW64 + sizeW64 - 1 << " : " << iWord*sizeW64 << "\n  ";
        myCout << *ritWord;

        iWord++;

    }
}

// set the GtDecisionWord value from a 64-bits word
// WordA: bits 0 - 63
void L1GtFdlWord::setGtDecisionWordA(const cms_uint64_t& word64)
{

    int word64Size = sizeof(word64)*8; // well, it should be 64, if not...  :-)
    cms_uint64_t wordA = (word64 & GtDecisionWordAMask) >> GtDecisionWordAShift;

    cms_uint64_t one64 = 1ULL;

    for (int iBit = 0; iBit < word64Size; ++iBit) {
        m_gtDecisionWord.at(iBit) = wordA & (one64 << iBit);
    }

}

// set the GtDecisionWord value from a 64-bits word
// WordB: bits 64 - 127
void L1GtFdlWord::setGtDecisionWordB(const cms_uint64_t& word64)
{

    int word64Size = sizeof(word64)*8;
    cms_uint64_t wordB = (word64 & GtDecisionWordBMask) >> GtDecisionWordBShift;

    cms_uint64_t one64 = 1ULL;

    for (int iBit = 0; iBit < word64Size; ++iBit) {
        m_gtDecisionWord.at(iBit + word64Size) = wordB & (one64 << iBit);

    }

}


// set the GtDecisionWord value in a 64-bits word, having the index iWord
// in the GTFE raw record
// WordA: bits 0 - 63

// a bit forced: assumes wordSize64 = 64, but also take word shift
void L1GtFdlWord::setGtDecisionWordAWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == GtDecisionWordAWord) {

        int word64Size = sizeof(word64)*8;
        cms_uint64_t wordA = 0x0000000000000000ULL;

        int iBit = 0;
        cms_uint64_t iDecision = 0ULL;

        for (std::vector<bool>::const_iterator itBit = m_gtDecisionWord.begin();
                itBit != m_gtDecisionWord.end(); ++itBit) {

            iDecision = static_cast<cms_uint64_t> (*itBit);//(*itBit ? 1 : 0);
            wordA = wordA | (iDecision << iBit);

            iBit++;
            if (iBit >= word64Size) {
                break;
            }

        }

        word64 = word64 | (wordA << GtDecisionWordAShift);

    }

}


// set the GtDecisionWord value in a 64-bits word, having the index iWord
// in the GTFE raw record
// WordB: bits 64 - 127

// a bit forced: assumes wordSize64 = 64, but also take word shift
void L1GtFdlWord::setGtDecisionWordBWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == GtDecisionWordBWord) {

        int word64Size = sizeof(word64)*8;
        cms_uint64_t wordB = 0x0000000000000000ULL;

        int iBit = 0;
        cms_uint64_t iDecision = 0ULL;

        for (std::vector<bool>::const_iterator itBit = m_gtDecisionWord.begin();
                itBit != m_gtDecisionWord.end(); ++itBit) {

            if (iBit >= word64Size) {
                // skip first word64Size bits, they go in wordA
                iDecision = static_cast<cms_uint64_t> (*itBit);//(*itBit ? 1 : 0);
                wordB = wordB | ( iDecision << (iBit - word64Size) );
            }

            iBit++;

        }

        word64 = word64 | (wordB << GtDecisionWordBShift);
    }

}

// print GT decision word extended in bitset style
//    depend on the type of DecisionWord
//    this version: <vector<bool>
void L1GtFdlWord::printGtDecisionWordExtended(std::ostream& myCout) const
{

    myCout << "  DecisionWordExtended (bitset style):    \n  " ;

    int sizeW64 = 64; // 64 bits words
    int iBit = 0;

    for (std::vector<bool>::const_reverse_iterator ritBit = m_gtDecisionWordExtended.rbegin();
            ritBit != m_gtDecisionWordExtended.rend(); ++ritBit) {

        myCout << (*ritBit ? '1' : '0');

        if ( (((iBit + 1)%16) == (sizeW64%16)) && (iBit != 63) ) {
            myCout << " ";
        }

        iBit++;

    }

}

// set the GtDecisionWordExtended value from a 64-bits word
void L1GtFdlWord::setGtDecisionWordExtended(const cms_uint64_t& word64)
{

    int word64Size = sizeof(word64)*8;
    cms_uint64_t wordE = (word64 & GtDecisionWordExtendedMask)
                            >> GtDecisionWordExtendedShift;

    cms_uint64_t one64 = 1ULL;

    for (int iBit = 0; iBit < word64Size; ++iBit) {
        m_gtDecisionWordExtended.at(iBit) = wordE & (one64 << iBit);
    }


}

// set the GtDecisionWordExtended value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setGtDecisionWordExtendedWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == GtDecisionWordExtendedWord) {

        int word64Size = sizeof(word64)*8;
        cms_uint64_t wordE = 0x0000000000000000ULL;

        int iBit = 0;
        cms_uint64_t iDecision = 0ULL;

        for (std::vector<bool>::const_iterator itBit = m_gtDecisionWordExtended.begin();
                itBit != m_gtDecisionWordExtended.end(); ++itBit) {

            iDecision = static_cast<cms_uint64_t> (*itBit);//(*itBit ? 1 : 0);
            wordE = wordE | (iDecision << iBit);

            iBit++;
            if (iBit >= word64Size) {
                break;
            }

        }

        word64 = word64 | (wordE << GtDecisionWordExtendedShift);

    }

}


// set the "physics declared" bit value from a 64-bits word
void L1GtFdlWord::setPhysicsDeclared(const cms_uint64_t& word64)
{
    m_physicsDeclared = (word64 & PhysicsDeclaredMask) >> PhysicsDeclaredShift;
}

// set the "physics declared" bit value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setPhysicsDeclaredWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == PhysicsDeclaredWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_physicsDeclared)
                           << PhysicsDeclaredShift);
    }

}


// set the GtPrescaleFactorIndexTech from a 64-bits word
void L1GtFdlWord::setGtPrescaleFactorIndexTech(const cms_uint64_t& word64) {
    m_gtPrescaleFactorIndexTech = (word64 & GtPrescaleFactorIndexTechMask)
            >> GtPrescaleFactorIndexTechShift;
}

// set the GtPrescaleFactorIndexTech bits in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setGtPrescaleFactorIndexTechWord64(cms_uint64_t& word64,
        const int iWord) {

    if (iWord == GtPrescaleFactorIndexTechWord) {
        word64 = word64
                | (static_cast<cms_uint64_t> (m_gtPrescaleFactorIndexTech)
                        << GtPrescaleFactorIndexTechShift);
    }

}


// set the GtPrescaleFactorIndexAlgo from a 64-bits word
void L1GtFdlWord::setGtPrescaleFactorIndexAlgo(const cms_uint64_t& word64) {
    m_gtPrescaleFactorIndexAlgo = (word64 & GtPrescaleFactorIndexAlgoMask)
            >> GtPrescaleFactorIndexAlgoShift;
}

// set the GtPrescaleFactorIndexAlgo bits in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setGtPrescaleFactorIndexAlgoWord64(cms_uint64_t& word64,
        const int iWord) {

    if (iWord == GtPrescaleFactorIndexAlgoWord) {
        word64 = word64
                | (static_cast<cms_uint64_t> (m_gtPrescaleFactorIndexAlgo)
                        << GtPrescaleFactorIndexAlgoShift);
    }

}

// set the NoAlgo value from a 64-bits word
void L1GtFdlWord::setNoAlgo(const cms_uint64_t& word64)
{
    m_noAlgo = (word64 & NoAlgoMask) >> NoAlgoShift;
}

// set the NoAlgo value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setNoAlgoWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == NoAlgoWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_noAlgo)
                           << NoAlgoShift);
    }

}




// set the FinalOR value from a 64-bits word
void L1GtFdlWord::setFinalOR(const cms_uint64_t& word64)
{
    m_finalOR = (word64 & FinalORMask) >> FinalORShift;

}

// set the FinalOR value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setFinalORWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == FinalORWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_finalOR)
                           << FinalORShift);
    }

}


// set the orbit number bits from a 64-bits word
void L1GtFdlWord::setOrbitNr(const cms_uint64_t& word64) {
    m_orbitNr = (word64 & OrbitNrMask) >> OrbitNrShift;
}

// set the orbit number bits in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setOrbitNrWord64(cms_uint64_t& word64, const int iWord) {

    if (iWord == OrbitNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_orbitNr)
                << OrbitNrShift);
    }

}



// set the luminosity segment number bits from a 64-bits word
void L1GtFdlWord::setLumiSegmentNr(const cms_uint64_t& word64) {
    m_lumiSegmentNr = (word64 & LumiSegmentNrMask) >> LumiSegmentNrShift;
}

// set the luminosity segment number bits in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setLumiSegmentNrWord64(cms_uint64_t& word64,
        const int iWord) {

    if (iWord == LumiSegmentNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_lumiSegmentNr)
                << LumiSegmentNrShift);
    }

}


// set the LocalBxNr value from a 64-bits word
void L1GtFdlWord::setLocalBxNr(const cms_uint64_t& word64)
{
    m_localBxNr = (word64 & LocalBxNrMask) >> LocalBxNrShift;
}

// set the LocalBxNr value in a 64-bits word, having the index iWord
// in the GTFE raw record
void L1GtFdlWord::setLocalBxNrWord64(cms_uint64_t& word64, const int iWord)
{

    if (iWord == LocalBxNrWord) {
        word64 = word64 | (static_cast<cms_uint64_t> (m_localBxNr)
                           << LocalBxNrShift);
    }

}



// reset the content of a L1GtFdlWord
void L1GtFdlWord::reset()
{

    m_boardId = 0;
    m_bxInEvent = 0;
    m_bxNr = 0;
    m_eventNr = 0;

    // technical triggers std::vector<bool>
    m_gtTechnicalTriggerWord.assign(
        L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers, false);

    // decision word  std::vector<bool>
    m_gtDecisionWord.assign(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggers, false);

    // extended decision word  std::vector<bool>
    m_gtDecisionWordExtended.assign(
        L1GlobalTriggerReadoutSetup::NumberPhysTriggersExtended, false);

    m_physicsDeclared = 0;
    m_gtPrescaleFactorIndexTech = 0;
    m_gtPrescaleFactorIndexAlgo = 0;

    m_noAlgo = 0;
    m_finalOR = 0;

    m_orbitNr = 0;
    m_lumiSegmentNr = 0;
    m_localBxNr = 0;

}

// pretty print the content of a L1GtFdlWord
void L1GtFdlWord::print(std::ostream& myCout) const
{

    myCout << "\n L1GtFdlWord::print \n" << std::endl;

    int iWord = 0;

    myCout << "\n Word " << iWord << std::endl;

    myCout << "  Board Id:         "
    << std::hex << " hex: " << "    " << std::setw(4) << std::setfill('0') << m_boardId
    << std::setfill(' ')
    << std::dec << " dec: " << m_boardId
    << std::endl;
    //

    int baseValue = 16; // using hexadecimal values;
    int hexBxInEvent = (m_bxInEvent + baseValue)%baseValue;

    myCout << "  BxInEvent:        "
    << std::hex << " hex: " << "       " << std::setw(1) << hexBxInEvent
    << std::dec << " dec: " << m_bxInEvent
    << std::endl;

    myCout << "  BxNr:             "
    << std::hex << " hex: "  << "     " << std::setw(3) << std::setfill('0') << m_bxNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_bxNr
    << std::endl;


    myCout << "  EventNr:          "
    << std::hex << " hex: " << "  " << std::setw(6) << std::setfill('0') << m_eventNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_eventNr
    << std::endl;

    // technical triggers

    iWord++;
    myCout << "\n Word " << iWord << std::endl;

    printGtTechnicalTriggerWord(myCout);
    myCout << std::endl;

    // physics triggers (2 words!)

    iWord++;
    myCout << "\n Word " << iWord;
    iWord++;
    myCout << " and word " << iWord;

    printGtDecisionWord(myCout);
    myCout << std::endl;

    // decision word extended (64 bits)

    iWord++;
    myCout << "\n Word " << iWord << std::endl;

    printGtDecisionWordExtended(myCout);
    myCout << std::endl;

    //
    iWord++;
    myCout << "\n Word " << iWord << std::endl;

    myCout << "  PhysicsDeclared:           "
    << std::hex << " hex: "  << "    " << std::setw(4) << std::setfill('0')
    << m_physicsDeclared
    << std::setfill(' ')
    << std::dec << " dec: " << m_physicsDeclared
    << std::endl;

    myCout << "  GtPrescaleFactorIndexTech: "
    << std::hex << " hex: "  << "    " << std::setw(4) << std::setfill('0')
    << m_gtPrescaleFactorIndexTech
    << std::setfill(' ')
    << std::dec << " dec: " << m_gtPrescaleFactorIndexTech
    << std::endl;

    myCout << "  GtPrescaleFactorIndexAlgo: "
    << std::hex << " hex: "  << "    " << std::setw(4) << std::setfill('0')
    << m_gtPrescaleFactorIndexAlgo
    << std::setfill(' ')
    << std::dec << " dec: " << m_gtPrescaleFactorIndexAlgo
    << std::endl;

    myCout << "  NoAlgo:                    "
    << std::hex << " hex: "  << "       " << std::setw(1) << std::setfill('0') << m_noAlgo
    << std::setfill(' ')
    << std::dec << " dec: " << m_noAlgo
    << std::endl;

    myCout << "  FinalOR:                   "
    << std::hex << " hex: "  << "      " << std::setw(2) << std::setfill('0') << m_finalOR
    << std::setfill(' ')
    << std::dec << " dec: " << m_finalOR
    << std::endl;

    iWord++;
    myCout << "\n Word " << iWord << std::endl;

    myCout << "  OrbitNr:          "
    << std::hex << " hex: "  << "" << std::setw(8) << std::setfill('0') << m_orbitNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_orbitNr
    << std::endl;

    myCout << "  LumiSegmentNr:    "
    << std::hex << " hex: "  << "    " << std::setw(4) << std::setfill('0') << m_lumiSegmentNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_lumiSegmentNr
    << std::endl;

    myCout << "  LocalBxNr:        "
    << std::hex << " hex: "  << "     " << std::setw(3) << std::setfill('0') << m_localBxNr
    << std::setfill(' ')
    << std::dec << " dec: " << m_localBxNr
    << std::endl;

}

// unpack FDL
// fdlPtr pointer to the beginning of the FDL block in the raw data
void L1GtFdlWord::unpack(const unsigned char* fdlPtr)
{
    LogDebug("L1GtFdlWord")
    << "\nUnpacking FDL block.\n"
    << std::endl;

    const cms_uint64_t* payload =
        reinterpret_cast<cms_uint64_t*>(const_cast<unsigned char*>(fdlPtr));

    setBoardId(payload[BoardIdWord]);
    setBxInEvent(payload[BxInEventWord]);
    setBxNr(payload[BxNrWord]);
    setEventNr(payload[EventNrWord]);

    setGtTechnicalTriggerWord(payload[GtTechnicalTriggerWordWord]);

    setGtDecisionWordA(payload[GtDecisionWordAWord]);

    setGtDecisionWordB(payload[GtDecisionWordBWord]);

    setGtDecisionWordExtended(payload[GtDecisionWordExtendedWord]);

    setPhysicsDeclared(payload[PhysicsDeclaredWord]);
    setGtPrescaleFactorIndexTech(payload[GtPrescaleFactorIndexTechWord]);
    setGtPrescaleFactorIndexAlgo(payload[GtPrescaleFactorIndexAlgoWord]);
    setNoAlgo(payload[NoAlgoWord]);
    setFinalOR(payload[FinalORWord]);

    setOrbitNr(payload[OrbitNrWord]);
    setLumiSegmentNr(payload[LumiSegmentNrWord]);
    setLocalBxNr(payload[LocalBxNrWord]);

    if ( edm::isDebugEnabled() ) {

        for (int iWord = 0; iWord < BlockSize; ++iWord) {
            LogTrace("L1GtFdlWord")
            << std::setw(4) << iWord << "  "
            << std::hex << std::setfill('0')
            << std::setw(16) << payload[iWord]
            << std::dec << std::setfill(' ')
            << std::endl;
        }

    }

}


// static class members

// block description in the raw GT record

// block size in 64bits words (BlockSize * 64 bits)
const int L1GtFdlWord::BlockSize = 7;

// word 0

// index of the word in the FDL block containig the variable
const int L1GtFdlWord::BoardIdWord = 0;
const int L1GtFdlWord::BxInEventWord = 0;
const int L1GtFdlWord::BxNrWord = 0;
const int L1GtFdlWord::EventNrWord = 0;

// mask to get the 64-bit-value from the corresponding word in the FDL block
const cms_uint64_t L1GtFdlWord::BoardIdMask =   0xFFFF000000000000ULL;
const cms_uint64_t L1GtFdlWord::BxInEventMask = 0x0000F00000000000ULL;
const cms_uint64_t L1GtFdlWord::BxNrMask =      0x00000FFF00000000ULL;
const cms_uint64_t L1GtFdlWord::EventNrMask =   0x0000000000FFFFFFULL;

// shift to the right to get the value from the "64-bit-value"
const int L1GtFdlWord::BoardIdShift = 48;
const int L1GtFdlWord::BxInEventShift = 44;
const int L1GtFdlWord::BxNrShift = 32;
const int L1GtFdlWord::EventNrShift = 0;

// word 1

const int L1GtFdlWord::GtTechnicalTriggerWordWord = 1;
const cms_uint64_t L1GtFdlWord::GtTechnicalTriggerWordMask = 0xFFFFFFFFFFFFFFFFULL;
const int L1GtFdlWord::GtTechnicalTriggerWordShift = 0;

// word 2 - WordA: bits 0-63

const int L1GtFdlWord::GtDecisionWordAWord = 2;
const cms_uint64_t L1GtFdlWord::GtDecisionWordAMask = 0xFFFFFFFFFFFFFFFFULL;
const int L1GtFdlWord::GtDecisionWordAShift = 0;

// word 3 - WordB: bits 64-128

const int L1GtFdlWord::GtDecisionWordBWord = 3;
const cms_uint64_t L1GtFdlWord::GtDecisionWordBMask = 0xFFFFFFFFFFFFFFFFULL;
const int L1GtFdlWord::GtDecisionWordBShift = 0;


// word 4
const int L1GtFdlWord::GtDecisionWordExtendedWord = 4;
const cms_uint64_t L1GtFdlWord::GtDecisionWordExtendedMask = 0xFFFFFFFFFFFFFFFFULL;
const int L1GtFdlWord::GtDecisionWordExtendedShift = 0;

// word 5
const int L1GtFdlWord::PhysicsDeclaredWord = 5;
const int L1GtFdlWord::GtPrescaleFactorIndexTechWord = 5;
const int L1GtFdlWord::GtPrescaleFactorIndexAlgoWord = 5;
const int L1GtFdlWord::NoAlgoWord = 5;
const int L1GtFdlWord::FinalORWord = 5;

const cms_uint64_t L1GtFdlWord::PhysicsDeclaredMask =           0x8000000000000000ULL;
const cms_uint64_t L1GtFdlWord::GtPrescaleFactorIndexTechMask = 0x00FF000000000000ULL;
const cms_uint64_t L1GtFdlWord::GtPrescaleFactorIndexAlgoMask = 0x000000FF00000000ULL;
const cms_uint64_t L1GtFdlWord::NoAlgoMask =  0x0000000000000100ULL;
const cms_uint64_t L1GtFdlWord::FinalORMask = 0x00000000000000FFULL;

const int L1GtFdlWord::PhysicsDeclaredShift = 63;
const int L1GtFdlWord::GtPrescaleFactorIndexTechShift = 48;
const int L1GtFdlWord::GtPrescaleFactorIndexAlgoShift = 32;
const int L1GtFdlWord::NoAlgoShift = 8;
const int L1GtFdlWord::FinalORShift = 0;

// word 6
const int L1GtFdlWord::OrbitNrWord = 6;
const int L1GtFdlWord::LumiSegmentNrWord = 6;
const int L1GtFdlWord::LocalBxNrWord = 6;

const cms_uint64_t L1GtFdlWord::OrbitNrMask =        0xFFFFFFFF00000000ULL;
const cms_uint64_t L1GtFdlWord::LumiSegmentNrMask =  0x00000000FFFF0000ULL;
const cms_uint64_t L1GtFdlWord::LocalBxNrMask =      0x0000000000000FFFULL;

const int L1GtFdlWord::OrbitNrShift = 32;
const int L1GtFdlWord::LumiSegmentNrShift = 16;
const int L1GtFdlWord::LocalBxNrShift = 0;