Exemple #1
0
def plot_hists_dict(hist_dict, setNames=True, **kwargs):
    """
    Draws the contents of a dictionary of hists. Styling will be done
    automatically. Any additional kwargs are passed to the plot_hists and legend
    methods.

    Args:
        hist_dict: a str, Hist dictionary of the histograms to be drawn.

    Keywords:
        setNames: a bool to specify whether the keys of the dict will be used as
            titles in the legend.

    Returns: a handle to the new canvas
    """
    items = hist_dict.items()
    for hn, h in items:
        h.SetName(hn)
        if setNames:
            h.SetTitle(hn)
    hists = [x[1] for x in items]
    names = [x[0] for x in items]
    ColorStyleGen.style_hists(hists)
    canv = plot_hists(hists, **kwargs)

    leg = legend(hists, styles=["f", "f"], **kwargs)
    canv.LEGEND = leg
    return canv
Exemple #2
0
    def plot_data_mc(hists_mc, hist_data, name):
        canv = ROOT.TCanvas()
        p1 = ROOT.TPad("p1", "p1", 0, 0.3, 1, 1)
        p1.Draw()
        p1.SetTicks(1, 1);
        p1.SetGrid();
        p1.SetFillStyle(0);
        p1.cd()

        stacks_d = OrderedDict()
        print "MC",hists_mc
        print "VAL",hists_mc.values()
        stacks_d["mc"] = hists_mc.values()
        stacks_d["data"] = [hist_data]
        stacks = plot_hists_stacked(
            p1,
            stacks_d,
            x_label=var,
            y_label="",
            do_log_y=True
        )
        leg = legend([hist_data] + list(reversed(hists_mc.values())), styles=["p", "f"])
        print canv, hist_data
        print get_stack_total_hist(stacks["mc"])
        ratio_pad, hratio = plot_data_mc_ratio(canv, get_stack_total_hist(stacks["mc"]), hist_data)

        plot_info = PlotMetaInfo(
            name,
            "CUT",
            "WEIGHT",
            [infile],
            subdir=fit.name,
            comments=str(result[SIGNAL])
        )
        of.savePlot(canv, plot_info)
        canv.Close()
Exemple #3
0
        legend_pos = "top-right"

    if legend_pos == "top-right":
        lumibox = lumi_textbox(Lumi,"top-left")
    if legend_pos == "top-left":
        lumibox = lumi_textbox(Lumi,"top-right")
    
    hist_list = mc_to_plot.values()
    hist_list.reverse() # reverse order of mc histograms for the legend entry
    hist_list.append(qcd)
    hist_list.insert(0,data)
    
    leg = legend(
        hist_list,
        names = process_names,
        styles=["p", "f"],
        width=0.25,
        pos = legend_pos
        )

    outfilename = "Plots/" + channel + "/" + mode1 + mode1a + "/" + hist_to_plot + mode2 + weight + ".pdf"
    if not os.path.exists(os.path.dirname(outfilename)):
        os.makedirs(os.path.dirname(outfilename))
    c.SaveAs(outfilename)
    c.Close()

    #----------------Signal PDG ID information------------------
#    nr_W = 0
#    nr_tau = 0
    if hist_to_plot == "el_mother_id" or hist_to_plot == "mu_mother_id":
        nr_W = mc_to_plot["signal"].GetBinContent(2) + mc_to_plot["signal"].GetBinContent(50)
Exemple #4
0
    hcomphep.SetLineStyle('dashed')
    hcomphep.SetMarkerSize(0)

    Styling.data_style(data_post)

    hi = [data_post, htrue, hcomphep]
    chi2 = data_post.Chi2Test(htrue, "WW CHI2/NDF")
    #htrue.SetTitle(htrue.GetTitle() + " #chi^{2}/#nu = %.1f" % chi2)
    #hi_norm = hi
    hi_norm = map(post_normalize, hi)
    for h in hi[1:]:
        h.SetMarkerSize(0)
    of = OutputFolder(subdir='unfolding/%s' % lep)
    canv = plot_hists(hi_norm, x_label="cos #theta*", draw_cmd=len(hi)*["E1"], y_label="a.u.")
    #leg = legend(hi, styles=['p', 'f'], legend_pos='bottom-right', nudge_x=-0.29, nudge_y=-0.08)
    leg = legend(hi, styles=['p', 'f'], legend_pos='top-left', nudge_y=-0.14)
    lb = lumi_textbox(lumi,
        pos='top-center',
        line2="#scale[1.5]{A = %.2f #pm %.2f (stat.) #pm %.2f (syst.)}" % (
            measured_asym, measured_asym_errs[lep][0],  measured_asym_errs[lep][1]
        ), nudge_y=0.03
    )
    pmi = PlotMetaInfo(
        'costheta_unfolded',
        '2j1t_mva_loose {0}'.format(channel),
        'weighted to lumi={0}, sf(tchan)={1}'.format(lumi, fitpars[lep]),
        [args.infileMC, args.infileD]
    )

    of.savePlot(canv, pmi)
Exemple #5
0
def data_mc_plot(samples, plot_def, name, lepton_channel, lumi, weight, physics_processes, use_antiiso=False):

    logger.info('Plot in progress %s' % name)

    merge_cmds = PhysicsProcess.get_merge_dict(physics_processes) #The actual merge dictionary

    var = plot_def['var']

    #Id var is a list/tuple, assume
    if not isinstance(var, basestring):
        try:
            if lepton_channel == 'ele':
                var = var[0]
            elif lepton_channel == 'mu':
                var = var[1]
        except Exception as e:
            logger.error("Plot variable 'var' specification incorrect for multi-variable plot: %s" % str(var))
            raise e
    cut = None
    if lepton_channel == 'ele':
        cut = plot_def['elecut']
    elif lepton_channel == 'mu':
        cut = plot_def['mucut']

    cut_str = str(cut)

    plot_range = plot_def['range']

    do_norm = False
    if 'normalize' in plot_def.keys() and plot_def['normalize']:
        do_norm = True
    hists_mc = dict()
    hists_data = dict()
    for name, sample in samples.items():
        logger.debug("Starting to plot %s" % name)
        if sample.isMC:
            hist = sample.drawHistogram(var, cut_str, weight=str(weight), plot_range=plot_range)
            hist.Scale(sample.lumiScaleFactor(lumi))
            hists_mc[sample.name] = hist
            if do_norm:
                Styling.mc_style_nostack(hists_mc[sample.name], sample.name)
            else:
                Styling.mc_style(hists_mc[sample.name], sample.name)

            if "fitpars" in plot_def.keys():
                rescale_to_fit(sample.name, hist, plot_def["fitpars"][lepton_channel])
        elif "antiiso" in name and plot_def['estQcd'] and not use_antiiso:

            # Make loose template
            #Y U NO LOOP :) -JP
            region = '2j1t'
            if '2j0t' in plot_def['estQcd']: region='2j0t'
            if '3j0t' in plot_def['estQcd']: region='3j0t'
            if '3j1t' in plot_def['estQcd']: region='3j1t'
            if '3j2t' in plot_def['estQcd']: region='3j2t'

            qcd_extra_cut = Cuts.deltaR(0.3)*Cuts.antiiso(lepton_channel)

            #Take the loose template with a good shape from the N-jet, M-tag, post lepton selection region with high statistics
            qcd_loose_cut = cutlist[region]*cutlist['presel_'+lepton_channel]*qcd_extra_cut

            #Take the template which can be correctly normalized from the actual region with inverted isolation cuts
            qcd_cut = cut*qcd_extra_cut

            hist_qcd_loose = sample.drawHistogram(var, str(qcd_loose_cut), weight="1.0", plot_range=plot_range)
            hist_qcd = sample.drawHistogram(var, str(qcd_cut), weight="1.0", plot_range=plot_range)
            logger.debug("Using the QCD scale factor %s: %.2f" % (plot_def['estQcd'], qcdScale[lepton_channel][plot_def['estQcd']]))
            

            hist_qcd.Scale(qcdScale[lepton_channel][plot_def['estQcd']])
            hist_qcd_loose.Scale(hist_qcd.Integral()/hist_qcd_loose.Integral())
            if var=='cos_theta':
                hist_qcd=hist_qcd_loose
            sampn = "QCD"+sample.name

            #Rescale the QCD histogram to the eta_lj fit
            if "fitpars" in plot_def.keys():
                rescale_to_fit(sampn, hist_qcd, plot_def["fitpars"][lepton_channel])

            hists_mc[sampn] = hist_qcd
            hists_mc[sampn].SetTitle('QCD')
            if do_norm:
                Styling.mc_style_nostack(hists_mc[sampn], 'QCD')
            else:
                Styling.mc_style(hists_mc[sampn], 'QCD')

        #Real ordinary data in the isolated region
        elif not "antiiso" in name or use_antiiso:
            hist_data = sample.drawHistogram(var, cut_str, weight="1.0", plot_range=plot_range)
            hist_data.SetTitle('Data')
            Styling.data_style(hist_data)
            hists_data[name] = hist_data


    if len(hists_data.values())==0:
        raise Exception("Couldn't draw the data histogram")

    #Combine the subsamples to physical processes
    hist_data = sum(hists_data.values())
    merge_cmds['QCD']=["QCD"+merge_cmds['data'][0]]
    order=['QCD']+PhysicsProcess.desired_plot_order
    if plot_def['log']:
        order = PhysicsProcess.desired_plot_order_log+['QCD']
    merged_hists = merge_hists(hists_mc, merge_cmds, order=order)

    if hist_data.Integral()<=0:
        logger.error(hists_data)
        logger.error("hist_data.entries = %d" % hist_data.GetEntries())
        logger.error("hist_data.integral = %d" % hist_data.Integral())
        raise Exception("Histogram for data was empty. Something went wrong, please check.")

    if do_norm:
        for k,v in merged_hists.items():
            v.Scale(1./v.Integral())
        hist_data.Scale(1./hist_data.Integral())

    htot = sum(merged_hists.values())

    chi2 = hist_data.Chi2Test(htot, "UW CHI2/NDF")
    if chi2>20:#FIXME: uglyness
        logger.error("The chi2 between data and MC is large (%s, chi2=%.2f). You may have errors with your samples!" %
            (name, chi2)
        )
        logger.info("MC  : %s" % " ".join(map(lambda x: "%.1f" % x, list(htot.y()))))
        logger.info("DATA: %s" % " ".join(map(lambda x: "%.1f" % x, list(hist_data.y()))))
        logger.info("diff: %s" % str(
            " ".join(map(lambda x: "%.1f" % x, numpy.abs(numpy.array(list(htot.y())) - numpy.array(list(hist_data.y())))))
        ))

    merged_hists_l = merged_hists.values()

    PhysicsProcess.name_histograms(physics_processes, merged_hists)

    leg_style = ['p','f']
    if do_norm:
        leg_style=['p','l']
    leg = legend([hist_data] + list(reversed(merged_hists_l)), legend_pos=plot_def['labloc'], styles=leg_style)

    canv = ROOT.TCanvas()

    #Make the stacks
    stacks_d = OrderedDict()
    stacks_d["mc"] = merged_hists_l
    stacks_d["data"] = [hist_data]

    #label
    xlab = plot_def['xlab']
    if not isinstance(xlab, basestring):
        if lepton_channel == 'ele':
            xlab = xlab[0]
        else:
            xlab = xlab[1]
    ylab = 'N / '+str((1.*(plot_range[2]-plot_range[1])/plot_range[0]))
    if plot_def['gev']:
        ylab+=' GeV'
    fact = 1.5
    if plot_def['log']:
        fact = 10

    plow=0.3
    if do_norm:
        plow=0

    #Make a separate pad for the stack plot
    p1 = ROOT.TPad("p1", "p1", 0, plow, 1, 1)
    p1.Draw()
    p1.SetTicks(1, 1);
    p1.SetGrid();
    p1.SetFillStyle(0);
    p1.cd()

    stacks = plot_hists_stacked(p1, stacks_d, x_label=xlab, y_label=ylab, max_bin_mult = fact, do_log_y = plot_def['log'], stack = (not do_norm))

    #Put the the lumi box where the legend is not
    boxloc = 'top-right'
    if plot_def['labloc'] == 'top-right':
        boxloc = 'top-left'
    chan = 'Electron'
    if lepton_channel == "mu":
        chan = 'Muon'

    additional_comments = ""
    if 'cutname' in plot_def.keys():
        additional_comments += ", " + plot_def['cutname'][lepton_channel]
    lbox = lumi_textbox(lumi,
        boxloc,
        'preliminary',
        chan + ' channel' + additional_comments
    )

    #Draw everything
    lbox.Draw()
    leg.Draw()
    canv.Draw()

    #Keep the handles just in case
    canv.PAD1 = p1
    canv.STACKS = stacks
    canv.LEGEND = legend
    canv.LUMIBOX = lbox

    return canv, merged_hists, htot, hist_data
Exemple #6
0
def plot_fit(var, fitConf, hData, fit_result):
   tdrstyle()
   canvases = []
   infile = "fits/"+var.shortName+"_fit_"+fitConf.name+".root"
   f = TFile(infile)
   
   print fitConf.name
   outfile_name = "fit_plots/"+var.shortName+"_Fit_"+fitConf.name
   
   #print fit_result
   QCDRATE = fit_result.qcd
   QCDRATE_UP = fit_result.qcd + fit_result.qcd_uncert
   QCDRATE_DOWN = fit_result.qcd - fit_result.qcd_uncert
   NONQCDRATE = fit_result.nonqcd
   NONQCDRATE_UP = fit_result.nonqcd + fit_result.nonqcd_uncert
   NONQCDRATE_DOWN = fit_result.nonqcd - fit_result.nonqcd_uncert
   WJETS = fit_result.wjets
   WJETS_UP = fit_result.wjets + fit_result.wjets_uncert
   WJETS_DOWN = fit_result.wjets - fit_result.wjets_uncert
      
   cst = TCanvas("Histogram_"+fitConf.name,fitConf.name,10,10,1000,1000)
   
   hNonQCD = TH1D(f.Get(var.shortName+"__nonqcd"))
   hNonQCD.SetTitle("Non-QCD")   
   hNonQCD.SetLineColor(kRed)
      
   hNonQCDp=TH1D(hNonQCD)
   hNonQCDp.Scale(NONQCDRATE_UP/NONQCDRATE)
   hNonQCDm=TH1D(hNonQCD)
   hNonQCDm.Scale(NONQCDRATE_DOWN/NONQCDRATE)
      
   hNonQCDp.SetLineColor(kOrange)
   hNonQCDp.SetTitle("Non-QCD #pm 1 #sigma")
   hNonQCDm.SetLineColor(kOrange)
   hNonQCDm.SetTitle("non-QCD - 1 sigma")

   hWJets = TH1D(f.Get(var.shortName+"__wjets"))
   hWJets.SetTitle("W+Jets")   
   hWJets.SetLineColor(kGreen+4)
      
   hWJetsp=TH1D(hWJets)
   hWJetsp.Scale(WJETS_UP/WJETS)
   hWJetsm=TH1D(hWJets)
   hWJetsm.Scale(WJETS_DOWN/WJETS)
      
   hWJetsp.SetLineColor(kGreen+8)
   hWJetsp.SetTitle("W+Jets #pm 1 #sigma")
   hWJetsm.SetLineColor(kGreen+8)
   hWJetsm.SetTitle("W+Jets - 1 sigma")
      
   hData.SetNameTitle(var.shortName+"__DATA", "Data")
   hData.SetMarkerStyle(20)

   #print "data integral: ",hData.Integral()
   hQCD = f.Get(var.shortName+"__qcd")
   hQCD.SetNameTitle(var.shortName+"__qcd", "QCD")
   hQCD.SetLineColor(kYellow)
      
   hQCDp=TH1D(hQCD)
   hQCDp.Scale(QCDRATE_UP/QCDRATE)
   hQCDm=TH1D(hQCD)   
   hQCDm.Scale(QCDRATE_DOWN/QCDRATE)
      
   hQCDp.SetLineColor(kGreen)
   hQCDp.SetTitle("QCD #pm 1 #sigma")
   hQCDm.SetLineColor(kGreen)
   hQCDm.SetTitle("QCD #pm 1 #sigma")
      
   hTotal=TH1D(hNonQCD)
   hTotal.Add(hQCD)
   hTotal.Add(hWJets)
   hTotal.SetLineColor(kBlue)
   hTotal.SetTitle("Fitted total")
   max_bin = hData.GetMaximum()*1.6
   hData.SetAxisRange(0, max_bin, "Y")
   hData.GetXaxis().SetTitle(var.displayName)
   #hTotal.Draw("")
   title = fit_result.getTitle()
   hData.SetMarkerStyle(20)
   hData.Draw("E1")
   hNonQCDp.Draw("same")
   hQCD.Draw("same")
   hNonQCD.Draw("same")
   hNonQCDm.Draw("same")
   hQCDp.Draw("same")
   hQCDm.Draw("same")
   hWJets.Draw("same")
   hWJetsp.Draw("same")
   hWJetsm.Draw("same")
   hTotal.Draw("same")
   #hData.SetTitle("QCD fit, "+title)
   hData.Draw("E1 same")

   lumibox = lumi_textbox(19739)

   leg = legend(
        [hData, hQCD, hQCDp, hNonQCD, hNonQCDp, hWJets, hWJetsp, hTotal],
        styles=["p", "l"],
        width=0.2
    ) 

   leg.Draw()
          
   #print hNonQCD.Integral(), hData.Integral(), hQCD.Integral(), hTotal.Integral(), hQCDp.Integral(), hQCDm.Integral()
   cst.Update()
   cst.SaveAs(outfile_name+".png")
   cst.SaveAs(outfile_name+".pdf")
   cst.Draw()
   return cst
Exemple #7
0
if __name__=="__main__":
	samp = Sample.fromFile("~/Documents/stpol/data/out_step3_joosep_11_07_19_44/mu/iso/nominal/W4Jets_exclusive.root")
	samp.tree.AddFriend("trees/WJets_weights", samp.file_name)

	tdrstyle()
	
	cut = str(Cuts.final(2,0)*Cuts.Wflavour("W_heavy"))
	mean_weight = samp.drawHistogram(str(Weights.wjets_madgraph_weight("nominal")), cut, weight="1.0", plot_range=[200, 0, 2]).hist.GetMean()
	print "mean weight=%.2f" % mean_weight
	hi0 = samp.drawHistogram("cos_theta", cut, weight="1.0", plot_range=[20, -1, 1]).hist
	hi0.Scale(samp.lumiScaleFactor(20000))
	hi1 = samp.drawHistogram("cos_theta", cut, weight=str(Weights.wjets_madgraph_weight("nominal")), plot_range=[20, -1, 1]).hist
	hi1.Scale(samp.lumiScaleFactor(20000))
	hi2 = samp.drawHistogram("cos_theta", cut, weight=str(Weights.wjets_madgraph_weight("wjets_up")), plot_range=[20, -1, 1]).hist
	hi2.Scale(samp.lumiScaleFactor(20000))
	hi3 = samp.drawHistogram("cos_theta", cut, weight=str(Weights.wjets_madgraph_weight("wjets_down")), plot_range=[20, -1, 1]).hist
	hi3.Scale(samp.lumiScaleFactor(20000))

	hists = [hi0, hi1, hi2, hi3]
	#for h in hists:
	#	h.Scale(1.0/h.Integral())
	hi0.SetTitle("unweighted")
	hi1.SetTitle("weighted")
	hi2.SetTitle("weighted wjets_up")
	hi3.SetTitle("weighted wjets_down")
	ColorStyleGen.style_hists(hists)
	canv = plot_hists(hists, x_label="cos #theta")
	leg = legend(hists, styles=["f", "f"], nudge_x=-0.2)
	hi0.SetTitle("WJets hf yield with variations, 2J0T")
	canv.Update()
Exemple #8
0
            for name, histo in histos[process].items():
                if name != "Nominal":
                    print "Chi2 %s %s %.2f %.3f" % (
                        process, name,
                        histo.Chi2Test(histos[process]["Nominal"],
                                       "WW CHI2/NDF"),
                        histo.Chi2Test(histos[process]["Nominal"], "WW"))

            canv = plot_hists(canv,
                              histos[process],
                              x_label="cos(#Theta *)",
                              title=process,
                              max_bin_mult=1.6)

            #Draws the lumi box
            lumibox = lumi_textbox(lumi_iso["mu"])

            #Draw the legend
            leg = legend(
                histos[process].values(
                ),  # <<< need to reverse MC order here, mc3 is top-most
                styles=["l"],
                width=0.3,
                text_size=0.015)

            outf.write(make_plot_slide(process, canv))

    outf.write("\end{document}")
    outf.close()
Exemple #9
0
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
Exemple #10
0
def plot_ratios(cut_name, cut, samples, out_dir, recreate, flavour_scenario=flavour_scenarios[0]):
    out_dir += "/" + cut_name
    mkdir_p(out_dir)

    colls = dict()

    samples_WJets = filter(lambda x: sample_types.is_wjets(x.name), samples)

    for sc in flavour_scenario:
        logger.info("Drawing ratio with cut %s" % sc)
        cut_ = cut*getattr(Cuts, sc)
        colls[sc] = data_mc(costheta["var"], cut_name + "__" + sc, cut_, Weights.total()*Weights.mu, samples_WJets, out_dir, recreate, LUMI_TOTAL, plot_range=costheta["range"])

    logger.debug(colls[flavour_scenario[0]].hists["weight__nominal/cut__all/WJets_sherpa_nominal"].Integral())
    logger.debug(colls[flavour_scenario[1]].hists["weight__nominal/cut__all/WJets_sherpa_nominal"].Integral())
    coll = dict()
    for k, c in colls.items():
        for hn, h in c.hists.items():
            coll[hn + "/" + k] = h

    for k, h in coll.items():
        logger.debug("%s = %s" % (k, str([y for y in h.y()])))

    logger.debug(coll)
    #coll = HistCollection(coll, name=cut_name)

    merges = {}
    for sc in flavour_scenario:
        merges["madgraph/%s" % sc] = ["weight__nominal/cut__all/W[1-4]Jets_exclusive/%s" % sc]
        merges["sherpa/unweighted/%s" % sc] = ["weight__nominal/cut__all/WJets_sherpa_nominal/%s" % sc]
        merges["sherpa/weighted/%s" % sc] = ["weight__sherpa_flavour/cut__all/WJets_sherpa_nominal/%s" % sc]

    merged = merge_hists(coll, merges)
    for k, h in merged.items():
        logger.debug("%s = %s" % (k, str([y for y in h.y()])))
    hists_flavour = dict()
    hists_flavour["madgraph"] = ROOT.TH1F("madgraph", "madgraph", len(flavour_scenario), 0, len(flavour_scenario)-1)
    hists_flavour["sherpa/unweighted"] = ROOT.TH1F("sherpa_unw", "sherpa unweighted", len(flavour_scenario), 0, len(flavour_scenario)-1)
    hists_flavour["sherpa/weighted"] = ROOT.TH1F("sherpa_rew", "sherpa weighted", len(flavour_scenario), 0, len(flavour_scenario)-1)

    for i, sc in zip(range(1,len(flavour_scenario)+1), flavour_scenario):
        sh1_int, sh1_err = calc_int_err(merged["sherpa/unweighted/%s" % sc])
        sh2_int, sh2_err = calc_int_err(merged["sherpa/weighted/%s" % sc])
        mg_int, mg_err = calc_int_err(merged["madgraph/%s" % sc])
        logger.debug("%.2f %.2f" % (sh1_int, sh1_err))
        logger.debug("%.2f %.2f" % (sh2_int, sh2_err))
        logger.debug("%.2f %.2f" % (mg_int, mg_err))
        hists_flavour["madgraph"].SetBinContent(i, mg_int)
        hists_flavour["madgraph"].SetBinError(i, mg_err)
        hists_flavour["sherpa/unweighted"].SetBinContent(i, sh1_int)
        hists_flavour["sherpa/unweighted"].SetBinError(i, sh1_err)
        hists_flavour["sherpa/weighted"].SetBinContent(i, sh2_int)
        hists_flavour["sherpa/weighted"].SetBinError(i, sh2_err)

        hists_flavour["madgraph"].GetXaxis().SetBinLabel(i, sc)
        hists_flavour["sherpa/unweighted"].GetXaxis().SetBinLabel(i, sc)
        hists_flavour["sherpa/weighted"].GetXaxis().SetBinLabel(i, sc)

    hists_flavour["sherpa/weighted"].Sumw2()
    hists_flavour["sherpa/unweighted"].Sumw2()
    hists_flavour["madgraph"].Sumw2()

    hists_flavour["ratio/unweighted"] = hists_flavour["madgraph"].Clone("ratio_unw")
    hists_flavour["ratio/unweighted"].Divide(hists_flavour["sherpa/unweighted"])
    hists_flavour["ratio/weighted"] = hists_flavour["madgraph"].Clone("ratio_rew")
    hists_flavour["ratio/weighted"].Divide(hists_flavour["sherpa/weighted"])

    for i, sc in zip(range(1,len(flavour_scenario)+1), flavour_scenario):
        logger.info("weights[%s] = %.6f; //error=%.6f [%d]" % (sc, hists_flavour["ratio/unweighted"].GetBinContent(i), hists_flavour["ratio/unweighted"].GetBinError(i), i))

    flavour_ratio_coll = HistCollection(hists_flavour, name="hists__flavour_ratios")
    flavour_ratio_coll.save(out_dir)

    for sc in flavour_scenario:
        hists = [merged["madgraph/%s" % sc], merged["sherpa/unweighted/%s" % sc], merged["sherpa/weighted/%s" % sc]]
        for hist in hists:
            norm(hist)
            #hist.SetName(sc)
            #hist.SetTitle(sc)
        ColorStyleGen.style_hists(hists)
        canv = plot_hists(hists, x_label=costheta["varname"])
        leg = legend(hists, styles=["f", "f"], nudge_x=-0.2)
        chi2 = hists[0].Chi2Test(hists[1], "WW CHI2/NDF")
        hists[0].SetTitle("madgraph to sherpa comparison #chi^{2}/ndf=%.2f" % chi2)
        canv.Update()
        canv.SaveAs(out_dir + "/flavours__%s.png" % (sc))

    md_merged = dict()
    for sc in flavour_scenario:
        logger.info("Calculating ratio for %s" % sc)
        hi = merged["sherpa/unweighted/%s" % sc].Clone("ratio__%s" % sc)
        hi.Divide(merged["madgraph/%s" % sc])
        merged[hi.GetName()] = hi

    hc_merged = HistCollection(merged, md_merged, "hists__costheta_flavours_merged")
    hc_merged.save(out_dir)
    logger.info("Saved merged histogram collection")
Exemple #11
0
        h.Draw("same *h")   

    hData.Draw("e1 same")
    #Draws the lumi box
    from plots.common.utils import lumi_textbox
    lumibox = lumi_textbox(lumi_iso["mu"], "top-right")
    
    stacks_d = OrderedDict() #<<< need to use OrderedDict to have data drawn last (dict does not preserve order)
    stacks_d["sys"] = histos
    stacks_d["mc"] = list(reversed(stack.GetHists()))
    stacks_d["data"] = [hData]
    #print stacks_d
    #Draw the legend
    
    leg_histos = [hData]
    leg_histos.extend(histos)
    leg_histos.extend(list(reversed(stack.GetHists())))
    from plots.common.legend import legend
    leg = legend(
        leg_histos,# <<< need to reverse MC order here, mc3 is top-most
        pos="top-left",
        styles=["p", "pl", "pl", "pl", "pl", "pl", "pl", "f"],
        width=0.2,
        text_size=0.015
    )

    filename = "plots/systematics_stack"
    cst.SaveAs(filename+".png")
    cst.SaveAs(filename+".pdf")
    #return cst
            \end{tabular}
            \end{center}    
\end{frame}
            """)

            for name,histo in histos[process].items():
                if name != "Nominal":
                    print "Chi2 %s %s %.2f %.3f" %(process,name,histo.Chi2Test(histos[process]["Nominal"], "WW CHI2/NDF"),histo.Chi2Test(histos[process]["Nominal"], "WW"))

            canv = plot_hists(canv, histos[process],
                x_label="cos(#Theta *)",
                title=process,
                max_bin_mult=1.6
            )
            
            #Draws the lumi box
            lumibox = lumi_textbox(lumi_iso["mu"])
            
            #Draw the legend
            leg = legend(
                histos[process].values(), # <<< need to reverse MC order here, mc3 is top-most
                styles=["l"],
                width=0.3,
                text_size=0.015
            )

            outf.write(make_plot_slide(process, canv))

    outf.write("\end{document}")
    outf.close()
Exemple #13
0
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)
Exemple #14
0
    #Draw the stacked histograms
    #----
    stacks_d = OrderedDict() #<<< need to use OrderedDict to have data drawn last (dict does not preserve order)
    stacks_d["mc"] = [h_mc1, h_mc2, h_mc3] # <<< order is important here, mc1 is bottom-most
    stacks_d["data"] = [h_d1]
    stacks = plot_hists_stacked(
        canv,
        stacks_d,
        x_label="variable x [GeV]",
        y_label="",
        do_log_y=False
    )

    #Draws the lumi box
    from plots.common.utils import lumi_textbox
    lumibox = lumi_textbox(19432)

    #Draw the legend
    from plots.common.legend import legend
    leg = legend(
        [h_d1, h_mc3, h_mc2, h_mc1], # <<< need to reverse MC order here, mc3 is top-most
        styles=["p", "f"],
        width=0.25
    )

    try:
        os.mkdir("muon_out")
    except OSError:
        pass
    canv.SaveAs("muon_out/test.pdf")
Exemple #15
0
        h.Draw("same *h")

    hData.Draw("e1 same")
    #Draws the lumi box
    from plots.common.utils import lumi_textbox
    lumibox = lumi_textbox(lumi_iso["mu"], "top-right")

    stacks_d = OrderedDict(
    )  #<<< need to use OrderedDict to have data drawn last (dict does not preserve order)
    stacks_d["sys"] = histos
    stacks_d["mc"] = list(reversed(stack.GetHists()))
    stacks_d["data"] = [hData]
    #print stacks_d
    #Draw the legend

    leg_histos = [hData]
    leg_histos.extend(histos)
    leg_histos.extend(list(reversed(stack.GetHists())))
    from plots.common.legend import legend
    leg = legend(
        leg_histos,  # <<< need to reverse MC order here, mc3 is top-most
        pos="top-left",
        styles=["p", "pl", "pl", "pl", "pl", "pl", "pl", "f"],
        width=0.2,
        text_size=0.015)

    filename = "plots/systematics_stack"
    cst.SaveAs(filename + ".png")
    cst.SaveAs(filename + ".pdf")
    #return cst
Exemple #16
0
    #Draw the stacked histograms
    #----
    stacks_d = OrderedDict(
    )  #<<< need to use OrderedDict to have data drawn last (dict does not preserve order)
    stacks_d["mc"] = [h_mc1, h_mc2,
                      h_mc3]  # <<< order is important here, mc1 is bottom-most
    stacks_d["data"] = [h_d1]
    stacks = plot_hists_stacked(canv,
                                stacks_d,
                                x_label="variable x [GeV]",
                                y_label="",
                                do_log_y=False)

    #Draws the lumi box
    from plots.common.utils import lumi_textbox
    lumibox = lumi_textbox(19432)

    #Draw the legend
    from plots.common.legend import legend
    leg = legend(
        [h_d1, h_mc3, h_mc2, h_mc1
         ],  # <<< need to reverse MC order here, mc3 is top-most
        styles=["p", "f"],
        width=0.25)

    try:
        os.mkdir("muon_out")
    except OSError:
        pass
    canv.SaveAs("muon_out/test.pdf")
Exemple #17
0
    else:
        legend_pos = "top-right"

    if legend_pos == "top-right":
        lumibox = lumi_textbox(Lumi, "top-left")
    if legend_pos == "top-left":
        lumibox = lumi_textbox(Lumi, "top-right")

    hist_list = mc_to_plot.values()
    hist_list.reverse()  # reverse order of mc histograms for the legend entry
    hist_list.append(qcd)
    hist_list.insert(0, data)

    leg = legend(hist_list,
                 names=process_names,
                 styles=["p", "f"],
                 width=0.25,
                 pos=legend_pos)

    outfilename = "Plots/" + channel + "/" + mode1 + mode1a + "/" + hist_to_plot + mode2 + weight + ".pdf"
    if not os.path.exists(os.path.dirname(outfilename)):
        os.makedirs(os.path.dirname(outfilename))
    c.SaveAs(outfilename)
    c.Close()

    #----------------Signal PDG ID information------------------
    #    nr_W = 0
    #    nr_tau = 0
    if hist_to_plot == "el_mother_id" or hist_to_plot == "mu_mother_id":
        nr_W = mc_to_plot["signal"].GetBinContent(
            2) + mc_to_plot["signal"].GetBinContent(50)
Exemple #18
0
        logging.info("files = %s" % str(files))

        for sn, fi in files.items():
            hi = fi.Get("flavour_counts")
            hi.SetName(sn)
            pn = sn
            Styling.mc_style(hi, pn)
            hists[sn] = hi

        merges = OrderedDict()
        merges["W (madgraph)"] = ["W1Jets_exclusive", "W2Jets_exclusive", "W3Jets_exclusive", "W4Jets_exclusive"]
        merges["W (sherpa)"] = ["WJets_sherpa"]
        hists_merged = merge_hists(hists, merges)
        hists = hists_merged.values()

        ColorStyleGen.style_hists(hists)
        for h in hists:
            logging.info(list(h.y()))
            h.SetFillColor(ROOT.kWhite)
            h.Scale(1.0 / h.Integral())
        c = plot_hists(hists, x_label="flavour(j,j)", y_label="", draw_cmd="HIST E1")
        leg = legend(hists, styles=len(hists) * ["f"], nudge_x=-0.1)
        hists[0].SetTitle("Jet flavour fraction n %s" % cut_name)
        # hists[0].SetFillColor(ROOT.kGreen+2)
        hists[0].SetMinimum(10 ** -3)
        hists[0].SetMaximum(10)
        # hists[0].SetLineColor(ROOT.kGreen+2)
        c.SetLogy()
        c.SaveAs(out_dir + "/flavour_%s.pdf" % cut_name)
        c.Close()