def plot_detector_unfolded(self, do_dijet=True, do_zpj=True):
for ibin, (bin_edge_low, bin_edge_high) in enumerate(
zip(self.bins[:-1], self.bins[1:])):
hbc_args = dict(ind=ibin,
axis='pt',
do_norm=True,
do_div_bin_width=True,
binning_scheme='generator')
print("----------pt bin", ibin, "=", bin_edge_low, "-",
bin_edge_high)
def determine_num_dp(values):
"""Determine correct number of decimal places
so that the smallest value has 1 digit
If smallest > 1, then just returns 0
"""
smallest_value = min([v for v in values if v > 0])
print('determine_num_dp', smallest_value)
if smallest_value > 1:
return 0
# use log10 to figure out exponent, then floor it
# e.g. log10(5.5E-3) = -2.25...., floor(-2.25...) = -3
n_dp = abs(floor(log10(smallest_value)))
return n_dp
def setup_beta_function(name):
fit = ROOT.TF1(name, "[2]*TMath::BetaDist(x,[0],[1])", 0, 1)
fit.SetParameter(0, 3)
fit.SetParLimits(0, 0, 100)
fit.SetParameter(1, 5)
fit.SetParLimits(1, 0, 100)
fit.SetParameter(2, 0.05)
fit.SetParLimits(2, 0, 10)
# fit.SetParameter(3, 0)
# fit.SetParLimits(3, 0, 10)
# fit.SetParameter(4, 1)
# fit.SetParLimits(4, 0.1, 10)
return fit
fit_opts = "S"
# Weird setup here: basically need all the values going into legend first,
# to be able to determine the number of decimal points
# Then we can actually create the Contributions and plot afterwards
dijet_detector_hist, dijet_unfolded_hist = None, None
dijet_detector_mean, dijet_detector_mean_err = None, None
dijet_unfolded_mean, dijet_unfolded_mean_err = None, None
zpj_detector_hist, zpj_unfolded_hist = None, None
zpj_detector_mean, zpj_detector_mean_err = None, None
zpj_unfolded_mean, zpj_unfolded_mean_err = None, None
dijet_entries, zpj_entries = [], []
errors = []
if do_dijet:
# get detector-level data
dijet_detector_hist = self.dijet_hbc.get_bin_plot(
'input_hist_gen_binning_bg_subtracted', **hbc_args)
dijet_detector_mean, dijet_detector_mean_err = self.get_uncorrelated_mean_err(
dijet_detector_hist, is_density=True)
errors.append(dijet_detector_mean_err)
# fit with beta function
# dijet_detector_fit = setup_beta_function("beta_fit_dijet_detector")
# fit_result = dijet_detector_hist.Fit(dijet_detector_fit, fit_opts, "")
# fit_result.Print()
# get unfolded data
dijet_unfolded_hist = self.dijet_hbc.get_bin_plot(
"unfolded", **hbc_args)
dijet_cov_matrix = self.dijet_hbc.get_bin_plot(
self.dijet_region['unfolder'].total_ematrix_name,
**hbc_args)
dijet_unfolded_mean, dijet_unfolded_mean_err = self.get_correlated_mean_err(
dijet_unfolded_hist, dijet_cov_matrix, is_density=True)
errors.append(dijet_unfolded_mean_err)
# dijet_unfolded_fit = setup_beta_function("beta_fit_dijet_unfolded")
# fit_result = dijet_unfolded_hist.Fit(dijet_unfolded_fit, fit_opts, "")
# fit_result.Print()
if do_zpj:
# get detector-level data
zpj_detector_hist = self.zpj_hbc.get_bin_plot(
'input_hist_gen_binning_bg_subtracted', **hbc_args)
zpj_detector_mean, zpj_detector_mean_err = self.get_uncorrelated_mean_err(
zpj_detector_hist, is_density=True)
errors.append(zpj_detector_mean_err)
# zpj_detector_fit = setup_beta_function("beta_fit_zpj_detector")
# fit_result = zpj_detector_hist.Fit(zpj_detector_fit, fit_opts, "")
# fit_result.Print()
# get unfolded data
zpj_unfolded_hist = self.zpj_hbc.get_bin_plot(
"unfolded", **hbc_args)
zpj_cov_matrix = self.zpj_hbc.get_bin_plot(
self.zpj_region['unfolder'].total_ematrix_name, **hbc_args)
zpj_unfolded_mean, zpj_unfolded_mean_err = self.get_correlated_mean_err(
zpj_unfolded_hist, zpj_cov_matrix, is_density=True)
errors.append(zpj_unfolded_mean_err)
# zpj_unfolded_fit = setup_beta_function("beta_fit_zpj_unfolded")
# fit_result = zpj_unfolded_hist.Fit(zpj_unfolded_fit, fit_opts, "")
# fit_result.Print()
# n_dp = determine_num_dp(errors)
n_dp = 3
# kerning necessary as it puts massive space around #pm
# but the first #kern doesn't affect the space after #pm as much (?!),
# so I have to add another one with harder kerning
# we use %.(n_dp)f as our float format str to ensure the correct number of dp are shown (and not rounded off)
stat_template = 'Mean = {:.%df}#kern[-0.2dx]{{ #pm}}#kern[-0.5dx]{{ }}{}' % (
n_dp)
err_template = "{:.%df}" % n_dp
def _stat_label(mean, err, dp):
err_str = err_template.format(err)
# if the error is so small that it would display as 0.000,
# i.e. < 0.0005, instead show < 0.001
if err < 5 * 10**(-dp - 1):
err_str = "#lower[-0.09dy]{<}#kern[-0.75dx]{ }" + err_template.format(
1 * 10**(-dp))
return stat_template.format(round(mean, dp), err_str)
if do_dijet:
dijet_entries.append(
Contribution(
dijet_detector_hist,
label='Detector-level (stat. only)\n%s' %
(_stat_label(dijet_detector_mean,
dijet_detector_mean_err, n_dp)),
line_color=self.plot_colours['dijet_colour'],
line_width=self.line_width,
line_style=self.line_style_detector,
marker_color=self.plot_colours['dijet_colour'],
marker_style=cu.Marker.get('circle', filled=False),
marker_size=0.75,
subplot=zpj_detector_hist if do_zpj else None))
dijet_entries.append(
Contribution(
dijet_unfolded_hist,
label='Particle-level\n%s' %
(_stat_label(dijet_unfolded_mean,
dijet_unfolded_mean_err, n_dp)),
line_color=self.plot_colours['dijet_colour'],
line_width=self.line_width,
line_style=1,
marker_color=self.plot_colours['dijet_colour'],
marker_style=cu.Marker.get('circle', filled=True),
marker_size=0.75,
subplot=zpj_unfolded_hist if do_zpj else None))
if do_zpj:
zpj_entries.append(
Contribution(
zpj_detector_hist,
label='Detector-level (stat. only)\n%s' % (_stat_label(
zpj_detector_mean, zpj_detector_mean_err, n_dp)),
line_color=self.plot_colours['zpj_colour'],
line_width=self.line_width,
line_style=self.line_style_detector,
marker_color=self.plot_colours['zpj_colour'],
marker_style=cu.Marker.get('square', filled=False),
marker_size=0.75))
zpj_entries.append(
Contribution(
zpj_unfolded_hist,
label='Particle-level\n%s' % (_stat_label(
zpj_unfolded_mean, zpj_unfolded_mean_err, n_dp)),
line_color=self.plot_colours['zpj_colour'],
line_width=self.line_width,
line_style=1,
marker_color=self.plot_colours['zpj_colour'],
marker_style=cu.Marker.get('square', filled=True),
marker_size=0.75))
all_entries = list(chain(dijet_entries, zpj_entries))
plot = Plot(
all_entries,
ytitle=self.pt_bin_normalised_differential_label,
title=self.get_pt_bin_title(bin_edge_low, bin_edge_high),
legend=True,
xlim=qgp.calc_auto_xlim(
all_entries), # set x lim to where data is non-0
what="hist",
xtitle=self.particle_title,
has_data=self.has_data,
ylim=[0, None],
is_preliminary=self.is_preliminary)
# plot.default_canvas_size = (600, 600)
# plot.left_margin = 0.2
# plot.left_title_offset_fudge_factor = 8
plot.y_padding_max_linear = 1.8
plot.top_margin = 0.07
plot.title_start_y = 0.888
plot.cms_text_y = 0.94
plot.lumi = cu.get_lumi_str(do_dijet=do_dijet, do_zpj=do_zpj)
if do_zpj and do_dijet:
plot.subplot_type = 'ratio'
plot.subplot_title = 'Dijet / Z+jet'
plot.subplot_limits = (0.25, 2.75)
# disable adding objects to legend & drawing - we'll do it manually
# since we want proper error bar
plot.do_legend = False
plot.splitline_legend = False
# plot.legend.SetFillColor(ROOT.kRed)
# plot.legend.SetFillStyle(1001)
plot.plot("NOSTACK E1 X0")
# plot.get_modifier().GetYaxis().SetTitleOffset(plot.get_modifier().GetYaxis().GetTitleOffset()*1.5)
plot.main_pad.cd()
for e in [plot.contributions[0].obj, plot.contributions[2].obj]:
e.Draw("HIST SAME")
for e in [plot.contributions[1].obj, plot.contributions[3].obj]:
e.Draw("L SAME")
plot.canvas.cd()
# unfolded_fit = ROOT.TF1("beta_fit_dijet_unfolded", "[2]*TMath::BetaDist(x,[0],[1])", 0, 1)
# unfolded_fit.SetParameter(0, 3)
# unfolded_fit.SetParLimits(0, 0, 100)
# unfolded_fit.SetParameter(1, 5)
# unfolded_fit.SetParLimits(1, 0, 100)
# unfolded_fit.SetParameter(2, .1)
# unfolded_fit.SetParLimits(2, 0, 1000)
# # fit_result = unfolded_hist.Fit(unfolded_fit, "EMSR", "", 0, 1)
# # fit_result.Print()
# unfolded_fit.SetLineColor(ROOT.kRed)
# unfolded_fit.SetLineWidth(2)
# plot.main_pad.cd()
# unfolded_fit.Draw("SAME")
# Create dummy graphs with the same styling to put into the legend
dummy_gr = ROOT.TGraphErrors(1, array('d', [1]), array('d', [1]),
array('d', [1]), array('d', [1]))
dummies = [] # to stop garbage collection
dummy_entries = [] # to stop garbage collection
label_height = 0.03
legend_height = 0.12
legend_x1 = 0.54
legend_x2 = 0.75 # this doesn't really control width - legend_text_size mainly does
label_left_offset = 0.01
label_text_size = 0.032
label_top = plot.title_start_y
legend_text_size = 0.028
inter_region_offset = 0.025
if do_dijet:
dijet_legend = plot.legend.Clone()
dijet_legend.SetX1(legend_x1)
dijet_legend.SetX2(legend_x2)
dijet_legend.SetY1(label_top - label_height - legend_height)
dijet_legend.SetY2(label_top - label_height + 0.01)
dijet_legend.SetTextSize(legend_text_size)
# Add text with region label
dijet_pt = ROOT.TPaveText(legend_x1 - label_left_offset,
label_top - label_height,
legend_x2 - label_left_offset,
label_top, "NDC NB")
dijet_pt.SetFillStyle(0)
dijet_pt.SetBorderSize(0)
text = dijet_pt.AddText(qgc.Dijet_CEN_LABEL)
text.SetTextAlign(11)
text.SetTextFont(62)
text.SetTextSize(label_text_size)
dummies.append(dijet_pt)
dummies.append(text)
dijet_pt.Draw()
for cont in dijet_entries:
this_dummy_entry = dummy_gr.Clone()
cont.update_obj_styling(this_dummy_entry)
if "\n" in cont.label:
parts = cont.label.split("\n")
dijet_legend.AddEntry(
this_dummy_entry,
"#splitline{%s}{%s}" % (parts[0], parts[1]), "LEP")
else:
dijet_legend.AddEntry(this_dummy_entry, cont.label,
"LEP")
dummy_entries.append(
this_dummy_entry) # to avoid garbage collection
dijet_legend.Draw()
dummies.append(dijet_legend)
# setup for Z+J
label_top -= label_height + legend_height + inter_region_offset
if do_zpj:
zpj_legend = plot.legend.Clone()
zpj_legend.SetX1(legend_x1)
zpj_legend.SetX2(legend_x2)
zpj_legend.SetY1(label_top - label_height - legend_height)
zpj_legend.SetY2(label_top - label_height + 0.01)
zpj_legend.SetTextSize(legend_text_size)
# Add text with region label
zpj_pt = ROOT.TPaveText(legend_x1 - label_left_offset,
label_top - label_height,
legend_x2 - label_left_offset,
label_top, "NDC NB")
zpj_pt.SetFillStyle(0)
zpj_pt.SetBorderSize(0)
text = zpj_pt.AddText(qgc.ZpJ_LABEL)
text.SetTextAlign(11)
text.SetTextFont(62)
text.SetTextSize(label_text_size)
dummies.append(zpj_pt)
dummies.append(text)
zpj_pt.Draw()
for cont in zpj_entries:
this_dummy_entry = dummy_gr.Clone()
cont.update_obj_styling(this_dummy_entry)
if "\n" in cont.label:
parts = cont.label.split("\n")
zpj_legend.AddEntry(
this_dummy_entry,
"#splitline{%s}{%s}" % (parts[0], parts[1]), "LEP")
else:
zpj_legend.AddEntry(this_dummy_entry, cont.label,
"LEP")
dummy_entries.append(this_dummy_entry)
zpj_legend.Draw()
dummies.append(zpj_legend)
# Add legend to ratio plot
plot.subplot_pad.cd()
for e in [plot.subplot_contributions[0]]:
e.Draw("HIST SAME")
for e in [plot.subplot_contributions[1]]:
e.Draw("L SAME")
plot.subplot_leg = ROOT.TLegend(0.3, 0.73, 0.9, 0.9)
plot.subplot_leg.SetTextSize(0.07)
plot.subplot_leg.SetFillStyle(0)
plot.subplot_leg.SetNColumns(2)
plot.subplot_leg.AddEntry(dummy_entries[0], "Detector-level",
"LEP")
plot.subplot_leg.AddEntry(dummy_entries[1], "Particle-level",
"LEP")
plot.subplot_leg.Draw()
plot.canvas.cd()
parts = [
'detector_unfolded', 'dijet' if do_dijet else None,
'zpj' if do_zpj else None, self.append,
'bin_%d' % ibin, 'divBinWidth',
f'{self.paper_str}.{self.output_fmt}'
]
filename = '_'.join([x for x in parts if x])
plot.save("%s/%s" % (self.output_dir, filename))
print("%s/%s" % (self.output_dir, filename))
def plot_unfolded_with_yoda_normalised(self,
do_chi2=False,
do_zoomed=True):
data_total_errors_style = dict(
label="Data (total unc.)",
line_color=self.plot_styles['unfolded_total_colour'],
line_width=self.line_width,
line_style=1,
marker_color=self.plot_styles['unfolded_total_colour'],
marker_style=cu.Marker.get('circle'),
marker_size=self.plot_styles['unfolded_marker_size'],
leg_draw_opt="LEP")
data_stat_errors_style = dict(
label="Data (stat. unc.)",
line_color=self.plot_styles['unfolded_stat_colour'],
line_width=self.line_width,
line_style=1,
marker_color=self.plot_styles['unfolded_stat_colour'],
marker_style=cu.Marker.get('circle'),
marker_size=0.0001,
leg_draw_opt="LEP"
) # you need a non-0 marker to get the horizontal bars at the end of errors
mc_style = dict(label=self.region['mc_label'],
line_color=self.plot_styles['gen_colour'],
line_width=self.line_width,
marker_color=self.plot_styles['gen_colour'],
marker_size=self.plot_styles['gen_marker_size'],
marker_style=self.plot_styles['gen_marker'],
leg_draw_opt="LEP"
if self.plot_styles['gen_marker_size'] > 0 else "LE")
rivet_path, rivet_region, rivet_radius, rivet_lambda, rivet_pt_bins = get_matching_rivet_setup(
self.setup)
for ibin, (bin_edge_low, bin_edge_high) in enumerate(
zip(self.bins[:-1], self.bins[1:])):
hbc_args = dict(ind=ibin, binning_scheme='generator')
mc_gen_hist_bin = self.hist_bin_chopper.get_pt_bin_normed_div_bin_width(
'hist_truth', **hbc_args)
unfolded_hist_bin_stat_errors = self.hist_bin_chopper.get_pt_bin_normed_div_bin_width(
'unfolded_stat_err', **hbc_args)
unfolded_hist_bin_total_errors = self.hist_bin_chopper.get_pt_bin_normed_div_bin_width(
'unfolded', **hbc_args)
# Get RIVET hists, which are absolute counts, so need normalising
rivet_hist_name = '/%s/%s' % (
rivet_path,
rn.get_plot_name(rivet_radius, rivet_region, rivet_lambda,
rivet_pt_bins[ibin]))
rivet_hists = [
qgp.normalise_hist_divide_bin_width(
yoda.root.to_root(ent['yoda_dict'][rivet_hist_name]))
for ent in self.rivet_entries
]
# Create copy of data to go on top of stat unc,
# but remove vertical error bar so we can see the stat unc
# Note that you CAN'T set it to 0, otherwise vertical lines connecting
# bins start being drawn. Instead set it to some super small value.
unfolded_hist_bin_total_errors_marker_noerror = unfolded_hist_bin_total_errors.Clone(
) # clone to avoid restyling the original as well
for i in range(
1,
unfolded_hist_bin_total_errors_marker_noerror.GetNbinsX() +
1):
unfolded_hist_bin_total_errors_marker_noerror.SetBinError(
i, 1E-100)
data_entries = [
Contribution(unfolded_hist_bin_total_errors,
**data_total_errors_style),
Contribution(unfolded_hist_bin_stat_errors,
**data_stat_errors_style),
# do data with black marker to get it on top
Contribution(unfolded_hist_bin_total_errors_marker_noerror,
**data_total_errors_style),
]
# For subplot to ensure only MC errors drawn, not MC+data
data_no_errors = unfolded_hist_bin_total_errors_marker_noerror.Clone(
)
cu.remove_th1_errors(data_no_errors)
this_mc_style = deepcopy(mc_style)
rivet_styles = []
for ind, _ in enumerate(rivet_hists):
s_dict = self.rivet_entries[ind]['style_dict']
rivet_styles.append(
dict(label=s_dict['label'],
line_color=s_dict['color'],
line_width=self.line_width,
marker_color=s_dict['color'],
marker_size=s_dict.get(
'marker_size',
self.plot_styles['gen_marker_size']),
marker_style=s_dict['marker_style'],
leg_draw_opt="LEP"
if self.plot_styles['gen_marker_size'] > 0 else "LE"))
# Calculate chi2 between data and MCs if desired
if do_chi2:
# print("unfolded_alt_truth bin", ibin)
ematrix = self.hist_bin_chopper.get_pt_bin_normed_div_bin_width(
self.unfolder.total_ematrix_name, **hbc_args)
# stats are chi2, ndof, p
mc_stats = calc_chi2_stats(unfolded_hist_bin_total_errors,
mc_gen_hist_bin, ematrix)
# print(mc_stats)
# print(alt_mc_stats)
nbins = sum([
1 for i in range(
1,
unfolded_hist_bin_total_errors.GetNbinsX() + 1)
if unfolded_hist_bin_total_errors.GetBinContent(i) != 0
])
# reduced_chi2 = mc_stats[0] / nbins
# alt_reduced_chi2 = alt_mc_stats[0] / nbins
n_sig_fig = 2
chi2_template = "\n#lower[-0.1]{{(#chi^{{2}} / N_{{bins}} = {chi2:g} / {nbins:d})}}"
this_mc_style['label'] += chi2_template.format(chi2=cu.nsf(
mc_stats[0], n_sig_fig),
nbins=nbins)
for ind, h in enumerate(rivet_hists):
this_stats = calc_chi2_stats(
unfolded_hist_bin_total_errors, h, ematrix)
rivet_styles[ind]['label'] += chi2_template.format(
chi2=cu.nsf(this_stats[0], n_sig_fig), nbins=nbins)
mc_entries = [
Contribution(mc_gen_hist_bin,
subplot=data_no_errors,
**this_mc_style),
]
for h, s_dict in zip(rivet_hists, rivet_styles):
mc_entries.append(
Contribution(h, subplot=data_no_errors, **s_dict))
entries = [
# Draw MC
*mc_entries,
# Draw data after to put on top of MC
*data_entries
]
func_name = cu.get_current_func_name()
if not self.check_entries(entries, "%s bin %d" %
(func_name, ibin)):
return
ymin = 0
if np.any(
cu.th1_to_ndarray(unfolded_hist_bin_total_errors)[0] < 0):
ymin = None # let it do its thing and auto calc ymin
max_rel_err = 0.5 if "multiplicity" in self.setup.angle.var.lower(
) else -1
plot = Plot(
entries,
ytitle=self.setup.pt_bin_normalised_differential_label,
title=self.get_pt_bin_title(bin_edge_low, bin_edge_high),
legend=True,
xlim=qgp.calc_auto_xlim(
entries[2:3],
max_rel_err=0.5), # set x lim to where data is non-0
ylim=[ymin, None],
**self.pt_bin_plot_args)
plot.subplot_title = qgc.SIM_DATA_STR
self._modify_plot_paper(plot)
# disable adding objects to legend & drawing - we'll do it manually
plot.do_legend = False
plot.legend.SetTextSize(0.03)
plot.legend.SetY1(0.6)
plot.legend.SetX1(0.57)
plot.legend.SetX2(0.93)
if len(entries) > 4:
# if lots of entries, try auto-expand
plot.legend.SetY1(0.6 - (0.02 * (len(entries) - 4)))
# plot.legend.SetEntrySeparation(0.005)
subplot_draw_opts = "NOSTACK E1"
plot.plot("NOSTACK E1", subplot_draw_opts)
dummy_graphs = qgp.do_fancy_legend(chain(data_entries[:2],
mc_entries),
plot,
use_splitline=False)
plot.canvas.cd()
plot.legend.Draw()
# Create hists for data with error region for ratio
# Easiest way to get errors right is to do data (with 0 errors)
# and divide by data (with errors), as if you had MC = data with 0 error
data_stat_ratio = data_no_errors.Clone()
data_stat_ratio.Divide(unfolded_hist_bin_stat_errors)
data_stat_ratio.SetFillStyle(3245)
data_stat_ratio.SetFillColor(
self.plot_styles['unfolded_stat_colour'])
data_stat_ratio.SetLineWidth(0)
data_stat_ratio.SetMarkerSize(0)
data_total_ratio = data_no_errors.Clone()
data_total_ratio.Divide(unfolded_hist_bin_total_errors)
data_total_ratio.SetFillStyle(3254)
data_total_ratio.SetFillColor(
self.plot_styles['unfolded_total_colour'])
data_total_ratio.SetLineWidth(0)
data_total_ratio.SetMarkerSize(0)
# now draw the data error shaded area
# this is a bit hacky - basically draw them on the ratio pad,
# then redraw the existing hists & line to get them ontop
# note that we use "same" for all - this is to keep the original axes
# (we may want to rethink this later?)
plot.subplot_pad.cd()
draw_opt = "E2 SAME"
data_stat_ratio.Draw(draw_opt)
data_total_ratio.Draw(draw_opt)
plot.subplot_line.Draw()
plot.subplot_container.Draw("SAME" + subplot_draw_opts)
# Add subplot legend
x_left = 0.25
y_bottom = 0.75
width = 0.67
height = 0.15
plot.subplot_legend = ROOT.TLegend(x_left, y_bottom,
x_left + width,
y_bottom + height)
plot.subplot_legend.AddEntry(data_total_ratio,
qgc.DATA_TOTAL_UNC_STR, "F")
plot.subplot_legend.AddEntry(data_stat_ratio,
qgc.DATA_STAT_UNC_STR, "F")
plot.subplot_legend.SetTextSize(0.085)
plot.subplot_legend.SetFillStyle(0)
plot.subplot_legend.SetNColumns(2)
plot.subplot_legend.Draw()
plot.canvas.cd()
stp = self.setup
fname = f"unfolded_{stp.append}_rivet_bin_{ibin:d}_divBinWidth{stp.paper_str}.{stp.output_fmt}"
self.save_plot(plot, os.path.join(stp.output_dir, fname))
# Do version with small x values only
if do_zoomed:
if self.setup.angle.var in [
"jet_thrust_charged", "jet_width_charged",
"jet_thrust", "jet_width"
]:
# plot.ylim = (1E-5)
plot.y_padding_max_log = 50
plot.y_padding_min_log = 0.5
plot.ylim = None
plot.set_logy(do_exponent=False, do_more_labels=False)
fname = f"unfolded_{stp.append}_alt_truth_bin_{ibin:d}_divBinWidth_logY.{stp.output_fmt}"
self.save_plot(plot, os.path.join(stp.output_dir, fname))
if self.setup.angle.var in [
"jet_LHA_charged", "jet_thrust_charged",
"jet_width_charged", "jet_thrust", "jet_width"
]:
bin_edges = cu.get_bin_edges(mc_gen_hist_bin, 'x')
# get the bin edge thats smallest between 0.2, and 5th bin
bin_lt_lim = [x for x in bin_edges if x < 0.2][-1]
upper_bin = min(bin_edges[5], bin_lt_lim)
plot2 = Plot(
entries,
ytitle=self.setup.pt_bin_normalised_differential_label,
title=self.get_pt_bin_title(bin_edge_low,
bin_edge_high),
xlim=(0, upper_bin),
**self.pt_bin_plot_args)
self._modify_plot(plot2)
plot2.subplot_title = "* / Generator"
plot2.plot("NOSTACK E1")
# plot2.set_logx(do_exponent=False)
fname = f"unfolded_{stp.append}_rivet_bin_{ibin:d}_divBinWidth_lowX.{stp.output_fmt}"
self.save_plot(plot2, os.path.join(stp.output_dir, fname))