mergeEnergyRamps.GainsFromSqlite Class Reference

Collaboration diagram for mergeEnergyRamps.GainsFromSqlite:

Public Member Functions
	__init__ (self, name, geometryMapper)
	getGoodGains (self)

Public Attributes
int	cut_gain_low = 0.
int	cut_gain_high = 3
int	cut_offset_low = -100.
int	cut_offset_high = 100.
	geometry_convertor = geometryMapper
	run_nr = None
	strategy = None
dict	measured_gains = {}
dict	measured_chi2 = {}
dict	measured_offset = {}
dict	measured_error_code = {}
int	UNIX2COOL = 1000000000

Detailed Description

Definition at line 279 of file mergeEnergyRamps.py.

Constructor & Destructor Documentation

__init__()

mergeEnergyRamps.GainsFromSqlite.__init__	(		self,
			name,
			geometryMapper )

Definition at line 281 of file mergeEnergyRamps.py.

     def __init__(self,name,geometryMapper):
       
#       self.cut_gain_low    = 0.5
#       self.cut_gain_high   = 1.6
#       self.cut_offset_low  = -10.
#       self.cut_offset_high = 10.
 
       self.cut_gain_low    = 0.                    # all gains that are not completly crazy...
       self.cut_gain_high   = 3
       self.cut_offset_low  = -100.
       self.cut_offset_high = 100.
 
       self.geometry_convertor = geometryMapper
 
       self.run_nr = None         #will come later
       self.strategy = None     #later
 
       self.measured_gains={}  
       self.measured_chi2={}  
       self.measured_offset={}
       self.measured_error_code={}
  
       self.UNIX2COOL = 1000000000
 
       # get database service and open database
       dbSvc = cool.DatabaseSvcFactory.databaseService()
 
       dbString='sqlite://;schema='+name+';dbname=L1CALO'
       try:
         db = dbSvc.openDatabase(dbString, False)        
       except Exception as e:
         print ('Error: Problem opening database', e)
         sys.exit(1)
 
       folder_name = '/TRIGGER/L1Calo/V1/Results/EnergyScanResults'
       folder=db.getFolder(folder_name)
       
       startUtime = int(time.time())
       endUtime = int(time.time())
       startValKey = startUtime * self.UNIX2COOL
       endValKey = endUtime * self.UNIX2COOL
       chsel = cool.ChannelSelection(0,sys.maxsize)
 
       try:
         itr=folder.browseObjects(startValKey, endValKey, chsel)
       except Exception as e:
         print (e)
         sys.exit(1)
 
       for row in itr:
         CoolId = hex(int(row.channelId()))
         payload = row.payload()
         self.measured_gains[CoolId]      = payload['Slope']
         self.measured_chi2[CoolId]       = payload['Chi2']
         self.measured_offset[CoolId]     = payload['Offset']
         self.measured_error_code[CoolId] = payload['ErrorCode']
  
#       print (self.measured_gains)
 
       folder_gen_name = '/TRIGGER/L1Calo/V1/Results/EnergyScanRunInfo'
       folder_gen=db.getFolder(folder_gen_name)
 
       try:
         itr=folder_gen.browseObjects(startValKey, endValKey, chsel)
       except Exception as e:
         print (e)
         sys.exit(1)
 
       for row in itr:
          payload = row.payload()
          self.run_nr   = payload['RunNumber']
          self.strategy = payload['GainStrategy']
 
 
       # close database
       db.closeDatabase()
 

Member Function Documentation

getGoodGains()

mergeEnergyRamps.GainsFromSqlite.getGoodGains

(

self

)

Definition at line 358 of file mergeEnergyRamps.py.

     def getGoodGains(self):
 
       good_gains={}
 
       for i in self.measured_gains.keys():
 
         if ((self.measured_gains[i] > self.cut_gain_low and self.measured_gains[i] < self.cut_gain_high) and
            (self.measured_offset[i] > self.cut_offset_low and self.measured_offset[i] < self.cut_offset_high) and
#            not (self.geometry_convertor.isCoolHad(i) and self.geometry_convertor.isPPMFCAL(i)) ):
            not (self.geometry_convertor.isPPMFCAL(i)) ):
 
           good_gains[i]=[self.measured_gains[i],self.measured_error_code[i]]
 
         elif self.geometry_convertor.isPPMFCAL(i):
           good_gains[i]=[self.measured_gains[i]/2,self.measured_error_code[i]]
 
         else:
           print ("GainsFromSqlite::getGoodGains have rejected channel ", i)
 
       return good_gains      # these are gains as a function of PPM Cool
 
 

Member Data Documentation

cut_gain_high

mergeEnergyRamps.GainsFromSqlite.cut_gain_high = 3

Definition at line 289 of file mergeEnergyRamps.py.

cut_gain_low

int mergeEnergyRamps.GainsFromSqlite.cut_gain_low = 0.

Definition at line 288 of file mergeEnergyRamps.py.

cut_offset_high

mergeEnergyRamps.GainsFromSqlite.cut_offset_high = 100.

Definition at line 291 of file mergeEnergyRamps.py.

cut_offset_low

int mergeEnergyRamps.GainsFromSqlite.cut_offset_low = -100.

Definition at line 290 of file mergeEnergyRamps.py.

geometry_convertor

mergeEnergyRamps.GainsFromSqlite.geometry_convertor = geometryMapper

Definition at line 293 of file mergeEnergyRamps.py.

measured_chi2

dict mergeEnergyRamps.GainsFromSqlite.measured_chi2 = {}

Definition at line 299 of file mergeEnergyRamps.py.

measured_error_code

dict mergeEnergyRamps.GainsFromSqlite.measured_error_code = {}

Definition at line 301 of file mergeEnergyRamps.py.

measured_gains

dict mergeEnergyRamps.GainsFromSqlite.measured_gains = {}

Definition at line 298 of file mergeEnergyRamps.py.

measured_offset

dict mergeEnergyRamps.GainsFromSqlite.measured_offset = {}

Definition at line 300 of file mergeEnergyRamps.py.

run_nr

mergeEnergyRamps.GainsFromSqlite.run_nr = None

Definition at line 295 of file mergeEnergyRamps.py.

strategy

mergeEnergyRamps.GainsFromSqlite.strategy = None

Definition at line 296 of file mergeEnergyRamps.py.

UNIX2COOL

int mergeEnergyRamps.GainsFromSqlite.UNIX2COOL = 1000000000

Definition at line 303 of file mergeEnergyRamps.py.

---

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

• mergeEnergyRamps.py