L1METvalue.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
/***************************************************************************
                          L1METvalue.cxx  -  description
                             -------------------
    begin                : 19-10-2007
    email                : Alan.Watson@cern.ch
 
    A simple set of functions to calculate ETmiss at the precision available
    in the L1 thresholding logic (depending on values of Ex & Ey).
 
    Because of the way the thresholding logic works, Ex or Ey values outside
    the defined range will simply cause all thresholds to be set (irrespective
    of values). In this case there is no "correct" ETmiss value to return, and
    so we (a) return a boolean flag to indicate that overflow has occurred,
    and (b) set the returned ETmiss value to 1 TeV (outside the threshold
    range). The flag should however always be checked before using the ETmiss
    value.
 ***************************************************************************/
 
#include "TrigT1Interfaces/L1METvalue.h"
#include <cmath>
 
namespace LVL1 {
 
 
void LVL1::L1METvalue::calcL1METQ(int Ex, int Ey, int& METQ, bool& Overflow) {
 
  unsigned int absEx = std::abs(Ex);
  unsigned int absEy = std::abs(Ey);
  int max = (absEx > absEy ? absEx : absEy);
 
  if ( max >= (1<<(m_nBits+m_nRanges-1)) )  {
    METQ = 16777216; // 4096**2
    Overflow = true;
  }
  else {
    for (unsigned int range = 0; range < m_nRanges; ++range) {
      if ( max < (1<<(m_nBits+range)) ) {
        absEx &= (m_mask<<range);
        absEy &= (m_mask<<range);
        break;
      }
    }
    METQ = absEx*absEx + absEy*absEy;
    Overflow = false;
  }
   
}
 
void LVL1::L1METvalue::calcL1MET(int Ex, int Ey, float& MET, bool& Overflow) {
  int METQ;
  calcL1METQ(Ex, Ey, METQ, Overflow);
  MET = sqrt(static_cast<float>(METQ));
}
 
void LVL1::L1METvalue::calcL1MET(int Ex, int Ey, int& MET, unsigned int& Range, bool& Overflow) {
  
  unsigned int absEx = std::abs(Ex);
  unsigned int absEy = std::abs(Ey);
  int max = (absEx > absEy ? absEx : absEy);
 
  if ( max >= (1<<(m_nBits+m_nRanges-1)) )  {
    MET = m_rangeMask + m_valueMask; // 7 bit ET + 2 bit range, all bits set
    Overflow = true;
  }
  else {
    Range = 0;
    for (unsigned int range = 0; range < m_nRanges; ++range) {
      if ( max < (1<<(m_nBits+range)) ) {
        absEx &= (m_mask<<range);
        absEy &= (m_mask<<range);
        Range = range;
        break;
      }
    }
    // Shift Ex/Ey values to lowest 6 bits
    absEx = (absEx >> Range);
    absEy = (absEy >> Range);
    // Calculate 7 bit MET value, rounded up to the ceiling 
    int METQ = absEx*absEx + absEy*absEy;
    MET = ceil(sqrt(static_cast<float>(METQ)));
    Overflow = false;
  }
 
}
 
void LVL1::L1METvalue::calcL1METSig(int Ex, int Ey, int SumET, float a, float b, int XEmin, int XEmax, int sqrtTEmin, int sqrtTEmax,
                                    float& XS, int& OutOfRange) {
  
  bool overflow = false;
  int MET = 0;
  unsigned int Range = 0;
  calcL1MET(Ex, Ey, MET, Range, overflow);
  
  calcL1METSig(MET, Range, SumET, a, b, XEmin, XEmax, sqrtTEmin, sqrtTEmax, XS, OutOfRange);
  
}
 
void LVL1::L1METvalue::calcL1METSig(int MET, unsigned int Range, int SumET, float a, float b, int XEmin, int XEmax, int sqrtTEmin, int sqrtTEmax,
                                    float& XS, int& OutOfRange) {
 
  XS = -1.;
  OutOfRange = 0;
    
  if (XEmax > m_xsXEmax)          XEmax     = m_xsXEmax;
  if (sqrtTEmax > m_xsSqrtTEmax)  sqrtTEmax = m_xsSqrtTEmax;
  
  int XE = (MET<<Range);
  
  if (XE > m_xsXEmax) XE = m_xsXEmax;
 
  if (XE >= XEmax) {
    XS = 9999.;
    OutOfRange = 1;
    return;
  }
 
  if (SumET < 0) {
     OutOfRange = -1;
     return;
  }
  
  int sqrtSumET = sqrt(SumET);
  if (sqrtSumET > m_xsSqrtTEmax) sqrtSumET = m_xsSqrtTEmax;
 
  if (XE < XEmin || sqrtSumET >= sqrtTEmax || sqrtSumET < sqrtTEmin) {
    //XS = 0.;
    OutOfRange = -1;
  }
  else { 
    OutOfRange = 0;
    if (sqrtSumET > b) XS = float(XE)/(a*(sqrtSumET-b));
  }
 
}
 
} // end of namespace bracket