def test_init(): l = Legend(2) h = Hist(10, 0, 1) l.AddEntry(h) hr = TH1D("test", "", 10, 0, 1) l.AddEntry(hr)
def test_init(): with invisible_canvas(): l = Legend(2) h = Hist(10, 0, 1) l.AddEntry(h) hr = TH1D("test", "", 10, 0, 1) l.AddEntry(hr)
def make_plot(parentDirectory, efficiencyName, titleText, outfn, legendText=None, drawHist=False, binsToMerge=None, numerAdd=None): _efficiency = get_efficiency(parentDirectory, efficiencyName + '__total', efficiencyName + '__match', binsToMerge=binsToMerge, numerAdd=numerAdd) _graph = _efficiency.graph _graph.drawstyle = 'AP' draw(_graph, xtitle='Lxy [cm]', ytitle='Efficiency') title = TitleAsLatex(titleText) title.Draw() if legendText: leg = Legend(1, margin=0.25, leftmargin=0.45, topmargin=0.02, entrysep=0.01, entryheight=0.02, textsize=12) leg.AddEntry(_graph, legendText, style='LEP') leg.Draw() canvas.SaveAs(outfn) canvas.clear() if drawHist: _total, _passed = _efficiency.total, _efficiency.passed _passed.markercolor = 'red' draw([_total, _passed], logy=True) title.Draw() leg = Legend(2, margin=0.25, leftmargin=0.45, topmargin=0.02, entrysep=0.01, entryheight=0.02, textsize=12) leg.AddEntry(_total, label='total', style='LEP') leg.AddEntry(_passed, label='passed', style='LEP') leg.Draw() canvas.SaveAs(outfn.replace('.pdf', '__HIST.pdf')) canvas.clear()
def drawDataLegend(inputdatastack, inputstack, plotData, BLINDEDLIST, defaultlabelsize, Region): datalegend_entries = 2 #figure out how to remove this magic number datamargin = 0.10 datarightmargin = 0.00 datatopmargin = 0.05 dataentryheight = 0.045 dataentrysep = 0.06 datalegend = Legend(datalegend_entries, leftmargin=0.26, topmargin=datatopmargin, rightmargin=datarightmargin, entryheight=dataentryheight, entrysep=dataentrysep, margin=datamargin, textfont=43, textsize=defaultlabelsize, header=None) datalegend.SetLineColor(0) if plotData: if Region not in BLINDEDLIST: datalegend.AddEntry( inputdatastack.sum, label="Data [" + str(round(inputdatastack.sum.integral(overflow=True), 1)) + "]", style="EP") errorband = inputstack.sum.Clone() errorband.SetLineWidth(10) errorband.SetFillStyle(3244) errorband.SetFillColor(922) if Region == "A" or Region == "B" or Region == "D" or Region == "VRC" or Region == "VRD": datalegend.AddEntry( inputstack.sum, label="SM [" + str(round(float(inputstack.sum.integral(overflow=True)), 1)) + "\pm" + str( round( float( inputstack.sum.integral(error=True, overflow=True)[1]), 1)) + "]", style="L") else: datalegend.AddEntry( inputstack.sum, label="SM [" + str(round(float(inputstack.sum.integral(overflow=True)), 1)) + "]", style="L") datalegend.Draw("SAME")
def compare_efficiency(parentDirectory, efficiencyName, titleText, outfn, baseLegendText=None, binsToMerge=None, numerAdds=[], additionalLegendTexts=[]): base_efficiency = get_efficiency(parentDirectory, efficiencyName + '__total', efficiencyName + '__match', binsToMerge=binsToMerge, numerAdd=None).graph base_efficiency.drawstyle = 'AP' base_efficiency.markercolor = sigCOLORS[6] base_efficiency.linecolor = sigCOLORS[6] comp_efficiencies = [] for numerAdd in numerAdds: g = get_efficiency(parentDirectory, efficiencyName + '__total', efficiencyName + '__match', binsToMerge=binsToMerge, numerAdd=numerAdd).graph comp_efficiencies.append(g) for i, g in enumerate(comp_efficiencies): g.drawstyle = 'P' g.markercolor = sigCOLORS[i + 7] g.linecolor = sigCOLORS[i + 7] draw([base_efficiency] + [g for g in comp_efficiencies], xtitle='Lxy [cm]', ytitle='Efficiency') title = TitleAsLatex(titleText) title.Draw() if baseLegendText: leg = Legend(1 + len(numerAdds), margin=0.25, leftmargin=0.45, topmargin=0.02, entrysep=0.01, entryheight=0.03, textsize=14) leg.AddEntry(base_efficiency, baseLegendText, style='LEP') for g, t in zip(comp_efficiencies, additionalLegendTexts): leg.AddEntry(g, t, style='LEP') leg.Draw() canvas.SaveAs(outfn) canvas.clear()
def __make_overlay(self, hists, fits, labels, ytitle, suffix=""): with preserve_current_style(): # Draw each resolution (with fit) xtitle = self.online_title canvas = draw(hists, draw_args={ "xtitle": xtitle, "ytitle": ytitle }) if fits: for fit, hist in zip(fits, hists): fit["asymmetric"].linecolor = hist.GetLineColor() fit["asymmetric"].Draw("same") # Add labels label_canvas() # Add a legend legend = Legend(len(hists), header="Pile-up bin", topmargin=0.35, entryheight=0.035) for hist, label in zip(hists, labels): legend.AddEntry(hist, label) legend.SetBorderSize(0) legend.Draw() # Save canvas to file name = self.filename_format.format(pileup="all") self.save_canvas(canvas, name + suffix)
def __make_overlay(self, pileup, threshold, hists, fits, labels, header): with preserve_current_style(): # Draw each efficiency (with fit) canvas = draw(hists, draw_args={ "xtitle": self.offline_title, "ytitle": "Efficiency" }) if len(fits) > 0: for fit, hist in zip(fits, hists): fit["asymmetric"].linecolor = hist.GetLineColor() fit["asymmetric"].Draw("same") # Add labels label_canvas() # Add a legend legend = Legend( len(hists), header=self.legend_title, topmargin=0.35, rightmargin=0.3, leftmargin=0.7, textsize=0.035, entryheight=0.035, ) for hist, label in zip(hists, labels): legend.AddEntry(hist, label) legend.SetBorderSize(0) legend.Draw() # Save canvas to file name = self.filename_format.format(pileup=pileup, threshold=threshold) self.save_canvas(canvas, name)
def plotResults(variable, data, templates, results): resCan = Canvas() leg = Legend(nTemplates + 2) data.Draw('PE') leg.AddEntry(data, style='LEP') nBins = len(inputTemplates[variable]['data'][whichBinFromFile]) h_tSumAfter = Hist(nBins, 0, nBins, title='after_' + variable) if useT1: plotTemplateAfter(templates[tNames['t1']], results[tNames['t1']][0], resCan, leg, h_tSumAfter) pass if useT2: plotTemplateAfter(templates[tNames['t2']], results[tNames['t2']][0], resCan, leg, h_tSumAfter) pass if useT3: plotTemplateAfter(templates[tNames['t3']], results[tNames['t3']][0], resCan, leg, h_tSumAfter) pass if useT4: plotTemplateAfter(templates[tNames['t4']], results[tNames['t4']][0], resCan, leg, h_tSumAfter) pass leg.Draw() h_tSumAfter.SetLineColor(2) h_tSumAfter.SetLineStyle(7) h_tSumAfter.SetMarkerSize(0) h_tSumAfter.Draw('SAME HIST') resCan.Update() return resCan, h_tSumAfter
def __make_overlay(self, hists, fits, labels, thresholds, suffix=""): with preserve_current_style(): # Draw each rate vs pileup (with fit) xtitle = "< \\mu >" ytitle = "Rate (kHz)" canvas = draw(hists, draw_args={"xtitle": xtitle, "ytitle": ytitle, "xlimits": (20, 50), "ylimits": (0, 5)}) if fits: for fit, hist in zip(fits, hists): fit["asymmetric"].linecolor = hist.GetLineColor() fit["asymmetric"].Draw("same") # Add labels label_canvas() # Add a legend legend = Legend( len(hists), header=self.legend_title, topmargin=0.02, leftmargin=0.22, rightmargin=0.78, textsize=0.025, entryheight=0.028, ) for hist, label in zip(hists, labels): legend.AddEntry(hist, label) legend.SetBorderSize(0) legend.Draw() # Save canvas to file name = self.filename_format.format(threshold=thresholds[0]) self.save_canvas(canvas, name + suffix)
def routine(chan, var): hs_b, hs_a = [], [] htitle = None numbers = defaultdict(dict) # before chandir = getattr(beforef, 'ch' + chan) for it, sigtag in enumerate(sigTAGS): h = getattr(getattr(chandir.sig, sigtag), var) # Hist if htitle is None: htitle = h.title h.title = sigtag + ' w/ mu iso' h.drawstyle = 'hist' h.color = sigCOLORS[it] h.linewidth = 2 h.legendstyle = 'L' hs_b.append(h) numbers[sigtag]['before'] = h.integral() # after chandir = getattr(afterf, 'ch' + chan) for it, sigtag in enumerate(sigTAGS): h = getattr(getattr(chandir.sig, sigtag), var) # Hist h.title = 'w/o mu iso' h.drawstyle = 'hist' h.color = sigCOLORS[it] h.linewidth = 2 h.linestyle = 'dashed' h.legendstyle = 'L' hs_a.append(h) numbers[sigtag]['after'] = h.integral() print('>', chan, var) df = pd.DataFrame(numbers).T df['incr %'] = (df['after'] - df['before']) / df['before'] * 100 print(df[['before', 'after', 'incr %']]) draw(hs_b + hs_a, logy=True) legend = Legend(len(hs_b), pad=canvas, margin=0.25, leftmargin=0.3, topmargin=0.02, entrysep=0.01, entryheight=0.02, textsize=10) legend.SetNColumns(2) for _b, _a in zip(hs_b, hs_a): legend.AddEntry(_b) legend.AddEntry(_a) legend.Draw() title = TitleAsLatex('[{}] '.format(chan.replace('mu', '#mu')) + htitle) title.Draw() draw_labels('59.74 fb^{-1} (13 TeV)', cms_position='left', extra_text='work-in-progress') canvas.SaveAs('{}/ch{}_{}.pdf'.format(outdir, chan, var)) canvas.Clear()
def drawBackgroundLegend(backgroundstacks, stack, LegendExtraInformation, defaultlabelsize, Region): legend_entries = 4 #figure out how to remove this magic number margin = 0.30 rightmargin = 0.07 topmargin = 0.05 entryheight = 0.045 entrysep = 0.06 legend = Legend(legend_entries, leftmargin=0.49, topmargin=topmargin, rightmargin=rightmargin, entryheight=entryheight, entrysep=entrysep, margin=margin, textfont=43, textsize=defaultlabelsize, header=None) legend.SetLineColor(0) totalyield, totalerror = stack.sum.integral(error=True, overflow=True) for LegendGroup in backgroundstacks: if LegendGroup is 'Data': continue backgroundyield, backgrounderror = backgroundstacks[ LegendGroup].sum.integral(error=True, overflow=True) if LegendExtraInformation == "Relative" and totalyield != 0: relativeyield = str(round(100 * backgroundyield / totalyield, 1)) legend.AddEntry(backgroundstacks[LegendGroup].sum, label=LegendGroup + " [" + relativeyield + "%]", style="F") elif LegendExtraInformation == "Absolute": legend.AddEntry(backgroundstacks[LegendGroup].sum, label=LegendGroup + " (" + str(round(backgroundyield, 1)) + ")", style="F") else: legend.AddEntry(backgroundstacks[LegendGroup].sum, label=LegendGroup, style="F") legend.Draw("SAME")
def __make_overlay(self, pileup, threshold, hists, fits, labels, header): with preserve_current_style(): name = self.filename_format.format(pileup=pileup, threshold=threshold) xmin = hists[0].GetTotalHistogram().GetBinLowEdge(1) xmax = hists[0].GetTotalHistogram().GetBinLowEdge( hists[0].GetTotalHistogram().GetNbinsX() + 1) # Draw each efficiency (with fit) draw_args = { "xtitle": self.offline_title, "ytitle": "Efficiency", "xlimits": [xmin, xmax] } canvas = draw(hists, draw_args=draw_args) if len(fits) > 0: for fit, hist in zip(fits, hists): fit["asymmetric"].linecolor = hist.GetLineColor() fit["asymmetric"].Draw("same") # Add labels label_canvas() # Add a legend legend = Legend( len(hists), header=self.legend_title, topmargin=0.35, rightmargin=0.3, leftmargin=0.7, textsize=0.025, entryheight=0.028, ) for hist, label in zip(hists, labels): legend.AddEntry(hist, label) legend.SetBorderSize(0) legend.Draw() for val in [0.25, 0.5, 0.75, 0.95, 1.]: line = ROOT.TLine(xmin, val, xmax, val) line.SetLineStyle("dashed") line.SetLineColor(15) line.Draw() for thresh in self.thresholds.bins: line = ROOT.TLine(thresh, 0., thresh, 1.) line.SetLineStyle("dashed") line.SetLineColor(15) line.Draw() # Save canvas to file self.save_canvas(canvas, name)
def __make_overlay(self, hists, fits, labels, ytitle, suffix="", setlogy=False): with preserve_current_style(): # Draw each resolution (with fit) xtitle = "" if 'Jet' in self.online_title: xtitle = "Jet #it{p}_{T} (GeV)" if 'HT' in self.online_title: xtitle = "#it{H}_{T} (GeV)" if 'MET' in self.online_title: xtitle = "#it{E}_{T}^{miss} (GeV)" canvas = draw(hists, draw_args={ "xtitle": xtitle, "ytitle": ytitle, "logy": setlogy, "ylimits": (0.1, 50000) }) if fits: for fit, hist in zip(fits, hists): fit["asymmetric"].linecolor = hist.GetLineColor() fit["asymmetric"].Draw("same") # Add labels label_canvas() # Add a legend legend = Legend(len(hists), header=self.legend_title, topmargin=0.35, rightmargin=0.2, leftmargin=0.8, entryheight=0.028, textsize=0.03) for hist, label in zip(hists, labels): legend.AddEntry(hist, label) legend.SetBorderSize(0) legend.Draw() # Save canvas to file name = self.filename_format.format(pileup="all") self.save_canvas(canvas, name + suffix)
def draw_curve_7(_func, name, title, ylow, yhigh): """ Draw 7TeV trigger efficiency curves """ graphs = [] for (trigger, color) in triggers: tool = ROOT.TauTriggerCorrections( os.path.join(base, 'triggerSF_%s.root' % trigger)) func = getattr(tool, _func) eff = map(lambda x: func(x, 0), pt) eff_low = map(lambda x: func(x, -1), pt) eff_high = map(lambda x: func(x, 1), pt) graph = Graph(len(pt), name=trigger) for i, (p, e, e_low, e_high) in enumerate(zip(pt, eff, eff_low, eff_high)): graph.SetPoint(i, p / 1000, e) graph.SetPointError(i, 0.4, 0.4, e - e_low, e_high - e) graph.linecolor = color graph.linewidth = 2 graph.fillstyle = '/' graph.fillcolor = color graphs.append(graph) c = Canvas() leg = Legend(len(graphs), pad=c, topmargin=0.4, leftmargin=0.3, textsize=25, margin=0.2) for i, g in enumerate(graphs): if i == 0: g.Draw('3AC') g.xaxis.title = '#font[52]{p}_{T} [GeV]' g.xaxis.SetLimits(20, 100) g.yaxis.SetLimits(ylow, yhigh) g.yaxis.SetRangeUser(ylow, yhigh) g.yaxis.title = title else: g.Draw('3C SAME') leg.AddEntry(g, g.name, 'L') leg.Draw() lines = [] for thresh in (25, 35): line = Line(thresh, ylow, thresh, yhigh) line.linestyle = 'dashed' line.linewidth = 2 line.Draw() lines.append(line) c.SaveAs('trigger_{0}.png'.format(name)) c.SaveAs('trigger_{0}.eps'.format(name))
def __make_overlay(self, hists, fits, labels, ytitle, suffix=""): with preserve_current_style(): # Draw each resolution (with fit) # TODO: this feels like it does not belong here for hist in hists: hist.GetYaxis().SetRangeUser(0, 0.1) hist.GetYaxis().SetTitleOffset(1.4) xtitle = self.resolution_method.label.format( on=self.online_title, off=self.offline_title) canvas = draw(hists, draw_args={ "xtitle": xtitle, "ytitle": ytitle }) if fits: for fit, hist in zip(fits, hists): fit["asymmetric"].linecolor = hist.GetLineColor() fit["asymmetric"].Draw("same") # Add labels label_canvas() # Add a legend legend = Legend( len(hists), header=self.legend_title, topmargin=0.35, rightmargin=0.3, leftmargin=0.7, textsize=0.03, entryheight=0.03, ) for hist, label in zip(hists, labels): legend.AddEntry(hist, label) legend.SetBorderSize(0) legend.Draw() ymax = 1.2 * max([hist.GetMaximum() for hist in hists]) line = ROOT.TLine(0., 0., 0., ymax) line.SetLineColor(15) # Save canvas to file name = self.filename_format.format(pileup="all") self.save_canvas(canvas, name + suffix)
def plot_distributions(input_file, distribution_plots): with root_open(input_file) as file: for name,histo_configs in distribution_plots.items(): canvas = Canvas(700,700) legend = Legend(len(histo_configs), leftmargin=0.4, margin=0.3) histograms = [] for histo_config in histo_configs: histogram = file.Get(histo_config.name) if len(histo_config.range)==2: histogram.SetAxisRange(histo_config.range[0], histo_config.range[1], 'X') histogram.color = histo_config.color histogram.markerstyle = histo_config.marker legend.AddEntry(histogram, label=histo_config.legend, style='ep') histograms.append(histogram) xmin, xmax, ymin, ymax = get_limits(histograms, logy=False) option = '' for histogram in histograms: histogram.SetAxisRange(ymin,ymax,'Y') histogram.Draw(option) option += ' same' legend.Draw() canvas.Print('plots/{}.png'.format(name))
# loop over all histograms, set their styles, split them up, scale if need for hist in hists: group = groups.get(hist.title) hist_styles = group.get('styles', {}) # auto loop through colors and add color if not set if not any('color' in k for k in hist_styles.keys()): hist_styles['color'] = hist_styles.get('color', next(default_colors)) # decorate it hist.decorate(**hist_styles) # set axis get_axis(hist, 'x').SetNdivisions(canvasConfigs.get('ndivisions', 1), canvasConfigs.get('ndivisions opt', True)) # add each hist to the legend legend.AddEntry(hist)#, style=group.get('legendstyle', 'F')) # rebin? rebin = plots_path.get('rebin', plots_config.get('rebin', None)) if rebin is not None: hist.rebin(rebin) # exclusion, so we don't need to plot it if hist.title in plots_path.get('exclude', []): continue if group.get('stack it', False): # overwrite with solid when stacking hist.fillstyle = 'solid' stackHists.append(hist) else: soloHists.append(hist)
fit_data = FitData(h_data, templates, fit_boundaries=(0, h_data.nbins())) fit_collection = FitDataCollection() fit_collection.add(fit_data) minuit_fitter = Minuit(fit_collection, method='logLikelihood', verbose=True) minuit_fitter.fit() results = minuit_fitter.readResults() c.cd(2) ymax = h_data.GetBinContent(h_data.GetMaximumBin()) * 1.1 h_data.GetYaxis().SetRangeUser(0, ymax) h_data.Draw('PE') leg = Legend(nTemplates + 2) leg.AddEntry(h_data, style='LEP') h_tSumAfter = 0 print '----> Target \t Fit Result' if useT1: h_t1After = h_t1.Clone() h_t1After.Scale(results['t1'][0] / h_t1.Integral()) h_t1After.Draw('SAME HIST') h_tSumAfter += h_t1After leg.AddEntry(h_t1After, style='L') t1AfterCont = h_t1.Integral() * t1Scale * h_data.Integral() / ( h_t1.Integral() * t1Scale + h_t2.Integral() * t2Scale + h_t3.Integral() * t3Scale) print '%s : \t %.3g \t %.3g +/- %.3g' % ( t1Name, t1AfterCont, results['t1'][0], results['t1'][1]) scan1 = results['t1'][2]
def __make_overlay(self, pileup, threshold, hists, fits, labels, header): with preserve_current_style(): name = self.filename_format.format(pileup=pileup, threshold=threshold) # Draw each efficiency (with fit) draw_args = {"xtitle": self.offline_title, "ytitle": "Efficiency"} # TODO: special case should not be implemented here! if 'Jet' in name and 'HiRange' in name: draw_args['xlimits'] = [20, 2000] canvas = draw(hists, draw_args=draw_args) if len(fits) > 0: for fit, hist in zip(fits, hists): fit["asymmetric"].linecolor = hist.GetLineColor() fit["asymmetric"].Draw("same") # Add labels label_canvas() # Add a legend legend = Legend( len(hists), header=self.legend_title, topmargin=0.35, rightmargin=0.3, leftmargin=0.7, textsize=0.025, entryheight=0.028, ) for hist, label in zip(hists, labels): legend.AddEntry(hist, label) legend.SetBorderSize(0) legend.Draw() xmin = 0 xmax = self.x_max # TODO: also specialisation, needs removal if ("HT" in name): xmax = 800 xmin = 30 if ("MET" in name): xmin = 0 xmax = 400 if ("Jet" in name): xmin = 20 xmax = 400 if ("HiRange" in name): xmax = 2000 for val in [0.25, 0.5, 0.75, 0.95, 1.]: line = ROOT.TLine(xmin, val, xmax, val) line.SetLineStyle("dashed") line.SetLineColor(15) line.Draw() for val in range(100, xmax, 100): line = ROOT.TLine(val, 0., val, 1.) line.SetLineStyle("dashed") line.SetLineColor(15) line.Draw() # Save canvas to file self.save_canvas(canvas, name)
# h_.fit('pol1') # fitfunc = h_.GetFunction('pol1') # offset, slope = fitfunc.GetParameter(0), fitfunc.GetParameter(1) # fitfuncs.append(fitfunc) for i, h_ in enumerate(todraw): h_.color = COLORS[i] draw(todraw) leg = Legend(3, pad=canvas, margin=0.25, leftmargin=0.45, topmargin=0.02, entrysep=0.01, entryheight=0.02, textsize=12) leg.AddEntry(ratios[0.2][0], label='iso boundary=0.2') leg.AddEntry(ratios[0.3][0], label='iso boundary=0.3') leg.AddEntry(ratios[0.4][0], label='iso boundary=0.4') leg.Draw() title = TitleAsLatex('[4#mu VR] Ratio of maxiso <high> to maxiso <low>') title.Draw() canvas.SaveAs('{}/ch4mu_vr_ratio_maxiso.pdf'.format(outdir, )) canvas.clear() ratios = {} ratios[0.7] = create_ratioplot(h, xbound_bin=14) ratios[0.8] = create_ratioplot(h, xbound_bin=16) ratios[0.9] = create_ratioplot(h, xbound_bin=18) todraw = [ratios[0.7][1], ratios[0.8][1], ratios[0.9][1]] for i, h_ in enumerate(todraw): h_.color = COLORS[i]
os.makedirs(args.output) plots_written = [] with io.open(layout_filename, 'r') as layout_file: log.info("Plotting all histograms") for path, subdirs, histos in layout_file.walk(class_pattern='TH1F'): for histo in histos: log.info("Plotting %s in %s", histo, path) data_histo = data_view.Get(os.path.join(path, histo)) mc_histo = mc_view.Get(os.path.join(path, histo)) log.info("Data histo has %f entries", data_histo.Integral()) mc_histo.Draw() data_histo.Draw('same') legend = Legend(7, leftmargin=0.5) legend.AddEntry(mc_histo) legend.AddEntry(data_histo) legend.SetBorderSize(0) legend.Draw() mc_histo.SetMaximum( 1.2 * max(mc_histo.GetMaximum(), data_histo.GetMaximum())) plot_filename = os.path.join( args.output, path.replace('/', '_') + '_' + histo + '.pdf') plots_written.append(plot_filename) canvas.SaveAs(plot_filename) with open(os.path.join(args.output, 'plot_list.txt'), 'w') as plot_list: for plot_filename in plots_written: plot_list.write(plot_filename + '\n')
# plot with ROOT canvas = Canvas(width=700, height=500) # try setting logy=True and uncommenting the two lines below xmin, xmax, ymin, ymax = get_limits([stack, h3], logy=False) stack.SetMaximum(ymax) #stack.SetMinimum(ymin) #canvas.SetLogy() stack.Draw('HIST E1 X0') h3.Draw('SAME E1 X0') stack.xaxis.SetTitle('Mass') stack.yaxis.SetTitle('Events') # set the number of expected legend entries legend = Legend(3, leftmargin=0.45, margin=0.3) legend.AddEntry(h1, style='F') legend.AddEntry(h2, style='F') legend.AddEntry(h3, style='LEP') legend.Draw() label = ROOT.TText(0.3, 0.8, 'ROOT') label.SetTextFont(43) label.SetTextSize(25) label.SetNDC() label.Draw() canvas.Modified() canvas.Update() # plot with matplotlib set_style('ATLAS', mpl=True) fig = plt.figure(figsize=(7, 5), dpi=100) axes = plt.axes()
if bg_bool == "Plot": background = root_open(backgroundMC_location + "/" + rootfile) compressed = background.CompressedAnalysis print compressed histname = "hist" + rootfile histogram = histname + "(" + nbins + "," + xmin + "," + xmax + ")" histname = compressed.Draw(variable + ">>" + histogram, selection=weight * total, drawstyle='hist', fillstyle='solid', linecolor='black', fillcolor=color) print histname print background_name legend.AddEntry(histname, label=background_name, style='F') #was label=background_name stack.Add(histname) #=================== DATA SAMPLES ====================================# objects = [] dataobjects = [] for (datafilename, data_weight, data_bool) in zip(data_list, data_weight_list, data_bool_list): print datafilename, data_weight, data_bool if data_bool == "Plot": print "datafilename: ", datafilename data = root_open(data_location + "/" + datafilename) treesSR = data.CompressedAnalysis datacut = total if data_weight != "1":
x_max = gr.GetXaxis().GetXmax() y_min = gr.GetXaxis().GetXmin() y_max = gr.GetXaxis().GetXmax() gr.Draw('a3') gr.Draw('Xp same') # a straight line y=x to be a reference f_dia = ROOT.TF1("f_dia", "x", h1.GetXaxis().GetXmin(), h1.GetXaxis().GetXmax()) f_dia.SetLineColor(9) f_dia.SetLineWidth(2) f_dia.SetLineStyle(2) f_dia.Draw("same") leg = Legend(3, pad=pad, leftmargin=0.45, topmargin=0.45, rightmargin=0.05, textsize=20) leg.AddEntry(gr, "QQ points", "p") leg.AddEntry(gr, "68% CL band", "f") leg.AddEntry(f_dia, "Diagonal line", "l") leg.Draw() c.Modified() c.Update() c.Draw() wait()
def plot(self): evaluator = Evaluator(self.model, self.transformation, self.features) makedirs(self.plt_dir, exist_ok=True) makedirs('/'.join([self.plt_dir, 'lin']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'log']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'lin', 'png']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'lin', 'root']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'log', 'png']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'log', 'root']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'lnt_region', 'lin']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'lnt_region', 'log']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'lnt_region', 'lin', 'png']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'lnt_region', 'lin', 'root']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'lnt_region', 'log', 'png']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'lnt_region', 'log', 'root']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'shapes', 'lin']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'shapes', 'log']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'shapes', 'lin', 'png']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'shapes', 'lin', 'root']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'shapes', 'log', 'png']), exist_ok=True) makedirs('/'.join([self.plt_dir, 'shapes', 'log', 'root']), exist_ok=True) # NN evaluator print('============> starting reading the trees') print('Plots will be stored in: ', self.plt_dir) now = time() signal = [] if self.process_signals: signal = self.get_signal_samples(self.channel, self.base_dir, self.post_fix, self.selection_data, mini=self.mini_signals) else: signal = [] data = self.get_data_samples(self.channel, self.base_dir, self.post_fix, self.selection_data) mc = self.get_mc_samples(self.channel, self.base_dir, self.post_fix, self.selection_mc) print('============> it took %.2f seconds' % (time() - now)) # evaluate FR for isample in (mc + data): #+signal): isample.df['fr'] = evaluator.evaluate(isample.df) # already corrected, ready to be applied in lnt-not-tight isample.df['fr_corr'] = isample.df['fr'] / (1. - isample.df['fr']) # apply an extra selection to the pandas dataframes if len(self.pandas_selection): for isample in (mc + data + signal): isample.df = isample.df.query(self.pandas_selection) # split the dataframe in tight and lnt-not-tight (called simply lnt for short) print('============> splitting dataframe in tight and loose not tight') for isample in (mc + data + signal): isample.df_tight = isample.df.query(self.selection_tight) if isample not in signal: isample.df_lnt = isample.df.query(self.selection_lnt) # free some mem del isample.df gc.collect() print('============> ... done') # sort depending on their position in the stack mc.sort(key=lambda x: x.position_in_stack) # now we plot self.create_canvas(self.do_ratio) for ivar in variables: variable, bins, label, xlabel, ylabel, extra_sel = ivar.var, ivar.bins, ivar.label, ivar.xlabel, ivar.ylabel, ivar.extra_selection print('plotting', label) ###################################################################################### # plot MC stacks, in tight and lnt ###################################################################################### stack_prompt = [] stack_nonprompt = [] stack_nonprompt_control = [] for imc in mc: if extra_sel: mc_df_tight = imc.df_tight.query(extra_sel) mc_df_lnt = imc.df_lnt.query(extra_sel) else: mc_df_tight = imc.df_tight mc_df_lnt = imc.df_lnt histo_tight = Hist(bins, title=imc.label, markersize=0, legendstyle='F', name=imc.datacard_name + '#' + label + '#t') weights = self.total_weight_calculator( mc_df_tight, ['weight'] + imc.extra_signal_weights, [self.lumi, imc.lumi_scaling]) histo_tight.fill_array(mc_df_tight[variable], weights=weights * self.relaxed_mc_scaling) histo_tight.fillstyle = 'solid' histo_tight.fillcolor = 'steelblue' if self.data_driven else imc.colour histo_tight.linewidth = 0 stack_prompt.append(histo_tight) # optionally remove the MC subtraction in loose-not-tight # may help if MC stats is terrible (and it often is) if self.data_driven: if self.mc_subtraction: histo_lnt = Hist(bins, title=imc.label, markersize=0, legendstyle='F', name=imc.datacard_name + '#' + label + '#lnt') weights = self.total_weight_calculator( mc_df_lnt, ['weight', 'fr_corr'] + imc.extra_signal_weights, [-1., self.lumi, imc.lumi_scaling]) histo_lnt.fill_array(mc_df_lnt[variable], weights=weights * self.relaxed_mc_scaling) histo_lnt.fillstyle = 'solid' histo_lnt.fillcolor = 'skyblue' if self.data_driven else imc.colour histo_lnt.linewidth = 0 stack_nonprompt.append(histo_lnt) histo_lnt_control = Hist(bins, title=imc.label, markersize=0, legendstyle='F', name=imc.datacard_name + '#' + label + '#lntcontrol') weights_control = self.total_weight_calculator( mc_df_lnt, ['weight'] + imc.extra_signal_weights, [self.lumi, imc.lumi_scaling]) histo_lnt_control.fill_array(mc_df_lnt[variable], weights=weights_control * self.relaxed_mc_scaling) histo_lnt_control.fillstyle = 'solid' histo_lnt_control.fillcolor = imc.colour histo_lnt_control.linewidth = 0 # print(histo_lnt_control) # print(histo_lnt_control.fillcolor) # print(imc.name, imc.colour) # print(histo_lnt_control.integral()) stack_nonprompt_control.append(histo_lnt_control) # merge different samples together (add the histograms) # prepare two temporary containers for the post-grouping histograms stack_prompt_tmp = [] stack_nonprompt_tmp = [] stack_nonprompt_control_tmp = [] for ini, fin in [(stack_prompt, stack_prompt_tmp), (stack_nonprompt, stack_nonprompt_tmp), (stack_nonprompt_control, stack_nonprompt_control_tmp)]: for k, v in groups.items(): grouped = [] for ihist in ini: if ihist.name.split('#')[0] in v: grouped.append(ihist) elif ihist.name.split('#')[0] not in togroup: fin.append(ihist) if len(grouped): group = sum(grouped) group.title = k group.name = '#'.join([k] + ihist.name.split('#')[1:]) group.fillstyle = grouped[0].fillstyle group.fillcolor = grouped[0].fillcolor group.linewidth = grouped[0].linewidth fin.append(group) stack_prompt = stack_prompt_tmp stack_nonprompt = stack_nonprompt_tmp stack_nonprompt_control = stack_nonprompt_control_tmp ###################################################################################### # plot the signals ###################################################################################### all_signals = [] signals_to_plot = [] for isig in signal: if variable not in self.datacards: if not isig.toplot: continue if variable == 'fr' or variable == 'fr_corr': continue if extra_sel: isig_df_tight = isig.df_tight.query(extra_sel) else: isig_df_tight = isig.df_tight histo_tight = Hist( bins, title=isig.label, markersize=0, legendstyle='L', name=isig.datacard_name + '#' + label ) # the "#" thing is a trick to give hists unique name, else ROOT complains weights = self.total_weight_calculator( isig_df_tight, ['weight'] + isig.extra_signal_weights, [self.lumi, isig.lumi_scaling]) histo_tight.fill_array(isig_df_tight[variable], weights=weights) histo_tight.color = isig.colour histo_tight.fillstyle = 'hollow' histo_tight.linewidth = 2 histo_tight.linestyle = 'dashed' histo_tight.drawstyle = 'HIST' all_signals.append(histo_tight) if isig.toplot: signals_to_plot.append(histo_tight) ###################################################################################### # plot the data ###################################################################################### data_prompt = [] data_nonprompt = [] data_nonprompt_control = [] for idata in data: if extra_sel: idata_df_tight = idata.df_tight.query(extra_sel) idata_df_lnt = idata.df_lnt.query(extra_sel) else: idata_df_tight = idata.df_tight idata_df_lnt = idata.df_lnt histo_tight = Hist(bins, title=idata.label, markersize=1, legendstyle='LEP') histo_tight.fill_array(idata_df_tight[variable]) data_prompt.append(histo_tight) if self.data_driven: histo_lnt = Hist(bins, title=idata.label, markersize=0, legendstyle='F') histo_lnt.fill_array(idata_df_lnt[variable], weights=idata_df_lnt.fr_corr) histo_lnt.fillstyle = 'solid' histo_lnt.fillcolor = 'skyblue' histo_lnt.linewidth = 0 histo_lnt_control = Hist(bins, title=idata.label, markersize=1, legendstyle='LEP') histo_lnt_control.fill_array(idata_df_lnt[variable]) data_nonprompt.append(histo_lnt) data_nonprompt_control.append(histo_lnt_control) if self.data_driven: # put the prompt backgrounds together all_exp_prompt = sum(stack_prompt) all_exp_prompt.title = 'prompt' # put the nonprompt backgrounds together all_exp_nonprompt = sum(stack_nonprompt + data_nonprompt) all_exp_nonprompt.fillstyle = 'solid' all_exp_nonprompt.fillcolor = 'skyblue' all_exp_nonprompt.linewidth = 0 all_exp_nonprompt.title = 'nonprompt' # create the stacks stack = HistStack([all_exp_prompt, all_exp_nonprompt], drawstyle='HIST', title='') stack_control = HistStack(stack_nonprompt_control, drawstyle='HIST', title='') else: stack = HistStack(stack_prompt, drawstyle='HIST', title='') # stat uncertainty hist_error = stack.sum #sum([all_exp_prompt, all_exp_nonprompt]) hist_error.drawstyle = 'E2' hist_error.fillstyle = '/' hist_error.color = 'gray' hist_error.title = 'stat. unc.' hist_error.legendstyle = 'F' if self.data_driven: hist_error_control = stack_control.sum hist_error_control.drawstyle = 'E2' hist_error_control.fillstyle = '/' hist_error_control.color = 'gray' hist_error_control.title = 'stat. unc.' hist_error_control.legendstyle = 'F' # put the data together all_obs_prompt = sum(data_prompt) all_obs_prompt.title = 'observed' if self.data_driven: all_obs_nonprompt_control = sum(data_nonprompt_control) all_obs_nonprompt_control.title = 'observed' all_obs_nonprompt_control.drawstyle = 'EP' # prepare the legend print(signals_to_plot) for jj in signals_to_plot: print(jj.name, jj.integral()) if len(signals_to_plot): legend = Legend([all_obs_prompt, stack, hist_error], pad=self.main_pad, leftmargin=0., rightmargin=0., topmargin=0., textfont=42, textsize=0.025, entrysep=0.01, entryheight=0.04) legend_signals = Legend(signals_to_plot, pad=self.main_pad, leftmargin=0., rightmargin=0., topmargin=0., textfont=42, textsize=0.025, entrysep=0.01, entryheight=0.04) legend_signals.SetBorderSize(0) legend_signals.x1 = 0.42 legend_signals.y1 = 0.74 legend_signals.x2 = 0.88 legend_signals.y2 = 0.90 legend_signals.SetFillColor(0) legend.SetBorderSize(0) legend.x1 = 0.2 legend.y1 = 0.74 legend.x2 = 0.45 legend.y2 = 0.90 legend.SetFillColor(0) else: legend = Legend([all_obs_prompt, stack, hist_error], pad=self.main_pad, leftmargin=0., rightmargin=0., topmargin=0., textfont=42, textsize=0.03, entrysep=0.01, entryheight=0.04) legend.SetBorderSize(0) legend.x1 = 0.55 legend.y1 = 0.74 legend.x2 = 0.88 legend.y2 = 0.90 legend.SetFillColor(0) # plot with ROOT, linear and log scale for islogy in [False, True]: things_to_plot = [stack, hist_error] if not self.blinded: things_to_plot.append(all_obs_prompt) # plot signals, as an option if self.plot_signals: things_to_plot += signals_to_plot # set the y axis range # FIXME! setting it by hand to each object as it doesn't work if passed to draw if islogy: yaxis_max = 40. * max( [ithing.max() for ithing in things_to_plot]) else: yaxis_max = 1.65 * max( [ithing.max() for ithing in things_to_plot]) if islogy: yaxis_min = 0.01 else: yaxis_min = 0. for ithing in things_to_plot: ithing.SetMaximum(yaxis_max) draw(things_to_plot, xtitle=xlabel, ytitle=ylabel, pad=self.main_pad, logy=islogy) # expectation uncertainty in the ratio pad ratio_exp_error = Hist(bins) ratio_data = Hist(bins) for ibin in hist_error.bins_range(): ratio_exp_error.set_bin_content(ibin, 1.) ratio_exp_error.set_bin_error( ibin, hist_error.get_bin_error(ibin) / hist_error.get_bin_content(ibin) if hist_error.get_bin_content(ibin) != 0. else 0.) ratio_data.set_bin_content( ibin, all_obs_prompt.get_bin_content(ibin) / hist_error.get_bin_content(ibin) if hist_error.get_bin_content(ibin) != 0. else 0.) ratio_data.set_bin_error( ibin, all_obs_prompt.get_bin_error(ibin) / hist_error.get_bin_content(ibin) if hist_error.get_bin_content(ibin) != 0. else 0.) ratio_data.drawstyle = 'EP' ratio_data.title = '' ratio_exp_error.drawstyle = 'E2' ratio_exp_error.markersize = 0 ratio_exp_error.title = '' ratio_exp_error.fillstyle = '/' ratio_exp_error.color = 'gray' for ithing in [ratio_data, ratio_exp_error]: ithing.xaxis.set_label_size( ithing.xaxis.get_label_size() * 3. ) # the scale should match that of the main/ratio pad size ratio ithing.yaxis.set_label_size( ithing.yaxis.get_label_size() * 3. ) # the scale should match that of the main/ratio pad size ratio ithing.xaxis.set_title_size( ithing.xaxis.get_title_size() * 3. ) # the scale should match that of the main/ratio pad size ratio ithing.yaxis.set_title_size( ithing.yaxis.get_title_size() * 3. ) # the scale should match that of the main/ratio pad size ratio ithing.yaxis.set_ndivisions(405) ithing.yaxis.set_title_offset(0.4) things_to_plot = [ratio_exp_error] if not self.blinded: things_to_plot.append(ratio_data) draw(things_to_plot, xtitle=xlabel, ytitle='obs/exp', pad=self.ratio_pad, logy=False, ylimits=(0.5, 1.5)) line = ROOT.TLine(min(bins), 1., max(bins), 1.) line.SetLineColor(ROOT.kBlack) line.SetLineWidth(1) self.ratio_pad.cd() line.Draw('same') # chi2_score_text = '\chi^{2}/NDF = %.1f' %(all_obs_prompt.Chi2Test(hist_error, 'UW CHI2/NDF')) chi2_score_text = 'p-value = %.2f' % (all_obs_prompt.Chi2Test( hist_error, 'UW')) chi2_score = ROOT.TLatex(0.7, 0.81, chi2_score_text) chi2_score.SetTextFont(43) chi2_score.SetTextSize(15) chi2_score.SetNDC() chi2_score.Draw('same') self.canvas.cd() # FIXME! add SS and OS channels if self.full_channel == 'mmm': channel = '\mu\mu\mu' elif self.full_channel == 'eee': channel = 'eee' elif self.full_channel == 'mem_os': channel = '\mu^{\pm}\mu^{\mp}e' elif self.full_channel == 'mem_ss': channel = '\mu^{\pm}\mu^{\pm}e' elif self.full_channel == 'eem_os': channel = 'e^{\pm}e^{\mp}\mu' elif self.full_channel == 'eem_ss': channel = 'e^{\pm}e^{\pm}\mu' else: assert False, 'ERROR: Channel not valid.' finalstate = ROOT.TLatex(0.68, 0.68, channel) finalstate.SetTextFont(43) finalstate.SetTextSize(25) finalstate.SetNDC() finalstate.Draw('same') self.canvas.cd() # remove old legend for iprim in self.canvas.primitives: if isinstance(iprim, Legend): self.canvas.primitives.remove(iprim) legend.Draw('same') if self.plot_signals: legend_signals.Draw('same') CMS_lumi(self.main_pad, 4, 0, lumi_13TeV="%d, L = %.1f fb^{-1}" % (self.year, self.lumi / 1000.)) self.canvas.Modified() self.canvas.Update() for iformat in ['pdf', 'png', 'root']: self.canvas.SaveAs('/'.join([ self.plt_dir, 'log' if islogy else 'lin', iformat if iformat != 'pdf' else '', '%s%s.%s' % (label, '_log' if islogy else '_lin', iformat) ])) # plot distributions in loose not tight # check MC contamination there if self.data_driven and variable not in ['fr', 'fr_corr']: things_to_plot = [ stack_control, hist_error_control, all_obs_nonprompt_control ] # set the y axis range # FIXME! setting it by hand to each object as it doesn't work if passed to draw if islogy: yaxis_max = 40. * max( [ithing.max() for ithing in things_to_plot]) else: yaxis_max = 1.65 * max( [ithing.max() for ithing in things_to_plot]) if islogy: yaxis_min = 0.01 else: yaxis_min = 0. for ithing in things_to_plot: ithing.SetMaximum(yaxis_max) ithing.SetMinimum(yaxis_min) draw(things_to_plot, xtitle=xlabel, ytitle=ylabel, pad=self.main_pad, logy=islogy, ylimits=(yaxis_min, yaxis_max)) new_legend = Legend( stack_control.hists + [hist_error_control, all_obs_nonprompt_control], pad=self.main_pad, leftmargin=0., rightmargin=0., topmargin=0., textfont=42, textsize=0.03, entrysep=0.01, entryheight=0.04) new_legend.SetBorderSize(0) new_legend.x1 = 0.55 new_legend.y1 = 0.71 new_legend.x2 = 0.88 new_legend.y2 = 0.90 new_legend.SetFillColor(0) # divide MC to subtract by data stack_nonprompt_control_scaled_list = [] for ihist in stack_control.hists: new_hist = copy(ihist) for ibin in new_hist.bins_range(): new_hist.SetBinContent( ibin, np.nan_to_num( np.divide( new_hist.GetBinContent(ibin), all_obs_nonprompt_control. GetBinContent(ibin)))) new_hist.SetBinError( ibin, np.nan_to_num( np.divide( new_hist.GetBinError(ibin), all_obs_nonprompt_control. GetBinContent(ibin)))) stack_nonprompt_control_scaled_list.append(new_hist) stack_control_scaled = HistStack( stack_nonprompt_control_scaled_list, drawstyle='HIST', title='') stack_control_scaled_err = stack_control_scaled.sum stack_control_scaled_err.drawstyle = 'E2' stack_control_scaled_err.fillstyle = '/' stack_control_scaled_err.color = 'gray' stack_control_scaled_err.title = 'stat. unc.' stack_control_scaled_err.legendstyle = 'F' draw([stack_control_scaled, stack_control_scaled_err], xtitle=xlabel, ytitle='MC/data', pad=self.ratio_pad, logy=False) stack_control_scaled.xaxis.set_label_size( stack_control_scaled.xaxis.get_label_size() * 3. ) # the scale should match that of the main/ratio pad size ratio stack_control_scaled.yaxis.set_label_size( stack_control_scaled.yaxis.get_label_size() * 3. ) # the scale should match that of the main/ratio pad size ratio stack_control_scaled.xaxis.set_title_size( stack_control_scaled.xaxis.get_title_size() * 3. ) # the scale should match that of the main/ratio pad size ratio stack_control_scaled.yaxis.set_title_size( stack_control_scaled.yaxis.get_title_size() * 3. ) # the scale should match that of the main/ratio pad size ratio stack_control_scaled.yaxis.set_ndivisions(405) stack_control_scaled.yaxis.set_title_offset(0.4) stack_control_scaled.SetMinimum(0.) stack_control_scaled.SetMaximum(1.5) CMS_lumi(self.main_pad, 4, 0, lumi_13TeV="%d, L = %.1f fb^{-1}" % (self.year, self.lumi / 1000.)) self.canvas.cd() # remove old legend for iprim in self.canvas.primitives: if isinstance(iprim, Legend): self.canvas.primitives.remove(iprim) # draw new legend new_legend.Draw('same') self.canvas.Modified() self.canvas.Update() for iformat in ['pdf', 'png', 'root']: self.canvas.SaveAs('/'.join([ self.plt_dir, 'lnt_region', 'log' if islogy else 'lin', iformat if iformat != 'pdf' else '', '%s%s.%s' % (label, '_log' if islogy else '_lin', iformat) ])) # compare shapes in tight and loose not tight # data in tight all_obs_prompt_norm = copy(all_obs_prompt) if all_obs_prompt_norm.integral() != 0: all_obs_prompt_norm.Scale( np.nan_to_num( np.divide(1., all_obs_prompt_norm.integral()))) #import pdb; pdb.set_trace() all_obs_prompt_norm.drawstyle = 'hist e' all_obs_prompt_norm.linecolor = 'black' all_obs_prompt_norm.markersize = 0 all_obs_prompt_norm.legendstyle = 'LE' all_obs_prompt_norm.title = '' all_obs_prompt_norm.label = 'data - tight' # data MC subtracted in loose all_obs_prompt_mc_sub_norm = copy(all_obs_prompt) all_obs_prompt_mc_sub_norm.add(all_exp_prompt, -1) all_obs_prompt_mc_sub_norm.Scale( np.nan_to_num( np.divide(1., all_obs_prompt_mc_sub_norm.integral()))) all_obs_prompt_mc_sub_norm.drawstyle = 'hist e' all_obs_prompt_mc_sub_norm.linecolor = 'green' all_obs_prompt_mc_sub_norm.markersize = 0 all_obs_prompt_mc_sub_norm.legendstyle = 'LE' all_obs_prompt_mc_sub_norm.title = '' all_obs_prompt_mc_sub_norm.label = '(data-MC) - tight' # data in loose all_obs_nonprompt_control_norm = copy( all_obs_nonprompt_control) all_obs_nonprompt_control_norm.Scale( np.nan_to_num( np.divide( 1., all_obs_nonprompt_control_norm.integral()))) all_obs_nonprompt_control_norm.drawstyle = 'hist e' all_obs_nonprompt_control_norm.linecolor = 'red' all_obs_nonprompt_control_norm.markersize = 0 all_obs_nonprompt_control_norm.legendstyle = 'LE' all_obs_nonprompt_control_norm.title = '' all_obs_nonprompt_control_norm.label = 'data - l-n-t' # data MC subtracted in loose all_obs_nonprompt_control_mc_sub_norm = copy( all_obs_nonprompt_control) all_obs_nonprompt_control_mc_sub_norm.add( stack_control.sum, -1) all_obs_nonprompt_control_mc_sub_norm.Scale( np.nan_to_num( np.divide( 1., all_obs_nonprompt_control_mc_sub_norm.integral( )))) all_obs_nonprompt_control_mc_sub_norm.drawstyle = 'hist e' all_obs_nonprompt_control_mc_sub_norm.linecolor = 'blue' all_obs_nonprompt_control_mc_sub_norm.markersize = 0 all_obs_nonprompt_control_mc_sub_norm.legendstyle = 'LE' all_obs_nonprompt_control_mc_sub_norm.title = '' all_obs_nonprompt_control_mc_sub_norm.label = '(data-MC) - l-n-t' things_to_plot = [ all_obs_prompt_norm, all_obs_prompt_mc_sub_norm, all_obs_nonprompt_control_norm, all_obs_nonprompt_control_mc_sub_norm, ] yaxis_max = max([ii.GetMaximum() for ii in things_to_plot]) draw(things_to_plot, xtitle=xlabel, ytitle=ylabel, pad=self.main_pad, logy=islogy, ylimits=(yaxis_min, 1.55 * yaxis_max)) self.canvas.cd() # remove old legend for iprim in self.canvas.primitives: if isinstance(iprim, Legend): self.canvas.primitives.remove(iprim) shape_legend = Legend([], pad=self.main_pad, leftmargin=0., rightmargin=0., topmargin=0., textfont=42, textsize=0.03, entrysep=0.01, entryheight=0.04) shape_legend.AddEntry(all_obs_prompt_norm, all_obs_prompt_norm.label, all_obs_prompt_norm.legendstyle) shape_legend.AddEntry( all_obs_prompt_mc_sub_norm, all_obs_prompt_mc_sub_norm.label, all_obs_prompt_mc_sub_norm.legendstyle) shape_legend.AddEntry( all_obs_nonprompt_control_norm, all_obs_nonprompt_control_norm.label, all_obs_nonprompt_control_norm.legendstyle) shape_legend.AddEntry( all_obs_nonprompt_control_mc_sub_norm, all_obs_nonprompt_control_mc_sub_norm.label, all_obs_nonprompt_control_mc_sub_norm.legendstyle) shape_legend.SetBorderSize(0) shape_legend.x1 = 0.50 shape_legend.y1 = 0.71 shape_legend.x2 = 0.88 shape_legend.y2 = 0.90 shape_legend.SetFillColor(0) shape_legend.Draw('same') # plot ratios all_obs_prompt_norm_ratio = copy(all_obs_prompt_norm) all_obs_prompt_mc_sub_norm_ratio = copy( all_obs_prompt_mc_sub_norm) all_obs_nonprompt_control_norm_ratio = copy( all_obs_nonprompt_control_norm) all_obs_nonprompt_control_mc_sub_norm_ratio = copy( all_obs_nonprompt_control_mc_sub_norm) all_obs_prompt_norm_ratio.Divide( all_obs_prompt_mc_sub_norm_ratio) all_obs_nonprompt_control_norm_ratio.Divide( all_obs_prompt_mc_sub_norm_ratio) all_obs_nonprompt_control_mc_sub_norm_ratio.Divide( all_obs_prompt_mc_sub_norm_ratio) things_to_plot_ratio = [ all_obs_prompt_norm_ratio, all_obs_nonprompt_control_norm_ratio, all_obs_nonprompt_control_mc_sub_norm_ratio, ] for ithing in things_to_plot_ratio: ithing.xaxis.set_label_size( ithing.xaxis.get_label_size() * 3. ) # the scale should match that of the main/ratio pad size ratio ithing.yaxis.set_label_size( ithing.yaxis.get_label_size() * 3. ) # the scale should match that of the main/ratio pad size ratio ithing.xaxis.set_title_size( ithing.xaxis.get_title_size() * 3. ) # the scale should match that of the main/ratio pad size ratio ithing.yaxis.set_title_size( ithing.yaxis.get_title_size() * 3. ) # the scale should match that of the main/ratio pad size ratio ithing.yaxis.set_ndivisions(405) ithing.yaxis.set_title_offset(0.4) ithing.SetMinimum(0.) ithing.SetMaximum(2.) draw(things_to_plot_ratio, xtitle=xlabel, ytitle='1/(data-MC)_{tight}', pad=self.ratio_pad, logy=False, ylimits=(0., 2.)) self.ratio_pad.cd() line.Draw('same') CMS_lumi(self.main_pad, 4, 0, lumi_13TeV="%d, L = %.1f fb^{-1}" % (self.year, self.lumi / 1000.)) self.canvas.Modified() self.canvas.Update() for iformat in ['pdf', 'png', 'root']: self.canvas.SaveAs('/'.join([ self.plt_dir, 'shapes', 'log' if islogy else 'lin', iformat if iformat != 'pdf' else '', '%s%s.%s' % (label, '_log' if islogy else '_lin', iformat) ])) # save only the datacards you want, don't flood everything if len(self.datacards) and label not in self.datacards: continue # FIXME! allow it to save datacards even for non data driven bkgs if self.data_driven: self.create_datacards(data=all_obs_prompt, bkgs={ 'prompt': all_exp_prompt, 'nonprompt': all_exp_nonprompt }, signals=all_signals, label=label)
for i, s in enumerate(samples): histName = '{}_{}__{}'.format(histType, chan, s) h = getattr(f, histName).Clone() # h.xaxis.SetRange(1, h.nbins()+1) h.title = s h.Scale(1. / h.Integral()) h.drawstyle = 'hist pmc plc' h.legendstyle = 'L' if s == 'data': h.fillstyle = '\\' h.color = 'salmon' h.drawstyle = 'hist' h.legendstyle = 'F' hs.append(h) legend.AddEntry(h) xmin, xmax, ymin, ymax = get_limits(hs) draw(hs, pad=c, ytitle='norm. counts/50', ylimits=(0, ymax)) legend.Draw() title = TitleAsLatex('[{}] {}'.format(chan.replace('mu', '#mu'), histType)) title.Draw() draw_labels('59.74 fb^{-1} (13 TeV)', cms_position='left', extra_text='work-in-progress') c.SaveAs('{}/{}_{}.pdf'.format(outdir, histType, chan)) c.Clear() f.Close()
1.) try: axislabel = axislabels[axislabel] except: axislabel = axislabel tmpratio.GetXaxis().SetTitle(axislabel) if plotWithROOT: pad1.cd() ROOT.ATLASLabel(0.2, 0.9, "Internal %s, %s" % (regionName, kindOfRegion)) legend = Legend(4, leftmargin=0.45, margin=0.35, topmargin=0.07) hists["DataMain"].SetTitle("Data 15+16 %s fb^{-1}" % lumiscale) legend.AddEntry(hists["DataMain"], style='ep') # sortedHistsToStack.reverse() for BG in reversed(sortedHistsToStack): BG.SetTitle(BG.GetTitle().replace("MassiveCB", "")) legend.AddEntry(BG, style='F') for signalsample in signalsamples: skip = 1 try: if any([ thissig in signalsample for thissig in plottedsignals[regionName] ]): skip = 0 except: skip = 1
dn.Reset() dn.fill_array(transform(dn_scores)) # Plot the nominal, up, and down scores canvas = Canvas() nominal.SetMaximum(max(dn) * 1.1) nominal.Draw() nominal.xaxis.SetTitle('BDT Score') nominal.yaxis.SetTitle('Events') up.Draw('same hist') dn.Draw('same hist') leg = Legend(3, pad=canvas, leftmargin=.5) leg.AddEntry(nominal, style='LEP') leg.AddEntry(up, style='L') leg.AddEntry(dn, style='L') leg.Draw() canvas.SaveAs('canvas_original.png') # Take the ratio of systematic / nominal ratio_up = up / nominal ratio_dn = dn / nominal ratio_canvas = Canvas() ratio_canvas.SetLogy() ratio_up.SetMinimum(0.001) ratio_up.Draw('hist') ratio_dn.Draw('same hist')
frame.SetMaximum(1) frame.SetMinimum(0) frame.axis().SetTitle("Number of vertices") frame.axis(2).SetTitle("Efficiency (w.r.t. reco. p_{T}>40 GeV)") canvas.SetLogy(False) canvas.SetLeftMargin(0.2) frame.Draw() l1_efficiency.Draw('pe same') uct_efficiency.Draw('pe same') uct_iso_efficiency.Draw('pe same') legend = Legend(3, topmargin=0.25, leftmargin=0.25) legend.AddEntry(l1_efficiency, 'lp', 'Current Tau44') legend.AddEntry(uct_efficiency, 'lp', 'Upgrade RlxTau25 Rel. Rate %0.2f' % (9488. / 9355)) legend.AddEntry(uct_iso_efficiency, 'lp', 'Upgrade IsoTau25 Rel. Rate %0.2f' % (6224. / 9355)) legend.SetBorderSize(0) legend.SetTextSize(0.03) legend.Draw() canvas.SaveAs("eff_vs_pu.png") canvas.SaveAs("eff_vs_pu.pdf") frame.Draw() l1_efficiency.Draw('pe same') uct_efficiency.Draw('pe same')
ljisotot.Add(psljiso) ljisotot.color = "#000000" for p in [pljiso, pproxyiso, psljiso, ljisotot]: p.markersize = 0.5 p.legendstyle = 'LEP' draw([pljiso, pproxyiso, psljiso, ljisotot], ) # ylimits=(3e-3,1), logy=True) leg = Legend(4, pad=canvas, topmargin=0.02, margin=0.2, entryheight=0.015, entrysep=0.01, textsize=10) leg.AddEntry(pproxyiso, label='proxy muon iso') leg.AddEntry(pljiso, label='lepton-jet iso (proxy events)') leg.AddEntry(psljiso, label='lepton-jet iso (signal events)') leg.AddEntry(ljisotot, label='lepton-jet iso (signal+proxy events)') leg.Draw() canvas.SaveAs('{}/ch4mu_isolationprofiles.pdf'.format(outdir)) canvas.clear() proxymusf = pljiso.Clone() proxymusf.Divide(pproxyiso) draw([proxymusf], ylimits=(0, 2)) leg = Legend([proxymusf], pad=canvas, topmargin=0.02, margin=0.2, entryheight=0.015,