/data/refman/pasoursint/CMSSW_6_1_2_SLHC2_patch1/src/L1Trigger/GlobalTrigger/interface/L1GtConditionEvaluation.h

Go to the documentation of this file.

#ifndef GlobalTrigger_L1GtConditionEvaluation_h
#define GlobalTrigger_L1GtConditionEvaluation_h

// system include files
#include <iostream>

#include <string>
#include <vector>

#include <boost/cstdint.hpp>

// user include files

//   base class

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

// forward declarations

// class interface
class L1GtConditionEvaluation
{

public:

    L1GtConditionEvaluation()  :
    m_condMaxNumberObjects(0),
    m_condLastResult(false),
    m_verbosity(0) {}


  virtual ~L1GtConditionEvaluation(){}

public:

    inline int condMaxNumberObjects() const {
        return m_condMaxNumberObjects;
    }

    inline void setCondMaxNumberObjects(int condMaxNumberObjectsValue) {
        m_condMaxNumberObjects = condMaxNumberObjectsValue;
    }

    inline bool condLastResult() const {
        return m_condLastResult;
    }

    inline void evaluateConditionStoreResult() {
        m_condLastResult = evaluateCondition();
    }

    virtual const bool evaluateCondition() const = 0;

    virtual std::string getNumericExpression() const {
        if (m_condLastResult) {
            return "1";
        }
        else {
            return "0";
        }
    }

    inline CombinationsInCond const & getCombinationsInCond() const {
        return m_combinationsInCond;
    }


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

    inline void setVerbosity(const int verbosity) {
        m_verbosity = verbosity;
    }

protected:

    inline CombinationsInCond& combinationsInCond() const {
        return m_combinationsInCond;
    }

    template<class Type1, class Type2> const bool checkThreshold(const Type1& threshold,
        const Type2& value, const bool condGEqValue) const;

    template<class Type1> const bool checkBit(const Type1& mask, const unsigned int bitNumber) const;

protected:

    int m_condMaxNumberObjects;

    bool m_condLastResult;

    mutable CombinationsInCond m_combinationsInCond;

    int m_verbosity;

};

// define templated methods

// check if a value is greater than a threshold or
// greater-or-equal depending on the value of the condGEqValue flag
template<class Type1, class Type2> const bool L1GtConditionEvaluation::checkThreshold(
    const Type1& threshold, const Type2& value, const bool condGEqValue) const {

    //if (value > 0) {
    //    LogTrace("L1GlobalTrigger") << "  threshold check for condGEqValue = "
    //        << condGEqValue << "\n    hex: " << std::hex << "threshold = " << threshold
    //        << " value = " << value << "\n    dec: " << std::dec << "threshold = " << threshold
    //        << " value = " << value << std::endl;
    //}

    if (condGEqValue) {
        if (value >= threshold) {

            //LogTrace("L1GlobalTrigger") << "    condGEqValue: value >= threshold"
            //    << std::endl;

            return true;
        }

        return false;

    }
    else {

        if (value == threshold) {

            //LogTrace("L1GlobalTrigger") << "    condGEqValue: value = threshold"
            //    << std::endl;

            return true;
        }

        return false;
    }
}

// check if a bit with a given number is set in a mask
template<class Type1> const bool L1GtConditionEvaluation::checkBit(const Type1& mask,
    const unsigned int bitNumber) const {

    boost::uint64_t oneBit = 1ULL;

    if (bitNumber >= (sizeof(oneBit)*8)) {

        if (m_verbosity) {

            LogTrace("L1GlobalTrigger")
                << "    checkBit " << "\n     Bit number = "
                << bitNumber << " larger than maximum allowed " << sizeof ( oneBit ) * 8
                << std::endl;
        }

        return false;
    }

    oneBit <<= bitNumber;

    //LogTrace("L1GlobalTrigger") << "    checkBit " << "\n     mask address = " << &mask
    //    << std::dec << "\n     dec: " << "mask = " << mask << " oneBit = " << oneBit
    //    << " bitNumber = " << bitNumber << std::hex << "\n     hex: " << "mask = " << mask
    //    << " oneBit = " << oneBit << " bitNumber = " << bitNumber << std::dec
    //    << "\n     mask & oneBit result = " << bool ( mask & oneBit ) << std::endl;

    return (mask & oneBit);
}

#endif