AlgorithmEvaluation.h

Go to the documentation of this file.

#ifndef GlobalTrigger_AlgorithmEvaluation_h
#define GlobalTrigger_AlgorithmEvaluation_h

// work-around for missing dependency - force checkout...

//   for L1GtLogicParser
#include "DataFormats/L1GlobalTrigger/interface/L1GtLogicParser.h"

// system include files
#include <iostream>

#include <string>
#include <vector>
#include <map>
#include <stack>
#include <queue>

#include <boost/cstdint.hpp>

// if hash map is used

#include <ext/hash_map>
#include "L1Trigger/GlobalTrigger/interface/L1GtAlgorithmEvaluation.h"

//   how to hash std::string, using a "template specialization"
// DMP Comment out for not to prevent conflicts
/* namespace __gnu_cxx { */

/*     /\** */
/*      Explicit template specialization of hash of a string class, */
/*      which just uses the internal char* representation as a wrapper. */
/*      *\/ */
/*     template<> struct hash<std::string> { */
/*         size_t operator()(const std::string& x) const { */
/*             return hash<const char*> ()(x.c_str()); */
/*         } */
/*     }; */

/* } */
// end hash map


// user include files

//   base class
#include "DataFormats/L1GlobalTrigger/interface/L1GtLogicParser.h"

//
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapFwd.h"

// forward declarations
class L1GtAlgorithm;

namespace l1t {

class ConditionEvaluation;

// class interface
class AlgorithmEvaluation {

public:
    typedef L1GtLogicParser::TokenRPN TokenRPN;
    typedef std::vector<TokenRPN> RpnVector;
    typedef L1GtLogicParser::OperandToken OperandToken;

    //  AlgorithmEvaluation();

    explicit AlgorithmEvaluation(const L1GtAlgorithm&);

    // AlgorithmEvaluation(AlgorithmEvaluation&);

    // virtual ~AlgorithmEvaluation();

    //typedef std::map<std::string, ConditionEvaluation*> ConditionEvaluationMap;
    typedef __gnu_cxx ::hash_map<std::string, ConditionEvaluation*>
            ConditionEvaluationMap;
    typedef ConditionEvaluationMap::const_iterator CItEvalMap;
    typedef ConditionEvaluationMap::iterator ItEvalMap;

public:

    inline bool gtAlgoResult() const {
        return m_algoResult;
    }

    inline void setGtAlgoResult(const bool algoResult) {
        m_algoResult = algoResult;
    }

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

    inline std::vector<CombinationsInCond> & gtAlgoCombinationVector() {
        return m_algoCombinationVector;
    }

    inline std::vector<L1GtLogicParser::OperandToken>& operandTokenVector() {
        return m_operandTokenVector;
    }

    void print(std::ostream& myCout) const;

private:

    bool m_algoResult;

    // input
    std::string const & m_logicalExpression;
    RpnVector const & m_rpnVector;

    std::vector<OperandToken> m_operandTokenVector;

    std::vector<CombinationsInCond> m_algoCombinationVector;

};

}
#endif