def sum_over_inds(tobj, template, bins):
final = None
for b in bins:
if final is None:
final = cu.get_from_tfile(tobj, template.format(b)).Clone(
template.format("all"))
else:
final.Add(cu.get_from_tfile(tobj, template.format(b)))
return final
def do_data_mc_plot(dirname, histname, output_filename, **plot_kwargs):
data_file = cu.open_root_file(os.path.join(dirname, qgc.JETHT_ZB_FILENAME))
qcd_file = cu.open_root_file(os.path.join(dirname, qgc.QCD_FILENAME))
qcd_py_file = cu.open_root_file(
os.path.join(dirname, qgc.QCD_PYTHIA_ONLY_FILENAME))
qcd_hpp_file = cu.open_root_file(
os.path.join(dirname, qgc.QCD_HERWIG_FILENAME))
data_hist = cu.get_from_tfile(data_file, histname)
qcd_hist = cu.get_from_tfile(qcd_file, histname)
qcd_py_hist = cu.get_from_tfile(qcd_py_file, histname)
qcd_hpp_hist = cu.get_from_tfile(qcd_hpp_file, histname)
conts = [
Contribution(data_hist,
label="Data",
line_color=ROOT.kBlack,
marker_size=0,
marker_color=ROOT.kBlack),
Contribution(qcd_hist,
label="QCD MG+PYTHIA8 MC",
line_color=qgc.QCD_COLOUR,
subplot=data_hist,
marker_size=0,
marker_color=qgc.QCD_COLOUR),
Contribution(qcd_py_hist,
label="QCD PYTHIA8 MC",
line_color=qgc.QCD_COLOURS[2],
subplot=data_hist,
marker_size=0,
marker_color=qgc.QCD_COLOURS[2]),
# Contribution(qcd_hpp_hist, label="QCD HERWIG++ MC", line_color=qgc.HERWIGPP_QCD_COLOUR, subplot=data_hist, marker_size=0, marker_color=qgc.HERWIGPP_QCD_COLOUR),
]
plot = Plot(conts,
what='hist',
ytitle="N",
xtitle="p_{T}^{Leading jet} [GeV]",
subplot_type="ratio",
subplot_title="Simulation / data",
ylim=[1E3, None],
lumi=cu.get_lumi_str(do_dijet=True, do_zpj=False),
**plot_kwargs)
plot.y_padding_max_log = 500
plot.legend.SetX1(0.55)
plot.legend.SetX2(0.98)
plot.legend.SetY1(0.7)
# plot.legend.SetY2(0.88)
plot.plot("NOSTACK HIST E")
plot.set_logx(do_more_labels=True, do_exponent=False)
plot.set_logy(do_more_labels=False)
plot.save(output_filename)
def do_weight_vs_var_plot_per_pt(histname, input_filename, output_filename):
ROOT.gStyle.SetPalette(palette_2D)
tf = cu.open_root_file(input_filename)
h3d = cu.get_from_tfile(tf, histname)
if h3d.GetEntries() == 0:
return
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
canv.SetTicks(1, 1)
canv.SetLeftMargin(0.1)
canv.SetRightMargin(0.15)
canv.SetLogz()
weight_str = "(unweighted)" if "unweighted" in histname else "(weighted)"
for ibin in range(1, h3d.GetNbinsY()+1):
h3d.GetYaxis().SetRange(ibin, ibin+1)
h2d = h3d.Project3D("xz")
if h2d.GetEntries() == 0:
continue
pt_low = h3d.GetYaxis().GetBinLowEdge(ibin)
pt_high = h3d.GetYaxis().GetBinLowEdge(ibin+1)
jet_str = pt_genjet_str if "_vs_pt_genjet_vs_" in histname else pt_str
h2d.SetTitle("%g < %s < %g GeV %s" % (pt_low, jet_str, pt_high, weight_str))
h2d.GetXaxis().SetTitle(get_var_str(histname))
h2d.Draw("COLZ")
jet_app = "_genjet" if "_vs_pt_genjet_vs" in histname else ""
this_output_filename = output_filename.replace(".pdf", "_pt%s%gto%g.pdf" % (jet_app, pt_low, pt_high))
canv.SaveAs(this_output_filename)
canv.Clear()
tf.Close()
def do_mc_pt_comparison_plot(dirname_label_pairs, output_filename,
qcd_filename, **plot_kwargs):
# qcd_files = [cu.open_root_file(os.path.join(dl[0], qgc.QCD_FILENAME)) for dl in dirname_label_pairs]
qcd_files = [
cu.open_root_file(os.path.join(dl[0], qgc.QCD_PYTHIA_ONLY_FILENAME))
for dl in dirname_label_pairs
]
histname = "Dijet_tighter/pt_jet1"
qcd_hists = [cu.get_from_tfile(qf, histname) for qf in qcd_files]
N = len(dirname_label_pairs)
conts = [
Contribution(qcd_hists[i],
label=lab,
marker_color=cu.get_colour_seq(i, N),
line_color=cu.get_colour_seq(i, N),
line_style=(i % 3) + 1,
line_width=2,
rebin_hist=1,
subplot=qcd_hists[0] if i != 0 else None)
for i, (d, lab) in enumerate(dirname_label_pairs)
]
plot = Plot(conts,
what='hist',
ytitle="N",
subplot_limits=(0.5, 1.5),
subplot_type="ratio",
subplot_title="* / %s" % (dirname_label_pairs[0][1]),
**plot_kwargs)
plot.y_padding_max_log = 500
plot.legend.SetY1(0.7)
plot.plot("NOSTACK HIST E")
plot.set_logx(do_more_labels=False)
plot.set_logy(do_more_labels=False)
plot.save(output_filename)
def do_dijet_gen_distributions(root_dir):
"""Do plots comparing different different inputs in dijet region"""
root_files = [
qgc.QCD_FILENAME, qgc.QCD_PYTHIA_ONLY_FILENAME, qgc.QCD_HERWIG_FILENAME
][:]
root_files = [
cu.open_root_file(os.path.join(root_dir, r)) for r in root_files
]
directories = [
cu.get_from_tfile(rf, "Dijet_tighter") for rf in root_files[:]
]
mc_col = qgc.QCD_COLOUR
mc_col2 = qgc.QCD_COLOURS[2]
mc_col3 = qgc.QCD_COLOURS[3]
msize = 1
lw = 2
csd = [
{
"label": "QCD MC [MG+PY8]",
"line_color": mc_col,
"fill_color": mc_col,
"marker_color": mc_col,
"marker_style": 22,
"fill_style": 0,
"marker_size": msize,
'line_width': lw
},
{
"label": "QCD MC [PY8]",
"line_color": mc_col2,
"fill_color": mc_col2,
"marker_color": mc_col2,
"marker_style": 21,
"fill_style": 0,
"marker_size": msize,
'line_width': lw
},
{
"label": "QCD MC [H++]",
"line_color": mc_col3,
"fill_color": mc_col3,
"marker_color": mc_col3,
"marker_style": 23,
"fill_style": 0,
"marker_size": msize,
'line_width': lw
},
]
jet_config_str = qgc.extract_jet_config(root_dir)
# Compare shapes
do_all_1D_plots_in_dir(directories=directories,
output_dir=os.path.join(
root_dir,
"Dijet_gen_kin_comparison_normalised"),
components_styles_dicts=csd,
jet_config_str=jet_config_str,
normalise_hists=True)
def do_jet_pt_rel_error_with_var_cuts(histname, cuts, input_filename, output_filename):
ROOT.gStyle.SetPalette(palette_1D)
tf = cu.open_root_file(input_filename)
h3d = cu.get_from_tfile(tf, histname)
if h3d.GetEntries() == 0:
return
pt_hists = []
for cut in cuts:
max_bin = h3d.GetZaxis().FindFixBin(cut)
# print("cut:", cut, "bin:", max_bin)
h = h3d.ProjectionY("pt_var_lt_%g" % cut, 0, -1, 0, max_bin, "e")
h2 = h.Clone()
h2.Rebin(2)
if h.GetEntries() > 0:
h3 = qgp.hist_divide_bin_width(h2)
# convert bin contents to bin error/bin contents
for ibin in range(1, h2.GetNbinsX()+1):
if h3.GetBinContent(ibin) == 0:
continue
h3.SetBinContent(ibin, h3.GetBinError(ibin) / h3.GetBinContent(ibin))
h3.SetBinError(ibin, 0)
pt_hists.append(h3)
line_styles = [1, 2, 3]
n_line_styles = len(line_styles)
conts = [Contribution(h, label=" < %g" % cut,
line_color=cu.get_colour_seq(ind, len(cuts)),
line_style=line_styles[ind % n_line_styles],
line_width=2,
marker_color=cu.get_colour_seq(ind, len(cuts)),
subplot=pt_hists[-1])
for ind, (h, cut) in enumerate(zip(pt_hists, cuts))]
jet_str = pt_genjet_str if "_vs_pt_genjet_vs_" in histname else pt_str
weight_str = "(unweighted)" if "unweighted" in histname else "(weighted)"
ratio_lims = (0.98, 1.02) if "unweighted" in histname else None
plot = Plot(conts, what='hist',
title='%s for cuts on %s %s' % (jet_str, get_var_str(histname), weight_str),
xtitle=None,
ytitle='Relative error',
# xlim=None, ylim=None,
legend=True,
subplot_type='ratio',
subplot_title='* / var < %g' % cuts[-1],
subplot_limits=ratio_lims,
has_data=False)
plot.y_padding_max_log = 200
plot.subplot_maximum_ceil = 2
plot.subplot_maximum_floor = 1.02
plot.subplot_minimum_ceil = 0.98
plot.legend.SetY1(0.7)
plot.legend.SetY2(0.89)
plot.legend.SetX1(0.78)
plot.legend.SetX2(0.88)
plot.plot("NOSTACK HISTE", "NOSTACK HIST")
plot.set_logx(True, do_more_labels=True)
plot.set_logy(True, do_more_labels=False)
plot.save(output_filename)
def do_jet_pt_vs_genht_plot(dirname, output_filename, title=""):
"""2D heat map of genHT vs jet pt"""
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
qcd_file = cu.open_root_file(os.path.join(dirname, qgc.QCD_FILENAME))
histname = "Dijet_tighter/pt_jet_vs_genHT"
canv.SetRightMargin(0.15)
h = cu.get_from_tfile(qcd_file, histname)
h.SetTitle(title + ";p_{T}^{Leading jet} [GeV]; H_{T}^{Gen} [GeV]")
h.Draw("COLZ")
h.GetXaxis().SetRangeUser(0, 200)
h.GetYaxis().SetRangeUser(0, 200)
canv.SaveAs(output_filename)
def grab_obj(file_name, obj_name):
"""Get object names obj_name from ROOT file file_name"""
# TODO: checks!
input_file = cu.open_root_file(file_name)
obj = cu.get_from_tfile(input_file, obj_name)
# print("Getting", obj_name, "from", file_name)
if isinstance(obj, (ROOT.TH1, ROOT.TGraph)):
obj.SetDirectory(0) # Ownership kludge
input_file.Close()
return obj.Clone(ROOT.TUUID().AsString())
else:
return obj
def do_genht_plot(dirname, output_filename, **plot_kwargs):
qcd_file = cu.open_root_file(os.path.join(dirname, qgc.QCD_FILENAME))
histname = "Dijet_gen/gen_ht"
qcd_hist = cu.get_from_tfile(qcd_file, histname)
conts = [Contribution(qcd_hist, label="QCD MC", line_color=ROOT.kRed)]
plot = Plot(conts, what='hist', ytitle="N", **plot_kwargs)
plot.y_padding_max_log = 500
plot.legend.SetY1(0.7)
plot.plot("NOSTACK HIST E")
plot.set_logx(do_more_labels=False)
plot.set_logy(do_more_labels=False)
plot.save(output_filename)
def grab_obj(file_name, obj_name):
"""Get object names obj_name from ROOT file file_name"""
# TODO: checks!
input_file = cu.open_root_file(file_name)
obj = cu.get_from_tfile(input_file, obj_name)
# print("Getting", obj_name, "from", file_name)
if isinstance(obj, (ROOT.TH1, ROOT.TGraph, ROOT.TH2)):
# THIS ORDER IS VERY IMPORTANT TO AVOID MEMORY LEAKS
new_obj = obj.Clone(ROOT.TUUID().AsString())
new_obj.SetDirectory(0)
input_file.Close()
return new_obj
else:
return obj
def do_plot(entries, output_file, hist_name=None, xlim=None, ylim=None, rebin=2, is_data=True, is_ak8=False):
components = []
do_unweighted = any(["unweighted" in e.get('hist_name', hist_name) for e in entries])
for ent in entries:
if 'tfile' not in ent:
ent['tfile'] = cu.open_root_file(ent['filename'])
ent['hist'] = cu.get_from_tfile(ent['tfile'], ent.get('hist_name', hist_name))
if not do_unweighted and 'scale' in ent:
ent['hist'].Scale(ent.get('scale', 1))
components.append(
Contribution(ent['hist'],
fill_color=ent['color'],
line_color=ent['color'],
marker_color=ent['color'],
marker_size=0,
line_width=2,
label=ent['label'],
rebin_hist=rebin
)
)
# print stats
print(ent['hist_name'], ent['label'], ent['hist'].Integral())
title = 'AK8 PUPPI' if is_ak8 else 'AK4 PUPPI'
plot = Plot(components,
what='hist',
has_data=is_data,
title=title,
xlim=xlim,
ylim=ylim,
xtitle="p_{T}^{jet 1} [GeV]",
ytitle="Unweighted N" if do_unweighted else 'N')
# plot.y_padding_min_log = 10 if 'unweighted' in hist_name else 10
plot.default_canvas_size = (700, 600)
plot.legend.SetNColumns(2)
plot.legend.SetX1(0.55)
plot.legend.SetY1(0.7)
plot.legend.SetY2(0.88)
plot.plot("HISTE")
plot.set_logx()
plot.set_logy(do_more_labels=False)
plot.save(output_file)
# do non-stacked version
stem, ext = os.path.splitext(output_file)
plot.plot("HISTE NOSTACK")
plot.set_logx()
plot.set_logy(do_more_labels=False)
plot.save(stem+"_nostack" + ext)
def do_weight_vs_pt_plot(input_filename, output_filename):
ROOT.gStyle.SetPalette(palette_2D)
histname = "Weight_Presel/weight_vs_pt_vs_pt_jet_qScale_ratio"
tf = cu.open_root_file(input_filename)
h3d = cu.get_from_tfile(tf, histname)
if h3d.GetEntries() == 0:
return
h2d = h3d.Project3D("xy")
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
canv.SetTicks(1, 1)
canv.SetLeftMargin(0.1)
canv.SetRightMargin(0.15)
canv.SetLogz()
canv.SetLogx()
h2d.Draw("COLZ")
canv.SaveAs(output_filename)
tf.Close()
def do_jet_index_plots(tdir, plot_dir):
"""Do 2D plots of genjet index vs recojet index"""
plot_dir = os.path.join(plot_dir, tdir.GetName())
cu.check_dir_exists_create(plot_dir)
stem = "genjet_ind_recojet_ind_pt_"
for plot_name in cu.get_list_of_element_names(tdir):
if not plot_name.startswith(stem):
continue
h2d = cu.get_from_tfile(tdir, plot_name)
h2d.SetTitle(h2d.GetTitle())
renorm_h2d = cu.make_normalised_TH2(h2d, 'X', recolour=False)
# renorm_h2d = h2d
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
pad = ROOT.gPad
pad.SetBottomMargin(0.12)
pad.SetLeftMargin(0.13)
pad.SetRightMargin(0.12)
canv.SetTicks(1, 1)
renorm_h2d.Draw("COLZ TEXT")
renorm_h2d.SetMaximum(1)
renorm_h2d.SetMinimum(0)
title_offset = 1.5
renorm_h2d.SetTitleOffset(title_offset, 'X')
renorm_h2d.SetTitleOffset(title_offset * 1.15, 'Y')
canv.SaveAs(
os.path.join(plot_dir,
"%s_renormX_linZ.%s" % (plot_name, OUTPUT_FMT)))
# canv.SetLogz()
# renorm_h2d.SetMinimum(1E-3)
# canv.SaveAs(os.path.join(plot_dir, "%s_renormX_logZ.%s" % (plot_name, OUTPUT_FMT)))
canv.Clear()
renorm_h2d = cu.make_normalised_TH2(h2d, 'Y', recolour=False)
renorm_h2d.Draw("COLZ TEXT")
renorm_h2d.SetMaximum(1)
renorm_h2d.SetMinimum(0)
title_offset = 1.5
renorm_h2d.SetTitleOffset(title_offset, 'X')
renorm_h2d.SetTitleOffset(title_offset * 1.15, 'Y')
canv.SaveAs(
os.path.join(plot_dir,
"%s_renormY_linZ.%s" % (plot_name, OUTPUT_FMT)))
def do_pthat_comparison_plot(dirname_label_pairs, output_filename,
**plot_kwargs):
qcd_files = [
cu.open_root_file(os.path.join(dl[0], qgc.QCD_PYTHIA_ONLY_FILENAME))
for dl in dirname_label_pairs
]
histname = "Dijet_gen/ptHat"
qcd_hists = [cu.get_from_tfile(qf, histname) for qf in qcd_files]
N = len(dirname_label_pairs)
pthat_rebin = array('d', [
15, 30, 50, 80, 120, 170, 300, 470, 600, 800, 1000, 1400, 1800, 2400,
3200, 5000
])
nbins = len(pthat_rebin) - 1
qcd_hists = [
h.Rebin(nbins, cu.get_unique_str(), pthat_rebin) for h in qcd_hists
]
conts = [
Contribution(qcd_hists[i],
label=lab,
marker_color=cu.get_colour_seq(i, N),
line_color=cu.get_colour_seq(i, N),
line_style=i + 1,
line_width=2,
subplot=qcd_hists[0] if i != 0 else None)
for i, (d, lab) in enumerate(dirname_label_pairs)
]
plot = Plot(conts,
what='hist',
ytitle="N",
subplot_limits=(0.75, 1.25),
subplot_type="ratio",
subplot_title="* / %s" % (dirname_label_pairs[0][1]),
**plot_kwargs)
plot.y_padding_max_log = 500
plot.legend.SetY1(0.7)
plot.plot("NOSTACK HIST E")
plot.set_logx(do_more_labels=False)
plot.set_logy(do_more_labels=False)
plot.save(output_filename)
def do_weight_vs_var_plot(histname, input_filename, output_filename):
ROOT.gStyle.SetPalette(palette_2D)
tf = cu.open_root_file(input_filename)
h3d = cu.get_from_tfile(tf, histname)
if h3d.GetEntries() == 0:
return
h2d = h3d.Project3D("xz")
if "unweighted" in histname:
h2d.SetTitle("Unweighted")
else:
h2d.SetTitle("Weighted")
h2d.GetXaxis().SetTitle(get_var_str(histname))
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
canv.SetTicks(1, 1)
canv.SetLeftMargin(0.1)
canv.SetRightMargin(0.15)
canv.SetLogz()
h2d.Draw("COLZ")
canv.SaveAs(output_filename)
tf.Close()
def do_genht_comparison_plot(dirname_label_pairs, output_filename,
**plot_kwargs):
"""Like do_genht but for multiple samples"""
qcd_files = [
cu.open_root_file(os.path.join(dl[0], qgc.QCD_FILENAME))
for dl in dirname_label_pairs
]
histname = "Dijet_gen/gen_ht"
qcd_hists = [cu.get_from_tfile(qf, histname) for qf in qcd_files]
N = len(dirname_label_pairs)
conts = [
Contribution(qcd_hists[i],
label=lab,
marker_color=cu.get_colour_seq(i, N),
line_color=cu.get_colour_seq(i, N),
line_style=i + 1,
line_width=2,
subplot=qcd_hists[0] if i != 0 else None)
for i, (d, lab) in enumerate(dirname_label_pairs)
]
plot = Plot(
conts,
what='hist',
ytitle="N",
# subplot_limits=(0.75, 1.25),
subplot_type="ratio",
subplot_title="* / %s" % (dirname_label_pairs[0][1]),
ylim=[1E6, None],
**plot_kwargs)
plot.y_padding_max_log = 500
plot.legend.SetY1(0.7)
plot.subplot_maximum_ceil = 5
plot.plot("NOSTACK HIST E")
plot.set_logx(do_more_labels=False)
plot.set_logy(do_more_labels=False)
plot.save(output_filename)
def do_pt_transfer_plot(tdir, plot_dir):
"""Plot ratio between pt bins of the spectrum. Check to make sure xfer factor << drop in pt"""
plot_dir = os.path.join(plot_dir, tdir.GetName())
cu.check_dir_exists_create(plot_dir)
hist_name = "pt_jet_response_binning"
h = cu.get_from_tfile(tdir, hist_name)
binning = [
h.GetXaxis().GetBinLowEdge(bin_ind)
for bin_ind in range(1,
h.GetNbinsX() + 1)
]
hist_factors = ROOT.TH1F(
"hist_factors" + cu.get_unique_str(),
";p_{T}^{Reco} [GeV];Fraction rel to previous bin",
len(binning) - 1, array('d', binning))
for bin_ind in range(2, h.GetNbinsX() + 1):
cont = h.GetBinContent(bin_ind)
cont_prev = h.GetBinContent(bin_ind - 1)
if cont == 0 or cont_prev == 0:
continue
factor = cont / cont_prev
hist_factors.SetBinContent(bin_ind, factor)
hist_factors.SetBinError(bin_ind, 0)
col_purity = ROOT.kBlack
conts = [
Contribution(hist_factors,
label="Factor relative to previous bin",
line_color=col_purity,
marker_color=col_purity),
# Contribution(hist_purity, label="Purity (gen in right bin)", line_color=col_purity, marker_color=col_purity),
]
xlim = [30, binning[-1]]
plot = Plot(conts, what='hist', xlim=xlim)
plot.plot()
plot.set_logx()
plot.save(os.path.join(plot_dir, 'pt_migration_factors.%s' % (OUTPUT_FMT)))
def do_jet_pt_with_var_cuts(histname, cuts, input_filename, output_filename):
ROOT.gStyle.SetPalette(palette_1D)
total = len(cuts) - 1 + .1 # slight offset to not hit the maximum or minimum
# if len(cuts) <= 3:
# ROOT.gStyle.SetPalette(ROOT.kCool)
# num_colours = ROOT.TColor.GetPalette().fN - 1
# print('num_colours:', num_colours)
# for index in range(len(cuts)):
# print(num_colours, index, len(cuts), index / len(cuts), num_colours * index / total)
# print(index, ROOT.TColor.GetColorPalette(int(num_colours * 1. * index / total)))
tf = cu.open_root_file(input_filename)
h3d = cu.get_from_tfile(tf, histname)
if h3d.GetEntries() == 0:
return
pt_hists = []
for cut in cuts:
max_bin = h3d.GetZaxis().FindFixBin(cut)
# print("cut:", cut, "bin:", max_bin)
h = h3d.ProjectionY("pt_var_lt_%g" % cut, 0, -1, 0, max_bin, "e")
h2 = h.Clone()
h2.Rebin(2)
if h.GetEntries() > 0:
h3 = qgp.hist_divide_bin_width(h2)
pt_hists.append(h3)
line_styles = [1, 2, 3]
if len(cuts) <= 3:
line_styles = [1]
n_line_styles = len(line_styles)
ref_ind = 0
conts = [Contribution(h, label=" < %g" % cut,
line_color=cu.get_colour_seq(ind, total),
line_style=line_styles[ind % n_line_styles],
line_width=2,
marker_color=cu.get_colour_seq(ind, total),
subplot=pt_hists[ref_ind] if ind != ref_ind else None)
for ind, (h, cut) in enumerate(zip(pt_hists, cuts))]
jet_str = pt_genjet_str if "_vs_pt_genjet_vs_" in histname else pt_str
weight_str = "(unweighted)" if "unweighted" in histname else "(weighted)"
ratio_lims = (0.5, 2.5)
ratio_lims = (0.5, 1.1)
plot = Plot(conts, what='hist',
title='%s for cuts on %s %s' % (jet_str, get_var_str(histname), weight_str),
xtitle=None,
ytitle='N',
# xlim=None, ylim=None,
legend=True,
subplot_type='ratio',
subplot_title='* / var < %g' % cuts[ref_ind],
subplot_limits=ratio_lims,
has_data=False)
plot.y_padding_max_log = 200
plot.subplot_maximum_ceil = 4
plot.subplot_maximum_floor = 1.02
plot.subplot_minimum_ceil = 0.98
plot.legend.SetY1(0.7)
plot.legend.SetY2(0.89)
plot.legend.SetX1(0.78)
plot.legend.SetX2(0.88)
plot.plot("NOSTACK HISTE", "NOSTACK HIST")
plot.set_logx(True, do_more_labels=True)
plot.set_logy(True, do_more_labels=False)
plot.save(output_filename)
def do_plots(root_dir):
# QG variable plots
pt_bins = qgc.PT_BINS[:]
var_list = qgc.COMMON_VARS
var_prepend = ""
radius, pus = cu.get_jet_config_from_dirname(root_dir)
jet_str = "AK%s PF %s" % (radius.upper(), pus.upper())
for gr_append in ["", "_groomed"][:1]:
if gr_append == "_groomed":
print("Doing groomed plots...")
else:
print("Doing ungroomed plots...")
zpj_dirname = "ZPlusJets_QG%s" % (gr_append)
dj_cen_dirname = "Dijet_QG_central_tighter%s" % (gr_append)
dj_fwd_dirname = "Dijet_QG_forward_tighter%s" % (gr_append)
# tfiles = {
# "data_run_B": cu.open_root_file(os.path.join(root_dir, "uhh2.AnalysisModuleRunner.DATA.Data_JetHT_RunB.root")),
# "data_run_C": cu.open_root_file(os.path.join(root_dir, "uhh2.AnalysisModuleRunner.DATA.Data_JetHT_RunC.root")),
# "data_run_D": cu.open_root_file(os.path.join(root_dir, "uhh2.AnalysisModuleRunner.DATA.Data_JetHT_RunD.root")),
# "data_run_E": cu.open_root_file(os.path.join(root_dir, "uhh2.AnalysisModuleRunner.DATA.Data_JetHT_RunE.root")),
# "data_run_F": cu.open_root_file(os.path.join(root_dir, "uhh2.AnalysisModuleRunner.DATA.Data_JetHT_RunF.root")),
# "data_run_G": cu.open_root_file(os.path.join(root_dir, "uhh2.AnalysisModuleRunner.DATA.Data_JetHT_RunG.root")),
# "data_run_H": cu.open_root_file(os.path.join(root_dir, "uhh2.AnalysisModuleRunner.DATA.Data_JetHT_RunH.root")),
# }
tfiles = {
"data_run_B":
cu.open_root_file(
os.path.join(
root_dir,
"uhh2.AnalysisModuleRunner.DATA.Data_JetHT_ZeroBias_RunB.root"
)),
"data_run_C":
cu.open_root_file(
os.path.join(
root_dir,
"uhh2.AnalysisModuleRunner.DATA.Data_JetHT_ZeroBias_RunC.root"
)),
"data_run_D":
cu.open_root_file(
os.path.join(
root_dir,
"uhh2.AnalysisModuleRunner.DATA.Data_JetHT_ZeroBias_RunD.root"
)),
"data_run_E":
cu.open_root_file(
os.path.join(
root_dir,
"uhh2.AnalysisModuleRunner.DATA.Data_JetHT_ZeroBias_RunE.root"
)),
"data_run_F":
cu.open_root_file(
os.path.join(
root_dir,
"uhh2.AnalysisModuleRunner.DATA.Data_JetHT_ZeroBias_RunF.root"
)),
"data_run_G":
cu.open_root_file(
os.path.join(
root_dir,
"uhh2.AnalysisModuleRunner.DATA.Data_JetHT_ZeroBias_RunG.root"
)),
"data_run_H":
cu.open_root_file(
os.path.join(
root_dir,
"uhh2.AnalysisModuleRunner.DATA.Data_JetHT_ZeroBias_RunH.root"
)),
}
for ang in var_list[:]:
print("...Doing", ang.name)
v = "%s%s_vs_pt" % (var_prepend, ang.var)
zpj_1d_entries = []
dijet_cen_1d_entries = []
dijet_fwd_1d_entries = []
for pt_ind, (start_val, end_val) in enumerate(pt_bins):
entries = []
zpj_entries = []
dijet_cen_entries = []
dijet_fwd_entries = []
# Get all plots
lw = 2
msize = 1.1
data_line_width = lw
colours = [
ROOT.kBlack, ROOT.kRed, ROOT.kBlue, ROOT.kGreen + 2,
ROOT.kOrange + 1, ROOT.kAzure + 1, ROOT.kGreen + 3
]
# --------------------------------------------------------------
# Create reference hists, for Run G+H
# --------------------------------------------------------------
####################
# DIJET CENTRAL REGION
####################
h2d_qcd_cen_data_g = cu.get_from_tfile(
tfiles['data_run_G'], "%s/%s" % (dj_cen_dirname, v))
h2d_qcd_cen_data_h = cu.get_from_tfile(
tfiles['data_run_H'], "%s/%s" % (dj_cen_dirname, v))
colour = colours[0]
qcd_cen_kwargs_data = dict(line_color=colour,
line_width=data_line_width,
fill_color=colour,
marker_color=colour,
marker_style=cu.Marker.get(
qgc.QCD_MARKER),
marker_size=0,
label="Runs G+H")
dijet_cen_data_hist_g = qgp.get_projection_plot(
h2d_qcd_cen_data_g, start_val, end_val)
dijet_cen_data_hist_h = qgp.get_projection_plot(
h2d_qcd_cen_data_h, start_val, end_val)
dijet_cen_data_hist_g.Add(dijet_cen_data_hist_h)
dijet_cen_entries.append(
(dijet_cen_data_hist_g, qcd_cen_kwargs_data))
####################
# DIJET FORWARD REGION
####################
h2d_qcd_fwd_data_g = cu.get_from_tfile(
tfiles['data_run_G'], "%s/%s" % (dj_fwd_dirname, v))
h2d_qcd_fwd_data_h = cu.get_from_tfile(
tfiles['data_run_H'], "%s/%s" % (dj_fwd_dirname, v))
qcd_fwd_kwargs_data = dict(line_color=colour,
line_width=data_line_width,
fill_color=colour,
marker_color=colour,
marker_style=cu.Marker.get(
qgc.QCD_MARKER),
marker_size=0,
label="Runs G+H")
dijet_fwd_data_hist_g = qgp.get_projection_plot(
h2d_qcd_fwd_data_g, start_val, end_val)
dijet_fwd_data_hist_h = qgp.get_projection_plot(
h2d_qcd_fwd_data_h, start_val, end_val)
dijet_fwd_data_hist_g.Add(dijet_fwd_data_hist_h)
dijet_fwd_entries.append(
(dijet_fwd_data_hist_g, qcd_fwd_kwargs_data))
# --------------------------------------------------------------
# FOR SUMMED B-F:
# --------------------------------------------------------------
dijet_cen_data_hist_btof, dijet_fwd_data_hist_btof = None, None
runs = ["B", "C", "D", "E", "F"]
for run in runs:
# DIJET CENTRAL REGION
h2d_qcd_cen_data = cu.get_from_tfile(
tfiles['data_run_%s' % run],
"%s/%s" % (dj_cen_dirname, v))
this_dijet_cen_data_hist = qgp.get_projection_plot(
h2d_qcd_cen_data, start_val, end_val)
if dijet_cen_data_hist_btof is None:
dijet_cen_data_hist_btof = this_dijet_cen_data_hist.Clone(
)
else:
dijet_cen_data_hist_btof.Add(this_dijet_cen_data_hist)
# DIJET FORWARD REGION
h2d_qcd_fwd_data = cu.get_from_tfile(
tfiles['data_run_%s' % run], "%s/%s" %
(dj_fwd_dirname, v)) # use already merged jetht+zb
this_dijet_fwd_data_hist = qgp.get_projection_plot(
h2d_qcd_fwd_data, start_val, end_val)
if dijet_fwd_data_hist_btof is None:
dijet_fwd_data_hist_btof = this_dijet_fwd_data_hist.Clone(
)
else:
dijet_fwd_data_hist_btof.Add(this_dijet_fwd_data_hist)
colour = colours[1]
mark = cu.Marker.get('circle')
btof_cen_kwargs_data = dict(line_color=colour,
line_width=data_line_width,
fill_color=colour,
marker_color=colour,
marker_style=mark,
marker_size=msize,
label="Runs %s-%s" %
(runs[0], runs[-1]),
subplot=dijet_cen_data_hist_g)
dijet_cen_entries.append(
(dijet_cen_data_hist_btof, btof_cen_kwargs_data))
btof_fwd_kwargs_data = dict(line_color=colour,
line_width=data_line_width,
fill_color=colour,
marker_color=colour,
marker_style=mark,
marker_size=msize,
label="Runs %s-%s" %
(runs[0], runs[-1]),
subplot=dijet_fwd_data_hist_g)
dijet_fwd_entries.append(
(dijet_fwd_data_hist_btof, btof_fwd_kwargs_data))
# FOR INDIVIDUAL RUN PERIODS:
# runs = ["B", "C", "D", "E", "F"]
# for run, colour, mark in zip(runs, colours[1:], cu.Marker().cycle()):
# ####################
# # DIJET CENTRAL REGION
# ####################
# # JETHT DATA
# h2d_qcd_cen_data = cu.get_from_tfile(tfiles['data_run_%s' % run], "%s/%s" % (dj_cen_dirname, v))
# qcd_cen_kwargs_data = dict(line_color=colour, line_width=data_line_width, fill_color=colour,
# marker_color=colour, marker_style=mark, marker_size=msize,
# label="Run %s" % run,
# subplot=dijet_cen_data_hist_g)
# dijet_cen_data_hist = qgp.get_projection_plot(h2d_qcd_cen_data, start_val, end_val)
# dijet_cen_entries.append((dijet_cen_data_hist, qcd_cen_kwargs_data))
# ####################
# # DIJET FORWARD REGION
# ####################
# # JETHT DATA
# h2d_qcd_fwd_data = cu.get_from_tfile(tfiles['data_run_%s' % run], "%s/%s" % (dj_fwd_dirname, v)) # use already merged jetht+zb
# qcd_fwd_kwargs_data = dict(line_color=colour, line_width=data_line_width, fill_color=colour,
# marker_color=colour, marker_style=mark, marker_size=msize,
# label="Run %s" % run,
# subplot=dijet_fwd_data_hist_g)
# dijet_fwd_data_hist = qgp.get_projection_plot(h2d_qcd_fwd_data, start_val, end_val)
# dijet_fwd_entries.append((dijet_fwd_data_hist, qcd_fwd_kwargs_data))
# ####################
# # Z+JETS REGION
# ####################
# # SINGLE MU DATA
# # h2d_dyj_data = cu.get_from_tfile(os.path.join(root_dir, "uhh2.AnalysisModuleRunner.DATA.Data_SingleMu_Run%s.root" % run), "%s/%s" % (zpj_dirname, v))
# # dy_kwargs_data = dict(line_color=qgc.colour, line_width=data_line_width, fill_color=qgc.colour,
# # marker_color=qgc.colour, marker_style=cu.Marker.get(qgc.DY_MARKER), marker_size=msize,
# # label="SingleMu Run %s" % run)
# # zpj_data_hist = qgp.get_projection_plot(h2d_dyj_data, start_val, end_val)
# # zpj_entries.append((zpj_data_hist, dy_kwargs_data))
#################
# SETUP PLOTTING
#################
rebin = 2
v_lower = v.lower()
if "multiplicity" in v_lower:
rebin = 2
elif "flavour" in v_lower or "thrust" in v_lower:
rebin = 1
elif 'ptd' in v_lower:
rebin = 2
xlim = None
if "width" in v_lower or "ptd" in v_lower:
xlim = (0, 1)
elif "thrust" in v_lower:
xlim = (0, 0.5)
elif "multiplicity" in v_lower and "ak4" in root_dir.lower():
if end_val <= 150:
xlim = (0, 50)
else:
xlim = (0, 80)
ylim = None
if "flavour" in v_lower:
ylim = (0, 1)
# elif "lha" in v_lower:
# ylim = (0, 5)
plot_dir = os.path.join(root_dir,
"plots_run_dependent%s" % (gr_append))
plot_dir = os.path.join(
root_dir, "plots_run_dependent_btof%s" % (gr_append))
subplot_title = "Run * / G+H"
subplot_title = "B-F / G+H"
subplot_limits = (0.5, 1.5)
xlabel = ang.name + " (" + ang.lambda_str + ")"
if gr_append is not "":
xlabel = "Groomed " + ang.name + " (" + ang.lambda_str + ")"
# dj central only
dijet_cen_entries = dijet_cen_entries[1:] + dijet_cen_entries[
0:1] # move G+H to last
qgp.do_comparison_plot(
dijet_cen_entries,
"%s/ptBinned/%s_pt%dto%d_dijet_central.%s" %
(plot_dir, v, start_val, end_val, OUTPUT_FMT),
rebin=rebin,
title="%d < p_{T}^{jet} < %d GeV\n%s\n%s" %
(start_val, end_val, jet_str, qgc.Dijet_CEN_LABEL),
xtitle=xlabel,
xlim=xlim,
ylim=ylim,
subplot_type='ratio',
subplot_title=subplot_title,
subplot_limits=subplot_limits)
# dj forward only
dijet_fwd_entries = dijet_fwd_entries[1:] + dijet_fwd_entries[
0:1] # move G+H to last
qgp.do_comparison_plot(
dijet_fwd_entries,
"%s/ptBinned/%s_pt%dto%d_dijet_forward.%s" %
(plot_dir, v, start_val, end_val, OUTPUT_FMT),
rebin=rebin,
title="%d < p_{T}^{jet} < %d GeV\n%s\n%s" %
(start_val, end_val, jet_str, qgc.Dijet_FWD_LABEL),
xtitle=xlabel,
xlim=xlim,
ylim=ylim,
subplot_type='ratio',
subplot_title=subplot_title,
subplot_limits=subplot_limits)
def do_var_vs_pt_plot(histname, input_filename, output_filename):
ROOT.gStyle.SetPalette(palette_2D)
tf = cu.open_root_file(input_filename)
h3d = cu.get_from_tfile(tf, histname)
if h3d.GetEntries() == 0:
return
h2d = h3d.Project3D("zy")
xlabel = h2d.GetXaxis().GetTitle()
ylabel = h2d.GetYaxis().GetTitle()
ylabel = get_var_str(histname)
# find largest var value (ie row) that has a filled bin
h2d_ndarray = cu.th2_to_ndarray(h2d)[0]
xbins = np.array(cu.get_bin_edges(h2d, 'x'))
ybins = np.array(cu.get_bin_edges(h2d, 'y'))
# remove dodgy bins with 0 width cos I was an idiot and duplicated some bins
n_deleted = 0
# weight bin
# xax = h2d.GetXaxis()
# for ix in range(1, h2d.GetNbinsX()+1):
# if xax.GetBinWidth(ix) == 0:
# h2d_ndarray = np.delete(h2d_ndarray, ix-1-n_deleted, axis=1)
# xbins = np.delete(xbins, ix-1-n_deleted, axis=0)
# n_deleted += 1
# print("Deleting bin", ix)
# pt bin
# n_deleted = 0
# yax = h2d.GetYaxis()
# for iy in range(1, h2d.GetNbinsY()+1):
# if yax.GetBinWidth(iy) == 0:
# h2d_ndarray = np.delete(h2d_ndarray, iy-1-n_deleted, axis=0)
# ybins = np.delete(ybins, iy-1-n_deleted, axis=0)
# n_deleted += 1
# print("Deleting bin", iy)
# nonzero returns (row #s)(col #s) of non-zero elements
# we only want the largest row #
max_filled_row_ind = int(np.nonzero(h2d_ndarray)[0].max())
h2d = cu.ndarray_to_th2(h2d_ndarray, binsx=xbins, binsy=ybins)
if "unweighted" in histname:
h2d.SetTitle("Unweighted;%s;%s" % (xlabel, ylabel))
else:
h2d.SetTitle("Weighted;%s;%s" % (xlabel, ylabel))
h2d.GetYaxis().SetRange(1, max_filled_row_ind+2) # +1 as ROOT 1-indexed, +1 for padding
h2d.GetYaxis().SetTitle(get_var_str(histname))
xmin = 15 if "pt_genjet_vs" in histname else 30
xmax = 300
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
canv.SetTicks(1, 1)
canv.SetLeftMargin(0.12)
canv.SetRightMargin(0.15)
# canv.SetLogz()
# canv.SetLogy()
h2d_copy = h2d.Clone()
# h2d_copy.Scale(1, "width")
h2d_copy.Draw("COLZ")
canv.SetLogx()
h2d_copy.GetXaxis().SetMoreLogLabels()
canv.SaveAs(output_filename)
zoom_ymin, zoom_ymax = 0.1, 5
h2d_copy.SetAxisRange(zoom_ymin, zoom_ymax,"Y")
h2d_copy.SetAxisRange(xmin, xmax, "X")
canv.SaveAs(output_filename.replace(".pdf", "_zoomY.pdf"))
canv.SetLogz()
canv.SaveAs(output_filename.replace(".pdf", "_zoomY_logZ.pdf"))
canv.SetLogz(False)
# h2d.Scale(1, "width")
h2d_normed = cu.make_normalised_TH2(h2d, norm_axis='x', recolour=True)
h2d_normed.Draw("COLZ")
h2d_normed.GetXaxis().SetMoreLogLabels()
# h2d_normed.SetMinimum(1E-5)
h2d_normed.SetAxisRange(xmin, xmax, "X")
canv.SaveAs(output_filename.replace(".pdf", "_normX.pdf"))
h2d_normed.SetAxisRange(zoom_ymin, zoom_ymax,"Y")
canv.SaveAs(output_filename.replace(".pdf", "_normX_zoomY.pdf"))
# Do cumulative plot per column (ie fraction of events passing cut < y)
h2d_ndarray_cumsum = h2d_ndarray.cumsum(axis=0)
nonzero_mask = h2d_ndarray_cumsum[-1] > 0
h2d_ndarray_cumsum[:, nonzero_mask] /= h2d_ndarray_cumsum[-1][nonzero_mask] # scale so total is 1
h2d_cumsum = cu.ndarray_to_th2(h2d_ndarray_cumsum, binsx=xbins, binsy=ybins)
# Get max row ind
max_filled_row_ind = int(h2d_ndarray_cumsum.argmax(axis=0).max())
h2d_cumsum.GetYaxis().SetRange(1, max_filled_row_ind+1) # +1 as ROOT 1-indexed
# ROOT.gStyle.SetPalette(ROOT.kBird)
ylabel = "Fraction of events with " + ylabel + " < y"
if "unweighted" in histname:
h2d_cumsum.SetTitle("Unweighted;%s;%s" % (xlabel, ylabel))
else:
h2d_cumsum.SetTitle("Weighted;%s;%s" % (xlabel, ylabel))
canv.Clear()
canv.SetLogz(False)
h2d_cumsum.SetContour(20)
h2d_cumsum.Draw("CONT1Z")
h2d_cumsum.SetAxisRange(xmin, xmax, "X")
canv.SetLogx()
h2d_cumsum.GetXaxis().SetMoreLogLabels()
canv.SaveAs(output_filename.replace(".pdf", "_cumulY.pdf"))
h2d_cumsum.SetAxisRange(zoom_ymin, zoom_ymax,"Y")
canv.SaveAs(output_filename.replace(".pdf", "_cumulY_zoomY.pdf"))
canv.Clear()
h2d_normed.Draw("COL")
h2d_cumsum.Draw("CONT1Z SAME")
h2d_cumsum.SetAxisRange(xmin, xmax, "X")
canv.SetLogx()
h2d_cumsum.GetXaxis().SetMoreLogLabels()
canv.SaveAs(output_filename.replace(".pdf", "_cumulY_normX.pdf"))
h2d_cumsum.SetAxisRange(zoom_ymin, zoom_ymax,"Y")
canv.SaveAs(output_filename.replace(".pdf", "_cumulY_normX_zoomY.pdf"))
tf.Close()
def do_all_2d_plots(tfile, output_dir):
rebin = 2
hist_dicts = [
{
"hname": "JtcefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtcef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtchfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtchf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtchmultVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtchmult",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JthfefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jthfef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JthfhfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jthfhf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtmufVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtmuf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtnefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtnef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtnhfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtnhf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtnmultVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtnmult",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefcefRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefcefRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefchfRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefchfRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefchmultRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefchmultRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefmufRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefmufRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefnefRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefnefRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefnhfRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefnhfRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefnmultRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefnmultRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefcefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refcef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefchfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refchf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefchmultVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refchmult",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefmufVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refmuf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefnefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refnef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefnhfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refnhf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefnmultVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refnmult",
"rebinx": rebin,
"rebiny": rebin,
},
]
for hdict in hist_dicts:
for renorm in ['', 'X', 'Y']:
h2d = cu.get_from_tfile(tfile, "ak4pfchs/"+hdict['hname'])
ofile = output_dir+"/"+hdict.get('ofile', hdict['hname'])
if renorm == "X":
ofile += "_renormX"
elif renorm == "Y":
ofile += "_renormY"
ofile +=".pdf"
do_2d_plot(h2d, output_filename=ofile,
renorm=renorm,
logz=hdict.get('logz', False),
xtitle=hdict.get('xtitle', ''), ytitle=hdict.get('ytitle', ''),
rebinx=hdict.get('rebinx', 1), rebiny=hdict.get('rebiny', 1),
)
def make_plot(entries,
output_filename,
plot_kwargs,
projection_axis='x',
start_val=None,
end_val=None,
is_pdgid_plot=False,
logy=False):
"""Make a plot from entries. Each one is a projection of a 2D plot.
Parameters
----------
entries : list[dict]
List of plot entries. Each is represented by a dict
output_filename : str
Filename for output plot
plot_kwargs : dict
kwargs for Plot constructor
projection_axis : str, optional
Axis to use for projection. If None, must be specified in entry.
start_val : None, optional
If set, use this to make 1D projection plot. Cuts on X axis.
Otherwise should be set per entry.
end_val : None, optional
If set, use this to make 1D projection plot. Cuts on X axis.
Otherwise should be set per entry.
is_pdgid_plot : bool, optional
True if for PDGIDs (sets special size & binning)
logy : bool, optional
Description
Raises
------
RuntimeError
Description
"""
conts = []
if not is_pdgid_plot:
for ent in entries:
h2d = cu.get_from_tfile(
ent['file'],
"ak4pfchsl1/" + ent['histname'] + "_JetEta0to0.783")
start_val = ent.get('start_val', start_val)
end_val = ent.get('end_val', end_val)
if start_val is None or end_val is None:
raise RuntimeError("Expected start_val and end_val")
hist = cu.get_projection_plot(
h2d, start_val, end_val,
ent.get('projection_axis', projection_axis))
if hist.GetEntries() == 0:
ent['used'] = False
continue
contrib = Contribution(hist,
label=ent['label'],
line_width=lw,
line_color=ent['colour'],
line_style=ent.get('line_style', 1),
marker_size=ent.get('marker_size', 0),
marker_color=ent['colour'],
marker_style=ent.get('marker_style', 1),
normalise_hist=True,
rebin_hist=ent.get('rebin', None))
conts.append(contrib)
ent['used'] = True
else:
# For PDGID plots, we want a different canvas aspect ratio, and only to include bins
# with non-0 contents. We also relabel bins.
custom_bins = []
for ent in entries:
h2d = cu.get_from_tfile(
ent['file'],
"ak4pfchsl1/" + ent['histname'] + "_JetEta0to0.783")
start_val = ent.get('start_val', start_val)
end_val = ent.get('end_val', end_val)
if not start_val or not end_val:
raise RuntimeError("Expected start_val and end_val")
hist = cu.get_projection_plot(
h2d, start_val, end_val,
ent.get('projection_axis', projection_axis))
ax = hist.GetXaxis()
bins = dict()
for i in range(1, hist.GetNbinsX() + 1):
value = ax.GetBinLowEdge(i)
cont = hist.GetBinContent(i)
err = hist.GetBinError(i)
if cont > 0:
bins[value] = [cont, err]
# print(custom_bins[-1])
custom_bins.append(bins)
nbins = max([len(d) for d in custom_bins])
first_keys = set(custom_bins[0].keys())
for cb in custom_bins[1:]:
first_keys = first_keys.union(set(cb.keys()))
all_keys = sorted(list(first_keys))
print(all_keys)
for cbin, ent in zip(custom_bins, entries):
h = ROOT.TH1D(cu.get_unique_str(), ";PDGID;N", nbins, 0, nbins)
for ind, k in enumerate(all_keys, 1):
content, error = cbin.get(k, [0, 0])
h.SetBinContent(ind, content)
h.SetBinError(ind, error)
ax = h.GetXaxis()
for i in range(1, nbins + 1):
# ax.SetBinLabel(i, str(int(all_keys[i-1])))
pdgid = int(all_keys[i - 1])
ax.SetBinLabel(i, PDGID_STR.get(pdgid, str(pdgid)))
h.LabelsOption("v")
contrib = Contribution(h,
label=ent['label'],
line_width=lw,
line_color=ent['colour'],
line_style=ent.get('line_style', 1),
marker_size=ent.get('marker_size', 0),
marker_color=ent['colour'],
marker_style=ent.get('marker_style', 1),
normalise_hist=True,
rebin_hist=ent.get('rebin', None))
conts.append(contrib)
ent['used'] = True
entries = [e for e in entries if e['used']]
for ind, ent in enumerate(entries):
if not ent['used']:
continue
if ent.get('subplot_ind', -1) >= 0:
conts[ind].subplot = conts[ent['subplot_ind']].obj
plot = Plot(conts,
what="hist",
ytitle="p.d.f.",
has_data=False,
**plot_kwargs)
if is_pdgid_plot and conts[0].obj.GetNbinsX() > 10:
plot.default_canvas_size = (800, 800)
else:
plot.default_canvas_size = (450, 600)
plot.legend.SetX1(0.5)
plot.legend.SetX2(0.97)
if len(entries) > 4:
plot.legend.SetY1(0.7)
plot.legend.SetNColumns(2)
else:
plot.legend.SetY1(0.75)
plot.legend.SetY2(0.9)
plot.plot("HISTE NOSTACK")
if logy:
plot.set_logy()
plot.save(output_filename)
ROOT.gStyle.SetOptStat(0)
My_Style.cd()
FONT_SIZE = 0.032
f_hpp = cu.open_root_file("QCD_Pt_Herwigpp_NoJEC_relPtHatCut2p5_jtptmin4_HadronParton_nbinsrelrsp_10k_L1FastJet_Summer16_07Aug2017_V20_MC/jra_QCD_Pt_15to7000_Herwigpp_NoJEC_newFlav_ak4pfchs_rspRangeLarge_absEta_hadronParton.root")
f_hpp = cu.open_root_file("QCD_Pt_Pythia8_CP5_NoJEC_relPtHatCut2p5_jtptmin4_HadronParton_nbinsrelrsp_10k_L1FastJet_Autumn18_V3_MC/jra_QCD_Pt_15toInf_NoJEC_newFlav_ak4pfchs_rspRangeLarge_absEta_hadronParton.root")
f_h7 = cu.open_root_file("QCD_Pt_Herwig7_NoJEC_relPtHatCut2p5_jtptmin4_HadronParton_nbinsrelrsp_10k_L1FastJet_Autumn18_V3_MC/jra_QCD_Pt_15to7000_Herwig7_NoJEC_newFlav_ak4pfchs_rspRangeLarge_absEta_hadronParton.root")
for flav in ['b', 'ud', 'g', 'c', 's']:
for ptmin, ptmax in [(750, 1000), (72, 90)]:
ptbin = "%dto%d" % (ptmin, ptmax)
histname = "ak4pfchsl1/%s_RelRsp_JetEta0to0.783_RefPt%s" % (flav, ptbin)
hpp = cu.get_from_tfile(f_hpp, histname)
h7 = cu.get_from_tfile(f_h7, histname)
entries = [
(hpp, {"label":"Pythia8 (CP5)", "line_color": ROOT.kAzure+10, "line_width": 2}),
(h7, {"label":"Herwig7", "line_color": ROOT.kBlue, "line_width": 2, "subplot": hpp})
]
plot_kwargs = {
"title": "0 < |#eta| < 0.783\n%d < p_{T}^{Gen} < %d GeV\n%s jets (+ L1FastJet JEC)" %(ptmin, ptmax, flav),
"xlim": [0.5, 1.5],
"xtitle": "Response (p_{T}^{Reco} / p_{T}^{Gen})",
"subplot_type": "ratio",
# "subplot_title": "H7 / H++",
"subplot_title": "H7 / Py8",
}
def do_all_2d_plots(tfile, output_dir):
rebin = 2
hist_dicts = [
{
"hname": "JtcefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtcef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtchfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtchf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtchmultVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtchmult",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JthfefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jthfef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JthfhfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jthfhf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtmufVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtmuf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtnefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtnef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtnhfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtnhf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtnmultVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Jtnmult",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefcefRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefcefRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefchfRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefchfRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefchmultRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefchmultRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefmufRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefmufRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefnefRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefnefRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefnhfRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefnhfRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "JtRefnmultRatioVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "JtRefnmultRatio",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefcefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refcef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefchfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refchf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefchmultVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refchmult",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefmufVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refmuf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefnefVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refnef",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefnhfVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refnhf",
"rebinx": rebin,
"rebiny": rebin,
},
{
"hname": "RefnmultVsRsp_JetEta0to0.783",
"renorm": "X",
"xtitle": "Response",
"ytitle": "Refnmult",
"rebinx": rebin,
"rebiny": rebin,
},
]
for hdict in hist_dicts:
h2d = cu.get_from_tfile(tfile, "ak4pfchs/"+hdict['hname'])
for renorm in ['', 'X', 'Y']:
ofile = output_dir+"/"+hdict.get('ofile', hdict['hname'])
if renorm == "X":
ofile += "_renormX"
elif renorm == "Y":
ofile += "_renormY"
ofile +=".pdf"
do_2d_plot(h2d, output_filename=ofile,
renorm=renorm,
logz=hdict.get('logz', False),
xtitle=hdict.get('xtitle', ''), ytitle=hdict.get('ytitle', ''),
rebinx=hdict.get('rebinx', 1), rebiny=hdict.get('rebiny', 1),
)
# 1D plots cut on response
h_rsp_low = cu.get_projection_plot(h2d, 0.9, 1.1, 'x')
h_rsp_high = cu.get_projection_plot(h2d, 1.1, 2, 'x')
entries = [
(h_rsp_low, {'label': "0.9<rsp<1.1", 'line_color': ROOT.kBlue, 'line_width': 2, }),
(h_rsp_high, {'label': "rsp>1.1", 'line_color': ROOT.kRed, 'line_width': 2, }),
]
plot_kwargs = {
"xtitle": hdict.get('ytitle', ''),
'has_data': False,
}
ofile = output_dir + "/" + hdict.get('ofile', hdict['hname']) + "_1DrspCut.pdf"
cu.do_comparison_plot(entries, ofile, rebin=2, **plot_kwargs)
h2d = cu.get_from_tfile(tfile, "ak4pfchs/RelRspVsRefPt_JetEta0to0.783")
h_rsp = cu.get_projection_plot(h2d, 0, 100000, 'x')
entries = [
(h_rsp, {'line_width':2})
]
plot_kwargs = {
'xtitle':'Response',
'has_data': False,
}
ofile = output_dir + "/response.pdf"
cu.do_comparison_plot(entries, ofile, rebin=2, **plot_kwargs)
def do_comparison_plots(workdir_label_pairs, output_dir):
dirnames = [w[0] for w in workdir_label_pairs]
# templates, we'll change the filename/dir as per instance
total_len = len(workdir_label_pairs)
mark = cu.Marker()
sources = [
{
# "root_dir": wd,
'label': label,
"style": {
'line_style': 1,
'line_color': cu.get_colour_seq(ind, total_len),
'marker_color': cu.get_colour_seq(ind, total_len),
'marker_style': m,
'marker_size': 0.75,
}
}
for ind, ((wd, label), m) in enumerate(zip(workdir_label_pairs, mark.cycle(cycle_filling=True)))
]
jet_config_str = qgc.extract_jet_config(dirnames[0])
if len(dirnames) >1 and qgc.extract_jet_config(dirnames[1]) != jet_config_str:
print("Conflicting jet config str, not adding")
jet_config_str = None
# COMPARE NOMINAL QCD
if exists_in_all(qgc.QCD_FILENAME, dirnames):
print("Found", qgc.QCD_FILENAME, "in all dirs")
root_files = [cu.open_root_file(os.path.join(d, qgc.QCD_FILENAME)) for d in dirnames]
directories = [cu.get_from_tfile(rf, "Dijet_tighter") for rf in root_files]
this_sources = deepcopy(sources)
for s in this_sources:
s['label'] = "QCD [MG+PY8] [%s]" % s['label']
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_qcd_compare_dijet_tighter_kinematics_normalised"),
jet_config_str=jet_config_str,
normalise_hists=True,
bin_by='ave')
directories = [cu.get_from_tfile(rf, "Dijet_eta_ordered") for rf in root_files]
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_qcd_compare_dijet_eta_ordered_kinematics_normalised"),
jet_config_str=jet_config_str,
normalise_hists=True,
bin_by='ave')
# COMPARE NOMINAL DY
if exists_in_all(qgc.DY_FILENAME, dirnames):
root_files = [cu.open_root_file(os.path.join(d, qgc.DY_FILENAME)) for d in dirnames]
directories = [cu.get_from_tfile(rf, "ZPlusJets") for rf in root_files]
this_sources = deepcopy(sources)
for s in this_sources:
s['label'] = "Z+Jet [MG+PY8] [%s]" % s['label']
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_dy_compare_kinematics_absolute"),
jet_config_str=jet_config_str,
normalise_hists=False,
bin_by='Z')
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_dy_compare_kinematics_normalised"),
jet_config_str=jet_config_str,
normalise_hists=True,
bin_by='Z')
# COMPARE JETHT+ZEROBIAS
if exists_in_all(qgc.JETHT_ZB_FILENAME, dirnames):
print("Found", qgc.JETHT_ZB_FILENAME, "in all dirs")
root_files = [cu.open_root_file(os.path.join(d, qgc.JETHT_ZB_FILENAME)) for d in dirnames]
directories = [cu.get_from_tfile(rf, "Dijet_tighter") for rf in root_files]
this_sources = deepcopy(sources)
for s in this_sources:
s['label'] = "Data [%s]" % s['label']
directories = [cu.get_from_tfile(rf, "Dijet_Presel") for rf in root_files]
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_jetht_zb_compare_dijet_presel_kinematics_normalised"),
jet_config_str=jet_config_str,
normalise_hists=False,
bin_by='ave')
directories = [cu.get_from_tfile(rf, "Dijet_tighter") for rf in root_files]
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_jetht_zb_compare_dijet_tighter_kinematics_normalised"),
jet_config_str=jet_config_str,
normalise_hists=True,
bin_by='ave')
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_jetht_zb_compare_dijet_tighter_kinematics_abs"),
jet_config_str=jet_config_str,
normalise_hists=False,
bin_by='ave')
# COMPARE SINGLEMU
# COMPARE HERWIG++ QCD
if exists_in_all(qgc.QCD_HERWIG_FILENAME, dirnames):
root_files = [cu.open_root_file(os.path.join(d, qgc.QCD_HERWIG_FILENAME)) for d in dirnames]
directories = [cu.get_from_tfile(rf, "Dijet_tighter") for rf in root_files]
this_sources = deepcopy(sources)
for s in this_sources:
s['label'] = "QCD [H++] [%s]" % s['label']
# do_all_1D_projection_plots_in_dir(directories=directories,
# components_styles_dicts=this_sources,
# output_dir=os.path.join(output_dir, "plots_qcd_hpp_compare_dijet_tighter_kinematics_normalised"),
# jet_config_str=jet_config_str,
# normalise_hists=True,
# bin_by='ave')
# directories = [cu.get_from_tfile(rf, "Dijet_eta_ordered") for rf in root_files]
# do_all_1D_projection_plots_in_dir(directories=directories,
# components_styles_dicts=this_sources,
# output_dir=os.path.join(output_dir, "plots_qcd_hpp_compare_dijet_eta_ordered_kinematics_normalised"),
# jet_config_str=jet_config_str,
# normalise_hists=True,
# bin_by='ave')
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_qcd_hpp_compare_dijet_tighter_kinematics_absolute"),
jet_config_str=jet_config_str,
normalise_hists=False,
bin_by='ave')
directories = [cu.get_from_tfile(rf, "Dijet_eta_ordered") for rf in root_files]
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_qcd_hpp_compare_dijet_eta_ordered_kinematics_absolute"),
jet_config_str=jet_config_str,
normalise_hists=False,
bin_by='ave')
# COMPARE HERWIG++ DY
if exists_in_all(qgc.DY_HERWIG_FILENAME, dirnames):
root_files = [cu.open_root_file(os.path.join(d, qgc.DY_HERWIG_FILENAME)) for d in dirnames]
directories = [cu.get_from_tfile(rf, "ZPlusJets") for rf in root_files]
this_sources = deepcopy(sources)
for s in this_sources:
s['label'] = "Z+Jet [H++] [%s]" % s['label']
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_dy_hpp_compare_kinematics_absolute"),
jet_config_str=jet_config_str,
normalise_hists=False,
bin_by='Z')
do_all_1D_projection_plots_in_dir(directories=directories,
components_styles_dicts=this_sources,
output_dir=os.path.join(output_dir, "plots_dy_hpp_compare_kinematics_normalised"),
jet_config_str=jet_config_str,
normalise_hists=True,
bin_by='Z')
def do_cut_scan_per_pt(histname, input_filename, output_filename):
ROOT.gStyle.SetPalette(palette_1D)
tf = cu.open_root_file(input_filename)
h3d = cu.get_from_tfile(tf, histname)
h3d_unweighted = cu.get_from_tfile(tf, histname+"_unweighted")
if h3d.GetEntries() == 0:
return
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
canv.SetTicks(1, 1)
canv.SetLeftMargin(0.12)
canv.SetRightMargin(0.12)
# canv.SetLogz()
h2d = h3d.Project3D("zy") # var vs pt
h2d_unweighted = h3d_unweighted.Project3D("zy") # var vs pt
var_name = os.path.basename(histname).replace("weight_vs_pt_vs_", "").replace("weight_vs_pt_genjet_vs_", "")
for ibin in range(3, h2d.GetNbinsX()+1): # iterate over pt bins
if h2d.Integral(ibin, ibin+1, 0, -1) == 0:
# data.append(None)
continue
pt_low = h3d.GetYaxis().GetBinLowEdge(ibin)
pt_high = h3d.GetYaxis().GetBinLowEdge(ibin+1)
data = []
data_unweighted = []
# Do integral, error for increasingly looser cuts
# find maximum in this pt bin
# yes I probably should collapse to a 1D hist and use GetMaximumBin
max_val, max_bin = 0, 0
for icut in range(1, h2d.GetNbinsY()+1):
val = h2d.GetBinContent(ibin, icut)
if val > max_val:
max_val = val
max_bin = icut
for icut in range(max_bin + 5, h2d.GetNbinsY()+2):
err = array('d', [0])
count = h2d.IntegralAndError(ibin, ibin+1, 1, icut-1, err)
if count == 0:
continue
data.append([count, err[0], h2d.GetYaxis().GetBinLowEdge(icut)])
err = array('d', [0])
count = h2d_unweighted.IntegralAndError(ibin, ibin+1, 1, icut, err)
data_unweighted.append([count, err[0], h2d.GetYaxis().GetBinLowEdge(icut)])
# Plot count, rel error vs cut value
cuts = [d[2] for d in data]
gr_count = ROOT.TGraph(len(data), array('d', cuts), array('d', [d[0] / data[-1][0] for d in data]))
gr_count.SetMarkerColor(ROOT.kRed)
gr_count.SetMarkerStyle(22)
gr_count.SetLineColor(ROOT.kRed)
gr_count.SetTitle("%g < p_{T} < %g GeV;%s cut (<);Count (relative to loosest cut)" % (pt_low, pt_high, get_var_str(histname)))
gr_count_unweighted = ROOT.TGraph(len(data), array('d', cuts), array('d', [d[0] / data_unweighted[-1][0] for d in data_unweighted]))
gr_count_unweighted.SetMarkerColor(ROOT.kBlack)
gr_count_unweighted.SetMarkerStyle(23)
gr_count_unweighted.SetLineColor(ROOT.kBlack)
gr_count_unweighted.SetTitle("%g < p_{T} < %g GeV;%s cut (<);Count (relative to loosest cut)" % (pt_low, pt_high, get_var_str(histname)))
leg = ROOT.TLegend(0.7, 0.5, 0.85, 0.65)
leg.AddEntry(gr_count, "Weighted", "LP")
leg.AddEntry(gr_count_unweighted, "Unweighted", "LP")
# gr_rel_err = ROOT.TGraph(len(data), array('d', cuts), array('d', [(d[1] / d[0]) if d[0] != 0 else 0 for d in data ]))
# gr_rel_err.SetMarkerColor(ROOT.kRed)
# gr_rel_err.SetMarkerStyle(22)
# gr_rel_err.SetLineColor(ROOT.kRed)
# gr_rel_err.SetTitle("%g < p_{T} < %g GeV;%s cut (<);Rel. error" % (pt_low, pt_high, var_name))
canv.SetLogy(False)
gr_count.Draw("ALP")
gr_count_unweighted.Draw("LP")
gr_count.Draw("LP")
leg.Draw()
canv.SaveAs(output_filename.replace(".pdf", "_count_pt%gto%g.pdf" % (pt_low, pt_high)))
# canv.Clear()
# gr_rel_err.Draw("ALP")
# canv.SetLogy()
# gr_rel_err.GetYaxis().SetMoreLogLabels()
# canv.SaveAs(output_filename.replace(".pdf", "_rel_err_pt%gto%g.pdf" % (pt_low, pt_high)))
tf.Close()
def do_cut_roc_per_pt(histname, input_filename, output_filename):
"""Plot fractional # unweighted vs fraction # weighted, for different cuts
Not a true ROC, but kinda like one
"""
ROOT.gStyle.SetPalette(palette_1D)
tf = cu.open_root_file(input_filename)
h3d = cu.get_from_tfile(tf, histname)
h3d_unweighted = cu.get_from_tfile(tf, histname+"_unweighted")
if h3d.GetEntries() == 0:
return
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
canv.SetTicks(1, 1)
canv.SetLeftMargin(0.12)
canv.SetRightMargin(0.12)
# canv.SetLogz()
h2d = h3d.Project3D("zy") # var vs pt
h2d_unweighted = h3d_unweighted.Project3D("zy") # var vs pt
var_name = os.path.basename(histname).replace("weight_vs_pt_vs_", "").replace("weight_vs_pt_genjet_vs_", "")
for ibin in range(3, h2d.GetNbinsX()+1): # iterate over pt bins
if h2d.Integral(ibin, ibin+1, 0, -1) == 0:
# data.append(None)
continue
pt_low = h3d.GetYaxis().GetBinLowEdge(ibin)
pt_high = h3d.GetYaxis().GetBinLowEdge(ibin+1)
data = []
data_unweighted = []
# Do integral, error for increasingly looser cuts
# find maximum in this pt bin
# yes I probably should collapse to a 1D hist and use GetMaximumBin
max_val, max_bin = 0, 0
for icut in range(1, h2d.GetNbinsY()+1):
val = h2d.GetBinContent(ibin, icut)
if val > max_val:
max_val = val
max_bin = icut
for icut in range(max_bin + 5, h2d.GetNbinsY()+2, 2):
# for icut in range(2, h2d.GetNbinsY()+2):
err = array('d', [0])
count = h2d.IntegralAndError(ibin, ibin+1, 1, icut-1, err)
if count == 0:
continue
data.append([count, err[0], h2d.GetYaxis().GetBinLowEdge(icut)])
err = array('d', [0])
count = h2d_unweighted.IntegralAndError(ibin, ibin+1, 1, icut-1, err)
data_unweighted.append([count, err[0], h2d.GetYaxis().GetBinLowEdge(icut)])
cuts = np.array([d[2] for d in data][1:])
# cuts = np.array([d[2] for d in data])
weighted_fractions = np.array([abs(d[0]-dd[0]) / dd[0] for d, dd in zip(data[:-1], data[1:])])
unweighted_fractions = np.array([abs(d[0]-dd[0]) / dd[0] for d, dd in zip(data_unweighted[:-1], data_unweighted[1:])])
non_zero_mask = (unweighted_fractions>0) & (weighted_fractions>0)
non_zero_weighted = weighted_fractions[non_zero_mask]
weight_min_pow = math.floor(math.log10(min(non_zero_weighted))) if len(non_zero_weighted) > 0 else -10
weight_max_pow = math.floor(math.log10(max(non_zero_weighted))) if len(non_zero_weighted) > 0 else 0
assert(weight_max_pow>=weight_min_pow)
non_zero_unweighted = unweighted_fractions[non_zero_mask]
unweight_min_pow = math.floor(math.log10(min(non_zero_unweighted))) if len(non_zero_unweighted) > 0 else -10
unweight_max_pow = math.floor(math.log10(max(non_zero_unweighted))) if len(non_zero_unweighted) > 0 else 0
assert(unweight_max_pow>=unweight_min_pow)
mask = unweighted_fractions < 10**(unweight_min_pow+1) # last decade of unweighted drops
mask &= weighted_fractions > 10**(weight_max_pow-1) # largest decades of weighted drops
if np.sum(mask) == 0:
continue
# weighted_fractions = np.array([d[0] / data[-1][0] for d in data])
# unweighted_fractions = np.array([d[0] / data_unweighted[-1][0] for d in data_unweighted])
unweighted_useful = unweighted_fractions[mask & non_zero_mask]
weighted_useful = weighted_fractions[mask & non_zero_mask]
if "pt_jet_genHT_ratio" in histname and pt_low == 800:
print("weight_min_pow:", weight_min_pow)
print("weight_max_pow:", weight_max_pow)
print("unweight_min_pow:", unweight_min_pow)
print("unweight_max_pow:", unweight_max_pow)
print("unweight_max_pow:", unweight_max_pow)
print("weighted_useful:", weighted_useful)
print("unweighted_useful:", unweighted_useful)
gr_count = ROOT.TGraph(len(unweighted_useful), unweighted_useful, weighted_useful)
gr_count.SetMarkerColor(ROOT.kRed)
gr_count.SetMarkerSize(0)
gr_count.SetMarkerStyle(21)
gr_count.SetLineColor(ROOT.kRed)
gr_count.SetTitle("%s, %g < p_{T} < %g GeV;Relative unweighted count;Relative weighted count" % (get_var_str(histname), pt_low, pt_high))
gr_count.SetTitle("%s, %g < p_{T} < %g GeV;Unweighted fractional drop;Weighted fractional drop" % (get_var_str(histname), pt_low, pt_high))
# add annotations of cuts
latexs = []
for i, cut in enumerate(cuts[mask * non_zero_mask]):
latex = ROOT.TLatex(gr_count.GetX()[i], gr_count.GetY()[i], " < %.2f" % cut)
latex.SetTextSize(0.02)
latex.SetTextColor(ROOT.kBlue)
gr_count.GetListOfFunctions().Add(latex)
latexs.append(latex)
# canv.SetLogx(False)
# canv.SetLogy(False)
# ROOT.TGaxis.SetMaxDigits(2)
# gr_count.Draw("ALP")
# ROOT.TGaxis.SetMaxDigits(2)
# unweighted_min = 0.9999
# # Calculate differences between points
# unweighted_diffs = unweighted_fractions[1:] - unweighted_fractions[:-1]
# weighted_diffs = weighted_fractions[1:] - weighted_fractions[:-1]
# big_diff_inds = []
# for ind, (u, w) in enumerate(zip(unweighted_diffs, weighted_diffs)):
# # look for big diff in weighted frac, small diff in unweighted,
# # with a limit on the minimum size of unweighted frac
# # (only trying to remove a few events)
# if u > 0 and w / u > 100 and u < 0.005 and unweighted_fractions[ind] > unweighted_min:
# big_diff_inds.append(ind)
# if "pt_jet_genHT_ratio" in histname and pt_low == 186:
# for u, w in zip(unweighted_diffs, weighted_diffs):
# print(u, w)
# print(big_diff_inds)
# make graph of big diff points, add annotations of cuts
# if len(big_diff_inds) > 0:
# gr_big_diffs = ROOT.TGraph(len(big_diff_inds), array('d', [unweighted_fractions[i+1] for i in big_diff_inds]), array('d', [weighted_fractions[i+1] for i in big_diff_inds]))
# gr_big_diffs.SetLineWidth(0)
# gr_big_diffs.SetMarkerColor(ROOT.kBlue)
# gr_big_diffs.SetMarkerStyle(25)
# latexs = []
# for i, ind in enumerate(big_diff_inds[:]):
# latex = ROOT.TLatex(gr_big_diffs.GetX()[i], gr_big_diffs.GetY()[i], " < %.2f" % cuts[ind+1])
# latex.SetTextSize(0.02)
# latex.SetTextColor(ROOT.kBlue)
# gr_big_diffs.GetListOfFunctions().Add(latex)
# latexs.append(latex)
# gr_big_diffs.Draw("*")
# gr_count.GetXaxis().SetLimits(unweighted_min, 1)
# find corresponding value for weighted to set axis range
# weighted_min = 0
# for ind, u in enumerate(unweighted_fractions):
# if u >= unweighted_min:
# weighted_min = weighted_fractions[ind-1]
# if ind == len(unweighted_fractions) - 1:
# weighted_min = 0
# break
# gr_count.GetHistogram().SetMinimum(weighted_min*1.1 - 0.1)
# gr_count.GetHistogram().SetMaximum(1)
# canv.SaveAs(output_filename.replace(".pdf", "_count_pt%gto%g.pdf" % (pt_low, pt_high)))
# do a version zoomed out
canv.Clear()
gr_count.SetMarkerSize(0.5)
gr_count.Draw("AP")
# unweighted_min = 0.
# gr_count.GetXaxis().SetLimits(unweighted_min, 1)
# weighted_min = 0
# for ind, u in enumerate(unweighted_fractions):
# if u >= unweighted_min:
# weighted_min = weighted_fractions[ind-1]
# if ind == len(unweighted_fractions) - 1:
# weighted_min = 0
# break
# gr_count.GetHistogram().SetMinimum(weighted_min*1.1 - 0.1)
gr_count.GetXaxis().SetMoreLogLabels()
gr_count.GetYaxis().SetMoreLogLabels()
weight_min_pow = math.floor(math.log10(min(weighted_useful))) if len(weighted_useful) > 0 else -10
weight_max_pow = math.floor(math.log10(max(weighted_useful))) if len(weighted_useful) > 0 else 0
unweight_min_pow = math.floor(math.log10(min(unweighted_useful))) if len(unweighted_useful) > 0 else -10
unweight_max_pow = math.floor(math.log10(max(unweighted_useful))) if len(unweighted_useful) > 0 else 0
gr_count.GetHistogram().SetMinimum(10**weight_min_pow)
gr_count.GetHistogram().SetMaximum(10**(weight_max_pow+1))
gr_count.GetXaxis().SetLimits(10**unweight_min_pow, 10**(unweight_max_pow+1))
canv.SetLogy()
canv.SetLogx()
canv.SaveAs(output_filename.replace(".pdf", "_count_pt%gto%g_all.pdf" % (pt_low, pt_high)))
tf.Close()
def do_counting(zb_input_file,
jetht_input_file,
trig_info,
eta_min=-2.4,
eta_max=2.4,
title="",
output_filename="pt.pdf"):
"""Get hists of pt spectrum for each trigger, plot, and make & return cumulative hist"""
trig_names = list(trig_info.keys())
# first get num event passing ZeroBias trigger, up to the first trigger threshold
h_zb = cu.get_from_tfile(zb_input_file, "ZeroBiasRef/pt_vs_eta_all")
pt_min, pt_max = 50, trig_info[trig_names[0]]['actual_threshold']
h_zb_pt = get_xprojection_hist(h_zb, 50, pt_max, eta_min, eta_max)
h_zb_pt.SetName("ZeroBias")
h_zb_pt.Sumw2()
zb_color = 17
h_zb_pt.SetFillColor(zb_color)
h_zb_pt.SetLineColor(zb_color)
print("WARNING: rounding to nearest bin width", h_zb_pt.GetBinWidth(1))
hst = ROOT.THStack("hst", title + ";Leading jet p_{T} [GeV];N")
hst.Add(h_zb_pt)
# for printout at end
total = []
this_num_entries = h_zb_pt.Integral()
total.append(("ZeroBias", this_num_entries))
leg = ROOT.TLegend(0.6, 0.5, 0.95, 0.88)
leg.AddEntry(h_zb_pt,
"ZeroBias (p_{T} > %g GeV): %g" % (pt_min, this_num_entries),
"LF")
# Now go through each of the triggers and get their hists,
# using next trigger actual threshold as upper limit on pt
for this_trig_name, next_trig_name in zip(trig_names[:-1], trig_names[1:]):
h2d = cu.get_from_tfile(jetht_input_file,
this_trig_name + "_v*Ref/pt_vs_eta_all")
pt_min = trig_info[this_trig_name]['actual_threshold']
pt_max = trig_info[next_trig_name]['actual_threshold']
h_pt = get_xprojection_hist(h2d, pt_min, pt_max, eta_min, eta_max)
h_pt.SetName(this_trig_name)
h_pt.SetFillColor(trig_info[this_trig_name]['color'])
h_pt.SetLineColor(trig_info[this_trig_name]['color'])
this_num_entries = h_pt.Integral()
total.append((this_trig_name, this_num_entries))
hst.Add(h_pt)
leg.AddEntry(h_pt, this_trig_name + ": %g" % (this_num_entries), "LF")
# Do the last trigger manually
last_trig_name = trig_names[-1]
h2d = cu.get_from_tfile(jetht_input_file,
last_trig_name + "_v*Ref/pt_vs_eta_all")
pt_min = trig_info[last_trig_name]['actual_threshold']
h_pt = get_xprojection_hist(h2d, pt_min, 10000, eta_min, eta_max)
h_pt.SetName(last_trig_name)
h_pt.SetFillColor(trig_info[last_trig_name]['color'])
h_pt.SetLineColor(trig_info[last_trig_name]['color'])
this_num_entries = h_pt.Integral()
total.append((last_trig_name, this_num_entries))
hst.Add(h_pt)
leg.AddEntry(h_pt, last_trig_name + ": %g" % (this_num_entries), "LF")
# Now print a plot showing distribution of each trigger
c = ROOT.TCanvas("c", "", 800, 600)
c.SetTicks(1, 1)
# c.SetLogx()
c.SetLogy()
hst.Draw("HISTE NOSTACK")
hst.SetMinimum(10)
hst.SetMaximum(1E6)
total_count = sum(x[1] for x in total)
leg.AddEntry(0, "Total: " + str(total_count), "")
leg.Draw()
c.SaveAs(output_filename)
for count in total:
print(count[0], "=", count[1])
print("Total:", total_count)
# Now make a cumulative histogram of all triggers, need to convert to
# single TH1 first though from THStack
htotal = cu.thstack_to_th1(hst)
cumul = htotal.GetCumulative()
cumul.SetTitle(title + " (cumulative);Leading jet p_{T} [GeV];N")
c.Clear()
c.SetLogx()
cumul.SetFillStyle(0)
cumul.SetLineColor(ROOT.kRed)
cumul.Draw("HISTE")
cumul.SetMinimum(5E5)
cumul.SetMaximum(5E7)
cumul.SetAxisRange(50, 2000, "X")
c.SaveAs(output_filename.replace(".pdf", "_cumul.pdf"))
return cumul
"name":
"%s/%s%s" %
(source_plot_dir_name, angle.var, pt_region_dict['append']),
"var_label":
"%s (%s)" % (angle.name, angle.lambda_str),
"title":
"%s\n%s" % (region_label, pt_region_dict['title']),
}
# Need both to do corrections
# this is reco vs gen
full_var_name = var_dict['name'] + "_response"
# relative response is reco/gen vs gen
full_var_name_rel = var_dict['name'] + "_rel_response"
h2d_orig = cu.get_from_tfile(input_tfile, full_var_name)
h2d_rel_orig = cu.get_from_tfile(input_tfile, full_var_name_rel)
h2d_orig.Rebin2D(4, 4)
h2d_rel_orig.Rebin2D(4, 4)
metric = "rawmean"
metric = "median"
x_values, corrections, reco_hists, response_hists = get_corrections(
h2d_orig, h2d_rel_orig, metric)
corrections_graph = ROOT.TGraphErrors(
len(x_values), array('d', x_values[:, 0]),
array('d', corrections[:, 0]), array('d', x_values[:, 1]),
array('d', corrections[:, 1]))
def do_response_plot(tdir,
plot_dir,
var_name,
xlabel,
log_var=False,
rebinx=1,
rebiny=1,
do_migration_summary_plots=True,
do_resolution_plots=True,
save_response_hists=False):
"""Do 2D plots of genjet pt vs recojet pt"""
h2d_orig = cu.get_from_tfile(tdir, var_name)
h2d = h2d_orig.Clone(cu.get_unique_str())
h2d.RebinX(rebinx)
h2d.RebinY(rebiny)
pt_regions = [
{
"append": "_lowPt",
"title": "30 < p_{T}^{Reco} < 100 GeV",
},
{
"append": "_midPt",
"title": "100 < p_{T}^{Reco} < 250 GeV",
},
{
"append": "_highPt",
"title": "p_{T}^{Reco} > 250 GeV",
},
]
pt_bin_name = ""
for region in pt_regions:
if region['append'] in var_name:
pt_bin_name = region['title']
title = "%s;%s (GEN);%s (RECO)" % (pt_bin_name, xlabel, xlabel)
# title = pt_bin_name
canv = ROOT.TCanvas(cu.get_unique_str(), "", 800, 600)
draw_opt = "COLZ TEXT"
draw_opt = "COLZ"
pad = ROOT.gPad
pad.SetBottomMargin(0.12)
pad.SetLeftMargin(0.13)
pad.SetRightMargin(0.12)
canv.SetTicks(1, 1)
if log_var:
canv.SetLogx()
canv.SetLogy()
# un normalised
h2d.SetTitle(title)
h2d.Draw(draw_opt)
xax = h2d.GetXaxis()
upper_lim = xax.GetBinUpEdge(xax.GetLast())
# print(upper_lim)
# upper_lim = 5000
title_offset = 1.5
h2d.SetTitleOffset(title_offset, 'X')
xax.SetMoreLogLabels()
yax = h2d.GetYaxis()
h2d.SetTitleOffset(title_offset * 1.15, 'Y')
yax.SetMoreLogLabels()
canv.Update()
plot_dir = os.path.join(plot_dir, tdir.GetName())
cu.check_dir_exists_create(plot_dir)
canv.SaveAs(os.path.join(plot_dir, "%s_linZ.%s" % (var_name, OUTPUT_FMT)))
canv.SetLogz()
canv.SaveAs(os.path.join(plot_dir, "%s_logZ.%s" % (var_name, OUTPUT_FMT)))
# renorm by row (reco bins)
canv.SetLogz(0)
h2d_renorm_y = cu.make_normalised_TH2(h2d,
'Y',
recolour=True,
do_errors=True)
h2d_renorm_y.SetMarkerSize(0.5)
h2d_renorm_y.SetMaximum(1)
h2d_renorm_y.Draw(draw_opt)
xax = h2d_renorm_y.GetXaxis()
upper_lim = xax.GetBinUpEdge(xax.GetLast())
# print(upper_lim)
# upper_lim = 5000
title_offset = 1.5
h2d_renorm_y.SetTitleOffset(title_offset, 'X')
# xax.SetRangeUser(0, upper_lim)
xax.SetMoreLogLabels()
yax = h2d_renorm_y.GetYaxis()
h2d_renorm_y.SetTitleOffset(title_offset * 1.15, 'Y')
# yax.SetRangeUser(0, upper_lim)
yax.SetMoreLogLabels()
canv.Update()
canv.SaveAs(
os.path.join(plot_dir, "%s_renormY_linZ.%s" % (var_name, OUTPUT_FMT)))
canv.SetLogz()
h2d_renorm_y.SetMaximum(1)
h2d_renorm_y.SetMinimum(1E-3)
canv.SaveAs(
os.path.join(plot_dir, "%s_renormY_logZ.%s" % (var_name, OUTPUT_FMT)))
# renorm by column (gen bins)
canv.Clear()
canv.SetLogz(0)
h2d_renorm_x = cu.make_normalised_TH2(h2d,
'X',
recolour=True,
do_errors=True)
h2d_renorm_x.SetMarkerSize(0.5)
h2d_renorm_x.SetMaximum(1)
h2d_renorm_x.Draw(draw_opt)
xax = h2d_renorm_x.GetXaxis()
upper_lim = xax.GetBinUpEdge(xax.GetLast())
# upper_lim = 5000
title_offset = 1.5
h2d_renorm_x.SetTitleOffset(title_offset, 'X')
# xax.SetRangeUser(0, upper_lim)
xax.SetMoreLogLabels()
yax = h2d_renorm_x.GetYaxis()
h2d_renorm_x.SetTitleOffset(title_offset * 1.15, 'Y')
# yax.SetRangeUser(0, upper_lim)
yax.SetMoreLogLabels()
canv.Update()
canv.SaveAs(
os.path.join(plot_dir, "%s_renormX_linZ.%s" % (var_name, OUTPUT_FMT)))
canv.SetLogz()
h2d_renorm_x.SetMaximum(1)
h2d_renorm_x.SetMinimum(1E-3)
canv.SaveAs(
os.path.join(plot_dir, "%s_renormX_logZ.%s" % (var_name, OUTPUT_FMT)))
# Now do plot of purity, etc
if do_migration_summary_plots:
qgg.make_migration_summary_plot(
h2d_renorm_x,
h2d_renorm_y,
xlabel=xlabel,
output_filename=os.path.join(
plot_dir, '%s_migration_summary.%s' % (var_name, OUTPUT_FMT)),
log_var=log_var)
# Do resolution plots
if do_resolution_plots:
res_rms, rel_res_rms = make_resolution_plots(
h2d_orig,
xlabel=xlabel,
output_filename=os.path.join(
plot_dir,
'%s_resolution_summary_rms.%s' % (var_name, OUTPUT_FMT)),
do_fit=False,
do_rms=True,
log_var=log_var,
save_response_hists=False)
res_quantiles, rel_res_quantiles = make_resolution_plots(
h2d_orig,
xlabel=xlabel,
output_filename=os.path.join(
plot_dir,
'%s_resolution_summary_quantiles.%s' % (var_name, OUTPUT_FMT)),
do_fit=False,
do_rms=False,
quantiles=None, # auto determine
log_var=log_var,
save_response_hists=save_response_hists)
# compare RMS and quantile results
conts = [
Contribution(
res_rms,
label="#sqrt{RMS} #pm #frac{#sqrt{#delta RMS}}{#LT %s #GT}" %
(xlabel),
line_color=ROOT.kRed,
marker_color=ROOT.kRed),
Contribution(res_quantiles,
label="68% quantile",
line_color=ROOT.kBlue,
marker_color=ROOT.kBlue)
]
ylabel = "#frac{#sigma(RECO/GEN)}{GEN}" if "_rel_" in var_name else "#frac{#sigma(RECO)}{GEN}"
res_plot = Plot(conts,
what='graph',
xtitle=xlabel,
ytitle=ylabel,
legend=True,
ylim=[0, 3])
res_plot.legend.SetX1(0.5)
res_plot.legend.SetX2(0.9)
res_plot.legend.SetY1(0.7)
res_plot.legend.SetY2(0.85)
res_plot.plot('ALP')
res_plot.save(
os.path.join(
plot_dir,
'%s_resolution_rms_vs_quantiles.%s' % (var_name, OUTPUT_FMT)))
