l1t::AlgorithmEvaluation Class Reference

#include <AlgorithmEvaluation.h>

Public Types
typedef ConditionEvaluationMap::const_iterator	CItEvalMap
typedef std::unordered_map< std::string, ConditionEvaluation * >	ConditionEvaluationMap
	copy constructor More...
typedef ConditionEvaluationMap::iterator	ItEvalMap
typedef GlobalLogicParser::OperandToken	OperandToken
typedef std::vector< TokenRPN >	RpnVector
typedef GlobalLogicParser::TokenRPN	TokenRPN

Public Member Functions
	AlgorithmEvaluation (const GlobalAlgorithm &)
	constructor More...
void	evaluateAlgorithm (const int chipNumber, const std::vector< ConditionEvaluationMap > &)
	evaluate an algorithm More...
std::vector< CombinationsInCond > &	gtAlgoCombinationVector ()
bool	gtAlgoResult () const
	get / set the result of the algorithm More...
std::vector< GlobalLogicParser::OperandToken > &	operandTokenVector ()
void	print (std::ostream &myCout) const
void	setGtAlgoResult (const bool algoResult)

Private Attributes
std::vector< CombinationsInCond >	m_algoCombinationVector
bool	m_algoResult
	algorithm result More...
std::string const &	m_logicalExpression
std::vector< OperandToken >	m_operandTokenVector
RpnVector const &	m_rpnVector

Detailed Description

Definition at line 39 of file AlgorithmEvaluation.h.

Member Typedef Documentation

CItEvalMap

typedef ConditionEvaluationMap::const_iterator l1t::AlgorithmEvaluation::CItEvalMap

Definition at line 59 of file AlgorithmEvaluation.h.

ConditionEvaluationMap

typedef std::unordered_map<std::string, ConditionEvaluation*> l1t::AlgorithmEvaluation::ConditionEvaluationMap

copy constructor

destructor

Definition at line 58 of file AlgorithmEvaluation.h.

ItEvalMap

typedef ConditionEvaluationMap::iterator l1t::AlgorithmEvaluation::ItEvalMap

Definition at line 60 of file AlgorithmEvaluation.h.

OperandToken

typedef GlobalLogicParser::OperandToken l1t::AlgorithmEvaluation::OperandToken

Definition at line 43 of file AlgorithmEvaluation.h.

RpnVector

typedef std::vector<TokenRPN> l1t::AlgorithmEvaluation::RpnVector

Definition at line 42 of file AlgorithmEvaluation.h.

TokenRPN

typedef GlobalLogicParser::TokenRPN l1t::AlgorithmEvaluation::TokenRPN

Definition at line 41 of file AlgorithmEvaluation.h.

Constructor & Destructor Documentation

AlgorithmEvaluation()

AlgorithmEvaluation::AlgorithmEvaluation ( const GlobalAlgorithm &  alg )

explicit

constructor

constructor from an algorithm from event setup

Definition at line 39 of file AlgorithmEvaluation.cc.

    : m_algoResult(false), m_logicalExpression(alg.algoLogicalExpression()), m_rpnVector(alg.algoRpnVector()) {
  // the rest is properly initialized by default
}

Member Function Documentation

evaluateAlgorithm()

void AlgorithmEvaluation::evaluateAlgorithm	(	const int	chipNumber,
		const std::vector< ConditionEvaluationMap > &	conditionResultMaps
	)

evaluate an algorithm

Definition at line 47 of file AlgorithmEvaluation.cc.

References b1, b2, Exception, spr::find(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, GlobalLogicParser::OP_AND, GlobalLogicParser::OP_NOT, GlobalLogicParser::OP_OPERAND, GlobalLogicParser::OP_OR, GlobalLogicParser::OP_XOR, GlobalLogicParser::OperandToken::tokenName, GlobalLogicParser::OperandToken::tokenNumber, and GlobalLogicParser::OperandToken::tokenResult.

Referenced by l1t::GlobalBoard::runGTL().

                                                                                                               {
  // set result to false if there is no expression
  if (m_rpnVector.empty()) {
    m_algoResult = false;

    // it should never be happen
    throw cms::Exception("FailModule") << "\nEmpty RPN vector for the logical expression = " << m_logicalExpression
                                       << std::endl;
  }

  // reserve memory
  int rpnVectorSize = m_rpnVector.size();

  m_algoCombinationVector.reserve(rpnVectorSize);
  m_operandTokenVector.reserve(rpnVectorSize);

  // stack containing temporary results
  std::stack<bool, std::vector<bool> > resultStack;
  bool b1, b2;

  int opNumber = 0;

  for (RpnVector::const_iterator it = m_rpnVector.begin(); it != m_rpnVector.end(); it++) {
    //LogTrace("L1TGlobal")
    //<< "\nit->operation = " << it->operation
    //<< "\nit->operand =   '" << it->operand << "'\n"
    //<< std::endl;

    switch (it->operation) {
      case GlobalLogicParser::OP_OPERAND: {
        CItEvalMap itCond = (conditionResultMaps.at(chipNumber)).find(it->operand);
        if (itCond != (conditionResultMaps[chipNumber]).end()) {
          if (nullptr == itCond->second) {
            // it should never be happen, only valid conditions are in the maps
            throw cms::Exception("FailModule")
                << "\nCondition " << (it->operand) << " NULL pointer found in condition map" << std::endl;
          }

          //
          bool condResult = (itCond->second)->condLastResult();

          resultStack.push(condResult);

          // only conditions are added to /counted in m_operandTokenVector
          // opNumber is the index of the condition in the logical expression
          OperandToken opToken;
          opToken.tokenName = it->operand;
          opToken.tokenNumber = opNumber;
          opToken.tokenResult = condResult;

          m_operandTokenVector.push_back(opToken);
          opNumber++;

          //
          CombinationsInCond const& combInCondition = (itCond->second)->getCombinationsInCond();
          m_algoCombinationVector.push_back(combInCondition);

        } else {
          // it should never be happen, all conditions are in the maps
          throw cms::Exception("FailModule")
              << "\nCondition " << (it->operand) << " not found in condition map" << std::endl;
        }

      }

      break;
      case GlobalLogicParser::OP_NOT: {
        b1 = resultStack.top();
        resultStack.pop();      // pop the top
        resultStack.push(!b1);  // and push the result
      }

      break;
      case GlobalLogicParser::OP_OR: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 || b2);
      }

      break;
      case GlobalLogicParser::OP_AND: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 && b2);
      }

      break;
      case GlobalLogicParser::OP_XOR: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 ^ b2);
      }

      break;
      default: {
        // should not arrive here
      }

      break;
    }
  }

  // get the result in the top of the stack
  m_algoResult = resultStack.top();
}

gtAlgoCombinationVector()

std::vector<CombinationsInCond>& l1t::AlgorithmEvaluation::gtAlgoCombinationVector ( )

inline

get all the object combinations evaluated to true in the conditions from the algorithm

Definition at line 73 of file AlgorithmEvaluation.h.

References m_algoCombinationVector.

Referenced by l1t::GlobalBoard::runGTL().

{ return m_algoCombinationVector; }

gtAlgoResult()

bool l1t::AlgorithmEvaluation::gtAlgoResult ( ) const

inline

get / set the result of the algorithm

Definition at line 64 of file AlgorithmEvaluation.h.

References m_algoResult.

Referenced by l1t::GlobalBoard::runGTL().

{ return m_algoResult; }

operandTokenVector()

std::vector<GlobalLogicParser::OperandToken>& l1t::AlgorithmEvaluation::operandTokenVector ( )

inline

Definition at line 75 of file AlgorithmEvaluation.h.

References m_operandTokenVector.

Referenced by l1t::GlobalBoard::runGTL().

{ return m_operandTokenVector; }

print()

void AlgorithmEvaluation::print

(

std::ostream &

myCout

)

const

Definition at line 161 of file AlgorithmEvaluation.cc.

References mps_fire::i.

Referenced by l1t::GlobalBoard::runGTL().

                                                           {
  myCout << std::endl;

  myCout << "    Algorithm result:          " << m_algoResult << std::endl;

  myCout << "    CombinationVector size:    " << m_algoCombinationVector.size() << std::endl;

  int operandTokenVectorSize = m_operandTokenVector.size();

  myCout << "    Operand token vector size: " << operandTokenVectorSize;

  if (operandTokenVectorSize == 0) {
    myCout << "   - not properly initialized! " << std::endl;
  } else {
    myCout << std::endl;

    for (int i = 0; i < operandTokenVectorSize; ++i) {
      myCout << "      " << std::setw(5) << (m_operandTokenVector[i]).tokenNumber << "\t" << std::setw(25)
             << (m_operandTokenVector[i]).tokenName << "\t" << (m_operandTokenVector[i]).tokenResult << std::endl;
    }
  }

  myCout << std::endl;
}

setGtAlgoResult()

void l1t::AlgorithmEvaluation::setGtAlgoResult ( const bool  algoResult )

inline

Definition at line 66 of file AlgorithmEvaluation.h.

References m_algoResult.

{ m_algoResult = algoResult; }

Member Data Documentation

m_algoCombinationVector

std::vector<CombinationsInCond> l1t::AlgorithmEvaluation::m_algoCombinationVector

private

Definition at line 89 of file AlgorithmEvaluation.h.

Referenced by gtAlgoCombinationVector().

m_algoResult

bool l1t::AlgorithmEvaluation::m_algoResult

private

algorithm result

Definition at line 81 of file AlgorithmEvaluation.h.

Referenced by gtAlgoResult(), and setGtAlgoResult().

m_logicalExpression

std::string const& l1t::AlgorithmEvaluation::m_logicalExpression

private

Definition at line 84 of file AlgorithmEvaluation.h.

m_operandTokenVector

std::vector<OperandToken> l1t::AlgorithmEvaluation::m_operandTokenVector

private

Definition at line 87 of file AlgorithmEvaluation.h.

Referenced by operandTokenVector().

m_rpnVector

RpnVector const& l1t::AlgorithmEvaluation::m_rpnVector

private

Definition at line 85 of file AlgorithmEvaluation.h.