L1GtBoardMapsTrivialProducer.cc

Go to the documentation of this file.

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

// system include files
#include <memory>

#include <string>

// user include files
//   base class
#include "FWCore/Utilities/interface/EDMException.h"

#include "FWCore/Framework/interface/ModuleFactory.h"
#include "FWCore/Framework/interface/ESHandle.h"

#include "CondFormats/L1TObjects/interface/L1GtFwd.h"

// forward declarations

//

std::vector<L1GtObject> chInputObjects(
        const std::vector<std::string>& chInputStrings)
{
    std::vector<L1GtObject> chInputObjectsV;
    chInputObjectsV.reserve(chInputStrings.size());

    L1GtObject obj;

    for (std::vector<std::string>::const_iterator itObj =
            chInputStrings.begin(); itObj != chInputStrings.end(); ++itObj) {

        if ((*itObj) == "Mu") {
            obj = Mu;
        }
        else if ((*itObj) == "NoIsoEG") {
            obj = NoIsoEG;
        }
        else if ((*itObj) == "IsoEG") {
            obj = IsoEG;
        }
        else if ((*itObj) == "CenJet") {
            obj = CenJet;
        }
        else if ((*itObj) == "ForJet") {
            obj = ForJet;
        }
        else if ((*itObj) == "TauJet") {
            obj = TauJet;
        }
        else if ((*itObj) == "ETM") {
            obj = ETM;
        }
        else if ((*itObj) == "ETT") {
            obj = ETT;
        }
        else if ((*itObj) == "HTT") {
            obj = HTT;
        }
        else if ((*itObj) == "HTM") {
            obj = HTM;
        }
        else if ((*itObj) == "JetCounts") {
            obj = JetCounts;
        }
        else if ((*itObj) == "HfBitCounts") {
            obj = HfBitCounts;
        }
        else if ((*itObj) == "HfRingEtSums") {
            obj = HfRingEtSums;
        }
        else if ((*itObj) == "TechTrig") {
            obj = TechTrig;
        }
        else if ((*itObj) == "BPTX") {
            obj = BPTX;
        }
        else if ((*itObj) == "GtExternal") {
            obj = GtExternal;
        }
        else {
            throw cms::Exception("Configuration")
                    << "\nError: no such L1 GT object: " << (*itObj) << "\n"
                    << "\n       Can not define the mapping of the L1 GT boards.     \n"
                    << std::endl;

        }

        chInputObjectsV.push_back(obj);
    }

    return chInputObjectsV;
}

// constructor(s)
L1GtBoardMapsTrivialProducer::L1GtBoardMapsTrivialProducer(const edm::ParameterSet& parSet)
{
    // tell the framework what data is being produced
    setWhatProduced(this, &L1GtBoardMapsTrivialProducer::produceBoardMaps);

    // now do what ever other initialization is needed

    // get the list of the board names and indices
    std::vector<std::string> boardList =
        parSet.getParameter<std::vector<std::string> >("BoardList");

    std::vector<int> boardIndexVec =
        parSet.getParameter<std::vector<int> >("BoardIndex");

    // check if the board list and the board indices are consistent
    // i.e. have the same number of entries

    if (boardList.size() != boardIndexVec.size()) {
        throw cms::Exception("Configuration")
        << "\nError: inconsistent length of board list and board indices.\n"
        << "\n       Can not define the mapping of the L1 GT boards.     \n"
        << std::endl;
    }

    // L1 GT DAQ record map
    std::vector<int> boardPositionDaqRecord =
        parSet.getParameter<std::vector<int> >("BoardPositionDaqRecord");

    if (boardList.size() != boardPositionDaqRecord.size()) {
        throw cms::Exception("Configuration")
        << "\nError: inconsistent length of board list and board indices in GT DAQ record.\n"
        << "\n       Can not define the mapping of the L1 GT boards.     \n"
        << std::endl;
    }

    // L1 GT EVM record map
    std::vector<int> boardPositionEvmRecord =
        parSet.getParameter<std::vector<int> >("BoardPositionEvmRecord");

    if (boardList.size() != boardPositionEvmRecord.size()) {
        throw cms::Exception("Configuration")
        << "\nError: inconsistent length of board list and board indices in GT EVM record.\n"
        << "\n       Can not define the mapping of the L1 GT boards.     \n"
        << std::endl;
    }

    // L1 GT "active boards" map for DAQ record
    std::vector<int> activeBoardsDaqRecord =
        parSet.getParameter<std::vector<int> >("ActiveBoardsDaqRecord");

    if (boardList.size() != activeBoardsDaqRecord.size()) {
        throw cms::Exception("Configuration")
        << "\nError: inconsistent length of board list and active boards in GT DAQ record.\n"
        << "\n       Can not define the mapping of the L1 GT boards.     \n"
        << std::endl;
    }

    // L1 GT "active boards" map for EVM record
    std::vector<int> activeBoardsEvmRecord =
        parSet.getParameter<std::vector<int> >("ActiveBoardsEvmRecord");

    if (boardList.size() != activeBoardsEvmRecord.size()) {
        throw cms::Exception("Configuration")
        << "\nError: inconsistent length of board list and active boards in GT EVM record.\n"
        << "\n       Can not define the mapping of the L1 GT boards.     \n"
        << std::endl;
    }

    // L1 GT board - slot map
    std::vector<int> boardSlotMap =
        parSet.getParameter<std::vector<int> >("BoardSlotMap");

    if (boardList.size() != boardSlotMap.size()) {
        throw cms::Exception("Configuration")
        << "\nError: inconsistent length of board list and board - slot map.\n"
        << "\n       Can not define the mapping of the L1 GT boards.     \n"
        << std::endl;
    }

    // L1 GT board name in hw record map
    std::vector<int> boardHexNameMap =
        parSet.getParameter<std::vector<int> >("BoardHexNameMap");

    if (boardList.size() != boardHexNameMap.size()) {
        throw cms::Exception("Configuration")
        << "\nError: inconsistent length of board list and board name in hw record map.\n"
        << "\n       Can not define the mapping of the L1 GT boards.     \n"
        << std::endl;
    }



    // GCT PSB to GT - map cables to input quadruplets  and PSB indices


    // L1 GT cable list (GCT input to PSB)
    std::vector<std::string> cableList =
        parSet.getParameter<std::vector<std::string> >("CableList");

    // L1 GT calo input to PSB map
    //    gives the mapping of GT calorimeter input to GT PSBs via PSB index
    //    4 infinicables per PSB (last PSB can use only 2!)
    std::vector<int> cableToPsbMap =
        parSet.getParameter<std::vector<int> >("CableToPsbMap");


    if (cableList.size() != cableToPsbMap.size()) {
        throw cms::Exception("Configuration")
        << "\nError: inconsistent length of cable list and input to PSB list.\n"
        << "\n       Can not define the mapping of GCT quadruplets to GT PSBs.\n"
        << std::endl;
    }


    // detailed input configuration for PSB
    std::vector<edm::ParameterSet> psbInput = parSet.getParameter<std::vector<
            edm::ParameterSet> > ("PsbInput");

    // reserve space for L1 GT boards
    m_gtBoardMaps.reserve(boardList.size());


    // fill the maps
    int posVec = 0;

    for (std::vector<std::string>::const_iterator
            it = boardList.begin(); it != boardList.end(); ++it) {

        L1GtBoardType boardType;

        if ( (*it) == "GTFE" ) {
            boardType = GTFE;
        } else if ( (*it) == "FDL" ) {
            boardType = FDL;
        } else if ( (*it) == "PSB" ) {
            boardType = PSB;
        } else if ( (*it) == "GMT" ) {
            boardType = GMT;
        } else if ( (*it) == "TCS" ) {
            boardType = TCS;
        } else if ( (*it) == "TIM" ) {
            boardType = TIM;
        } else {
            throw cms::Exception("Configuration")
            << "\nError: no such board: " << (*it).c_str() << "\n"
            << "\n       Can not define the mapping of the L1 GT boards.     \n"
            << std::endl;
        }

        // construct from board type and board index

        int iBoard = boardIndexVec.at(posVec);
        L1GtBoard gtBoard = L1GtBoard(boardType, iBoard);

        // set the position of board data block
        // in the GT DAQ readout record
        gtBoard.setGtPositionDaqRecord(boardPositionDaqRecord.at(posVec));

        // set the position of board data block
        // in the GT EVM readout record
        gtBoard.setGtPositionEvmRecord(boardPositionEvmRecord.at(posVec));

        // set the bit of board in the GTFE ACTIVE_BOARDS
        // for the GT DAQ readout record
        gtBoard.setGtBitDaqActiveBoards(activeBoardsDaqRecord.at(posVec));

        // set the bit of board in the GTFE ACTIVE_BOARDS
        // for the GT EVM readout record
        gtBoard.setGtBitEvmActiveBoards(activeBoardsEvmRecord.at(posVec));

        // set board slot
        int boardSlot = boardSlotMap.at(posVec);
        gtBoard.setGtBoardSlot(boardSlot);

        // set board hex fragment name in hw record
        gtBoard.setGtBoardHexName(boardHexNameMap.at(posVec));

        // set L1 quadruplet (4x16 bits)(cable) in the PSB input
        // valid for PSB only

        if (boardType == PSB) {

            L1GtPsbQuad psbQuad = Free;
            int posCable = 0;
            int iPsb = 0;
            std::vector<L1GtPsbQuad> quadVec(L1GtBoard::NumberCablesBoard);

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


                if ( *cIt == "TechTr" ) {
                    psbQuad = TechTr;
                } else if ( *cIt == "IsoEGQ" ) {
                    psbQuad = IsoEGQ;
                } else if ( *cIt == "NoIsoEGQ" ) {
                    psbQuad = NoIsoEGQ;
                } else if ( *cIt == "CenJetQ" ) {
                    psbQuad = CenJetQ;
                } else if ( *cIt == "ForJetQ" ) {
                    psbQuad = ForJetQ;
                } else if ( *cIt == "TauJetQ" ) {
                    psbQuad = TauJetQ;
                } else if ( *cIt == "ESumsQ" ) {
                    psbQuad = ESumsQ;
                } else if ( *cIt == "JetCountsQ" ) {
                    psbQuad = JetCountsQ;
                } else if ( *cIt == "MQB1" ) {
                    psbQuad = MQB1;
                } else if ( *cIt == "MQB2" ) {
                    psbQuad = MQB2;
                } else if ( *cIt == "MQF3" ) {
                    psbQuad = MQF3;
                } else if ( *cIt == "MQF4" ) {
                    psbQuad = MQF4;
                } else if ( *cIt == "MQB5" ) {
                    psbQuad = MQB5;
                } else if ( *cIt == "MQB6" ) {
                    psbQuad = MQB6;
                } else if ( *cIt == "MQF7" ) {
                    psbQuad = MQF7;
                } else if ( *cIt == "MQF8" ) {
                    psbQuad = MQF8;
                } else if ( *cIt == "MQB9" ) {
                    psbQuad = MQB9;
                } else if ( *cIt == "MQB10" ) {
                    psbQuad = MQB10;
                } else if ( *cIt == "MQF11" ) {
                    psbQuad = MQF11;
                } else if ( *cIt == "MQF12" ) {
                    psbQuad = MQF12;
                } else if ( *cIt == "Free" ) {
                    psbQuad = Free;
                } else if ( *cIt == "HfQ" ) {
                    psbQuad = HfQ;
                } else {
                    // should not arrive here
                    throw cms::Exception("Configuration")
                    << "\nError: no such quadruplet: " << (*cIt).c_str() << "\n"
                    << "\n       Can not define the mapping of quadruplets to the L1 PSB boards.\n"
                    << std::endl;
                }

                int psbIndex = cableToPsbMap.at(posCable);

                if (psbIndex == gtBoard.gtBoardIndex()) {

                    if (iPsb > L1GtBoard::NumberCablesBoard) {
                        throw cms::Exception("Configuration")
                        << "\nError: too many cables for PSB_" << gtBoard.gtBoardIndex()
                        << "\n\n       "
                        << "Can not define the mapping of cables to L1 PSB boards.     \n"
                        << std::endl;

                    }
                    quadVec[iPsb] = psbQuad;
                    iPsb++;
                }
                posCable++;

            }

            gtBoard.setGtQuadInPsb(quadVec);

        }

        if (boardType == PSB) {

            std::map<int, std::vector<L1GtObject> > inputPsbChannels;

            std::vector<std::string> chStrings;
            chStrings.reserve(2); // most channels have 2 objects

            std::vector<L1GtObject>  chObjects;

            for (std::vector<edm::ParameterSet>::const_iterator itPSet =
                    psbInput.begin(); itPSet != psbInput.end(); ++itPSet) {

                //
                int slot = itPSet->getParameter<int> ("Slot");

                if (slot == boardSlot) {
                    chStrings = itPSet->getParameter<std::vector<std::string> > (
                            "Ch0");
                    chObjects = chInputObjects(chStrings);
                    inputPsbChannels[0] = chObjects;
                    chStrings.clear();
                    chObjects.clear();

                    chStrings = itPSet->getParameter<std::vector<std::string> > (
                            "Ch1");
                    chObjects = chInputObjects(chStrings);
                    inputPsbChannels[1] = chObjects;
                    chStrings.clear();
                    chObjects.clear();

                    chStrings = itPSet->getParameter<std::vector<std::string> > (
                            "Ch2");
                    chObjects = chInputObjects(chStrings);
                    inputPsbChannels[2] = chObjects;
                    chStrings.clear();
                    chObjects.clear();

                    chStrings = itPSet->getParameter<std::vector<std::string> > (
                            "Ch3");
                    chObjects = chInputObjects(chStrings);
                    inputPsbChannels[3] = chObjects;
                    chStrings.clear();
                    chObjects.clear();

                    chStrings = itPSet->getParameter<std::vector<std::string> > (
                            "Ch4");
                    chObjects = chInputObjects(chStrings);
                    inputPsbChannels[4] = chObjects;
                    chStrings.clear();
                    chObjects.clear();

                    chStrings = itPSet->getParameter<std::vector<std::string> > (
                            "Ch5");
                    chObjects = chInputObjects(chStrings);
                    inputPsbChannels[5] = chObjects;
                    chStrings.clear();
                    chObjects.clear();

                    chStrings = itPSet->getParameter<std::vector<std::string> > (
                            "Ch6");
                    chObjects = chInputObjects(chStrings);
                    inputPsbChannels[6] = chObjects;
                    chStrings.clear();
                    chObjects.clear();

                    chStrings = itPSet->getParameter<std::vector<std::string> > (
                            "Ch7");
                    chObjects = chInputObjects(chStrings);
                    inputPsbChannels[7] = chObjects;
                    chStrings.clear();
                    chObjects.clear();
                }
            }

            gtBoard.setGtInputPsbChannels(inputPsbChannels);
        }

        // push the board in the vector
        m_gtBoardMaps.push_back(gtBoard);

        // increase the counter
        posVec++;

    }

}

// destructor
L1GtBoardMapsTrivialProducer::~L1GtBoardMapsTrivialProducer()
{

    // empty

}


// member functions

// method called to produce the data
std::unique_ptr<L1GtBoardMaps> L1GtBoardMapsTrivialProducer::produceBoardMaps(
    const L1GtBoardMapsRcd& iRecord)
{
    auto pL1GtBoardMaps = std::make_unique<L1GtBoardMaps>();

    pL1GtBoardMaps->setGtBoardMaps(m_gtBoardMaps);

    return pL1GtBoardMaps ;
}