Classes
struct	EtMiss

Typedefs
typedef ap_int< kHTSize >	Et_t

typedef ap_int< kInternalEtaWidth >	eta_t

typedef ap_ufixed< kMHTSize, kMHTIntSize >	MHT_t

typedef ap_uint< kMHTPhiSize >	MHTphi_t

typedef ap_uint< 5 >	ntracks_t

typedef ap_int< kInternalPhiWidth >	phi_t

typedef ap_uint< kInternalPtWidth >	pt_t

Enumerations
enum	BitLocations { kValidLSB = 0, kValidMSB = kValidLSB + kValidSize - 1, kMHTLSB = kValidMSB + 1, kMHTMSB = kMHTLSB + kMHTSize - 1, kMHTPhiLSB = kMHTMSB + 1, kMHTPhiMSB = kMHTPhiLSB + kMHTPhiSize - 1, kHTLSB = kMHTPhiMSB + 1, kHTMSB = kHTLSB + kHTSize - 1, kUnassignedLSB = kHTMSB + 1, kUnassignedMSB = kUnassignedLSB + kUnassignedSize - 1 }

Functions
EtMiss	cordicSqrt (Et_t x, Et_t y, int cordicSteps, std::vector< l1tmhtemu::MHTphi_t > atanLUT, std::vector< Et_t > magNormalisationLUT)

template<typename T >
T	digitizeSignedValue (double value, unsigned int nBits, double lsb)

std::vector< MHTphi_t >	generateaTanLUT (int cordicSteps)

std::vector< phi_t >	generateCosLUT (unsigned int size)

std::vector< Et_t >	generatemagNormalisationLUT (int cordicSteps)

Variables
const unsigned int	kEtExtra {10}

const unsigned int	kHTSize {kInternalPtWidth + kEtExtra}

const unsigned int	kInternalEtaWidth {l1t::TkJetWord::TkJetBitWidths::kGlbEtaSize}

const unsigned int	kInternalPhiWidth {l1t::TkJetWord::TkJetBitWidths::kGlbPhiSize}

const unsigned int	kInternalPtWidth {l1t::TkJetWord::TkJetBitWidths::kPtSize}

const float	kMaxCosLUTPhi {M_PI}

const float	kMaxMHT {2048}

const float	kMaxMHTPhi {2 * M_PI}

const unsigned int	kMHTBins = 1 << kMHTSize

const unsigned int	kMHTIntSize {11}

const unsigned int	kMHTPhiBins = 1 << kMHTPhiSize

const unsigned int	kMHTPhiSize {13}

const unsigned int	kMHTSize {16}

const unsigned int	kPhiBins = 1 << kInternalPhiWidth

const double	kStepEta {M_PI / (720)}

const double	kStepMHT = (l1tmhtemu::kMaxMHT / l1tmhtemu::kMHTBins)

const double	kStepMHTPhi = (l1tmhtemu::kMaxMHTPhi / l1tmhtemu::kMHTPhiBins)

const double	kStepPhi {M_PI / (720)}

const double	kStepPt {0.25}

const unsigned int	kUnassignedSize {64 - (kHTSize + kMHTSize + kMHTPhiSize + kValidSize)}

const unsigned int	kValidSize {1}

Typedef Documentation

◆ Et_t

typedef ap_int<kHTSize> l1tmhtemu::Et_t

Definition at line 58 of file L1TkHTMissEmulatorProducer.h.

◆ eta_t

typedef ap_int<kInternalEtaWidth> l1tmhtemu::eta_t

Definition at line 55 of file L1TkHTMissEmulatorProducer.h.

◆ MHT_t

typedef ap_ufixed<kMHTSize, kMHTIntSize> l1tmhtemu::MHT_t

Definition at line 59 of file L1TkHTMissEmulatorProducer.h.

◆ MHTphi_t

typedef ap_uint<kMHTPhiSize> l1tmhtemu::MHTphi_t

Definition at line 60 of file L1TkHTMissEmulatorProducer.h.

◆ ntracks_t

typedef ap_uint<5> l1tmhtemu::ntracks_t

Definition at line 53 of file L1TkHTMissEmulatorProducer.h.

◆ phi_t

typedef ap_int<kInternalPhiWidth> l1tmhtemu::phi_t

Definition at line 56 of file L1TkHTMissEmulatorProducer.h.

◆ pt_t

typedef ap_uint<kInternalPtWidth> l1tmhtemu::pt_t

Definition at line 54 of file L1TkHTMissEmulatorProducer.h.

Enumeration Type Documentation

◆ BitLocations

enum l1tmhtemu::BitLocations

Enumerator
kValidLSB
kValidMSB
kMHTLSB
kMHTMSB
kMHTPhiLSB
kMHTPhiMSB
kHTLSB
kHTMSB
kUnassignedLSB
kUnassignedMSB

Definition at line 36 of file L1TkHTMissEmulatorProducer.h.

                     {
     // The location of the least significant bit (LSB) and most significant bit (MSB) in the sum word for different fields
     kValidLSB = 0,
     kValidMSB = kValidLSB + kValidSize - 1,
     kMHTLSB = kValidMSB + 1,
     kMHTMSB = kMHTLSB + kMHTSize - 1,
     kMHTPhiLSB = kMHTMSB + 1,
     kMHTPhiMSB = kMHTPhiLSB + kMHTPhiSize - 1,
     kHTLSB = kMHTPhiMSB + 1,
     kHTMSB = kHTLSB + kHTSize - 1,
     kUnassignedLSB = kHTMSB + 1,
     kUnassignedMSB = kUnassignedLSB + kUnassignedSize - 1
   };

Function Documentation

◆ cordicSqrt()

EtMiss l1tmhtemu::cordicSqrt	(	Et_t	x,
		Et_t	y,
		int	cordicSteps,
		std::vector< l1tmhtemu::MHTphi_t >	atanLUT,
		std::vector< Et_t >	magNormalisationLUT
	)

inline

Definition at line 122 of file L1TkHTMissEmulatorProducer.h.

References l1tmhtemu::EtMiss::Et, nano_mu_digi_cff::float, kMHTBins, kMHTPhiBins, kStepPhi, kStepPt, l1tmhtemu::EtMiss::Phi, Validation_hcalonly_cfi::sign, and x.

Referenced by L1TkHTMissEmulatorProducer::produce(), and L1TrackerEtMissEmulatorProducer::produce().

                                                                 {
     Et_t new_x = 0;
     Et_t new_y = 0;
 
     MHTphi_t phi = 0;
     MHTphi_t new_phi = 0;
     bool sign = false;
 
     EtMiss ret_etmiss;
 
     if (x >= 0 && y >= 0) {
       phi = 0;
       sign = true;
       //x = x;
       //y = y;
     } else if (x < 0 && y >= 0) {
       phi = kMHTPhiBins >> 1;
       sign = false;
       x = -x;
       //y = y;
     } else if (x < 0 && y < 0) {
       phi = kMHTPhiBins >> 1;
       sign = true;
       x = -x;
       y = -y;
     } else {
       phi = kMHTPhiBins;
       sign = false;
       //x = x;
       y = -y;
     }
 
     for (int step = 0; step < cordicSteps; step++) {
       if (y < 0) {
         new_x = x - (y >> step);
         new_y = y + (x >> step);
       } else {
         new_x = x + (y >> step);
         new_y = y - (x >> step);
       }
 
       if ((y < 0) == sign) {
         new_phi = phi - atanLUT[step];
       } else {
         new_phi = phi + atanLUT[step];
       }
 
       x = new_x;
       y = new_y;
       phi = new_phi;
     }
 
     float sqrtval = (float(x * magNormalisationLUT[cordicSteps - 1]) / (float)kMHTBins) * float(kStepPt * kStepPhi);
     ret_etmiss.Et = sqrtval;
     ret_etmiss.Phi = phi;
 
     return ret_etmiss;
   }

◆ digitizeSignedValue()

template<typename T >

T l1tmhtemu::digitizeSignedValue	(	double	value,
		unsigned int	nBits,
		double	lsb
	)

Definition at line 77 of file L1TkHTMissEmulatorProducer.h.

References funct::abs(), and l1tHGCalVFEProducer_cfi::lsb.

                                                                       {
     T digitized_value = std::floor(std::abs(value) / lsb);
     T digitized_maximum = (1 << (nBits - 1)) - 1;  // The remove 1 bit from nBits to account for the sign
     if (digitized_value > digitized_maximum)
       digitized_value = digitized_maximum;
     if (value < 0)
       digitized_value = (1 << nBits) - digitized_value;  // two's complement encoding
     return digitized_value;
   }

◆ generateaTanLUT()

std::vector<MHTphi_t> l1tmhtemu::generateaTanLUT ( int cordicSteps )

inline

Definition at line 98 of file L1TkHTMissEmulatorProducer.h.

References kMHTPhiBins, M_PI, and funct::pow().

Referenced by L1TkHTMissEmulatorProducer::L1TkHTMissEmulatorProducer().

                                                               {  // Fill atan LUT with integer values
     std::vector<MHTphi_t> atanLUT;
     atanLUT.reserve(cordicSteps);
     for (int cordicStep = 0; cordicStep < cordicSteps; cordicStep++) {
       atanLUT.push_back(MHTphi_t(round((kMHTPhiBins * atan(pow(2, -1 * cordicStep))) / (2 * M_PI))));
     }
     return atanLUT;
   }

◆ generateCosLUT()

std::vector<phi_t> l1tmhtemu::generateCosLUT ( unsigned int size )

inline

Definition at line 87 of file L1TkHTMissEmulatorProducer.h.

References funct::cos(), kInternalPhiWidth, and kStepPhi.

Referenced by L1TkHTMissEmulatorProducer::L1TkHTMissEmulatorProducer().

                                                             {  // Fill cosine LUT with integer values
     float phi = 0;
     std::vector<phi_t> cosLUT;
     for (unsigned int LUT_idx = 0; LUT_idx < size; LUT_idx++) {
       cosLUT.push_back(digitizeSignedValue<phi_t>(cos(phi), l1tmhtemu::kInternalPhiWidth, l1tmhtemu::kStepPhi));
       phi += l1tmhtemu::kStepPhi;
     }
     cosLUT.push_back((phi_t)(0));  //Prevent overflow in last bin
     return cosLUT;
   }

◆ generatemagNormalisationLUT()

std::vector<Et_t> l1tmhtemu::generatemagNormalisationLUT ( int cordicSteps )

inline

Definition at line 107 of file L1TkHTMissEmulatorProducer.h.

References kMHTBins, funct::pow(), and heppy_batch::val.

Referenced by L1TkHTMissEmulatorProducer::L1TkHTMissEmulatorProducer().

                                                                       {
     float val = 1.0;
     std::vector<Et_t> magNormalisationLUT;
     for (int cordicStep = 0; cordicStep < cordicSteps; cordicStep++) {
       val = val / (pow(1 + pow(4, -1 * cordicStep), 0.5));
       magNormalisationLUT.push_back(Et_t(round(kMHTBins * val)));
     }
     return magNormalisationLUT;
   }