GlobalAlgorithm.cc

Go to the documentation of this file.

 
// this class header
#include "L1Trigger/L1TGlobal/interface/GlobalAlgorithm.h"
 
// system include files
#include <iostream>
#include <iomanip>
 
// user include files
 
// forward declarations
 
// constructor(s)
//   default
GlobalAlgorithm::GlobalAlgorithm() {
  // default values for private members not set
  // the other private members are C++ initialized
  m_algoBitNumber = -1;
  m_algoChipNumber = -1;
}
 
//   name only
GlobalAlgorithm::GlobalAlgorithm(const std::string& algoNameValue) : m_algoName(algoNameValue) {
  // default values for private members not set
  // the other private members are C++ initialized
  m_algoBitNumber = -1;
  m_algoChipNumber = -1;
}
 
//   name and logical expression
GlobalAlgorithm::GlobalAlgorithm(const std::string& algoNameValue, const std::string& algoLogicalExpressionValue)
    : m_algoName(algoNameValue), m_algoLogicalExpression(algoLogicalExpressionValue) {
  GlobalLogicParser logicParser(m_algoLogicalExpression);
  m_algoRpnVector = logicParser.rpnVector();
 
  // default values for private members not set
  m_algoBitNumber = -1;
  m_algoChipNumber = -1;
}
 
//   name, logical expression and bit number
GlobalAlgorithm::GlobalAlgorithm(const std::string& algoNameValue,
                                 const std::string& algoLogicalExpressionValue,
                                 const int algoBitNumberValue)
    : m_algoName(algoNameValue),
      m_algoLogicalExpression(algoLogicalExpressionValue),
      m_algoBitNumber(algoBitNumberValue)
 
{
  GlobalLogicParser logicParser(m_algoLogicalExpression);
  m_algoRpnVector = logicParser.rpnVector();
 
  // default values for private members not set
  m_algoChipNumber = -1;
}
 
// destructor
GlobalAlgorithm::~GlobalAlgorithm() {
  // empty
}
 
// public methods
 
// get the condition chip number the algorithm is located on
const int GlobalAlgorithm::algoChipNumber(const int numberConditionChips,
                                          const int pinsOnConditionChip,
                                          const std::vector<int>& orderConditionChip) const {
  int posChip = (m_algoBitNumber / pinsOnConditionChip) + 1;
  for (int iChip = 0; iChip < numberConditionChips; ++iChip) {
    if (posChip == orderConditionChip[iChip]) {
      return iChip;
    }
  }
 
  // chip number not found
  return -1;
}
 
// get the output pin on the condition chip for the algorithm
const int GlobalAlgorithm::algoOutputPin(const int numberConditionChips,
                                         const int pinsOnConditionChip,
                                         const std::vector<int>& orderConditionChip) const {
  int iChip = algoChipNumber(numberConditionChips, pinsOnConditionChip, orderConditionChip);
 
  int outputPin = m_algoBitNumber - (orderConditionChip[iChip] - 1) * pinsOnConditionChip + 1;
 
  return outputPin;
}
 
// print algorithm
void GlobalAlgorithm::print(std::ostream& myCout) const {
  myCout << std::endl;
 
  myCout << "    Algorithm name:         " << m_algoName << std::endl;
  myCout << "    Algorithm alias:        " << m_algoAlias << std::endl;
 
  myCout << "    Bit number:             " << m_algoBitNumber;
  if (m_algoBitNumber < 0) {
    myCout << "   - not properly initialized! " << std::endl;
  } else {
    myCout << std::endl;
  }
 
  myCout << "    Located on chip number: " << m_algoChipNumber;
  if (m_algoChipNumber < 0) {
    myCout << "   - not properly initialized! " << std::endl;
  } else {
    myCout << std::endl;
  }
 
  myCout << "    Logical expresssion:    " << m_algoLogicalExpression << std::endl;
 
  int rpnVectorSize = m_algoRpnVector.size();
 
  myCout << "    RPN vector size:        " << rpnVectorSize;
 
  if (rpnVectorSize == 0) {
    myCout << "   - not properly initialized! " << std::endl;
  } else {
    myCout << std::endl;
 
    for (int i = 0; i < rpnVectorSize; ++i) {
      myCout << "      ( " << (m_algoRpnVector[i]).operation << ", " << (m_algoRpnVector[i]).operand << " )"
             << std::endl;
    }
  }
 
  myCout << std::endl;
}
 
// output stream operator
std::ostream& operator<<(std::ostream& os, const GlobalAlgorithm& result) {
  result.print(os);
  return os;
}