LVL1::jFEXCompression Class Reference

LAr supercell data are received by the jFEX in a 10-bit multi-linear encoded form. More...

#include <jFEXCompression.h>

Collaboration diagram for LVL1::jFEXCompression:

Static Public Member Functions
static unsigned int	Compress (float floatEt, bool empty=false)
	Compress data.
static int	Expand (unsigned int code)
	Uncompress data.
static unsigned int	Threshold (unsigned int code, int threshold=-800)
	Apply threshold to compressed data.
static unsigned int	Linearize (unsigned int code, int threshold=0)
	Linearize LAr code to jFEX internal format.

Static Private Attributes
static const int	s_maxET = 800000
	Maximum ET value that can be encoded.
static const unsigned int	s_nRanges = 5
	Number of ranges.
static const int	s_steps [s_nRanges] = {25, 50, 100, 200, 400}
	Step sizes in each range, MeV.
static const int	s_minET [s_nRanges] = {-3150, 6400, 25600, 102400, 409600}
	Minimum ET values in each range, MeV.
static const int	s_minCode [s_nRanges] = {2, 384, 768, 1536, 3072}
	Minimum code value in each range.
static const int	s_NoData = 0
	Indicates no data present.
static const unsigned int	s_LArUnderflow = 1
	LAr underflow code.
static const unsigned int	s_LArOverflow = 4048
	LAr overflow code.
static const unsigned int	s_LArMaxCode = 4095
	Maximum code value, values 4049 to 4094 reserved.
static const unsigned int	s_LArInvalid = 4095
	Invalid code value.
static const unsigned int	s_jFEXstep = 25
	L1Calo ET digit step.
static const unsigned int	s_jFEXOverflow = 0xffff
	L1Calo saturated/overflow.
static const int	s_error = -99999
	Error return value.

Detailed Description

LAr supercell data are received by the jFEX in a 10-bit multi-linear encoded form.

This simple utility class contains 3 functions:

• Compress: encodes a signed integer MeV value
• Expand: decodes a 10 bit unsigned int into a signed integer MeV value
• Threshold: applies a threshold (in MeV) to the compressed code, zeroing if below
• Linearize: decodes a 10 bit unsigned int into the unsigned 16 bit jFEX ET with least count of 25 MeV. A user-defined threshold (in MeV) can be applied, but as the jFEX ET is positive a negative threshold is equivalent to a threshold of 0.

Definition at line 30 of file jFEXCompression.h.

Member Function Documentation

Compress()

unsigned int LVL1::jFEXCompression::Compress ( float floatEt, bool empty = false )

static

Compress data.

Definition at line 20 of file jFEXCompression.cxx.

                                                                {
    
    //If all Scells are masked, then send empty/data not available
    if(empty) return s_NoData;
    
    int Et = std::round(floatEt);
 
    // Check for overflow
    if (Et >= s_maxET) return s_LArOverflow;
 
    // Find which range the ET value is in
    int range = -1;
    for (unsigned int i = 0; i < s_nRanges; i++) {
        if (Et < s_minET[i]) break;
        range = i;
    }
 
    // Calculate code
    unsigned int code = 0;
 
    if (range < 0) {
        // Below minimum value
        code = s_LArUnderflow;
    }
    else {
        // Lies inside one of the value ranges
        int steps = std::round( (Et - s_minET[range])/s_steps[range] );
        code = static_cast<int>(s_minCode[range] + steps);
    }
 
    return code;
}

Expand()

int LVL1::jFEXCompression::Expand ( unsigned int code )

static

Uncompress data.

Now expand code into an ET value. Start by finding what range the code is in

Now expand the value

Definition at line 53 of file jFEXCompression.cxx.

                                             {
 
  // Deal with special codes first:
  if (code == s_NoData)  return 0;
  if (code == s_LArInvalid) return 0; 
  if (code > s_LArOverflow && code < s_LArInvalid) return s_error; 
  if (code == s_LArOverflow) return s_maxET;

  int range = 0;
  for (unsigned int i = 0; i < s_nRanges-1; ++i) {
    if (code < (unsigned int)s_minCode[i+1]) break;
    range++;
  }
  int minEt = s_minET[range];
  int valEt = (code-s_minCode[range])*s_steps[range];
  
  int Et = minEt+valEt;
  return Et;
}

Linearize()

unsigned int LVL1::jFEXCompression::Linearize ( unsigned int code, int threshold = 0 )

static

Linearize LAr code to jFEX internal format.

Apply the threshold. Since jFEX ET is positive, minimum threshold is 0.

Expand the ET value

Convert to jFEX digit scale

Definition at line 89 of file jFEXCompression.cxx.

                                                                        {

  if (threshold < 0) threshold = 0;
  code = jFEXCompression::Threshold(code, threshold);

  int Et = jFEXCompression::Expand(code);
 
  // Check for overflow
  if (Et >= s_maxET) return s_jFEXOverflow;

  unsigned int jFexET = Et/s_jFEXstep;
  return jFexET;
}

Threshold()

unsigned int LVL1::jFEXCompression::Threshold ( unsigned int code, int threshold = -800 )

static

Apply threshold to compressed data.

Convert threshold into a compressed code

Zero code if < threshold

Definition at line 77 of file jFEXCompression.cxx.

                                                                        {

  unsigned int cut = jFEXCompression::Compress(threshold);

  if (code < cut) code = 0;
 
  return code;
}

Member Data Documentation

s_error

const int LVL1::jFEXCompression::s_error = -99999

staticprivate

Error return value.

Definition at line 68 of file jFEXCompression.h.

s_jFEXOverflow

const unsigned int LVL1::jFEXCompression::s_jFEXOverflow = 0xffff

staticprivate

L1Calo saturated/overflow.

Definition at line 66 of file jFEXCompression.h.

s_jFEXstep

const unsigned int LVL1::jFEXCompression::s_jFEXstep = 25

staticprivate

L1Calo ET digit step.

Definition at line 64 of file jFEXCompression.h.

s_LArInvalid

const unsigned int LVL1::jFEXCompression::s_LArInvalid = 4095

staticprivate

Invalid code value.

Definition at line 62 of file jFEXCompression.h.

s_LArMaxCode

const unsigned int LVL1::jFEXCompression::s_LArMaxCode = 4095

staticprivate

Maximum code value, values 4049 to 4094 reserved.

Definition at line 60 of file jFEXCompression.h.

s_LArOverflow

const unsigned int LVL1::jFEXCompression::s_LArOverflow = 4048

staticprivate

LAr overflow code.

Definition at line 58 of file jFEXCompression.h.

s_LArUnderflow

const unsigned int LVL1::jFEXCompression::s_LArUnderflow = 1

staticprivate

LAr underflow code.

Definition at line 56 of file jFEXCompression.h.

s_maxET

const int LVL1::jFEXCompression::s_maxET = 800000

staticprivate

Maximum ET value that can be encoded.

Definition at line 44 of file jFEXCompression.h.

s_minCode

const int LVL1::jFEXCompression::s_minCode = {2, 384, 768, 1536, 3072}

staticprivate

Minimum code value in each range.

Definition at line 52 of file jFEXCompression.h.

s_minET

const int LVL1::jFEXCompression::s_minET = {-3150, 6400, 25600, 102400, 409600}

staticprivate

Minimum ET values in each range, MeV.

Definition at line 50 of file jFEXCompression.h.

s_NoData

const int LVL1::jFEXCompression::s_NoData = 0

staticprivate

Indicates no data present.

Definition at line 54 of file jFEXCompression.h.

s_nRanges

const unsigned int LVL1::jFEXCompression::s_nRanges = 5

staticprivate

Number of ranges.

Definition at line 46 of file jFEXCompression.h.

s_steps

const int LVL1::jFEXCompression::s_steps = {25, 50, 100, 200, 400}

staticprivate

Step sizes in each range, MeV.

Definition at line 48 of file jFEXCompression.h.

---

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

• jFEXCompression.h
• jFEXCompression.cxx