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 55 of file AtlRunQueryDQSummary.py.

def ComputeRunLumi(dic,run,lumiperlb):
    # consider ATLAS ready only
    global readylb
    total = 0.
    for lbl in lumiperlb:
        if lbl not in readylb:
            continue
        total += lumiperlb[lbl]
    return total
 
 

GetLBLiveFraction()

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

Definition at line 97 of file AtlRunQueryDQSummary.py.

def GetLBLiveFraction(dic,run):
    global livetrigger
    livefraction = {}
    #trigrate = dic[DataKey('TriggerRates')][run][0].value['L1_EM5']
    triggerRates = dic[DataKey('TriggerRates')][run][0].value
    if triggerRates != "No match":
        try:
            trigrate = triggerRates[livetrigger]
            for item in trigrate:
                (lb, tbp, tap, tav) = map(int, item)
                livefraction[lb]= 0.
                if tap != 0:
                    livefraction[lb] = float(tav)/tap
        except KeyError:
            print ("%s trigger not found - no live fraction computation" % livetrigger)
    return livefraction
 

GetLBLumi()

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

Definition at line 66 of file AtlRunQueryDQSummary.py.

def GetLBLumi(dic,run):
    global lumifolder
    global usenb
    
    lumifolder = ''
    lumiperlb = {}
    for k,v in dic.items():
        if 'ofllumi' not in k.ResultKey:
            continue
        lumifolder = k.ResultKey
    if lumifolder == '':
        return lumiperlb
 
    lbdic = dic[DataKey(lumifolder)][run]
    lbtime = dic[DataKey('#LB')][run][1]
 
    for i,item in enumerate(lbdic):
        for lb in range(int(item.startlb),int(item.endlb)):
            lumiperlb[lb] = 0.
            if item.value == "n.a.":
                continue
            if (lbtime[lb]-lbtime[lb-1])<0:
                continue
            # change unit (pb/nb)
            scale = 0.001
            if usenb:
                scale = 1.
            lumiperlb[lb] = float(item.value)*(lbtime[lb]-lbtime[lb-1])*0.001*scale # output in nb-1/pb-1
            #print ("DEBUG",run,lb,float(item.value),lbtime[lb]-lbtime[lb-1])
    return lumiperlb
 

GetLBReady()

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

Definition at line 114 of file AtlRunQueryDQSummary.py.

def GetLBReady(dic,run):
    rlb = []
    for b in dic[DataKey('Ready for physics')][run]:
        for lb in range(b.startlb,b.endlb):
            if b.value == "1" :
                rlb.append(lb)
    return rlb
    
 

listify()

def python.html.AtlRunQueryDQSummary.listify

(

lbl

)

Definition at line 530 of file AtlRunQueryDQSummary.py.

def listify(lbl): # compactify lb lists
    if len(lbl) == 0 :
        return ''
    i = 0
    newlist=[]
    while i < len(lbl):
        start=lbl[i]
        j=i
        while(j+1<len(lbl) and lbl[j+1]==lbl[j]+1):
            j+=1
        end=lbl[j]
        i=j+1
        if start==end:
            newlist.append(start)
        else:
            newlist.append(str(start)+'-'+str(end))
    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 368 of file AtlRunQueryDQSummary.py.

def MakePlot_DefectsPerSystem(sys,intolerable,tolerable,ignored,dic,run):
 
    global readylb
 
    from CoolRunQuery.AtlRunQueryQueryConfig import QC
    
    hname = ['','','']
    h2_DefectVsLB = ['','','','']
 
    
    SetStyle()
    gStyle.SetTitleX(0.5)
    gStyle.SetTitleAlign(23)
 
    lbrange = readylb[-1]-readylb[0] # can be disconnected !
    #print (run,len(readylb),lbrange)
    
    
    if len(intolerable) > 0 :
        #TCol = TColor.GetColor( "#5D6B7D")
        TCol = TColor.GetColor( "#0f3a60")
        hname[0]= "%s_Intolerable_Run%s"%(sys,str(dic[DataKey('Run')][run]))
        htitle = "%s - Intolerable defects - Run %s"%(sys,str(dic[DataKey('Run')][run]))
        h2_DefectVsLB[0] = TH2F("h2_defectVsLB_%s"%hname[0],htitle,
                                lbrange,readylb[0]-0.5,readylb[-1]+0.5,
                                len(intolerable),0.,len(intolerable))
        h2_DefectVsLB[0].SetFillColor(TCol)
        h2_DefectVsLB[0].GetXaxis().SetTitle("Lumiblocks with ATLAS Ready")
        SetYLabel(h2_DefectVsLB[0],[defect for defect in intolerable])
        h2_DefectVsLB[0].LabelsOption("a","Y") # order Y label by alphabetical order
    
        # Text to store lumi loss number
        ttext = {}
        # Fill & Compute lumi losses
        for i,item in enumerate(intolerable):
            ibiny = h2_DefectVsLB[0].GetYaxis().FindBin(item)
            binxmax = h2_DefectVsLB[0].GetXaxis().GetXmax()
            frac = 100*float(len(intolerable[item]))/float(len(readylb))
            if frac> 0.:
                ttext[item] = TText(binxmax,ibiny-0.8,"  %.2f %%"%frac)
            else:
                ttext[item] = TText(binxmax,ibiny-0.8,"")
            ttext[item].SetTextSize(0.03)
            ttext[item].SetTextColor(TCol)
            for lb in intolerable[item]:
                if lb not in readylb:
                    continue
                ibinx = h2_DefectVsLB[0].GetXaxis().FindBin(lb)
                h2_DefectVsLB[0].SetBinContent(ibinx,ibiny,1.)
        
        # create png
        canvas = TCanvas( 'c_Int',"Systems Defects - %s"%hname[0], 200, 10, 1000, 800)
        canvas.Divide(1,1)
        canvas.cd(1)
        gPad.SetLeftMargin(0.40)
        gPad.SetRightMargin(0.1)
        h2_DefectVsLB[0].Draw("BOX")
        for item in intolerable:
            ttext[item].Draw()
        canvas.Update()
        hname[0] = QC.datapath+"/"+hname[0]+".png"
        canvas.Print(hname[0])
        
    
    if len(tolerable) > 0 :
 
        all = {**tolerable, **intolerable, **ignored}
 
        TCol1 = TColor.GetColor("#0f3a60")
        TCol2 = TColor.GetColor("#a3c0d9")
        TCol3 = TColor.GetColor("#4681b3")
        #TCol1 = TColor.GetColor("#015669")
        #TCol2 = TColor.GetColor("#5cbad0")
        #TCol3 = TColor.GetColor("#258aa1")
        hname[1]= "%s_All_Run%s"%(sys,str(dic[DataKey('Run')][run]))
        htitle = "%s - All defects - Run %s"%(sys,str(dic[DataKey('Run')][run]))
        
        # intolerable
        h2_DefectVsLB[1] = TH2F("h2_defectVsLB_int_%s"%hname[1],htitle,
                                lbrange,readylb[0]-0.5,readylb[-1]+0.5,
                                len(all),0.,len(all))
        # tolerable
        h2_DefectVsLB[2] = TH2F("h2_defectVsLB_tol_%s"%hname[1],htitle,
                                lbrange,readylb[0]-0.5,readylb[-1]+0.5,
                                len(all),0.,len(all))
        
        # ignored
        h2_DefectVsLB[3] = TH2F("h2_defectVsLB_ign_%s"%hname[1],htitle,
                                lbrange,readylb[0]-0.5,readylb[-1]+0.5,
                                len(all),0.,len(all))
        
        h2_DefectVsLB[1].SetFillColor(TCol1)
        h2_DefectVsLB[2].SetFillColor(TCol2)
        h2_DefectVsLB[3].SetFillColor(TCol3)
        #h2_DefectVsLB[3].SetFillStyle(3004) # not a great idea for single LBs
        h2_DefectVsLB[1].GetXaxis().SetTitle("Lumiblocks with ATLAS Ready")
        h2_DefectVsLB[2].GetXaxis().SetTitle("Lumiblocks with ATLAS Ready")
        h2_DefectVsLB[3].GetXaxis().SetTitle("Lumiblocks with ATLAS Ready")
        SetYLabel(h2_DefectVsLB[1],[defect for defect in all])
        SetYLabel(h2_DefectVsLB[2],[defect for defect in all])
        SetYLabel(h2_DefectVsLB[3],[defect for defect in all])
        h2_DefectVsLB[1].LabelsOption("a","Y") # order Y label by alphabetical order
        h2_DefectVsLB[2].LabelsOption("a","Y") # order Y label by alphabetical order
        h2_DefectVsLB[3].LabelsOption("a","Y") # order Y label by alphabetical order
 
        # Text to store lumi loss number
        ttext = {}
        
        # Fill 
        for i,item in enumerate(all):
            ibiny = h2_DefectVsLB[1].GetYaxis().FindBin(item)
            binxmax = h2_DefectVsLB[1].GetXaxis().GetXmax()
            frac = 100*float(len(all[item]))/float(len(readylb))
            if frac >0.:
                ttext[item] = TText(binxmax,ibiny-0.8,"  %.2f %%"%frac)
            else:
                ttext[item] = TText(binxmax,ibiny-0.8,"")
            ttext[item].SetTextSize(0.03)
            if item in intolerable:
                ttext[item].SetTextColor(TCol1)
            if item in tolerable:
                ttext[item].SetTextColor(TCol2)
            if item in ignored:
                ttext[item].SetTextColor(TCol3)    
            for lb in all[item]:
                ibinx = h2_DefectVsLB[1].GetXaxis().FindBin(lb)
                if item in intolerable:
                    h2_DefectVsLB[1].SetBinContent(ibinx,ibiny,1.)
                if item in tolerable:
                    h2_DefectVsLB[2].SetBinContent(ibinx,ibiny,1.)
                if item in ignored:
                    h2_DefectVsLB[3].SetBinContent(ibinx,ibiny,1.)
 
        # create png
        canvas = TCanvas( 'c_Tol',"Systems Defects - %s"%hname[1], 200, 10, 1000, 800)
        canvas.Divide(1,1)
        canvas.cd(1)
        gPad.SetLeftMargin(0.40)
        gPad.SetRightMargin(0.1)
        h2_DefectVsLB[2].Draw("BOX")
        h2_DefectVsLB[3].Draw("BOXSAME")
        h2_DefectVsLB[1].Draw("BOXSAME")
 
        for item in all:
            ttext[item].Draw()
        canvas.Update()
        hname[1] = QC.datapath+"/"+hname[1]+".png"
        canvas.Print(hname[1])
 
    return hname
 

MakePlot_PerRunLumiLoss()

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

Definition at line 229 of file AtlRunQueryDQSummary.py.

def MakePlot_PerRunLumiLoss(loss,colors,dicsum,name):
 
    global usenb
    global unit
 
    
    runs = []
    for r in loss['_TOTAL']:
        if loss['_TOTAL'][r]>0. :
            runs.append(r)
    #if len(runs) == 0 : return
    empty = False
    if len(runs) == 0 :
        empty = True
        runs.append("-")
    runs.sort()
 
    
    TotalLumi = dicsum[DataKey('TotalLumi')][0]
 
    
    SetStyle()
    gStyle.SetTitleX(0.5)
    gStyle.SetTitleAlign(23)
    
    
    h_stack = THStack("hs_PerRun","Luminosity Loss during ATLAS Ready [%s]"%unit)
 
    
    x0=0.17
    y0=0.62
    nsplits = 4
    dx = 0.2
    dy = 0.05
    leg = TLegend(x0,y0,x0+dx,y0+nsplits*dy)
    nhists = 0
 
    
    SHIFT = 0.1
    WIDTH = 0.4
    
    
    h1_total = TH1F("h1_total","",len(runs),-0.5,len(runs)-0.5)
    h1_total.SetMinimum(0.)
    h1_total.SetFillColor(colors['_TOTAL'])
    h1_total.SetFillStyle(3244)
    h1_total.SetBarWidth(WIDTH)
    h1_total.SetBarOffset(SHIFT+WIDTH)
 
    for r,run in enumerate(runs):
        if run != "-" and loss['_TOTAL'][run] > 0:
            h1_total.Fill(r,loss['_TOTAL'][run])
    nhists +=1
    leg.AddEntry(h1_total,'TOTAL',"f")
                
    
    h1_lumi = {}    
    for i,sys in enumerate(loss):
            
        if sys == '_TOTAL':
            continue
        
        h1_lumi[sys] = TH1F("h1_lumi_%s"%sys,"",len(runs),-0.5,len(runs)-0.5)
        h1_lumi[sys].SetMinimum(0.)
        h1_lumi[sys].SetFillColor(colors[sys])
        h1_lumi[sys].SetBarWidth(WIDTH)
        h1_lumi[sys].SetBarOffset(SHIFT)
        for r,run in enumerate(runs):
            if run != "-" and loss[sys][run]> 0.:
                h1_lumi[sys].Fill(r,loss[sys][run])
                
    
    for sys in h1_lumi:
        if h1_lumi[sys].GetEntries() > 0:
            h_stack.Add(h1_lumi[sys])
            leg.AddEntry(h1_lumi[sys],sys,"f")
            nhists +=1
            
    
    hmax = h_stack.GetMaximum()*1.6
 
    
    if len(runs) == 1:
        if runs[0] == "-":
            t1 = "            Run [-]"
        else:
            t1 = "            Run [%i]"%runs[0]  
    else:
        t1 = "       Runs [%i-%i]"%(runs[0],runs[-1])
 
    t2 = "ATLAS Ready Lumi: %.2f %s"%(TotalLumi,unit)
    h1_frame = TH1F("h1_frame_runs","#splitline{%s}{%s}"%(t1,t2),len(runs),-0.5,len(runs)-0.5)
    SetXLabel(h1_frame,runs)
    h1_frame.SetLabelSize(0.06,"X")
    h1_frame.SetMinimum(0.)
    h1_frame.GetYaxis().SetTitle("Luminosity Loss during ATLAS Ready [%s]"%unit) 
    h1_frame.GetYaxis().SetTitleOffset(1.3)
 
    
    canvas = TCanvas( 'c_PerRunLumiLoss',"Luminosity Losses Per Run", 200, 10, 600, 700)
    canvas.Divide(1,1)
    canvas.cd(1)
    gPad.SetTopMargin(0.15)
    h1_frame.SetMaximum(hmax)
    h_stack.SetMaximum(hmax)
    #h_total.SetBarOffset((shift)
    
    h1_frame.Draw("")
    h_stack.Draw("BARsame")
    h1_total.Draw("BARsame")
    ncolumns = int(math.ceil(float(nhists)/float(nsplits)))
    leg.SetNColumns(ncolumns)
    leg.Paint() # Draw once to access coordinates
    leg.SetX2NDC(leg.GetX1NDC()+ncolumns*dx) # Modify legend size w.r.t number of columns
    nrows = leg.GetNRows()
    leg.SetY2NDC(leg.GetY1NDC()+nrows*dy) # Modify legend size w.r.t number of rows
    if not empty:
        leg.Draw() # Draw again
 
    subtitle = TText(len(runs)-0.35,0.,name)
    subtitle.SetTextSize(0.03)
    subtitle.SetTextAngle(90)
    subtitle.SetTextColor(kGray+1)
    subtitle.Draw()
    if empty:
        bgtext = TText(0.0,0.5,"No Luminosity Losses")
        bgtext.SetTextAlign(22)
        bgtext.SetTextColor(kRed)
        bgtext.SetTextFont(43)
        bgtext.SetTextSize(40)
        bgtext.SetTextAngle(45)
        bgtext.Draw()
 
    canvas.Update()
    from CoolRunQuery.AtlRunQueryQueryConfig import QC
    pname = QC.datapath+'/'+name+'_lumiloss_perrun.png'
    canvas.Print(pname)
    return pname
 

MakePlot_SummaryLumiLoss()

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

Definition at line 124 of file AtlRunQueryDQSummary.py.

def MakePlot_SummaryLumiLoss(loss,colors,dicsum,name):
 
    global usenb
    global unit
 
    SetStyle()
    gStyle.SetTitleX(0.5)
    gStyle.SetTitleAlign(23)
 
    
    TotalLumi = dicsum[DataKey('TotalLumi')][0]
 
    
    xlabels = [s for s in loss]
 
    
    runs = [item for item in loss[xlabels[0]]]
    runs.sort()
 
    
    lumi = {}
    max = 0.
    for sys in loss:
        lumi[sys] = 0.
        for r in runs:
            lumi[sys] += loss[sys][r]
        if lumi[sys] > max:
            max=lumi[sys]
    max = max*1.5
 
    # if no entry, print no plot
    empty = False
    if max == 0.:
        empty = True
        max = 1.
        
 
    
    t1 = "       Runs [%i-%i]"%(runs[0],runs[-1])
    if len(runs) == 1:
        t1 = "            Run [%i]"%runs[0]
    t2 = "ATLAS Ready Lumi: %.2f %s"%(TotalLumi,unit)
    h1_frame = TH1F("h1_frame","#splitline{%s}{%s}"%(t1,t2),len(loss),-0.5,len(loss)-0.5)
    SetXLabel(h1_frame,xlabels)
    h1_frame.SetMinimum(0.)
    h1_frame.SetMaximum(max)
    h1_frame.SetTickLength(0.,"X")
    h1_frame.GetYaxis().SetTitle("Luminosity Loss during ATLAS Ready [%s]"%unit)
    h1_frame.LabelsOption("a","X") # order X label by alphabetical order
 
    
    h1_lumi = []
    text_lumi = []
    for sys in loss:
        h1_lumi.append(TH1F("h1_lumi_%s"%sys,"",len(loss),-0.5,len(loss)-0.5))
        SetXLabel(h1_lumi[-1],xlabels)
        h1_lumi[-1].LabelsOption("a","X") # order X label by alphabetical order
        h1_lumi[-1].SetBarWidth(0.90)
        h1_lumi[-1].SetTickLength(0.,"X")
        h1_lumi[-1].SetMinimum(0.)
        h1_lumi[-1].SetMaximum(max)
        h1_lumi[-1].SetFillColor(colors[sys])
        if sys == '_TOTAL':
            h1_lumi[-1].SetFillStyle(3244)
        ibin = h1_lumi[-1].GetXaxis().FindBin(sys)
        #print (sys,ibin,colors[sys],lumi[sys]/TotalLumi,h1_lumi[-1].GetName())
        h1_lumi[-1].SetBinContent(ibin,lumi[sys])
        if lumi[sys] > 0. :
            text_lumi.append(TText(lumi[sys]*1.1,ibin-1,"%.2f %%"%(100*lumi[sys]/TotalLumi)))
        else:
            text_lumi.append(TText(lumi[sys]*1.1,ibin-1,""))
 
    
    
    canvas = TCanvas( 'c_SummaryLumiLoss',"Summary Lumi Losses", 200, 10, 600, 700)
    canvas.Divide(1,1)
    canvas.cd(1)
    gPad.SetTopMargin(0.15)
    h1_frame.Draw("HBAR")
    subtitle = TText(max,0.,name)
    subtitle.SetTextSize(0.03)
    subtitle.SetTextAngle(90)
    subtitle.SetTextColor(kGray+1)
    subtitle.Draw()
    if empty:
        bgtext = TText(0.5,round(len(loss)/2)-0.5,"No Luminosity Losses")
        bgtext.SetTextAlign(22)
        bgtext.SetTextColor(kRed)
        bgtext.SetTextFont(43)
        bgtext.SetTextSize(40)
        bgtext.SetTextAngle(45)
        bgtext.Draw()
        
    for i,h in enumerate(h1_lumi):
        text_lumi[i].SetTextAlign(12) # Vertical align
        text_lumi[i].SetTextSize(0.04) # Text Size
        if not empty:
            h.Draw("HBAR SAME")
            text_lumi[i].Draw()
    canvas.Update()
    from CoolRunQuery.AtlRunQueryQueryConfig import QC
    pname = QC.datapath+'/'+name+'_lumiloss.png'
    canvas.Print(pname)
    return pname
 

MapToSystem()

def python.html.AtlRunQueryDQSummary.MapToSystem

(

defect

)

Definition at line 33 of file AtlRunQueryDQSummary.py.

def MapToSystem(defect):
 
    # Store detectors/cp per "family" for readability
    global_systems_map = {'LAR':'Calo','TILE':'Calo','CALO':'Calo',
                          'TAU':'Calo','EGAMMA':'Calo','JET':'Calo','MET':'Calo',
                          'ALFA':'Trigger & Lumi','LCD':'Trigger & Lumi',
                          'ZDC':'Trigger & Lumi','BCM':'Trigger & Lumi',
                          'LUMI':'Trigger & Lumi','TRIG':'Trigger & Lumi',
                          'GLOBAL':'Trigger & Lumi',
                          'MS_CSC':'Muon','MS_RPC':'Muon','MS_TGC':'Muon','MS_MDT':'Muon',
                          'MS':'Muon','MBTS':'Muon','MCP':'Muon',
                          'PIXEL':'Tracking','SCT':'Tracking','TRT':'Tracking',
                          'ID':'Tracking','BTAG':'Tracking'}
    words = defect.split('_')
    for w in words:
        for item in global_systems_map:
            if w in item:
                return global_systems_map[item]
    return ' '
 

SetXLabel()

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

Definition at line 520 of file AtlRunQueryDQSummary.py.

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

SetYLabel()

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

Definition at line 525 of file AtlRunQueryDQSummary.py.

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

Variable Documentation

datapath

python.html.AtlRunQueryDQSummary.datapath

Definition at line 1205 of file AtlRunQueryDQSummary.py.

doDQPickle

python.html.AtlRunQueryDQSummary.doDQPickle

Definition at line 1210 of file AtlRunQueryDQSummary.py.

pageinfo

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

Definition at line 1207 of file AtlRunQueryDQSummary.py.

server

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

Definition at line 22 of file AtlRunQueryDQSummary.py.