1200.0, 1300.0, 1400.0, 1500.0, 1600.0, 1700.0, 1800.0, 1900.0, 2000.0, 2100.0, 2200.0, 2300.0, 2400.0, 2500.0, 2600.0, 2700.0, 2800.0, 2900.0, 3000.0, 3100.0, 3200.0, 3300.0, 3400.0, 3500.0, 3600.0, 3700.0, 3800.0, 3900.0, 4000.0, 4100.0, 4200.0, 4300.0, 4400.0, 4500.0, 4600.0, 4700.0, 4800.0, 4900.0, 5000.0, 5100.0, 5200.0 ]) significances = array('d', [ 0.0, 0.0, 0.0, 0.0, 0.0, 1.4301, 2.35386, 2.02192, 0.911242, 0.0, 0.0, 0.0366119, 0.422815, 0.404487, 0.0, 0.0, 0.0, 0.0, 0.0, 0.360739, 0.296693, 0.206474, 0.717595, 1.39978, 1.65206, 1.39911, 0.912702, 0.328027, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]) ##------------------------------------------------------ graph_sig = TGraph(len(masses), masses, significances) graph_sig.GetXaxis().SetTitle("qq resonance mass [GeV]") graph_sig.GetYaxis().SetTitle("Significance") graph_sig.SetLineWidth(2) graph_sig.SetLineColor(kRed) graph_sig.SetMarkerStyle(21) graph_sig.SetMarkerSize(1) graph_sig.SetMarkerColor(kBlue) #graph_sig.GetYaxis().SetRangraph_sig.SetMarkerStyle(20)geUser(1e-03,2e+02) graph_sig.GetXaxis().SetNdivisions(1005) gStyle.SetOptTitle(0) c = TCanvas("c", "", 800, 800) c.cd() graph_sig.Draw("ALP")
from array import array n = count x, y = array('d'), array('d') #for i in range( n ): coutn = 0 for i in fileIn: j = i.split() print j x.append(float(j[0])) y.append(float(j[1])) print(' i %f %f %f ' % (coutn, x[coutn], y[coutn])) coutn += 1 fileIn.close() gr = TGraph(n, x, y) gr.SetLineColor(2) gr.SetLineWidth(4) gr.SetMarkerColor(4) gr.SetMarkerStyle(21) gr.SetTitle('a simple graph') gr.GetXaxis().SetTitle('X title') gr.GetYaxis().SetTitle('Y title') #gr.Draw( 'ACP' ) #c1.SaveAs("test.png") fileIn = open("cutoffscale.dat", "read") xx, yy = array('d'), array('d') coutn = 0 for i in fileIn: j = i.split()
def makeLimitPlot(output,obs,exp,chan,printStats=False): fileForHEPData = TFile("plots/"+output+"_forHEPData.root","RECREATE") obsLimits = {} for obsFile in obs: if 'width' in obsFile: width = obsFile.split('width')[-1].split('_')[0] else: width = '0.006' obsLimits[width] = createObsGraph(obsFile) if SMOOTH: for width,obsGraph in obsLimits.iteritems(): smooth_obs=TGraphSmooth("normal") GraphObs_nonSmooth=obsGraph obsLimits[width]=copy.deepcopy(smooth_obs.SmoothSuper(GraphObs_nonSmooth,"linear",0,0.005)) obsLimits[width].SetLineWidth(3) expLimits = {} for expFile in exp: if 'width' in expFile: width = expFile.split('width')[-1].split('_')[0] else: width = '0.006' expLimits[width] = createExpGraph(expFile) cCL=TCanvas("cCL", "cCL",0,0,600,450) gStyle.SetOptStat(0) gStyle.SetPadRightMargin(0.063) gStyle.SetPadLeftMargin(0.14) gStyle.SetPadBottomMargin(0.12) plotPad = ROOT.TPad("plotPad","plotPad",0,0,1,1) plotPad.Draw() plotPad.cd() smoother=TGraphSmooth("normal") smoother2=TGraphSmooth("normal") zprimeX=[] zprimeY=[] fileZPrime=open('tools/xsec_ssm.txt','r') for entries in fileZPrime: entry=entries.split() zprimeX.append(float(entry[0])) zprimeY.append(float(entry[1])/1928) zpX=numpy.array(zprimeX) zpY=numpy.array(zprimeY) GraphZPrime=TGraph(len(zprimeX),zpX,zpY) GraphZPrimeSmooth=smoother2.SmoothSuper(GraphZPrime,"linear") GraphZPrimeSmooth.SetLineWidth(3) GraphZPrimeSmooth.SetLineColor(ROOT.kGreen+3) GraphZPrimeSmooth.SetLineStyle(2) zprimePsiX=[] zprimePsiY=[] fileZPrimePsi=open('tools/xsec_psi.txt','r') for entries in fileZPrimePsi: entry=entries.split() zprimePsiX.append(float(entry[0])) zprimePsiY.append(float(entry[1])/1928) zpPsiX=numpy.array(zprimePsiX) zpPsiY=numpy.array(zprimePsiY) GraphZPrimePsi=TGraph(len(zprimePsiX),zpPsiX,zpPsiY) GraphZPrimePsiSmooth=smoother.SmoothSuper(GraphZPrimePsi,"linear") GraphZPrimePsiSmooth.SetLineWidth(3) GraphZPrimePsiSmooth.SetLineColor(ROOT.kBlue) #Draw the graphs: plotPad.SetLogy() DummyGraph=TH1F("DummyGraph","",100,200,5500) DummyGraph.GetXaxis().SetTitle("M [GeV]") if SPIN2: DummyGraph.GetYaxis().SetTitle("[#sigma#upoint#font[12]{B}] G_{KK} / #sigma#upoint#font[12]{B}] Z") else: DummyGraph.GetYaxis().SetTitle("[#sigma#upoint#font[12]{B}] Z' / [#sigma#upoint#font[12]{B}] Z") # if SPIN2: # if chan=="mumu": # DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowG_{KK}+X#rightarrow#mu^{+}#mu^{-}+X) / #sigma(pp#rightarrowZ+X#rightarrow#mu^{+}#mu^{-}+X)") # elif chan=="elel": # DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowG_{KK}+X#rightarrowee+X) / #sigma(pp#rightarrowZ+X#rightarrowee+X)") # elif chan=="elmu": # DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowG_{KK}+X#rightarrow#font[12]{ll}+X) / #sigma(pp#rightarrowZ+X#rightarrow#font[12]{ll}+X)") # else: # if chan=="mumu": # DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowZ'+X#rightarrow#mu^{+}#mu^{-}+X) / #sigma(pp#rightarrowZ+X#rightarrow#mu^{+}#mu^{-}+X)") # elif chan=="elel": # DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowZ'+X#rightarrowee+X) / #sigma(pp#rightarrowZ+X#rightarrowee+X)") # elif chan=="elmu": # DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowZ'+X#rightarrow#font[12]{ll}+X) / #sigma(pp#rightarrowZ+X#rightarrow#font[12]{ll}+X)") gStyle.SetOptStat(0) DummyGraph.GetXaxis().SetRangeUser(200,5500) DummyGraph.SetMinimum(1e-8) DummyGraph.SetMaximum(3e-4) DummyGraph.GetXaxis().SetLabelSize(0.055) DummyGraph.GetXaxis().SetTitleSize(0.055) DummyGraph.GetXaxis().SetTitleOffset(1.05) DummyGraph.GetYaxis().SetLabelSize(0.055) DummyGraph.GetYaxis().SetTitleSize(0.055) DummyGraph.GetYaxis().SetTitleOffset(1.3) DummyGraph.Draw() plCMS=TPaveLabel(.16,.76,.27,.83,"CMS","NBNDC") #plCMS.SetTextSize(0.8) plCMS.SetTextAlign(12) plCMS.SetTextFont(62) plCMS.SetFillColor(0) plCMS.SetBorderSize(0) plCMS.Draw() plPrelim=TPaveLabel(.16,.76,.27,.82,"Preliminary","NBNDC") plPrelim.SetTextSize(0.6) plPrelim.SetTextAlign(12) plPrelim.SetTextFont(52) plPrelim.SetFillColor(0) plPrelim.SetBorderSize(0) # plPrelim.Draw() leg=TLegend(0.420517,0.7,0.85,0.878644,"","brNDC") legWidth=TLegend(0.625,0.5,0.9,0.7,"width","brNDC") # leg=TLegend(0.55,0.55,0.87,0.87,"","brNDC") leg.SetTextSize(0.0425) legWidth.SetTextSize(0.0425) colors = {'01':ROOT.kBlue,'03':ROOT.kRed,'05':ROOT.kGreen+3,'10':ROOT.kOrange} # for width in sorted(obsLimits): # obsGraph = obsLimits[width] # if colors.has_key(width): # obsGraph.SetLineColor(colors[width]) # obsGraph.Draw("lsame") # if width == '0.006': # leg.AddEntry(obsGraph,"Observed 95% CL limit width 0.6%","l") # else: # leg.AddEntry(obsGraph,"Observed 95%% CL limit width %d%%"%int(width),"l") # # for width in sorted(expLimits): # expGraph = expLimits[width] # if colors.has_key(width): # expGraph.SetLineColor(colors[width]) # expGraph.Draw("lsame") # if width == '0.006': # leg.AddEntry(expGraph,"Expected 95% CL limit width 0.6%, median","l") # else: # leg.AddEntry(expGraph,"Expected 95%% CL limit width %d%%, median"%(int(width)),"l") for width in sorted(obsLimits): obsGraph = obsLimits[width] if colors.has_key(width): obsGraph.SetLineColor(colors[width]) obsGraph.Draw("lsame") if width == '0.006': leg.AddEntry(obsGraph,"Obs. 95% CL limit","l") for width in sorted(expLimits): expGraph = expLimits[width] if colors.has_key(width): expGraph.SetLineColor(colors[width]) expGraph.Draw("lsame") if width == '0.006': leg.AddEntry(expGraph,"Exp. 95% CL limit, median","l") for width in sorted(obsLimits): obsGraph = obsLimits[width] if colors.has_key(width): obsGraph.SetLineColor(colors[width]) if width == '0.006': legWidth.AddEntry(obsGraph,"0.6%","l") else: legWidth.AddEntry(obsGraph,"%d%%"%int(width),"l") if not SPIN2: GraphZPrimeSmooth.Draw("lsame") GraphZPrimePsiSmooth.Draw("lsame") leg1=TLegend(0.625,0.35,0.825,0.5,"","brNDC") leg1.SetTextSize(0.0375) leg1.AddEntry(GraphZPrimeSmooth,"Z'_{SSM} (width 2.97%)","l") leg1.AddEntry(GraphZPrimePsiSmooth,"Z'_{#Psi} (width 0.53%)","l") leg1.SetLineWidth(0) leg1.SetLineStyle(0) leg1.SetLineColor(0) leg1.SetFillStyle(0) leg1.SetBorderSize(0) leg1.Draw() cCL.SetTickx(1) cCL.SetTicky(1) cCL.RedrawAxis() cCL.Update() #plCMS.Draw() plotPad.SetTicks(1,1) plotPad.RedrawAxis() leg.SetLineWidth(0) leg.SetLineStyle(0) leg.SetLineColor(0) leg.Draw("hist") legWidth.SetLineWidth(0) legWidth.SetLineStyle(0) legWidth.SetLineColor(0) legWidth.SetFillStyle(0) legWidth.SetNColumns(2) legWidth.Draw("hist") if "Moriond" in output: if (chan=="mumu"): plLumi=TPaveLabel(.65,.885,.9,.99,"36.3 fb^{-1} (13 TeV, #mu^{+}#mu^{-})","NBNDC") elif (chan=="elel"): plLumi=TPaveLabel(.65,.885,.9,.99,"35.9 fb^{-1} (13 TeV, ee)","NBNDC") elif (chan=="elmu"): plLumi=TPaveLabel(.27,.885,.9,.99,"35.9 fb^{-1} (13 TeV, ee) + 36.3 fb^{-1} (13 TeV, #mu^{+}#mu^{-})","NBNDC") else: if (chan=="mumu"): plLumi=TPaveLabel(.65,.905,.9,.99,"13.0 fb^{-1} (13 TeV, #mu#mu)","NBNDC") elif (chan=="elel"): plLumi=TPaveLabel(.65,.905,.9,.99,"2.7 fb^{-1} (13 TeV, ee)","NBNDC") elif (chan=="elmu"): plLumi=TPaveLabel(.4,.905,.9,.99,"12.4 fb^{-1} (13 TeV, ee) + 13.0 fb^{-1} (13 TeV, #mu#mu)","NBNDC") plLumi.SetTextSize(0.5) plLumi.SetTextFont(42) plLumi.SetFillColor(0) plLumi.SetBorderSize(0) plLumi.Draw() plotPad.RedrawAxis() for width in sorted(obsLimits): obsGraph = obsLimits[width] obsGraph.SetName("graphObs%s"%width) obsGraph.Write("graphObs%s"%width) for width in sorted(expLimits): expGraph = expLimits[width] expGraph.SetName("graphExp%s"%width) expGraph.Write("graphExp%s"%width) fileForHEPData.Write() fileForHEPData.Close() cCL.Update() printPlots(cCL,output)
def plot_graph_yield(yield_signal, yield_signal_err, binmin, binmax): gr = TGraph(0) _ = gr.GetN() print(yield_signal, yield_signal_err, binmin, binmax)
# Fill program use arrays with data Z.append(Data[0] / 1000.) Bx.append(Data[1]) By.append(Data[2]) Bz.append(Data[3]) # Close file fIN.close() # Get the max and mins in the field [MaxListInd, MaxListBy] = FindMaxAndMins(Z, By) [MaxByZ, MaxBy] = FindMinMaxFromFit(MaxListInd, Z, By, None) # Save a graph of the points found gMaxBy = TGraph(len(MaxByZ), array('d', MaxByZ), array('d', MaxBy)) gMaxBy.SetName('MaxBy') gMaxBy.SetTitle('Calculated Max By') gMaxBy.GetXaxis().SetTitle('Position [m]') gMaxBy.GetYaxis().SetTitle('B_{Y} [T]') gMaxBy.Write() # TGraphs for measured Bx By and Bz vs Z gBx = TGraph(len(Z), Z, Bx) gBy = TGraph(len(Z), Z, By) gBz = TGraph(len(Z), Z, Bz) gBx.SetTitle('Measured magnetic field B_{X}') gBx.GetXaxis().SetTitle('Position [m]') gBx.GetYaxis().SetTitle('#B_{x} [T]') gBx.SetName("Bx")
if threshold[1] < halfMax: thrArrayFallingEdge.append(threshold[0]) break # Only one threshold is needed, leave loop trimFallingEdge.append(thrArrayFallingEdge) # Turn array of trimming value arrays with pixels in the sub array into transposed array ( Pix1(trimDac[0-31]), Pix2(),.,,,Pix48(trimDac[0-31])) pxlTrimFallingEdge = [list(trim) for trim in zip(*trimFallingEdge)] # Draw graphs on canvas c1 = TCanvas("graph", "graph", 1024, 768) graphs = [] for pxl in pxlTrimFallingEdge: graphs.append( TGraph(32, array('d', range(32)), array('d', pxl)) ) # Generate graph with trimDACs on x-axis and falling edge position (in threshold-steps) on y-axis for i, graph in enumerate(graphs): graph.SetLineColor(i) if i == 0: graph.SetTitle('Trim Scan;Trim (DAC);Falling Edge (Threshold)') #graph.GetYaxis().SetRangeUser(0,max(maxHitsPerPixTrim[trim])*1.1) graph.Draw("APL") else: graph.Draw("PL") pickle.dump(pxlTrimFallingEdge, open(str(sys.path[0]) + "/trimDacFallingEdge.pickle", "w")) raw_input("Press any key to exit")
for n in range(0, stepNum + 1): currentFreq = startFreq + n * stepSize frequencies.append(currentFreq) f = TFile('Freq' + str(currentFreq) + '.root') t = f.Get('neutronend') hist = TH1D('hist', "", 400, -1, 1) t.Draw("Szend>>hist", "stopID==-1") print("Mean Szend: ") print(hist.GetMean()) meanSzend.append(hist.GetMean()) x = array("d", frequencies) y = array("d", meanSzend) #f1 = TF1("f1", "-.5 - .5*cos((100*(pi)+8)*(29.16469-x))",29.16, 29.17) graph = TGraph(stepNum + 1, x, y) graph.SetTitle("Szend Of Ramsey Cycles in Frequency Range from " + str(startFreq) + " to " + str(endFreq)) graph.GetXaxis().SetTitle("BField Frequency") graph.GetYaxis().SetTitle("Mean Szend") canvas = TCanvas("canvas", "canvas", 700, 500) graph.Draw() #f1.Draw("same") raw_input("Press Enter to Finish")
hhh = TH2D("hhh","hhh",modmax-modmin+1,modmin-0.5,modmax+0.5,chanmax-chanmin+1,chanmin-0.5,chanmax+0.5) if vsbin: tree.Draw(data,cut_cond,"goff",15) else: tree.Draw(data,cut_cond,"goff") if (not opt2d and tree.GetSelectedRows() <= 1) or tree.GetSelectedRows() <= 0: print "Not enough points to plot" sys.exit(2) if vsbin: if tree.GetSelectedRows() >= 15: print "Maximum number of bins is 15" if line or noline: gr = TGraph(tree.GetSelectedRows(),tree.GetV2(),tree.GetV1()) gr.SetTitle(modulename +" " + " Channel "+ str(chan_n) +" " + gainvalue + titsuff) gr.SetMarkerStyle(20) gr.SetMarkerSize(1.3) gr.SetMarkerColor(2) gr.SetLineColor(2) gr.GetXaxis().SetNoExponent(kTRUE) if one_run: gr.GetXaxis().SetTitle("Lumi") else: gr.GetXaxis().SetTitle("Runs") if noline: gr.Draw("ap") else: gr.Draw("apl") elif opt2d: nentries = tree.GetEntries() hhh.SetName(modulename) hhh.SetTitle(partname +" " + gainvalue + titsuff)
def Make_TDC_Energy(Fname1,Fname2,Title, XaxisT,low,high,freq,RootName): f_fc=TFile(Fname1) f_tdc=TFile(Fname2) gr_Inregral_fc=f_fc.Get("Graph_Integral") gr_Inregral_tdc=f_tdc.Get("Graph_Integral") FNumber=int((high-low)/freq) xpoint=array("d",xrange(0,FNumber)) ypoint=array("d",xrange(0,FNumber)) num=-1 for iAmp in range(low,high,freq): num+=1 xpoint[num]=gr_Inregral_fc.Eval(iAmp)/3800;print xpoint[num] ypoint[num]= gr_Inregral_tdc.Eval(iAmp); print ypoint[num] TwoDGraph=TGraph(len(xpoint), xpoint,ypoint) canvas_Integral = MakeCanvas("can1","can1",800,800) TwoDGraph.SetTitle("Time [ns] vs. Energy [GeV] ") TwoDGraph.SetMarkerStyle(22) TwoDGraph.SetMarkerColor(3) TwoDGraph.SetMarkerSize(2) TwoDGraph.GetXaxis().SetTitle("Energy [GeV]") TwoDGraph.GetYaxis().SetTitle("Time [ns]") TwoDGraph.GetYaxis().SetRangeUser(TMath.MinElement(len(xpoint),TwoDGraph.GetY())/1.3, TMath.MaxElement(len(xpoint),TwoDGraph.GetY()) * 1.2) TwoDGraph.Draw() canvas_Integral.SaveAs("Final_Time_Energy.pdf")
def btag_efficiency(cut, year, pT_range=None): ### Preliminary Operations ### from root_numpy import hist2array from sklearn.metrics import roc_curve import numpy as np genPoints = [ 1600, 1800, 2000, 2500, 3000, 3500, 4000, 4500, 5000, 5500, 6000, 7000, 8000 ] signal = ['ZpBB_M' + str(x) for x in genPoints] btag_vars = BTAGGEFFVARS nbins = 100 min_, max_ = 0., 1. treeRead = True channel = cut isAH = False for k in sorted(alias.keys(), key=len, reverse=True): if k in cut: cut = cut.replace(k, aliasSM[k]) ### Create and fill MC histograms ### # Create dict file = {} tree = {} hist = {} ### Create and fill MC histograms ### for i, s in enumerate(back + signal): tree[s] = TChain("tree") for j, ss in enumerate(sample[s]['files']): if year == "run2" or year in ss: ### to run on big ntuples: #k = 0 #while True: # if os.path.exists("/eos/user/m/msommerh/Zprime_to_bb_analysis/" + ss + "/" + ss+ "_flatTuple_{}.root".format(k)): # tree[s].Add("/eos/user/m/msommerh/Zprime_to_bb_analysis/" + ss + "/" + ss + "_flatTuple_{}.root".format(k)) # k += 1 # else: # print "found {} files for sample:".format(k), ss # break #if k == 0: # print ' WARNING: files for sample', ss , 'do not exist, continuing' # return True ### end big ntuples tree[s].Add(NTUPLEDIR + ss + ".root") ## to run on skimmed ntuples for var in btag_vars: hist[s + "_" + var] = TH1F(s + "_" + var, ";efficiency; mistag rate", nbins, min_, max_) for suf in ["_1", "_2"]: temp_hist = TH1F(s + "_" + var + suf, ";efficiency; mistag rate", nbins, min_, max_) temp_hist.Sumw2() if pT_range is not None: pT_cut = " && jpt" + suf + ">=" + str( pT_range[0]) + " && jpt" + suf + "<" + str(pT_range[1]) else: pT_cut = "" if s in signal: flavourcut = " && abs(jflavour" + suf + ")==5" else: flavourcut = " && (abs(jflavour" + suf + ")<4 || abs(jflavour" + suf + ")==9 || abs(jflavour" + suf + ")==21)" ## FIXME this currently excludes charms if len(cut) == 0: flavourcut = flavourcut[4:] cutstring = "(eventWeightLumi)" + "*(" + cut + flavourcut + pT_cut + ")" tree[s].Project(s + "_" + var + suf, var + suf, cutstring) if not tree[s].GetTree() == None: hist[s + "_" + var].SetOption( "%s" % tree[s].GetTree().GetEntriesFast()) #hist[s][var+suf].Scale(sample[s]['weight'] if hist[s].Integral() >= 0 else 0) hist[s + "_" + var].Add(temp_hist) temp_hist.Delete() fpr = {} tpr = {} thr = {} for var in btag_vars: hist_sig = TH1F(var + "_sig", ";efficiency; mistag rate", nbins, min_, max_) hist_bkg = TH1F(var + "_bkg", ";efficiency; mistag rate", nbins, min_, max_) for i, s in enumerate(signal): hist_sig.Add(hist[s + "_" + var]) for i, s in enumerate(back): hist_bkg.Add(hist[s + "_" + var]) sig_arr, sig_edges = hist2array(hist_sig, return_edges=True) bkg_arr, bkg_edges = hist2array(hist_bkg, return_edges=True) assert len(sig_edges[0]) == len(bkg_edges[0]) vals = [] sig_weights = [] bkg_weights = [] for j, entry in enumerate(sig_edges[0][:-1]): vals.append(0.5 * (sig_edges[0][j] + sig_edges[0][j + 1])) sig_weights.append(sig_arr[j]) bkg_weights.append(bkg_arr[j]) sig_labels = np.ones(len(sig_weights)) bkg_labels = np.zeros(len(bkg_weights)) fpr[var], tpr[var], thr[var] = roc_curve(np.concatenate( (sig_labels, bkg_labels)), np.array(vals + vals), sample_weight=np.concatenate( (sig_weights, bkg_weights))) canv = TCanvas('c', 'c', 500, 650) canv.SetGrid() graphs = {} for j, var in enumerate(btag_vars): graphs[var] = TGraph(len(tpr[var]), tpr[var], fpr[var]) graphs[var].SetLineColor(btag_colors[var]) graphs[var].SetMarkerStyle(1) graphs[var].SetMarkerColor(btag_colors[var]) graphs[var].SetLineWidth(2) graphs[var].SetTitle(";b tagging efficiency;mistag rate (udsg jets)") graphs[var].GetXaxis().SetLimits(0., 1.) graphs[var].GetHistogram().SetMinimum(1e-4) graphs[var].GetHistogram().SetMaximum(1.) graphs[var].GetYaxis().SetTitleOffset(1.4) leg = TLegend(0.65, 0.15, 0.9, 0.35) for j, var in enumerate(btag_vars): leg.AddEntry(graphs[var], btag_titles[var]) if j == 0: graphs[var].Draw("APL") else: graphs[var].Draw("PL SAME") latex = TLatex(0.05, 0.5, str(pT_range[0]) + '<p_{T}<' + str(pT_range[1]) + ' GeV') latex.SetTextSize(0.043) latex.Draw() leg.Draw() canv.SetLogy() if pT_range is not None: pt_suff = "pT{}to{}".format(pT_range[0], pT_range[1]) else: pt_suff = "incl_pT" canv.Print("plots/btag_eff/ROC_{}_{}.png".format(year, pt_suff)) canv.Print("plots/btag_eff/ROC_{}_{}.pdf".format(year, pt_suff))
def trigger_efficiency(year, separate=False): from root_numpy import root2array, fill_hist from aliases import triggers, triggers_PFHT, triggers_Jet, triggers_BTag import numpy as np #spec_triggers = {"PFHT": triggers_PFHT, "Jet": triggers_Jet, "BTag": triggers_BTag} spec_triggers = { "HT/Jet": "(" + triggers_PFHT + " || " + triggers_Jet + ")", "BTag": triggers_BTag } spec_triggers_colors = { "PFHT": 418, "Jet": 4, "BTag": 6, "HT/Jet": 4, "total": 2 } hist_pass = TH1F("pass", "pass", 100, 0., 10000.) if separate: hist_pass_spec = {} for trig in spec_triggers.keys(): hist_pass_spec[trig] = TH1F("pass_" + trig, "pass_" + trig, 100, 0., 10000.) hist_all = TH1F("all", "all", 100, 0., 10000.) file_list = [] data_2016_letters = ["B", "C", "D", "E", "F", "G", "H"] data_2017_letters = ["B", "C", "D", "E", "F"] data_2018_letters = ["A", "B", "C", "D"] sample_names = [] if year == '2016': letters = data_2016_letters elif year == '2017': letters = data_2017_letters elif year == '2018': letters = data_2018_letters else: print "unknown year" sys.exit() for letter in letters: #dir_content = os.listdir(TRIGGERDIR+"/SingleMuon_{}_{}/".format(year, letter)) ## intended to run directly on ntuples #for entry in dir_content: # if "_flatTuple" in entry: file_list.append(TRIGGERDIR+"/SingleMuon_{}_{}/".format(year, letter)+entry) file_list.append(TRIGGERDIR + "/SingleMuon_{}_{}.root".format(year, letter)) print "appending:", TRIGGERDIR + "/SingleMuon_{}_{}.root".format( year, letter) for file_name in file_list: temp_array = root2array(file_name, treename='tree', branches='jj_mass_widejet', selection="jj_deltaEta_widejet<1.1") fill_hist(hist_all, temp_array) temp_array = root2array(file_name, treename='tree', branches='jj_mass_widejet', selection="jj_deltaEta_widejet<1.1 && " + triggers) fill_hist(hist_pass, temp_array) if separate: for trig in spec_triggers.keys(): temp_array = root2array( file_name, treename='tree', branches='jj_mass_widejet', selection="jj_deltaEta_widejet<1.1 && " + spec_triggers[trig]) fill_hist(hist_pass_spec[trig], temp_array) temp_array = None import array from aliases import dijet_bins binning = [] for num in dijet_bins: if num <= 10000: binning.append(num) #binning = range(0,1500,100)+range(1500,2000,100)+range(2000,3100,150)+range(3100,10000,300) binning_ = array.array('d', binning) hist_pass2 = hist_pass.Rebin( len(binning_) - 1, "hist_pass_rebinned", binning_) hist_all2 = hist_all.Rebin( len(binning_) - 1, "hist_all_rebinned", binning_) if separate: hist_pass_spec2 = {} for trig in spec_triggers.keys(): hist_pass_spec2[trig] = hist_pass_spec[trig].Rebin( len(binning_) - 1, "hist_pass_" + trig + "_rebinned", binning_) hist_pass2.Sumw2() hist_all2.Sumw2() eff = TGraphAsymmErrors() eff.Divide(hist_pass2, hist_all2) eff.SetMarkerColor(spec_triggers_colors["total"]) if separate: eff.SetMarkerStyle(5) else: eff.SetMarkerStyle(1) eff.SetLineColor(spec_triggers_colors["total"]) eff.SetLineWidth(2) if separate: eff_spec = {} for trig in spec_triggers.keys(): hist_pass_spec2[trig].Sumw2() eff_spec[trig] = TGraphAsymmErrors() eff_spec[trig].Divide(hist_pass_spec2[trig], hist_all2) eff_spec[trig].SetMarkerColor(spec_triggers_colors[trig]) eff_spec[trig].SetMarkerStyle(1) eff_spec[trig].SetLineColor(spec_triggers_colors[trig]) eff_spec[trig].SetLineWidth(2) one_line = TGraph() one_line.SetPoint(0, 0., 1.) one_line.SetPoint(1, 10000., 1.) one_line.SetLineStyle(2) c1 = TCanvas("c1", "Trigger Efficiency", 800, 800) c1.cd(1) eff.Draw("AP") one_line.Draw("L") eff.SetTitle(";m_{jj} (GeV);trigger efficiency") eff.SetMinimum(0.) eff.SetMaximum(1.4) #0.65 ## new dijet_bin_centers = [] for b, lthr in enumerate(dijet_bins[:-1]): if lthr < 1200 or lthr > 2500: continue dijet_bin_centers.append(0.5 * (dijet_bins[b] + dijet_bins[b + 1])) print "total trigger efficiency:" for cval in dijet_bin_centers: print cval, ":", eff.Eval(cval) ## end new if separate: leg = TLegend(0.65, 0.75, 0.9, 0.95) leg.AddEntry(eff, "total") for trig in spec_triggers.keys(): leg.AddEntry(eff_spec[trig], trig + "-based") eff_spec[trig].Draw("P SAME") ## new print trig, "trigger efficiency" for cval in dijet_bin_centers: print cval, ":", eff_spec[trig].Eval(cval) ## end new leg.Draw() eff.GetXaxis().SetTitleSize(0.045) eff.GetYaxis().SetTitleSize(0.045) eff.GetYaxis().SetTitleOffset(1.1) eff.GetXaxis().SetTitleOffset(1.05) eff.GetXaxis().SetLimits(700., 5000.) c1.SetTopMargin(0.05) #drawCMS(-1, "Preliminary", year=year) #Preliminary #drawCMS(-1, "Work in Progress", year=year, suppressCMS=True) drawCMS(-1, "", year=year, suppressCMS=True) drawAnalysis("") suffix = "" if separate: suffix = "_sep" c1.Print("plots/Efficiency/trigger_" + year + suffix + ".pdf") c1.Print("plots/Efficiency/trigger_" + year + suffix + ".png")
def main(): filename = read_file_name("LA_OUTPUT.txt") can = TCanvas("can", "can") can.SetGrid() mg = TMultiGraph() nn = 9 GR = [] NAME = [] px, py = array('d'), array('d') f = open(filename[2], 'r') indicator = 0 for line in f: if (indicator == 0): indicator = indicator + 1 continue Name, Total, Pos, Neg, TNum = line.split() name = Find_Loca(Name) name = Name.replace(Name[name:], "") # print(name) px.append((indicator - 1) % 9) py.append(float(TNum)) if ((indicator) % 9 == 0): NAME.append(name) gr = TGraph(nn, px, py) GR.append(gr) px, py = array('d'), array('d') indicator = indicator + 1 # print(GR); print(len(GR)) for i in range(len(GR)): GR[i].SetLineWidth(2) if "water" in NAME[i]: GR[i].SetLineWidth(5) GR[i].SetLineColor(1) GR[i].SetMarkerColor(1) if "wine" in NAME[i]: GR[i].SetMarkerColor(2) GR[i].SetLineColor(2) if "beer" in NAME[i]: GR[i].SetMarkerColor(5) GR[i].SetLineColor(5) if "tea" in NAME[i]: GR[i].SetMarkerColor(4) GR[i].SetLineColor(4) if "coffee" in NAME[i]: GR[i].SetMarkerColor(3) GR[i].SetLineColor(3) if "juice" in NAME[i]: GR[i].SetMarkerColor(7) GR[i].SetLineColor(7) if "COLA" in NAME[i]: GR[i].SetMarkerColor(6) GR[i].SetLineColor(6) GR[i].GetXaxis().SetTitle("days") GR[i].SetMarkerStyle(20) # GR[i].Fit("pol4","q") mg.Add(GR[i]) mg.Draw("ALP") leg = TLegend(0.65, 0.65, 0.9, 0.8) leg.SetBorderSize(0) leg.SetFillColor(10) for i in range(len(GR)): leg_entry = leg.AddEntry(GR[i], NAME[i], "l") leg.Draw() mg.SetTitle("Total tweets counts at LA") mg.GetHistogram().GetXaxis().SetTitle("days") mg.GetHistogram().GetXaxis().SetTitleOffset(1) mg.GetHistogram().GetXaxis().SetLabelSize(0.03) mg.GetHistogram().GetYaxis().SetTitle("Counts") mg.GetHistogram().GetYaxis().SetTitleOffset(1.3) mg.GetHistogram().GetYaxis().SetLabelSize(0.03) mg.GetHistogram().GetXaxis().SetBinLabel(5, "Mon") mg.GetHistogram().GetXaxis().SetBinLabel(16, "Tue") mg.GetHistogram().GetXaxis().SetBinLabel(28, "Wed") mg.GetHistogram().GetXaxis().SetBinLabel(40, "Thu") mg.GetHistogram().GetXaxis().SetBinLabel(51, "Fri") mg.GetHistogram().GetXaxis().SetBinLabel(63, "Sat") mg.GetHistogram().GetXaxis().SetBinLabel(73, "Sun") mg.GetHistogram().GetXaxis().SetBinLabel(84, "Mon") mg.GetHistogram().GetXaxis().SetBinLabel(96, "Tue") # for i in range(len(GR)): # mg.GetHistogram().GetXaxis().SetBinLabel(i,DAYS) # mg.GetHistogram().GetXaxis().SetLabel("tt") can.Modified() can.Update() # can.GetFrame().SetBorderSize( 12 ) can.Print("Total_tweet_LA.pdf")
def MakeCutPlot(c, cal, var, eb, elo, ehi, vb, vlo, vhi, d2Cut, d1Cut, outPlot, fastMode): """ Creates a channel-specific energy calibration plot. """ # Calculate cut vals (assumes plot range is correct) h1 = wl.H1D(cal, vb, vlo, vhi, var, d1Cut) h1Sum = h1.Integral() if h1Sum == 0: print( "Error: Failed %s, histogram sum is 0 so cannot normalize, setting to [0,0,0,0,0]" % (var)) return 0, 0, 0, 0, 0 h1.Scale(1 / h1Sum) try: cut99, cut95, cut01, cut05, cut90 = wl.GetIntegralPoints(h1) except: print("Error: Failed %s using cut %s, setting to [0,0,0,0,0]" % (var, d1Cut)) return 0, 0, 0, 0, 0 if fastMode: print("Returning fastMode output: ", cut99, cut95, cut01, cut05, cut90) return cut99, cut95, cut01, cut05, cut90 # Generate the plot for inspection. c.cd(2) gPad.SetLogy(0) h1.GetXaxis().SetRangeUser(cut01 - abs(0.25 * cut01), cut99 + abs(0.25 * cut99)) h1.SetTitle("") h1.GetXaxis().SetTitle(var) h1.Draw("hist") c.cd(1) gPad.SetLogy(0) cal.Draw( "%s:trapENFCal>>b(%d,%d,%d,%d,%.3E,%.3E)" % (var, eb + 10, elo - 5, ehi + 5, vb, cut01 - abs(0.25 * cut01), cut99 + abs(0.25 * cut99)), d2Cut) l1, l2, l3 = TLine(), TLine(), TLine() l1.SetLineColor(ROOT.kGreen) l2.SetLineColor(ROOT.kRed) l3.SetLineColor(ROOT.kMagenta) l1.DrawLine(elo - 5, cut99, ehi + 5, cut99) l2.DrawLine(elo - 5, cut95, ehi + 5, cut95) l2.DrawLine(elo - 5, cut05, ehi + 5, cut05) l1.DrawLine(elo - 5, cut01, ehi + 5, cut01) c.cd(3) x_h1, y_h1 = wl.npTH1D(h1) int_h1 = wl.integFunc(y_h1) g2 = TGraph(len(x_h1), x_h1, int_h1) g2.GetXaxis().SetRangeUser(cut01 - abs(0.3 * cut01), cut99 + abs(0.3 * cut99)) g2.SetTitle("") g2.GetXaxis().SetTitle(var) g2.GetYaxis().SetTitle("Percentile") g2.Draw("ACP") l1.DrawLine(cut99, 0, cut99, 1) l2.DrawLine(cut95, 0, cut95, 1) l1.DrawLine(cut01, 0, cut01, 1) l2.DrawLine(cut05, 0, cut05, 1) c.Print(outPlot) return cut99, cut95, cut01, cut05, cut90
mg.Add(brazil_yellow) mg.Add(brazil_green) mg.Draw("a3") yaxistitle = "#sigma #times A #times BR [pb]" if particle == "qbh": yaxistitle = "#sigma #times A [pb]" mg.GetXaxis().SetTitle("m_{%s} [GeV]" % particle_symbol) mg.GetYaxis().SetTitle(yaxistitle) mg.GetYaxis().SetRangeUser(*y_limits) mg.GetYaxis().SetTitleOffset(1.35) mg.GetXaxis().SetTitleOffset(1.2) mg.GetXaxis().SetNdivisions(508) brazil_line = TGraph(len(brazil_data), x, mean) brazil_line.SetLineStyle(7) brazil_line.SetLineColor(1) brazil_line.Draw("same") data_mass_limit_pairs = [] with open(data_cl_file, "r") as data_file: for line in data_file.readlines(): data_mass_limit_pairs.append(tuple(map(float, line.split(":")))) with open(op.join(args.output_dir, "b_{0}.txt".format(job_id)), "a") as out_file: for a, b in data_mass_limit_pairs: out_file.write("o:{0}:{1}\n".format(a, b / fb2)) data_x, data_y = zip(*sorted(data_mass_limit_pairs, key=itemgetter(0)))
avg = 0.0 mags = [] print "Scanning through files" for f in files: for l in f: n += 1 if( n >= 900): z += 1 l.strip() avg += float(l) mags.append(avg/float(z)) z = 0 avg = 0 n = 0 looks_minos() c1 = TCanvas() tg = TGraph() for x in xrange(len(mags)): tg.SetPoint(x,temps[x],mags[x]) tg.SetMarkerStyle(6) tg.Draw("AP") c1.Update() c1.Modified()
5100.0, 5200.0, 5300.0, 5400.0, 5500.0, 5600.0, 5700.0, 5800.0, 5900.0, 6000.0, 6100.0, 6200.0, 6300.0, 6400.0, 6500.0, 6600.0, 6700.0, 6800.0, 6900.0, 7000.0, 7100.0, 7200.0 ]) significances = array('d', [ 0.0, 0.361683, 1.17934, 0.937784, 0.20214, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.351713, 0.54517, 0.698591, 0.877327, 0.877771, 1.01375, 1.27896, 1.35268, 1.12581, 1.1746, 1.46086, 1.41497, 0.872541, 0.00435573, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0856762, 0.433186, 0.542791, 0.55899, 0.556067, 0.573986, 0.583046, 0.538931, 0.459697, 0.332036, 0.152038, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]) ##------------------------------------------------------ graph_sig = TGraph(len(masses), masses, significances) graph_sig.GetXaxis().SetTitle("qg resonance mass [GeV]") graph_sig.GetYaxis().SetTitle("Significance (local)") graph_sig.GetYaxis().SetTitleOffset(1.2) graph_sig.GetYaxis().SetRangeUser(0., 3.0) graph_sig.SetLineWidth(2) graph_sig.SetLineColor(kRed) graph_sig.SetMarkerStyle(21) graph_sig.SetMarkerSize(1) graph_sig.SetMarkerColor(kBlue) #graph_sig.GetXaxis().SetNdivisions(1005) gStyle.SetOptTitle(0) c = TCanvas("c", "", 800, 800) c.cd()
print 'dt ', dt print 'dx ', dx print str(dt / (dx * dx)) + '<' + str(1 / D) C = [Ct0] X = [0] for i in range(1, N - 1): C.append(random.gauss(Ct0, Ct0 * 0.001)) X.append(X[-1] + dx) C.append(C_L) X.append(L) FileOutRoot = TFile('Out.root', 'recreate') for t in range(0, 10000): C_tp = [C_0] for i in range(1, N - 1): C_tp.append(evolution(dt, dx, D, C[i], C[i + 1], C[i - 1])) C_tp.append(C_L) g = TGraph(N, np.asarray(X), np.asarray(C_tp)) g.Write('Ct_' + str(t)) for i in range(0, N): C[i] = C_tp[i] FileOutRoot.Close()
histoVar2.GetBinContent(iBin) - hRefVar['var2'].GetBinContent(iBin) ]) relVar = np.array(relVar) absVar = np.array(absVar) if doRelVar and removeOutliersRel: radius = inputCfg['outputs']['variations']['relative']['outliers'][ 'DBSCAN']['radius'] minsample = inputCfg['outputs']['variations']['relative']['outliers'][ 'DBSCAN']['minsample'] _, clLabelsRel = dbscan(relVar, eps=radius, min_samples=minsample, metric='euclidean') gRelVarOutliers = TGraph(0) if doAbsVar and removeOutliersAbs: radius = inputCfg['outputs']['variations']['absolute']['outliers'][ 'DBSCAN']['radius'] minsample = inputCfg['outputs']['variations']['absolute']['outliers'][ 'DBSCAN']['minsample'] _, clLabelsAbs = dbscan(relVar, eps=radius, min_samples=minsample, metric='euclidean') gAbsVarOutliers = TGraph(0) iPointOutlier, iPointCore = 0, 0 gRelVar, gAbsVar = TGraph(0), TGraph(0) if doRelVar: for iPoint, point in enumerate(relVar):
def CalculateTotalSelectionEfficiencies(self): print green(' --> Producing selection efficiencies.') gROOT.SetBatch(1) ROOT.gErrorIgnoreLevel = kError signalcategory = 'fromtau' backgroundcategories = ['fromhad', 'unmatched'] histnametags_per_lepton = { 'el': [''] + [signalcategory] + backgroundcategories, 'mu': [''] + [signalcategory] + backgroundcategories } histclassname_per_lepton = { 'el': ('Electrons', 'electron'), 'mu': ('Muons', 'muon') } ids_per_lepton = { 'mu': [ 'pteta', 'mvasoft', 'mvaloose', 'mvatight', 'cutsoft', 'cutloose', 'cuttight' ], 'el': [ 'pteta', 'cutveto', 'cutloose', 'cuttight', 'mvaisoloose', 'mvanonisoloose', 'mvaiso90', 'mvanoniso90' ] } colors = [kRed + 4, kRed + 1, kAzure - 2, kOrange, kGreen - 2] tags_denominator = { 'iddenominator': 'WrtAllReco', 'pteta': 'WrtPtEta', } for lep in ids_per_lepton.keys(): eff_sig_per_id = {} eff_bkg_per_id = {} eff_had_per_id = {} eff_unm_per_id = {} for id in ids_per_lepton[lep]: eff_sig_per_denomtag = {} eff_bkg_per_denomtag = {} eff_had_per_denomtag = {} eff_unm_per_denomtag = {} for denomtag in tags_denominator.keys(): eff_sig_per_signal = {} eff_bkg_per_signal = {} eff_had_per_signal = {} eff_unm_per_signal = {} npass_sig_per_signal = {} npass_bkg_per_signal = {} npass_had_per_signal = {} npass_unm_per_signal = {} ntot_sig_per_signal = {} ntot_bkg_per_signal = {} ntot_had_per_signal = {} ntot_unm_per_signal = {} for signal in self.signals: npass_sig_per_signal[signal] = 0 ntot_sig_per_signal[signal] = 0 npass_bkg_per_signal[signal] = 0 ntot_bkg_per_signal[signal] = 0 npass_had_per_signal[signal] = 0 ntot_had_per_signal[signal] = 0 npass_unm_per_signal[signal] = 0 ntot_unm_per_signal[signal] = 0 for tag in histnametags_per_lepton[lep]: is_signal = tag == signalcategory is_background = tag in backgroundcategories is_had = tag == 'fromhad' is_unmatched = tag == 'unmatched' hists_total = [] hists_pass = [] ratios = [] hists_n_total = [] hists_n_pass = [] for signal in self.signals: infilename = os.path.join(self.inputpath, 'MC__' + signal + '.root') infile = TFile(infilename, 'READ') hfn_den = '_'.join( [denomtag, histclassname_per_lepton[lep][0]]) hfn_num = '_'.join( [lep, id, histclassname_per_lepton[lep][0]]) h_total = infile.Get('/'.join([ hfn_den, histclassname_per_lepton[lep][1] + tag + 'pt_rebin2' ])) h_total.SetDirectory(0) hists_total.append(h_total) h_pass = infile.Get('/'.join([ hfn_num, histclassname_per_lepton[lep][1] + tag + 'pt_rebin2' ])) h_pass.SetDirectory(0) hists_pass.append(h_pass) h_n_total = infile.Get('/'.join([ hfn_den, 'n' + histclassname_per_lepton[lep][1] + 's' + tag ])) h_n_total.SetDirectory(0) hists_n_total.append(h_n_total) h_n_pass = infile.Get('/'.join([ hfn_num, 'n' + histclassname_per_lepton[lep][1] + 's' + tag ])) h_n_pass.SetDirectory(0) hists_n_pass.append(h_n_pass) ratio = TGraphAsymmErrors(h_pass, h_total, 'cl=0.683 b(1,1) mode') ratios.append(ratio) c = tdrDiCanvas( 'c', hists_total[0].GetBinLowEdge(1), hists_total[0].GetBinLowEdge( hists_total[0].GetNbinsX() + 1), 1E-2, 1E8, 0.3, 1.7, hists_total[0].GetXaxis().GetTitle(), hists_total[0].GetYaxis().GetTitle(), 'efficiency', True, 0, 11) leg = tdrLeg(0.25, 0.65, 0.85, 0.9, textSize=0.025) len(self.signals) for idx, signal in enumerate(self.signals): mlq, mps, mch = get_mlq_mps_mch(signal) c.cd(1).SetLogy() tdrDraw(hists_total[idx], "E", marker=kOpenCircle, mcolor=colors[idx], lcolor=colors[idx], fstyle=0) tdrDraw(hists_pass[idx], "E", marker=kFullCircle, mcolor=colors[idx], lcolor=colors[idx], fstyle=0) npass = 0 ntotal = 0 for i in range(hists_n_pass[idx].GetNbinsX()): npass += hists_n_pass[idx].GetBinContent( i + 1) * hists_n_pass[idx].GetBinCenter(i + 1) ntotal += hists_n_total[idx].GetBinContent( i + 1) * hists_n_total[idx].GetBinCenter(i + 1) total_eff = npass / ntotal if is_signal: npass_sig_per_signal[signal] += float(npass) ntot_sig_per_signal[signal] += float(ntotal) if is_background: npass_bkg_per_signal[signal] += float(npass) ntot_bkg_per_signal[signal] += float(ntotal) if is_had: npass_had_per_signal[signal] += float(npass) ntot_had_per_signal[signal] += float(ntotal) if is_unmatched: npass_unm_per_signal[signal] += float(npass) ntot_unm_per_signal[signal] += float(ntotal) leg.AddEntry( hists_pass[idx], 'M_{#psi} = %i GeV, M_{DM} = %i GeV (tot. eff: %.2f)' % (mps, mch, total_eff), 'L') c.cd(2) tdrDraw(ratios[idx], "P", marker=kFullCircle, mcolor=colors[idx], lcolor=colors[idx], fstyle=0) tagstr = '' if tag == '' else '_' + tag c.SaveAs( os.path.join( self.plotoutput_path, 'IDEfficiency_%s_%s_%s%s.pdf' % (lep, tags_denominator[denomtag], id, tagstr))) for signal in self.signals: eff_sig_per_signal[signal] = npass_sig_per_signal[ signal] / ntot_sig_per_signal[signal] eff_bkg_per_signal[signal] = npass_bkg_per_signal[ signal] / ntot_bkg_per_signal[signal] eff_had_per_signal[signal] = npass_had_per_signal[ signal] / ntot_had_per_signal[signal] eff_unm_per_signal[signal] = npass_unm_per_signal[ signal] / ntot_unm_per_signal[signal] eff_sig_per_denomtag[denomtag] = eff_sig_per_signal eff_bkg_per_denomtag[denomtag] = eff_bkg_per_signal eff_had_per_denomtag[denomtag] = eff_had_per_signal eff_unm_per_denomtag[denomtag] = eff_unm_per_signal eff_sig_per_id[id] = eff_sig_per_denomtag eff_bkg_per_id[id] = eff_bkg_per_denomtag eff_had_per_id[id] = eff_had_per_denomtag eff_unm_per_id[id] = eff_unm_per_denomtag for signal in self.signals: for denomtag in tags_denominator.keys(): graphs_bkg = [] graphs_had = [] graphs_unm = [] legends_bkg = [] legends_had = [] legends_unm = [] for id in ids_per_lepton[lep]: graph_bkg = TGraph() graph_bkg.SetPoint(0, eff_sig_per_id[id][denomtag][signal], eff_bkg_per_id[id][denomtag][signal]) legends_bkg.append(id) graphs_bkg.append(graph_bkg) graph_had = TGraph() graph_had.SetPoint(0, eff_sig_per_id[id][denomtag][signal], eff_had_per_id[id][denomtag][signal]) legends_had.append(id) graphs_had.append(graph_had) graph_unm = TGraph() graph_unm.SetPoint(0, eff_sig_per_id[id][denomtag][signal], eff_unm_per_id[id][denomtag][signal]) legends_unm.append(id) graphs_unm.append(graph_unm) cgrbkg = tdrCanvas( 'cgrbkg', 0, 1, 1E-3, 1, '%s from #tau efficiency' % (histclassname_per_lepton[lep][1]), 'other %s efficiency' % (histclassname_per_lepton[lep][1]), True, 0, 11) legend_bkg = tdrLeg(0.25, 0.65, 0.85, 0.9, textSize=0.025) for i in range(len(graphs_bkg)): g = graphs_bkg[i] l = legends_bkg[i] tdrDraw(g, "P", marker=kFullCircle, mcolor=i + 1, lcolor=i + 1, fstyle=0) legend_bkg.AddEntry(g, l, 'P') cgrbkg.SetLogy() cgrbkg.SaveAs( os.path.join( self.plotoutput_path, 'IDEfficiencyVsBackground_%s_%s_%s.pdf' % (lep, signal, tags_denominator[denomtag]))) cgrhad = tdrCanvas( 'cgrhad', 0, 1, 1E-3, 1, '%s from #tau efficiency' % (histclassname_per_lepton[lep][1]), '%s from had. efficiency' % (histclassname_per_lepton[lep][1]), True, 0, 11) legend_had = tdrLeg(0.25, 0.65, 0.85, 0.9, textSize=0.025) for i in range(len(graphs_had)): g = graphs_had[i] l = legends_had[i] tdrDraw(g, "P", marker=kFullCircle, mcolor=i + 1, lcolor=i + 1, fstyle=0) legend_had.AddEntry(g, l, 'P') cgrhad.SetLogy() cgrhad.SaveAs( os.path.join( self.plotoutput_path, 'IDEfficiencyVsHadronic_%s_%s_%s.pdf' % (lep, signal, tags_denominator[denomtag]))) cgrunm = tdrCanvas( 'cgrunm', 0, 1, 1E-3, 1, '%s from #tau efficiency' % (histclassname_per_lepton[lep][1]), 'unmatched %s efficiency' % (histclassname_per_lepton[lep][1]), True, 0, 11) legend_unm = tdrLeg(0.25, 0.65, 0.85, 0.9, textSize=0.025) for i in range(len(graphs_unm)): g = graphs_unm[i] l = legends_unm[i] tdrDraw(g, "P", marker=kFullCircle, mcolor=i + 1, lcolor=i + 1, fstyle=0) legend_unm.AddEntry(g, l, 'P') cgrunm.SetLogy() # os.path.join(self.plotoutput_path, 'ReconstructionEfficiency_%s_%s_%s%s.pdf' % (lep, histfolders_denom[histfolder_denom], id, tagstr)) cgrunm.SaveAs( os.path.join( self.plotoutput_path, 'IDEfficiencyVsUnmatched_%s_%s_%s.pdf' % (lep, signal, tags_denominator[denomtag])))
def __init__(self, name, title, lenght, time_min, time_max, helix, n_points=100, ip_algorithm='complex'): """ Constructor providing: name: string used to identify ROOT objects title: string used as title of canvases and graphs lenght: half of the axis dimension time_min and time_max: defining the time interval for which the track is shown helix: helix object to be shown; having the ip attributes is mandatory n_points: number of points that show the track ip_algorithm: if 'complex' it shows also the distance of closest approach to the jet direction, and the linearized track at that point. It requires to have run the function compute_IP_wrt_direction on the helix object. """ self.name = name self.title = title self.helix = helix self.ip_algorithm = ip_algorithm self.gr_transverse = TGraph() self.gr_transverse.SetNameTitle("g_tr_" + name, title) self.gr_transverse.SetPoint(0, 0., 0.) self.gr_transverse.SetPoint(1, 0., lenght) self.gr_transverse.SetPoint(2, 0., -lenght) self.gr_transverse.SetPoint(3, lenght, 0.) self.gr_transverse.SetPoint(4, -lenght, 0.) self.gr_transverse.SetMarkerStyle(22) self.gr_transverse.SetMarkerColor(3) self.gr_transverse.GetXaxis().SetTitle("X axis") self.gr_transverse.GetYaxis().SetTitle("Y axis") # Origin self.gr_transverse.SetPoint(5, helix.origin.X(), helix.origin.Y()) # Track self.ell_transverse = TGraph() self.ell_transverse.SetNameTitle("g_ellipse_" + name, title) self.ell_transverse.SetMarkerStyle(7) self.ell_transverse.SetMarkerColor(1) for i in range(n_points): time_coord = time_min + i * (time_max - time_min) / n_points point = helix.point_at_time(time_coord) self.ell_transverse.SetPoint(i, point.X(), point.Y()) # Jet direction jet_dir_x1 = self.helix.primary_vertex.X( ) - lenght * self.helix.jet_direction.X() jet_dir_x2 = self.helix.primary_vertex.X( ) + lenght * self.helix.jet_direction.X() jet_dir_y1 = self.helix.primary_vertex.Y( ) - lenght * self.helix.jet_direction.Y() jet_dir_y2 = self.helix.primary_vertex.Y( ) + lenght * self.helix.jet_direction.Y() self.jet_dir = TLine(jet_dir_x1, jet_dir_y1, jet_dir_x2, jet_dir_y2) self.jet_dir.SetLineColor(6) self.jet_dir.SetLineStyle(1) self.jet_dir.SetLineWidth(1) # Impact Parameter D impact_parameter_x1 = self.helix.primary_vertex.X() impact_parameter_y1 = self.helix.primary_vertex.Y() impact_parameter_x2 = self.helix.vector_impact_parameter.X() impact_parameter_y2 = self.helix.vector_impact_parameter.Y() self.impact_parameter = TLine(impact_parameter_x1, impact_parameter_y1, impact_parameter_x2, impact_parameter_y2) self.impact_parameter.SetLineColor(4) self.impact_parameter.SetLineStyle(6) self.impact_parameter.SetLineWidth(4) if self.ip_algorithm == 'complex': # Linearized_track lin_track_x1 = self.helix.linearized_track.origin.X() \ - lenght * self.helix.linearized_track.direction.X() lin_track_x2 = self.helix.linearized_track.origin.X() \ + lenght * self.helix.linearized_track.direction.X() lin_track_y1 = self.helix.linearized_track.origin.Y() \ - lenght * self.helix.linearized_track.direction.Y() lin_track_y2 = self.helix.linearized_track.origin.Y() \ + lenght * self.helix.linearized_track.direction.Y() self.lin_track = TLine(lin_track_x1, lin_track_y1, lin_track_x2, lin_track_y2) self.lin_track.SetLineColor(2) self.lin_track.SetLineStyle(9) self.lin_track.SetLineWidth(2) # Jet-track distance D_j: vector from S_j to S_t jet_track_distance_x1 = self.helix.jet_point_min_approach.X() jet_track_distance_y1 = self.helix.jet_point_min_approach.Y() jet_track_distance_x2 = self.helix.point_min_approach.X() jet_track_distance_y2 = self.helix.point_min_approach.Y() self.jet_track_distance = TLine(jet_track_distance_x1, jet_track_distance_y1, jet_track_distance_x2, jet_track_distance_y2) self.jet_track_distance.SetLineColor(3) self.jet_track_distance.SetLineStyle(3) self.jet_track_distance.SetLineWidth(4)
def uncertainty_interpolation(year, category, uncertainty_type="BTag"): uncerts = {'up': {}, 'down': {}} g_up = TGraph() g_up.SetTitle("uncert;m_{X} (GeV);uncert") g_up.SetMarkerStyle(20) g_up.SetMarkerColor(2) i_up = TGraph() i_up.SetMarkerStyle(24) i_up.SetMarkerColor(2) f_up = TF1("f_up", "pol0", 0, 1) g_down = TGraph() g_down.SetMarkerStyle(20) g_down.SetMarkerColor(4) i_down = TGraph() i_down.SetMarkerStyle(24) i_down.SetMarkerColor(4) f_down = TF1("f_down", "pol0", 0, 1) n = 0 for i, m in enumerate(genPoints): if year == "run2": up_value = 0 for yr in ['2016', '2017', '2018']: up_value += LUMI[yr] * sample['ZpBB_M{}'.format(m)][ uncertainty_type + '_uncertainties'][yr]['up'][category] up_value /= LUMI['run2'] else: up_value = sample['ZpBB_M{}'.format(m)][ uncertainty_type + '_uncertainties'][year]['up'][category] if up_value == -100: continue g_up.SetPoint(n, m, up_value) n = n + 1 if n == 0: print "no valid uncertainties detected!!" sys.exit() n = 0 for i, m in enumerate(genPoints): if year == "run2": down_value = 0 for yr in ['2016', '2017', '2018']: down_value += LUMI[yr] * sample['ZpBB_M{}'.format(m)][ uncertainty_type + '_uncertainties'][yr]['down'][category] down_value /= LUMI['run2'] else: down_value = sample['ZpBB_M{}'.format(m)][ uncertainty_type + '_uncertainties'][year]['down'][category] if down_value == -100: continue g_down.SetPoint(n, m, down_value) n = n + 1 if n == 0: print "no valid uncertainties detected!!" sys.exit() g_up.Fit(f_up, "Q0", "SAME") g_down.Fit(f_down, "Q0", "SAME") for m in massPoints: up_val = g_up.Eval(m) uncerts['up'][m] = up_val i_up.SetPoint(i_up.GetN(), m, up_val) down_val = g_down.Eval(m) uncerts['down'][m] = down_val i_down.SetPoint(i_down.GetN(), m, down_val) c = TCanvas("c2", "Signal Efficiency", 800, 600) g_up.Draw("APL") i_up.Draw("P, SAME") g_down.Draw("PL, SAME") i_down.Draw("P, SAME") g_up.GetYaxis().SetRangeUser(-1., 1.) g_up.GetXaxis().SetRangeUser(genPoints[0] - 100, genPoints[-1] + 100) leg = TLegend(0.7, 0.75, 0.9, 0.9) leg.AddEntry(g_up, "up") leg.AddEntry(g_down, "down") leg.Draw() c.Print(PLOTDIR + uncertainty_type + "_uncertainty_interpol_{}_{}.png".format(year, category)) return uncerts
def makepTbinsPlots(w, rfr, is_prefit, suffix, plotdir, yields=None, save_hists=False): """ Plot VpT distributions in each tag region """ logging.info("Plotting VpT Distributions") if is_prefit: w.loadSnapshot("vars_initial") else: w.loadSnapshot("vars_final") if not yields: logging.debug("Yields not provided. Compute them") getYields(w, rfr, True) yields = Config.yields os.system("mkdir -vp " + plotdir) ptbins_cut = array('d', [0, 90, 120, 160, 200, 250]) hmodel_cut = TH1F("hmodel_cut", "hmodel_cut", 5, ptbins_cut) errmodel_x_cut = array('d', [ 0, 90, 90, 120, 120, 160, 160, 200, 200, 250, 250, 200, 200, 160, 160, 120, 120, 90, 90, 0 ]) errmodel_y_cut = array('d', [0 for i in range(20)]) errmodel_cut = TGraph(20, errmodel_x_cut, errmodel_y_cut) ptbins_mva = array('d', [0, 120, 250]) hmodel_mva = TH1F("hmodel_mva", "hmodel_mva", 2, ptbins_mva) errmodel_x_mva = array('d', [0, 120, 120, 250, 250, 120, 120, 0]) errmodel_y_mva = array('d', [0 for i in range(8)]) errmodel_mva = TGraph(8, errmodel_x_mva, errmodel_y_mva) ptbins_cut_0lep = array('d', [0, 100, 120, 160, 200, 250]) hmodel_cut_0lep = TH1F("hmodel_cut_0lep", "hmodel_cut_0lep", 5, ptbins_cut_0lep) errmodel_x_cut_0lep = array('d', [ 0, 100, 100, 120, 120, 160, 160, 200, 200, 250, 250, 200, 200, 160, 160, 120, 120, 100, 100, 0 ]) errmodel_y_cut_0lep = array('d', [0 for i in range(20)]) errmodel_cut_0lep = TGraph(20, errmodel_x_cut_0lep, errmodel_y_cut_0lep) ptbins_mva_0lep = array('d', [0, 100, 120, 250]) hmodel_mva_0lep = TH1F("hmodel_mva_0lep", "hmodel_mva_0lep", 3, ptbins_mva_0lep) errmodel_x_mva_0lep = array( 'd', [0, 100, 100, 120, 120, 250, 250, 120, 120, 100, 100, 0]) errmodel_y_mva_0lep = array('d', [0 for i in range(12)]) errmodel_mva_0lep = TGraph(12, errmodel_x_mva_0lep, errmodel_y_mva_0lep) histos = {} mass = None for k, y in yields.iteritems(): parts = k.split('_') # k: Region_Y2012_isMVA1_B2_J2_T2_L2_distmva_TType # find the bin: pos1 = k.find("_B") pos2 = k.find("_", pos1 + 1) if pos2 - pos1 != 3: logging.error( "name of the region {} does not seem to be a standard one". format(k)) logging.error("_B should match the bin name") return # TODO: horrible. Need to take care of 0 lepton low MET bin properly, especially in MVA case where lowMET is still CUT regname = k[:pos1 + 2] + '9' + k[pos2:] bin = int(k[pos1 + 2]) pos1 = regname.find("_dist") pos2 = regname.find("_", pos1 + 1) regname = regname[:pos1 + 5] + "VpT" + regname[pos2:] pos1 = regname.find("_isMVA") isMVA = int(regname[pos1 + 6]) pos1 = k.find("_L") pos2 = k.find("_", pos1 + 1) nlep = int(k[pos1 + 2]) logging.info("Accumulating for region {}".format(regname)) ibin = bin + 1 if isMVA and nlep != 0 and ibin == 3: # MVA has no B1 ibin = 2 if isMVA: if nlep == 0: hmodel = hmodel_mva_0lep errmodel = errmodel_mva_0lep else: hmodel = hmodel_mva errmodel = errmodel_mva else: if nlep == 0: hmodel = hmodel_cut_0lep errmodel = errmodel_cut_0lep else: hmodel = hmodel_cut errmodel = errmodel_cut if not regname in histos: histos[regname] = {} for s, v in y.iteritems(): if s.startswith("L_x"): sname = getCompName(s) histos[regname][sname] = hmodel.Clone(sname) if mass == None: res = is_signal(sname) if res: mass = res histos[regname]["data"] = hmodel.Clone("data") histos[regname]["error"] = errmodel.Clone("error") histos[regname]["prefit"] = [hmodel.Clone("prefit"), ""] # now, fill the histos for s, v in y.iteritems(): if s.startswith("L_x"): sname = getCompName(s) try: histos[regname][getCompName(s)].SetBinContent(ibin, v[0]) except KeyError: # case when a given component is 0 in the first found VpT bin, but !=0 elsewhere sname = getCompName(s) histos[regname][sname] = hmodel.Clone(sname) histos[regname][sname].SetBinContent(ibin, v[0]) histos[regname]["data"].SetBinContent(ibin, y["data"]) (mcval, mcerr) = y["MC"] if mcerr == -1: # recompute case by case if not already computed somewhere mcerr = getMCerror(w, rfr, k) y["MC"] = [mcval, mcerr] X = Double() Y = Double() for i in [2 * ibin - 2, 2 * ibin - 1]: histos[regname]["error"].GetPoint(i, X, Y) histos[regname]["error"].SetPoint(i, X, mcval - mcerr) npoints = histos[regname]["error"].GetN() for i in [npoints + 1 - 2 * ibin, npoints - 2 * ibin]: histos[regname]["error"].GetPoint(i, X, Y) histos[regname]["error"].SetPoint(i, X, mcval + mcerr) # if doing postfit, add the prefit line if not is_prefit: histo, mulegend = getPrefitCurve(w, regname=k) histos[regname]["prefit"][0].SetBinContent(ibin, histo.Integral()) print("PREFIT ", mulegend) logging.info("PREFIT {}".format(mulegend)) histos[regname]["prefit"][1] = mulegend for reg, h in histos.iteritems(): h["data"] = TGraphAsymmErrors(h["data"]) # TODO use Poisson errors ? sm = mkplots.SetupMaker(reg, mass, muhat=Config.muhat) for k, v in h.iteritems(): sm.add(k, v) cname = reg + "_" + suffix can = sm.setup.make_complete_plot(cname, True, ybounds=(0.85, 1.15)) plotname = "{0}/{1}".format(plotdir, can.GetName()) can2 = sm.setup.make_complete_plot(cname + "_logy", True, True, ybounds=(0.85, 1.15)) plotname2 = "{0}/{1}".format(plotdir, can2.GetName()) for f in Config.formats: can.Print(plotname + '.' + f) can2.Print(plotname2 + '.' + f) # save histograms if requested if save_hists: afile = TFile.Open(plotname + ".root", "recreate") can.Write(can.GetName()) can2.Write(can2.GetName()) for k, v in h.iteritems(): if isinstance(v, TObject): v.Write(v.GetName()) if k == "prefit": v[0].Write(v[0].GetName()) can.Close() can2.Close() # free memory for some objects used in the plotting... mkplots.purge() # TODO check for things not deleted Config.save_yields()