l1t::AlgorithmEvaluation Class Reference

#include <AlgorithmEvaluation.h>

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

Public Member Functions
	AlgorithmEvaluation (const L1GtAlgorithm &)
	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 < L1GtLogicParser::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 73 of file AlgorithmEvaluation.h.

Member Typedef Documentation

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

Definition at line 95 of file AlgorithmEvaluation.h.

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

copy constructor

destructor

Definition at line 94 of file AlgorithmEvaluation.h.

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

Definition at line 96 of file AlgorithmEvaluation.h.

typedef L1GtLogicParser::OperandToken l1t::AlgorithmEvaluation::OperandToken

Definition at line 78 of file AlgorithmEvaluation.h.

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

Definition at line 77 of file AlgorithmEvaluation.h.

typedef L1GtLogicParser::TokenRPN l1t::AlgorithmEvaluation::TokenRPN

Definition at line 76 of file AlgorithmEvaluation.h.

Constructor & Destructor Documentation

AlgorithmEvaluation::AlgorithmEvaluation ( const L1GtAlgorithm &  alg )

explicit

constructor

constructor from an algorithm from event setup

Definition at line 45 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

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

evaluate an algorithm

Definition at line 58 of file AlgorithmEvaluation.cc.

References Exception, spr::find(), L1GtLogicParser::OP_AND, L1GtLogicParser::OP_NOT, L1GtLogicParser::OP_OPERAND, L1GtLogicParser::OP_OR, L1GtLogicParser::OperandToken::tokenName, L1GtLogicParser::OperandToken::tokenNumber, and L1GtLogicParser::OperandToken::tokenResult.

Referenced by l1t::GtBoard::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
    // FIXME we shall find a better solution than static
    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("l1t|Global")
        //<< "\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 (0 == 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
    while(!resultStack.empty()) resultStack.pop();

}

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

inline

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

Definition at line 115 of file AlgorithmEvaluation.h.

References m_algoCombinationVector.

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

                                                                     {
        return m_algoCombinationVector;
    }

bool l1t::AlgorithmEvaluation::gtAlgoResult ( ) const

inline

get / set the result of the algorithm

Definition at line 101 of file AlgorithmEvaluation.h.

References m_algoResult.

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

                                     {
        return m_algoResult;
    }

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

inline

Definition at line 119 of file AlgorithmEvaluation.h.

References m_operandTokenVector.

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

                                                                        {
        return m_operandTokenVector;
    }

void AlgorithmEvaluation::print

(

std::ostream &

myCout

)

const

Definition at line 184 of file AlgorithmEvaluation.cc.

References i.

Referenced by l1t::GtBoard::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;
}

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

inline

Definition at line 105 of file AlgorithmEvaluation.h.

References m_algoResult.

                                                       {
        m_algoResult = algoResult;
    }

Member Data Documentation

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

private

Definition at line 136 of file AlgorithmEvaluation.h.

Referenced by gtAlgoCombinationVector().

bool l1t::AlgorithmEvaluation::m_algoResult

private

algorithm result

Definition at line 128 of file AlgorithmEvaluation.h.

Referenced by gtAlgoResult(), and setGtAlgoResult().

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

private

Definition at line 131 of file AlgorithmEvaluation.h.

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

private

Definition at line 134 of file AlgorithmEvaluation.h.

Referenced by operandTokenVector().

RpnVector const& l1t::AlgorithmEvaluation::m_rpnVector

private

Definition at line 132 of file AlgorithmEvaluation.h.