ATLAS Offline Software
Classes | Functions | Variables
python.html.AtlRunQueryDQSummary Namespace Reference

Classes

class  DQSummary
 

Functions

def MapToSystem (defect)
 
def ComputeRunLumi (dic, run, lumiperlb)
 
def GetLBLumi (dic, run)
 
def GetLBLiveFraction (dic, run)
 
def GetLBReady (dic, run)
 
def MakePlot_SummaryLumiLoss (loss, colors, dicsum, name)
 
def MakePlot_PerRunLumiLoss (loss, colors, dicsum, name)
 
def MakePlot_DefectsPerSystem (sys, intolerable, tolerable, ignored, dic, run)
 
def SetXLabel (h, labels)
 
def SetYLabel (h, labels)
 
def listify (lbl)
 

Variables

 server = xmlrpc.client.ServerProxy('http://atlasdqm.cern.ch')
 
 datapath
 
 pageinfo = pickle.load(open('%s/dqsum_pi.pickle' % QC.datapath))
 
 doDQPickle
 

Function Documentation

◆ ComputeRunLumi()

def python.html.AtlRunQueryDQSummary.ComputeRunLumi (   dic,
  run,
  lumiperlb 
)

Definition at line 54 of file AtlRunQueryDQSummary.py.

54 def ComputeRunLumi(dic,run,lumiperlb):
55  # consider ATLAS ready only
56  global readylb
57  total = 0.
58  for lbl in lumiperlb:
59  if lbl not in readylb:
60  continue
61  total += lumiperlb[lbl]
62  return total
63 
64 

◆ GetLBLiveFraction()

def python.html.AtlRunQueryDQSummary.GetLBLiveFraction (   dic,
  run 
)

Definition at line 96 of file AtlRunQueryDQSummary.py.

96 def GetLBLiveFraction(dic,run):
97  global livetrigger
98  livefraction = {}
99  #trigrate = dic[DataKey('TriggerRates')][run][0].value['L1_EM5']
100  triggerRates = dic[DataKey('TriggerRates')][run][0].value
101  if triggerRates != "No match":
102  try:
103  trigrate = triggerRates[livetrigger]
104  for item in trigrate:
105  (lb, tbp, tap, tav) = map(int, item)
106  livefraction[lb]= 0.
107  if tap != 0:
108  livefraction[lb] = float(tav)/tap
109  except KeyError:
110  print ("%s trigger not found - no live fraction computation" % livetrigger)
111  return livefraction
112 

◆ GetLBLumi()

def python.html.AtlRunQueryDQSummary.GetLBLumi (   dic,
  run 
)

Definition at line 65 of file AtlRunQueryDQSummary.py.

65 def GetLBLumi(dic,run):
66  global lumifolder
67  global usenb
68 
69  lumifolder = ''
70  lumiperlb = {}
71  for k,v in dic.items():
72  if 'ofllumi' not in k.ResultKey:
73  continue
74  lumifolder = k.ResultKey
75  if lumifolder == '':
76  return lumiperlb
77 
78  lbdic = dic[DataKey(lumifolder)][run]
79  lbtime = dic[DataKey('#LB')][run][1]
80 
81  for i,item in enumerate(lbdic):
82  for lb in range(int(item.startlb),int(item.endlb)):
83  lumiperlb[lb] = 0.
84  if item.value == "n.a.":
85  continue
86  if (lbtime[lb]-lbtime[lb-1])<0:
87  continue
88  # change unit (pb/nb)
89  scale = 0.001
90  if usenb:
91  scale = 1.
92  lumiperlb[lb] = float(item.value)*(lbtime[lb]-lbtime[lb-1])*0.001*scale # output in nb-1/pb-1
93  #print ("DEBUG",run,lb,float(item.value),lbtime[lb]-lbtime[lb-1])
94  return lumiperlb
95 

◆ GetLBReady()

def python.html.AtlRunQueryDQSummary.GetLBReady (   dic,
  run 
)

Definition at line 113 of file AtlRunQueryDQSummary.py.

113 def GetLBReady(dic,run):
114  rlb = []
115  for b in dic[DataKey('Ready for physics')][run]:
116  for lb in range(b.startlb,b.endlb):
117  if b.value == "1" :
118  rlb.append(lb)
119  return rlb
120 
121 

◆ listify()

def python.html.AtlRunQueryDQSummary.listify (   lbl)

Definition at line 529 of file AtlRunQueryDQSummary.py.

529 def listify(lbl): # compactify lb lists
530  if len(lbl) == 0 :
531  return ''
532  i = 0
533  newlist=[]
534  while i < len(lbl):
535  start=lbl[i]
536  j=i
537  while(j+1<len(lbl) and lbl[j+1]==lbl[j]+1):
538  j+=1
539  end=lbl[j]
540  i=j+1
541  if start==end:
542  newlist.append(start)
543  else:
544  newlist.append(str(start)+'-'+str(end))
545  return ", ".join([str(x) for x in newlist])

◆ MakePlot_DefectsPerSystem()

def python.html.AtlRunQueryDQSummary.MakePlot_DefectsPerSystem (   sys,
  intolerable,
  tolerable,
  ignored,
  dic,
  run 
)

Definition at line 367 of file AtlRunQueryDQSummary.py.

367 def MakePlot_DefectsPerSystem(sys,intolerable,tolerable,ignored,dic,run):
368 
369  global readylb
370 
371  from CoolRunQuery.AtlRunQueryQueryConfig import QC
372 
373  hname = ['','','']
374  h2_DefectVsLB = ['','','','']
375 
376 
377  SetStyle()
378  gStyle.SetTitleX(0.5)
379  gStyle.SetTitleAlign(23)
380 
381  lbrange = readylb[-1]-readylb[0] # can be disconnected !
382  #print (run,len(readylb),lbrange)
383 
384 
385  if len(intolerable) > 0 :
386  #TCol = TColor.GetColor( "#5D6B7D")
387  TCol = TColor.GetColor( "#0f3a60")
388  hname[0]= "%s_Intolerable_Run%s"%(sys,str(dic[DataKey('Run')][run]))
389  htitle = "%s - Intolerable defects - Run %s"%(sys,str(dic[DataKey('Run')][run]))
390  h2_DefectVsLB[0] = TH2F("h2_defectVsLB_%s"%hname[0],htitle,
391  lbrange,readylb[0]-0.5,readylb[-1]+0.5,
392  len(intolerable),0.,len(intolerable))
393  h2_DefectVsLB[0].SetFillColor(TCol)
394  h2_DefectVsLB[0].GetXaxis().SetTitle("Lumiblocks with ATLAS Ready")
395  SetYLabel(h2_DefectVsLB[0],[defect for defect in intolerable])
396  h2_DefectVsLB[0].LabelsOption("a","Y") # order Y label by alphabetical order
397 
398  # Text to store lumi loss number
399  ttext = {}
400  # Fill & Compute lumi losses
401  for i,item in enumerate(intolerable):
402  ibiny = h2_DefectVsLB[0].GetYaxis().FindBin(item)
403  binxmax = h2_DefectVsLB[0].GetXaxis().GetXmax()
404  frac = 100*float(len(intolerable[item]))/float(len(readylb))
405  if frac> 0.:
406  ttext[item] = TText(binxmax,ibiny-0.8," %.2f %%"%frac)
407  else:
408  ttext[item] = TText(binxmax,ibiny-0.8,"")
409  ttext[item].SetTextSize(0.03)
410  ttext[item].SetTextColor(TCol)
411  for lb in intolerable[item]:
412  if lb not in readylb:
413  continue
414  ibinx = h2_DefectVsLB[0].GetXaxis().FindBin(lb)
415  h2_DefectVsLB[0].SetBinContent(ibinx,ibiny,1.)
416 
417  # create png
418  canvas = TCanvas( 'c_Int',"Systems Defects - %s"%hname[0], 200, 10, 1000, 800)
419  canvas.Divide(1,1)
420  canvas.cd(1)
421  gPad.SetLeftMargin(0.40)
422  gPad.SetRightMargin(0.1)
423  h2_DefectVsLB[0].Draw("BOX")
424  for item in intolerable:
425  ttext[item].Draw()
426  canvas.Update()
427  hname[0] = QC.datapath+"/"+hname[0]+".png"
428  canvas.Print(hname[0])
429 
430 
431  if len(tolerable) > 0 :
432 
433  all = {**tolerable, **intolerable, **ignored}
434 
435  TCol1 = TColor.GetColor("#0f3a60")
436  TCol2 = TColor.GetColor("#a3c0d9")
437  TCol3 = TColor.GetColor("#4681b3")
438  #TCol1 = TColor.GetColor("#015669")
439  #TCol2 = TColor.GetColor("#5cbad0")
440  #TCol3 = TColor.GetColor("#258aa1")
441  hname[1]= "%s_All_Run%s"%(sys,str(dic[DataKey('Run')][run]))
442  htitle = "%s - All defects - Run %s"%(sys,str(dic[DataKey('Run')][run]))
443 
444  # intolerable
445  h2_DefectVsLB[1] = TH2F("h2_defectVsLB_int_%s"%hname[1],htitle,
446  lbrange,readylb[0]-0.5,readylb[-1]+0.5,
447  len(all),0.,len(all))
448  # tolerable
449  h2_DefectVsLB[2] = TH2F("h2_defectVsLB_tol_%s"%hname[1],htitle,
450  lbrange,readylb[0]-0.5,readylb[-1]+0.5,
451  len(all),0.,len(all))
452 
453  # ignored
454  h2_DefectVsLB[3] = TH2F("h2_defectVsLB_ign_%s"%hname[1],htitle,
455  lbrange,readylb[0]-0.5,readylb[-1]+0.5,
456  len(all),0.,len(all))
457 
458  h2_DefectVsLB[1].SetFillColor(TCol1)
459  h2_DefectVsLB[2].SetFillColor(TCol2)
460  h2_DefectVsLB[3].SetFillColor(TCol3)
461  #h2_DefectVsLB[3].SetFillStyle(3004) # not a great idea for single LBs
462  h2_DefectVsLB[1].GetXaxis().SetTitle("Lumiblocks with ATLAS Ready")
463  h2_DefectVsLB[2].GetXaxis().SetTitle("Lumiblocks with ATLAS Ready")
464  h2_DefectVsLB[3].GetXaxis().SetTitle("Lumiblocks with ATLAS Ready")
465  SetYLabel(h2_DefectVsLB[1],[defect for defect in all])
466  SetYLabel(h2_DefectVsLB[2],[defect for defect in all])
467  SetYLabel(h2_DefectVsLB[3],[defect for defect in all])
468  h2_DefectVsLB[1].LabelsOption("a","Y") # order Y label by alphabetical order
469  h2_DefectVsLB[2].LabelsOption("a","Y") # order Y label by alphabetical order
470  h2_DefectVsLB[3].LabelsOption("a","Y") # order Y label by alphabetical order
471 
472  # Text to store lumi loss number
473  ttext = {}
474 
475  # Fill
476  for i,item in enumerate(all):
477  ibiny = h2_DefectVsLB[1].GetYaxis().FindBin(item)
478  binxmax = h2_DefectVsLB[1].GetXaxis().GetXmax()
479  frac = 100*float(len(all[item]))/float(len(readylb))
480  if frac >0.:
481  ttext[item] = TText(binxmax,ibiny-0.8," %.2f %%"%frac)
482  else:
483  ttext[item] = TText(binxmax,ibiny-0.8,"")
484  ttext[item].SetTextSize(0.03)
485  if item in intolerable:
486  ttext[item].SetTextColor(TCol1)
487  if item in tolerable:
488  ttext[item].SetTextColor(TCol2)
489  if item in ignored:
490  ttext[item].SetTextColor(TCol3)
491  for lb in all[item]:
492  ibinx = h2_DefectVsLB[1].GetXaxis().FindBin(lb)
493  if item in intolerable:
494  h2_DefectVsLB[1].SetBinContent(ibinx,ibiny,1.)
495  if item in tolerable:
496  h2_DefectVsLB[2].SetBinContent(ibinx,ibiny,1.)
497  if item in ignored:
498  h2_DefectVsLB[3].SetBinContent(ibinx,ibiny,1.)
499 
500  # create png
501  canvas = TCanvas( 'c_Tol',"Systems Defects - %s"%hname[1], 200, 10, 1000, 800)
502  canvas.Divide(1,1)
503  canvas.cd(1)
504  gPad.SetLeftMargin(0.40)
505  gPad.SetRightMargin(0.1)
506  h2_DefectVsLB[2].Draw("BOX")
507  h2_DefectVsLB[3].Draw("BOXSAME")
508  h2_DefectVsLB[1].Draw("BOXSAME")
509 
510  for item in all:
511  ttext[item].Draw()
512  canvas.Update()
513  hname[1] = QC.datapath+"/"+hname[1]+".png"
514  canvas.Print(hname[1])
515 
516  return hname
517 

◆ MakePlot_PerRunLumiLoss()

def python.html.AtlRunQueryDQSummary.MakePlot_PerRunLumiLoss (   loss,
  colors,
  dicsum,
  name 
)

Definition at line 228 of file AtlRunQueryDQSummary.py.

228 def MakePlot_PerRunLumiLoss(loss,colors,dicsum,name):
229 
230  global usenb
231  global unit
232 
233 
234  runs = []
235  for r in loss['_TOTAL']:
236  if loss['_TOTAL'][r]>0. :
237  runs.append(r)
238  #if len(runs) == 0 : return
239  empty = False
240  if len(runs) == 0 :
241  empty = True
242  runs.append("-")
243  runs.sort()
244 
245 
246  TotalLumi = dicsum[DataKey('TotalLumi')][0]
247 
248 
249  SetStyle()
250  gStyle.SetTitleX(0.5)
251  gStyle.SetTitleAlign(23)
252 
253 
254  h_stack = THStack("hs_PerRun","Luminosity Loss during ATLAS Ready [%s]"%unit)
255 
256 
257  x0=0.17
258  y0=0.62
259  nsplits = 4
260  dx = 0.2
261  dy = 0.05
262  leg = TLegend(x0,y0,x0+dx,y0+nsplits*dy)
263  nhists = 0
264 
265 
266  SHIFT = 0.1
267  WIDTH = 0.4
268 
269 
270  h1_total = TH1F("h1_total","",len(runs),-0.5,len(runs)-0.5)
271  h1_total.SetMinimum(0.)
272  h1_total.SetFillColor(colors['_TOTAL'])
273  h1_total.SetFillStyle(3244)
274  h1_total.SetBarWidth(WIDTH)
275  h1_total.SetBarOffset(SHIFT+WIDTH)
276 
277  for r,run in enumerate(runs):
278  if run != "-" and loss['_TOTAL'][run] > 0:
279  h1_total.Fill(r,loss['_TOTAL'][run])
280  nhists +=1
281  leg.AddEntry(h1_total,'TOTAL',"f")
282 
283 
284  h1_lumi = {}
285  for i,sys in enumerate(loss):
286 
287  if sys == '_TOTAL':
288  continue
289 
290  h1_lumi[sys] = TH1F("h1_lumi_%s"%sys,"",len(runs),-0.5,len(runs)-0.5)
291  h1_lumi[sys].SetMinimum(0.)
292  h1_lumi[sys].SetFillColor(colors[sys])
293  h1_lumi[sys].SetBarWidth(WIDTH)
294  h1_lumi[sys].SetBarOffset(SHIFT)
295  for r,run in enumerate(runs):
296  if run != "-" and loss[sys][run]> 0.:
297  h1_lumi[sys].Fill(r,loss[sys][run])
298 
299 
300  for sys in h1_lumi:
301  if h1_lumi[sys].GetEntries() > 0:
302  h_stack.Add(h1_lumi[sys])
303  leg.AddEntry(h1_lumi[sys],sys,"f")
304  nhists +=1
305 
306 
307  hmax = h_stack.GetMaximum()*1.6
308 
309 
310  if len(runs) == 1:
311  if runs[0] == "-":
312  t1 = " Run [-]"
313  else:
314  t1 = " Run [%i]"%runs[0]
315  else:
316  t1 = " Runs [%i-%i]"%(runs[0],runs[-1])
317 
318  t2 = "ATLAS Ready Lumi: %.2f %s"%(TotalLumi,unit)
319  h1_frame = TH1F("h1_frame_runs","#splitline{%s}{%s}"%(t1,t2),len(runs),-0.5,len(runs)-0.5)
320  SetXLabel(h1_frame,runs)
321  h1_frame.SetLabelSize(0.06,"X")
322  h1_frame.SetMinimum(0.)
323  h1_frame.GetYaxis().SetTitle("Luminosity Loss during ATLAS Ready [%s]"%unit)
324  h1_frame.GetYaxis().SetTitleOffset(1.3)
325 
326 
327  canvas = TCanvas( 'c_PerRunLumiLoss',"Luminosity Losses Per Run", 200, 10, 600, 700)
328  canvas.Divide(1,1)
329  canvas.cd(1)
330  gPad.SetTopMargin(0.15)
331  h1_frame.SetMaximum(hmax)
332  h_stack.SetMaximum(hmax)
333  #h_total.SetBarOffset((shift)
334 
335  h1_frame.Draw("")
336  h_stack.Draw("BARsame")
337  h1_total.Draw("BARsame")
338  ncolumns = int(math.ceil(float(nhists)/float(nsplits)))
339  leg.SetNColumns(ncolumns)
340  leg.Paint() # Draw once to access coordinates
341  leg.SetX2NDC(leg.GetX1NDC()+ncolumns*dx) # Modify legend size w.r.t number of columns
342  nrows = leg.GetNRows()
343  leg.SetY2NDC(leg.GetY1NDC()+nrows*dy) # Modify legend size w.r.t number of rows
344  if not empty:
345  leg.Draw() # Draw again
346 
347  subtitle = TText(len(runs)-0.35,0.,name)
348  subtitle.SetTextSize(0.03)
349  subtitle.SetTextAngle(90)
350  subtitle.SetTextColor(kGray+1)
351  subtitle.Draw()
352  if empty:
353  bgtext = TText(0.0,0.5,"No Luminosity Losses")
354  bgtext.SetTextAlign(22)
355  bgtext.SetTextColor(kRed)
356  bgtext.SetTextFont(43)
357  bgtext.SetTextSize(40)
358  bgtext.SetTextAngle(45)
359  bgtext.Draw()
360 
361  canvas.Update()
362  from CoolRunQuery.AtlRunQueryQueryConfig import QC
363  pname = QC.datapath+'/'+name+'_lumiloss_perrun.png'
364  canvas.Print(pname)
365  return pname
366 

◆ MakePlot_SummaryLumiLoss()

def python.html.AtlRunQueryDQSummary.MakePlot_SummaryLumiLoss (   loss,
  colors,
  dicsum,
  name 
)

Definition at line 123 of file AtlRunQueryDQSummary.py.

123 def MakePlot_SummaryLumiLoss(loss,colors,dicsum,name):
124 
125  global usenb
126  global unit
127 
128  SetStyle()
129  gStyle.SetTitleX(0.5)
130  gStyle.SetTitleAlign(23)
131 
132 
133  TotalLumi = dicsum[DataKey('TotalLumi')][0]
134 
135 
136  xlabels = [s for s in loss]
137 
138 
139  runs = [item for item in loss[xlabels[0]]]
140  runs.sort()
141 
142 
143  lumi = {}
144  max = 0.
145  for sys in loss:
146  lumi[sys] = 0.
147  for r in runs:
148  lumi[sys] += loss[sys][r]
149  if lumi[sys] > max:
150  max=lumi[sys]
151  max = max*1.5
152 
153  # if no entry, print no plot
154  empty = False
155  if max == 0.:
156  empty = True
157  max = 1.
158 
159 
160 
161  t1 = " Runs [%i-%i]"%(runs[0],runs[-1])
162  if len(runs) == 1:
163  t1 = " Run [%i]"%runs[0]
164  t2 = "ATLAS Ready Lumi: %.2f %s"%(TotalLumi,unit)
165  h1_frame = TH1F("h1_frame","#splitline{%s}{%s}"%(t1,t2),len(loss),-0.5,len(loss)-0.5)
166  SetXLabel(h1_frame,xlabels)
167  h1_frame.SetMinimum(0.)
168  h1_frame.SetMaximum(max)
169  h1_frame.SetTickLength(0.,"X")
170  h1_frame.GetYaxis().SetTitle("Luminosity Loss during ATLAS Ready [%s]"%unit)
171  h1_frame.LabelsOption("a","X") # order X label by alphabetical order
172 
173 
174  h1_lumi = []
175  text_lumi = []
176  for sys in loss:
177  h1_lumi.append(TH1F("h1_lumi_%s"%sys,"",len(loss),-0.5,len(loss)-0.5))
178  SetXLabel(h1_lumi[-1],xlabels)
179  h1_lumi[-1].LabelsOption("a","X") # order X label by alphabetical order
180  h1_lumi[-1].SetBarWidth(0.90)
181  h1_lumi[-1].SetTickLength(0.,"X")
182  h1_lumi[-1].SetMinimum(0.)
183  h1_lumi[-1].SetMaximum(max)
184  h1_lumi[-1].SetFillColor(colors[sys])
185  if sys == '_TOTAL':
186  h1_lumi[-1].SetFillStyle(3244)
187  ibin = h1_lumi[-1].GetXaxis().FindBin(sys)
188  #print (sys,ibin,colors[sys],lumi[sys]/TotalLumi,h1_lumi[-1].GetName())
189  h1_lumi[-1].SetBinContent(ibin,lumi[sys])
190  if lumi[sys] > 0. :
191  text_lumi.append(TText(lumi[sys]*1.1,ibin-1,"%.2f %%"%(100*lumi[sys]/TotalLumi)))
192  else:
193  text_lumi.append(TText(lumi[sys]*1.1,ibin-1,""))
194 
195 
196 
197  canvas = TCanvas( 'c_SummaryLumiLoss',"Summary Lumi Losses", 200, 10, 600, 700)
198  canvas.Divide(1,1)
199  canvas.cd(1)
200  gPad.SetTopMargin(0.15)
201  h1_frame.Draw("HBAR")
202  subtitle = TText(max,0.,name)
203  subtitle.SetTextSize(0.03)
204  subtitle.SetTextAngle(90)
205  subtitle.SetTextColor(kGray+1)
206  subtitle.Draw()
207  if empty:
208  bgtext = TText(0.5,round(len(loss)/2)-0.5,"No Luminosity Losses")
209  bgtext.SetTextAlign(22)
210  bgtext.SetTextColor(kRed)
211  bgtext.SetTextFont(43)
212  bgtext.SetTextSize(40)
213  bgtext.SetTextAngle(45)
214  bgtext.Draw()
215 
216  for i,h in enumerate(h1_lumi):
217  text_lumi[i].SetTextAlign(12) # Vertical align
218  text_lumi[i].SetTextSize(0.04) # Text Size
219  if not empty:
220  h.Draw("HBAR SAME")
221  text_lumi[i].Draw()
222  canvas.Update()
223  from CoolRunQuery.AtlRunQueryQueryConfig import QC
224  pname = QC.datapath+'/'+name+'_lumiloss.png'
225  canvas.Print(pname)
226  return pname
227 

◆ MapToSystem()

def python.html.AtlRunQueryDQSummary.MapToSystem (   defect)

Definition at line 32 of file AtlRunQueryDQSummary.py.

32 def MapToSystem(defect):
33 
34  # Store detectors/cp per "family" for readability
35  global_systems_map = {'LAR':'Calo','TILE':'Calo','CALO':'Calo',
36  'TAU':'Calo','EGAMMA':'Calo','JET':'Calo','MET':'Calo',
37  'ALFA':'Trigger & Lumi','LCD':'Trigger & Lumi',
38  'ZDC':'Trigger & Lumi','BCM':'Trigger & Lumi',
39  'LUMI':'Trigger & Lumi','TRIG':'Trigger & Lumi',
40  'GLOBAL':'Trigger & Lumi',
41  'MS_CSC':'Muon','MS_RPC':'Muon','MS_TGC':'Muon','MS_MDT':'Muon',
42  'MS':'Muon','MBTS':'Muon','MCP':'Muon',
43  'PIXEL':'Tracking','SCT':'Tracking','TRT':'Tracking',
44  'ID':'Tracking','BTAG':'Tracking'}
45  words = defect.split('_')
46  for w in words:
47  for item in global_systems_map:
48  if w in item:
49  return global_systems_map[item]
50  return ' '
51 

◆ SetXLabel()

def python.html.AtlRunQueryDQSummary.SetXLabel (   h,
  labels 
)

Definition at line 519 of file AtlRunQueryDQSummary.py.

519 def SetXLabel(h,labels):
520  for i in range(len(labels)):
521  h.GetXaxis().SetBinLabel(i+1,str(labels[i]))
522  return
523 

◆ SetYLabel()

def python.html.AtlRunQueryDQSummary.SetYLabel (   h,
  labels 
)

Definition at line 524 of file AtlRunQueryDQSummary.py.

524 def SetYLabel(h,labels):
525  for i in range(len(labels)):
526  h.GetYaxis().SetBinLabel(i+1,str(labels[i]))
527  return
528 

Variable Documentation

◆ datapath

python.html.AtlRunQueryDQSummary.datapath

Definition at line 1204 of file AtlRunQueryDQSummary.py.

◆ doDQPickle

python.html.AtlRunQueryDQSummary.doDQPickle

Definition at line 1209 of file AtlRunQueryDQSummary.py.

◆ pageinfo

python.html.AtlRunQueryDQSummary.pageinfo = pickle.load(open('%s/dqsum_pi.pickle' % QC.datapath))

Definition at line 1206 of file AtlRunQueryDQSummary.py.

◆ server

python.html.AtlRunQueryDQSummary.server = xmlrpc.client.ServerProxy('http://atlasdqm.cern.ch')

Definition at line 21 of file AtlRunQueryDQSummary.py.

python.html.AtlRunQueryDQSummary.MakePlot_SummaryLumiLoss
def MakePlot_SummaryLumiLoss(loss, colors, dicsum, name)
Definition: AtlRunQueryDQSummary.py:123
python.html.AtlRunQueryDQSummary.listify
def listify(lbl)
Definition: AtlRunQueryDQSummary.py:529
RootHelpers::FindBin
Int_t FindBin(const TAxis *axis, const double x)
Definition: RootHelpers.cxx:14
MuonGM::round
float round(const float toRound, const unsigned int decimals)
Definition: Mdt.cxx:27
GetEntries
TGraphErrors * GetEntries(TH2F *histo)
Definition: TRTCalib_makeplots.cxx:4019
python.html.AtlRunQueryDQSummary.SetXLabel
def SetXLabel(h, labels)
Definition: AtlRunQueryDQSummary.py:519
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
while
while((inf=(TStreamerInfo *) nextinfo()) !=0)
Definition: liststreamerinfos.cxx:13
python.output.AtlRunQueryRoot.SetStyle
def SetStyle(whiteCanvas=False)
Definition: AtlRunQueryRoot.py:28
python.html.AtlRunQueryDQSummary.SetYLabel
def SetYLabel(h, labels)
Definition: AtlRunQueryDQSummary.py:524
python.html.AtlRunQueryDQSummary.ComputeRunLumi
def ComputeRunLumi(dic, run, lumiperlb)
Definition: AtlRunQueryDQSummary.py:54
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
python.html.AtlRunQueryDQSummary.MapToSystem
def MapToSystem(defect)
Definition: AtlRunQueryDQSummary.py:32
TCS::join
std::string join(const std::vector< std::string > &v, const char c=',')
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/Root/StringUtils.cxx:10
python.html.AtlRunQueryDQSummary.MakePlot_PerRunLumiLoss
def MakePlot_PerRunLumiLoss(loss, colors, dicsum, name)
Definition: AtlRunQueryDQSummary.py:228
python.html.AtlRunQueryDQSummary.GetLBLiveFraction
def GetLBLiveFraction(dic, run)
Definition: AtlRunQueryDQSummary.py:96
python.html.AtlRunQueryDQSummary.GetLBReady
def GetLBReady(dic, run)
Definition: AtlRunQueryDQSummary.py:113
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
python.html.AtlRunQueryDQSummary.GetLBLumi
def GetLBLumi(dic, run)
Definition: AtlRunQueryDQSummary.py:65
str
Definition: BTagTrackIpAccessor.cxx:11
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
python.html.AtlRunQueryDQSummary.MakePlot_DefectsPerSystem
def MakePlot_DefectsPerSystem(sys, intolerable, tolerable, ignored, dic, run)
Definition: AtlRunQueryDQSummary.py:367
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65