L1GtAlgorithmEvaluation.cc

Go to the documentation of this file.

 
// this class header
#include "L1Trigger/GlobalTrigger/interface/L1GtAlgorithmEvaluation.h"
 
// system include files
#include <string>
 
#include <queue>
#include <stack>
#include <vector>
 
#include <iomanip>
#include <iostream>
 
#include <boost/algorithm/string.hpp>
#include <ext/hash_map>
 
// user include files
 
//
#include "CondFormats/L1TObjects/interface/L1GtAlgorithm.h"
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapFwd.h"
 
#include "L1Trigger/GlobalTrigger/interface/L1GtConditionEvaluation.h"
 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"
 
L1GtAlgorithmEvaluation::L1GtAlgorithmEvaluation(const L1GtAlgorithm &alg)
    : m_algoResult(false), m_logicalExpression(alg.algoLogicalExpression()), m_rpnVector(alg.algoRpnVector()) {
  // the rest is properly initialized by default
}
 
// methods
 
void L1GtAlgorithmEvaluation::evaluateAlgorithm(const int chipNumber,
                                                const std::vector<ConditionEvaluationMap> &conditionResultMaps) {
  // 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
  // FIXME we shall find a better solution than static
  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("L1GlobalTrigger")
    //<< "\nit->operation = " << it->operation
    //<< "\nit->operand =   '" << it->operand << "'\n"
    //<< std::endl;
 
    switch (it->operation) {
      case L1GtLogicParser::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 L1GtLogicParser::OP_NOT: {
        b1 = resultStack.top();
        resultStack.pop();      // pop the top
        resultStack.push(!b1);  // and push the result
      }
 
      break;
      case L1GtLogicParser::OP_OR: {
        b1 = resultStack.top();
        resultStack.pop();
        b2 = resultStack.top();
        resultStack.pop();
        resultStack.push(b1 || b2);
      }
 
      break;
      case L1GtLogicParser::OP_AND: {
        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();
 
  // clear resultStack not needed since it is now a function temporary
}
 
// print algorithm evaluation
void L1GtAlgorithmEvaluation::print(std::ostream &myCout) const {
  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;
}