flist = []
if os.path.isdir(cmdline_args.indir):
for root, dirs, files in os.walk(cmdline_args.indir):
for fi in files:
flist.append(os.path.join(root, fi))
elif os.path.isfile(cmdline_args.indir):
for line in open(cmdline_args.indir):
flist.append(line.strip())
for fi in flist:
if not fi.endswith(".txt"):
continue
sampn = get_sample_name(fi)
is_signal = sample_types.is_signal(sampn)
isMC = sample_types.is_mc(sampn)
for lep in leptons:
if sampn.startswith("SingleMu") and lep=="ele":
continue
if sampn.startswith("SingleEle") and lep=="mu":
continue
args = " --doControlVars --lepton=%s" % lep
if isMC:
args += " --isMC"
if sample_types.is_powheg(sampn):
args += " --generator=powheg"
#!!!!!!!FIXME: cleverer way of getting the systematic scenario
if "nominal" in fi:
args += " --systematic=nominal"
def combine_templates(templates, patterns, conf):
"""
Args:
"""
hists = {}
hsources = []
for k in ["data", "mc_nom", "mc_varsamp", "mc_varproc"]:
items = templates[patterns[k]]
if len(items)==0:
raise MatchingException("Nothing matched to %s:%s" % (k, patterns[k]))
hsources += items
if len(hsources)==0:
raise ValueError("No histograms matched")
hqcd = NestedDict()
hqcd["nominal"][None] = []
for syst in ["yield", "iso"]:
for sdir in ["up", "down"]:
hqcd[syst][sdir] = []
templates_qcd = templates[patterns["data_antiiso"]]
if len(templates_qcd)==0:
raise MatchingException("Nothing matched to %s:%s" % ("data_antiiso", patterns["data_antiiso"]))
for keys, hist in templates[patterns["data_antiiso"]]:
if keys[1].startswith("antiiso"):
#We have isolation variations
isodir = keys[1].split("_")[1]
if isodir=="nominal":
hqcd["nominal"][None].append(hist)
hup = hist.Clone()
hdown = hist.Clone()
hup.Scale(qcd_yield_variations[0])
hdown.Scale(qcd_yield_variations[1])
hqcd["yield"]["up"].append(hup)
hqcd["yield"]["down"].append(hdown)
elif isodir in ["up", "down"]:
hqcd["iso"][isodir].append(hist)
else:
raise ValueError("Undefined isolation variation direction: %s" % isodir)
#We only have the nominal QCD shape
elif keys[1]=="weight__unweighted":
hqcd["nominal"][None].append(hist)
hup = hist.Clone()
hdown = hist.Clone()
hup.Scale(qcd_yield_variations[0])
hdown.Scale(qcd_yield_variations[1])
hqcd["yield"]["up"].append(hup)
hqcd["yield"]["down"].append(hdown)
#Placeholders for the isolation variation
for isodir in ["up", "down"]:
h = hist.Clone()
hqcd["iso"][isodir].append(h)
else:
raise Exception("Couldn't parse the QCD pattern: %s" % str(keys))
def map_leaves(di, f, equate=True):
for k, v in di.items():
if isinstance(v, dict):
map_leaves(v, f)
else:
if equate:
di[k] = f(v)
else:
f(v)
return di
#Sum the anti-iso data subsamples
map_leaves(hqcd, lambda li: reduce(lambda x,y: x+y, li))
#Normalize the isolation variations to the nominal
map_leaves(hqcd["iso"],
lambda hi:
hi.Scale(hqcd["nominal"][None].Integral() / hi.Integral()) if hi.Integral()>0 else 0,
equate=False
)
#Add the variated data-driven QCD templates
hsources += [
(("data", "qcd", "weight__unweighted"), hqcd["nominal"][None]),
(("data", "qcd", "weight__qcd_yield_up"), hqcd["yield"]["up"]),
(("data", "qcd", "weight__qcd_yield_down"), hqcd["yield"]["down"]),
(("data", "qcd", "weight__qcd_iso_up"), hqcd["iso"]["up"]),
(("data", "qcd", "weight__qcd_iso_down"), hqcd["iso"]["down"]),
]
#f = open('temp.pickle','wb')
#pickle.dump(hsources, f)
#f.close()
#load the histos from the temporary pickle
#f = open('temp.pickle','rb')
#hsources = pickle.load(f)
syst_scenarios = NestedDict()
for (sample_var, sample, weight_var), hist in hsources:
make_hist(hist)
# if "__ele" in weight_var:
# continue
if ".root" in sample:
sample = sample[:sample.index(".root")]
if "__" in weight_var:
spl = weight_var.split("__")
wn = spl[1]
else:
wn = weight_var
sample_var = sample_var.lower()
wtype = None
wdir = None
stype = None
sdir = None
syst = None
#Nominal weight, look for variated samples
if wn=="nominal":
syst = sample_var
elif wn=="unweighted":
syst="unweighted"
else:
#Variated weight, use only nominal sample or data in case of data-driven shapes
if not (sample_var=="nominal" or sample_var=="data"):
continue
syst = wn
if wn==conf.get_nominal_weight() and sample_var=="nominal":
logger.info("Using %s:%s as nominal sample for %s" % (wn, sample_var, sample))
syst_scenarios[sample]["nominal"][None] = hist
#A systematic scenario which has a separate systematic sample
elif sample_var == "syst":
try:
r = get_syst_from_sample_name(sample)
except Exception as e:
logger.warning("Unhandled systematic: %s" % str(e))
r = None
if not r:
continue
sample, systname, d = r
#sample = map_syst_sample_to_nominal(sample)
syst_scenarios[sample][systname][d] = hist
else:
logger.debug("Systematically variated weight: %s:%s %s" % (wn, sample_var, sample))
systname, d = get_updown(syst)
syst_scenarios[sample][systname][d] = hist
logger.info("histogram W3Jets_exclusive nominal: " + "%f %d" % (
syst_scenarios["W3Jets_exclusive"]["nominal"][None].Integral(),
syst_scenarios["W3Jets_exclusive"]["nominal"][None].GetEntries())
)
######################################
### Save systematics, fill missing ###
######################################
#########
# tchan #
#########
#T_t_ToLeptons mass_up is missing, take the mass down and flip the difference with the nominal
mnomt = syst_scenarios["T_t_ToLeptons"]["nominal"][None].Clone()
mdownt = syst_scenarios["T_t_ToLeptons"]["mass"]["down"].Clone()
mupt = (mnomt+mnomt-mdownt)
syst_scenarios["T_t_ToLeptons"]["mass"]["up"] = mupt
#########
# TTBar #
#########
#TTbar variations are provided for the inclusive only, fill them for the exclusive
nom_ttbar = syst_scenarios["TTJets_FullLept"]["nominal"][None] + syst_scenarios["TTJets_SemiLept"]["nominal"][None]
for syst in ["mass", "ttbar_scale", "ttbar_matching"]:
for sample in ["TTJets_FullLept", "TTJets_SemiLept"]:
for sd in ["up", "down"]:
syst_scenarios[sample][syst][sd] = syst_scenarios[sample]["nominal"][None] * syst_scenarios["TTJets"][syst][sd] / nom_ttbar
syst_scenarios.pop("TTJets")
syst_scenarios = syst_scenarios.as_dict()
#Create the output file
p = os.path.dirname(conf.get_outfile_unmerged())
if not os.path.exists(p):
os.makedirs(p)
of = ROOT.TFile(conf.get_outfile_unmerged() , "RECREATE")
of.cd()
#Get the list of all possible systematic scenarios that we have available
allsysts = get_all_systs(syst_scenarios)
for sampn, h1 in syst_scenarios.items():
#Consider all the possible systematic scenarios
for systname in allsysts:
#If we have it available, fine, use it
if systname in h1.keys():
h2 = h1[systname]
#If not, in case of MC and a non-trivial variation
elif not sampn.startswith("Single") and systname not in ["unweighted", "nominal"]:
#Try to get the unvariated template as a placeholder
h = h1.get("nominal", None)
if not h:
h = h1.get("unweighted", None)
if not h:
raise Exception("Could not get the nominal template for %s:%s" % (sampn, systname))
#Our convention is that even the unvariated template is a dict with a single
#key for the direction of variation, which is 'None'
h = h[None]
#Add placeholder templates
for systdir in ["up", "down"]:
h = h.Clone(hname_encode(conf.varname, sampn, systname, systdir))
set_missing_hist(h)
#Save to file
h.SetDirectory(of)
h.Write()
continue
else:
continue
for systdir, h in h2.items():
if systdir==None and systname=="nominal" or not sample_types.is_mc(sampn):
h = h.Clone(hname_encode(conf.varname, sampn))
elif systdir==None and systname=="unweighted":
h = h.Clone(hname_encode(conf.varname, sampn, "unweighted"))
else:
h = h.Clone(hname_encode(conf.varname, sampn, systname, systdir))
h.SetDirectory(of)
h.Write()
nkeys = len(of.GetListOfKeys())
logger.info("Saved %d histograms to file %s" % (nkeys, of.GetPath()))
# of.Close()
########################
### Load systematics ###
########################
# of_unmerged = File(conf.get_outfile_unmerged())
hists = dict()
# ROOT.gROOT.cd()
for k in of.GetListOfKeys():
hists[k.GetName()] = of.Get(k.GetName())
h = hists[k.GetName()]
#hists[k.GetName()].Rebin(2)
logger.info("Loaded %d histograms from file %s" % (len(hists), of.GetPath()))
#of_unmerged.Close()
########################
### Merge ###
########################
from plots.common.utils import merge_hists, PhysicsProcess
merge_cmds = PhysicsProcess.get_merge_dict(
PhysicsProcess.get_proc_dict(conf.channel)
)
hsysts = NestedDict()
for k, v in hists.items():
spl = split_name(k)
hsysts[spl["type"]][spl["dir"]][spl["sample"]] = v
hsysts = hsysts.as_dict()
p = os.path.dirname(conf.get_outfile_merged())
if not os.path.exists(p):
os.makedirs(p)
of = ROOT.TFile(conf.get_outfile_merged(), "RECREATE")
of.cd()
for syst, h1 in hsysts.items():
if syst in skipped_systs:
continue
for sdir, h2 in h1.items():
hmc = merge_hists(h2, merge_cmds)
for hn, h in hmc.items():
if syst=="nominal" or syst=="unweighted":
h.SetName("__".join([spl["var"], hn]))
else:
h.SetName("__".join([spl["var"], hn, syst, sdir]))
h.SetDirectory(of)
h.Write()
nkeys = len(of.GetListOfKeys())
logger.info("Saved %d histograms to file %s" % (nkeys, of.GetPath()))
of.Close()
hists = load_theta_format(conf.get_outfile_merged())
processes = []
systs = []
for (variable, sample, syst, systdir), v in hists.items_flat():
processes.append(sample)
systs.append(syst)
processes = set(processes)
systs = set(systs)
logger.info("Processes: %s" % processes)
if not processes == set(['diboson', 'schan', 'tWchan', 'TTJets', 'tchan', 'WJets', 'qcd', 'DYJets', 'data']):
raise Exception("Combined file did not contain the necessary processes: %s" % str(processes))
logger.info("Systematic scenarios: %s" % systs)
def data_mc_plot(pd):
hists = load_theta_format(pd.infile, styles)
for (variable, sample, systtype, systdir), hist in hists.items_flat():
#Scale all MC samples except QCD to the luminosity
if sample_types.is_mc(sample) and not sample=="qcd":
hist.Scale(pd.lumi)
if hasattr(pd, "rebin"):
hist.Rebin(pd.rebin)
if sample=="qcd" and hasattr(pd, "qcd_yield"):
hist.Scale(pd.qcd_yield / hist.Integral())
rescale_to_fit(sample, hist, pd.process_scale_factor)
hist.SetTitle(sample)
hist.SetName(sample)
#Assuming we only have 1 variable
hists = hists[pd.var]
hists_nominal = hists.pop("nominal")[None]
hists_nom_data = hists_nominal.pop('data')
hists_nom_mc = hists_nominal.values()
hists_syst = hists
hists_nom_data.SetTitle('data')
#A list of all the systematic up, down variation templates as 2-tuples
all_systs = [
]
all_systs = hists_syst.keys()
systs_to_consider = []
#See which systematics where asked to switch on
for syst in all_systs:
for sm in pd.systematics:
if re.match(sm, syst):
systs_to_consider.append(syst)
#The total nominal MC histogram
nom = sum(hists_nom_mc)
if pd.normalize:
ratio = hists_nom_data.Integral() / nom.Integral()
hists_nom_data.Scale(1.0/ratio)
#Get all the variated up/down total templates
#A list with all the up/down total templates
all_systs = []
sumsqs = []
logger.info("Considering systematics %s" % str(systs_to_consider))
for syst in systs_to_consider:
#A list with the up/down variated template for a particular systematic
totupdown = []
sumsq = []
for systdir in ["up", "down"]:
#Get all the templates corresponding to a systematic scenario and a variation
_hists = hists_syst[syst][systdir]
for k, h in _hists.items():
"""
Consider only the shape variation of the systematic,
hence the variated template is normalized to the corresponding
unvariated template.
"""
if pd.systematics_shapeonly:
if h.Integral()>0:
h.Scale(hists_nominal[k].Integral() / h.Integral())
#For the missing variated templates, use the nominal ones, but warn the user
present = set(_hists.keys())
all_mc = set(hists_nominal.keys())
missing = list(all_mc.difference(present))
for m in missing:
logger.warning("Missing systematic template for %s:%s" % (syst, systdir))
#Calculate the total variated template
tot = sum(_hists.values()) + sum([hists_nominal[m] for m in missing])
totupdown.append(tot)
sumsq.append(
math.sqrt(numpy.sum(numpy.power(numpy.array(list(nom.y())) - numpy.array(list(tot.y())), 2)))
)
logger.debug("Systematic %s: sumsq=%.2Eu, %.2Ed" % (syst, sumsq[0], sumsq[1]))
sumsqs.append((syst, max(sumsq)))
all_systs.append(
(syst, tuple(totupdown))
)
sumsqs = sorted(sumsqs, key=lambda x: x[1], reverse=True)
for syst, sumsq in sumsqs[0:7]:
logger.info("Systematic %s, %.4f" % (syst, sumsq))
#Calculate the total up/down variated templates by summing in quadrature
syst_stat_up, syst_stat_down = total_syst(
nom, all_systs,
)
for k, v in hists_nominal.items():
if hasattr(PhysicsProcess, k):
pp = getattr(PhysicsProcess, k)
v.SetTitle(pp.pretty_name)
else:
logger.warning("Not setting pretty name for %s" % k)
#If QCD is high-stats, put it in the bottom
plotorder = copy.copy(PhysicsProcess.desired_plot_order_mc)
if hists_nominal["qcd"].GetEntries()>100:
plotorder.pop(plotorder.index("qcd"))
plotorder.insert(0, "qcd")
stacks_d = OrderedDict()
stacks_d['mc'] = reorder(hists_nominal, plotorder)
stacks_d['data'] = [hists_nom_data]
#Systematic style
for s in [syst_stat_up, syst_stat_down]:
s.SetFillStyle(0)
s.SetLineWidth(3)
s.SetMarkerSize(0)
s.SetLineColor(ROOT.kBlue+2)
s.SetLineStyle('dashed')
s.SetTitle("stat. + syst.")
#c = ROOT.TCanvas("c", "c", 1000, 1000)
c = ROOT.TCanvas("c", "c")
p1 = ROOT.TPad("p1", "p1", 0, 0.3, 1, 1)
p1.Draw()
p1.SetTicks(1, 1);
p1.SetGrid();
p1.SetFillStyle(0);
p1.cd()
stacks = plot_hists_stacked(
p1, stacks_d,
x_label=pd.get_x_label(), max_bin_mult=pd.get_max_bin_mult(),
min_bin=pd.get_min_bin()
)
p1.SetLogy(pd.log)
syst_stat_up.Draw("SAME hist")
syst_stat_down.Draw("SAME hist")
ratio_pad, hratio = plot_data_mc_ratio(
c, hists_nom_data,
nom, syst_hists=(syst_stat_down, syst_stat_up), min_max=pd.get_ratio_minmax()
)
p1.cd()
leg = legend(
stacks_d['data'] +
list(reversed(stacks_d['mc'])) +
[syst_stat_up],
nudge_x=pd.legend_nudge_x,
nudge_y=pd.legend_nudge_y,
**pd.__dict__
)
lb = lumi_textbox(pd.lumi,
line2=pd.get_lumibox_comments(channel=pd.channel_pretty),
pos=pd.get_lumi_pos()
)
c.children = [p1, ratio_pad, stacks, leg, lb]
tot = 0
for k, v in hists_nominal.items():
print k, v.Integral(), v.GetEntries()
tot += v.Integral()
tot_data = hists_nom_data.Integral()
print "MC: %.2f Data: %.2f" % (tot, tot_data)
#import pdb; pdb.set_trace()
return c, (hists_nominal, hists_nom_data)
def plot_sherpa_vs_madgraph(var, cut_name, cut, samples, out_dir, recreate=False, **kwargs):
hname = var["varname"]
out_dir = out_dir + "/" + cut_name
if recreate and os.path.exists(out_dir):
logger.info("Output directory %s exists, removing" % out_dir)
shutil.rmtree(out_dir)
mkdir_p(out_dir)
logger.info("Using output directory %s" % out_dir)
logger.info("Using output directory %s" % out_dir)
coll = data_mc(var["var"], cut_name, cut, Weights.total()*Weights.mu, samples, out_dir, recreate, LUMI_TOTAL, reweight_madgraph=True, flavour_split=True, plot_range=var["range"], **kwargs)
logging.debug(str(coll.hists))
for hn, hist in coll.hists.items():
sample_name = coll.metadata[hn].sample_name
process_name = coll.metadata[hn].process_name
match = re.match(".*/cut__flavour__(W_[Hl][Hl])/.*", hn)
if match:
flavour_scenario = match.group(1)
else:
flavour_scenario = None
try:
if sample_types.is_mc(sample_name):
Styling.mc_style(hist, process_name)
else:
Styling.data_style(hist)
except KeyError as e:
logger.warning("Couldn't style histogram %s" % hn)
if flavour_scenario:
logger.debug("Matched flavour split histogram %s, %s" % (hn, flavour_scenario))
#Styling.mc_style(hist, process_name)
if re.match("W_H[lH]", flavour_scenario):
logger.debug("Changing colour of %s" % (hn))
hist.SetFillColor(hist.GetFillColor()+1)
hist.SetLineColor(hist.GetLineColor()+1)
logger.debug("pre merge: %s" % str([ (hn, coll.hists[hn].GetLineColor()) for hn in coll.hists.keys() if "sherpa" in hn]))
merges = dict()
merge_cmds = get_merge_cmds()
merge_cmds.pop("WJets")
merges["madgraph/unweighted"] = merge_cmds.copy()
merges["madgraph/weighted"] = merge_cmds.copy()
merges["sherpa/unweighted"] = merge_cmds.copy()
merges["sherpa/weighted"] = merge_cmds.copy()
merges["sherpa/unweighted"]["WJets_hf"] = ["weight__nominal/cut__flavour__W_heavy/WJets_sherpa_nominal"]
merges["sherpa/unweighted"]["WJets_lf"] = ["weight__nominal/cut__flavour__W_light/WJets_sherpa_nominal"]
merges["sherpa/weighted"]["WJets_hf"] = ["weight__sherpa_flavour/cut__flavour__W_heavy/WJets_sherpa_nominal"]
merges["sherpa/weighted"]["WJets_lf"] = ["weight__sherpa_flavour/cut__flavour__W_light/WJets_sherpa_nominal"]
merges["madgraph/unweighted"]["WJets_hf"] = ["weight__nominal/cut__flavour__W_heavy/W[1-4]Jets_exclusive"]
merges["madgraph/unweighted"]["WJets_lf"] = ["weight__nominal/cut__flavour__W_light/W[1-4]Jets_exclusive"]
merges["madgraph/weighted"]["WJets_hf"] = ["weight__reweight_madgraph/cut__flavour__W_heavy/W[1-4]Jets_exclusive"]
merges["madgraph/weighted"]["WJets_lf"] = ["weight__reweight_madgraph/cut__flavour__W_light/W[1-4]Jets_exclusive"]
hmerged = dict()
for k in merges.keys():
hmerged[k] = merge_hists(copy.deepcopy(coll.hists), merges[k])
logger.debug("post merge: %s" % str([ (hn, hmerged["sherpa/weighted"][hn].GetLineColor()) for hn in hmerged["sherpa/weighted"].keys()]))
#w_mg_sh = 1.0416259307303726 #sherpa to madgraph ratio
w_mg_sh = 1.0821535639376414
hmerged["sherpa/weighted"]["WJets_hf"].Scale(w_mg_sh)
hmerged["sherpa/weighted"]["WJets_lf"].Scale(w_mg_sh)
logger.info("Drawing madgraph unweighted plot")
canv = ROOT.TCanvas("c2", "c2")
suffix = "__%s__%s" % (var["var"], cut_name)
suffix = escape(suffix)
plot(canv, "madgraph_unw"+suffix, hmerged["madgraph/unweighted"], out_dir, **kwargs)
kwargs = dict({"x_label": var["varname"]}, **kwargs)
for k, v in hmerged.items():
logger.debug("Group %s" % k)
for hn, h in v.items():
logger.debug("Sample %s = %.2f" % (hn, h.Integral()))
logger.info("%s data=%.2f" % (k, v["data"].Integral()))
logger.info("%s MC=%.2f" % (k, sum([h.Integral() for k, h in v.items() if k!="data"])))
hists_flavours_merged = dict()
hists_flavours_merged["madgraph/weighted"] = merge_hists(hmerged["madgraph/weighted"], {"WJets": ["WJets_hf", "WJets_lf"]})
hists_flavours_merged["madgraph/unweighted"] = merge_hists(hmerged["madgraph/unweighted"], {"WJets": ["WJets_hf", "WJets_lf"]})
hists_flavours_merged["sherpa/unweighted"] = merge_hists(hmerged["sherpa/unweighted"], {"WJets": ["WJets_hf", "WJets_lf"]})
hists_flavours_merged["sherpa/weighted"] = merge_hists(hmerged["sherpa/weighted"], {"WJets": ["WJets_hf", "WJets_lf"]})
logger.info("Drawing sherpa weighted plot")
canv = ROOT.TCanvas("c1", "c1")
plot(canv, "sherpa_rew"+suffix, hmerged["sherpa/weighted"], out_dir, **kwargs)
logger.info("Drawing sherpa unweighted plot")
canv = ROOT.TCanvas("c1", "c1")
plot(canv, "sherpa_unw"+suffix, hmerged["sherpa/unweighted"], out_dir, **kwargs)
logger.info("Drawing madgraph plot")
canv = ROOT.TCanvas("c2", "c2")
plot(canv, "madgraph_rew"+suffix, hmerged["madgraph/weighted"], out_dir, **kwargs)
total_madgraph = copy.deepcopy(hmerged["madgraph/unweighted"])
merged_colls = dict()
for k, v in hmerged.items():
merged_colls[k] = HistCollection(copy.deepcopy(v), name=k)
logger.info("Drawing sherpa vs. madgraph shape comparison plots")
hists = [
("sherpa unw hf", hmerged["sherpa/unweighted"]["WJets_hf"]),
("sherpa rew hf", hmerged["sherpa/weighted"]["WJets_hf"]),
("madgraph unw hf", hmerged["madgraph/unweighted"]["WJets_hf"]),
("madgraph rew hf", hmerged["madgraph/weighted"]["WJets_hf"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.SaveAs(out_dir + "/weighted_flavour_hf_%s.png" % hname)
canv.Close()
hists = [
("data", hmerged["madgraph/unweighted"]["data"]),
("sherpa", hists_flavours_merged["sherpa/unweighted"]["WJets"]),
("madgraph", hists_flavours_merged["madgraph/unweighted"]["WJets"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.SaveAs(out_dir + "/unweighted_sherpa_mg_%s.png" % hname)
canv.Close()
hists = [
("data", hmerged["madgraph/unweighted"]["data"]),
("sherpa", hists_flavours_merged["sherpa/weighted"]["WJets"]),
("madgraph", hists_flavours_merged["madgraph/weighted"]["WJets"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.SaveAs(out_dir + "/weighted_sherpa_mg_%s.png" % hname)
canv.Close()
hists = [
("sherpa unw lf", hmerged["sherpa/unweighted"]["WJets_lf"]),
("sherpa rew lf", hmerged["sherpa/weighted"]["WJets_lf"]),
("madgraph unw lf", hmerged["madgraph/unweighted"]["WJets_lf"]),
("madgraph rew lf", hmerged["madgraph/weighted"]["WJets_lf"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
canv.SaveAs(out_dir + "/weighted_flavour_lf_%s.png" % hname)
canv.Close()
hists = [
("data", hmerged["madgraph/unweighted"]["data"]),
("madgraph unw", hists_flavours_merged["madgraph/unweighted"]["WJets"]),
("madgraph rew", hists_flavours_merged["madgraph/weighted"]["WJets"]),
("sherpa unw", hists_flavours_merged["sherpa/unweighted"]["WJets"]),
("sherpa rew", hists_flavours_merged["sherpa/weighted"]["WJets"]),
]
hists = copy.deepcopy(hists)
for hn, h in hists:
h.SetTitle(hn + " %.2f" % h.Integral())
h.Scale(1.0/h.Integral())
hists = [h[1] for h in hists]
ColorStyleGen.style_hists(hists)
canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
leg = legend(hists, styles=["f", "f"], **kwargs)
hists[0].SetTitle("")
canv.Update()
canv.SaveAs(out_dir + "/shapes_%s.png" % hname)
canv.Close()
# hists = [
# ("sherpa hf", hmerged["sherpa"]["WJets_hf"]),
# ("madgraph unw hf", hmerged["madgraph/unweighted"]["WJets_hf"]),
# ("madgraph rew hf", hmerged["madgraph/weighted"]["WJets_hf"]),
# ]
# hists = copy.deepcopy(hists)
# for hn, h in hists:
# h.SetTitle(hn + " %.2f" % h.Integral())
# h.Scale(1.0/h.Integral())
# hists = [h[1] for h in hists]
# ColorStyleGen.style_hists(hists)
# canv = plot_hists(hists, x_label=var["varname"], do_chi2=True)
# leg = legend(hists, styles=["f", "f"], **kwargs)
# hists[0].SetTitle("madgraph sherpa rew hf")
# canv.SaveAs(out_dir + "/shapes_hf_%s.png" % hname)
# canv.Close()
return coll, merged_colls
def style_collection(coll):
for hn, h in coll.hists.items():
if sample_types.is_mc(hn):
Styling.mc_style(h, hn)
else:
Styling.data_style(h)
