def plot_hists_dict(hist_dict, setNames=True, **kwargs):
"""
Draws the contents of a dictionary of hists. Styling will be done
automatically. Any additional kwargs are passed to the plot_hists and legend
methods.
Args:
hist_dict: a str, Hist dictionary of the histograms to be drawn.
Keywords:
setNames: a bool to specify whether the keys of the dict will be used as
titles in the legend.
Returns: a handle to the new canvas
"""
items = hist_dict.items()
for hn, h in items:
h.SetName(hn)
if setNames:
h.SetTitle(hn)
hists = [x[1] for x in items]
names = [x[0] for x in items]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, **kwargs)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.LEGEND = leg
return canv
def plot_data_mc(hists_mc, hist_data, name):
canv = ROOT.TCanvas()
p1 = ROOT.TPad("p1", "p1", 0, 0.3, 1, 1)
p1.Draw()
p1.SetTicks(1, 1);
p1.SetGrid();
p1.SetFillStyle(0);
p1.cd()
stacks_d = OrderedDict()
print "MC",hists_mc
print "VAL",hists_mc.values()
stacks_d["mc"] = hists_mc.values()
stacks_d["data"] = [hist_data]
stacks = plot_hists_stacked(
p1,
stacks_d,
x_label=var,
y_label="",
do_log_y=True
)
leg = legend([hist_data] + list(reversed(hists_mc.values())), styles=["p", "f"])
print canv, hist_data
print get_stack_total_hist(stacks["mc"])
ratio_pad, hratio = plot_data_mc_ratio(canv, get_stack_total_hist(stacks["mc"]), hist_data)
plot_info = PlotMetaInfo(
name,
"CUT",
"WEIGHT",
[infile],
subdir=fit.name,
comments=str(result[SIGNAL])
)
of.savePlot(canv, plot_info)
canv.Close()
legend_pos = "top-right"
if legend_pos == "top-right":
lumibox = lumi_textbox(Lumi,"top-left")
if legend_pos == "top-left":
lumibox = lumi_textbox(Lumi,"top-right")
hist_list = mc_to_plot.values()
hist_list.reverse() # reverse order of mc histograms for the legend entry
hist_list.append(qcd)
hist_list.insert(0,data)
leg = legend(
hist_list,
names = process_names,
styles=["p", "f"],
width=0.25,
pos = legend_pos
)
outfilename = "Plots/" + channel + "/" + mode1 + mode1a + "/" + hist_to_plot + mode2 + weight + ".pdf"
if not os.path.exists(os.path.dirname(outfilename)):
os.makedirs(os.path.dirname(outfilename))
c.SaveAs(outfilename)
c.Close()
#----------------Signal PDG ID information------------------
# nr_W = 0
# nr_tau = 0
if hist_to_plot == "el_mother_id" or hist_to_plot == "mu_mother_id":
nr_W = mc_to_plot["signal"].GetBinContent(2) + mc_to_plot["signal"].GetBinContent(50)
hcomphep.SetLineStyle('dashed')
hcomphep.SetMarkerSize(0)
Styling.data_style(data_post)
hi = [data_post, htrue, hcomphep]
chi2 = data_post.Chi2Test(htrue, "WW CHI2/NDF")
#htrue.SetTitle(htrue.GetTitle() + " #chi^{2}/#nu = %.1f" % chi2)
#hi_norm = hi
hi_norm = map(post_normalize, hi)
for h in hi[1:]:
h.SetMarkerSize(0)
of = OutputFolder(subdir='unfolding/%s' % lep)
canv = plot_hists(hi_norm, x_label="cos #theta*", draw_cmd=len(hi)*["E1"], y_label="a.u.")
#leg = legend(hi, styles=['p', 'f'], legend_pos='bottom-right', nudge_x=-0.29, nudge_y=-0.08)
leg = legend(hi, styles=['p', 'f'], legend_pos='top-left', nudge_y=-0.14)
lb = lumi_textbox(lumi,
pos='top-center',
line2="#scale[1.5]{A = %.2f #pm %.2f (stat.) #pm %.2f (syst.)}" % (
measured_asym, measured_asym_errs[lep][0], measured_asym_errs[lep][1]
), nudge_y=0.03
)
pmi = PlotMetaInfo(
'costheta_unfolded',
'2j1t_mva_loose {0}'.format(channel),
'weighted to lumi={0}, sf(tchan)={1}'.format(lumi, fitpars[lep]),
[args.infileMC, args.infileD]
)
of.savePlot(canv, pmi)
def data_mc_plot(samples, plot_def, name, lepton_channel, lumi, weight, physics_processes, use_antiiso=False):
logger.info('Plot in progress %s' % name)
merge_cmds = PhysicsProcess.get_merge_dict(physics_processes) #The actual merge dictionary
var = plot_def['var']
#Id var is a list/tuple, assume
if not isinstance(var, basestring):
try:
if lepton_channel == 'ele':
var = var[0]
elif lepton_channel == 'mu':
var = var[1]
except Exception as e:
logger.error("Plot variable 'var' specification incorrect for multi-variable plot: %s" % str(var))
raise e
cut = None
if lepton_channel == 'ele':
cut = plot_def['elecut']
elif lepton_channel == 'mu':
cut = plot_def['mucut']
cut_str = str(cut)
plot_range = plot_def['range']
do_norm = False
if 'normalize' in plot_def.keys() and plot_def['normalize']:
do_norm = True
hists_mc = dict()
hists_data = dict()
for name, sample in samples.items():
logger.debug("Starting to plot %s" % name)
if sample.isMC:
hist = sample.drawHistogram(var, cut_str, weight=str(weight), plot_range=plot_range)
hist.Scale(sample.lumiScaleFactor(lumi))
hists_mc[sample.name] = hist
if do_norm:
Styling.mc_style_nostack(hists_mc[sample.name], sample.name)
else:
Styling.mc_style(hists_mc[sample.name], sample.name)
if "fitpars" in plot_def.keys():
rescale_to_fit(sample.name, hist, plot_def["fitpars"][lepton_channel])
elif "antiiso" in name and plot_def['estQcd'] and not use_antiiso:
# Make loose template
#Y U NO LOOP :) -JP
region = '2j1t'
if '2j0t' in plot_def['estQcd']: region='2j0t'
if '3j0t' in plot_def['estQcd']: region='3j0t'
if '3j1t' in plot_def['estQcd']: region='3j1t'
if '3j2t' in plot_def['estQcd']: region='3j2t'
qcd_extra_cut = Cuts.deltaR(0.3)*Cuts.antiiso(lepton_channel)
#Take the loose template with a good shape from the N-jet, M-tag, post lepton selection region with high statistics
qcd_loose_cut = cutlist[region]*cutlist['presel_'+lepton_channel]*qcd_extra_cut
#Take the template which can be correctly normalized from the actual region with inverted isolation cuts
qcd_cut = cut*qcd_extra_cut
hist_qcd_loose = sample.drawHistogram(var, str(qcd_loose_cut), weight="1.0", plot_range=plot_range)
hist_qcd = sample.drawHistogram(var, str(qcd_cut), weight="1.0", plot_range=plot_range)
logger.debug("Using the QCD scale factor %s: %.2f" % (plot_def['estQcd'], qcdScale[lepton_channel][plot_def['estQcd']]))
hist_qcd.Scale(qcdScale[lepton_channel][plot_def['estQcd']])
hist_qcd_loose.Scale(hist_qcd.Integral()/hist_qcd_loose.Integral())
if var=='cos_theta':
hist_qcd=hist_qcd_loose
sampn = "QCD"+sample.name
#Rescale the QCD histogram to the eta_lj fit
if "fitpars" in plot_def.keys():
rescale_to_fit(sampn, hist_qcd, plot_def["fitpars"][lepton_channel])
hists_mc[sampn] = hist_qcd
hists_mc[sampn].SetTitle('QCD')
if do_norm:
Styling.mc_style_nostack(hists_mc[sampn], 'QCD')
else:
Styling.mc_style(hists_mc[sampn], 'QCD')
#Real ordinary data in the isolated region
elif not "antiiso" in name or use_antiiso:
hist_data = sample.drawHistogram(var, cut_str, weight="1.0", plot_range=plot_range)
hist_data.SetTitle('Data')
Styling.data_style(hist_data)
hists_data[name] = hist_data
if len(hists_data.values())==0:
raise Exception("Couldn't draw the data histogram")
#Combine the subsamples to physical processes
hist_data = sum(hists_data.values())
merge_cmds['QCD']=["QCD"+merge_cmds['data'][0]]
order=['QCD']+PhysicsProcess.desired_plot_order
if plot_def['log']:
order = PhysicsProcess.desired_plot_order_log+['QCD']
merged_hists = merge_hists(hists_mc, merge_cmds, order=order)
if hist_data.Integral()<=0:
logger.error(hists_data)
logger.error("hist_data.entries = %d" % hist_data.GetEntries())
logger.error("hist_data.integral = %d" % hist_data.Integral())
raise Exception("Histogram for data was empty. Something went wrong, please check.")
if do_norm:
for k,v in merged_hists.items():
v.Scale(1./v.Integral())
hist_data.Scale(1./hist_data.Integral())
htot = sum(merged_hists.values())
chi2 = hist_data.Chi2Test(htot, "UW CHI2/NDF")
if chi2>20:#FIXME: uglyness
logger.error("The chi2 between data and MC is large (%s, chi2=%.2f). You may have errors with your samples!" %
(name, chi2)
)
logger.info("MC : %s" % " ".join(map(lambda x: "%.1f" % x, list(htot.y()))))
logger.info("DATA: %s" % " ".join(map(lambda x: "%.1f" % x, list(hist_data.y()))))
logger.info("diff: %s" % str(
" ".join(map(lambda x: "%.1f" % x, numpy.abs(numpy.array(list(htot.y())) - numpy.array(list(hist_data.y())))))
))
merged_hists_l = merged_hists.values()
PhysicsProcess.name_histograms(physics_processes, merged_hists)
leg_style = ['p','f']
if do_norm:
leg_style=['p','l']
leg = legend([hist_data] + list(reversed(merged_hists_l)), legend_pos=plot_def['labloc'], styles=leg_style)
canv = ROOT.TCanvas()
#Make the stacks
stacks_d = OrderedDict()
stacks_d["mc"] = merged_hists_l
stacks_d["data"] = [hist_data]
#label
xlab = plot_def['xlab']
if not isinstance(xlab, basestring):
if lepton_channel == 'ele':
xlab = xlab[0]
else:
xlab = xlab[1]
ylab = 'N / '+str((1.*(plot_range[2]-plot_range[1])/plot_range[0]))
if plot_def['gev']:
ylab+=' GeV'
fact = 1.5
if plot_def['log']:
fact = 10
plow=0.3
if do_norm:
plow=0
#Make a separate pad for the stack plot
p1 = ROOT.TPad("p1", "p1", 0, plow, 1, 1)
p1.Draw()
p1.SetTicks(1, 1);
p1.SetGrid();
p1.SetFillStyle(0);
p1.cd()
stacks = plot_hists_stacked(p1, stacks_d, x_label=xlab, y_label=ylab, max_bin_mult = fact, do_log_y = plot_def['log'], stack = (not do_norm))
#Put the the lumi box where the legend is not
boxloc = 'top-right'
if plot_def['labloc'] == 'top-right':
boxloc = 'top-left'
chan = 'Electron'
if lepton_channel == "mu":
chan = 'Muon'
additional_comments = ""
if 'cutname' in plot_def.keys():
additional_comments += ", " + plot_def['cutname'][lepton_channel]
lbox = lumi_textbox(lumi,
boxloc,
'preliminary',
chan + ' channel' + additional_comments
)
#Draw everything
lbox.Draw()
leg.Draw()
canv.Draw()
#Keep the handles just in case
canv.PAD1 = p1
canv.STACKS = stacks
canv.LEGEND = legend
canv.LUMIBOX = lbox
return canv, merged_hists, htot, hist_data
def plot_fit(var, fitConf, hData, fit_result):
tdrstyle()
canvases = []
infile = "fits/"+var.shortName+"_fit_"+fitConf.name+".root"
f = TFile(infile)
print fitConf.name
outfile_name = "fit_plots/"+var.shortName+"_Fit_"+fitConf.name
#print fit_result
QCDRATE = fit_result.qcd
QCDRATE_UP = fit_result.qcd + fit_result.qcd_uncert
QCDRATE_DOWN = fit_result.qcd - fit_result.qcd_uncert
NONQCDRATE = fit_result.nonqcd
NONQCDRATE_UP = fit_result.nonqcd + fit_result.nonqcd_uncert
NONQCDRATE_DOWN = fit_result.nonqcd - fit_result.nonqcd_uncert
WJETS = fit_result.wjets
WJETS_UP = fit_result.wjets + fit_result.wjets_uncert
WJETS_DOWN = fit_result.wjets - fit_result.wjets_uncert
cst = TCanvas("Histogram_"+fitConf.name,fitConf.name,10,10,1000,1000)
hNonQCD = TH1D(f.Get(var.shortName+"__nonqcd"))
hNonQCD.SetTitle("Non-QCD")
hNonQCD.SetLineColor(kRed)
hNonQCDp=TH1D(hNonQCD)
hNonQCDp.Scale(NONQCDRATE_UP/NONQCDRATE)
hNonQCDm=TH1D(hNonQCD)
hNonQCDm.Scale(NONQCDRATE_DOWN/NONQCDRATE)
hNonQCDp.SetLineColor(kOrange)
hNonQCDp.SetTitle("Non-QCD #pm 1 #sigma")
hNonQCDm.SetLineColor(kOrange)
hNonQCDm.SetTitle("non-QCD - 1 sigma")
hWJets = TH1D(f.Get(var.shortName+"__wjets"))
hWJets.SetTitle("W+Jets")
hWJets.SetLineColor(kGreen+4)
hWJetsp=TH1D(hWJets)
hWJetsp.Scale(WJETS_UP/WJETS)
hWJetsm=TH1D(hWJets)
hWJetsm.Scale(WJETS_DOWN/WJETS)
hWJetsp.SetLineColor(kGreen+8)
hWJetsp.SetTitle("W+Jets #pm 1 #sigma")
hWJetsm.SetLineColor(kGreen+8)
hWJetsm.SetTitle("W+Jets - 1 sigma")
hData.SetNameTitle(var.shortName+"__DATA", "Data")
hData.SetMarkerStyle(20)
#print "data integral: ",hData.Integral()
hQCD = f.Get(var.shortName+"__qcd")
hQCD.SetNameTitle(var.shortName+"__qcd", "QCD")
hQCD.SetLineColor(kYellow)
hQCDp=TH1D(hQCD)
hQCDp.Scale(QCDRATE_UP/QCDRATE)
hQCDm=TH1D(hQCD)
hQCDm.Scale(QCDRATE_DOWN/QCDRATE)
hQCDp.SetLineColor(kGreen)
hQCDp.SetTitle("QCD #pm 1 #sigma")
hQCDm.SetLineColor(kGreen)
hQCDm.SetTitle("QCD #pm 1 #sigma")
hTotal=TH1D(hNonQCD)
hTotal.Add(hQCD)
hTotal.Add(hWJets)
hTotal.SetLineColor(kBlue)
hTotal.SetTitle("Fitted total")
max_bin = hData.GetMaximum()*1.6
hData.SetAxisRange(0, max_bin, "Y")
hData.GetXaxis().SetTitle(var.displayName)
#hTotal.Draw("")
title = fit_result.getTitle()
hData.SetMarkerStyle(20)
hData.Draw("E1")
hNonQCDp.Draw("same")
hQCD.Draw("same")
hNonQCD.Draw("same")
hNonQCDm.Draw("same")
hQCDp.Draw("same")
hQCDm.Draw("same")
hWJets.Draw("same")
hWJetsp.Draw("same")
hWJetsm.Draw("same")
hTotal.Draw("same")
#hData.SetTitle("QCD fit, "+title)
hData.Draw("E1 same")
lumibox = lumi_textbox(19739)
leg = legend(
[hData, hQCD, hQCDp, hNonQCD, hNonQCDp, hWJets, hWJetsp, hTotal],
styles=["p", "l"],
width=0.2
)
leg.Draw()
#print hNonQCD.Integral(), hData.Integral(), hQCD.Integral(), hTotal.Integral(), hQCDp.Integral(), hQCDm.Integral()
cst.Update()
cst.SaveAs(outfile_name+".png")
cst.SaveAs(outfile_name+".pdf")
cst.Draw()
return cst
if __name__=="__main__":
samp = Sample.fromFile("~/Documents/stpol/data/out_step3_joosep_11_07_19_44/mu/iso/nominal/W4Jets_exclusive.root")
samp.tree.AddFriend("trees/WJets_weights", samp.file_name)
tdrstyle()
cut = str(Cuts.final(2,0)*Cuts.Wflavour("W_heavy"))
mean_weight = samp.drawHistogram(str(Weights.wjets_madgraph_weight("nominal")), cut, weight="1.0", plot_range=[200, 0, 2]).hist.GetMean()
print "mean weight=%.2f" % mean_weight
hi0 = samp.drawHistogram("cos_theta", cut, weight="1.0", plot_range=[20, -1, 1]).hist
hi0.Scale(samp.lumiScaleFactor(20000))
hi1 = samp.drawHistogram("cos_theta", cut, weight=str(Weights.wjets_madgraph_weight("nominal")), plot_range=[20, -1, 1]).hist
hi1.Scale(samp.lumiScaleFactor(20000))
hi2 = samp.drawHistogram("cos_theta", cut, weight=str(Weights.wjets_madgraph_weight("wjets_up")), plot_range=[20, -1, 1]).hist
hi2.Scale(samp.lumiScaleFactor(20000))
hi3 = samp.drawHistogram("cos_theta", cut, weight=str(Weights.wjets_madgraph_weight("wjets_down")), plot_range=[20, -1, 1]).hist
hi3.Scale(samp.lumiScaleFactor(20000))
hists = [hi0, hi1, hi2, hi3]
#for h in hists:
# h.Scale(1.0/h.Integral())
hi0.SetTitle("unweighted")
hi1.SetTitle("weighted")
hi2.SetTitle("weighted wjets_up")
hi3.SetTitle("weighted wjets_down")
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label="cos #theta")
leg = legend(hists, styles=["f", "f"], nudge_x=-0.2)
hi0.SetTitle("WJets hf yield with variations, 2J0T")
canv.Update()
for name, histo in histos[process].items():
if name != "Nominal":
print "Chi2 %s %s %.2f %.3f" % (
process, name,
histo.Chi2Test(histos[process]["Nominal"],
"WW CHI2/NDF"),
histo.Chi2Test(histos[process]["Nominal"], "WW"))
canv = plot_hists(canv,
histos[process],
x_label="cos(#Theta *)",
title=process,
max_bin_mult=1.6)
#Draws the lumi box
lumibox = lumi_textbox(lumi_iso["mu"])
#Draw the legend
leg = legend(
histos[process].values(
), # <<< need to reverse MC order here, mc3 is top-most
styles=["l"],
width=0.3,
text_size=0.015)
outf.write(make_plot_slide(process, canv))
outf.write("\end{document}")
outf.close()
def plot_sherpa_vs_madgraph(var, cut_name, cut, samples, out_dir, recreate=False, **kwargs):
hname = var["varname"]
out_dir = out_dir + "/" + cut_name
if recreate and os.path.exists(out_dir):
logger.info("Output directory %s exists, removing" % out_dir)
shutil.rmtree(out_dir)
mkdir_p(out_dir)
logger.info("Using output directory %s" % out_dir)
logger.info("Using output directory %s" % out_dir)
coll = data_mc(var["var"], cut_name, cut, Weights.total()*Weights.mu, samples, out_dir, recreate, LUMI_TOTAL, reweight_madgraph=True, flavour_split=True, plot_range=var["range"], **kwargs)
logging.debug(str(coll.hists))
for hn, hist in coll.hists.items():
sample_name = coll.metadata[hn].sample_name
process_name = coll.metadata[hn].process_name
match = re.match(".*/cut__flavour__(W_[Hl][Hl])/.*", hn)
if match:
flavour_scenario = match.group(1)
else:
flavour_scenario = None
try:
if sample_types.is_mc(sample_name):
Styling.mc_style(hist, process_name)
else:
Styling.data_style(hist)
except KeyError as e:
logger.warning("Couldn't style histogram %s" % hn)
if flavour_scenario:
logger.debug("Matched flavour split histogram %s, %s" % (hn, flavour_scenario))
#Styling.mc_style(hist, process_name)
if re.match("W_H[lH]", flavour_scenario):
logger.debug("Changing colour of %s" % (hn))
hist.SetFillColor(hist.GetFillColor()+1)
hist.SetLineColor(hist.GetLineColor()+1)
logger.debug("pre merge: %s" % str([ (hn, coll.hists[hn].GetLineColor()) for hn in coll.hists.keys() if "sherpa" in hn]))
merges = dict()
merge_cmds = get_merge_cmds()
merge_cmds.pop("WJets")
merges["madgraph/unweighted"] = merge_cmds.copy()
merges["madgraph/weighted"] = merge_cmds.copy()
merges["sherpa/unweighted"] = merge_cmds.copy()
merges["sherpa/weighted"] = merge_cmds.copy()
merges["sherpa/unweighted"]["WJets_hf"] = ["weight__nominal/cut__flavour__W_heavy/WJets_sherpa_nominal"]
merges["sherpa/unweighted"]["WJets_lf"] = ["weight__nominal/cut__flavour__W_light/WJets_sherpa_nominal"]
merges["sherpa/weighted"]["WJets_hf"] = ["weight__sherpa_flavour/cut__flavour__W_heavy/WJets_sherpa_nominal"]
merges["sherpa/weighted"]["WJets_lf"] = ["weight__sherpa_flavour/cut__flavour__W_light/WJets_sherpa_nominal"]
merges["madgraph/unweighted"]["WJets_hf"] = ["weight__nominal/cut__flavour__W_heavy/W[1-4]Jets_exclusive"]
merges["madgraph/unweighted"]["WJets_lf"] = ["weight__nominal/cut__flavour__W_light/W[1-4]Jets_exclusive"]
merges["madgraph/weighted"]["WJets_hf"] = ["weight__reweight_madgraph/cut__flavour__W_heavy/W[1-4]Jets_exclusive"]
merges["madgraph/weighted"]["WJets_lf"] = ["weight__reweight_madgraph/cut__flavour__W_light/W[1-4]Jets_exclusive"]
hmerged = dict()
for k in merges.keys():
hmerged[k] = merge_hists(copy.deepcopy(coll.hists), merges[k])
logger.debug("post merge: %s" % str([ (hn, hmerged["sherpa/weighted"][hn].GetLineColor()) for hn in hmerged["sherpa/weighted"].keys()]))
#w_mg_sh = 1.0416259307303726 #sherpa to madgraph ratio
w_mg_sh = 1.0821535639376414
hmerged["sherpa/weighted"]["WJets_hf"].Scale(w_mg_sh)
hmerged["sherpa/weighted"]["WJets_lf"].Scale(w_mg_sh)
logger.info("Drawing madgraph unweighted plot")
canv = ROOT.TCanvas("c2", "c2")
suffix = "__%s__%s" % (var["var"], cut_name)
suffix = escape(suffix)
plot(canv, "madgraph_unw"+suffix, hmerged["madgraph/unweighted"], out_dir, **kwargs)
kwargs = dict({"x_label": var["varname"]}, **kwargs)
for k, v in hmerged.items():
logger.debug("Group %s" % k)
for hn, h in v.items():
logger.debug("Sample %s = %.2f" % (hn, h.Integral()))
logger.info("%s data=%.2f" % (k, v["data"].Integral()))
logger.info("%s MC=%.2f" % (k, sum([h.Integral() for k, h in v.items() if k!="data"])))
hists_flavours_merged = dict()
hists_flavours_merged["madgraph/weighted"] = merge_hists(hmerged["madgraph/weighted"], {"WJets": ["WJets_hf", "WJets_lf"]})
hists_flavours_merged["madgraph/unweighted"] = merge_hists(hmerged["madgraph/unweighted"], {"WJets": ["WJets_hf", "WJets_lf"]})
hists_flavours_merged["sherpa/unweighted"] = merge_hists(hmerged["sherpa/unweighted"], {"WJets": ["WJets_hf", "WJets_lf"]})
hists_flavours_merged["sherpa/weighted"] = merge_hists(hmerged["sherpa/weighted"], {"WJets": ["WJets_hf", "WJets_lf"]})
logger.info("Drawing sherpa weighted plot")
canv = ROOT.TCanvas("c1", "c1")
plot(canv, "sherpa_rew"+suffix, hmerged["sherpa/weighted"], out_dir, **kwargs)
logger.info("Drawing sherpa unweighted plot")
canv = ROOT.TCanvas("c1", "c1")
plot(canv, "sherpa_unw"+suffix, hmerged["sherpa/unweighted"], out_dir, **kwargs)
logger.info("Drawing madgraph plot")
canv = ROOT.TCanvas("c2", "c2")
plot(canv, "madgraph_rew"+suffix, hmerged["madgraph/weighted"], out_dir, **kwargs)
total_madgraph = copy.deepcopy(hmerged["madgraph/unweighted"])
merged_colls = dict()
for k, v in hmerged.items():
merged_colls[k] = HistCollection(copy.deepcopy(v), name=k)
logger.info("Drawing sherpa vs. madgraph shape comparison plots")
hists = [
("sherpa unw hf", hmerged["sherpa/unweighted"]["WJets_hf"]),
("sherpa rew hf", hmerged["sherpa/weighted"]["WJets_hf"]),
("madgraph unw hf", hmerged["madgraph/unweighted"]["WJets_hf"]),
("madgraph rew hf", hmerged["madgraph/weighted"]["WJets_hf"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.SaveAs(out_dir + "/weighted_flavour_hf_%s.png" % hname)
canv.Close()
hists = [
("data", hmerged["madgraph/unweighted"]["data"]),
("sherpa", hists_flavours_merged["sherpa/unweighted"]["WJets"]),
("madgraph", hists_flavours_merged["madgraph/unweighted"]["WJets"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.SaveAs(out_dir + "/unweighted_sherpa_mg_%s.png" % hname)
canv.Close()
hists = [
("data", hmerged["madgraph/unweighted"]["data"]),
("sherpa", hists_flavours_merged["sherpa/weighted"]["WJets"]),
("madgraph", hists_flavours_merged["madgraph/weighted"]["WJets"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.SaveAs(out_dir + "/weighted_sherpa_mg_%s.png" % hname)
canv.Close()
hists = [
("sherpa unw lf", hmerged["sherpa/unweighted"]["WJets_lf"]),
("sherpa rew lf", hmerged["sherpa/weighted"]["WJets_lf"]),
("madgraph unw lf", hmerged["madgraph/unweighted"]["WJets_lf"]),
("madgraph rew lf", hmerged["madgraph/weighted"]["WJets_lf"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.SaveAs(out_dir + "/weighted_flavour_lf_%s.png" % hname)
canv.Close()
hists = [
("data", hmerged["madgraph/unweighted"]["data"]),
("madgraph unw", hists_flavours_merged["madgraph/unweighted"]["WJets"]),
("madgraph rew", hists_flavours_merged["madgraph/weighted"]["WJets"]),
("sherpa unw", hists_flavours_merged["sherpa/unweighted"]["WJets"]),
("sherpa rew", hists_flavours_merged["sherpa/weighted"]["WJets"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
hists[0].SetTitle("")
canv.Update()
canv.SaveAs(out_dir + "/shapes_%s.png" % hname)
canv.Close()
# hists = [
# ("sherpa hf", hmerged["sherpa"]["WJets_hf"]),
# ("madgraph unw hf", hmerged["madgraph/unweighted"]["WJets_hf"]),
# ("madgraph rew hf", hmerged["madgraph/weighted"]["WJets_hf"]),
# ]
# hists = copy.deepcopy(hists)
# for hn, h in hists:
# h.SetTitle(hn + " %.2f" % h.Integral())
# h.Scale(1.0/h.Integral())
# hists = [h[1] for h in hists]
# ColorStyleGen.style_hists(hists)
# canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
# leg = legend(hists, styles=["f", "f"], **kwargs)
# hists[0].SetTitle("madgraph sherpa rew hf")
# canv.SaveAs(out_dir + "/shapes_hf_%s.png" % hname)
# canv.Close()
return coll, merged_colls
def plot_ratios(cut_name, cut, samples, out_dir, recreate, flavour_scenario=flavour_scenarios[0]):
out_dir += "/" + cut_name
mkdir_p(out_dir)
colls = dict()
samples_WJets = filter(lambda x: sample_types.is_wjets(x.name), samples)
for sc in flavour_scenario:
logger.info("Drawing ratio with cut %s" % sc)
cut_ = cut*getattr(Cuts, sc)
colls[sc] = data_mc(costheta["var"], cut_name + "__" + sc, cut_, Weights.total()*Weights.mu, samples_WJets, out_dir, recreate, LUMI_TOTAL, plot_range=costheta["range"])
logger.debug(colls[flavour_scenario[0]].hists["weight__nominal/cut__all/WJets_sherpa_nominal"].Integral())
logger.debug(colls[flavour_scenario[1]].hists["weight__nominal/cut__all/WJets_sherpa_nominal"].Integral())
coll = dict()
for k, c in colls.items():
for hn, h in c.hists.items():
coll[hn + "/" + k] = h
for k, h in coll.items():
logger.debug("%s = %s" % (k, str([y for y in h.y()])))
logger.debug(coll)
#coll = HistCollection(coll, name=cut_name)
merges = {}
for sc in flavour_scenario:
merges["madgraph/%s" % sc] = ["weight__nominal/cut__all/W[1-4]Jets_exclusive/%s" % sc]
merges["sherpa/unweighted/%s" % sc] = ["weight__nominal/cut__all/WJets_sherpa_nominal/%s" % sc]
merges["sherpa/weighted/%s" % sc] = ["weight__sherpa_flavour/cut__all/WJets_sherpa_nominal/%s" % sc]
merged = merge_hists(coll, merges)
for k, h in merged.items():
logger.debug("%s = %s" % (k, str([y for y in h.y()])))
hists_flavour = dict()
hists_flavour["madgraph"] = ROOT.TH1F("madgraph", "madgraph", len(flavour_scenario), 0, len(flavour_scenario)-1)
hists_flavour["sherpa/unweighted"] = ROOT.TH1F("sherpa_unw", "sherpa unweighted", len(flavour_scenario), 0, len(flavour_scenario)-1)
hists_flavour["sherpa/weighted"] = ROOT.TH1F("sherpa_rew", "sherpa weighted", len(flavour_scenario), 0, len(flavour_scenario)-1)
for i, sc in zip(range(1,len(flavour_scenario)+1), flavour_scenario):
sh1_int, sh1_err = calc_int_err(merged["sherpa/unweighted/%s" % sc])
sh2_int, sh2_err = calc_int_err(merged["sherpa/weighted/%s" % sc])
mg_int, mg_err = calc_int_err(merged["madgraph/%s" % sc])
logger.debug("%.2f %.2f" % (sh1_int, sh1_err))
logger.debug("%.2f %.2f" % (sh2_int, sh2_err))
logger.debug("%.2f %.2f" % (mg_int, mg_err))
hists_flavour["madgraph"].SetBinContent(i, mg_int)
hists_flavour["madgraph"].SetBinError(i, mg_err)
hists_flavour["sherpa/unweighted"].SetBinContent(i, sh1_int)
hists_flavour["sherpa/unweighted"].SetBinError(i, sh1_err)
hists_flavour["sherpa/weighted"].SetBinContent(i, sh2_int)
hists_flavour["sherpa/weighted"].SetBinError(i, sh2_err)
hists_flavour["madgraph"].GetXaxis().SetBinLabel(i, sc)
hists_flavour["sherpa/unweighted"].GetXaxis().SetBinLabel(i, sc)
hists_flavour["sherpa/weighted"].GetXaxis().SetBinLabel(i, sc)
hists_flavour["sherpa/weighted"].Sumw2()
hists_flavour["sherpa/unweighted"].Sumw2()
hists_flavour["madgraph"].Sumw2()
hists_flavour["ratio/unweighted"] = hists_flavour["madgraph"].Clone("ratio_unw")
hists_flavour["ratio/unweighted"].Divide(hists_flavour["sherpa/unweighted"])
hists_flavour["ratio/weighted"] = hists_flavour["madgraph"].Clone("ratio_rew")
hists_flavour["ratio/weighted"].Divide(hists_flavour["sherpa/weighted"])
for i, sc in zip(range(1,len(flavour_scenario)+1), flavour_scenario):
logger.info("weights[%s] = %.6f; //error=%.6f [%d]" % (sc, hists_flavour["ratio/unweighted"].GetBinContent(i), hists_flavour["ratio/unweighted"].GetBinError(i), i))
flavour_ratio_coll = HistCollection(hists_flavour, name="hists__flavour_ratios")
flavour_ratio_coll.save(out_dir)
for sc in flavour_scenario:
hists = [merged["madgraph/%s" % sc], merged["sherpa/unweighted/%s" % sc], merged["sherpa/weighted/%s" % sc]]
for hist in hists:
norm(hist)
#hist.SetName(sc)
#hist.SetTitle(sc)
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=costheta["varname"])
leg = legend(hists, styles=["f", "f"], nudge_x=-0.2)
chi2 = hists[0].Chi2Test(hists[1], "WW CHI2/NDF")
hists[0].SetTitle("madgraph to sherpa comparison #chi^{2}/ndf=%.2f" % chi2)
canv.Update()
canv.SaveAs(out_dir + "/flavours__%s.png" % (sc))
md_merged = dict()
for sc in flavour_scenario:
logger.info("Calculating ratio for %s" % sc)
hi = merged["sherpa/unweighted/%s" % sc].Clone("ratio__%s" % sc)
hi.Divide(merged["madgraph/%s" % sc])
merged[hi.GetName()] = hi
hc_merged = HistCollection(merged, md_merged, "hists__costheta_flavours_merged")
hc_merged.save(out_dir)
logger.info("Saved merged histogram collection")
h.Draw("same *h")
hData.Draw("e1 same")
#Draws the lumi box
from plots.common.utils import lumi_textbox
lumibox = lumi_textbox(lumi_iso["mu"], "top-right")
stacks_d = OrderedDict() #<<< need to use OrderedDict to have data drawn last (dict does not preserve order)
stacks_d["sys"] = histos
stacks_d["mc"] = list(reversed(stack.GetHists()))
stacks_d["data"] = [hData]
#print stacks_d
#Draw the legend
leg_histos = [hData]
leg_histos.extend(histos)
leg_histos.extend(list(reversed(stack.GetHists())))
from plots.common.legend import legend
leg = legend(
leg_histos,# <<< need to reverse MC order here, mc3 is top-most
pos="top-left",
styles=["p", "pl", "pl", "pl", "pl", "pl", "pl", "f"],
width=0.2,
text_size=0.015
)
filename = "plots/systematics_stack"
cst.SaveAs(filename+".png")
cst.SaveAs(filename+".pdf")
#return cst
\end{tabular}
\end{center}
\end{frame}
""")
for name,histo in histos[process].items():
if name != "Nominal":
print "Chi2 %s %s %.2f %.3f" %(process,name,histo.Chi2Test(histos[process]["Nominal"], "WW CHI2/NDF"),histo.Chi2Test(histos[process]["Nominal"], "WW"))
canv = plot_hists(canv, histos[process],
x_label="cos(#Theta *)",
title=process,
max_bin_mult=1.6
)
#Draws the lumi box
lumibox = lumi_textbox(lumi_iso["mu"])
#Draw the legend
leg = legend(
histos[process].values(), # <<< need to reverse MC order here, mc3 is top-most
styles=["l"],
width=0.3,
text_size=0.015
)
outf.write(make_plot_slide(process, canv))
outf.write("\end{document}")
outf.close()
def data_mc_plot(pd):
hists = load_theta_format(pd.infile, styles)
for (variable, sample, systtype, systdir), hist in hists.items_flat():
#Scale all MC samples except QCD to the luminosity
if sample_types.is_mc(sample) and not sample=="qcd":
hist.Scale(pd.lumi)
if hasattr(pd, "rebin"):
hist.Rebin(pd.rebin)
if sample=="qcd" and hasattr(pd, "qcd_yield"):
hist.Scale(pd.qcd_yield / hist.Integral())
rescale_to_fit(sample, hist, pd.process_scale_factor)
hist.SetTitle(sample)
hist.SetName(sample)
#Assuming we only have 1 variable
hists = hists[pd.var]
hists_nominal = hists.pop("nominal")[None]
hists_nom_data = hists_nominal.pop('data')
hists_nom_mc = hists_nominal.values()
hists_syst = hists
hists_nom_data.SetTitle('data')
#A list of all the systematic up, down variation templates as 2-tuples
all_systs = [
]
all_systs = hists_syst.keys()
systs_to_consider = []
#See which systematics where asked to switch on
for syst in all_systs:
for sm in pd.systematics:
if re.match(sm, syst):
systs_to_consider.append(syst)
#The total nominal MC histogram
nom = sum(hists_nom_mc)
if pd.normalize:
ratio = hists_nom_data.Integral() / nom.Integral()
hists_nom_data.Scale(1.0/ratio)
#Get all the variated up/down total templates
#A list with all the up/down total templates
all_systs = []
sumsqs = []
logger.info("Considering systematics %s" % str(systs_to_consider))
for syst in systs_to_consider:
#A list with the up/down variated template for a particular systematic
totupdown = []
sumsq = []
for systdir in ["up", "down"]:
#Get all the templates corresponding to a systematic scenario and a variation
_hists = hists_syst[syst][systdir]
for k, h in _hists.items():
"""
Consider only the shape variation of the systematic,
hence the variated template is normalized to the corresponding
unvariated template.
"""
if pd.systematics_shapeonly:
if h.Integral()>0:
h.Scale(hists_nominal[k].Integral() / h.Integral())
#For the missing variated templates, use the nominal ones, but warn the user
present = set(_hists.keys())
all_mc = set(hists_nominal.keys())
missing = list(all_mc.difference(present))
for m in missing:
logger.warning("Missing systematic template for %s:%s" % (syst, systdir))
#Calculate the total variated template
tot = sum(_hists.values()) + sum([hists_nominal[m] for m in missing])
totupdown.append(tot)
sumsq.append(
math.sqrt(numpy.sum(numpy.power(numpy.array(list(nom.y())) - numpy.array(list(tot.y())), 2)))
)
logger.debug("Systematic %s: sumsq=%.2Eu, %.2Ed" % (syst, sumsq[0], sumsq[1]))
sumsqs.append((syst, max(sumsq)))
all_systs.append(
(syst, tuple(totupdown))
)
sumsqs = sorted(sumsqs, key=lambda x: x[1], reverse=True)
for syst, sumsq in sumsqs[0:7]:
logger.info("Systematic %s, %.4f" % (syst, sumsq))
#Calculate the total up/down variated templates by summing in quadrature
syst_stat_up, syst_stat_down = total_syst(
nom, all_systs,
)
for k, v in hists_nominal.items():
if hasattr(PhysicsProcess, k):
pp = getattr(PhysicsProcess, k)
v.SetTitle(pp.pretty_name)
else:
logger.warning("Not setting pretty name for %s" % k)
#If QCD is high-stats, put it in the bottom
plotorder = copy.copy(PhysicsProcess.desired_plot_order_mc)
if hists_nominal["qcd"].GetEntries()>100:
plotorder.pop(plotorder.index("qcd"))
plotorder.insert(0, "qcd")
stacks_d = OrderedDict()
stacks_d['mc'] = reorder(hists_nominal, plotorder)
stacks_d['data'] = [hists_nom_data]
#Systematic style
for s in [syst_stat_up, syst_stat_down]:
s.SetFillStyle(0)
s.SetLineWidth(3)
s.SetMarkerSize(0)
s.SetLineColor(ROOT.kBlue+2)
s.SetLineStyle('dashed')
s.SetTitle("stat. + syst.")
#c = ROOT.TCanvas("c", "c", 1000, 1000)
c = ROOT.TCanvas("c", "c")
p1 = ROOT.TPad("p1", "p1", 0, 0.3, 1, 1)
p1.Draw()
p1.SetTicks(1, 1);
p1.SetGrid();
p1.SetFillStyle(0);
p1.cd()
stacks = plot_hists_stacked(
p1, stacks_d,
x_label=pd.get_x_label(), max_bin_mult=pd.get_max_bin_mult(),
min_bin=pd.get_min_bin()
)
p1.SetLogy(pd.log)
syst_stat_up.Draw("SAME hist")
syst_stat_down.Draw("SAME hist")
ratio_pad, hratio = plot_data_mc_ratio(
c, hists_nom_data,
nom, syst_hists=(syst_stat_down, syst_stat_up), min_max=pd.get_ratio_minmax()
)
p1.cd()
leg = legend(
stacks_d['data'] +
list(reversed(stacks_d['mc'])) +
[syst_stat_up],
nudge_x=pd.legend_nudge_x,
nudge_y=pd.legend_nudge_y,
**pd.__dict__
)
lb = lumi_textbox(pd.lumi,
line2=pd.get_lumibox_comments(channel=pd.channel_pretty),
pos=pd.get_lumi_pos()
)
c.children = [p1, ratio_pad, stacks, leg, lb]
tot = 0
for k, v in hists_nominal.items():
print k, v.Integral(), v.GetEntries()
tot += v.Integral()
tot_data = hists_nom_data.Integral()
print "MC: %.2f Data: %.2f" % (tot, tot_data)
#import pdb; pdb.set_trace()
return c, (hists_nominal, hists_nom_data)
#Draw the stacked histograms
#----
stacks_d = OrderedDict() #<<< need to use OrderedDict to have data drawn last (dict does not preserve order)
stacks_d["mc"] = [h_mc1, h_mc2, h_mc3] # <<< order is important here, mc1 is bottom-most
stacks_d["data"] = [h_d1]
stacks = plot_hists_stacked(
canv,
stacks_d,
x_label="variable x [GeV]",
y_label="",
do_log_y=False
)
#Draws the lumi box
from plots.common.utils import lumi_textbox
lumibox = lumi_textbox(19432)
#Draw the legend
from plots.common.legend import legend
leg = legend(
[h_d1, h_mc3, h_mc2, h_mc1], # <<< need to reverse MC order here, mc3 is top-most
styles=["p", "f"],
width=0.25
)
try:
os.mkdir("muon_out")
except OSError:
pass
canv.SaveAs("muon_out/test.pdf")
h.Draw("same *h")
hData.Draw("e1 same")
#Draws the lumi box
from plots.common.utils import lumi_textbox
lumibox = lumi_textbox(lumi_iso["mu"], "top-right")
stacks_d = OrderedDict(
) #<<< need to use OrderedDict to have data drawn last (dict does not preserve order)
stacks_d["sys"] = histos
stacks_d["mc"] = list(reversed(stack.GetHists()))
stacks_d["data"] = [hData]
#print stacks_d
#Draw the legend
leg_histos = [hData]
leg_histos.extend(histos)
leg_histos.extend(list(reversed(stack.GetHists())))
from plots.common.legend import legend
leg = legend(
leg_histos, # <<< need to reverse MC order here, mc3 is top-most
pos="top-left",
styles=["p", "pl", "pl", "pl", "pl", "pl", "pl", "f"],
width=0.2,
text_size=0.015)
filename = "plots/systematics_stack"
cst.SaveAs(filename + ".png")
cst.SaveAs(filename + ".pdf")
#return cst
#Draw the stacked histograms
#----
stacks_d = OrderedDict(
) #<<< need to use OrderedDict to have data drawn last (dict does not preserve order)
stacks_d["mc"] = [h_mc1, h_mc2,
h_mc3] # <<< order is important here, mc1 is bottom-most
stacks_d["data"] = [h_d1]
stacks = plot_hists_stacked(canv,
stacks_d,
x_label="variable x [GeV]",
y_label="",
do_log_y=False)
#Draws the lumi box
from plots.common.utils import lumi_textbox
lumibox = lumi_textbox(19432)
#Draw the legend
from plots.common.legend import legend
leg = legend(
[h_d1, h_mc3, h_mc2, h_mc1
], # <<< need to reverse MC order here, mc3 is top-most
styles=["p", "f"],
width=0.25)
try:
os.mkdir("muon_out")
except OSError:
pass
canv.SaveAs("muon_out/test.pdf")
else:
legend_pos = "top-right"
if legend_pos == "top-right":
lumibox = lumi_textbox(Lumi, "top-left")
if legend_pos == "top-left":
lumibox = lumi_textbox(Lumi, "top-right")
hist_list = mc_to_plot.values()
hist_list.reverse() # reverse order of mc histograms for the legend entry
hist_list.append(qcd)
hist_list.insert(0, data)
leg = legend(hist_list,
names=process_names,
styles=["p", "f"],
width=0.25,
pos=legend_pos)
outfilename = "Plots/" + channel + "/" + mode1 + mode1a + "/" + hist_to_plot + mode2 + weight + ".pdf"
if not os.path.exists(os.path.dirname(outfilename)):
os.makedirs(os.path.dirname(outfilename))
c.SaveAs(outfilename)
c.Close()
#----------------Signal PDG ID information------------------
# nr_W = 0
# nr_tau = 0
if hist_to_plot == "el_mother_id" or hist_to_plot == "mu_mother_id":
nr_W = mc_to_plot["signal"].GetBinContent(
2) + mc_to_plot["signal"].GetBinContent(50)
logging.info("files = %s" % str(files))
for sn, fi in files.items():
hi = fi.Get("flavour_counts")
hi.SetName(sn)
pn = sn
Styling.mc_style(hi, pn)
hists[sn] = hi
merges = OrderedDict()
merges["W (madgraph)"] = ["W1Jets_exclusive", "W2Jets_exclusive", "W3Jets_exclusive", "W4Jets_exclusive"]
merges["W (sherpa)"] = ["WJets_sherpa"]
hists_merged = merge_hists(hists, merges)
hists = hists_merged.values()
ColorStyleGen.style_hists(hists)
for h in hists:
logging.info(list(h.y()))
h.SetFillColor(ROOT.kWhite)
h.Scale(1.0 / h.Integral())
c = plot_hists(hists, x_label="flavour(j,j)", y_label="", draw_cmd="HIST E1")
leg = legend(hists, styles=len(hists) * ["f"], nudge_x=-0.1)
hists[0].SetTitle("Jet flavour fraction n %s" % cut_name)
# hists[0].SetFillColor(ROOT.kGreen+2)
hists[0].SetMinimum(10 ** -3)
hists[0].SetMaximum(10)
# hists[0].SetLineColor(ROOT.kGreen+2)
c.SetLogy()
c.SaveAs(out_dir + "/flavour_%s.pdf" % cut_name)
c.Close()