UserCode/RateMonShiftTool_dev/ReadConfig.py

#!/usr/bin/env python
import os
import cPickle as pickle
import math
from DatabaseParser import *

class RateMonConfig:
    
    def __init__(self,path='./'):
        self.CFGfile=path+"/defaults.cfg"
        self.BasePath=path
        self.ReferenceRun=""
        self.DefAllowRatePercDiff=0.0
        self.DefAllowRateSigmaDiff=0.0
        self.DefAllowIgnoreThresh=0.0
        self.ExcludeList=[]
        self.MonitorList=[]
        self.MonitorIntercept=[]
        self.MonitorSlope=[]
        self.MonitorQuad=[]
        self.L1Predictions=[]
        self.MonitorOnly=0
        self.MonTargetLumi=0
        self.FindL1Zeros=0
        self.LSWindow=-1
        self.CompareReference=0
        self.ShifterMode=0
        self.NoVersion=0
        self.MaxExpressRate=999
        self.ForbiddenCols=[]
        self.CirculatingBeamsColumn=9
        self.MaxLogMonRate=10
        self.DefWarnOnSigmaDiff=1
        self.DefShowSigmaAndPercDiff=0
        self.DoL1=0
        
    def ReadList(self,filename):
        filename=self.BasePath+'/'+filename
        list = []
        if not os.path.exists(filename):
            return list
        f = open(filename)
        for line in f:
            if line.startswith('#'):
                continue
            if len(line)<3 or line=='\n':
                continue
            line = ((line.rstrip('\n')).rstrip(' '))
            if line.find(':')==-1: # exclude list, no rate estimates
                list.append( line )
            else:
                split = line.split(':')
                list.append(split[0])
                ##list.append([split[0],split[1],split[2],split[3]])
        f.close()
        return list

    def ReadCFG(self):
        f=open(self.CFGfile)
        for line in f:
            if line.startswith('#'):
                continue
            if len(line)<1:
                continue
            
            strippedLine = line.split('#')[0]
            strippedLine = strippedLine.rstrip('\n').rstrip(' ')
            if strippedLine=='':
                continue
            tok = strippedLine.split('=')
            par = tok[0].rstrip(' ').lstrip(' ')
            if len(tok)>=2:
                arg=tok[1].rstrip('\n').rstrip(' ').lstrip(' ')
            else:
                arg=''
                
            if par=="ReferenceRun":
                self.ReferenceRun=arg
            elif par=="ShowSigmaAndPercDiff":
                self.DefShowSigmaAndPercDiff=float(arg)
            elif par=="DefaultAllowedRatePercDiff":
                self.DefAllowRatePercDiff=float(arg)
            elif par=="DefaultAllowedRateSigmaDiff":
                self.DefAllowRateSigmaDiff=float(arg)                
            elif par=="DefaultIgnoreThreshold":
                self.DefAllowIgnoreThresh=float(arg)
            elif par=="ExcludeTriggerList":
                self.ExcludeList=self.ReadList(arg)
            elif par=="TriggerToMonitorList":
                tmp=self.ReadList(arg)
                for line in tmp:
                    self.MonitorList.append(line)
                    #self.MonitorIntercept.append(float(line[1]))
                    #self.MonitorSlope.append(float(line[2]))
                    #self.MonitorQuad.append(float(line[3]))
            elif par=="ForbiddenColumns":
                tmp=arg.split(',')
                for line in tmp:
                    try:
                        self.ForbiddenCols.append(int(line))
                    except:
                        print "Cannot parse Forbidden Cols parameter"
            elif par=="L1CrossSection":
                self.L1Predictions = self.ReadList(arg)
            elif par =="MonitorOnlyListed":
                self.MonitorOnly=int(arg)
            elif par=="MonitorTargetLumi":
                self.MonTargetLumi=float(arg)
            elif par=="FindL1Zeros":
                self.FindL1Zeros=int(arg)
            elif par=="LSSlidingWindow":
                self.LSWindow=int(arg)
            elif par=="CompareReference":
                self.CompareReference=int(arg)
            elif par=="ShifterMode":
                self.ShifterMode=arg
            elif par=="MaxExpressRate":
                self.MaxExpressRate=float(arg)
            elif par=="MaxStreamARate":
                self.MaxStreamARate=float(arg)
            elif par=="FitFileName":
                self.FitFileName=arg
            elif par=="NoVersion":
                self.NoVersion=int(arg)
            elif par=="CirculatingBeamsColumn":
                self.CircBeamCol=int(arg)
            elif par=="MaxLogMonRate":
                self.MaxLogMonRate=float(arg)
            elif par=="WarnOnSigmaDiff":
                self.DefWarnOnSigmaDiff=float(arg)
            elif par=="DoL1":
                self.DoL1=int(arg)
            else:
                print "Invalid Option : "+strippedLine
        f.close()
                
    def AnalyzeTrigger(self,TrigName): ## Have to pass this a version number stripped Trigger
        if TrigName in self.ExcludeList:
            return False
        if self.MonitorOnly and not TrigName in self.MonitorList:
            return False
        return True

##     def GetExpectedRate(self,TrigName,lumi):
##         for trig,intercept,slope,quad in zip(self.MonitorList,self.MonitorIntercept,self.MonitorSlope,self.MonitorQuad):
##             if trig==TrigName:
##                 #print "mon list",self.MonitorList
##                 if lumi:
##                     return intercept + lumi*slope/1000 + lumi*lumi*quad/1000000
##                 else:
##                     return intercept + 3000*slope/1000 + 3000*3000*quad/1000000
##         return -1

    def GetExpectedRate(self,TrigName,Input,Rates,live,delivered,deadtime):
        RefRun = False
        #replaced live/delivered with deadtimebeamactive
        if self.NoVersion:
            TrigName=StripVersion(TrigName)
        if TrigName not in Input.keys():
            return 0
        
        try:
            sigma = Input[TrigName][5]
            if Input[TrigName][0] == "poly":
                return [(1-deadtime)*(Input[TrigName][1]+Input[TrigName][2]*delivered+Input[TrigName][3]*delivered*delivered+Input[TrigName][4]*delivered*delivered*delivered), sigma]
            else:
                return [(1-deadtime)*(Input[TrigName][1]+Input[TrigName][2]*math.exp(Input[TrigName][3]+Input[TrigName][4]*delivered)), sigma]
        except:
            RefRun = True
            #print "EXCEPT ERR"

        if RefRun:
            num_compare = 0
            pred_rate = 0
            for iterator in range(len(Rates[TrigName]["rate"])):
                delivered_lumi = Rates[TrigName]["delivered_lumi"][iterator]
                if delivered_lumi > delivered - 100 and delivered_lumi < delivered + 100:
                    live_lumi = Rates[TrigName]["live_lumi"][iterator]
                    rate = Rates[TrigName]["rate"][iterator]
                    pred_rate += (live/delivered)*rate*(delivered_lumi/live_lumi)
                    num_compare += 1

            pred_rate = pred_rate/num_compare
            Chi2 = pred_rate/math.sqrt(num_compare)
            return [pred_rate, Chi2]

        return -1
                    
        
##     def GetExpectedL1Rates(self,lumi):
##         if not lumi:
##             return {}
##         expectedRates = {}
##         for col,inter,slope,quad in self.L1Predictions:
##             try:
##                 expectedRates[int(col)] = lumi*(float(inter)+float(slope)*lumi+float(quad)*lumi*lumi)
##             except:
##                 return {}
##         return expectedRates
       
    
Revision:	1.20
Committed:	Wed Sep 26 22:12:49 2012 UTC (12 years, 7 months ago) by grchrist
Content type:	text/x-python
Branch:	MAIN
CVS Tags:	V00-02-04, V00-02-03
Changes since 1.19:	+3 -0 lines
Log Message:	added L1 monitoring to rate monitoring
#	Content
1	#!/usr/bin/env python
2	import os
3	import cPickle as pickle
4	import math
5	from DatabaseParser import *
6
7	class RateMonConfig:
8
9	def __init__(self,path='./'):
10	self.CFGfile=path+"/defaults.cfg"
11	self.BasePath=path
12	self.ReferenceRun=""
13	self.DefAllowRatePercDiff=0.0
14	self.DefAllowRateSigmaDiff=0.0
15	self.DefAllowIgnoreThresh=0.0
16	self.ExcludeList=[]
17	self.MonitorList=[]
18	self.MonitorIntercept=[]
19	self.MonitorSlope=[]
20	self.MonitorQuad=[]
21	self.L1Predictions=[]
22	self.MonitorOnly=0
23	self.MonTargetLumi=0
24	self.FindL1Zeros=0
25	self.LSWindow=-1
26	self.CompareReference=0
27	self.ShifterMode=0
28	self.NoVersion=0
29	self.MaxExpressRate=999
30	self.ForbiddenCols=[]
31	self.CirculatingBeamsColumn=9
32	self.MaxLogMonRate=10
33	self.DefWarnOnSigmaDiff=1
34	self.DefShowSigmaAndPercDiff=0
35	self.DoL1=0
36
37	def ReadList(self,filename):
38	filename=self.BasePath+'/'+filename
39	list = []
40	if not os.path.exists(filename):
41	return list
42	f = open(filename)
43	for line in f:
44	if line.startswith('#'):
45	continue
46	if len(line)<3 or line=='\n':
47	continue
48	line = ((line.rstrip('\n')).rstrip(' '))
49	if line.find(':')==-1: # exclude list, no rate estimates
50	list.append( line )
51	else:
52	split = line.split(':')
53	list.append(split[0])
54	##list.append([split[0],split[1],split[2],split[3]])
55	f.close()
56	return list
57
58	def ReadCFG(self):
59	f=open(self.CFGfile)
60	for line in f:
61	if line.startswith('#'):
62	continue
63	if len(line)<1:
64	continue
65
66	strippedLine = line.split('#')[0]
67	strippedLine = strippedLine.rstrip('\n').rstrip(' ')
68	if strippedLine=='':
69	continue
70	tok = strippedLine.split('=')
71	par = tok[0].rstrip(' ').lstrip(' ')
72	if len(tok)>=2:
73	arg=tok[1].rstrip('\n').rstrip(' ').lstrip(' ')
74	else:
75	arg=''
76
77	if par=="ReferenceRun":
78	self.ReferenceRun=arg
79	elif par=="ShowSigmaAndPercDiff":
80	self.DefShowSigmaAndPercDiff=float(arg)
81	elif par=="DefaultAllowedRatePercDiff":
82	self.DefAllowRatePercDiff=float(arg)
83	elif par=="DefaultAllowedRateSigmaDiff":
84	self.DefAllowRateSigmaDiff=float(arg)
85	elif par=="DefaultIgnoreThreshold":
86	self.DefAllowIgnoreThresh=float(arg)
87	elif par=="ExcludeTriggerList":
88	self.ExcludeList=self.ReadList(arg)
89	elif par=="TriggerToMonitorList":
90	tmp=self.ReadList(arg)
91	for line in tmp:
92	self.MonitorList.append(line)
93	#self.MonitorIntercept.append(float(line[1]))
94	#self.MonitorSlope.append(float(line[2]))
95	#self.MonitorQuad.append(float(line[3]))
96	elif par=="ForbiddenColumns":
97	tmp=arg.split(',')
98	for line in tmp:
99	try:
100	self.ForbiddenCols.append(int(line))
101	except:
102	print "Cannot parse Forbidden Cols parameter"
103	elif par=="L1CrossSection":
104	self.L1Predictions = self.ReadList(arg)
105	elif par =="MonitorOnlyListed":
106	self.MonitorOnly=int(arg)
107	elif par=="MonitorTargetLumi":
108	self.MonTargetLumi=float(arg)
109	elif par=="FindL1Zeros":
110	self.FindL1Zeros=int(arg)
111	elif par=="LSSlidingWindow":
112	self.LSWindow=int(arg)
113	elif par=="CompareReference":
114	self.CompareReference=int(arg)
115	elif par=="ShifterMode":
116	self.ShifterMode=arg
117	elif par=="MaxExpressRate":
118	self.MaxExpressRate=float(arg)
119	elif par=="MaxStreamARate":
120	self.MaxStreamARate=float(arg)
121	elif par=="FitFileName":
122	self.FitFileName=arg
123	elif par=="NoVersion":
124	self.NoVersion=int(arg)
125	elif par=="CirculatingBeamsColumn":
126	self.CircBeamCol=int(arg)
127	elif par=="MaxLogMonRate":
128	self.MaxLogMonRate=float(arg)
129	elif par=="WarnOnSigmaDiff":
130	self.DefWarnOnSigmaDiff=float(arg)
131	elif par=="DoL1":
132	self.DoL1=int(arg)
133	else:
134	print "Invalid Option : "+strippedLine
135	f.close()
136
137	def AnalyzeTrigger(self,TrigName): ## Have to pass this a version number stripped Trigger
138	if TrigName in self.ExcludeList:
139	return False
140	if self.MonitorOnly and not TrigName in self.MonitorList:
141	return False
142	return True
143
144	## def GetExpectedRate(self,TrigName,lumi):
145	## for trig,intercept,slope,quad in zip(self.MonitorList,self.MonitorIntercept,self.MonitorSlope,self.MonitorQuad):
146	## if trig==TrigName:
147	## #print "mon list",self.MonitorList
148	## if lumi:
149	## return intercept + lumislope/1000 + lumilumi*quad/1000000
150	## else:
151	## return intercept + 3000slope/1000 + 30003000*quad/1000000
152	## return -1
153
154	def GetExpectedRate(self,TrigName,Input,Rates,live,delivered,deadtime):
155	RefRun = False
156	#replaced live/delivered with deadtimebeamactive
157	if self.NoVersion:
158	TrigName=StripVersion(TrigName)
159	if TrigName not in Input.keys():
160	return 0
161
162	try:
163	sigma = Input[TrigName][5]
164	if Input[TrigName][0] == "poly":
165	return [(1-deadtime)(Input[TrigName][1]+Input[TrigName][2]delivered+Input[TrigName][3]delivereddelivered+Input[TrigName][4]delivereddelivered*delivered), sigma]
166	else:
167	return [(1-deadtime)(Input[TrigName][1]+Input[TrigName][2]math.exp(Input[TrigName][3]+Input[TrigName][4]*delivered)), sigma]
168	except:
169	RefRun = True
170	#print "EXCEPT ERR"
171
172	if RefRun:
173	num_compare = 0
174	pred_rate = 0
175	for iterator in range(len(Rates[TrigName]["rate"])):
176	delivered_lumi = Rates[TrigName]["delivered_lumi"][iterator]
177	if delivered_lumi > delivered - 100 and delivered_lumi < delivered + 100:
178	live_lumi = Rates[TrigName]["live_lumi"][iterator]
179	rate = Rates[TrigName]["rate"][iterator]
180	pred_rate += (live/delivered)rate(delivered_lumi/live_lumi)
181	num_compare += 1
182
183	pred_rate = pred_rate/num_compare
184	Chi2 = pred_rate/math.sqrt(num_compare)
185	return [pred_rate, Chi2]
186
187	return -1
188
189
190	## def GetExpectedL1Rates(self,lumi):
191	## if not lumi:
192	## return {}
193	## expectedRates = {}
194	## for col,inter,slope,quad in self.L1Predictions:
195	## try:
196	## expectedRates[int(col)] = lumi(float(inter)+float(slope)lumi+float(quad)lumilumi)
197	## except:
198	## return {}
199	## return expectedRates
200
201