L1GtTriggerMenuLite.cc

Go to the documentation of this file.

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

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

// user include files

// forward declarations

// constructor
L1GtTriggerMenuLite::L1GtTriggerMenuLite()
    : m_triggerMenuInterface("NULL"),
      m_triggerMenuName("NULL"),
      m_triggerMenuImplementation("NULL"),
      m_scaleDbKey("NULL") {
  // empty
}

L1GtTriggerMenuLite::L1GtTriggerMenuLite(const std::string& triggerMenuNameVal,
                                         const L1TriggerMap& algorithmMapVal,
                                         const L1TriggerMap& algorithmAliasMapVal,
                                         const L1TriggerMap& technicalTriggerMapVal,
                                         const std::vector<unsigned int>& triggerMaskAlgoTrigVal,
                                         const std::vector<unsigned int>& triggerMaskTechTrigVal,
                                         const std::vector<std::vector<int> >& prescaleFactorsAlgoTrigVal,
                                         const std::vector<std::vector<int> >& prescaleFactorsTechTrigVal)
    : m_triggerMenuInterface("NULL"),
      m_triggerMenuName(triggerMenuNameVal),
      m_triggerMenuImplementation("NULL"),
      m_scaleDbKey("NULL"),
      m_algorithmMap(algorithmMapVal),
      m_algorithmAliasMap(algorithmAliasMapVal),
      m_technicalTriggerMap(technicalTriggerMapVal),
      m_triggerMaskAlgoTrig(triggerMaskAlgoTrigVal),
      m_triggerMaskTechTrig(triggerMaskTechTrigVal),
      m_prescaleFactorsAlgoTrig(prescaleFactorsAlgoTrigVal),
      m_prescaleFactorsTechTrig(prescaleFactorsTechTrigVal)

{
  // empty
}

// copy constructor
L1GtTriggerMenuLite::L1GtTriggerMenuLite(const L1GtTriggerMenuLite& rhs) {
  m_triggerMenuInterface = rhs.m_triggerMenuInterface;
  m_triggerMenuName = rhs.m_triggerMenuName;
  m_triggerMenuImplementation = rhs.m_triggerMenuImplementation;
  m_scaleDbKey = rhs.m_scaleDbKey;

  // copy algorithm map
  m_algorithmMap = rhs.m_algorithmMap;
  m_algorithmAliasMap = rhs.m_algorithmAliasMap;

  // copy technical triggers
  // (separate map for technical triggers and physics triggers)
  m_technicalTriggerMap = rhs.m_technicalTriggerMap;

  // copy masks
  m_triggerMaskAlgoTrig = rhs.m_triggerMaskAlgoTrig;
  m_triggerMaskTechTrig = rhs.m_triggerMaskTechTrig;

  // copy prescale factors
  m_prescaleFactorsAlgoTrig = rhs.m_prescaleFactorsAlgoTrig;
  m_prescaleFactorsTechTrig = rhs.m_prescaleFactorsTechTrig;
}

// destructor
L1GtTriggerMenuLite::~L1GtTriggerMenuLite() {
  m_algorithmMap.clear();
  m_algorithmAliasMap.clear();
  m_technicalTriggerMap.clear();
}

// assignment operator
L1GtTriggerMenuLite& L1GtTriggerMenuLite::operator=(const L1GtTriggerMenuLite& rhs) {
  if (this != &rhs) {
    m_triggerMenuInterface = rhs.m_triggerMenuInterface;
    m_triggerMenuName = rhs.m_triggerMenuName;
    m_triggerMenuImplementation = rhs.m_triggerMenuImplementation;
    m_scaleDbKey = rhs.m_scaleDbKey;

    m_algorithmMap = rhs.m_algorithmMap;
    m_algorithmAliasMap = rhs.m_algorithmAliasMap;

    m_technicalTriggerMap = rhs.m_technicalTriggerMap;

    m_triggerMaskAlgoTrig = rhs.m_triggerMaskAlgoTrig;
    m_triggerMaskTechTrig = rhs.m_triggerMaskTechTrig;

    m_prescaleFactorsAlgoTrig = rhs.m_prescaleFactorsAlgoTrig;
    m_prescaleFactorsTechTrig = rhs.m_prescaleFactorsTechTrig;
  }

  // return the object
  return *this;
}

// equal operator
bool L1GtTriggerMenuLite::operator==(const L1GtTriggerMenuLite& rhs) const {
  if (m_triggerMenuInterface != rhs.m_triggerMenuInterface) {
    return false;
  }

  if (m_triggerMenuName != rhs.m_triggerMenuName) {
    return false;
  }

  if (m_triggerMenuImplementation != rhs.m_triggerMenuImplementation) {
    return false;
  }

  if (m_scaleDbKey != rhs.m_scaleDbKey) {
    return false;
  }

  if (m_algorithmMap != rhs.m_algorithmMap) {
    return false;
  }

  if (m_algorithmAliasMap != rhs.m_algorithmAliasMap) {
    return false;
  }

  if (m_technicalTriggerMap != rhs.m_technicalTriggerMap) {
    return false;
  }

  if (m_triggerMaskAlgoTrig != rhs.m_triggerMaskAlgoTrig) {
    return false;
  }

  if (m_triggerMaskTechTrig != rhs.m_triggerMaskTechTrig) {
    return false;
  }

  if (m_prescaleFactorsAlgoTrig != rhs.m_prescaleFactorsAlgoTrig) {
    return false;
  }

  if (m_prescaleFactorsTechTrig != rhs.m_prescaleFactorsTechTrig) {
    return false;
  }

  // all members identical
  return true;
}

// unequal operator
bool L1GtTriggerMenuLite::operator!=(const L1GtTriggerMenuLite& otherObj) const { return !(otherObj == *this); }

// merge rule: test on isProductEqual
bool L1GtTriggerMenuLite::isProductEqual(const L1GtTriggerMenuLite& otherObj) const { return (otherObj == *this); }

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

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

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

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

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

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

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

// set the trigger mask for physics algorithms
void L1GtTriggerMenuLite::setGtTriggerMaskAlgoTrig(const std::vector<unsigned int>& maskValue) {
  m_triggerMaskAlgoTrig = maskValue;
}

// set the trigger mask for technical triggers
void L1GtTriggerMenuLite::setGtTriggerMaskTechTrig(const std::vector<unsigned int>& maskValue) {
  m_triggerMaskTechTrig = maskValue;
}

// set the prescale factors
void L1GtTriggerMenuLite::setGtPrescaleFactorsAlgoTrig(const std::vector<std::vector<int> >& factorValue) {
  m_prescaleFactorsAlgoTrig = factorValue;
}

void L1GtTriggerMenuLite::setGtPrescaleFactorsTechTrig(const std::vector<std::vector<int> >& factorValue) {
  m_prescaleFactorsTechTrig = factorValue;
}

// print the trigger menu
void L1GtTriggerMenuLite::print(std::ostream& myCout, int& printVerbosity) const {
  //

  switch (printVerbosity) {
    case 0: {
      size_t nrDefinedAlgo = m_algorithmMap.size();
      size_t nrDefinedTech = m_technicalTriggerMap.size();

      // header for printing algorithms

      myCout << "\n   ********** L1 Trigger Menu - printing   ********** \n"
             << "\nL1 Trigger Menu Interface: " << m_triggerMenuInterface
             << "\nL1 Trigger Menu Name:      " << m_triggerMenuName
             << "\nL1 Trigger Menu Implementation: " << m_triggerMenuImplementation
             << "\nAssociated Scale DB Key: " << m_scaleDbKey << "\n\n"
             << "\nL1 Physics Algorithms: " << nrDefinedAlgo << " algorithms defined."
             << "\n\n"
             << "Bit Number " << std::right << std::setw(35) << "Algorithm Name"
             << "  " << std::right << std::setw(35) << "Algorithm Alias"
             << "  " << std::right << std::setw(12) << "Trigger Mask";
      for (unsigned iSet = 0; iSet < m_prescaleFactorsAlgoTrig.size(); iSet++) {
        myCout << std::right << std::setw(10) << "PF Set " << std::right << std::setw(2) << iSet;
      }

      myCout << std::endl;

      for (CItL1Trig itTrig = m_algorithmMap.begin(); itTrig != m_algorithmMap.end(); itTrig++) {
        const unsigned int bitNumber = itTrig->first;
        const std::string& aName = itTrig->second;

        std::string aAlias;
        CItL1Trig itAlias = m_algorithmAliasMap.find(bitNumber);
        if (itAlias != m_algorithmAliasMap.end()) {
          aAlias = itAlias->second;
        }

        myCout << std::setw(6) << bitNumber << "     " << std::right << std::setw(35) << aName << "  " << std::right
               << std::setw(35) << aAlias << "  " << std::right << std::setw(12) << m_triggerMaskAlgoTrig[bitNumber];
        for (unsigned iSet = 0; iSet < m_prescaleFactorsAlgoTrig.size(); iSet++) {
          myCout << std::right << std::setw(12) << m_prescaleFactorsAlgoTrig[iSet][bitNumber];
        }

        myCout << std::endl;
      }

      myCout << "\nL1 Technical Triggers: " << nrDefinedTech << " technical triggers defined."
             << "\n\n"
             << std::endl;
      if (nrDefinedTech) {
        myCout << std::right << std::setw(6) << "Bit Number " << std::right << std::setw(45)
               << " Technical trigger name "
               << "  " << std::right << std::setw(12) << "Trigger Mask";
        for (unsigned iSet = 0; iSet < m_prescaleFactorsTechTrig.size(); iSet++) {
          myCout << std::right << std::setw(10) << "PF Set " << std::right << std::setw(2) << iSet;
        }

        myCout << std::endl;
      }

      for (CItL1Trig itTrig = m_technicalTriggerMap.begin(); itTrig != m_technicalTriggerMap.end(); itTrig++) {
        unsigned int bitNumber = itTrig->first;
        std::string aName = itTrig->second;

        myCout << std::setw(6) << bitNumber << "       " << std::right << std::setw(45) << aName << std::right
               << std::setw(12) << m_triggerMaskTechTrig[bitNumber];
        for (unsigned iSet = 0; iSet < m_prescaleFactorsTechTrig.size(); iSet++) {
          myCout << std::right << std::setw(12) << m_prescaleFactorsTechTrig[iSet][bitNumber];
        }

        myCout << std::endl;
      }

    } break;
    default: {
      myCout << "\n   ********** L1 Trigger Menu - printing   ********** \n\n"
             << "Verbosity level: " << printVerbosity << " not implemented.\n\n"
             << std::endl;
    } break;
  }
}

// output stream operator
std::ostream& operator<<(std::ostream& streamRec, const L1GtTriggerMenuLite& result) {
  int verbosityLevel = 0;

  result.print(streamRec, verbosityLevel);
  return streamRec;
}

// get the alias for a physics algorithm with a given bit number
const std::string* L1GtTriggerMenuLite::gtAlgorithmAlias(const unsigned int bitNumber, int& errorCode) const {
  const std::string* gtAlgorithmAlias = nullptr;

  for (CItL1Trig itTrig = m_algorithmAliasMap.begin(); itTrig != m_algorithmAliasMap.end(); itTrig++) {
    if (itTrig->first == bitNumber) {
      gtAlgorithmAlias = &(itTrig->second);

      errorCode = 0;
      return gtAlgorithmAlias;
    }
  }

  errorCode = 1;
  return gtAlgorithmAlias;
}

// get the name for a physics algorithm or a technical trigger
// with a given bit number
const std::string* L1GtTriggerMenuLite::gtAlgorithmName(const unsigned int bitNumber, int& errorCode) const {
  const std::string* gtAlgorithmName = nullptr;

  for (CItL1Trig itTrig = m_algorithmMap.begin(); itTrig != m_algorithmMap.end(); itTrig++) {
    if (itTrig->first == bitNumber) {
      gtAlgorithmName = &(itTrig->second);

      errorCode = 0;
      return gtAlgorithmName;
    }
  }

  errorCode = 1;
  return gtAlgorithmName;
}

const std::string* L1GtTriggerMenuLite::gtTechTrigName(const unsigned int bitNumber, int& errorCode) const {
  const std::string* gtTechTrigName = nullptr;

  for (CItL1Trig itTrig = m_technicalTriggerMap.begin(); itTrig != m_technicalTriggerMap.end(); itTrig++) {
    if (itTrig->first == bitNumber) {
      gtTechTrigName = &(itTrig->second);

      errorCode = 0;
      return gtTechTrigName;
    }
  }

  errorCode = 1;
  return gtTechTrigName;
}

// get the bit number for a physics algorithm or a technical trigger
// with a given name or alias
const unsigned int L1GtTriggerMenuLite::gtBitNumber(const std::string& trigName, int& errorCode) const {
  unsigned int bitNr = 999;

  //
  for (CItL1Trig itTrig = m_algorithmAliasMap.begin(); itTrig != m_algorithmAliasMap.end(); itTrig++) {
    if (itTrig->second == trigName) {
      bitNr = itTrig->first;

      errorCode = 0;
      return bitNr;
    }
  }

  //
  for (CItL1Trig itTrig = m_algorithmMap.begin(); itTrig != m_algorithmMap.end(); itTrig++) {
    if (itTrig->second == trigName) {
      bitNr = itTrig->first;
      errorCode = 0;
      return bitNr;
    }
  }

  //
  for (CItL1Trig itTrig = m_technicalTriggerMap.begin(); itTrig != m_technicalTriggerMap.end(); itTrig++) {
    if (itTrig->second == trigName) {
      bitNr = itTrig->first;
      errorCode = 0;
      return bitNr;
    }
  }

  errorCode = 1;
  return bitNr;
}

// get the result for a physics algorithm or a technical trigger with name trigName
// use directly the format of decisionWord (no typedef)
const bool L1GtTriggerMenuLite::gtTriggerResult(const std::string& trigName,
                                                const std::vector<bool>& decWord,
                                                int& errorCode) const {
  bool trigResult = false;

  // try first physics algorithm aliases

  for (CItL1Trig itTrig = m_algorithmAliasMap.begin(); itTrig != m_algorithmAliasMap.end(); itTrig++) {
    if (itTrig->second == trigName) {
      unsigned int bitNumber = itTrig->first;

      if ((bitNumber >= decWord.size())) {
        trigResult = false;
        errorCode = 10;
      } else {
        trigResult = decWord[bitNumber];
        errorCode = 0;
      }

      return trigResult;
    }
  }

  // ... then physics algorithm names

  for (CItL1Trig itTrig = m_algorithmMap.begin(); itTrig != m_algorithmMap.end(); itTrig++) {
    if (itTrig->second == trigName) {
      unsigned int bitNumber = itTrig->first;

      if ((bitNumber >= decWord.size())) {
        trigResult = false;
        errorCode = 10;
      } else {
        trigResult = decWord[bitNumber];
        errorCode = 0;
      }

      return trigResult;
    }
  }

  // ... then technical trigger names

  for (CItL1Trig itTrig = m_technicalTriggerMap.begin(); itTrig != m_technicalTriggerMap.end(); itTrig++) {
    if (itTrig->second == trigName) {
      unsigned int bitNumber = itTrig->first;

      if ((bitNumber >= decWord.size())) {
        trigResult = false;
        errorCode = 10;
      } else {
        trigResult = decWord[bitNumber];
        errorCode = 0;
      }

      return trigResult;
    }
  }

  // algorithm or technical trigger not in the menu

  errorCode = 1;
  return false;
}