Public Member Functions
def	__init__ (self, width_in, unused_lsbs, lsb, output_scale_factor, operation, start_value=0, label="", width_out_force=0)

def	config (self)

def	debug_info (self, msg)

def	export

def	optimal_scale_factor (width_in, max_width_out, unused_lsbs, lsb, operation, start_value=0)

def	print_error (self)

Public Attributes
	debug_txt

	input_scale_factor

	lsb

	lut

	max_error

	operation

	output_scale_factor

	start_value

	unused_lsbs

	width_in

	width_out

Detailed Description

Definition at line 13 of file l1tGTSingleInOutLUT.py.

Constructor & Destructor Documentation

◆ init()

def l1tGTSingleInOutLUT.SingleInOutLUT.__init__	(	self,
		width_in,
		unused_lsbs,
		lsb,
		output_scale_factor,
		operation,
		start_value = `0`,
		label = `""`,
		width_out_force = `0`
	)

Definition at line 15 of file l1tGTSingleInOutLUT.py.

     def __init__(self, width_in, unused_lsbs, lsb, output_scale_factor, operation, start_value=0, label="", width_out_force=0):
         self.debug_txt = ""
         input_scale_factor = 2**unused_lsbs * lsb
         self.unused_lsbs = unused_lsbs
         self.lsb = lsb
         signed_output = min([operation(input_scale_factor * (i + 0.5) + start_value)
                             for i in range(2**width_in)]) < 0
 
         if width_out_force == 0:
             self.width_out = math.ceil(math.log2(output_scale_factor *
                                                  max([abs(operation(input_scale_factor * (i + 0.5) + start_value)) for i in range(2**width_in - 1)] +
                                                      [abs(operation(input_scale_factor * (2**width_in - 1) + start_value))])))
             if signed_output:
                 self.width_out += 1
         else:
             self.width_out = width_out_force
 
         self.debug_info(
             "***************************** {} LUT {} *****************************".format(operation.__name__, label))
         self.debug_info("Depth: {} x {} (addr x data)".format(width_in, self.width_out))
         self.debug_info("Scale: {}".format(output_scale_factor))
 
         self.width_in = width_in
         self.output_scale_factor = output_scale_factor
         self.input_scale_factor = input_scale_factor
         self.operation = operation
         self.start_value = start_value
         self.lut = cms.vint32(
             * ([min(round(output_scale_factor * operation(input_scale_factor * (i + 0.5) + start_value)), 2**self.width_out - 1) for i in range(2**width_in - 1)]
                + [min(round(output_scale_factor * operation(input_scale_factor * (2 ** width_in - 1) + start_value)), 2**self.width_out - 1)]))
 
         self.print_error()
 

Member Function Documentation

◆ config()

def l1tGTSingleInOutLUT.SingleInOutLUT.config ( self )

Definition at line 51 of file l1tGTSingleInOutLUT.py.

References CSCTFDTReceiverLUT.lut, EcalTPGFineGrainStripEE::Item.lut, HcalLutSet.lut, LutXml::_Config.lut, l1tGTSingleInOutLUT.SingleInOutLUT.lut, l1tGTSingleInOutLUT.SingleInOutLUT.max_error, l1tGTSingleInOutLUT.SingleInOutLUT.output_scale_factor, and l1tGTSingleInOutLUT.SingleInOutLUT.unused_lsbs.

     def config(self):
         return cms.PSet(
             output_scale_factor=cms.double(self.output_scale_factor),
             unused_lsbs=cms.uint32(self.unused_lsbs),
             lut=self.lut,
             max_error=cms.double(self.max_error)
         )
 

◆ debug_info()

def l1tGTSingleInOutLUT.SingleInOutLUT.debug_info	(	self,
		msg
	)

Definition at line 48 of file l1tGTSingleInOutLUT.py.

References l1tGTSingleInOutLUT.SingleInOutLUT.debug_txt.

     def debug_info(self, msg):
         self.debug_txt += msg + "\n"
 

◆ export()

def l1tGTSingleInOutLUT.SingleInOutLUT.export	(	self,
		filename
	)

Definition at line 59 of file l1tGTSingleInOutLUT.py.

References l1tGTSingleInOutLUT.SingleInOutLUT.debug_txt, createfilelist.int, CSCTFDTReceiverLUT.lut, EcalTPGFineGrainStripEE::Item.lut, HcalLutSet.lut, LutXml::_Config.lut, l1tGTSingleInOutLUT.SingleInOutLUT.lut, print(), and l1tGTSingleInOutLUT.SingleInOutLUT.width_out.

     def export(self, filename: str):
         print(self.debug_txt)
         with open(filename, "w") as file:
             for value in self.lut:
                 file.write("{:X}".format(int(value) & ((1 << self.width_out) - 1)
                                          ).rjust(math.ceil(self.width_out/4), '0') + "\n")
 

◆ optimal_scale_factor()

def l1tGTSingleInOutLUT.SingleInOutLUT.optimal_scale_factor	(	width_in,
		max_width_out,
		unused_lsbs,
		lsb,
		operation,
		start_value = `0`
	)

Definition at line 67 of file l1tGTSingleInOutLUT.py.

References funct.abs(), WZElectronSkims53X_cff.max, l1tGTSingleInOutLUT.SingleInOutLUT.operation, and isotrackApplyRegressor.range.

     def optimal_scale_factor(width_in, max_width_out, unused_lsbs, lsb, operation, start_value=0):
         input_scale_factor = 2**unused_lsbs * lsb
         scale_factor = (2**max_width_out - 1) / max([abs(operation(input_scale_factor * (i + 0.5) + start_value))
                                                      for i in range(2**width_in)])
         return scale_factor
 

◆ print_error()

def l1tGTSingleInOutLUT.SingleInOutLUT.print_error ( self )

Definition at line 73 of file l1tGTSingleInOutLUT.py.

References funct.abs(), createfilelist.int, l1tGTSingleInOutLUT.SingleInOutLUT.lsb, CSCTFDTReceiverLUT.lut, EcalTPGFineGrainStripEE::Item.lut, HcalLutSet.lut, LutXml::_Config.lut, l1tGTSingleInOutLUT.SingleInOutLUT.lut, GlobalLogicParser::TokenRPN.operation, l1tGTSingleInOutLUT.SingleInOutLUT.operation, L1GtLogicParser::TokenRPN.operation, l1tGTSingleInOutLUT.SingleInOutLUT.output_scale_factor, isotrackApplyRegressor.range, l1tGTSingleInOutLUT.SingleInOutLUT.start_value, l1tGTSingleInOutLUT.SingleInOutLUT.unused_lsbs, and l1tGTSingleInOutLUT.SingleInOutLUT.width_in.

     def print_error(self):
         errors = [abs(self.lut[int(i/(2**self.unused_lsbs))]/self.output_scale_factor -
                       self.operation(i * self.lsb + self.start_value)) for i in range(2**(self.width_in + self.unused_lsbs))]
 
         self.max_error = max(errors)
 
         self.debug_info("Error: {:.5f} +/- {:.5f}, max: {:.5f}, total: {:.5f}, median: {:.5f}".format(
             mean(errors), stdev(errors), self.max_error, sum(errors), median(errors)))
 
         # mass_errors = [errors[i]/(2*self.operation(i * self.lsb + self.start_value)) for i in range(2**(self.width_in + self.unused_lsbs)) ]
         # self.debug_info("inv mass error: {:.5f} +/- {:.5f}, max: {:.5f}, total: {:.5f}, median: {:.5f}".format(
         #       mean(mass_errors), stdev(mass_errors), max(mass_errors), sum(mass_errors), median(mass_errors)))
 
 