/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_7/src/CondFormats/L1TObjects/src/L1GtBoard.cc

Go to the documentation of this file.

// this class header
#include "CondFormats/L1TObjects/interface/L1GtBoard.h"

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



// user include files
//   base class

// forward declarations

// constructors
L1GtBoard::L1GtBoard()
{

    // empty

}

L1GtBoard::L1GtBoard(const L1GtBoardType& gtBoardTypeValue) :
    m_gtBoardType(gtBoardTypeValue)
{

    m_gtBoardIndex = -1;

    m_gtPositionDaqRecord = -1;
    m_gtPositionEvmRecord = -1;

    m_gtBitDaqActiveBoards = -1;
    m_gtBitEvmActiveBoards = -1;

    m_gtBoardSlot = -1;
    m_gtBoardHexName = 0;

    m_gtQuadInPsb.reserve(NumberCablesBoard);

}

L1GtBoard::L1GtBoard(const L1GtBoardType& gtBoardTypeValue,
        const int& gtBoardIndexValue) :
    m_gtBoardType(gtBoardTypeValue), m_gtBoardIndex(gtBoardIndexValue)
{

    m_gtPositionDaqRecord = -1;
    m_gtPositionEvmRecord = -1;

    m_gtBitDaqActiveBoards = -1;
    m_gtBitEvmActiveBoards = -1;

    m_gtBoardSlot = -1;
    m_gtBoardHexName = 0;

    m_gtQuadInPsb.reserve(NumberCablesBoard);

}

// destructor
L1GtBoard::~L1GtBoard()
{
    // empty
}

// copy constructor
L1GtBoard::L1GtBoard(const L1GtBoard& gtb)
{

    m_gtBoardType = gtb.m_gtBoardType;
    m_gtBoardIndex = gtb.m_gtBoardIndex;

    m_gtPositionDaqRecord = gtb.m_gtPositionDaqRecord;
    m_gtPositionEvmRecord = gtb.m_gtPositionEvmRecord;

    m_gtBitDaqActiveBoards = gtb.m_gtBitDaqActiveBoards;
    m_gtBitEvmActiveBoards = gtb.m_gtBitEvmActiveBoards;

    m_gtBoardSlot = gtb.m_gtBoardSlot;
    m_gtBoardHexName = gtb.m_gtBoardHexName;

    m_gtQuadInPsb = gtb.m_gtQuadInPsb;

    m_gtInputPsbChannels = gtb.m_gtInputPsbChannels;

}

// assignment operator
L1GtBoard& L1GtBoard::operator=(const L1GtBoard& gtb)
{

    if ( this != &gtb ) {

        m_gtBoardType = gtb.m_gtBoardType;
        m_gtBoardIndex = gtb.m_gtBoardIndex;

        m_gtPositionDaqRecord = gtb.m_gtPositionDaqRecord;
        m_gtPositionEvmRecord = gtb.m_gtPositionEvmRecord;

        m_gtBitDaqActiveBoards = gtb.m_gtBitDaqActiveBoards;
        m_gtBitEvmActiveBoards = gtb.m_gtBitEvmActiveBoards;

        m_gtBoardSlot = gtb.m_gtBoardSlot;
        m_gtBoardHexName = gtb.m_gtBoardHexName;

        m_gtQuadInPsb = gtb.m_gtQuadInPsb;
        m_gtInputPsbChannels = gtb.m_gtInputPsbChannels;

    }

    return *this;

}

// equal operator
bool L1GtBoard::operator==(const L1GtBoard& gtb) const
{

    if (m_gtBoardType != gtb.m_gtBoardType) {
        return false;
    }

    if (m_gtBoardIndex != gtb.m_gtBoardIndex) {
        return false;
    }

    if (m_gtPositionDaqRecord != gtb.m_gtPositionDaqRecord) {
        return false;
    }

    if (m_gtPositionEvmRecord != gtb.m_gtPositionEvmRecord) {
        return false;
    }

    if (m_gtBitDaqActiveBoards != gtb.m_gtBitDaqActiveBoards) {
        return false;
    }

    if (m_gtBitEvmActiveBoards != gtb.m_gtBitEvmActiveBoards) {
        return false;
    }

    if (m_gtBoardSlot != gtb.m_gtBoardSlot) {
        return false;
    }

    if (m_gtBoardHexName != gtb.m_gtBoardHexName) {
        return false;
    }

    if (m_gtQuadInPsb != gtb.m_gtQuadInPsb) {
        return false;
    }

    if (m_gtInputPsbChannels != gtb.m_gtInputPsbChannels) {
        return false;
    }

    // all members identical
    return true;

}



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

    return !( result == *this);

}

// less than operator
bool L1GtBoard::operator< (const L1GtBoard& gtb) const
{
    if (m_gtBoardType < gtb.gtBoardType()) {
        return true;
    } else {
        if (m_gtBoardType == gtb.gtBoardType()) {

            if (m_gtBoardIndex < gtb.gtBoardIndex()) {
                return true;
            }
        }
    }

    return false;
}

// set board type
void L1GtBoard::setGtBoardType(const L1GtBoardType& gtBoardTypeValue)
{
    m_gtBoardType = gtBoardTypeValue;
}

// set board index
void L1GtBoard::setGtBoardIndex(const int& gtBoardIndexValue)
{
    m_gtBoardIndex = gtBoardIndexValue;
}

// set the position of board data block
// in the GT DAQ readout record
void L1GtBoard::setGtPositionDaqRecord(const int& gtPositionDaqRecordValue)
{
    m_gtPositionDaqRecord = gtPositionDaqRecordValue;
}

// set the position of board data block
// in the GT EVM readout record
void L1GtBoard::setGtPositionEvmRecord(const int& gtPositionEvmRecordValue)
{
    m_gtPositionEvmRecord = gtPositionEvmRecordValue;
}

// set the bit of board in the GTFE ACTIVE_BOARDS
// for the GT DAQ readout record
void L1GtBoard::setGtBitDaqActiveBoards(const int& gtBitDaqActiveBoardsValue)
{
    m_gtBitDaqActiveBoards = gtBitDaqActiveBoardsValue;
}


// set the bit of board in the GTFE ACTIVE_BOARDS
// for the GT EVM readout record
void L1GtBoard::setGtBitEvmActiveBoards(const int& gtBitEvmActiveBoardsValue)
{
    m_gtBitEvmActiveBoards = gtBitEvmActiveBoardsValue;
}

// set board slot
void L1GtBoard::setGtBoardSlot(const int& gtBoardSlotValue)
{
    m_gtBoardSlot = gtBoardSlotValue;
}

// set board hex fragment name in hw record
void L1GtBoard::setGtBoardHexName(const int& gtBoardHexNameValue)
{
    m_gtBoardHexName = gtBoardHexNameValue;
}


// set L1 quadruplet (4x16 bits)(cable) in the PSB input
// valid for PSB only
void L1GtBoard::setGtQuadInPsb(const std::vector<L1GtPsbQuad>& gtQuadInPsbValue)
{
    m_gtQuadInPsb = gtQuadInPsbValue;
}

// set detailed input configuration for PSB (objects pro channel)
// int: channel number
void L1GtBoard::setGtInputPsbChannels(const std::map<int, std::vector<L1GtObject> >& gtInputPsbChannelsValue) {
    m_gtInputPsbChannels = gtInputPsbChannelsValue;
}

// get the board ID
const boost::uint16_t L1GtBoard::gtBoardId() const
{

    boost::uint16_t boardIdValue = 0;

    if (m_gtBoardType == GTFE) {
        boardIdValue = boardIdValue | m_gtBoardSlot;
    } else {
        boardIdValue = boardIdValue | (m_gtBoardHexName << 8) | m_gtBoardSlot;
    }

    return boardIdValue;
}

// return board name - it depends on L1GtBoardType enum!!!
std::string L1GtBoard::gtBoardName() const
{

    std::string gtBoardNameValue;

    // active board, add its size
    switch (m_gtBoardType) {

        case GTFE: {
                gtBoardNameValue = "GTFE";
            }
            break;
        case FDL: {
                gtBoardNameValue = "FDL";
            }
            break;
        case PSB: {
                gtBoardNameValue = "PSB";
            }
            break;
        case GMT: {
                gtBoardNameValue = "GMT";
            }
            break;
        case TCS: {
                gtBoardNameValue = "TCS";
            }
            break;
        case TIM: {
                gtBoardNameValue = "TIM";
            }
            break;
        default: {
            //edm::LogWarning("L1GtBoard") << "\n\nError: no such board type" <<  m_gtBoardType
            //<< " in enum L1GtBoardType from L1GtFwd\n\n" << std::endl;
            gtBoardNameValue = "ERROR";
            }
            break;
    }


    return gtBoardNameValue;

}

void L1GtBoard::print(std::ostream& myCout) const
{

    boost::uint16_t boardId = gtBoardId();
    std::string boardName = gtBoardName();

    myCout
    << "Board ID:                        " << std::hex << boardId << std::dec << std::endl
    << "Board Name:                      " << boardName << "_" << m_gtBoardIndex << std::endl
    << "Position in DAQ Record:          " << m_gtPositionDaqRecord << std::endl
    << "Position in EVM Record:          " << m_gtPositionEvmRecord << std::endl
    << "Active_Boards bit in DAQ Record: " << m_gtBitDaqActiveBoards << std::endl
    << "Active_Boards bit in EVM Record: " << m_gtBitEvmActiveBoards << std::endl
    << "Board HexName:                   " << std::hex << m_gtBoardHexName << std::dec
    << std::endl;

    if (m_gtBoardType == PSB) {
        myCout
        << "PSB Input per Cable: DEPRECATED"
        << std::endl;
    }


    for (std::vector<L1GtPsbQuad>::const_iterator
            cIt = m_gtQuadInPsb.begin(); cIt != m_gtQuadInPsb.end(); ++cIt) {

        std::string objType;

        if ( *cIt == TechTr ) {
            objType = "TechTr";
        } else if ( *cIt == IsoEGQ ) {
            objType = "IsoEGQ";
        } else if ( *cIt == NoIsoEGQ ) {
            objType = "NoIsoEGQ";
        } else if ( *cIt == CenJetQ ) {
            objType = "CenJetQ";
        } else if ( *cIt == ForJetQ ) {
            objType = "ForJetQ";
        } else if ( *cIt == TauJetQ ) {
            objType = "TauJetQ";
        } else if ( *cIt == ESumsQ ) {
            objType = "ESumsQ";
        } else if ( *cIt == JetCountsQ ) {
            objType = "JetCountsQ";
        } else if ( *cIt == MQB1 ) {
            objType = "MQB1";
        } else if ( *cIt == MQB2 ) {
            objType = "MQB2";
        } else if ( *cIt == MQF3 ) {
            objType = "MQF3";
        } else if ( *cIt == MQF4 ) {
            objType = "MQF4";
        } else if ( *cIt == MQB5 ) {
            objType = "MQB5";
        } else if ( *cIt == MQB6 ) {
            objType = "MQB6";
        } else if ( *cIt == MQF7 ) {
            objType = "MQF7";
        } else if ( *cIt == MQF8 ) {
            objType = "MQF8";
        } else if ( *cIt == MQB9 ) {
            objType = "MQB9";
        } else if ( *cIt == MQB10 ) {
            objType = "MQB10";
        } else if ( *cIt == MQF11 ) {
            objType = "MQF11";
        } else if ( *cIt == MQF12 ) {
            objType = "MQF12";
        } else if ( *cIt == Free ) {
            objType = "Free";
        } else if ( *cIt == HfQ ) {
            objType = "HfQ";
        } else {
            myCout << "\n\nError: no such member " <<  (*cIt)
            << " in enum L1GtPsbQuad\n\n" << std::endl;
            objType = "ERROR";
        }


        myCout << "       " << objType << " ";
    }
    myCout << std::endl;

    if (m_gtBoardType == PSB) {
        myCout
        << "Input objects pro channel:";
    }

    for (std::map<int, std::vector<L1GtObject> >::const_iterator cIt =
            m_gtInputPsbChannels.begin(); cIt != m_gtInputPsbChannels.end(); ++cIt) {

        myCout << "\n  Channel " << cIt->first << " (" << (cIt->second).size() << " objects): ";

        for (std::vector<L1GtObject>::const_iterator itObj =
                (cIt->second).begin(); itObj != (cIt->second).end(); ++itObj) {

            switch (*itObj) {
                case Mu: {
                    myCout << " Mu ";
                }

                    break;
                case NoIsoEG: {
                    myCout << " NoIsoEG ";
                }

                    break;
                case IsoEG: {
                    myCout << " IsoEG ";
                }

                    break;
                case CenJet: {
                    myCout << " CenJet ";
                }

                    break;
                case ForJet: {
                    myCout << " ForJet ";
                }

                    break;
                case TauJet: {
                    myCout << " TauJet ";
                }

                    break;
                case ETM: {
                    myCout << " ETM ";
                }

                    break;
                case ETT: {
                    myCout << " ETT ";
                }

                    break;
                case HTT: {
                    myCout << " HTT ";
                }

                    break;
                case HTM: {
                    myCout << " HTM ";
                }

                    break;
                case JetCounts: {
                    myCout << " JetCounts ";
                }

                    break;
                case HfBitCounts: {
                    myCout << " HfBitCounts ";
                }

                    break;
                case HfRingEtSums: {
                    myCout << " HfRingEtSums ";
                }

                    break;
                case TechTrig: {
                    myCout << " TechTrig ";
                }

                    break;
                case Castor: {
                    myCout << " Castor ";
                }

                    break;
                case BPTX: {
                    myCout << " BPTX ";
                }

                    break;
                case GtExternal: {
                    myCout << " GtExternal ";
                }

                    break;
                default: {
                    myCout << " ERROR: Unknown type " << (*itObj);
                }
                    break;
            }
        }

    }


    myCout << std::endl;
}

// output stream operator
std::ostream& operator<<(std::ostream& os, const L1GtBoard& result)
{
    result.print(os);
    return os;

}

// number of InfiniCables per board
const int L1GtBoard::NumberCablesBoard = 4;