L1METvalue encoding is used for transmission of ET/Ex/Ey sums from JEM to CMM. More...

#include <L1METvalue.h>

Collaboration diagram for LVL1::L1METvalue:

Public Member Functions
void	calcL1MET (int Ex, int Ey, int &MET, unsigned int &Range, bool &Overflow)
	Return MET value as output by MET LUT (7 bit value + 2 bit range) More...

void	calcL1MET (int Ex, int Ey, float &MET, bool &Overflow)
	Return MET value at floating point precision used in threshold calculation. More...

void	calcL1METQ (int Ex, int Ey, int &METQ, bool &Overflow)
	Return MET**2 value at precision used in threshold calculation. More...

void	calcL1METSig (int Ex, int Ey, int SumET, float a, float b, int XEmin, int XEmax, int sqrtTEmin, int sqrtTEmax, float &XS, int &OutOfRange)
	Return MET value at floating point precision used in threshold calculation. More...

void	calcL1METSig (int MET, unsigned int Range, int SumET, float a, float b, int XEmin, int XEmax, int sqrtTEmin, int sqrtTEmax, float &XS, int &OutOfRange)

Static Private Attributes
static const unsigned int	m_nBits = 6
	Number of bits in range. More...

static const unsigned int	m_nRanges = 4
	Number of ET ranges to encode in. More...

static const unsigned int	m_mask = 0x3F
	Mask to select Ex/Ey bits. More...

static const unsigned int	m_valueMask = 0x7F
	Masks for integer MET word setting. More...

static const unsigned int	m_rangeMask = 0x180

static const int	m_xsXEmax = 127
	Limits on inputs to XS LUT. More...

static const int	m_xsSqrtTEmax = 63

Detailed Description

L1METvalue encoding is used for transmission of ET/Ex/Ey sums from JEM to CMM.

This class compresses/uncompresses 8 bit ET (JEM energy sums) to/from quad linear scale

Todo:: this should probably be a static class.

Definition at line 26 of file L1METvalue.h.

Member Function Documentation

◆ calcL1MET() [1/2]

void LVL1::L1METvalue::calcL1MET	(	int	Ex,
		int	Ey,
		float &	MET,
		bool &	Overflow
	)

Return MET value at floating point precision used in threshold calculation.

Definition at line 73 of file L1METvalue.cxx.

78 {

◆ calcL1MET() [2/2]

void LVL1::L1METvalue::calcL1MET	(	int	Ex,
		int	Ey,
		int &	MET,
		unsigned int &	Range,
		bool &	Overflow
	)

Return MET value as output by MET LUT (7 bit value + 2 bit range)

Greater of 2 values determines range of bits used

If Ex/Ey overflows the LUT input range, trigger fires all thresholds. Indicate this with overflow flag and an out of range ETmiss value

Otherwise, emulate precision by checking which ET range we are in and zeroing bits below that.

Definition at line 79 of file L1METvalue.cxx.

                                                              {
       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,

◆ calcL1METQ()

void LVL1::L1METvalue::calcL1METQ	(	int	Ex,
		int	Ey,
		int &	METQ,
		bool &	Overflow
	)

Return MET**2 value at precision used in threshold calculation.

Greater of 2 values determines range of bits used

If Ex/Ey overflows the LUT input range, trigger fires all thresholds. Indicate this with overflow flag and an out of range ETmiss value

Otherwise, emulate precision by checking which ET range we are in and zeroing bits below that.

Definition at line 44 of file L1METvalue.cxx.

                                                              {
       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);
  

◆ calcL1METSig() [1/2]

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
	)

Return MET value at floating point precision used in threshold calculation.

Calculate MET value with correct precision and format

Use that plus provided SumET and coefficients to calculate METSig

Definition at line 115 of file L1METvalue.cxx.

131 {

◆ calcL1METSig() [2/2]

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
	)

Initialise default values

Impose firmware limitations on specified ranges

Convert MET value to single linear scale

Impose hardware limits on MET input to LUT

MET overflow check takes precedence over all other conditions

Protection against invalid input (can never happen in reality, but this is software)

Calculate sqrt(SumET) with integer precision & hardware limits

If in range, calculate XS

Definition at line 129 of file L1METvalue.cxx.

                    {
     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

Member Data Documentation

◆ m_mask

const unsigned int LVL1::L1METvalue::m_mask = 0x3F

staticprivate

Mask to select Ex/Ey bits.

Definition at line 54 of file L1METvalue.h.

◆ m_nBits

const unsigned int LVL1::L1METvalue::m_nBits = 6

staticprivate

Number of bits in range.

Definition at line 50 of file L1METvalue.h.

◆ m_nRanges

const unsigned int LVL1::L1METvalue::m_nRanges = 4

staticprivate

Number of ET ranges to encode in.

Definition at line 52 of file L1METvalue.h.

◆ m_rangeMask

const unsigned int LVL1::L1METvalue::m_rangeMask = 0x180

staticprivate

Definition at line 57 of file L1METvalue.h.

◆ m_valueMask

const unsigned int LVL1::L1METvalue::m_valueMask = 0x7F

staticprivate

Masks for integer MET word setting.

Definition at line 56 of file L1METvalue.h.

◆ m_xsSqrtTEmax

const int LVL1::L1METvalue::m_xsSqrtTEmax = 63

staticprivate

Definition at line 60 of file L1METvalue.h.

◆ m_xsXEmax

const int LVL1::L1METvalue::m_xsXEmax = 127

staticprivate

Limits on inputs to XS LUT.

Definition at line 59 of file L1METvalue.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Private Attributes

Detailed Description

Member Function Documentation

◆ calcL1MET() [1/2]

◆ calcL1MET() [2/2]

◆ calcL1METQ()

◆ calcL1METSig() [1/2]

◆ calcL1METSig() [2/2]

Member Data Documentation

◆ m_mask

◆ m_nBits

◆ m_nRanges

◆ m_rangeMask

◆ m_valueMask

◆ m_xsSqrtTEmax

◆ m_xsXEmax