def draw_nse_mean(self): cent_bin1 = [0, 4, 7] cent_bin2 = [3, 6, 8] p_bin1 = [ 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5 ] p_bin2 = [ 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0 ] gr_mean = TGraphErrors() gr_width = TGraphErrors() gr_eff = TGraphErrors() for i in range(0, len(p_bin1)): f_gaus = self.draw_nse(cent_bin1[1], cent_bin2[1], p_bin1[i], p_bin2[i], -1, 2) mean = f_gaus.GetParameter(1) mean_err = f_gaus.GetParError(1) width = f_gaus.GetParameter(2) width_err = f_gaus.GetParError(2) gr_mean.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, mean) gr_mean.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, mean_err) gr_width.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, width) gr_width.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, width_err) p = 0.5 * (p_bin1[i] + p_bin2[i]) if p < 1: nse_low = 0.5 * p - 1.5 else: nse_low = -1 m = f_gaus.Integral(nse_low, 2.0) N = f_gaus.Integral(-10.0, 10.0) gr_eff.SetPoint(i, p, m / N) gr_eff.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, eff_err(m, N)) gr_mean.SetMarkerStyle(20) gr_mean.SetMarkerSize(1.5) gr_mean.SetMarkerColor(632) gr_width.SetMarkerStyle(20) gr_width.SetMarkerSize(1.5) gr_width.SetMarkerColor(600) gr_eff.SetMarkerStyle(20) gr_eff.SetMarkerSize(1.5) gr_eff.SetMarkerColor(600) hx = histo(0, 10, -0.2, 1.2, "p_{T}(GeV/c)", "Mean/Width") canvas_file = self.__canvas__ canvas_file.cd() c1 = TCanvas("c1", "c1", 1000, 800) hx.Draw() gr_width.Draw("psame") gr_mean.Draw("psame") c1.Write("nse") c1.SaveAs("nse.png") c2 = TCanvas("c2", "c2", 1000, 800) hx.GetYaxis().SetTitle("n#sigma_{e} cut efficiency") hx.Draw() gr_eff.Draw("psame") c2.Write("nse_eff") c2.SaveAs("nse_eff.png")
def draw_tof_cut_eff(self, cent_low, cent_high): cent_bin1 = [0, 4, 7] cent_bin2 = [3, 6, 8] p_bin1 = [ 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5 ] p_bin2 = [ 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0 ] gr_mean = TGraphErrors() gr_width = TGraphErrors() gr_eff = TGraphErrors() for i in range(0, len(p_bin1)): f_gaus = self.draw_tof_cut(cent_bin1[1], cent_bin2[1], p_bin1[i], p_bin2[i]) mean = f_gaus.GetParameter(1) mean_err = f_gaus.GetParError(1) width = f_gaus.GetParameter(2) width_err = f_gaus.GetParError(2) gr_mean.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, mean) gr_mean.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, mean_err) gr_width.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, width) gr_width.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, width_err) m = f_gaus.Integral(0.97, 1.03) N = f_gaus.GetParameter(0) * math.sqrt( 2 * math.pi) * f_gaus.GetParameter(2) print m, N gr_eff.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, m / N) gr_eff.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, eff_err(m, N)) gr_mean.SetMarkerStyle(20) gr_mean.SetMarkerSize(1.5) gr_mean.SetMarkerColor(632) gr_width.SetMarkerStyle(20) gr_width.SetMarkerSize(1.5) gr_width.SetMarkerColor(600) gr_eff.SetMarkerStyle(20) gr_eff.SetMarkerSize(1.5) gr_eff.SetMarkerColor(600) hx = histo(0, 10, -0.2, 1.2, "p_{T}(GeV/c)", "Mean/Width") canvas_file = self.__canvas__ canvas_file.cd() c1 = TCanvas("c1", "c1", 1000, 800) hx.GetYaxis().SetTitle("1/#beta cut efficency") hx.Draw() gr_width.Draw("psame") gr_mean.Draw("psame") c1.Write("tof") c1.SaveAs("tof.png") c2 = TCanvas("c2", "c2", 1000, 800) hx.Draw() gr_eff.Draw("psame") c2.Write("tof_cut_eff") c2.SaveAs("tof_cut.png")
def create_resolutiongraph(n, energies, sigmasmeans, energieserrors, sigmasmeanserrors, graphname): """Function to perform ROOT graphs of resolutions""" #How many points n = int(n) TGraphresolution = TGraphErrors(n, energies, sigmasmeans, energieserrors, sigmasmeanserrors) #Draw + DrawOptions, Fit + parameter estimation Style = gStyle Style.SetOptFit() XAxis = TGraphresolution.GetXaxis() #TGraphresolution TGraphresolution.SetMarkerColor(4) TGraphresolution.SetMarkerStyle(20) TGraphresolution.SetMarkerSize(2) XAxis.SetTitle("Energy (GeV)") YAxis = TGraphresolution.GetYaxis() YAxis.SetTitle("Sigma/Mean") resolutionfit = TF1("resolutionfit", '([0]/((x)**0.5))+[1]', 0, max(energies)) #somma non quadratura TGraphresolution.Fit("resolutionfit") a = resolutionfit.GetParameter(0) b = resolutionfit.GetParameter(1) TGraphresolution.Draw("AP") gPad.SaveAs(graphname) gPad.Close() return a, b
def draw_neta_cut_eff(self, cent_low, cent_high): cent_bin1 = [0, 4, 7] cent_bin2 = [3, 6, 8] p_bin1 = [ 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5 ] p_bin2 = [ 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0 ] gr_eff = TGraphErrors() for i in range(0, len(p_bin1)): mn = self.draw_neta_cut(cent_low, cent_high, p_bin1[i], p_bin2[i]) m = mn[0] N = mn[1] gr_eff.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, m / N) gr_eff.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, eff_err(m, N)) gr_eff.SetMarkerStyle(20) gr_eff.SetMarkerSize(1.5) gr_eff.SetMarkerColor(600) hx = histo(0, 8, -0.2, 1.2, "p_{T}(GeV/c)", "n#eta cut efficiency") canvas_file = self.__canvas__ canvas_file.cd() c2 = TCanvas("c2", "c2", 1000, 800) hx.Draw() gr_eff.Draw("psame") c2.Write("neta_cut_eff") c2.SaveAs("neta_cut.png")
def CompareToys(MwValuemT, MwValuemTStat): print(len(MwValuemT), len(MwValuemTStat)) n = len(MwValuemT) x, y = array('d'), array('d') ex, ey = array('d'), array('d') for i in range(0, n): x.append(i + 1) ex.append(0) y.append(MwValuemT[i]) ey.append(MwValuemTStat[i]) gr = TGraphErrors(n, x, y, ex, ey) gr.Draw("P") gr.SetLineWidth(0) gr.SetMarkerStyle(20) gr.SetMarkerSize(1) xax = gr.GetXaxis() for i in range(0, n): binIndex = xax.FindBin(i) xax.SetBinLabel(binIndex, "toys") Output = ROOT.TFile.Open("Matrix.root", "RECREATE") gr.Write("gr")
def compareEEC( filename="sjm91_all.root", datafilename="../EECMC/share/OPAL/data.dat" ): f= TFile( filename ) ao= createAnalysisObservable( f, "EEC" ) tokens= datafilename.split( "/" ) exp= tokens[3] plotoptions= { "xmin": 0.0, "xmax": 3.14159, "ymin": 0.05, "ymax": 5.0, "markerStyle": 20, "markerSize": 0.5, "drawas": "3", "fillcolor": 6, "title": "EEC "+exp, "xlabel": "\chi\ [rad.]", "ylabel": "1/\sigma d\Sigma/d\chi", "logy": 1 } tgest, tgesy= ao.plot( plotoptions ) lines= [ line.rstrip( '\n' ) for line in open( datafilename ) ] n= len( lines ) points= TVectorD( n ) values= TVectorD( n ) errors= TVectorD( n ) perrs= TVectorD(n) grad2rad= 3.14159/180.0 for i in range( n ): line= (lines[i]).split() points[i]= float(line[0])*grad2rad values[i]= float(line[3]) errors[i]= float(line[4]) perrs[i]= 0.0 datatge= TGraphErrors( points, values, perrs, errors ) datatge.SetMarkerStyle( 20 ) datatge.SetMarkerSize( 0.5 ) datatge.Draw( "psame" ) legend= TLegend( 0.2, 0.7, 0.5, 0.85 ) datatge.SetName( "datatge" ); tgesy.SetName( "tgesy" ) legend.AddEntry( "datatge", exp+" data", "pe" ) legend.AddEntry( "tgesy", "OPAL "+filename, "f" ) legend.Draw() return
def TGraph(x, y, yError=None, xError=None, **kwargs): __parseDrawOptions(kwargs) import sys #TODO: Need to check the types try: assert (len(x) == len(y)) except AssertionError: print "Oops! Data points x and y aren't of the same size!" sys.exit() nPoints = len(x) from array import array if xError is None: xError = __zeros(nPoints) if yError is None: yError = __zeros(nPoints) from ROOT import TGraphErrors graph = TGraphErrors(nPoints, array('d', x), array('d', y), array('d', xError), array('d', yError)) graph.SetTitle(__drawOptions['title']) graph.SetMarkerStyle(__drawOptions['mstyle']) graph.SetMarkerSize(__drawOptions['msize']) graph.SetMarkerColor(__drawOptions['mcolour']) graph.SetFillStyle(0) graph.SetFillColor(0) return graph
def make_tgrapherrors(name, title, color=1, marker=20, marker_size=1, width=1, asym_err=False, style=1, x=None, y=None): if (x and y) is None: gr = TGraphErrors() if not asym_err else TGraphAsymmErrors() else: gr = TGraphErrors(len(x), array(x, 'd'), array( y, 'd')) if not asym_err else TGraphAsymmErrors( len(x), array(x, 'd'), array(y), 'd') gr.SetTitle(title) gr.SetName(name) gr.SetMarkerStyle(marker) gr.SetMarkerColor(color) gr.SetLineColor(color) gr.SetMarkerSize(marker_size) gr.SetLineWidth(width) gr.SetLineStyle(style) return gr
def ZMultVsLumi(histo, recorded, outputDir, title): #gSystem.Exec("mkdir -p ZPlots") can1 = makeCMSCanvas(str(random.random()),"mult vs lumi ",900,700) lumi = [] lumi_err = [] mult = [] mult_err = [] sumLumi = 0. for i in range(0,len(recorded)): sumLumi += float(recorded[i]) lumi.append(sumLumi - float(recorded[i])/2) lumi_err.append(float(recorded[i])/2) mult.append(histo[i].GetEntries()/float(recorded[i])) mult_err.append(math.sqrt(histo[i].GetEntries()/float(recorded[i]))) graph1 = TGraphErrors(len(lumi),array('d',lumi),array('d',mult),array('d',lumi_err),array('d',mult_err)) can1.cd() graph1.SetTitle("") graph1.GetXaxis().SetTitle("Lumi [fb^{-1}]") graph1.GetYaxis().SetTitle("#Z / fb^{-1}") graph1.SetMarkerStyle(20) graph1.SetMarkerSize(1) graph1.Draw("AP") printLumiPrelOut(can1) can1.SaveAs(str(outputDir) + "/Z_multiplicity_"+title+".pdf") can1.SaveAs(str(outputDir) + "/Z_multiplicity_"+title+".png") return graph1;
def Ratio(histo1,histo2, recorded, title): #gSystem.Exec("mkdir -p ZPlots") can1 = makeCMSCanvas(str(random.random()),"mult vs lumi ",900,700) lumi = [] lumi_err = [] ratio = [] ratio_err = [] sumLumi = 0. for i in range(0,len(recorded)): sumLumi += float(recorded[i]) lumi.append(sumLumi - float(recorded[i])/2) lumi_err.append(float(recorded[i])/2) ratio.append(histo1[i].GetEntries()/histo2[i].GetEntries()) ratio_err.append(0) graph1 = TGraphErrors(len(recorded),array('d',lumi),array('d',ratio),array('d',lumi_err),array('d',ratio_err)) can1.cd() graph1.SetTitle("") graph1.GetXaxis().SetTitle("Lumi [fb^{-1}]") graph1.GetYaxis().SetTitle("e^{+}e^{-}/#mu^{+}#mu^{-}") graph1.SetMarkerStyle(20) graph1.SetMarkerSize(1) graph1.Draw("AP") printLumiPrelOut(can1) can1.SaveAs("ZPlots/Z_ratio_"+title+".pdf") can1.SaveAs("ZPlots/Z_ratio_"+title+".png") return;
def GraphVsLumi(result, outputDir, title): #gSystem.Exec("mkdir -p ZPlots") can1 = makeCMSCanvas(str(random.random()), "mean vs lumi ", 900, 700) can2 = makeCMSCanvas(str(random.random()), "width vs lumi ", 900, 700) lumi = [] lumi_err = [] mean = [] mean_err = [] width = [] width_err = [] sumLumi = 0. for i in range(0, len(result)): sumLumi += float(result[i].lumi) lumi.append(sumLumi - float(result[i].lumi) / 2) lumi_err.append(float(result[i].lumi) / 2) mean.append(result[i].mean) mean_err.append(result[i].mean_err) width.append(result[i].width) width_err.append(result[i].width_err) graph1 = TGraphErrors(len(result), array('d', lumi), array('d', mean), array('d', lumi_err), array('d', mean_err)) graph2 = TGraphErrors(len(result), array('d', lumi), array('d', width), array('d', lumi_err), array('d', width_err)) can1.cd() graph1.SetTitle("") graph1.GetXaxis().SetTitle("Lumi [fb^{-1}]") graph1.GetYaxis().SetTitle("Mass [GeV]") graph1.SetMarkerStyle(20) graph1.SetMarkerSize(1) graph1.Draw("AP") printLumiPrelOut(can1) can1.SaveAs(str(outputDir) + "/" + title + "_mean.pdf") can1.SaveAs(str(outputDir) + "/" + title + "_mean.png") can2.cd() graph2.SetTitle("") graph2.GetXaxis().SetTitle("Lumi [fb^{-1}]") graph2.GetYaxis().SetTitle("Width [GeV]") graph2.SetMarkerStyle(20) graph2.SetMarkerSize(1) graph2.Draw("AP") printLumiPrelOut(can2) can2.SaveAs(str(outputDir) + "/" + title + "_width.pdf") can2.SaveAs(str(outputDir) + "/" + title + "_width.png") return graph1, graph2
def MeanRMSVsLumi(histo, recorded, outputDir, title): can1 = makeCMSCanvas(str(random.random()), "mean vs lumi ", 900, 700) can2 = makeCMSCanvas(str(random.random()), "RMS vs lumi ", 900, 700) lumi = [] lumi_err = [] mean = [] mean_err = [] RMS = [] RMS_err = [] sumLumi = 0. for i in range(0, len(recorded)): sumLumi += float(recorded[i]) lumi.append(sumLumi - float(recorded[i]) / 2) lumi_err.append(float(recorded[i]) / 2) mean.append(histo[i].GetMean()) mean_err.append(0.) #dont put error on ISO and SIP histo[i].GetRMS() RMS.append(histo[i].GetRMS()) RMS_err.append(0.) graph1 = TGraphErrors(len(recorded), array('d', lumi), array('d', mean), array('d', lumi_err), array('d', mean_err)) graph2 = TGraphErrors(len(recorded), array('d', lumi), array('d', RMS), array('d', lumi_err), array('d', RMS_err)) can1.cd() graph1.SetTitle("") graph1.GetXaxis().SetTitle("Lumi [fb^{-1}]") graph1.GetYaxis().SetTitle(" ") graph1.SetMarkerStyle(20) graph1.SetMarkerSize(1) graph1.Draw("AP") printLumiPrelOut(can1) can1.SaveAs(str(outputDir) + "/" + title + "_mean.pdf") can1.SaveAs(str(outputDir) + "/" + title + "_mean.png") can2.cd() graph2.SetTitle("") graph2.GetXaxis().SetTitle(" ") graph2.GetYaxis().SetTitle("Width [GeV]") graph2.SetMarkerStyle(20) graph2.SetMarkerSize(1) graph2.Draw("AP") printLumiPrelOut(can2) can2.SaveAs(str(outputDir) + "/" + title + "_width.pdf") can2.SaveAs(str(outputDir) + "/" + title + "_width.png") return graph1, graph2
def getGraph(data, name='graph', offset=0): from ROOT import TGraphErrors g = TGraphErrors(len(data)) for n, (_, throughput, throughputE) in enumerate(data): g.SetPoint(n, offset + n, throughput) g.SetPointError(n, 0., throughputE) g.SetName(name) g.SetLineWidth(2) g.SetMarkerSize(1.7) return g
def draw_limits_per_category(nchannels, xmin, xmax, obs, expect, upper1sig, lower1sig, upper2sig, lower2sig): channel = np.array( [3. * nchannels - 1.5 - 3. * i for i in range(0, nchannels)]) ey = np.array([0.8 for i in range(0, nchannels)]) zero = np.zeros(nchannels) gexpect1sig = TGraphAsymmErrors(nchannels, expect, channel, lower1sig, upper1sig, ey, ey) gexpect1sig.SetFillColor(kGreen) gexpect1sig.SetLineWidth(2) gexpect1sig.SetLineStyle(2) gexpect2sig = TGraphAsymmErrors(nchannels, expect, channel, lower2sig, upper2sig, ey, ey) gexpect2sig.SetFillColor(kYellow) gexpect2sig.SetLineWidth(2) gexpect2sig.SetLineStyle(2) gexpect2sig.Draw("2") gexpect1sig.Draw("2") gobs = TGraphErrors(nchannels, obs, channel, zero, ey) gobs.SetMarkerStyle(21) gobs.SetMarkerSize(1.5) gobs.SetLineWidth(2) gobs.Draw("pz") # dashed line at median expected limits l = TLine() l.SetLineStyle(2) l.SetLineWidth(2) for bin in range(nchannels): l.DrawLine(expect[bin], channel[bin] - ey[bin], expect[bin], channel[bin] + ey[bin]) # line to separate individual and combined limits l.SetLineStyle(1) l.SetLineWidth(1) l.DrawLine(xmin, 0, xmax, 0) # legend x1 = gStyle.GetPadLeftMargin() + 0.01 y2 = 1 - gStyle.GetPadTopMargin() - 0.01 leg = TLegend(x1, y2 - 0.17, x1 + 0.25, y2) leg.SetFillColor(4000) leg.AddEntry(gexpect1sig, "Expected #pm1#sigma", "FL") leg.AddEntry(gexpect2sig, "Expected #pm2#sigma", "FL") leg.AddEntry(gobs, "Observed", "pl") leg.Draw() return gobs, gexpect1sig, gexpect2sig, leg
def draw_limits_per_category(nchannels, xmin, xmax, obs, expect, upper1sig, lower1sig, upper2sig, lower2sig): channel = np.array( [nchannels - 1.5 - float(i) for i in range(0, nchannels)]) ey = np.full(nchannels, 0.494) zero = np.zeros(nchannels) gexpect1sig = TGraphAsymmErrors(nchannels, expect, channel, lower1sig, upper1sig, ey, ey) gexpect1sig.SetFillColor(kGreen) gexpect1sig.SetLineWidth(2) gexpect1sig.SetLineStyle(2) gexpect2sig = TGraphAsymmErrors(nchannels, expect, channel, lower2sig, upper2sig, ey, ey) gexpect2sig.SetFillColor(kYellow) gexpect2sig.SetLineWidth(2) gexpect2sig.SetLineStyle(2) gexpect2sig.Draw("2") gexpect1sig.Draw("2") gobs = TGraphErrors(nchannels, obs, channel, zero, ey) gobs.SetMarkerStyle(21) gobs.SetMarkerSize(1.5) gobs.SetLineWidth(2) #gobs.Draw("pz") # dashed line at median expected limits l = TLine() l.SetLineStyle(2) l.SetLineWidth(2) for bin in range(nchannels): l.DrawLine(expect[bin], channel[bin] - ey[bin], expect[bin], channel[bin] + ey[bin]) # line to separate individual and combined limits l.SetLineStyle(1) l.SetLineWidth(1) l.DrawLine(xmin, 0, xmax, 0) # legend leg = TLegend(0.75, 0.75, 0.95, 0.9) leg.SetFillColor(4000) leg.AddEntry(gexpect1sig, "Expected #pm1#sigma", "FL") leg.AddEntry(gexpect2sig, "Expected #pm2#sigma", "FL") #leg.AddEntry( gobs, "Observed", "pl" ) leg.Draw() return gobs, gexpect1sig, gexpect2sig, leg
def plot_correction( h2, slope, offset, x_points, y_points, error_points, outname, xlabel='', etBinIdx=None, etaBinIdx=None, etBins=None, etaBins=None, label='Internal', ref_value=None, pd_value=None, palette=kBlackBody): def toStrBin(etlist = None, etalist = None, etidx = None, etaidx = None): if etlist and etidx is not None: etlist=copy(etlist) if etlist[-1]>9999: etlist[-1]='#infty' binEt = (str(etlist[etidx]) + ' < E_{T} [GeV] < ' + str(etlist[etidx+1]) if etidx+1 < len(etlist) else 'E_{T} > ' + str(etlist[etidx]) + ' GeV') return binEt if etalist and etaidx is not None: binEta = (str(etalist[etaidx]) + ' < |#eta| < ' + str(etalist[etaidx+1]) if etaidx+1 < len(etalist) else str(etalist[etaidx]) + ' <|#eta| < 2.47') return binEta canvas = TCanvas("canvas","canvas",500,500) rpl.set_figure(canvas) gStyle.SetPalette(palette) canvas.SetRightMargin(0.15) canvas.SetTopMargin(0.15) canvas.SetLogz() h2.GetXaxis().SetTitle('Neural Network output (Discriminant)') h2.GetYaxis().SetTitle(xlabel) h2.GetZaxis().SetTitle('Count') h2.Draw('colz') g = TGraphErrors(len(x_points), array.array('d',x_points), array.array('d',y_points), array.array('d',error_points), array.array('d',[0]*len(x_points))) g.SetMarkerColor(kBlue) g.SetMarkerStyle(8) g.SetMarkerSize(1) g.Draw("P same") line = TLine(slope*h2.GetYaxis().GetXmin()+offset,h2.GetYaxis().GetXmin(), slope*h2.GetYaxis().GetXmax()+offset, h2.GetYaxis().GetXmax()) line.SetLineColor(kBlack) line.SetLineWidth(2) line.Draw() # Add text labels into the canvas text = toStrBin(etlist=etBins, etidx=etBinIdx) text+= ', '+toStrBin(etalist=etaBins, etaidx=etaBinIdx) if ref_value and pd_value: text+=', P_{D} = %1.2f (%1.2f) [%%]'%(pd_value*100, ref_value*100) rpl.add_text(0.15, 0.885, text, textsize=.03) rpl.set_atlas_label(0.15, 0.94, label) rpl.format_canvas_axes(XLabelSize=16, YLabelSize=16, XTitleOffset=0.87, ZLabelSize=16,ZTitleSize=16, YTitleOffset=0.87, ZTitleOffset=1.1) canvas.SaveAs(outname)
def plot( self, plotoptions, opt="?" ): vx= array( "d", self.aostand.getPointsCenter() ) values= self.values sterrs= self.sterrs if "m" in opt: print "AnalysisObservable::plot: use errors from error matrix" sterrs= array( "d", self.aostand.getErrors( "m" ) ) syerrs= self.syerrs npoints= len(vx) if "xshift" in plotoptions: for i in range(npoints): vx[i]+= plotoptions["xshift"] vex= array( "d", npoints*[0.0] ) tgest= TGraphErrors( npoints, vx, values, vex, sterrs ) toterrs= np.sqrt( np.add( np.square( sterrs ), np.square( syerrs ) ) ) tgesy= TGraphErrors( npoints, vx, values, vex, toterrs ) tgesy.SetMarkerStyle( plotoptions["markerStyle"] ) tgesy.SetMarkerSize( plotoptions["markerSize"] ) drawas= plotoptions["drawas"] if "drawas" in plotoptions else "p" tgesy.SetName( self.obs ) if "fillcolor" in plotoptions: tgesy.SetFillColor(plotoptions["fillcolor"]) tgest.SetFillColor(plotoptions["fillcolor"]) if "s" in opt: tgesy.Draw( "psame" ) else: if "title" in plotoptions: tgesy.SetTitle( plotoptions["title"] ) else: tgesy.SetTitle( self.obs ) tgesy.SetMinimum( plotoptions["ymin"] ) tgesy.SetMaximum( plotoptions["ymax"] ) xaxis= tgesy.GetXaxis() xaxis.SetLimits( plotoptions["xmin"], plotoptions["xmax"] ) if "xlabel" in plotoptions: xaxis.SetTitle( plotoptions["xlabel"] ) if "ylabel" in plotoptions: tgesy.GetYaxis().SetTitle( plotoptions["ylabel"] ) tgesy.Draw( "a"+drawas ) optlogx= plotoptions["logx"] if "logx" in plotoptions else 0 gPad.SetLogx( optlogx ) optlogy= plotoptions["logy"] if "logy" in plotoptions else 0 gPad.SetLogy( optlogy ) tgest.Draw( "same"+drawas ) return tgest, tgesy
def getGraph(self, filename): data = self.getData(filename) from ROOT import TFile, TTree, gDirectory, TGraphErrors, TCanvas from array import array nsteps = len(data) g = TGraphErrors(nsteps) ## Loop on the data for n,(fragsize,tp,tpE) in enumerate(data): g.SetPoint( n, fragsize, tp) g.SetPointError( n, 0., tpE) g.SetLineWidth(2) g.SetMarkerSize(1.7) return g
def create_linearitygraph(n, energies, energieserrors, means, sigmameans, graphname): """Function to perform ROOT graphs of resolutions""" #How many points n = int(n) TGraphlinearity = TGraphErrors(n, energies, means, energieserrors, sigmameans) #Draw + DrawOptions, Fit + parameter estimation Style = gStyle Style.SetOptFit() XAxis = TGraphlinearity.GetXaxis() #TGraphresolution TGraphlinearity.SetMarkerColor(4) TGraphlinearity.SetMarkerStyle(20) TGraphlinearity.SetMarkerSize(2) XAxis.SetTitle("Energy (GeV)") YAxis = TGraphlinearity.GetYaxis() YAxis.SetTitle("Mean/TrueEnergy") TGraphlinearity.Draw("AP") gPad.SaveAs(graphname) gPad.Close()
def getResponseGraph(file): print "Read=", file i = 0 g1 = TGraphErrors() for line in open(file, "r"): columns = line.split(',') pt = float(columns[0]) pt_err = float(columns[1]) sigma = float(columns[2]) err = float(columns[3]) g1.SetPoint(i, pt, sigma) ex = pt_err ey = err g1.SetPointError(i, ex, ey) i = i + 1 g1.SetMarkerColor(1) g1.SetMarkerStyle(20) g1.SetMarkerSize(0.5) # g1->Print(); return g1
def compareY23d( filename="sjm91_all.root", mtffilename=None, opt="m" ): if mtffilename == None: ecm= ecmFromFilename( filename ) mtffilename= "mtford-y23d"+ecm+".txt" arrays= ascii2arrays( mtffilename ) mtfordpointsl= arrays[0] mtfordpointsr= arrays[1] mtfordpoints= np.divide( np.add( arrays[0], arrays[1] ), 2.0 ) mtfordvalues= arrays[2] mtfordsterrs= arrays[3] mtfordsyerrs= arrays[4] mtforderrs= np.sqrt( np.add( np.square( mtfordsterrs ), np.square( mtfordsyerrs ) ) ) if filename=="sjm133.root": f1= TFile( "sjm130.root" ) ao1= createAnalysisObservable( f1, "durhamymerge23" ) f2= TFile( "sjm136.root" ) ao2= createAnalysisObservable( f2, "durhamymerge23" ) ao= combineAnalysisObservables( [ ao1, ao2 ] ) else: f= TFile( filename ) ao= createAnalysisObservable( f, "durhamymerge23" ) npoints= len( mtfordpoints ) vex= array( "d", npoints*[0.0] ) tgest= TGraphErrors( npoints, mtfordpoints, mtfordvalues, vex, mtfordsterrs ) tgetot= TGraphErrors( npoints, mtfordpoints, mtfordvalues, vex, mtforderrs ) plotoptions= { "xmin": 0.0003, "xmax": 0.5, "ymin": 0.5, "ymax": 500.0, "markerStyle": 20, "markerSize": 0.75, "title": "Durham y23 "+filename, "xlabel": "y_{23}", "ylabel": "1/\sigma d\sigma/dy_{23}", "logx":1, "logy":1 } ao.plot( plotoptions, opt ) tgetot.SetMarkerStyle( 24 ) tgetot.SetMarkerSize( 1.25 ) tgetot.SetName( "mtford" ) tgetot.Draw( "psame" ) tgest.Draw( "psame" ) tl= TLegend( 0.7, 0.9, 0.7, 0.9 ) tl.AddEntry( "mtford", "M.T. Ford thesis", "ep" ) tl.AddEntry( "durhamymerge23", "sjmanalysis", "ep" ) tl.Draw() return
def compareThrust( filename="sjm91_all.root", mtffilename=None ): if mtffilename == None: ecm= ecmFromFilename( filename ) mtffilename= "mtford-thrust"+ecm+".txt" arrays= ascii2arrays( mtffilename ) mtfordvalues= arrays[2] mtfordsterrs= arrays[3] mtfordsyerrs= arrays[4] mtforderrs= np.sqrt( np.add( np.square( mtfordsterrs ), np.square( mtfordsyerrs ) ) ) if filename=="sjm133.root": # f1= TFile( "sjm130.root" ) # aothrust1= createAnalysisObservable( f1, "thrust" ) # f2= TFile( "sjm136.root" ) # aothrust2= createAnalysisObservable( f2, "thrust" ) # aothrust= combineAnalysisObservables( [ aothrust1, aothrust2 ] ) aothrust= createCombineAnalysisObservables( ( "sjm130.root", "sjm136.root" ), "lepthrust" ) else: f= TFile( filename ) aothrust= createAnalysisObservable( f, "lepthrust" ) vx= array( "d", aothrust.aostand.getPointsCenter() ) npoints= len(vx)-1 vex= array( "d", npoints*[0.0] ) tgethrustst= TGraphErrors( npoints, vx, mtfordvalues, vex, mtfordsterrs ) tgethrusttot= TGraphErrors( npoints, vx, mtfordvalues, vex, mtforderrs ) plotoptions= { "xmin": 0.0, "xmax": 0.5, "ymin": 0.2, "ymax": 30, "markerStyle": 20, "markerSize": 0.8, "title": "Thrust "+filename, "logy": 1, "xlabel": "1-T", "ylabel": "1/\sigma d\sigma/d(1-T)" } aothrust.plot( plotoptions ) tgethrusttot.SetMarkerStyle( 24 ) tgethrusttot.SetMarkerSize( 1.25 ) tgethrusttot.SetName( "mtford" ) tgethrusttot.Draw( "psame" ) tgethrustst.Draw( "psame" ) tl= TLegend( 0.6, 0.75, 0.85, 0.9 ) tl.AddEntry( "mtford", "M.T. Ford thesis", "ep" ) tl.AddEntry( "thrust", "sjmanalysis", "ep" ) tl.Draw() return
def draw_bemc_match(self, cent_low, cent_high): h_tpc_e = self.get_subtract(self.hist_sige, cent_low, cent_high) h_tpc_e.SetName("h_tpc_e") h_bemcmatch = self.get_subtract(self.hist_bemcmatch, cent_low, cent_high) h_bemcmatch.SetName("h_bemcmatch") ymax = h_tpc_e.GetMaximum() haxis = histo(0, 10, 1, ymax * 3.5, "p_{T}(GeV/c)", "Counts") haxis.SetNdivisions(510) h_tpc_e.SetLineColor(600) h_tpc_e.SetFillColor(600) h_tpc_e.SetFillStyle(1001) h_tpc_e.SetMarkerStyle(1) h_tpc_e.SetMarkerColor(600) h_bemcmatch.SetLineColor(632) h_bemcmatch.SetFillColorAlpha(632, 1) h_bemcmatch.SetFillStyle(1001) h_bemcmatch.SetMarkerStyle(1) h_bemcmatch.SetMarkerColor(632) leg = TLegend(0.55, 0.5, 0.8, 0.65) leg.SetBorderSize(0) leg.SetTextSize(0.035) leg.SetTextFont(132) leg.AddEntry(h_tpc_e, "TPC electron", "f") leg.AddEntry(h_bemcmatch, "BEMC match electon", "f") data_set = "Run10 Au+Au@200GeV MinBias" cent_range = "{}-{}% centrality".format(self.cent_list1[cent_high], self.cent_list2[cent_low]) c = TCanvas("c", "c", 1000, 800) haxis.SetStats(0) haxis.Draw() gPad.SetLogy() h_tpc_e.Draw("histsamelfbar2") h_bemcmatch.Draw("histsamelfbar2") leg.Draw("same") drawLatex(0.55, 0.72, data_set, 0.035, 132, 1) drawLatex(0.55, 0.67, cent_range, 0.035, 132, 1) c.SaveAs("tpc_e.png") self.__canvas__.cd() c.Write("tpc_e") c1 = TCanvas("c1", "c1", 1000, 800) gr = TGraphErrors() p_bin1 = [ 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0 ] p_bin2 = [ 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 7.0 ] for i in range(0, len(p_bin1)): xlow = h_tpc_e.GetXaxis().FindBin(p_bin1[i] + 1E-3) xup = h_tpc_e.GetXaxis().FindBin(p_bin2[i] + 1E-3) N = h_tpc_e.Integral(xlow, xup) xlow = h_bemcmatch.GetXaxis().FindBin(p_bin1[i] + 1E-3) xup = h_bemcmatch.GetXaxis().FindBin(p_bin2[i] + 1E-3) m = h_bemcmatch.Integral(xlow, xup) gr.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, m / N) gr.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, eff_err(m, N)) hx = histo(0, 10, 0, 1.5, "p_{T}(GeV/c)", "TOF match efficiency") hx.Draw() gr.Draw("psame") gr.SetMarkerStyle(20) gr.SetMarkerSize(1.5) gr.SetMarkerColor(632) canvas_file = self.__canvas__ canvas_file.cd() c1.Write("bemc_match_eff") c1.SaveAs("bemc_match_eff.png")
g_eff.SetMarkerStyle(20) g_eff.SetLineColor(kRed + 1) g_eff.SetLineWidth(2) g_purity.Draw("PL") g_purity.SetMarkerStyle(21) g_purity.SetLineColor(kBlue + 1) g_purity.SetLineWidth(2) g_acceptance.Draw("PL") g_acceptance.SetMarkerStyle(23) g_acceptance.SetLineColor(kGreen + 2) g_acceptance.SetLineWidth(2) g_reco_eff.Draw("PL") g_reco_eff.SetLineColor(kGray + 2) g_reco_eff.SetLineWidth(2) g_reco_eff.SetMarkerStyle(29) g_reco_eff.SetMarkerSize(1.5) g_reco_eff_data.Draw("PL") g_data_eff.Draw("PL") g_data_eff.SetLineColor(kRed + 1) g_data_eff.SetLineWidth(2) g_data_eff.SetMarkerStyle(4) g_data_eff.SetLineStyle(2) g_reco_eff_data.SetLineColor(kGray + 2) g_reco_eff_data.SetLineWidth(2) g_reco_eff_data.SetMarkerStyle(30) g_reco_eff_data.SetMarkerSize(1.5) g_reco_eff_data.SetLineStyle(2) l = TLegend(0.46, 0.16, 0.85, 0.425) l.SetBorderSize(0) l.SetShadowColor(0)
gPad.SetPad(small, 0.3, 1.-small, 1.-small) gPad.SetBottomMargin(small) labelSize=10 makerSize = 0.3 gStyle.SetEndErrorSize(0) gr = TGraphErrors( n, energyVec, recoEnergyVec, energyErrorVec, recoEnergyErrorVec ) gr.SetName('gr') gr.SetLineColor( 1 ) gr.SetLineWidth( 1 ) gr.SetLineStyle( 2 ) gr.SetMarkerColor( 2 ) gr.SetMarkerStyle( 20 ) gr.SetMarkerSize( makerSize ) textsize = labelSize/(gPad.GetWh()*gPad.GetAbsHNDC()) gr.SetTitle( '' ) gr.GetXaxis().SetTitle( 'E_{particle} (GeV)' ) gr.GetYaxis().SetTitle( 'E_{reco} (GeV)' ) gr.GetYaxis().SetTitleSize(textsize) gr.GetYaxis().SetLabelSize(textsize) gr.GetYaxis().SetTitleOffset(1.4) gr.GetYaxis().SetRangeUser(2, 100) gPad.SetLeftMargin(0.15) gr.Draw( 'AP' ) func1 = TF1('fun1', 'x', 0., 100.) func1.SetLineColor(4) func1.SetLineStyle(2) func1.Draw('same')
def main(argv): #Usage controls from OptionParser parser_usage = "" parser = OptionParser(usage=parser_usage) (options, args) = parser.parse_args(argv) if (len(args) != 2 and len(args) != 3): parser.print_help() return c1 = TCanvas("c1", "c1", 1200, 800) f_18deg = TFile.Open(argv[0]) f_10deg = TFile.Open(argv[1]) if (len(args) == 3): f_5deg = TFile.Open(argv[2]) size = 1.3 gr_L1_US_18deg = f_18deg.Get("gr_layer1_US_RMS") gr_L2_US_18deg = f_18deg.Get("gr_layer2_US_RMS") gr_L3_US_18deg = f_18deg.Get("gr_layer3_US_RMS") gr_L4_US_18deg = f_18deg.Get("gr_layer4_US_RMS") gr_global_US_18deg = f_18deg.Get("gr_global_US_RMS") gr_L1_US_10deg = f_10deg.Get("gr_layer1_US_RMS") gr_L2_US_10deg = f_10deg.Get("gr_layer2_US_RMS") gr_L3_US_10deg = f_10deg.Get("gr_layer3_US_RMS") gr_L4_US_10deg = f_10deg.Get("gr_layer4_US_RMS") gr_global_US_10deg = f_10deg.Get("gr_global_US_RMS") if (len(args) == 3): gr_L1_US_5deg = f_5deg.Get("gr_layer1_US_RMS") if (len(args) == 3): gr_L2_US_5deg = f_5deg.Get("gr_layer2_US_RMS") if (len(args) == 3): gr_L3_US_5deg = f_5deg.Get("gr_layer3_US_RMS") if (len(args) == 3): gr_L4_US_5deg = f_5deg.Get("gr_layer4_US_RMS") if (len(args) == 3): gr_global_US_5deg = f_5deg.Get("gr_global_US_RMS") color = kRed gr_L1_US_18deg.SetLineColor(color) gr_L1_US_18deg.SetMarkerColor(color) gr_L1_US_18deg.SetMarkerSize(size) gr_L1_US_18deg.SetMarkerStyle(kOpenCircle) gr_L1_US_10deg.SetLineColor(color) gr_L1_US_10deg.SetMarkerColor(color) gr_L1_US_10deg.SetMarkerSize(size) gr_L1_US_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_L1_US_5deg.SetLineColor(color) if (len(args) == 3): gr_L1_US_5deg.SetMarkerColor(color) if (len(args) == 3): gr_L1_US_5deg.SetMarkerSize(size) if (len(args) == 3): gr_L1_US_5deg.SetMarkerStyle(kRad) color = kGreen + 3 gr_L2_US_18deg.SetLineColor(color) gr_L2_US_18deg.SetMarkerColor(color) gr_L2_US_18deg.SetMarkerSize(size) gr_L2_US_18deg.SetMarkerStyle(kOpenCircle) gr_L2_US_10deg.SetLineColor(color) gr_L2_US_10deg.SetMarkerColor(color) gr_L2_US_10deg.SetMarkerSize(size) gr_L2_US_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_L2_US_5deg.SetLineColor(color) if (len(args) == 3): gr_L2_US_5deg.SetMarkerColor(color) if (len(args) == 3): gr_L2_US_5deg.SetMarkerSize(size) if (len(args) == 3): gr_L2_US_5deg.SetMarkerStyle(kRad) color = kBlue gr_L3_US_18deg.SetLineColor(color) gr_L3_US_18deg.SetMarkerColor(color) gr_L3_US_18deg.SetMarkerSize(size) gr_L3_US_18deg.SetMarkerStyle(kOpenCircle) gr_L3_US_10deg.SetLineColor(color) gr_L3_US_10deg.SetMarkerColor(color) gr_L3_US_10deg.SetMarkerSize(size) gr_L3_US_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_L3_US_5deg.SetLineColor(color) if (len(args) == 3): gr_L3_US_5deg.SetMarkerColor(color) if (len(args) == 3): gr_L3_US_5deg.SetMarkerSize(size) if (len(args) == 3): gr_L3_US_5deg.SetMarkerStyle(kRad) color = kMagenta gr_L4_US_18deg.SetLineColor(color) gr_L4_US_18deg.SetMarkerColor(color) gr_L4_US_18deg.SetMarkerSize(size) gr_L4_US_18deg.SetMarkerStyle(kOpenCircle) gr_L4_US_10deg.SetLineColor(color) gr_L4_US_10deg.SetMarkerColor(color) gr_L4_US_10deg.SetMarkerSize(size) gr_L4_US_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_L4_US_5deg.SetLineColor(color) if (len(args) == 3): gr_L4_US_5deg.SetMarkerColor(color) if (len(args) == 3): gr_L4_US_5deg.SetMarkerSize(size) if (len(args) == 3): gr_L4_US_5deg.SetMarkerStyle(kRad) color = kBlack gr_global_US_18deg.SetLineColor(color) gr_global_US_18deg.SetMarkerColor(color) gr_global_US_18deg.SetMarkerSize(size) gr_global_US_18deg.SetMarkerStyle(kOpenCircle) gr_global_US_10deg.SetLineColor(color) gr_global_US_10deg.SetMarkerColor(color) gr_global_US_10deg.SetMarkerSize(size) gr_global_US_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_global_US_5deg.SetLineColor(color) if (len(args) == 3): gr_global_US_5deg.SetMarkerColor(color) if (len(args) == 3): gr_global_US_5deg.SetMarkerSize(size) if (len(args) == 3): gr_global_US_5deg.SetMarkerStyle(kRad) gr_L1_US_18deg.SetTitle("Upstream Pedestal Width " + year) gr_L1_US_18deg.GetXaxis().SetTitle("SiPM bias voltage (V)") gr_L1_US_18deg.GetYaxis().SetTitle("Pedestal RMS (ADC units)") gr_L1_US_18deg.GetYaxis().SetRangeUser(1, 2.5) gr_L1_US_18deg.Draw("APx") gr_L2_US_18deg.Draw("Pxsame") gr_L3_US_18deg.Draw("Pxsame") gr_L4_US_18deg.Draw("Pxsame") gr_global_US_18deg.Draw("Pxsame") gr_L1_US_10deg.Draw("Pxsame") gr_L2_US_10deg.Draw("Pxsame") gr_L3_US_10deg.Draw("Pxsame") gr_L4_US_10deg.Draw("Pxsame") gr_global_US_10deg.Draw("Pxsame") if (len(args) == 3): gr_L1_US_5deg.Draw("Pxsame") if (len(args) == 3): gr_L2_US_5deg.Draw("Pxsame") if (len(args) == 3): gr_L3_US_5deg.Draw("Pxsame") if (len(args) == 3): gr_L4_US_5deg.Draw("Pxsame") if (len(args) == 3): gr_global_US_5deg.Draw("Pxsame") legend = TLegend( 0.13, 0.45, 0.7, 0.85 ) #0.1 is lower limit of plot, 0.9 is upper limit (beyond on either side is labeling+whitespace) legend.AddEntry(gr_L1_US_18deg, "Layer 1 (18 Celcius)", "pl") legend.AddEntry(gr_L1_US_10deg, "Layer 1 (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_L1_US_5deg, "Layer 1 (5 Celcius)", "pl") legend.AddEntry(gr_L2_US_18deg, "Layer 2 (18 Celcius)", "pl") legend.AddEntry(gr_L2_US_10deg, "Layer 2 (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_L2_US_5deg, "Layer 2 (5 Celcius)", "pl") legend.AddEntry(gr_L3_US_18deg, "Layer 3 (18 Celcius)", "pl") legend.AddEntry(gr_L3_US_10deg, "Layer 3 (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_L3_US_5deg, "Layer 3 (5 Celcius)", "pl") legend.AddEntry(gr_L4_US_18deg, "Layer 4 (18 Celcius)", "pl") legend.AddEntry(gr_L4_US_10deg, "Layer 4 (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_L4_US_5deg, "Layer 4 (5 Celcius)", "pl") legend.AddEntry(gr_global_US_18deg, "ALL upstream (18 Celcius)", "pl") legend.AddEntry(gr_global_US_10deg, "ALL upstream (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_global_US_5deg, "ALL upstream (5 Celcius)", "pl") legend.Draw() c1.SaveAs("plots/upstream" + year + ".png") gr_L1_DS_18deg = f_18deg.Get("gr_layer1_DS_RMS") gr_L2_DS_18deg = f_18deg.Get("gr_layer2_DS_RMS") gr_L3_DS_18deg = f_18deg.Get("gr_layer3_DS_RMS") gr_L4_DS_18deg = f_18deg.Get("gr_layer4_DS_RMS") gr_global_DS_18deg = f_18deg.Get("gr_global_DS_RMS") gr_L1_DS_10deg = f_10deg.Get("gr_layer1_DS_RMS") gr_L2_DS_10deg = f_10deg.Get("gr_layer2_DS_RMS") gr_L3_DS_10deg = f_10deg.Get("gr_layer3_DS_RMS") gr_L4_DS_10deg = f_10deg.Get("gr_layer4_DS_RMS") gr_global_DS_10deg = f_10deg.Get("gr_global_DS_RMS") if (len(args) == 3): gr_L1_DS_5deg = f_5deg.Get("gr_layer1_DS_RMS") if (len(args) == 3): gr_L2_DS_5deg = f_5deg.Get("gr_layer2_DS_RMS") if (len(args) == 3): gr_L3_DS_5deg = f_5deg.Get("gr_layer3_DS_RMS") if (len(args) == 3): gr_L4_DS_5deg = f_5deg.Get("gr_layer4_DS_RMS") if (len(args) == 3): gr_global_DS_5deg = f_5deg.Get("gr_global_DS_RMS") color = kRed gr_L1_DS_18deg.SetLineColor(color) gr_L1_DS_18deg.SetMarkerColor(color) gr_L1_DS_18deg.SetMarkerSize(size) gr_L1_DS_18deg.SetMarkerStyle(kOpenCircle) gr_L1_DS_10deg.SetLineColor(color) gr_L1_DS_10deg.SetMarkerColor(color) gr_L1_DS_10deg.SetMarkerSize(size) gr_L1_DS_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_L1_DS_5deg.SetLineColor(color) if (len(args) == 3): gr_L1_DS_5deg.SetMarkerColor(color) if (len(args) == 3): gr_L1_DS_5deg.SetMarkerSize(size) if (len(args) == 3): gr_L1_DS_5deg.SetMarkerStyle(kRad) color = kGreen + 3 gr_L2_DS_18deg.SetLineColor(color) gr_L2_DS_18deg.SetMarkerColor(color) gr_L2_DS_18deg.SetMarkerSize(size) gr_L2_DS_18deg.SetMarkerStyle(kOpenCircle) gr_L2_DS_10deg.SetLineColor(color) gr_L2_DS_10deg.SetMarkerColor(color) gr_L2_DS_10deg.SetMarkerSize(size) gr_L2_DS_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_L2_DS_5deg.SetLineColor(color) if (len(args) == 3): gr_L2_DS_5deg.SetMarkerColor(color) if (len(args) == 3): gr_L2_DS_5deg.SetMarkerSize(size) if (len(args) == 3): gr_L2_DS_5deg.SetMarkerStyle(kRad) color = kBlue gr_L3_DS_18deg.SetLineColor(color) gr_L3_DS_18deg.SetMarkerColor(color) gr_L3_DS_18deg.SetMarkerSize(size) gr_L3_DS_18deg.SetMarkerStyle(kOpenCircle) gr_L3_DS_10deg.SetLineColor(color) gr_L3_DS_10deg.SetMarkerColor(color) gr_L3_DS_10deg.SetMarkerSize(size) gr_L3_DS_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_L3_DS_5deg.SetLineColor(color) if (len(args) == 3): gr_L3_DS_5deg.SetMarkerColor(color) if (len(args) == 3): gr_L3_DS_5deg.SetMarkerSize(size) if (len(args) == 3): gr_L3_DS_5deg.SetMarkerStyle(kRad) color = kMagenta gr_L4_DS_18deg.SetLineColor(color) gr_L4_DS_18deg.SetMarkerColor(color) gr_L4_DS_18deg.SetMarkerSize(size) gr_L4_DS_18deg.SetMarkerStyle(kOpenCircle) gr_L4_DS_10deg.SetLineColor(color) gr_L4_DS_10deg.SetMarkerColor(color) gr_L4_DS_10deg.SetMarkerSize(size) gr_L4_DS_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_L4_DS_5deg.SetLineColor(color) if (len(args) == 3): gr_L4_DS_5deg.SetMarkerColor(color) if (len(args) == 3): gr_L4_DS_5deg.SetMarkerSize(size) if (len(args) == 3): gr_L4_DS_5deg.SetMarkerStyle(kRad) color = kBlack gr_global_DS_18deg.SetLineColor(color) gr_global_DS_18deg.SetMarkerColor(color) gr_global_DS_18deg.SetMarkerSize(size) gr_global_DS_18deg.SetMarkerStyle(kOpenCircle) gr_global_DS_10deg.SetLineColor(color) gr_global_DS_10deg.SetMarkerColor(color) gr_global_DS_10deg.SetMarkerSize(size) gr_global_DS_10deg.SetMarkerStyle(kSquare) if (len(args) == 3): gr_global_DS_5deg.SetLineColor(color) if (len(args) == 3): gr_global_DS_5deg.SetMarkerColor(color) if (len(args) == 3): gr_global_DS_5deg.SetMarkerSize(size) if (len(args) == 3): gr_global_DS_5deg.SetMarkerStyle(kRad) gr_L1_DS_18deg.SetTitle("Downstream Pedestal Width " + year) gr_L1_DS_18deg.GetXaxis().SetTitle("SiPM bias voltage (V)") gr_L1_DS_18deg.GetYaxis().SetTitle("Pedestal RMS (ADC units)") gr_L1_DS_18deg.GetYaxis().SetRangeUser(1, 2.5) gr_L1_DS_18deg.Draw("APx") gr_L2_DS_18deg.Draw("Pxsame") gr_L3_DS_18deg.Draw("Pxsame") gr_L4_DS_18deg.Draw("Pxsame") gr_global_DS_18deg.Draw("Pxsame") gr_L1_DS_10deg.Draw("Pxsame") gr_L2_DS_10deg.Draw("Pxsame") gr_L3_DS_10deg.Draw("Pxsame") gr_L4_DS_10deg.Draw("Pxsame") gr_global_DS_10deg.Draw("Pxsame") if (len(args) == 3): gr_L1_DS_5deg.Draw("Pxsame") if (len(args) == 3): gr_L2_DS_5deg.Draw("Pxsame") if (len(args) == 3): gr_L3_DS_5deg.Draw("Pxsame") if (len(args) == 3): gr_L4_DS_5deg.Draw("Pxsame") if (len(args) == 3): gr_global_DS_5deg.Draw("Pxsame") legend = TLegend( 0.13, 0.45, 0.7, 0.85 ) #0.1 is lower limit of plot, 0.9 is upper limit (beyond on either side is labeling+whitespace) legend.AddEntry(gr_L1_DS_18deg, "Layer 1 (18 Celcius)", "pl") legend.AddEntry(gr_L1_DS_10deg, "Layer 1 (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_L1_DS_5deg, "Layer 1 (5 Celcius)", "pl") legend.AddEntry(gr_L2_DS_18deg, "Layer 2 (18 Celcius)", "pl") legend.AddEntry(gr_L2_DS_10deg, "Layer 2 (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_L2_DS_5deg, "Layer 2 (5 Celcius)", "pl") legend.AddEntry(gr_L3_DS_18deg, "Layer 3 (18 Celcius)", "pl") legend.AddEntry(gr_L3_DS_10deg, "Layer 3 (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_L3_DS_5deg, "Layer 3 (5 Celcius)", "pl") legend.AddEntry(gr_L4_DS_18deg, "Layer 4 (18 Celcius)", "pl") legend.AddEntry(gr_L4_DS_10deg, "Layer 4 (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_L4_DS_5deg, "Layer 4 (5 Celcius)", "pl") legend.AddEntry(gr_global_DS_18deg, "ALL downstream (18 Celcius)", "pl") legend.AddEntry(gr_global_DS_10deg, "ALL downstream (10 Celcius)", "pl") if (len(args) == 3): legend.AddEntry(gr_global_DS_5deg, "ALL downstream (5 Celcius)", "pl") legend.Draw() c1.SaveAs("plots/downstream" + year + ".png") #Difference plots size = 0.8 gr_diff_L1 = TGraphErrors() gr_diff_L2 = TGraphErrors() gr_diff_L3 = TGraphErrors() gr_diff_L4 = TGraphErrors() gr_diff_G = TGraphErrors() if temp_4PlottingDiff == "5": gr_diff_L1 = f_5deg.Get("gr_layer1_diff_RMS") gr_diff_L2 = f_5deg.Get("gr_layer2_diff_RMS") gr_diff_L3 = f_5deg.Get("gr_layer3_diff_RMS") gr_diff_L4 = f_5deg.Get("gr_layer4_diff_RMS") gr_diff_G = f_5deg.Get("gr_global_diff_RMS") if temp_4PlottingDiff == "10": gr_diff_L1 = f_10deg.Get("gr_layer1_diff_RMS") gr_diff_L2 = f_10deg.Get("gr_layer2_diff_RMS") gr_diff_L3 = f_10deg.Get("gr_layer3_diff_RMS") gr_diff_L4 = f_10deg.Get("gr_layer4_diff_RMS") gr_diff_G = f_10deg.Get("gr_global_diff_RMS") if temp_4PlottingDiff == "18": gr_diff_L1 = f_18deg.Get("gr_layer1_diff_RMS") gr_diff_L2 = f_18deg.Get("gr_layer2_diff_RMS") gr_diff_L3 = f_18deg.Get("gr_layer3_diff_RMS") gr_diff_L4 = f_18deg.Get("gr_layer4_diff_RMS") gr_diff_G = f_18deg.Get("gr_global_diff_RMS") gr_diff_L1.SetMarkerColor(kBlack) gr_diff_L2.SetMarkerColor(kRed) gr_diff_L3.SetMarkerColor(kBlue) gr_diff_L4.SetMarkerColor(kMagenta) gr_diff_G.SetMarkerColor(kBlack) gr_diff_L1.SetMarkerStyle(20) gr_diff_L2.SetMarkerStyle(20) gr_diff_L3.SetMarkerStyle(20) gr_diff_L4.SetMarkerStyle(20) gr_diff_G.SetMarkerStyle(kOpenCircle) gr_diff_L1.SetMarkerSize(size) gr_diff_L2.SetMarkerSize(size) gr_diff_L3.SetMarkerSize(size) gr_diff_L4.SetMarkerSize(size) gr_diff_G.SetMarkerSize(size) gr_diff_L1.Draw("APx") c1.SaveAs("plots/diff_L1_" + year + "_" + temp_4PlottingDiff + "C.png") gr_diff_L2.Draw("APx") c1.SaveAs("plots/diff_L2_" + year + "_" + temp_4PlottingDiff + "C.png") gr_diff_L3.Draw("APx") c1.SaveAs("plots/diff_L3_" + year + "_" + temp_4PlottingDiff + "C.png") gr_diff_L4.Draw("APx") c1.SaveAs("plots/diff_L4_" + year + "_" + temp_4PlottingDiff + "C.png") gr_diff_G.Draw("APx") c1.SaveAs("plots/diff_global_" + year + "_" + temp_4PlottingDiff + "C.png") legend = TLegend( 0.13 + 0.15, 0.65, 0.5 + 0.15, 0.85 ) #0.1 is lower limit of plot, 0.9 is upper limit (beyond on either side is labeling+whitespace) legend.AddEntry(gr_diff_L1, "Layer 1", "pl") legend.AddEntry(gr_diff_L2, "Layer 2 / #sqrt{2}", "pl") legend.AddEntry(gr_diff_L3, "Layer 3 / #sqrt{3}", "pl") legend.AddEntry(gr_diff_L4, "Layer 4 / #sqrt{4}", "pl") gr_diff_L1.SetTitle("") gr_diff_L1.Draw("APx") gr_diff_L2.Draw("pxsame") gr_diff_L3.Draw("pxsame") gr_diff_L4.Draw("pxsame") legend.Draw() c1.SaveAs("plots/diff" + year + "_" + temp_4PlottingDiff + "C.png") print("Done ")
def Plot2DCorrection(hist2D, graph, f1, etBin=None, etaBin=None, outname=None, xlabel='N_{vtx}', runLabel=None, legends=None, extraText1=None, legendX1=.5, etidx=None, etaidx=None, etlist=None, etalist=None): import array as ar from ROOT import TCanvas, gStyle, TLegend, kRed, kBlue, kBlack, TLine, kBird, kOrange from ROOT import TGraphErrors, TF1, TColor pileup_max = hist2D.GetYaxis().GetXmax() pileup_min = hist2D.GetYaxis().GetXmin() # Retrieve some usefull information gStyle.SetPalette(kBird) canvas = TCanvas('canvas', 'canvas', 500, 500) #FormatCanvasAxes(canvas, XLabelSize=18, YLabelSize=18, XTitleOffset=0.87, YTitleOffset=1.5) canvas.SetRightMargin(0.12) canvas.SetLeftMargin(0.10) hist2D.Draw('colz') hist2D.GetZaxis().SetTitle("Entries") canvas.SetLogz() AddTopLabels(canvas, legends, runLabel=runLabel, legOpt='p', etlist=etlist, etalist=etalist, etidx=etidx, etaidx=etaidx) FormatCanvasAxes(canvas, XLabelSize=12, YLabelSize=12, XTitleOffset=0.87, ZLabelSize=12, ZTitleSize=14, YTitleOffset=0.87, ZTitleOffset=0.67) SetAxisLabels(canvas, 'Neural Network output (Discriminant)', xlabel) # Invert graph import array x = graph.GetX() x.SetSize(graph.GetN()) ex = graph.GetEX() ex.SetSize(graph.GetN()) y = graph.GetY() y.SetSize(graph.GetN()) ey = graph.GetEY() ey.SetSize(graph.GetN()) nvtx_points = array.array('d', x) nvtx_error_points = array.array('d', ex) discr_points = array.array('d', y) discr_error_points = array.array('d', ey) g1 = TGraphErrors(len(discr_points), discr_points, nvtx_points, discr_error_points, nvtx_error_points) g1.SetLineWidth(1) #g1.SetLineColor(kBlack) g1.SetMarkerColor(kBlue + 1) g1.SetMarkerSize(.6) g1.Draw("P same") tobject_collector.append(g1) #l2 = TLine(eff_uncorr.thres,miny,eff_uncorr.thres,maxy) #l2.SetLineColor(kRed) #l2.SetLineWidth(2) #l2.Draw("l,same") #tobject_collector.append(l2) #f1 = eff.f1 if type(f1) is not list: f1 = [f1] for idx, f in enumerate(f1): l3 = TLine(f.Eval(pileup_min), pileup_min, f.Eval(pileup_max), pileup_max) if idx > 0: l3.SetLineColor(GetTransparent(kRed)) else: l3.SetLineColor(kBlack) l3.SetLineWidth(2) l3.Draw("l,same") tobject_collector.append(l3) if outname: canvas.SaveAs(outname)
def plot_2(var,cuts): for s in attr: c1 = TCanvas("c1", "Signals", 1200, 800) if log_y == 1: c1.SetLogy() c1.SetTopMargin(0.08)#0.12 c1.SetBottomMargin(0.11)#0.12 c1.SetLeftMargin(0.14) c1.SetRightMargin(0.14)#0.24 c1.cd() #c1.SetGrid() gStyle.SetTitleFontSize(0.04) if ct_dep == 0: if s in ('elf','muf','cm','nm','chm'): c1.SetLogx() for cc in channel: #hist[cc][s].SetMaximum(0.44) if 'combind' in cc: fc = 30 #hist[cc][s].SetFillStyle()#3005) elif 'VBF' in cc: fc = 38 hist[cc][s].SetFillStyle(3444) elif 'HT50' in cc: fc = 7 hist[cc][s].SetFillStyle(3001) elif 'HT100' in cc: fc = 4 hist[cc][s].SetFillStyle(3002) elif 'HT200' in cc: fc = 6 hist[cc][s].SetFillStyle(3003) elif 'HT300' in cc: fc = 9 hist[cc][s].SetFillStyle(3004) if histFillColOn == 1: pass #hist[cc][s].SetFillColor(fc) hist[cc][s].Draw(histStyl) #legend = TLegend(0.76, 0.56, 0.99, 0.88) legend = TLegend(0.60, 0.9-0.04*2, 0.85, 0.9) #x_left y_bottom x_right y_top legend.SetBorderSize(0) legend.SetFillStyle(0)#1001 legend.SetFillColor(0) #legend.SetHeader( entry['entries'] ) for cc in channel: legend.AddEntry(hist[cc][s],cc) legend.Draw() for ct in cut_text: cut_text[ct].Draw() #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Line for critical value if s == 'chm': l = TLine(11.4,0.0,11.4,0.084) elif s == 'cHadEFrac': l = TLine(0.38,0.0,0.38,0.027) elif s == 'FracCal': l = TLine(30,0.0,30,0.44) #l.SetLineColor(2) #l.SetLineWidth(3) if critical_line == 1: l.SetLineColor(46)#4,2 l.SetLineWidth(3) l.Draw('same') c1.Print(path1 + s + var + cuts.replace('(','_').replace(')','_').replace('&&','_').replace('>','LG').replace('<','LS').replace('=','EQ').replace('.','P').replace('-','N').replace('Jet','J').replace('GenBquark','GBQ') + ".pdf") elif ct_dep == 1: eac0 = str( entries_after_cut['ct0'][s] ) c1.SetLogx() #gr = TGraph( len_of_lt , x , yy['sgn'][s] ) gr = TGraphErrors( len_of_lt , x , yy['sgn'][s] , ex , ey['sgn'][s] ) gr.SetMarkerSize(1.5) gr.SetMarkerStyle(1) gr.GetYaxis().SetTitleOffset(1.6) gr.SetLineColor(4) gr.SetLineWidth(4) gr.SetTitle('mean ' + s ) gr.GetXaxis().SetTitle('decaying length (mm)') gr.GetYaxis().SetTitle('mean normalized number of events') gr.GetXaxis().SetTitleOffset(1.4) gr.SetMaximum( plotrange[s] * 1.12 ) gr.SetName('sgn') gr.Draw('ACP') # '' sets up the scattering style gr1 = TGraphErrors( len_of_lt , x , yy['QCD'][s] , ex , ey['QCD'][s] ) gr1.SetMarkerSize(1.0) gr1.SetMarkerStyle(1) gr.GetYaxis().SetTitleOffset(1.6) gr1.SetLineColor(2) gr1.SetLineWidth(2) gr1.SetName('QCD') #gr1.SetTitle('averaged ' + s) #gr1.GetXaxis().SetTitle('decaying length (mm)') #gr1.GetYaxis().SetTitle('mean frequency') gr1.Draw('CP') # '' sets up the scattering style legend = TLegend(0.76, 0.56, 0.99, 0.88) legend.SetHeader( 'Entries: ' + eac0 ) legend.AddEntry('QCD', legendb, 'l') legend.AddEntry('sgn', legends, 'l') legend.Draw() for ct in cut_text: cut_text[ct].Draw() c1.Print(path1 + 'mean_' + s + var + cuts.replace('(','_').replace(')','_').replace('&&','_').replace('>','LG').replace('<','LS').replace('=','EQ').replace('.','P').replace('-','N').replace('Jet','J').replace('GenBquark','GBQ') + ".pdf") c1.Update() c1.Close() print('|||||||||||||||||||||||||||||||||||||||||||||||||||')
CombinedcorrectedTrackAmbiguity) / math.sqrt(NLoops), "%\n" _Efficiency.append(np.mean(CombinedtrackEfficiency)) _Purity.append(100 - np.mean(CombinedcorrectedTrackAmbiguity)) _NumberOfProtons.append(nMeanProton) _EfficiencyErr.append(np.std(CombinedtrackEfficiency) / math.sqrt(NLoops)) _PurityErr.append( np.std(CombinedcorrectedTrackAmbiguity) / math.sqrt(NLoops)) _NumberOfProtonsErr.append(0.0) canvas1 = TCanvas('c1', "mycanvas", 200, 10, 700, 500) effGraph = TGraphErrors(len(_NumberOfProtons), _NumberOfProtons, _Efficiency, _NumberOfProtonsErr, _EfficiencyErr) effGraph.SetMarkerStyle(2) effGraph.SetMarkerSize(2) effGraph.GetXaxis().SetTitle("Mean N Proton") effGraph.GetYaxis().SetTitle("Efficiency/Purity (%)") effGraph.SetTitle("Efficiency") purGraph = TGraphErrors(len(_NumberOfProtons), _NumberOfProtons, _Purity, _NumberOfProtonsErr, _PurityErr) purGraph.SetMarkerStyle(5) purGraph.SetLineColor(2) purGraph.SetMarkerColor(2) purGraph.SetMarkerSize(2) purGraph.GetXaxis().SetTitle("Mean N Proton") purGraph.GetYaxis().SetTitle("Purity") purGraph.SetTitle("Purity") MyFile = TFile( "effVsPurity_bs" + (str)(beamSpread) + "mrad_geo" + geoName +
y.append(1.08) y.append(1.1) y.append(1.15) y.append(1.2) y.append(1.2) y.append(1.22) y.append(1.22) n = len(x) gr0 = TGraphErrors(n, x, y, ex, ey) gr0.SetMarkerColor(ROOT.kBlue) gr0.SetMarkerStyle(20) gr0.SetLineColor(ROOT.kBlue) gr0.SetMarkerSize(1.5) gr0.Draw() p1 = TF1("pol1", "pol1", 200, 900.) # p1 = TF1("pol2","pol2",200,2000.); p1.SetLineColor(ROOT.kMagenta) f1 = TF1("f1", "[0] +[1]*x", 200, 2000) f1.SetParameters(0.99601, 0.00241919) f1.SetLineColor(ROOT.kBlue) gr0.Fit(p1, "0R") p1.Draw("sames") f1.Draw("same")