00001 import os,coral,datetime,fnmatch
00002 from RecoLuminosity.LumiDB import nameDealer,revisionDML,dataDML,lumiTime,CommonUtil,selectionParser,hltTrgSeedMapper
00003
00004 def runList(schema,fillnum=None,runmin=None,runmax=None,startT=None,stopT=None,l1keyPattern=None,hltkeyPattern=None,amodetag=None,nominalEnergy=None,energyFlut=0.2,requiretrg=True,requirehlt=True):
00005 return dataDML.runList(schema,fillnum,runmin,runmax,startT,stopT,l1keyPattern,hltkeyPattern,amodetag,nominalEnergy,energyFlut,requiretrg,requirehlt)
00006
00007 def lslengthsec(numorbit, numbx):
00008 '''
00009 input:
00010 numorbit : number of orbit in the lumi section
00011 numbx : number of orbits
00012 output:
00013 lumi section length in sec
00014 '''
00015 l = numorbit * numbx * 25.0e-09
00016 return l
00017 def hltpathsForRange(schema,runlist):
00018 '''
00019 input: runlist [run], (required)
00020 datatag: data version (optional)
00021 output : {runnumber,{hltpath:(l1bitname,l1seedexpr)}}
00022 '''
00023 result={}
00024 if isinstance(inputRange,list):
00025 for run in runlist:
00026 extendedmap={}
00027 hlttrgmap=dataDML.hlttrgMappingByrun(run)
00028 for hltpath,l1seedexpr in hlttrgmap.items():
00029 l1bitname=hltTrgSeedMapper(hltpath,l1seedexpr)
00030 extendedmap[hltpath]=(l1bitname,l1seedexpr)
00031 result[run]=extendedmap
00032 return result
00033 def trgbitsForRange(schema,runlist,datatag=None):
00034 '''
00035 input: runlist [run],(required)
00036 datatag: data version (optional)
00037 output: {runnumber:bitzeroname,[bitnames]}
00038 '''
00039 pass
00040
00041 def hltForRange(schema,inputRange,hltpathname=None,hltpathpattern=None,datatag=None):
00042 '''
00043 input:
00044 inputRange: {run:[cmsls]} (required)
00045 hltpathname: exact match hltpathname (optional)
00046 hltpathpattern: regex match hltpathpattern (optional)
00047 datatag : data version
00048 output: {runnumber:{hltpath:[[cmslsnum,l1pass,hltaccept,hltprescale]]})}
00049 '''
00050 pass
00051
00052 def trgForRange(schema,inputRange,trgbitname=None,trgbitnamepattern=None,datatag=None):
00053 '''
00054 input :
00055 inputRange {run:[cmsls]} (required)
00056 trgbitname exact match trgbitname (optional)
00057 trgbitnamepattern regex match trgbitname (optional)
00058 datatag : data version
00059 output
00060 result {run,{cmslsnum:[deadtimecount,bitzero_count,bitzero_prescale,deadfraction,{bitname:[prescale,counts]}]}}
00061 '''
00062 pass
00063
00064 def instLumiForRange(schema,inputRange,beamstatus=None,withBXInfo=False,bxAlgo='OCC1',xingMinLum=1.0e-4,withBeamIntensity=False,datatag=None):
00065 '''
00066 input:
00067 inputRange {run:[cmsls]} (required)
00068 beamstatus: LS filter on beamstatus (optional)
00069 beamenergy: LS filter on beamenergy (optional) beamenergy+-beamenergyFluc
00070 withBXInfo: get per bunch info (optional)
00071 bxAlgo: algoname for bx values (optional) ['OCC1','OCC2','ET']
00072 xingMinLum: cut on bx lumi value (optional)
00073 withBeamInfo: get beam intensity info (optional)
00074 datatag: data version
00075 output:
00076 result {run:{(lumilsnum,cmslsnum):[timestamp,beamstatus,beamenergy,instlumi,instlumierr,startorbit,numorbit,(bxvalues,bxerrs),(bxidx,b1intensities,b2intensities)]}}
00077 lumi unit: HZ/ub
00078 '''
00079 pass
00080
00081 def instCalibratedLumiForRange(schema,inputRange,amodetag='PROTPHYS',nominalegev=3500,beamstatus=None,withBXInfo=False,bxAlgo='OCC1',xingMinLum=1.0e-4,withBeamInfo=False,normname=None,datatag=None):
00082 '''
00083 Inst luminosity after calibration
00084 input:
00085 inputRange {run:[cmsls]} (required)
00086 amodetag : accelerator mode for all the runs (optional) ['PROTPHYS','HIPHYS']
00087 beamstatus: LS filter on beamstatus (optional)
00088 beamenergy: LS filter on beamenergy (optional) beamenergy+-beamenergyFluc
00089 withBXInfo: get per bunch info (optional)
00090 bxAlgo: algoname for bx values (optional) ['OCC1','OCC2','ET']
00091 xingMinLum: cut on bx lumi value (optional)
00092 withBeamInfo: get beam intensity info (optional)
00093 normname: norm factor name to use (optional)
00094 datatag: data version
00095 output:
00096 result {run:{(lumilsnum,cmslsnum):[timestamp,beamstatus,beamenergy,calibratedlumi,calibratedlumierr,startorbit,numorbit,(bxvalues,bxerrs),(bxidx,b1intensities,b2intensities)]}}
00097 lumi unit: HZ/ub
00098 '''
00099 result = {}
00100 normid=None
00101 if not normname:
00102 normid=dataDML.guessnormIdByContext(schema,amodetag,nominalegev)
00103 if not normid:
00104 raise ValueError('cannot find a normalization factor for the combined condition '+amodetag+' '+nominalegev)
00105 normval=dataDML.luminormById(schema,normid)[2]
00106 perbunchnormval=float(normval)/float(1000)
00107 instresult=instLumiForRange(schema,inputRange,beamstatus,withBXInfo,bxAlgo,withBeamIntensity,datatag)
00108 for run,lsdict in instresult.items():
00109 result[run]={}
00110 for (lumilsnum,cmslsnum),perlsdata in lsdict.items():
00111 timestamp=perlsdata[0]
00112 beamstatus=perlsdata[1]
00113 beamenergy=perlsdata[2]
00114 calibratedlumi=perlsdata[3]*normval
00115 calibratedlumierr=perlsdata[4]*normval
00116 startorbit=perlsdata[5]
00117 numorbit=perlsdata[6]
00118 bxdata=perlsdata[7]
00119 calibfatedbxdata=None
00120 if bxdata:
00121 calibratedbxdata=([x*perbunchnormval for x in bxdata[0]],[x*perbunchnormval for x in bxdata[1]])
00122 intensitydata=perlsdata[8]
00123 result[run][(lumilsnum,cmslsnum)]=[timestamp,beamstatus,beamenergy,calibratedlumi,calibratedlumierr,startorbit,numorbit,calibfatedbxdata,intensitydata]
00124 return result
00125
00126 def deliveredLumiForRange(schema,inputRange,amodetag='PROTPHYS',nominalegev=3500,beamstatus=None,withBXInfo=False,bxAlgo='OCC1',xingMinLum=1.0e-4,withBeamIntensity=False,normname=None,datatag=None):
00127 '''
00128 input:
00129 inputRange {run:[lsnum]} (required) [lsnum]==None means all ; [lsnum]==[] means selected ls
00130 amodetag : accelerator mode for all the runs (optional) ['PROTPHYS','HIPHYS']
00131 beamstatus: LS filter on beamstatus (optional)
00132 beamenergy: LS filter on beamenergy (optional) beamenergy+-beamenergyFluc
00133 withBXInfo: get per bunch info (optional)
00134 bxAlgo: algoname for bx values (optional) ['OCC1','OCC2','ET']
00135 xingMinLum: cut on bx lumi value (optional)
00136 withBeamInfo: get beam intensity info (optional)
00137 normname: norm factor name to use (optional)
00138 datatag: data version
00139 output:
00140 result {run:{(lumilsnum,cmslsnum):[timestamp,beamstatus,beamenergy,deliveredlumi,calibratedlumierr,(bxvalues,bxerrs),(bxidx,b1intensities,b2intensities)]}}
00141 avg lumi unit: 1/ub
00142 '''
00143 result = {}
00144 normid=None
00145 if not normname:
00146 normid=dataDML.guessnormIdByContext(schema,amodetag,nominalegev)
00147 if not normid:
00148 raise ValueError('cannot find a normalization factor for the combined condition '+amodetag+' '+nominalegev)
00149 normval=dataDML.luminormById(schema,normid)[2]
00150 perbunchnormval=float(normval)/float(1000)
00151 instresult=instLumiForRange(schema,inputRange,beamstatus,withBXInfo,bxAlgo,withBeamIntensity,datatag)
00152 for run,lslist in inputRange.items():
00153 result[run]={}
00154 for (lumilsnum,cmslsnum),perlsdata in lsdict.items():
00155 timestamp=perlsdata[0]
00156 beamstatus=perlsdata[1]
00157 beamenergy=perlsdata[2]
00158 calibratedlumi=perlsdata[3]*normval
00159 calibratedlumierr=perlsdata[4]*normval
00160 numorbit=perlsdata[6]
00161 numbx=3564
00162 lslen=lslengthsec(numorbit,numbx)
00163 deliveredlumi=calibratedlumi*lslen
00164 bxdata=perlsdata[7]
00165 calibratedbxdata=None
00166 if bxdata:
00167 calibratedbxdata=([x*perbunchnormval for x in bxdata[0]],[x*perbunchnormval for x in bxdata[1]])
00168 intensitydata=perlsdata[8]
00169 result[run][(lumilsnum,cmslsnum)]=[timestamp,beamstatus,beamenergy,deliveredlumi,calibratedlumierr,calibratedbxdata,intensitydata]
00170 return result
00171
00172 def lumiForRange(schema,inputRange,amodetag='PROTPHYS',beamstatus=None,beamenergy=None,beamenergyFluc=0.2,withBXInfo=False,bxAlgo='OCC1',xingMinLum=1.0e-4,withBeamInfo=False,normname=None,datatag=None):
00173 '''
00174 input:
00175 inputRange {run:[cmsls]} (required)
00176 amodetag : accelerator mode for all the runs (optional) ['PROTPHYS','HIPHYS']
00177 beamstatus: LS filter on beamstatus (optional)
00178 beamenergy: LS filter on beamenergy (optional) beamenergy+-beamenergyFluc
00179 withBXInfo: get per bunch info (optional)
00180 bxAlgo: algoname for bx values (optional) ['OCC1','OCC2','ET']
00181 xingMinLum: cut on bx lumi value (optional)
00182 withBeamInfo: get beam intensity info (optional)
00183 normname: norm factor name to use (optional)
00184 datatag: data version
00185 output:
00186 result {run:{(lumilsnum,cmslsnum):[timestamp,beamstatus,beamenergy,deliveredlumi,recordedlumi,calibratedlumierror,((bxidx,bxvalues,bxerrs),(bxidx,b1intensities,b2intensities)]}}
00187 lumi unit: 1/ub
00188 '''
00189 result = {}
00190 normid=None
00191 if not normname:
00192 normid=dataDML.guessnormIdByContext(schema,amodetag,nominalegev)
00193 if not normid:
00194 raise ValueError('cannot find a normalization factor for the combined condition '+amodetag+' '+nominalegev)
00195 normval=dataDML.luminormById(schema,normid)[2]
00196 perbunchnormval=float(normval)/float(1000)
00197 c=lumiTime.lumiTime()
00198 for run,lslist in inputRange.items():
00199 if lslist is not None and len(lslist)==0:
00200 result[run]={}
00201 continue
00202 cmsrunsummary=dataDML.runsummary(schema,run)
00203 startTimeStr=cmsrunsummary[6]
00204 lumidataid=None
00205 trgdataid=None
00206 hltdataid=None
00207 (lumidataid,trgdataid,hltdataid)=dataDML.guessDataIdByRun(schema,run)
00208 (lumirunnum,lumidata)=dataDML.lumiLSById(schema,lumidataid,beamstatus,beamenergy,beamenergyFluc,withBXInfo,bxAlgo,withBeamInfo)
00209 (trgrunnum,trgdata)=dataDML.trgLSById(schema,trgdataid,withblobdata=False)
00210 perrunresult={}
00211 for lumilsnum,perlsdata in lumidata.items():
00212 cmslsnum=perlsdata[0]
00213 if lslist is not None and cmslsnum not in lslist:
00214 continue
00215 instlumi=perlsdata[1]
00216 instlumierror=perlsdata[2]
00217 calibratedlumi=instlumi*normval
00218 calibratedlumierror=instlumierror*normval
00219 beamstatus=perlsdata[4]
00220 beamenergy=perlsdata[5]
00221 numorbit=perlsdata[6]
00222 startorbit=perlsdata[7]
00223 timestamp=c.OrbitToUTCTimestamp(startTimeStr,numorbit,startorbit+numorbit,0)
00224 numbx=3564
00225 lslen=lslengthsec(numorbit,numbx)
00226 deliveredlumi=calibratedlumi*lslen
00227 recordedlumi=0.0
00228 if cmslsnum!=0:
00229 deadcount=trgdata[cmslsnum][0]
00230 bitzerocount=trgdata[cmslsnum][1]
00231 bitzeroprescale=trgdata[cmslsnum][2]
00232 deadfrac=float(deadcount)/(float(bitzerocount)*float(bitzeroprescale))
00233 if deadfrac>1.0:
00234 deadfrac=0.0
00235 recordedlumi=deliveredlumi*(1.0-deadfrac)
00236 bxdata=None
00237 if withBXInfo:
00238 bxvalueblob=lumidata[8]
00239 bxerrblob=lumidata[9]
00240 bxidxlist=[]
00241 bxvaluelist=[]
00242 bxerrorlist=[]
00243 if bxvalueblob is not None and bxerrblob is not None:
00244 bxvaluearray=CommonUtil.unpackBlobtoArray(bxvalueblob,'f')
00245 bxerrorarray=CommonUtil.unpackBlobtoArray(bxerrblob,'f')
00246 for idx,bxval in enumerate(bxvaluearray):
00247 if bxval*perbunchnormval>xingMinLum:
00248 bxidxlist.append(idx)
00249 bxvaluelist.append(bxval*perbunchnormval)
00250 bxerrorlist.append(bxerrorarray[idx]*perbunchnormval)
00251 bxdata=(bxidxlist,bxvaluelist,bxerrorlist)
00252 beamdata=None
00253 if withBeamInfo:
00254 bxindexblob=lumidata[10]
00255 beam1intensityblob=lumidata[11]
00256 beam2intensityblob=lumidata[12]
00257 bxindexlist=[]
00258 b1intensitylist=[]
00259 b2intensitylist=[]
00260 if bxindexblob is not None and beam1intensity is not None and beam2intensity is not None:
00261 bxindexlist=CommonUtil.unpackBlobtoArray(bxindexblob,'h').tolist()
00262 beam1intensitylist=CommonUtil.unpackBlobtoArray(beam1intensityblob,'f').tolist()
00263 beam2intensitylist=CommonUtil.unpackBlobtoArray(beam2intensityblob,'f').tolist()
00264 beamdata=(bxindexlist,b1intensitylist,b2intensitylist)
00265 perrunresult[(lumilsnum,cmslsnum)]=[timestamp,beamstatus,beamenergy,deliveredlumi,recordedlumi,calibratedlumierror,bxdata,beamdata]
00266 lumidata.clear()
00267 trgdata.clear()
00268 result[run]=perrunresult
00269 return result
00270
00271 def effectiveLumiForRange(schema,inputRange,hltpathname=None,hltpathpattern=None,amodetag='PROTPHYS',beamstatus=None,beamenergy=None,beamenergyFluc=0.2,withBXInfo=False,xingMinLum=1.0e-4,bxAlgo='OCC1',withBeamInfo=False,normname=None,datatag=None):
00272 '''
00273 input:
00274 inputRange {run:[cmsls]} (required)
00275 hltpathname: selected hltpathname
00276 hltpathpattern: regex select hltpaths
00277 amodetag : accelerator mode for all the runs (optional) ['PROTPHYS','HIPHYS']
00278 beamstatus: LS filter on beamstatus (optional)
00279 beamenergy: LS filter on beamenergy (optional) beamenergy+-beamenergyFluc
00280 withBXInfo: get per bunch info (optional)
00281 bxAlgo: algoname for bx values (optional) ['OCC1','OCC2','ET']
00282 xingMinLum: cut on bx lumi value (optional)
00283 withBeamInfo: get beam intensity info (optional)
00284 normname: norm factor name to use (optional)
00285 datatag: data version
00286 output:
00287 result {run:{(lumilsnum,cmslsnum):[timestamp,beamstatus,beamenergy,deliveredlumi,recordedlumi,calibratedlumierror,{hltpath:[l1name,l1prescale,hltprescale,efflumi]},bxdata,beamdata]}}
00288 lumi unit: 1/ub
00289 '''
00290 result = {}
00291 normid=None
00292 if not normname:
00293 normid=dataDML.guessnormIdByContext(schema,amodetag,nominalegev)
00294 if not normid:
00295 raise ValueError('cannot find a normalization factor for the combined condition '+amodetag+' '+nominalegev)
00296 normval=dataDML.luminormById(schema,normid)[2]
00297 perbunchnormval=float(normval)/float(1000)
00298 c=lumiTime.lumiTime()
00299 for run,lslist in inputRange.items():
00300 if lslist is not None and len(lslist)==0:
00301 result[run]={}
00302 continue
00303 cmsrunsummary=dataDML.runsummary(schema,run)
00304 startTimeStr=cmsrunsummary[6]
00305 lumidataid=None
00306 trgdataid=None
00307 hltdataid=None
00308 (lumidataid,trgdataid,hltdataid)=dataDML.guessDataIdByRun(schema,run)
00309 (lumirunnum,lumidata)=dataDML.lumiLSById(schema,lumidataid,beamstatus,beamenergy,beamenergyFluc,withBXInfo,bxAlgo,withBeamInfo)
00310 (trgrunnum,trgdata)=dataDML.trgLSById(schema,trgdataid,withblobdata=True)
00311 (hltrunnum,hltdata)=dataDML.hltLSById(schema,hltdataid)
00312 trgrundata=dataDML.trgRunById(schema,trgdataid)
00313 hltrundata=dataDML.hltRunById(schema,hltdataid)
00314 bitnames=trgrundata[3].split(',')
00315 hlttrgmap=dataDML.hlttrgMappingByrun(schema,run)
00316 pathnames=hltrundata[3].split(',')
00317 perrunresult={}
00318 for lumilsnum,perlsdata in lumidata.items():
00319 cmslsnum=perlsdata[0]
00320 if lslist is not None and cmslsnum not in lslist:
00321 continue
00322 instlumi=perlsdata[1]
00323 instlumierror=perlsdata[2]
00324 calibratedlumi=instlumi*normval
00325 calibratedlumierror=instlumierror*normval
00326 beamstatus=perlsdata[4]
00327 beamenergy=perlsdata[5]
00328 numorbit=perlsdata[6]
00329 startorbit=perlsdata[7]
00330 timestamp=c.OrbitToUTCTimestamp(startTimeStr,numorbit)
00331 numbx=3564
00332 lslen=lslengthsec(numorbit,numbx)
00333 deliveredlumi=calibratedlumi*lslen
00334 recordedlumi=0.0
00335
00336 if cmslsnum==0: continue
00337
00338 deadcount=trgdata[cmslsnum][0]
00339 bitzerocount=trgdata[cmslsnum][1]
00340 bitzeroprescale=trgdata[cmslsnum][2]
00341 deadfrac=float(deadcount)/(float(bitzerocount)*float(bitzeroprescale))
00342 if deadfrac>1.0:
00343 deadfrac=0.0
00344 recordedlumi=deliveredlumi*(1.0-deadfrac)
00345 efflumidict={}
00346 l1prescaleblob=trgdata[cmslsnum][4]
00347 l1prescalearray=CommonUtil.unpackBlobtoArray(l1prescaleblob,'h')
00348 hltprescaleblob=hltdata[cmslsnum][0]
00349 hltprescalearray=CommonUtil.unpackBlobtoArray(hltprescaleblob,'h')
00350 trgprescalemap={}
00351 for bitnum,bitprescale in enumerate(l1prescalearray):
00352 thisbitname=bitnames[bitnum]
00353 trgprescalemap[thisbitname]=bitprescale
00354
00355 if hltpathname is None and hltpathpattern is None:
00356 for hpath,l1seedexpr in hlttrgmap.items():
00357 hltprescale=None
00358 l1prescale=None
00359 efflumi=None
00360 for pathidx,nm in enumerate(hltpathnames):
00361 if nm==hpath:
00362 hltprescale=hltprescalearray[pathidx]
00363 break
00364 try:
00365 l1bitname=hltTrgSeedMapper.findUniqueSeed(hpath,l1seedexpr)
00366 if l1bitname:
00367 l1prescale=trgprescalemap[l1bitname]
00368 except KeyError:
00369 l1prescale=None
00370 if l1prescale and hltprescale:
00371 efflumi=recordedlumi*l1prescale*hltprescale
00372 efflumidict[hpath]=[l1bitname,l1prescale,hltprescale,efflumi]
00373 elif hltpathname is not None:
00374 hltprescale=None
00375 l1prescale=None
00376 efflumi=None
00377 for pathidx,nm in enumerate(hltpathnames):
00378 if nm==hltpathname:
00379 hltprescale=hltprescalearray[pathidx]
00380 break
00381 try:
00382 l1bitname=hltTrgSeedMapper.findUniqueSeed(hltpathname,l1seedexpr)
00383 if l1bitname:
00384 l1prescale=trgprescalemap[l1bitname]
00385 except KeyError:
00386 l1prescale=None
00387 if l1prescale and hltprescale:
00388 efflumi=recordedlumi*l1prescale*hltprescale
00389 efflumidict[hpath]=[l1bitname,l1prescale,hltprescale,efflumi]
00390 elif hltpathpattern is not None:
00391 for hpath,l1seexexpr in hlttrgmap.items():
00392 hltprescale=None
00393 l1prescale=None
00394 efflumi=None
00395 if fnmatch.fnmatch(hpath,hltpathpattern):
00396 for pathidx,nm in enumerate(hltpathnames):
00397 if nm==hpath:
00398 hltprescale=hltprescalearray[pathidx]
00399 break
00400 try:
00401 l1bitname=hltTrgSeedMapper.findUniqueSeed(hpath,l1seedexpr)
00402 if l1bitname:
00403 l1prescale=trgprescalemap[l1bitname]
00404 except KeyError:
00405 l1prescale=None
00406 if l1prescale and hltprescale:
00407 efflumi=recordedlumi*l1prescale*hltprescale
00408 efflumidict[hpath]=[l1bitname,l1prescale,hltprescale,efflumi]
00409 bxdata=None
00410 if withBXInfo:
00411 bxvalueblob=lumidata[8]
00412 bxerrblob=lumidata[9]
00413 bxidxlist=[]
00414 bxvaluelist=[]
00415 bxerrorlist=[]
00416 if bxvalueblob is not None and bxerrblob is not None:
00417 bxvaluearray=CommonUtil.unpackBlobtoArray(bxvalueblob,'f')
00418 bxerrorarray=CommonUtil.unpackBlobtoArray(bxerrblob,'f')
00419 for idx,bxval in enumerate(bxvaluearray):
00420 if bxval*perbunchnormval>xingMinLum:
00421 bxidxlist.append(idx)
00422 bxvaluelist.append(bxval*perbunchnormval)
00423 bxerrorlist.append(bxerrorarray[idx]*perbunchnormval)
00424 bxdata=(bxidxlist,bxvaluelist,bxerrorlist)
00425 beamdata=None
00426 if withBeamInfo:
00427 bxindexblob=lumidata[10]
00428 beam1intensityblob=lumidata[11]
00429 beam2intensityblob=lumidata[12]
00430 bxindexlist=[]
00431 b1intensitylist=[]
00432 b2intensitylist=[]
00433 if bxindexblob is not None and beam1intensity is not None and beam2intensity is not None:
00434 bxindexlist=CommonUtil.unpackBlobtoArray(bxindexblob,'h').tolist()
00435 beam1intensitylist=CommonUtil.unpackBlobtoArray(beam1intensityblob,'f').tolist()
00436 beam2intensitylist=CommonUtil.unpackBlobtoArray(beam2intensityblob,'f').tolist()
00437 beamdata=(bxindexlist,b1intensitylist,b2intensitylist)
00438 perrunresult[(lumilsnum,cmslsnum)]=[timestamp,beamstatus,beamenergy,deliveredlumi,recordedlumi,calibratedlumierror,efflumidict,bxdata,beamdata]
00439 lumidata.clear()
00440 trgdata.clear()
00441 hltdata.clear()
00442 result[run]=perrunresult
00443 return result
00444
00445
00446
1.7.3