ConditionEvaluation.h

Go to the documentation of this file.

#ifndef L1Trigger_L1TGlobal_ConditionEvaluation_h
#define L1Trigger_L1TGlobal_ConditionEvaluation_h

// system include files
#include <iostream>

#include <string>
#include <vector>

#include <boost/cstdint.hpp>

// user include files

//   base class

//
#include "DataFormats/L1TGlobal/interface/GlobalObjectMapFwd.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

// forward declarations

namespace l1t {

// class interface
class ConditionEvaluation
{

public:

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


    virtual ~ConditionEvaluation(){}

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(const int bxEval) {
        m_condLastResult = evaluateCondition(bxEval);
    }

    virtual const bool evaluateCondition(const int bxEval) 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& thresholdL, const Type1& thresholdH,
        const Type2& value, bool condGEqValue) const;

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

    template<class Type1> const bool checkRangeEta(const unsigned int bitNumber, 
                           const Type1& W1beginR, const Type1& W1endR, 
                           const Type1& W2beginR, const Type1& W2endR,
                           const unsigned int nEtaBits ) const;

    template<class Type1> const bool checkRangePhi(const unsigned int bitNumber, 
                           const Type1& W1beginR, const Type1& W1endR, 
                           const Type1& W2beginR, const Type1& W2endR ) const;


    template<class Type1> const bool checkRangeDeltaEta(const unsigned int obj1Eta, const unsigned int obj2Eta, 
                            const Type1& lowerR, const Type1& upperR,
                            const unsigned int nEtaBits ) const;

    template<class Type1> const bool checkRangeDeltaPhi(const unsigned int obj1Phi, const unsigned int obj2Phi,
                            const Type1& lowerR, const Type1& upperR ) 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 ConditionEvaluation::checkThreshold(
    const Type1& thresholdL, const Type1& thresholdH, const Type2& value, const bool condGEqValue) const {

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

    if (condGEqValue) {
        if (value >= (Type2) thresholdL && (Type1) value < thresholdH) {

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

        return false;

    }
    else {

        if (value == (Type2) thresholdL ) {

            //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 ConditionEvaluation::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);
}


 template<class Type1> const bool ConditionEvaluation::checkRangeEta(const unsigned int bitNumber, 
                                     const Type1& W1beginR, const Type1& W1endR, 
                                     const Type1& W2beginR, const Type1& W2endR,
                                     const unsigned int nEtaBits) const {

  // set condtion to true if beginR==endR = default -1
  if( W1beginR==W1endR && W1beginR==(Type1)-1 ){
    return true;
  }

  unsigned int W1diff1 = W1endR - W1beginR;
  unsigned int W1diff2 = bitNumber - W1beginR;
  unsigned int W1diff3 = W1endR - bitNumber;

  bool W1cond1 = ( (W1diff1>>nEtaBits) & 1 ) ? false : true;
  bool W1cond2 = ( (W1diff2>>nEtaBits) & 1 ) ? false : true;
  bool W1cond3 = ( (W1diff3>>nEtaBits) & 1 ) ? false : true;

  // check if value is in range
  // for begin <= end takes [begin, end]
  // for begin >= end takes [begin, end] over zero angle!
  bool passWindow1 = false;
  if( W1cond1 && (W1cond2 && W1cond3 ) )      passWindow1=true;
  else if( !W1cond1 && (W1cond2 || W1cond3) ) passWindow1=true;
  else{
    passWindow1 = false;
  }



  LogDebug("l1t|Global")
    << "\n l1t::ConditionEvaluation"
    << "\n\t bitNumber = " << bitNumber
    << "\n\t W1beginR = " << W1beginR
    << "\n\t W1endR   = " << W1endR
    << "\n\t W1diff1 = " << W1diff1
    << "\n\t W1cond1 = " << W1cond1
    << "\n\t W1diff2 = " << W1diff2
    << "\n\t W1cond2 = " << W1cond2
    << "\n\t W1diff3 = " << W1diff3
    << "\n\t W1cond3 = " << W1cond3
    << "\n\t passWindow1 = " << passWindow1
    << std::endl;


  if( W2beginR==W2endR && W2beginR==(Type1)-1 ){
    return passWindow1;
  }


  unsigned int W2diff1 = W2endR - W2beginR;
  unsigned int W2diff2 = bitNumber - W2beginR;
  unsigned int W2diff3 = W2endR - bitNumber;

  bool W2cond1 = ( (W2diff1>>nEtaBits) & 1 ) ? false : true;
  bool W2cond2 = ( (W2diff2>>nEtaBits) & 1 ) ? false : true;
  bool W2cond3 = ( (W2diff3>>nEtaBits) & 1 ) ? false : true;

  bool passWindow2 = false;
  if( W2cond1 && (W2cond2 && W2cond3 ) )      passWindow2=true;
  else if( !W2cond1 && (W2cond2 || W2cond3) ) passWindow2=true;
  else{
    passWindow2 = false;
  }


  LogDebug("l1t|Global")
    << "\n\t W2beginR = " << W2beginR
    << "\n\t W2endR   = " << W2endR
    << "\n\t W2diff1 = " << W2diff1
    << "\n\t W2cond1 = " << W2cond1
    << "\n\t W2diff2 = " << W2diff2
    << "\n\t W2cond2 = " << W2cond2
    << "\n\t W2diff3 = " << W2diff3
    << "\n\t W2cond3 = " << W2cond3
    << "\n\t passWindow2 = " << passWindow2
    << "\n\t pass W1 || W2 = " << (passWindow1 || passWindow2)
    << std::endl;

  if( passWindow1 || passWindow2 ){
    return true;
  }
  else{
    return false;
  }

 }



template<class Type1> const bool ConditionEvaluation::checkRangePhi(const unsigned int bitNumber, 
                                    const Type1& W1beginR, const Type1& W1endR, 
                                    const Type1& W2beginR, const Type1& W2endR ) const {

  // set condtion to true if beginR==endR = default -1
  if( W1beginR==W1endR && W1beginR==(Type1)-1 ){
    return true;
  }

  int W1diff1 = W1endR - W1beginR;
  int W1diff2 = bitNumber - W1beginR;
  int W1diff3 = W1endR - bitNumber;

  bool W1cond1 = ( W1diff1<0 ) ? false : true;
  bool W1cond2 = ( W1diff2<0 ) ? false : true;
  bool W1cond3 = ( W1diff3<0 ) ? false : true;

  // check if value is in range
  // for begin <= end takes [begin, end]
  // for begin >= end takes [begin, end] over zero angle!
  bool passWindow1 = false;
  if( W1cond1 && (W1cond2 && W1cond3 ) )      passWindow1=true;
  else if( !W1cond1 && (W1cond2 || W1cond3) ) passWindow1=true;
  else{
    passWindow1 = false;
  }

  LogDebug("l1t|Global")
    << "\n l1t::ConditionEvaluation"
    << "\n\t bitNumber = " << bitNumber
    << "\n\t W1beginR = " << W1beginR
    << "\n\t W1endR   = " << W1endR
    << "\n\t W1diff1 = " << W1diff1
    << "\n\t W1cond1 = " << W1cond1
    << "\n\t W1diff2 = " << W1diff2
    << "\n\t W1cond2 = " << W1cond2
    << "\n\t W1diff3 = " << W1diff3
    << "\n\t W1cond3 = " << W1cond3
    << std::endl;



  if( W2beginR==W2endR && W2beginR==(Type1)-1 ){
    return passWindow1;
  }


  int W2diff1 = W2endR - W2beginR;
  int W2diff2 = bitNumber - W2beginR;
  int W2diff3 = W2endR - bitNumber;

  bool W2cond1 = ( W2diff1<0 ) ? false : true;
  bool W2cond2 = ( W2diff2<0 ) ? false : true;
  bool W2cond3 = ( W2diff3<0 ) ? false : true;

  // check if value is in range
  // for begin <= end takes [begin, end]
  // for begin >= end takes [begin, end] over zero angle!
  bool passWindow2 = false;
  if( W2cond1 && (W2cond2 && W2cond3 ) )      passWindow2=true;
  else if( !W2cond1 && (W2cond2 || W2cond3) ) passWindow2=true;
  else{
    passWindow2 = false;
  }


  if( passWindow1 || passWindow2 ){
    return true;
  }
  else{
    return false;
  }


 }

 template<class Type1> const bool ConditionEvaluation::checkRangeDeltaEta(const unsigned int obj1Eta, const unsigned int obj2Eta, 
                                      const Type1& lowerR, const Type1& upperR,
                                      const unsigned int nEtaBits )  const {

/*   // set condtion to true if beginR==endR = default -1 */
/*   if( beginR==endR && beginR==-1 ){ */
/*     return true; */
/*   } */

  unsigned int compare = obj1Eta - obj2Eta;
  bool cond = ( (compare>>nEtaBits) & 1 ) ? false : true;

  unsigned int larger, smaller;
  if( cond ){
    larger = obj1Eta;
    smaller= obj2Eta;
  }
  else{
    larger = obj2Eta;
    smaller= obj1Eta;
  }

  unsigned int diff = ( ( larger + ((~smaller + 1) & 255) ) & 255);

  unsigned int diff1 = upperR - lowerR;
  unsigned int diff2 = diff - lowerR;
  unsigned int diff3 = upperR - diff;

  bool cond1 = ( (diff1>>nEtaBits) & 1 ) ? false : true;
  bool cond2 = ( (diff2>>nEtaBits) & 1 ) ? false : true;
  bool cond3 = ( (diff3>>nEtaBits) & 1 ) ? false : true;

  LogDebug("l1t|Global")
    << "\n l1t::ConditionEvaluation"
    << "\n\t obj1Eta = " << obj1Eta
    << "\n\t obj2Eta = " << obj2Eta
    << "\n\t lowerR = " << lowerR
    << "\n\t upperR = " << upperR
    << "\n\t compare = " << compare
    << "\n\t cond = " << cond
    << "\n\t diff = " << diff
    << "\n\t diff1 = " << diff1
    << "\n\t cond1 = " << cond1
    << "\n\t diff2 = " << diff2
    << "\n\t cond2 = " << cond2
    << "\n\t diff3 = " << diff3
    << "\n\t cond3 = " << cond3
    << std::endl;

  if( cond1 && (cond2 && cond3 ) )      return true;
  else if( !cond1 && (cond2 || cond3) ) return true;
  else{
    return false;
  }

 }



template<class Type1> const bool ConditionEvaluation::checkRangeDeltaPhi(const unsigned int obj1Phi, const unsigned int obj2Phi, 
                                          const Type1& lowerR, const Type1& upperR )  const {

  int deltaPhi = abs(obj1Phi-obj2Phi);
  if( deltaPhi>71 ) deltaPhi = 143 - deltaPhi + 1; // Add +1 if the calculation is over 0

  int diff1 = upperR - lowerR;
  int diff2 = deltaPhi - lowerR;
  int diff3 = upperR - deltaPhi;

  bool cond1 = ( diff1<0 ) ? false : true;
  bool cond2 = ( diff2<0 ) ? false : true;
  bool cond3 = ( diff3<0 ) ? false : true;

  LogDebug("l1t|Global")
    << "\n l1t::ConditionEvaluation"
    << "\n\t obj1Phi = " << obj1Phi
    << "\n\t obj2Phi = " << obj2Phi
    << "\n\t deltaPhi = " << deltaPhi
    << "\n\t lowerR = " << lowerR
    << "\n\t upperR = " << upperR
    << "\n\t diff1 = " << diff1
    << "\n\t cond1 = " << cond1
    << "\n\t diff2 = " << diff2
    << "\n\t cond2 = " << cond2
    << "\n\t diff3 = " << diff3
    << "\n\t cond3 = " << cond3
    << std::endl;

  // check if value is in range
  // for begin <= end takes [begin, end]
  // for begin >= end takes [begin, end] over zero angle!
  if( cond1 && (cond2 && cond3 ) )      return true;
  else if( !cond1 && (cond2 || cond3) ) return true;
  else{
    return false;
  }

 }


}
#endif