UserCode/RateMonShiftTool_dev/DatabaseRatePredictor.py

from DatabaseParser import *
import sys
import os
from numpy import *
import pickle

from ROOT import gROOT, TCanvas, TF1, TGraph, TGraphErrors, TPaveStats, gPad, gStyle
from ROOT import TFile, TPaveText
from ROOT import gBenchmark
import array
import math

def main():

    ######## TO CREATE FITS #########
##     run_list = [179497,179547,179558,179563,179889,179959,179977,180072,180076,180093,180241,180250,180252]
##     trig_name = "HLT"
##     num_ls = 20
##     debug_print = False

##     min_rate = 1.0
##     print_table = False
##     data_clean = True
##     ##plot_properties = [varX, varY, do_fit, save_root, save_png, overlay_fit, fit_file]
##     plot_properties = [["live", "rate", True, True, False, False, ""]]
##     masked_triggers = ["AlCa_", "DST_", "HLT_L1", "HLT_L2", "HLT_Zero"]
##     save_fits = True
    

    ######## TO SEE RATE VS PREDICTION ########
    run_list = [180241]

    trig_name = "Mu"
    num_ls = 1
    debug_print = False

    min_rate = 3.0
    print_table = False
    data_clean = False
    ##plot_properties = [varX, varY, do_fit, save_root, save_png, overlay_fit, fit_file]
    plot_properties = [["ls", "rawrate", False, True, False, True,"Fits/2011/Fit_HLT_20LS_Run179497to180252.pkl"]]
    masked_triggers = ["AlCa_", "DST_", "HLT_L1", "HLT_L2", "HLT_Zero"]
    save_fits = False
    
    
    ########  END PARAMETERS ##########
    
    Rates = GetDBRates(run_list, trig_name, num_ls, debug_print)
    MakePlots(Rates, run_list, trig_name, num_ls, min_rate, print_table, data_clean, plot_properties, masked_triggers, save_fits, debug_print)
    

def GetDBRates(run_list,trig_name,num_ls, debug_print):
    
    Rates = {}
    RefRunNameTemplate = "RefRuns/2011/Rates_%s_%sLS.pkl"
    RefRunFile = RefRunNameTemplate % (trig_name,num_ls)
    try:
        pkl_file = open(RefRunFile, 'rb')
        Rates = pickle.load(pkl_file)
        pkl_file.close()
        os.remove(RefRunFile)
    except:
        print str(RefRunFile)+" does not exist. Creating ..."

    for RefRunNum in run_list: #Will change to a "count back runs" scheme, or something like that

        try:
            ExistsAlready = False
            for key in Rates:
                if RefRunNum in Rates[key]["run"]:
                    ExistsAlready = True
                    break
            if ExistsAlready:
                continue
        except:
            print "Getting info for run "+str(RefRunNum)
        
        if RefRunNum < 1:
            continue

        if True:
            if True: #May replace with "try" - for now it's good to know when problems happen
                RefParser = DatabaseParser()
                RefParser.RunNumber = RefRunNum
                RefParser.ParseRunSetup()
                RefLumiRangePhysicsActive = RefParser.GetLSRange(1,9999)
                RefLumiArray = RefParser.GetLumiInfo()
                RefLumiRange = []
                for iterator in RefLumiArray[0]:
                    RefLumiRange.append(iterator)

                nls = RefLumiRange[0]
                LSRange = {}
                if nls >= RefLumiRange[-1]-num_ls:
                    print "Run "+str(RefRunNum)+" is too short: from "+str(nls)+" to "+str(RefLumiRange[-1])+", while num_ls = "+str(num_ls)
                    continue
                while nls < RefLumiRange[-1]-num_ls:
                    if num_ls > 1:
                        #LSRange[nls] = RefParser.GetLSRange(nls,num_ls)
                        LSRange[nls] = []
                        for iterator in RefLumiRange:
                            if iterator >= nls and iterator < nls+num_ls:
                                LSRange[nls].append(iterator)
                    else:
                        LSRange[nls] = [nls]
                    nls = LSRange[nls][-1]+1
                print "Run "+str(RefRunNum)+" contains LS from "+str(min(LSRange))+" to "+str(max(LSRange))
                for nls in LSRange:
                    TriggerRates = RefParser.GetHLTRates(LSRange[nls])
                
                    [inst, live, delivered, dead, pscols] = RefParser.GetAvLumiInfo(LSRange[nls])
                    physics = 1
                    active = 1
                    for iterator in LSRange[nls]:
                        if RefLumiArray[5][iterator] == 0:
                            physics = 0
                        if RefLumiArray[6][iterator] == 0:
                            active = 0

                    if live < 0:
                        print "Run "+str(RefRunNum)+" LS "+str(nls)+" live lumi = "+str(live)+", delivered = "+str(delivered)+", physics = "+str(physics)+", active = "+str(active)

                    for key in TriggerRates:
                        if not trig_name in key:
                            continue
                        name = key
                        if re.match('.*_v[0-9]+',name):
                            name = name[:name.rfind('_')]

                        if not Rates.has_key(name):
                            Rates[name] = {}
                            Rates[name]["run"] = []
                            Rates[name]["ls"] = []
                            Rates[name]["ps"] = []
                            Rates[name]["inst_lumi"] = []
                            Rates[name]["live_lumi"] = []
                            Rates[name]["delivered_lumi"] = []
                            Rates[name]["deadtime"] = []
                            Rates[name]["rawrate"] = []
                            Rates[name]["rate"] = []
                            Rates[name]["rawxsec"] = []
                            Rates[name]["xsec"] = []
                            Rates[name]["physics"] = []
                            Rates[name]["active"] = []
                        [avps, ps, rate, psrate] = TriggerRates[key]
                        Rates[name]["run"].append(RefRunNum)
                        Rates[name]["ls"].append(nls)
                        Rates[name]["ps"].append(ps)
                        Rates[name]["inst_lumi"].append(inst)
                        Rates[name]["live_lumi"].append(live)
                        Rates[name]["delivered_lumi"].append(delivered)
                        Rates[name]["deadtime"].append(dead)
                        Rates[name]["rawrate"].append(rate)
                        Rates[name]["rate"].append(psrate/(1.0-dead))
                        if live == 0:
                            Rates[name]["rawxsec"].append(0.0)
                            Rates[name]["xsec"].append(0.0)
                        else:
                            Rates[name]["rawxsec"].append(rate/live)
                            Rates[name]["xsec"].append(psrate/live)
                        Rates[name]["physics"].append(physics)
                        Rates[name]["active"].append(active)
            #except:
                #print "Failed to parse run "+str(RefRunNum)

    RateOutput = open(RefRunFile, 'wb')
    pickle.dump(Rates, RateOutput, 2)
    RateOutput.close()
    #print Rates
    return Rates

def MakePlots(Rates, run_list, trig_name, num_ls, min_rate, print_table, data_clean, plot_properties, masked_triggers, save_fits, debug_print):
    min_run = min(run_list)
    max_run = max(run_list)

    Input = {}
    Output = {}

    RootNameTemplate = "%s_%sLS_Run%sto%s.root"
    RootFile = RootNameTemplate % (trig_name, num_ls, min_run, max_run)

    for varX, varY, do_fit, save_root, save_png, overlay_fit, fit_file in plot_properties:
        if overlay_fit:
            pkl_file = open(fit_file, 'rb')
            Input = pickle.load(pkl_file)
            pkl_file.close()
        if save_root:
            try:
                os.remove(RootFile)
            except:
                break

    for print_trigger in Rates:
        meanrawrate = sum(Rates[print_trigger]["rawrate"])/len(Rates[print_trigger]["rawrate"])
        if not trig_name in print_trigger:
            continue
        if meanrawrate < min_rate:
            continue
        masked_trig = False
        for mask in masked_triggers:
            if str(mask) in print_trigger:
                masked_trig = True
        if masked_trig:
            continue
                
        Output[print_trigger] = {}

        lowlumi = 0
        numzeroes = 0
        for live_lumi in Rates[print_trigger]["live_lumi"]:
            if live_lumi < 1:
                numzeroes+=1
        meanlumi_init = sum(Rates[print_trigger]["live_lumi"])/(len(Rates[print_trigger]["live_lumi"])-numzeroes)
        meanlumi = 0
        highlumi = 0
        lowxsec = 0
        meanxsec = 0
        highxsec = 0
        nlow = 0
        nhigh = 0
        for iterator in range(len(Rates[print_trigger]["rate"])):
            if not Rates[print_trigger]["run"][iterator] in run_list:
                continue
            if Rates[print_trigger]["live_lumi"][iterator] <= meanlumi_init:
                if not data_clean or ( Rates[print_trigger]["rawrate"][iterator] > 0.04 and Rates[print_trigger]["physics"][iterator] == 1 and Rates[print_trigger]["active"][iterator] == 1):
                    meanxsec+=Rates[print_trigger]["xsec"][iterator]
                    lowxsec+=Rates[print_trigger]["xsec"][iterator]
                    meanlumi+=Rates[print_trigger]["live_lumi"][iterator]
                    lowlumi+=Rates[print_trigger]["live_lumi"][iterator]
                    nlow+=1
            if Rates[print_trigger]["live_lumi"][iterator] > meanlumi_init:
                if not data_clean or ( Rates[print_trigger]["rawrate"][iterator] > 0.04 and Rates[print_trigger]["physics"][iterator] == 1 and Rates[print_trigger]["active"][iterator] == 1):
                    meanxsec+=Rates[print_trigger]["xsec"][iterator]
                    highxsec+=Rates[print_trigger]["xsec"][iterator]
                    meanlumi+=Rates[print_trigger]["live_lumi"][iterator]
                    highlumi+=Rates[print_trigger]["live_lumi"][iterator]
                    nhigh+=1
        meanxsec = meanxsec/(nlow+nhigh)
        meanlumi = meanlumi/(nlow+nhigh)
        slopexsec = ( (highxsec/nhigh) - (lowxsec/nlow) ) / ( (highlumi/nhigh) - (lowlumi/nlow) )

        run_t = array.array('f')
        ls_t = array.array('f')
        ps_t = array.array('f')
        inst_t = array.array('f')
        live_t = array.array('f')
        delivered_t = array.array('f')
        deadtime_t = array.array('f')
        rawrate_t = array.array('f')
        rate_t = array.array('f')
        rawxsec_t = array.array('f')
        xsec_t = array.array('f')

        e_run_t = array.array('f')
        e_ls_t = array.array('f')
        e_ps_t = array.array('f')
        e_inst_t = array.array('f')
        e_live_t = array.array('f')
        e_delivered_t = array.array('f')
        e_deadtime_t = array.array('f')
        e_rawrate_t = array.array('f')
        e_rate_t = array.array('f')
        e_rawxsec_t = array.array('f')
        e_xsec_t = array.array('f')

        rawrate_fit_t = array.array('f')
        rate_fit_t = array.array('f')
        rawxsec_fit_t = array.array('f')
        xsec_fit_t = array.array('f')
        e_rawrate_fit_t = array.array('f')
        e_rate_fit_t = array.array('f')
        e_rawxsec_fit_t = array.array('f')
        e_xsec_fit_t = array.array('f')

        if overlay_fit:
            X0 = Input[print_trigger][0]
            X1 = Input[print_trigger][1]
            X2 = Input[print_trigger][2]
            Chi2 = Input[print_trigger][3]
            
        for iterator in range(len(Rates[print_trigger]["rate"])):
            if not Rates[print_trigger]["run"][iterator] in run_list:
                continue
            prediction = meanxsec + slopexsec * (Rates[print_trigger]["live_lumi"][iterator] - meanlumi)
            realvalue = Rates[print_trigger]["xsec"][iterator]
            if not data_clean or ( ((realvalue > 0.4*prediction and realvalue < 2.5*prediction) or (realvalue > 0.4*meanxsec and realvalue < 2.5*meanxsec) or prediction < 0 ) and Rates[print_trigger]["physics"][iterator] == 1 and Rates[print_trigger]["active"][iterator] == 1 ):
                run_t.append(Rates[print_trigger]["run"][iterator])
                ls_t.append(Rates[print_trigger]["ls"][iterator])
                ps_t.append(Rates[print_trigger]["ps"][iterator])
                inst_t.append(Rates[print_trigger]["inst_lumi"][iterator])
                live_t.append(Rates[print_trigger]["live_lumi"][iterator])
                delivered_t.append(Rates[print_trigger]["delivered_lumi"][iterator])
                deadtime_t.append(Rates[print_trigger]["deadtime"][iterator])
                rawrate_t.append(Rates[print_trigger]["rawrate"][iterator])
                rate_t.append(Rates[print_trigger]["rate"][iterator])
                rawxsec_t.append(Rates[print_trigger]["rawxsec"][iterator])
                xsec_t.append(Rates[print_trigger]["xsec"][iterator])

                e_run_t.append(0.0)
                e_ls_t.append(0.0)
                e_ps_t.append(0.0)
                e_inst_t.append(14.14)
                e_live_t.append(14.14)
                e_delivered_t.append(14.14)
                e_deadtime_t.append(0.01)
                e_rawrate_t.append(math.sqrt(Rates[print_trigger]["rawrate"][iterator]/(num_ls*23.3)))
                e_rate_t.append(Rates[print_trigger]["ps"][iterator]*math.sqrt(Rates[print_trigger]["rawrate"][iterator]/(num_ls*23.3)))
                if live_t[-1] == 0:
                    e_rawxsec_t.append(0)
                    e_xsec_t.append(0)
                else:
                    e_rawxsec_t.append(math.sqrt(Rates[print_trigger]["rawrate"][iterator]/(num_ls*23.3))/Rates[print_trigger]["live_lumi"][iterator])
                    e_xsec_t.append(Rates[print_trigger]["ps"][iterator]*math.sqrt(Rates[print_trigger]["rawrate"][iterator]/(num_ls*23.3))/Rates[print_trigger]["live_lumi"][iterator])

                if overlay_fit:
                    rate_prediction = X0 + X1*delivered_t[-1] + X2*delivered_t[-1]*delivered_t[-1]
                    if rate_t[-1] < 0.7 * rate_prediction or rate_t[-1] > 1.4 * rate_prediction:
                        print str(run_t[-1])+"  "+str(ls_t[-1])+"  "+str(print_trigger)+"  "+str(ps_t[-1])+"  "+str(deadtime_t[-1])+"  "+str(rate_prediction)+"  "+str(rate_t[-1])+"  "+str(rawrate_t[-1])
                    rawrate_fit_t.append(rate_prediction*(1.0-deadtime_t[-1])/(ps_t[-1]))
                    rate_fit_t.append(rate_prediction)
                    if live_t[-1] == 0:
                        rawxsec_fit_t.append(0)
                        xsec_fit_t.append(0)
                    else:
                        rawxsec_fit_t.append(rate_prediction/(ps_t[-1]*live_t[-1]))
                        xsec_fit_t.append(rate_prediction/live_t[-1])
                    e_rawrate_fit_t.append(e_rawrate_t[-1]*sqrt(Chi2))
                    e_rate_fit_t.append(e_rate_t[-1]*sqrt(Chi2))
                    e_rawxsec_fit_t.append(e_rawxsec_t[-1]*sqrt(Chi2))
                    e_xsec_fit_t.append(e_xsec_t[-1]*sqrt(Chi2))
 
            else:
                if debug_print:
                    print str(print_trigger)+" has xsec "+str(round(Rates[print_trigger]["xsec"][iterator],6))+" at lumi "+str(round(Rates[print_trigger]["live_lumi"][iterator],2))+" where the expected value is "+str(prediction)

        for varX, varY, do_fit, save_root, save_png, overlay_fit, fit_file in plot_properties:
            if varX == "run":
                VX = run_t
                VXE = run_t_e
            elif varX == "ls":
                VX = ls_t
                VXE = e_ls_t
            elif varX == "ps":
                VX = ps_t
                VXE = e_ps_t
            elif varX == "inst":
                VX = inst_t
                VXE = e_inst_t
            elif varX == "live":
                VX = live_t
                VXE = e_live_t
            elif varX == "delivered":
                VX = delivered_t
                VXE = e_delivered_t
            elif varX == "deadtime":
                VX = deadtime_t
                VXE = e_deadtime_t
                print deadtime_t
            elif varX == "rawrate":
                VX = rawrate_t
                VXE = e_rawrate_t
            elif varX == "rate":
                VX = rate_t
                VXE = e_rate_t
            elif varX == "rawxsec":
                VX = rawxsec_t
                VXE = e_rawxsec_t
            elif varX == "xsec":
                VX = xsec_t
                VXE = e_xsec_t
            else:
                print "No valid variable entered for X"
                continue
            if varY == "run":
                VY = run_t
                VYE = run_t_e
            elif varY == "ls":
                VY = ls_t
                VYE = e_ls_t
            elif varY == "ps":
                VY = ps_t
                VYE = e_ps_t
            elif varY == "inst":
                VY = inst_t
                VYE = e_inst_t
            elif varY == "live":
                VY = live_t
                VYE = e_live_t
            elif varY == "delivered":
                VY = delivered_t
                VYE = e_delivered_t
            elif varY == "deadtime":
                VY = deadtime_t
                VYE = e_deadtime_t
            elif varY == "rawrate":
                VY = rawrate_t
                VYE = e_rawrate_t
                if overlay_fit:
                    VF = rawrate_fit_t
                    VFE = e_rawrate_fit_t
            elif varY == "rate":
                VY = rate_t
                VYE = e_rate_t
                if overlay_fit:
                    VF = rate_fit_t
                    VFE = e_rate_fit_t
            elif varY == "rawxsec":
                VY = rawxsec_t
                VYE = e_rawxsec_t
                if overlay_fit:
                    VF = rawxsec_fit_t
                    VFE = e_rawxsec_fit_t
            elif varY == "xsec":
                VY = xsec_t
                VYE = e_xsec_t
                if overlay_fit:
                    VF = xsec_fit_t
                    VFE = e_xsec_fit_t
            else:
                print "No valid variable entered for Y"
                continue


            if save_root or save_png:
                c1 = TCanvas(str(varX),str(varY))
                c1.SetName(str(print_trigger)+"_"+str(varY)+"_vs_"+str(varX))

            gr1 = TGraphErrors(len(VX), VX, VY, VXE, VYE)
            gr1.SetName("Graph_"+str(print_trigger)+"_"+str(varY)+"_vs_"+str(varX))
            gr1.GetXaxis().SetTitle(varX)
            gr1.GetYaxis().SetTitle(varY)
            gr1.SetTitle(str(print_trigger))
            gr1.SetMinimum(0)
            gr1.SetMaximum(1.2*max(VY))
            gr1.GetXaxis().SetLimits(min(VX)-0.2*max(VX),1.2*max(VX))
            gr1.SetMarkerStyle(8)
            if overlay_fit:
                gr1.SetMarkerSize(0.8)
            else:
                gr1.SetMarkerSize(0.5)
            gr1.SetMarkerColor(2)

##             gr2 = TGraphErrors(len(VX), live_t, xsec_t, e_live_t, e_xsec_t)

            if overlay_fit:
                gr3 = TGraphErrors(len(VX), VX, VF, VXE, VFE)
                gr3.SetMarkerStyle(8)
                gr3.SetMarkerSize(0.4)
                gr3.SetMarkerColor(4)
                gr3.SetFillColor(4)
                gr3.SetFillStyle(3003)
            
            if do_fit:
                if "rate" in varY:
##                     f2a = TF1("f2a","pol1",0,8000)
##                     f2a.SetParLimits(0,0,meanxsec*1.5)
##                     if slopexsec > 0:
##                         f2a.SetParLimits(1,0,max(xsec_t)/max(live_t))
##                     else:
##                         f2a.SetParLimits(1,2*slopexsec,-2*slopexsec)
##                     gr2.Fit("f2a","Q","rob=0.80")
                    
                    f1a = TF1("f1a","pol2",0,8000)
                    f1a.SetLineColor(4)
                    f1a.SetLineWidth(2)
                    f1a.SetParLimits(0,0,1000)
                    f1a.SetParLimits(1,0,1000)
                    #gr1.Fit("f1a","B","Q")
                    gr1.Fit("f1a","Q","rob=0.80")

                    if f1a.GetChisquare()/f1a.GetNDF() > 20:
                        f1b = TF1("f1b","pol3",0,8000)
                        f1b.SetLineColor(4)
                        f1b.SetLineWidth(2)
                        f1b.SetParLimits(0,0,1000)
                        f1b.SetParLimits(1,0,1000)
                        f1b.SetParLimits(2,0,1000)
                        gr1.Fit("f1b","Q","rob=0.80")
                        if f1b.GetChisquare()/f1b.GetNDF() < f1a.GetChisquare()/f1a.GetNDF():
                            print str(print_trigger)+" f1a Chi2 = "+str(f1a.GetChisquare()/f1a.GetNDF())+", f1b Chi2 = "+str(f1b.GetChisquare()/f1b.GetNDF())
                        

##                     f1b = TF1("f1b","pol2",0,8000)
##                     f1b.SetParameters(0.0,f2a.GetParameter(0),f2a.GetParameter(1))
##                     f1b.SetLineColor(3)
##                     f1b.SetLineWidth(2)
                    
                else:
                    f1a = TF1("f1a","pol1",0,8000)
                    f1a.SetLineColor(4)
                    f1a.SetLineWidth(2)
                    if "xsec" in varY:
                        f1a.SetParLimits(0,0,meanxsec*1.5)
                        if slopexsec > 0:
                            f1a.SetParLimits(1,0,max(VY)/max(VX))
                        else:
                            f1a.SetParLimits(1,2*slopexsec,-2*slopexsec)
                    else:
                        f1a.SetParLimits(0,0,1000)
                    gr1.Fit("f1a","Q","rob=0.80")

            if save_root or save_png:
                gr1.Draw("APZ")
                if overlay_fit:
                    gr3.Draw("P3")
                if do_fit:
                    #if f1b and f1b.GetChisquare()/f1b.GetNDF() < f1a.GetChisquare()/f1a.GetNDF():
                        #f1b.Draw("same")
                    #else:
                    f1a.Draw("same")
##                     if "rate" in varY:
##                         f1b.Draw("same")
                c1.Update()
                if save_root:
                    myfile = TFile( RootFile, 'UPDATE' )
                    c1.Write()
                    myfile.Close()
                if save_png:
                    c1.SaveAs(str(print_trigger)+"_"+str(varY)+"_vs_"+str(varX)+".png")
                
        
        ##p1 = TPaveStats()                                                                                                                              
        ##p1 = gr1.GetListOfFunctions().FindObject("stats")                                                                                              
        ##print p1                                                                                                                                       
        ##gr1.PaintStats(f1b).Draw("same")                                                                                                               

        if print_table or save_fits:
            Output[print_trigger] = [f1a.GetParameter(0), f1a.GetParameter(1), f1a.GetParameter(2), f1a.GetChisquare()/f1a.GetNDF(), f1a.GetParameter(0)+5000*(f1a.GetParameter(1)+f1a.GetParameter(2)*5000), meanrawrate]

    if save_root:
        print "Output root file is "+str(RootFile)

    if save_fits:
        FitNameTemplate = "Fits/2011/Fit_%s_%sLS_Run%sto%s.pkl"
        FitFile = FitNameTemplate % (trig_name, num_ls, min_run, max_run)
        if os.path.exists(FitFile):
            os.remove(FitFile)
        FitOutput = open(FitFile, 'wb')
        pickle.dump(Output, FitOutput, 2)
        FitOutput.close()

    if print_table:
        print '%60s%10s%10s%10s%10s%10s%10s' % ("Trig", "p0", "p1", "p2", "Chi2", "5e33 pred", "Av raw")
        for print_trigger in Output:
            _trigger = (print_trigger[:56] + '...') if len(print_trigger) > 59 else print_trigger
            try:
                print '%60s%10s%10s%10s%10s%10s%10s' % (_trigger, round(Output[print_trigger][0],3), round(Output[print_trigger][1],6)*1000, round(Output[print_trigger][2],9)*1000000, round(Output[print_trigger][3],2), round(Output[print_trigger][4],2) , round(Output[print_trigger][5],3))
            except:
                print str(print_trigger)+" is somehow broken"

if __name__=='__main__':
    main()
Revision:	1.2
Committed:	Tue Feb 28 18:28:09 2012 UTC (13 years, 2 months ago) by abrinke1
Content type:	text/x-python
Branch:	MAIN
Changes since 1.1:	+79 -18 lines
Log Message:	Corrected live/deliv reversal error, added Phys/Active option, better fits
#	User	Rev	Content
1	abrinke1	1.1	from DatabaseParser import *
2			import sys
3			import os
4			from numpy import *
5			import pickle
6
7			from ROOT import gROOT, TCanvas, TF1, TGraph, TGraphErrors, TPaveStats, gPad, gStyle
8			from ROOT import TFile, TPaveText
9			from ROOT import gBenchmark
10			import array
11			import math
12
13			def main():
14
15			######## TO CREATE FITS #########
16			## run_list = [179497,179547,179558,179563,179889,179959,179977,180072,180076,180093,180241,180250,180252]
17			## trig_name = "HLT"
18			## num_ls = 20
19			## debug_print = False
20
21			## min_rate = 1.0
22			## print_table = False
23			## data_clean = True
24			## ##plot_properties = [varX, varY, do_fit, save_root, save_png, overlay_fit, fit_file]
25			## plot_properties = [["live", "rate", True, True, False, False, ""]]
26			## masked_triggers = ["AlCa_", "DST_", "HLT_L1", "HLT_L2", "HLT_Zero"]
27			## save_fits = True
28
29
30			######## TO SEE RATE VS PREDICTION ########
31			run_list = [180241]
32
33			trig_name = "Mu"
34			num_ls = 1
35			debug_print = False
36
37			min_rate = 3.0
38			print_table = False
39			data_clean = False
40			##plot_properties = [varX, varY, do_fit, save_root, save_png, overlay_fit, fit_file]
41			plot_properties = [["ls", "rawrate", False, True, False, True,"Fits/2011/Fit_HLT_20LS_Run179497to180252.pkl"]]
42			masked_triggers = ["AlCa_", "DST_", "HLT_L1", "HLT_L2", "HLT_Zero"]
43			save_fits = False
44
45	abrinke1	1.2
46	abrinke1	1.1	######## END PARAMETERS ##########
47
48			Rates = GetDBRates(run_list, trig_name, num_ls, debug_print)
49			MakePlots(Rates, run_list, trig_name, num_ls, min_rate, print_table, data_clean, plot_properties, masked_triggers, save_fits, debug_print)
50
51
52			def GetDBRates(run_list,trig_name,num_ls, debug_print):
53
54			Rates = {}
55			RefRunNameTemplate = "RefRuns/2011/Rates_%s_%sLS.pkl"
56			RefRunFile = RefRunNameTemplate % (trig_name,num_ls)
57			try:
58			pkl_file = open(RefRunFile, 'rb')
59			Rates = pickle.load(pkl_file)
60			pkl_file.close()
61			os.remove(RefRunFile)
62			except:
63			print str(RefRunFile)+" does not exist. Creating ..."
64
65			for RefRunNum in run_list: #Will change to a "count back runs" scheme, or something like that
66
67			try:
68			ExistsAlready = False
69			for key in Rates:
70			if RefRunNum in Rates[key]["run"]:
71			ExistsAlready = True
72			break
73			if ExistsAlready:
74			continue
75			except:
76			print "Getting info for run "+str(RefRunNum)
77
78			if RefRunNum < 1:
79			continue
80
81			if True:
82			if True: #May replace with "try" - for now it's good to know when problems happen
83			RefParser = DatabaseParser()
84			RefParser.RunNumber = RefRunNum
85			RefParser.ParseRunSetup()
86	abrinke1	1.2	RefLumiRangePhysicsActive = RefParser.GetLSRange(1,9999)
87			RefLumiArray = RefParser.GetLumiInfo()
88			RefLumiRange = []
89			for iterator in RefLumiArray[0]:
90			RefLumiRange.append(iterator)
91	abrinke1	1.1
92			nls = RefLumiRange[0]
93			LSRange = {}
94			if nls >= RefLumiRange[-1]-num_ls:
95			print "Run "+str(RefRunNum)+" is too short: from "+str(nls)+" to "+str(RefLumiRange[-1])+", while num_ls = "+str(num_ls)
96			continue
97			while nls < RefLumiRange[-1]-num_ls:
98			if num_ls > 1:
99	abrinke1	1.2	#LSRange[nls] = RefParser.GetLSRange(nls,num_ls)
100			LSRange[nls] = []
101			for iterator in RefLumiRange:
102			if iterator >= nls and iterator < nls+num_ls:
103			LSRange[nls].append(iterator)
104	abrinke1	1.1	else:
105			LSRange[nls] = [nls]
106			nls = LSRange[nls][-1]+1
107			print "Run "+str(RefRunNum)+" contains LS from "+str(min(LSRange))+" to "+str(max(LSRange))
108			for nls in LSRange:
109			TriggerRates = RefParser.GetHLTRates(LSRange[nls])
110	abrinke1	1.2
111	abrinke1	1.1	[inst, live, delivered, dead, pscols] = RefParser.GetAvLumiInfo(LSRange[nls])
112	abrinke1	1.2	physics = 1
113			active = 1
114			for iterator in LSRange[nls]:
115			if RefLumiArray[5][iterator] == 0:
116			physics = 0
117			if RefLumiArray[6][iterator] == 0:
118			active = 0
119
120			if live < 0:
121			print "Run "+str(RefRunNum)+" LS "+str(nls)+" live lumi = "+str(live)+", delivered = "+str(delivered)+", physics = "+str(physics)+", active = "+str(active)
122
123	abrinke1	1.1	for key in TriggerRates:
124			if not trig_name in key:
125			continue
126			name = key
127			if re.match('.*_v[0-9]+',name):
128			name = name[:name.rfind('_')]
129
130			if not Rates.has_key(name):
131			Rates[name] = {}
132			Rates[name]["run"] = []
133			Rates[name]["ls"] = []
134			Rates[name]["ps"] = []
135			Rates[name]["inst_lumi"] = []
136			Rates[name]["live_lumi"] = []
137			Rates[name]["delivered_lumi"] = []
138			Rates[name]["deadtime"] = []
139			Rates[name]["rawrate"] = []
140			Rates[name]["rate"] = []
141			Rates[name]["rawxsec"] = []
142			Rates[name]["xsec"] = []
143	abrinke1	1.2	Rates[name]["physics"] = []
144			Rates[name]["active"] = []
145	abrinke1	1.1	[avps, ps, rate, psrate] = TriggerRates[key]
146			Rates[name]["run"].append(RefRunNum)
147			Rates[name]["ls"].append(nls)
148			Rates[name]["ps"].append(ps)
149			Rates[name]["inst_lumi"].append(inst)
150			Rates[name]["live_lumi"].append(live)
151			Rates[name]["delivered_lumi"].append(delivered)
152			Rates[name]["deadtime"].append(dead)
153			Rates[name]["rawrate"].append(rate)
154			Rates[name]["rate"].append(psrate/(1.0-dead))
155	abrinke1	1.2	if live == 0:
156			Rates[name]["rawxsec"].append(0.0)
157			Rates[name]["xsec"].append(0.0)
158			else:
159			Rates[name]["rawxsec"].append(rate/live)
160			Rates[name]["xsec"].append(psrate/live)
161			Rates[name]["physics"].append(physics)
162			Rates[name]["active"].append(active)
163	abrinke1	1.1	#except:
164			#print "Failed to parse run "+str(RefRunNum)
165
166			RateOutput = open(RefRunFile, 'wb')
167			pickle.dump(Rates, RateOutput, 2)
168			RateOutput.close()
169			#print Rates
170			return Rates
171
172			def MakePlots(Rates, run_list, trig_name, num_ls, min_rate, print_table, data_clean, plot_properties, masked_triggers, save_fits, debug_print):
173			min_run = min(run_list)
174			max_run = max(run_list)
175
176			Input = {}
177			Output = {}
178
179			RootNameTemplate = "%s_%sLS_Run%sto%s.root"
180			RootFile = RootNameTemplate % (trig_name, num_ls, min_run, max_run)
181
182			for varX, varY, do_fit, save_root, save_png, overlay_fit, fit_file in plot_properties:
183			if overlay_fit:
184			pkl_file = open(fit_file, 'rb')
185			Input = pickle.load(pkl_file)
186			pkl_file.close()
187			if save_root:
188			try:
189			os.remove(RootFile)
190			except:
191			break
192
193			for print_trigger in Rates:
194			meanrawrate = sum(Rates[print_trigger]["rawrate"])/len(Rates[print_trigger]["rawrate"])
195			if not trig_name in print_trigger:
196			continue
197			if meanrawrate < min_rate:
198			continue
199			masked_trig = False
200			for mask in masked_triggers:
201			if str(mask) in print_trigger:
202			masked_trig = True
203			if masked_trig:
204			continue
205
206			Output[print_trigger] = {}
207
208			lowlumi = 0
209	abrinke1	1.2	numzeroes = 0
210			for live_lumi in Rates[print_trigger]["live_lumi"]:
211			if live_lumi < 1:
212			numzeroes+=1
213			meanlumi_init = sum(Rates[print_trigger]["live_lumi"])/(len(Rates[print_trigger]["live_lumi"])-numzeroes)
214	abrinke1	1.1	meanlumi = 0
215			highlumi = 0
216			lowxsec = 0
217			meanxsec = 0
218			highxsec = 0
219			nlow = 0
220			nhigh = 0
221			for iterator in range(len(Rates[print_trigger]["rate"])):
222			if not Rates[print_trigger]["run"][iterator] in run_list:
223			continue
224			if Rates[print_trigger]["live_lumi"][iterator] <= meanlumi_init:
225	abrinke1	1.2	if not data_clean or ( Rates[print_trigger]["rawrate"][iterator] > 0.04 and Rates[print_trigger]["physics"][iterator] == 1 and Rates[print_trigger]["active"][iterator] == 1):
226	abrinke1	1.1	meanxsec+=Rates[print_trigger]["xsec"][iterator]
227			lowxsec+=Rates[print_trigger]["xsec"][iterator]
228			meanlumi+=Rates[print_trigger]["live_lumi"][iterator]
229			lowlumi+=Rates[print_trigger]["live_lumi"][iterator]
230			nlow+=1
231			if Rates[print_trigger]["live_lumi"][iterator] > meanlumi_init:
232	abrinke1	1.2	if not data_clean or ( Rates[print_trigger]["rawrate"][iterator] > 0.04 and Rates[print_trigger]["physics"][iterator] == 1 and Rates[print_trigger]["active"][iterator] == 1):
233	abrinke1	1.1	meanxsec+=Rates[print_trigger]["xsec"][iterator]
234			highxsec+=Rates[print_trigger]["xsec"][iterator]
235			meanlumi+=Rates[print_trigger]["live_lumi"][iterator]
236			highlumi+=Rates[print_trigger]["live_lumi"][iterator]
237			nhigh+=1
238			meanxsec = meanxsec/(nlow+nhigh)
239			meanlumi = meanlumi/(nlow+nhigh)
240			slopexsec = ( (highxsec/nhigh) - (lowxsec/nlow) ) / ( (highlumi/nhigh) - (lowlumi/nlow) )
241
242			run_t = array.array('f')
243			ls_t = array.array('f')
244			ps_t = array.array('f')
245			inst_t = array.array('f')
246			live_t = array.array('f')
247			delivered_t = array.array('f')
248			deadtime_t = array.array('f')
249			rawrate_t = array.array('f')
250			rate_t = array.array('f')
251			rawxsec_t = array.array('f')
252			xsec_t = array.array('f')
253
254			e_run_t = array.array('f')
255			e_ls_t = array.array('f')
256			e_ps_t = array.array('f')
257			e_inst_t = array.array('f')
258			e_live_t = array.array('f')
259			e_delivered_t = array.array('f')
260			e_deadtime_t = array.array('f')
261			e_rawrate_t = array.array('f')
262			e_rate_t = array.array('f')
263			e_rawxsec_t = array.array('f')
264			e_xsec_t = array.array('f')
265
266			rawrate_fit_t = array.array('f')
267			rate_fit_t = array.array('f')
268			rawxsec_fit_t = array.array('f')
269			xsec_fit_t = array.array('f')
270			e_rawrate_fit_t = array.array('f')
271			e_rate_fit_t = array.array('f')
272			e_rawxsec_fit_t = array.array('f')
273			e_xsec_fit_t = array.array('f')
274
275			if overlay_fit:
276			X0 = Input[print_trigger][0]
277			X1 = Input[print_trigger][1]
278			X2 = Input[print_trigger][2]
279			Chi2 = Input[print_trigger][3]
280
281			for iterator in range(len(Rates[print_trigger]["rate"])):
282			if not Rates[print_trigger]["run"][iterator] in run_list:
283			continue
284			prediction = meanxsec + slopexsec * (Rates[print_trigger]["live_lumi"][iterator] - meanlumi)
285			realvalue = Rates[print_trigger]["xsec"][iterator]
286	abrinke1	1.2	if not data_clean or ( ((realvalue > 0.4prediction and realvalue < 2.5prediction) or (realvalue > 0.4meanxsec and realvalue < 2.5meanxsec) or prediction < 0 ) and Rates[print_trigger]["physics"][iterator] == 1 and Rates[print_trigger]["active"][iterator] == 1 ):
287	abrinke1	1.1	run_t.append(Rates[print_trigger]["run"][iterator])
288			ls_t.append(Rates[print_trigger]["ls"][iterator])
289			ps_t.append(Rates[print_trigger]["ps"][iterator])
290			inst_t.append(Rates[print_trigger]["inst_lumi"][iterator])
291			live_t.append(Rates[print_trigger]["live_lumi"][iterator])
292			delivered_t.append(Rates[print_trigger]["delivered_lumi"][iterator])
293			deadtime_t.append(Rates[print_trigger]["deadtime"][iterator])
294			rawrate_t.append(Rates[print_trigger]["rawrate"][iterator])
295			rate_t.append(Rates[print_trigger]["rate"][iterator])
296			rawxsec_t.append(Rates[print_trigger]["rawxsec"][iterator])
297			xsec_t.append(Rates[print_trigger]["xsec"][iterator])
298
299			e_run_t.append(0.0)
300			e_ls_t.append(0.0)
301			e_ps_t.append(0.0)
302			e_inst_t.append(14.14)
303			e_live_t.append(14.14)
304			e_delivered_t.append(14.14)
305	abrinke1	1.2	e_deadtime_t.append(0.01)
306	abrinke1	1.1	e_rawrate_t.append(math.sqrt(Rates[print_trigger]["rawrate"][iterator]/(num_ls*23.3)))
307			e_rate_t.append(Rates[print_trigger]["ps"][iterator]math.sqrt(Rates[print_trigger]["rawrate"][iterator]/(num_ls23.3)))
308	abrinke1	1.2	if live_t[-1] == 0:
309			e_rawxsec_t.append(0)
310			e_xsec_t.append(0)
311			else:
312			e_rawxsec_t.append(math.sqrt(Rates[print_trigger]["rawrate"][iterator]/(num_ls*23.3))/Rates[print_trigger]["live_lumi"][iterator])
313			e_xsec_t.append(Rates[print_trigger]["ps"][iterator]math.sqrt(Rates[print_trigger]["rawrate"][iterator]/(num_ls23.3))/Rates[print_trigger]["live_lumi"][iterator])
314	abrinke1	1.1
315			if overlay_fit:
316	abrinke1	1.2	rate_prediction = X0 + X1delivered_t[-1] + X2delivered_t[-1]*delivered_t[-1]
317			if rate_t[-1] < 0.7 * rate_prediction or rate_t[-1] > 1.4 * rate_prediction:
318			print str(run_t[-1])+" "+str(ls_t[-1])+" "+str(print_trigger)+" "+str(ps_t[-1])+" "+str(deadtime_t[-1])+" "+str(rate_prediction)+" "+str(rate_t[-1])+" "+str(rawrate_t[-1])
319	abrinke1	1.1	rawrate_fit_t.append(rate_prediction*(1.0-deadtime_t[-1])/(ps_t[-1]))
320			rate_fit_t.append(rate_prediction)
321	abrinke1	1.2	if live_t[-1] == 0:
322			rawxsec_fit_t.append(0)
323			xsec_fit_t.append(0)
324			else:
325			rawxsec_fit_t.append(rate_prediction/(ps_t[-1]*live_t[-1]))
326			xsec_fit_t.append(rate_prediction/live_t[-1])
327	abrinke1	1.1	e_rawrate_fit_t.append(e_rawrate_t[-1]*sqrt(Chi2))
328			e_rate_fit_t.append(e_rate_t[-1]*sqrt(Chi2))
329			e_rawxsec_fit_t.append(e_rawxsec_t[-1]*sqrt(Chi2))
330			e_xsec_fit_t.append(e_xsec_t[-1]*sqrt(Chi2))
331
332			else:
333			if debug_print:
334			print str(print_trigger)+" has xsec "+str(round(Rates[print_trigger]["xsec"][iterator],6))+" at lumi "+str(round(Rates[print_trigger]["live_lumi"][iterator],2))+" where the expected value is "+str(prediction)
335
336			for varX, varY, do_fit, save_root, save_png, overlay_fit, fit_file in plot_properties:
337			if varX == "run":
338			VX = run_t
339			VXE = run_t_e
340			elif varX == "ls":
341			VX = ls_t
342			VXE = e_ls_t
343			elif varX == "ps":
344			VX = ps_t
345			VXE = e_ps_t
346			elif varX == "inst":
347			VX = inst_t
348			VXE = e_inst_t
349			elif varX == "live":
350			VX = live_t
351			VXE = e_live_t
352			elif varX == "delivered":
353			VX = delivered_t
354			VXE = e_delivered_t
355	abrinke1	1.2	elif varX == "deadtime":
356			VX = deadtime_t
357			VXE = e_deadtime_t
358			print deadtime_t
359	abrinke1	1.1	elif varX == "rawrate":
360			VX = rawrate_t
361			VXE = e_rawrate_t
362			elif varX == "rate":
363			VX = rate_t
364			VXE = e_rate_t
365			elif varX == "rawxsec":
366			VX = rawxsec_t
367			VXE = e_rawxsec_t
368			elif varX == "xsec":
369			VX = xsec_t
370			VXE = e_xsec_t
371			else:
372			print "No valid variable entered for X"
373			continue
374			if varY == "run":
375			VY = run_t
376			VYE = run_t_e
377			elif varY == "ls":
378			VY = ls_t
379			VYE = e_ls_t
380			elif varY == "ps":
381			VY = ps_t
382			VYE = e_ps_t
383			elif varY == "inst":
384			VY = inst_t
385			VYE = e_inst_t
386			elif varY == "live":
387			VY = live_t
388			VYE = e_live_t
389			elif varY == "delivered":
390			VY = delivered_t
391			VYE = e_delivered_t
392	abrinke1	1.2	elif varY == "deadtime":
393			VY = deadtime_t
394			VYE = e_deadtime_t
395	abrinke1	1.1	elif varY == "rawrate":
396			VY = rawrate_t
397			VYE = e_rawrate_t
398			if overlay_fit:
399			VF = rawrate_fit_t
400			VFE = e_rawrate_fit_t
401			elif varY == "rate":
402			VY = rate_t
403			VYE = e_rate_t
404			if overlay_fit:
405			VF = rate_fit_t
406			VFE = e_rate_fit_t
407			elif varY == "rawxsec":
408			VY = rawxsec_t
409			VYE = e_rawxsec_t
410			if overlay_fit:
411			VF = rawxsec_fit_t
412			VFE = e_rawxsec_fit_t
413			elif varY == "xsec":
414			VY = xsec_t
415			VYE = e_xsec_t
416			if overlay_fit:
417			VF = xsec_fit_t
418			VFE = e_xsec_fit_t
419			else:
420			print "No valid variable entered for Y"
421			continue
422
423
424			if save_root or save_png:
425			c1 = TCanvas(str(varX),str(varY))
426			c1.SetName(str(print_trigger)+"_"+str(varY)+"_vs_"+str(varX))
427
428			gr1 = TGraphErrors(len(VX), VX, VY, VXE, VYE)
429			gr1.SetName("Graph_"+str(print_trigger)+"_"+str(varY)+"_vs_"+str(varX))
430			gr1.GetXaxis().SetTitle(varX)
431			gr1.GetYaxis().SetTitle(varY)
432			gr1.SetTitle(str(print_trigger))
433			gr1.SetMinimum(0)
434			gr1.SetMaximum(1.2*max(VY))
435			gr1.GetXaxis().SetLimits(min(VX)-0.2max(VX),1.2max(VX))
436			gr1.SetMarkerStyle(8)
437			if overlay_fit:
438			gr1.SetMarkerSize(0.8)
439			else:
440			gr1.SetMarkerSize(0.5)
441			gr1.SetMarkerColor(2)
442
443			## gr2 = TGraphErrors(len(VX), live_t, xsec_t, e_live_t, e_xsec_t)
444
445			if overlay_fit:
446			gr3 = TGraphErrors(len(VX), VX, VF, VXE, VFE)
447			gr3.SetMarkerStyle(8)
448			gr3.SetMarkerSize(0.4)
449			gr3.SetMarkerColor(4)
450			gr3.SetFillColor(4)
451			gr3.SetFillStyle(3003)
452
453			if do_fit:
454			if "rate" in varY:
455			## f2a = TF1("f2a","pol1",0,8000)
456			## f2a.SetParLimits(0,0,meanxsec*1.5)
457			## if slopexsec > 0:
458			## f2a.SetParLimits(1,0,max(xsec_t)/max(live_t))
459			## else:
460			## f2a.SetParLimits(1,2slopexsec,-2slopexsec)
461			## gr2.Fit("f2a","Q","rob=0.80")
462
463			f1a = TF1("f1a","pol2",0,8000)
464			f1a.SetLineColor(4)
465			f1a.SetLineWidth(2)
466			f1a.SetParLimits(0,0,1000)
467			f1a.SetParLimits(1,0,1000)
468			#gr1.Fit("f1a","B","Q")
469			gr1.Fit("f1a","Q","rob=0.80")
470
471	abrinke1	1.2	if f1a.GetChisquare()/f1a.GetNDF() > 20:
472			f1b = TF1("f1b","pol3",0,8000)
473			f1b.SetLineColor(4)
474			f1b.SetLineWidth(2)
475			f1b.SetParLimits(0,0,1000)
476			f1b.SetParLimits(1,0,1000)
477			f1b.SetParLimits(2,0,1000)
478			gr1.Fit("f1b","Q","rob=0.80")
479			if f1b.GetChisquare()/f1b.GetNDF() < f1a.GetChisquare()/f1a.GetNDF():
480			print str(print_trigger)+" f1a Chi2 = "+str(f1a.GetChisquare()/f1a.GetNDF())+", f1b Chi2 = "+str(f1b.GetChisquare()/f1b.GetNDF())
481
482
483	abrinke1	1.1	## f1b = TF1("f1b","pol2",0,8000)
484			## f1b.SetParameters(0.0,f2a.GetParameter(0),f2a.GetParameter(1))
485			## f1b.SetLineColor(3)
486			## f1b.SetLineWidth(2)
487
488			else:
489			f1a = TF1("f1a","pol1",0,8000)
490			f1a.SetLineColor(4)
491			f1a.SetLineWidth(2)
492			if "xsec" in varY:
493			f1a.SetParLimits(0,0,meanxsec*1.5)
494			if slopexsec > 0:
495			f1a.SetParLimits(1,0,max(VY)/max(VX))
496			else:
497			f1a.SetParLimits(1,2slopexsec,-2slopexsec)
498			else:
499			f1a.SetParLimits(0,0,1000)
500			gr1.Fit("f1a","Q","rob=0.80")
501
502			if save_root or save_png:
503			gr1.Draw("APZ")
504			if overlay_fit:
505			gr3.Draw("P3")
506			if do_fit:
507	abrinke1	1.2	#if f1b and f1b.GetChisquare()/f1b.GetNDF() < f1a.GetChisquare()/f1a.GetNDF():
508			#f1b.Draw("same")
509			#else:
510	abrinke1	1.1	f1a.Draw("same")
511			## if "rate" in varY:
512			## f1b.Draw("same")
513			c1.Update()
514			if save_root:
515			myfile = TFile( RootFile, 'UPDATE' )
516			c1.Write()
517			myfile.Close()
518			if save_png:
519			c1.SaveAs(str(print_trigger)+"_"+str(varY)+"_vs_"+str(varX)+".png")
520
521
522			##p1 = TPaveStats()
523			##p1 = gr1.GetListOfFunctions().FindObject("stats")
524			##print p1
525			##gr1.PaintStats(f1b).Draw("same")
526
527			if print_table or save_fits:
528			Output[print_trigger] = [f1a.GetParameter(0), f1a.GetParameter(1), f1a.GetParameter(2), f1a.GetChisquare()/f1a.GetNDF(), f1a.GetParameter(0)+5000(f1a.GetParameter(1)+f1a.GetParameter(2)5000), meanrawrate]
529
530			if save_root:
531			print "Output root file is "+str(RootFile)
532
533			if save_fits:
534			FitNameTemplate = "Fits/2011/Fit_%s_%sLS_Run%sto%s.pkl"
535			FitFile = FitNameTemplate % (trig_name, num_ls, min_run, max_run)
536			if os.path.exists(FitFile):
537			os.remove(FitFile)
538			FitOutput = open(FitFile, 'wb')
539			pickle.dump(Output, FitOutput, 2)
540			FitOutput.close()
541
542			if print_table:
543			print '%60s%10s%10s%10s%10s%10s%10s' % ("Trig", "p0", "p1", "p2", "Chi2", "5e33 pred", "Av raw")
544			for print_trigger in Output:
545			_trigger = (print_trigger[:56] + '...') if len(print_trigger) > 59 else print_trigger
546			try:
547			print '%60s%10s%10s%10s%10s%10s%10s' % (_trigger, round(Output[print_trigger][0],3), round(Output[print_trigger][1],6)1000, round(Output[print_trigger][2],9)1000000, round(Output[print_trigger][3],2), round(Output[print_trigger][4],2) , round(Output[print_trigger][5],3))
548			except:
549			print str(print_trigger)+" is somehow broken"
550
551			if __name__=='__main__':
552			main()