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)