コード例 #1
0
def go(fileList, varName):
    hists = []
    varBins = array.array('d', range(30, 110, 10) + range(125, 225, 25) + range(250, 450, 50))
    counter = 0
    histList = []
    for iFile, mass in fileList:
        hists.append(r.TH1F("hist%i" %counter, "", 20, 0, 1.0))
#         hists.append(r.TH1F("hist%i" %counter, "", 30, 0, 300))
#         hists.append(r.TH1F("hist%i" %counter, "", 44, -2.2, 2.2))
        hists[counter].Sumw2()
        hists[counter] = getHist(iFile, hists[counter], varName)
        hists[counter].SetLineColor(counter + 1)
        hists[counter].Scale(1/hists[counter].Integral(0, hists[counter].GetNbinsX()+1))
        histList.append((hists[counter], "Z'(%s)#rightarrow #tau#tau" %(mass), 'l'))
        counter += 1

    c = r.TCanvas("c","Test", 400, 300)
    max = hists[0].GetMaximum()
    hists[0].SetTitle("; %s; A.U." %varName)
    hists[0].GetYaxis().SetTitleOffset(1.1)

    hists[0].Draw("EH")

    for i in range(1, len(hists)):
        hists[i].Draw("sameEH")
        if hists[i].GetMaximum() > max:
            max = hists[i].GetMaximum()
    hists[0].SetMaximum(1.2*max)
    position  = (0.7, 0.85 - 0.06*4, 0.9, 0.85)
    legends = tool.setMyLegend(position, histList)
    legends.Draw('same')
    psfile = '%s.pdf' %varName
    c.Print('%s' %psfile)
コード例 #2
0
def setLegend(position, histDict, observed, bins, signalName, drawWhichDY = 'DY_MC', category = '1M'):
    histList = []
    histList.append((observed, 'Observed'))
    keyList = defaultOrder
    if category == '0M':        
        keyList = defaultOrder0M
    nbins = len(bins)
    for ikey in keyList:
        if ikey == 'signal':
            if draw_cfg.addIntegrals:
                histList.append((histDict[ikey], '%s (%.2f)' %(signalName, histDict[ikey].Integral(0, nbins+1))))
            else:
                histList.append((histDict[ikey], '%s' %signalName))

        else:
            if (ikey == 'Electroweak' or ikey == 'singleT'):
                continue
            if 'DY' in ikey and ikey != drawWhichDY:
                continue
            if drawWhichDY == 'DY+ttLep':
                if ikey == 't#bar{t}':
                    continue
            else:
                if ikey == 't#bar{t}-ttLep':
                    continue
            if draw_cfg.addIntegrals:
                histList.append((histDict[ikey], '%s (%.2f)' %(getNames(ikey), histDict[ikey].Integral(0, nbins+1))))
            else:
                histList.append((histDict[ikey], '%s' %getNames(ikey)))

    return tool.setMyLegend(position, histList)
コード例 #3
0
def setLegend(position, histDict, option = 'width', mass = '500'):
    histList = []
    nbins = histDict['obs'].GetNbinsX()

    if options.unblind:
        if options.showIntegral:
            histList.append((histDict['obs'], 'Observed (%.2f)' %histDict['obs'].Integral(0, nbins+1, option), 'lep'))
        else:
            histList.append((histDict['obs'], 'Observed', 'lep'))
    else:
        histList.append((histDict['obs'], 'Observed', 'lep'))

    for ikey in reversed(stackOrder):
        name = getName(ikey)
        if options.showIntegral:
            histList.append((histDict[ikey], '%s (%.2f)' %(name, histDict[ikey].Integral(0, nbins+1, option)), 'f'))
        else:
            histList.append((histDict[ikey], '%s' %(name), 'f'))

    integral = histDict['signal'].Integral(0, nbins+1, option)
    multiplication = ''
    if getZPrimeXS(str(mass))[1] > 1:
        multiplication = '%i x ' %getZPrimeXS(str(mass))[1]
    
    if options.showIntegral:
        histList.append((histDict['signal'], '%sZPrime_%s (%.2f)' %(multiplication, mass, integral), 'l'))
    else:
        histList.append((histDict['signal'], "%sZ'(%s)#rightarrow #tau#tau" %(multiplication, mass), 'l'))

    return tool.setMyLegend(position, histList)
コード例 #4
0
def setLegend(position, hist25, hist50, bins):
    histList = []
    nbins = len(bins)

    histList.append((hist25, '25ns', 'L'))
    histList.append((hist50, '50ns', 'L'))

    return tool.setMyLegend(position, histList)
コード例 #5
0
def setLegend(position, histDict, histDict2, bins, option = 'width'):
    histList = []
    nbins = len(bins)

    if options.unblind:
        histList.append((histDict['Observed'], 'Observed (%.2f)' %histDict['Observed'].Integral(0, nbins+1, option), 'lep'))
    else:
        histList.append((histDict['Observed'], 'Observed', 'lep'))

    for ikey, iColor in reversed(defaultOrder):
        name = ikey
        if ikey == 'QCD':
            ikey = 'QCD_D_for_A'
        if ikey in histDict.keys():
            if plots_cfg.addIntegrals:
                if ikey == 'WJets':
                    if plots_cfg.unc:
                        integral, unc = IntegralAndError(histDict['WJets_OScontrol'], nbins, ikey, 'et')
                        histList.append((histDict[ikey], '%s (%.1f +/- %.1f)' %(name, integral, unc), 'f'))
                    else:
                        histList.append((histDict[ikey], '%s (%.2f)' %(name, histDict['WJets_OScontrol'].Integral(0, nbins+1, option)), 'f'))
#                 if plots_cfg.unc:
#                     integral, unc = IntegralAndError(histDict2[ikey], nbins)
#                     histList.append((histDict2[ikey], '%s (%.2f +/- %.2f)' %(name, integral, unc), 'f'))
                else:
                    if plots_cfg.unc:
                        integral, unc = IntegralAndError(histDict2[ikey], nbins, ikey, 'et')
                        histList.append((histDict2[ikey], '%s (%.1f +/- %.1f)' %(ikey, integral, unc), 'f'))
                    else:
                        histList.append((histDict[ikey], '%s (%.2f)' %(name, histDict[ikey].Integral(0, nbins+1, option)), 'f'))
            else:
                histList.append((histDict[ikey], '%s' %name, 'f'))

    if "ZPrime" in histDict.keys():
        for iName, iSample, iCategory in plots_cfg.sampleList:    
            if "Z'" in iName:
                signalName = iName
        if signalScale != 1:
            signalName += "x%i" %signalScale
        if plots_cfg.addIntegrals:
            if plots_cfg.unc:
                integral, unc = IntegralAndError(histDict2["ZPrime"], nbins)
                histList.append((histDict2["ZPrime"], "%s (%.1f +/- %.1f)" %(signalName, integral, unc), 'l'))
            else:
                histList.append((histDict["ZPrime"], "%s (%.2f)" %(signalName, histDict['ZPrime'].Integral(0, nbins+1, option)), 'l'))
        else:
            histList.append((histDict["ZPrime"], signalName, 'l'))

    return tool.setMyLegend(position, histList)
コード例 #6
0
def run(type = 'both'):

    points = {"both_antiIso":([(0.2, 0.5, 2.546, 0.115), (0.5, 1.0, 2.370, 0.233), (1.0, 10, 2.279, 0.671)], r.kBlue),
              "both_antiIso_MEt20":([(0.2, 0.5, 2.546, 0.151), (0.5, 1.0, 2.756,  0.360), (1.0, 10, 2.581, 0.895)], r.kRed),
              "e_antiIso":([(0.15, 0.2, 1.668, 0.216), (0.2, 0.5, 1.933, 0.138), (0.5, 1.0, 2.924,  0.475), (1.0, 10, 1.178, 0.491)], r.kRed),
              "e_antiIso_MEt20":([(0.15, 0.2, 1.596, 0.275), (0.2, 0.5, 1.508, 0.148), (0.5, 1.0, 2.976,  0.630), (1.0, 10, 3.118, 1.828)], r.kOrange),
              "m_antiIso":([(0.15, 0.2, 1.707, 0.232), (0.2, 0.5, 1.819, 0.093), (0.5, 1.0, 1.798,  0.102), (1.0, 10, 1.528, 0.095)], r.kBlue),
              "m_antiIso_MEt20":([(0.15, 0.2, 1.288, 0.237), (0.2, 0.5, 1.938, 0.133), (0.5, 1.0, 1.965,  0.145), (1.0, 10, 1.663, 0.126)], r.kCyan),
              }
    
    first = True
    if type != 'both':
        type = 'single'

    psfile = 'QCD_scales_%s.pdf' %type
    c = r.TCanvas("c","Test", 800, 600)
    grs = []
    histlist = []

    for iKey in points.keys():
        if type == 'both' and (not 'both' in iKey):
            continue
        elif type != 'both' and ('both' in iKey):
            continue
        grs.append(getGraph(points[iKey][0], points[iKey][1]))
        histlist.append((r.TH1F('dummy_%s' %iKey, '', 1, 0 ,1), iKey, 'L'))
        histlist[len(histlist)-1][0].SetLineColor(points[iKey][1])
        if first:        
            grs[0].Draw("AP")
            if type != 'both':
                grs[0].SetMaximum(3.5)
                grs[0].SetMinimum(0.8)

            first = False
        else:
            grs[len(grs)-1].Draw("sameP")

    r.gPad.SetTicky()
    r.gPad.SetTickx()
    r.gPad.SetLogx()
    leg = tool.setMyLegend((0.5, 0.8 - 0.07*(len(histlist)-1), 0.85, 0.8), histlist)
    leg.Draw("same")
    c.Print('%s' %psfile)
    c.Close()
コード例 #7
0
def setLegend(position,
              histDict,
              observed,
              bins,
              signalName,
              drawWhichDY='DY_MC',
              category='1M'):
    histList = []
    histList.append((observed, 'Observed'))
    keyList = defaultOrder
    if category == '0M':
        keyList = defaultOrder0M
    nbins = len(bins)
    for ikey in keyList:
        if ikey == 'signal':
            if draw_cfg.addIntegrals:
                histList.append(
                    (histDict[ikey], '%s (%.2f)' %
                     (signalName, histDict[ikey].Integral(0, nbins + 1))))
            else:
                histList.append((histDict[ikey], '%s' % signalName))

        else:
            if (ikey == 'Electroweak' or ikey == 'singleT'):
                continue
            if 'DY' in ikey and ikey != drawWhichDY:
                continue
            if drawWhichDY == 'DY+ttLep':
                if ikey == 't#bar{t}':
                    continue
            else:
                if ikey == 't#bar{t}-ttLep':
                    continue
            if draw_cfg.addIntegrals:
                histList.append(
                    (histDict[ikey], '%s (%.2f)' %
                     (getNames(ikey), histDict[ikey].Integral(0, nbins + 1))))
            else:
                histList.append((histDict[ikey], '%s' % getNames(ikey)))

    return tool.setMyLegend(position, histList)
コード例 #8
0
def setLegend(position, histDict, histDict2, bins, option = 'width'):
    histList = []
    nbins = len(bins)

    if options.unblind:
        histList.append((histDict['Observed'], 'Observed (%.2f)' %histDict['Observed'].Integral(0, nbins+1, option), 'lep'))
    else:
        histList.append((histDict['Observed'], 'Observed', 'lep'))

    for ikey, iColor in reversed(defaultOrder):
        name = ikey
        if ikey == 'QCD':
            ikey = 'QCD_C_for_A'
        if ikey in histDict.keys():
            if plots_cfg.addIntegrals:
                if ikey == 'WJets':
                    histList.append((histDict[ikey], '%s (%.2f)' %(name, histDict['WJets_A_'].Integral(0, nbins+1, option)), 'f'))
#                 if plots_cfg.unc:
#                     integral, unc = IntegralAndError(histDict2[ikey], nbins)
#                     histList.append((histDict2[ikey], '%s (%.2f +/- %.2f)' %(name, integral, unc), 'f'))
                else:
                    histList.append((histDict[ikey], '%s (%.2f)' %(name, histDict[ikey].Integral(0, nbins+1, option)), 'f'))
            else:
                histList.append((histDict[ikey], '%s' %name, 'f'))
    if not (options.antiIso or options.antiEIso or options.antiMIso or options.noIso):
        signalSampleName = 'ZPrime_500'
        if plots_cfg.addIntegrals:
            if plots_cfg.unc:
                integral, unc = IntegralAndError(histDict2[signalSampleName], nbins)
                histList.append((histDict2[signalSampleName], '%s (%.2f +/- %.2f)' %(signalSampleName, integral, unc), 'l'))
            else:
                histList.append((histDict[signalSampleName], '%s (%.2f)' %(signalSampleName, histDict[signalSampleName].Integral(0, nbins+1, option)), 'l'))
        else:
            histList.append((histDict[signalSampleName], signalSampleName, 'l'))

    return tool.setMyLegend(position, histList)
コード例 #9
0
def main():
    file_13TeV = '/nfs_scratch/zmao/test/DYJetsToLL_all.root'  #'/nfs_scratch/zmao/test/TTJets_all.root'#
    file_8TeV = '/nfs_scratch/zmao/samples_Iso/tauESOn/normal/dy.root'  #'/nfs_scratch/zmao/samples_Iso/tauESOff/normal/TT.root'#

    vars2compare = [
        ("tau1Pt", [50, 30, 230]),
        #                     ("tau2Pt", [50, 30, 230]),
        #                     ("tau1Eta", [25, -2.5, 2.5]),
        #                     ("tau2Eta", [25, -2.5, 2.5]),
        #                     ("tau1Iso", [40, 0, 2.]),
        #                     ("tau2Iso", [40, 0, 2.]),
        #                     ("J1Pt", [50, 30, 230]),
        #                     ("J2Pt", [50, 30, 230]),
        #                     ("J1Eta", [40, -4, 4]),
        #                     ("J2Eta", [40, -4, 4]),
        #                     ("J1CSVbTag", [50, 0, 1]),
        #                     ("J2CSVbTag", [50, 0, 1]),
        #
        #                     ("CSVJ1Pt", [50, 30, 230]),
        #                     ("CSVJ2Pt", [50, 30, 230]),
        #                     ("CSVJ1Eta", [40, -4, 4]),
        #                     ("CSVJ2Eta", [40, -4, 4]),
        #                     ("CSVJ1", [50, 0, 1]),
        #                     ("CSVJ2", [50, 0, 1]),
        #
        #                     ("svMass", [35, 0, 350]),
        #                     ("met", [25, 0, 200]),
        #                     ("mJJ", [50, 0, 500])
    ]

    histDicts = buildHistDict(vars2compare)

    psfile = 'out.pdf'
    c = r.TCanvas("c", "Test", 800, 600)

    counter = 0
    for iVar, Range in vars2compare:
        unc13TeV = readFile(file=file_13TeV,
                            hist=histDicts[iVar]['13TeV'],
                            varName=iVar,
                            which='13TeV')
        unc8TeV = readFile(file=file_8TeV,
                           hist=histDicts[iVar]['8TeV'],
                           varName=iVar,
                           which='8TeV')

        #normalization
        #         histDicts[iVar]['13TeV'].Scale(1.0/histDicts[iVar]['13TeV'].Integral(0, histDicts[iVar]['13TeV'].GetNbinsX()+1))
        #         histDicts[iVar]['8TeV'].Scale(1.0/histDicts[iVar]['8TeV'].Integral(0, histDicts[iVar]['8TeV'].GetNbinsX()+1))

        counter += 1
        c.Clear()
        histDicts[iVar]['13TeV'].SetTitle("13 TeV vs 8 TeV; %s; a.u" % iVar)
        histDicts[iVar]['8TeV'].SetTitle("13 TeV vs 8 TeV; %s; a.u" % iVar)
        histDicts[iVar]['8TeV'].SetLineColor(r.kRed)

        if histDicts[iVar]['13TeV'].GetMaximum(
        ) >= histDicts[iVar]['8TeV'].GetMaximum():
            histDicts[iVar]['13TeV'].Draw()
            histDicts[iVar]['8TeV'].Draw('same')
        else:
            histDicts[iVar]['8TeV'].Draw()
            histDicts[iVar]['13TeV'].Draw('same')
        if counter == 1:
            l = tool.setMyLegend(lPosition=[0.7, 0.85, 0.9, 0.7],
                                 lHistList=[(histDicts[iVar]['13TeV'],
                                             '13TeV'),
                                            (histDicts[iVar]['8TeV'], '8TeV')])
            l.Draw('same')
            c.Print('%s(' % psfile)
        if counter == len(vars2compare):
            l.Draw('same')
            c.Print('%s)' % psfile)
        else:
            l.Draw('same')
            c.Print('%s' % psfile)

        print "13TeV Integral: %.2f +- %.2f (fb)" % (
            histDicts[iVar]['13TeV'].Integral(
                0, histDicts[iVar]['13TeV'].GetNbinsX() + 1), unc13TeV)
        print "8TeV Integral : %.2f +- %.2f (fb)" % (
            histDicts[iVar]['8TeV'].Integral(
                0, histDicts[iVar]['8TeV'].GetNbinsX() + 1), unc8TeV)

    c.Close()
コード例 #10
0
def setLegend(position, histDict, histDict2, bins, option='width'):
    histList = []
    nbins = len(bins)

    if options.unblind:
        histList.append(
            (histDict['Observed'], 'Observed (%.2f)' %
             histDict['Observed'].Integral(0, nbins + 1, option), 'lep'))
    else:
        histList.append((histDict['Observed'], 'Observed', 'lep'))

    for ikey, iColor in reversed(defaultOrder):
        name = ikey
        if ikey == 'QCD':
            ikey = 'QCD_D_for_A'
        if ikey in histDict.keys():
            if plots_cfg.addIntegrals:
                if ikey == 'WJets':
                    if plots_cfg.unc:
                        integral, unc = IntegralAndError(
                            histDict['WJets_OScontrol'], nbins, ikey, 'et')
                        histList.append((histDict[ikey], '%s (%.1f +/- %.1f)' %
                                         (name, integral, unc), 'f'))
                    else:
                        histList.append(
                            (histDict[ikey], '%s (%.2f)' %
                             (name, histDict['WJets_OScontrol'].Integral(
                                 0, nbins + 1, option)), 'f'))


#                 if plots_cfg.unc:
#                     integral, unc = IntegralAndError(histDict2[ikey], nbins)
#                     histList.append((histDict2[ikey], '%s (%.2f +/- %.2f)' %(name, integral, unc), 'f'))
                else:
                    if plots_cfg.unc:
                        integral, unc = IntegralAndError(
                            histDict2[ikey], nbins, ikey, 'et')
                        histList.append(
                            (histDict2[ikey],
                             '%s (%.1f +/- %.1f)' % (ikey, integral, unc),
                             'f'))
                    else:
                        histList.append(
                            (histDict[ikey],
                             '%s (%.2f)' % (name, histDict[ikey].Integral(
                                 0, nbins + 1, option)), 'f'))
            else:
                histList.append((histDict[ikey], '%s' % name, 'f'))

    if "ZPrime" in histDict.keys():
        for iName, iSample, iCategory in plots_cfg.sampleList:
            if "Z'" in iName:
                signalName = iName
        if signalScale != 1:
            signalName += "x%i" % signalScale
        if plots_cfg.addIntegrals:
            if plots_cfg.unc:
                integral, unc = IntegralAndError(histDict2["ZPrime"], nbins)
                histList.append(
                    (histDict2["ZPrime"],
                     "%s (%.1f +/- %.1f)" % (signalName, integral, unc), 'l'))
            else:
                histList.append(
                    (histDict["ZPrime"],
                     "%s (%.2f)" % (signalName, histDict['ZPrime'].Integral(
                         0, nbins + 1, option)), 'l'))
        else:
            histList.append((histDict["ZPrime"], signalName, 'l'))

    return tool.setMyLegend(position, histList)
コード例 #11
0
#gr_unsliced2.Draw("sameP")

gr_unsliced_pu.SetFillStyle(3354)
gr_unsliced_pu.SetLineWidth(-802)
gr_unsliced_pu.SetFillColor(r.kBlue)
gr_unsliced_pu.SetLineColor(r.kBlue)
gr_unsliced_pu.Draw("same2")

gr_unsliced_pu2.SetLineWidth(-802)
gr_unsliced_pu2.SetLineColor(r.kBlue)
gr_unsliced_pu2.SetMarkerColor(r.kBlue)
gr_unsliced_pu2.Draw("sameP")

gr_sliced.SetLineColor(r.kGreen)
gr_sliced.SetMarkerColor(r.kGreen)
#gr_sliced.Draw("sameLP")
gr_sliced_pu.SetLineColor(r.kRed)
gr_sliced_pu.SetMarkerColor(r.kRed)
gr_sliced_pu.Draw("sameLP")

position = (0.15, 0.85 - 0.05 * 2, 0.55, 0.85)
histList = []
#histList.append((gr_unsliced, "wide mass bin without PU", 'f'))
histList.append((gr_unsliced_pu, "wide mass bin", 'f'))
#histList.append((gr_sliced, "narrow mass bin without PU", 'l'))
histList.append((gr_sliced_pu, "narrow mass bin", 'l'))

legends = tool.setMyLegend(position, histList)
legends.Draw("same")
c.Print('pdfSys_withUnc.pdf')
コード例 #12
0
def compareSamples(fs):

    varNameDict_et = {'m_eff': 'm(#tau_{e}, #tau_{h}, #slash{E}_{T}) [GeV]',
                      'ePt': 'Electron Pt [GeV]',
                      'tPt': 'Tau Pt [GeV]',
                      'nTruePU': 'nTruePU',
                    }
    varNameDict_em = {'m_eff': 'm(#tau_{e}, #tau_{#mu}, #slash{E}_{T}) [GeV]',
                      'ePt': 'Electron Pt [GeV]',
                      'mPt': 'Muon Pt [GeV]',
                      'nTruePU': 'nTruePU',
                    }

    varName = 'ePt'
    varBins = 0
    if varName == 'm_eff':
        varBins = array.array('d', [0,100,110,120,130,140,150,160,170,180,190,200,225,250,275,300,400,600,900])
        hist1 = r.TH1F("hist_1", "", len(varBins)-1, varBins)
        hist2 = r.TH1F("hist_2", "", len(varBins)-1, varBins)
    else:
        hist1 = r.TH1F("hist_1", "", 50, 0, 500)
        hist2 = r.TH1F("hist_2", "", 50, 0, 500)

    loopOneFile(iSample = '/user_data/zmao/Jan13Production_signalRegion/ZPrime_500_all_SYNC_%s_noIso.root' %fs,
                varName = varName,
                hist = hist1,
                fs = fs,
                varBins = varBins)
    loopOneFile(iSample = '/user_data/zmao/Jan13Production_signalRegion/ZPrime_500_2_all_SYNC_%s_noIso.root' %fs,
                varName = varName,
                hist = hist2,
                fs = fs,
                varBins = varBins)

    position  = (0.65, 0.85 - 0.06*2, 0.85, 0.85)
    histList = []
    histList.append((hist1, 'Old Zprime_500', 'lp'))
    histList.append((hist2, 'New Zprime_500', 'lp'))
    legend = tool.setMyLegend(position, histList)


    c = r.TCanvas("c","Test", 800, 600)
    hist1.SetMarkerSize(0.5)
    hist1.SetLineColor(r.kBlue)
    hist1.SetMarkerColor(r.kBlue)
    hist2.SetMarkerSize(0.5)
    hist2.SetLineColor(r.kRed)
    hist2.SetMarkerColor(r.kRed)
    if fs == 'et':
        title = varNameDict_et[varName]
    else:
        title = varNameDict_em[varName]

    hist1.SetTitle("ZPrime Sample Comparison; %s; Events/Initial Events" %title)
    hist1.SetMinimum(0.000001)
    hist1.Scale(1, 'width')
    hist2.Scale(1, 'width')

    hist1.Draw("E1")
    hist2.Draw("E1same")
    legend.Draw('same')

    r.gPad.SetLogy()

    r.gPad.SetTicky()
    r.gPad.SetTickx()
    c.Print('sampleCheck_%s_%s.pdf' %(fs, varName))
コード例 #13
0
ファイル: plotPDF.py プロジェクト: zaixingmao/samples-plots
gr_unsliced_pu.SetFillColor(r.kBlue)
gr_unsliced_pu.SetLineColor(r.kBlue)
gr_unsliced_pu.Draw("same2")

gr_unsliced_pu2.SetLineWidth(-802)
gr_unsliced_pu2.SetLineColor(r.kBlue)
gr_unsliced_pu2.SetMarkerColor(r.kBlue)
gr_unsliced_pu2.Draw("sameP")

gr_sliced.SetLineColor(r.kGreen)
gr_sliced.SetMarkerColor(r.kGreen)
#gr_sliced.Draw("sameLP")
gr_sliced_pu.SetLineColor(r.kRed)
gr_sliced_pu.SetMarkerColor(r.kRed)
gr_sliced_pu.Draw("sameLP")




position  = (0.15, 0.85 - 0.05*2, 0.55, 0.85)
histList = []
#histList.append((gr_unsliced, "wide mass bin without PU", 'f'))
histList.append((gr_unsliced_pu, "wide mass bin", 'f'))
#histList.append((gr_sliced, "narrow mass bin without PU", 'l'))
histList.append((gr_sliced_pu, "narrow mass bin", 'l'))

legends = tool.setMyLegend(position, histList)
legends.Draw("same")
c.Print('pdfSys_withUnc.pdf')

コード例 #14
0
def run(mass, FS):
    inputFile = '/user_data/elaird/svSkim-sep18/ZPrime_%s_all_SYNC_%s_inclusive.root' %(mass, FS)
    bins = array.array('d', range(0, 1000, 50) + range(1000, 4000, 100))
    bins2 = array.array('d', range(0, 1000, 50) + range(1000, 8000, 100))

    maximum = 0.005
    if mass == "2000":
        bins = array.array('d', range(0, 1000, 50) + range(1000, 3000, 100))
    if mass == '1000':
        bins = array.array('d', range(0, 1000, 50) + range(1000, 1500, 100))
        maximum = 0.01

    varsDict = {"mass_vis": (r.TH1D("mass_vis_%s_%s" %(mass, FS), "", len(bins)-1, bins), r.kRed),
                "mass_gen": (r.TH1D("mass_gen_%s_%s" %(mass, FS), "", len(bins)-1, bins), r.kBlue),
                "mass_withMEt": (r.TH1D("mass_withMEt_%s_%s" %(mass, FS), "", len(bins)-1, bins), r.kGreen),
                "mass_svfit": (r.TH1D("mass_svfit_%s_%s" %(mass, FS), "", len(bins)-1, bins), r.kBlack),
                }
    varsDict2 = {"mass_vis": (r.TH1D("mass2_vis_%s_%s" %(mass, FS), "", len(bins2)-1, bins2), r.kRed),
                "mass_gen": (r.TH1D("mass2_gen_%s_%s" %(mass, FS), "", len(bins2)-1, bins2), r.kBlue),
                "mass_withMEt": (r.TH1D("mass2_withMEt_%s_%s" %(mass, FS), "", len(bins2)-1, bins2), r.kGreen),
                "mass_svfit": (r.TH1D("mass2_svfit_%s_%s" %(mass, FS), "", len(bins2)-1, bins2), r.kBlack),
                }
    nbins = 60
    varsDict3 = {"mass_vis": (r.TH1D("mass3_vis_%s_%s" %(mass, FS), "", nbins, -1.5, 1.5), r.kRed),
                "mass_withMEt": (r.TH1D("mass3_withMEt_%s_%s" %(mass, FS), "", nbins, -1.5, 1.5), r.kGreen),
                "mass_svfit": (r.TH1D("mass3_svfit_%s_%s" %(mass, FS), "", nbins, -1.5, 1.5), r.kBlack),
                }

    varsDict = loop_through_files(inputFile, varsDict, FS)
    varsDict2 = loop_through_files(inputFile, varsDict2, FS)
    varsDict3 = loop_through_files(inputFile, varsDict3, FS, True)

    psfile = 'mass_compare_%s_%s.pdf' %(mass, FS)
    histlist = []
    histlist3 = []

    c = r.TCanvas("c","Test", 800, 600)
    r.gPad.SetTicky()
    r.gPad.SetTickx()
    print ''
    for iKey in varsDict.keys():
        varsDict[iKey][0].Scale(1.0/varsDict[iKey][0].Integral(0, len(bins) + 1), 'width')
        varsDict[iKey][0].SetLineColor(varsDict[iKey][1])
        histlist.append((varsDict[iKey][0], "%s: #bar{x} = %.2f, RMS = %.2f, RMS/#bar{x} = %.1f%%" %(iKey, varsDict2[iKey][0].GetMean(), varsDict2[iKey][0].GetRMS(), varsDict2[iKey][0].GetRMS()/varsDict2[iKey][0].GetMean()*100), 'l'))

        if len(histlist) == 1:
            varsDict[iKey][0].SetMaximum(maximum)
            varsDict[iKey][0].Draw()
            varsDict[iKey][0].SetTitle("Zprime %s (%s); %s mass; A.U" %(mass, FS, FS))

        else:
            varsDict[iKey][0].Draw("same")
    if mass != '500':
        leg = tool.setMyLegend((0.1, 0.8 - 0.07*(len(histlist)-1), 0.6, 0.8), histlist)
    else:
        leg = tool.setMyLegend((0.35, 0.8 - 0.07*(len(histlist)-1), 0.85, 0.8), histlist)
    leg.Draw("same")

    c.Print('%s(' %psfile)
    c.Clear()
    for iKey in varsDict3.keys():
        varsDict3[iKey][0].Scale(1.0/varsDict3[iKey][0].Integral(0, nbins + 1), 'width')
        varsDict3[iKey][0].SetLineColor(varsDict3[iKey][1])
        histlist3.append((varsDict3[iKey][0], "%s" %(iKey), 'l'))
        if len(histlist3) == 1:
            varsDict3[iKey][0].SetMaximum(3)
            varsDict3[iKey][0].Draw()
            varsDict3[iKey][0].SetTitle("Zprime %s (%s); %s mass resolution; A.U" %(mass, FS, FS))
        else:
            varsDict3[iKey][0].Draw("same")
    leg2 = tool.setMyLegend((0.6, 0.8 - 0.07*(len(histlist3)-1), 0.85, 0.8), histlist3)
    leg2.Draw("same")


    c.Print('%s)' %psfile)
    c.Close()
コード例 #15
0
def getHistos(varName, signalSelection, logY, sigBoost, nbins, useData, max, rangeMin, rangeMax, location, bTag, predict, predictPtBin, region, thirdLeptonVeto, SF, yMax, relaxedRegionOption, usePU):
    r.gStyle.SetOptStat(0)
    SF = float(SF)
    fileList = draw_cfg.MCFileList
    histList = []
    histList_4QCD = []
    QCDHistList = []
    QCDHistList_4KS = []
    QCDHistList_withScale = []
    varRange = [nbins, rangeMin, rangeMax]
    nBins = 10000
    Lumi = 19.7
    legendHistos = []
    var_background = []
    scaleMCPt = 1.0
    tmpFile = []
    tmpTree = []
    var_data_4KS = []
    var_data = []
    var_data_4QCD = []
    histList_4KS = []
    MC_Counts_0 = 0.0
    MC_Counts_1 = 0.0
    MC_Counts_2 = 0.0

    for i in range(6):
        var_data.append(r.TH1F('data_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        var_data_4KS.append(r.TH1F('data_4KS_%i' %(i),"", nBins, varRange[1], varRange[2]))
        if i < 5:
            var_data_4QCD.append(r.TH1F('data_4QCD_%i' %(i),"", varRange[0], varRange[1], varRange[2]))


    dataName = draw_cfg.dataFile
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' %dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag, region, thirdLeptonVeto, relaxedRegionOption)
        if (select == 0) or (select > 6):
            continue
        if (select == 1) and dontUnblind(treeData):
            continue
        var_data[select-1].Fill(varsList.findVar(treeData, varName))
        if (select != 1):
            var_data_4KS[select-2].Fill(varsList.findVar(treeData, varName))
        if select == 2:
            var_data_4QCD[0].Fill(varsList.findVar(treeData, varName), 1.0)
        elif select == 3:
            var_data_4QCD[1].Fill(varsList.findVar(treeData, varName), SF)
        elif select == 4:
            var_data_4QCD[2].Fill(varsList.findVar(treeData, varName), 1.0)
            var_data_4QCD[3].Fill(varsList.findVar(treeData, varName), SF)

    legendHistos.append([])
    for j in range(6):
        var_data[j].SetMarkerStyle(8)
        var_data[j].SetMarkerSize(0.9)
        legendHistos.append([])
        integral = 'observed'
        if j != 0 or (region != 'tight') or (bTag == 'None'):
            integral = 'observed (%.0f)' %var_data[j].Integral(0, varRange[0]+1)
        legendHistos[j].append((var_data[j], integral))

    for i in range(len(fileList)): 
        for j in range(6):
            histList_4KS.append(r.TH1F('%s_%i_KS' %(fileList[i][0],j),fileList[i][0], nBins, varRange[1], varRange[2]))
            histList.append(r.TH1F('%s_%i' %(fileList[i][0],j),fileList[i][0], varRange[0], varRange[1], varRange[2]))
            histList_4QCD.append(r.TH1F('%s_%i_2' %(fileList[i][0],j),fileList[i][0], varRange[0], varRange[1], varRange[2]))
        print 'Adding events from: %s ...' %(fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag, region, thirdLeptonVeto, relaxedRegionOption)
            if (not select) or (select > 6):
                continue
            if usePU:
                allWeights = tmpTree[i].triggerEff*tmpTree[i].PUWeight
            else:
                allWeights = tmpTree[i].triggerEff
            histList[6*i+select-1].Fill(varsList.findVar(tmpTree[i], varName), allWeights*tmpTree[i].xs/(tmpTree[i].initEvents))
            histList_4KS[6*i+select-1].Fill(varsList.findVar(tmpTree[i], varName), allWeights*tmpTree[i].xs/(tmpTree[i].initEvents))
            if select == 2:
                histList_4QCD[6*i].Fill(varsList.findVar(tmpTree[i], varName), allWeights*1.0*tmpTree[i].xs/(tmpTree[i].initEvents))
            elif select == 3:
                histList_4QCD[6*i+1].Fill(varsList.findVar(tmpTree[i], varName), allWeights*SF*tmpTree[i].xs/(tmpTree[i].initEvents))
            elif select == 4:             
                histList_4QCD[6*i+2].Fill(varsList.findVar(tmpTree[i], varName), allWeights*1.0*tmpTree[i].xs/(tmpTree[i].initEvents))
                histList_4QCD[6*i+3].Fill(varsList.findVar(tmpTree[i], varName), allWeights*SF*tmpTree[i].xs/(tmpTree[i].initEvents))

        for j in range(6):
            var_background.append(r.THStack())
            histList[6*i+j].SetFillColor(fileList[i][2])
            histList[6*i+j].Scale(Lumi)
            histList_4QCD[6*i+j].Scale(Lumi)
            histList_4KS[6*i+j].Scale(Lumi)   
            var_background[j].Add(histList[6*i+j])
            legendHistos[j].append((histList[6*i+j], '%s (%.2f)' %(fileList[i][0], histList[6*i+j].Integral(0, varRange[0]+1))))


    data_i = []
    MC_i = []
    data_r = []
    MC_r = []
    e = []
    MC_List = []
    for i in range(3):
        QCDHistList.append(r.TH1F('QCD_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        QCDHistList_4KS.append(r.TH1F('QCD_%i_KS' %(i),"", nBins, varRange[1], varRange[2]))
        MC_List.append(r.TH1F('MC_total_%i' %(i),"", varRange[0], varRange[1], varRange[2]))

        for j in range(varRange[0]+2):
            dataValue = var_data[i+1].GetBinContent(j)
            dataError = var_data[i+1].GetBinError(j)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue +=  histList[6*k+1+i].GetBinContent(j)
            if i == 0:
                data_i.append(dataValue)
                e.append(dataError)
                MC_i.append(MCValue)
            if i == 2:
                data_r.append(dataValue)
                MC_r.append(MCValue)
            MC_List[i].SetBinContent(j, MCValue)
            if dataValue - MCValue > 0:
                QCDHistList[i].SetBinContent(j, dataValue - MCValue)
                QCDHistList[i].SetBinError(j, dataError)
        MC_List[i].Sumw2()
        for j in range(nBins+2):
            dataValue4KS = var_data_4KS[i].GetBinContent(j)
            MCValue4KS = 0
            for k in range(len(fileList)):
                MCValue4KS += histList_4KS[6*k+1+i].GetBinContent(j)
            if dataValue4KS - MCValue4KS > 0:
                QCDHistList_4KS[i].SetBinContent(j, dataValue4KS - MCValue4KS)

    ss_t = QCDHistList[0].Integral(0, varRange[0]+1)
    ss_l = QCDHistList[2].Integral(0, varRange[0]+1)

    os_l = QCDHistList[1].Integral(0, varRange[0]+1)
    os_l_data = var_data[2].Integral(0, varRange[0]+1)
    print "QCD in SS_T: %.4f" %ss_t
    print "QCD in SS_L: %.4f" %ss_l

    print "QCD in OS_L: %.4f" %os_l
    print "Data in OS_L:%.4f" %os_l_data

    print "SF: %.4f" %(ss_t/ss_l)
    print "SF qcd/data: %.4f" %(os_l/os_l_data)


    for i in range(4):
        QCDHistList_withScale.append(r.TH1F('QCD_withScale_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        for j in range(varRange[0]+2):
            dataValue = var_data_4QCD[i].GetBinContent(j)
            dataError = var_data_4QCD[i].GetBinError(j)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue +=  histList_4QCD[6*k+i].GetBinContent(j)
            if dataValue - MCValue > 0:
                QCDHistList_withScale[i].SetBinContent(j, dataValue - MCValue)

    QCDDiff = r.TH1F('QCD_diff',"", varRange[0], varRange[1], varRange[2])
    QCDDiff2 = r.TH1F('QCD_diff2',"", varRange[0], varRange[1], varRange[2])
    QCDDiff_R2T = r.TH1F('QCDDiff_R2T',"", varRange[0], varRange[1], varRange[2])

#     QCDDiff2.Sumw2()

    fit1 = r.TF1("fit1","[0]", varRange[1],varRange[2])
    fit1.SetParName(0,'scale')
    fit1.FixParameter(0,1.0)

    QCDDiff.Fit('fit1', '0EM')
    fit1.SetLineStyle(2)
    fit1.SetLineColor(r.kRed)
    fit2 = r.TF1("fit2","[0]", varRange[1],varRange[2])
    fit2.SetParName(0,'scale')
    fit2.FixParameter(0,1.0)
    QCDDiff2.Fit('fit2', '0EM')
    fit2.SetLineStyle(2)
    fit2.SetLineColor(r.kRed)


    DrawSignal = False
    if signalSelection != '':
        var_signal = []
        var_signal_4KS = []
        for i in range(6):
            var_signal.append(r.TH1F('%s_%i' %(signalSelection,i),"", varRange[0], varRange[1], varRange[2]))
            var_signal_4KS.append(r.TH1F('%s_%i_4KS' %(signalSelection,i),"", nBins, varRange[1], varRange[2]))
        signalDict = draw_cfg.signalDict
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' %(signalDict[signalSelection])
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag, region, thirdLeptonVeto, relaxedRegionOption)
                if (not select) or (select > 6):
                    continue
                if usePU:
                    allWeights = treeSignal.triggerEff*treeSignal.PUWeight
                else:
                    allWeights = treeSignal.triggerEff
                var_signal[select-1].Fill(varsList.findVar(treeSignal, varName), allWeights*treeSignal.xs/(treeSignal.initEvents))
                var_signal_4KS[select-1].Fill(varsList.findVar(treeSignal, varName), allWeights*treeSignal.xs/(treeSignal.initEvents))
            initNEventsSignal = fSignal.Get('preselection')
            for i in range(6):
                var_signal[i].SetLineStyle(7)
                var_signal[i].SetLineWidth(4)
                var_signal[i].Scale(sigBoost*Lumi)
                if sigBoost != 1:
                    sum = var_signal[i].Integral(0, var_signal[i].GetNbinsX()+1)
                    legendHistos[i].append((var_signal[i], '%sx%0.f (%.2f)' %(signalSelection, sigBoost, var_signal[i].Integral(0, varRange[0]+1))))
                else:
                    legendHistos[i].append((var_signal[i], '%s (%.2f)' %(signalSelection, var_signal[i].Integral(0, varRange[0]+1))))
            DrawSignal = True
        else:
            print '%s not supported, please use H260, H300 or H350' %signalSelection

    scale_SS2OS = fit1.GetParameter(0)
    scale_er_SS2OS = fit1.GetParError(0)
    scale_relaxed2Tight = fit2.GetParameter(0)
    scale_er_relaxed2Tight = fit2.GetParError(0)

    QCDHistList_withScale[0].Scale(scale_SS2OS)
    QCDHistList_withScale[1].Scale(scale_relaxed2Tight)
    QCDHistList_withScale[2].Scale(scale_SS2OS)
    QCDHistList_withScale[3].Scale(scale_relaxed2Tight)

    QCDHistList_withScale[3].SetFillColor(r.TColor.GetColor(250,202,255))
    QCDHistList_withScale[2].SetFillColor(r.TColor.GetColor(250,202,255))
    QCDHistList_withScale[0].SetLineColor(r.TColor.GetColor(250,202,255))
    QCDHistList_withScale[0].SetLineWidth(2)
    QCDHistList_withScale[1].SetLineStyle(2)
    QCDHistList_withScale[1].SetLineColor(r.TColor.GetColor(250,202,255))
    QCDHistList_withScale[1].SetLineWidth(2)


    var_background[1].Add(QCDHistList_withScale[3])
    var_background[2].Add(QCDHistList_withScale[2])
    legendHistos[1].append((QCDHistList_withScale[3], 'QCD (%.2f)' %QCDHistList_withScale[3].Integral(0, varRange[0]+1)))
    legendHistos[2].append((QCDHistList_withScale[2], 'QCD (%.2f)' %QCDHistList_withScale[2].Integral(0, varRange[0]+1)))
    allStacked = var_background[0].Clone()
    QCDPredict = QCDHistList_withScale[1].Clone()
    QCDPredict.SetLineStyle(1)
    QCDPredict.SetLineWidth(1)

    QCDPredict.SetLineColor(r.kBlack)
    legendHistos[0].append((QCDPredict, 'QCD (%.0f, SF = %.3f)' %(QCDPredict.Integral(0, varRange[0]+1), SF)))

    QCDPredict.SetFillColor(r.TColor.GetColor(250,202,255))
    allStacked.Add(QCDPredict)

    QCDHistList_withScale[1] = tool.addFakeTHStack(QCDHistList_withScale[1],var_background[0])
    QCDHistList_withScale[0] = tool.addFakeTHStack(QCDHistList_withScale[0],var_background[0])
#     var_data[1].Sumw2()
#     MC_List[1].Sumw2()
    for i in range(varRange[0]):
        oldValue = var_data[2].GetBinContent(i+1)
        mcValue = MC_List[1].GetBinContent(i+1)
        if oldValue - mcValue > 0:
            QCDDiff2.SetBinContent(i+1, (oldValue - mcValue)/oldValue)
            QCDDiff2.SetBinError(i+1, MC_List[1].GetBinError(i+1)/oldValue)
    print QCDDiff2.Integral(0, varRange[0]+1)


    QCDDiff = var_data[2].Clone()
    QCDDiff_sub = QCDHistList_withScale[2].Clone() + MC_List[1].Clone()
    QCDDiff.Divide(QCDDiff_sub)

    QCDDiff_R2T = var_data[1].Clone()
    QCDDiff_R2T_sub = QCDHistList_withScale[3].Clone() + MC_List[0].Clone()
    QCDDiff_R2T.Divide(QCDDiff_R2T_sub)



    legendPosition = (0.6, 0.7, 0.90, 0.88)
    l = []
    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == '2M':
        titleName = '2 Medium b-tags'
        fileName = '2MbTag'
    elif bTag == '1M':
        titleName = '1 Medium b-tag'
        fileName = '1MbTag'
    elif bTag == '1M1NonM':
        titleName = '1 Medium 1 Anti-Medium b-tag'
        fileName = '1M1NonMbTag'
    elif bTag == 'None':
        titleName = '0 b-tag'
        fileName = '0bTag'

    KS1 = QCDHistList_4KS[0].KolmogorovTest(QCDHistList_4KS[2])
    KS2 = QCDHistList_4KS[1].KolmogorovTest(QCDHistList_4KS[2])

    ks_values = []
    tmpHists = []
    ks_values2 = []
    tmpHists2 = []
    nTimes = 10000
#     for i in range(nTimes):
#         tool.printProcessStatus(i, nTimes, processName = 'Making Sample Histograms')
#         tmpHists.append(r.TH1F('tmpHist_%i' %(i),"", nBins, varRange[1], varRange[2]))
#         tmpHists[i].FillRandom(QCDHistList_4KS[2], 100)
#         ks_values.append(QCDHistList_4KS[0].KolmogorovTest(tmpHists[i]))
#         tmpHists2.append(r.TH1F('tmpHist2_%i' %(i),"", nBins, varRange[1], varRange[2]))
#         tmpHists2[i].FillRandom(QCDHistList_4KS[2], 100)
#         ks_values2.append(QCDHistList_4KS[2].KolmogorovTest(tmpHists[i]))
    print ''
    print 'KS Test 1: %.3f' %KS1
    print 'KS Test 2: %.3f' %KS2
    fakeHist = r.TH1F()
    fakeHist.SetLineColor(0)
    usePUWeightName = ''
    if usePU:
        usePUWeightName = '_usePU'
    psfile = '%s_%s_%s_%s_%s%s.pdf' %(varName, fileName, signalSelection, region, relaxedRegionOption, usePUWeightName)
    c = r.TCanvas("c","Test", 800, 900)
    #ps = r.TPDF(psfile,112)
    c.Divide(2,3)
    drawOpt = ''
    QCDDiff.SetTitle('Data/Background OS Relaxed Events %s (%.1f fb^{-1}); %s; Data/Background' %(titleName, Lumi,varName))
    QCDDiff.SetMarkerStyle(8)
    QCDDiff.SetMarkerSize(0.9)
    QCDDiff.SetMaximum(4)
    QCDDiff.SetMinimum(0)
    QCDDiff_R2T.SetTitle('Data/Background OS Relaxed Events %s (%.1f fb^{-1}); %s; Data/Background' %(titleName, Lumi,varName))
    QCDDiff_R2T.SetMarkerStyle(8)
    QCDDiff_R2T.SetMarkerSize(0.9)
    QCDDiff_R2T.SetMaximum(4)
    QCDDiff_R2T.SetMinimum(0)

    pl_1 = r.TPad("pl_1","pl_1",0.,1,0.5,0.65)
    pl_1_delta = r.TPad("pl_1_delta","pl_1_delta",0.,0.65,0.5,0.45)
    pl_2 = r.TPad("pl_2","pl_2",0.,0.45,0.5,0.0)
    pl_1.SetMargin(1, 1, 0, 1)
    pl_1_delta.SetMargin(1, 1, 0.2, 0.05)

    pr_1 = r.TPad("pr_1","pr_1",0.5,1,1.,0.65)
    pr_1_delta = r.TPad("pr_1_delta","pr_1_delta",0.5,0.65,1.0,0.45)
    pr_2 = r.TPad("pr_2","pr_2",0.5,0.45,1.0,0.0)
    pr_1.SetMargin(1, 1, 0, 1)
    pr_1_delta.SetMargin(1, 1, 0.2, 0.05)

    pl_1.Draw()
    pl_1_delta.Draw()
    pl_2.Draw()
    pr_1.Draw()
    pr_1_delta.Draw()
    pr_2.Draw()

    pl_1.cd()
    r.gPad.SetTicky()
    signSelection, iso = conditions(1, region)
    allStacked.SetMaximum(int(yMax))
    allStacked.SetTitle('CMS Preliminary %.1f fb^{-1} at 8 TeV; %s; events / bin' %(Lumi,varName))
    allStacked.Draw()
    var_data[0].Draw('PE same')
    legendPosition = (0.43, 0.9 - 0.06*len(legendHistos[0]), 0.87, 0.9)
    l.append(tool.setMyLegend(lPosition=legendPosition, lHistList=getNewLegend(legendHistos[0], fakeHist)))
    l[0].Draw('same')
    var_signal[0].Draw('same')

    pl_1_delta.cd()
    r.gPad.SetTicky()
    r.gPad.SetTickx()
    pl_1_delta.SetGridy(1)
    bkgEst = QCDHistList_withScale[1].Clone()
    delta = var_data[0].Clone()
    delta.Sumw2()
    bkgEst.Sumw2()
    delta.Divide(bkgEst)
    delta.SetMinimum(0.5)
    delta.SetMaximum(1.5)
    delta.GetXaxis().SetTitle(varName)
    delta.GetXaxis().SetLabelSize(0.07)
    delta.GetXaxis().SetTitleSize(0.07)
    delta.GetYaxis().SetLabelSize(0.07)
    delta.GetYaxis().SetNdivisions(5,5,0)
    delta.Draw()

    pList = [pr_1, pl_2, pr_2]

    for k in range(1, len(pList)+1):
        pList[k-1].cd()
        r.gPad.SetTicky()
        if k > 1 and logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+1, region)
        var_background[k].SetTitle('%s %s Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        if k < 2:
            var_background[k].SetMaximum(int(yMax))
        else:
            var_background[k].SetMaximum(max)
        var_background[k].SetMinimum(0.01)
        var_background[k].Draw()
        if useData == 'True':
            var_data[k].Draw('PE same')
        legendPosition = (0.47, 0.9 - 0.06*len(legendHistos[k]), 0.87, 0.9)
        l.append(tool.setMyLegend(lPosition=legendPosition, lHistList=getNewLegend(legendHistos[k], fakeHist)))
        if k == 1:
            ksLegend1 = tool.setMyLegend((0.2, 0.8, 0.5, 0.9), [(QCDHistList_withScale[3], 'KS Test: %.3f' %KS1)])
            ksLegend1.Draw('same')
        if k == 2:
            ksLegend2 = tool.setMyLegend((0.2, 0.8, 0.5, 0.9), [(QCDHistList_withScale[2], 'KS Test: %.3f' %KS2)])
            ksLegend2.Draw('same')
        l[k].Draw('same')
        var_signal[k].Draw('same')

    pr_1_delta.cd()
    r.gPad.SetTicky()
    r.gPad.SetTickx()
    pr_1_delta.SetGridy(1)
    bkgEst2 = QCDHistList_withScale[3].Clone()
    delta2 = var_data[1].Clone()
    delta2.Sumw2()
    bkgEst2.Sumw2()
    delta2.Divide(bkgEst2)
    delta2.SetMinimum(0.5)
    delta2.SetMaximum(1.5)
    delta2.GetXaxis().SetTitle(varName)
    delta2.GetXaxis().SetLabelSize(0.07)
    delta2.GetXaxis().SetTitleSize(0.07)
    delta2.GetYaxis().SetLabelSize(0.07)
    delta2.GetYaxis().SetNdivisions(5,5,0)
    delta2.Draw()

    c.Update()
    c.Print('%s(' %psfile)

    c.Clear()

    p1 = r.TPad("p1","p1",0.,1,1.,0.4)
    p1_r = r.TPad("p1_r","p1_r",0.,0.39,1.,0.06)
    p1.SetMargin(1, 1, 0, 1)
    p1_r.SetMargin(1, 1, 0.2, 1)

    p1.Draw()
    p1_r.Draw()
    p1.cd()
    r.gPad.SetTicky()
    allStacked.Draw()

    var_data[0].Draw('PE same')
    l[0].Draw('same')
    var_signal[0].Draw('same')

    p1_r.cd()
    r.gPad.SetTicky()
    r.gPad.SetTickx()
    p1_r.SetGridy(1)

    delta.Draw()
    c.Print('%s)' %psfile)

    print "Plot saved at %s" %(psfile)
    c.Close()
コード例 #16
0
sampleName = options.inputFile[options.inputFile.find('TMVARegApp_'): options.inputFile.rfind('_new')]

c = r.TCanvas("c","Test", 800, 600)
c.Divide(2,2)
ps = r.TPDF(psfile,112)
c.cd(1)
met.SetTitle('%s met (%s); met (GeV); events / bin' %(sampleName,options.cut))
met.Draw()
met.SetMaximum(int(options.max))
met.SetFillColor(r.kAzure+8)
met.SetLineColor(r.kAzure+8)
met.SetFillStyle(3002)
metReg.Draw('same')
metReg.SetLineColor(r.kRed)
metReg.SetLineWidth(2)
l1 = tool.setMyLegend(lPosition=legendPosition3, lHistList=legendHistos1)
l1.Draw("same")
c.Update()
c.cd(2)
metInTauPair.SetTitle('%s met projected in tau pair direction (%s); met (GeV); events / bin' %(sampleName,options.cut))
metInTauPair.Draw()
metInTauPair.SetMaximum(int(options.max))
metInTauPair.SetFillColor(r.kAzure+8)
metInTauPair.SetLineColor(r.kAzure+8)
metInTauPair.SetFillStyle(3002)
metRegInTauPair.Draw('same')
metRegInTauPair.SetLineColor(r.kRed)
metRegInTauPair.SetLineWidth(2)
l2 = tool.setMyLegend(lPosition=legendPosition3, lHistList=legendHistos2)
l2.Draw("same")
c.Update()
コード例 #17
0
def compareSamples(fs):

    varNameDict_et = {
        'm_eff': 'm(#tau_{e}, #tau_{h}, #slash{E}_{T}) [GeV]',
        'ePt': 'Electron Pt [GeV]',
        'tPt': 'Tau Pt [GeV]',
        'nTruePU': 'nTruePU',
    }
    varNameDict_em = {
        'm_eff': 'm(#tau_{e}, #tau_{#mu}, #slash{E}_{T}) [GeV]',
        'ePt': 'Electron Pt [GeV]',
        'mPt': 'Muon Pt [GeV]',
        'nTruePU': 'nTruePU',
    }

    varName = 'ePt'
    varBins = 0
    if varName == 'm_eff':
        varBins = array.array('d', [
            0, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 225, 250,
            275, 300, 400, 600, 900
        ])
        hist1 = r.TH1F("hist_1", "", len(varBins) - 1, varBins)
        hist2 = r.TH1F("hist_2", "", len(varBins) - 1, varBins)
    else:
        hist1 = r.TH1F("hist_1", "", 50, 0, 500)
        hist2 = r.TH1F("hist_2", "", 50, 0, 500)

    loopOneFile(
        iSample=
        '/user_data/zmao/Jan13Production_signalRegion/ZPrime_500_all_SYNC_%s_noIso.root'
        % fs,
        varName=varName,
        hist=hist1,
        fs=fs,
        varBins=varBins)
    loopOneFile(
        iSample=
        '/user_data/zmao/Jan13Production_signalRegion/ZPrime_500_2_all_SYNC_%s_noIso.root'
        % fs,
        varName=varName,
        hist=hist2,
        fs=fs,
        varBins=varBins)

    position = (0.65, 0.85 - 0.06 * 2, 0.85, 0.85)
    histList = []
    histList.append((hist1, 'Old Zprime_500', 'lp'))
    histList.append((hist2, 'New Zprime_500', 'lp'))
    legend = tool.setMyLegend(position, histList)

    c = r.TCanvas("c", "Test", 800, 600)
    hist1.SetMarkerSize(0.5)
    hist1.SetLineColor(r.kBlue)
    hist1.SetMarkerColor(r.kBlue)
    hist2.SetMarkerSize(0.5)
    hist2.SetLineColor(r.kRed)
    hist2.SetMarkerColor(r.kRed)
    if fs == 'et':
        title = varNameDict_et[varName]
    else:
        title = varNameDict_em[varName]

    hist1.SetTitle("ZPrime Sample Comparison; %s; Events/Initial Events" %
                   title)
    hist1.SetMinimum(0.000001)
    hist1.Scale(1, 'width')
    hist2.Scale(1, 'width')

    hist1.Draw("E1")
    hist2.Draw("E1same")
    legend.Draw('same')

    r.gPad.SetLogy()

    r.gPad.SetTicky()
    r.gPad.SetTickx()
    c.Print('sampleCheck_%s_%s.pdf' % (fs, varName))
コード例 #18
0
ファイル: drawLTau.py プロジェクト: zaixingmao/H2hh2bbTauTau


print ''

psfile = 'LTauMCValidation_%s.pdf' %lepton

c = r.TCanvas("c","Test", 800, 600)
stack.SetTitle('MC Validation 19.7 fb^{-1}; tau phi; events / bin')
stack.SetMaximum(yMax)
stack.Draw()
stack.GetYaxis().SetTitleOffset(1.4)
data.SetMarkerStyle(8)
data.SetMarkerSize(0.9)
data.Draw('sameE')
l1 = tool.setMyLegend(lPosition=legendPosition, lHistList=legendHistos)
l1.Draw("same")

print 'data/MC %f'%(data.Integral()/totalBkg.Integral())

c.Update()
c.Print('%s(' %psfile)
c.Clear()
tauInfo = data.Clone()
tauInfo.Sumw2()
tauInfo.Divide(totalBkg)
tauInfo.SetMarkerStyle(8)
tauInfo.SetMarkerSize(0.9)
tauInfo.SetMaximum(1.5)
tauInfo.SetMinimum(0.5)
tauInfo.Draw('E')
コード例 #19
0
ファイル: drawQCD.py プロジェクト: zaixingmao/H2hh2bbTauTau
fmErr.SetPoint(1, ptBins[2],ratio.GetBinContent(2)+ratio.GetBinError(2))
fmErr.SetPoint(2, ptBins[2],ratio.GetBinContent(2)-ratio.GetBinError(2))
fmErr.SetFillStyle(3001)
fmErr.SetFillColor(r.kBlue)
fhErr = r.TGraph(4)
fhErr.SetPoint(0, ptBins[2],ratio.GetBinContent(3)+ratio.GetBinError(3))
fhErr.SetPoint(3, ptBins[2],ratio.GetBinContent(3)-ratio.GetBinError(3))
fhErr.SetPoint(1, ptBins[3],ratio.GetBinContent(3)+ratio.GetBinError(3))
fhErr.SetPoint(2, ptBins[3],ratio.GetBinContent(3)-ratio.GetBinError(3))
fhErr.SetFillStyle(3001)
fhErr.SetFillColor(r.kGreen)
flErr.Draw('fsame')
fmErr.Draw('fsame')
fhErr.Draw('fsame')
lFit1 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(flErr,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(ratio.GetBinContent(1), ratio.GetBinError(1))),
                                                 (fmErr,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(ratio.GetBinContent(2), ratio.GetBinError(2))),
                                                 (fhErr,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(ratio.GetBinContent(3), ratio.GetBinError(3)))])
lFit1.Draw('same')

c.cd(4)
chargeRatio.SetTitle('+ / - Ratio; %s; +/-' %varName)
chargeRatio.SetMaximum(2.5)
chargeRatio.Draw('PE')
lFit2 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(chargeRatio,'Scale between +/- in relaxed region: %.2f \pm %.2f' %(chargeRatio.GetBinContent(1), chargeRatio.GetBinError(1))),
                                                 (chargeRatio,'Scale between +/- in relaxed region: %.2f \pm %.2f' %(chargeRatio.GetBinContent(2), chargeRatio.GetBinError(2))),
                                                 (chargeRatio,'Scale between +/- in relaxed region: %.2f \pm %.2f' %(chargeRatio.GetBinContent(3), chargeRatio.GetBinError(3)))])

lFit2.Draw('same')
# chargeRatio2.Draw('samePE')
c.Update()
c.Print('QCDratio_%s_%s.pdf' %(bTag,varName))
コード例 #20
0
def compareSamples(fs):

    varNameDict_et = {'m_eff': 'm(#tau_{e}, #tau_{h}, #slash{E}_{T}) [GeV]',
                      'ePt': 'Electron Pt [GeV]',
                      'tPt': 'Tau Pt [GeV]',
                      'nTruePU': 'nTruePU',
                      'genHT': 'gen HT [GeV]',
                      'X_to_ll': 'gen Mass [GeV]',
                    }
    varNameDict_em = {'m_eff': 'm(#tau_{e}, #tau_{#mu}, #slash{E}_{T}) [GeV]',
                      'ePt': 'Electron Pt [GeV]',
                      'mPt': 'Muon Pt [GeV]',
                      'nTruePU': 'nTruePU',
                    }
    varNameDict_mt = {'m_eff': 'm(#tau_{#mu}, #tau_{h}, #slash{E}_{T}) [GeV]',
                      'tPt': 'Tau Pt [GeV]',
                      'mPt': 'Muon Pt [GeV]',
                      'genHT': 'gen HT [GeV]',
                      'nTruePU': 'nTruePU',
                      'X_to_ll': 'gen Mass [GeV]',
                    }

    varName = 'X_to_ll'
    varBins = 0
    if varName == 'm_eff':
        varBins = array.array('d', [0,100,110,120,130,140,150,160,170,180,190,200,225,250,275,300,400,600,900,1200, 1700])
    else:
        varBins = array.array('d', range(0, 1000, 10))
    hist1 = r.TH1F("hist_1", "", len(varBins)-1, varBins)
    hist2 = r.TH1F("hist_2", "", len(varBins)-1, varBins)
    hist3 = r.TH1F("hist_3", "", len(varBins)-1, varBins)
    hist4 = r.TH1F("hist_4", "", len(varBins)-1, varBins)
    hist5 = r.TH1F("hist_5", "", len(varBins)-1, varBins)
    hist6 = r.TH1F("hist_6", "", len(varBins)-1, varBins)

    dir = "/user_data/zmao/2016_signalRegionNoPZeta_fixMuon/"
#     dir = "/user_data/zmao/inclusive/"

    loopOneFile(iSample = '%s/DY-50_LO_all_SYNC_%s_noIso.root' %(dir, fs),
                varName = varName,
                hist = hist1,
                fs = fs,
                varBins = varBins)
    loopOneFile(iSample = '%s/DY-50to150_LO_all_SYNC_%s_noIso.root' %(dir, fs),
                varName = varName,
                hist = hist2,
                fs = fs,
                varBins = varBins)
    loopOneFile(iSample = '%s/DY-150_LO_all_SYNC_%s_noIso.root' %(dir, fs),
                varName = varName,
                hist = hist3,
                fs = fs,
                varBins = varBins)
#     loopOneFile(iSample = '%s/DY-50_LO_HT-200to400_all_SYNC_%s_noIso.root' %(dir, fs),
#                 varName = varName,
#                 hist = hist4,
#                 fs = fs,
#                 varBins = varBins)
#     loopOneFile(iSample = '%s/DY-50_LO_HT-400to600_all_SYNC_%s_noIso.root' %(dir, fs),
#                 varName = varName,
#                 hist = hist5,
#                 fs = fs,
#                 varBins = varBins)
#     loopOneFile(iSample = '%s/DY-50_LO_HT-600toInf_all_SYNC_%s_noIso.root' %(dir, fs),
#                 varName = varName,
#                 hist = hist6,
#                 fs = fs,
#                 varBins = varBins)
    position  = (0.7, 0.9 - 0.06*5, 0.9, 0.88)
    histList = []

    histList.append((hist1, 'Inclusive', 'lp'))
    histList.append((hist2, 'M-50to150', 'f'))
    histList.append((hist3, 'M-150', 'f'))
#     histList.append((hist4, 'HT-200to400', 'f'))
#     histList.append((hist5, 'HT-400to600', 'f'))
#     histList.append((hist6, 'HT-600toInf', 'f'))
    legend = tool.setMyLegend(position, histList)



    if fs == 'et':
        title = varNameDict_et[varName]
    elif fs == 'em':
        title = varNameDict_em[varName]
    elif fs == 'mt':
        title = varNameDict_mt[varName]

    colorList = [r.kBlack, 46, 41, 47, 30, 38]

    c = r.TCanvas("c","Test", 800, 600)
    hist1.SetMarkerSize(0.5)
    hist1.SetMarkerStyle(8)
    hist1.SetLineColor(colorList[0])
    hist1.SetMarkerColor(colorList[0])
    hist2.SetMarkerSize(0.5)
    hist2.SetLineColor(r.kBlack)
    hist2.SetFillColor(colorList[1])
    hist2.SetMarkerColor(colorList[1])

    hist3.SetMarkerSize(0.5)
    hist3.SetLineColor(r.kBlack)
    hist3.SetFillColor(colorList[2])
    hist3.SetMarkerColor(colorList[2])

    hist4.SetMarkerSize(0.5)
    hist4.SetLineColor(r.kBlack)
    hist4.SetFillColor(colorList[3])
    hist4.SetMarkerColor(colorList[3])

    hist5.SetMarkerSize(0.5)
    hist5.SetLineColor(r.kBlack)
    hist5.SetFillColor(colorList[4])
    hist5.SetMarkerColor(colorList[4])

    hist6.SetMarkerSize(0.5)
    hist6.SetLineColor(r.kBlack)
    hist6.SetFillColor(colorList[5])
    hist6.SetMarkerColor(colorList[5])
    if varName == 'm_eff':
        hist1.Scale(1, 'width')
        hist2.Scale(1, 'width')
        hist3.Scale(1, 'width')
        hist4.Scale(1, 'width')
        hist5.Scale(1, 'width')
        hist6.Scale(1, 'width')
        hist1.SetTitle("DY Inclusive/Exclusive Comparison; %s; Events/GeV" %title)
    else:
        hist1.SetTitle("DY Inclusive/Exclusive Comparison; %s; Events" %title)


    stack = r.THStack()
#     stack.Add(hist6)
#     stack.Add(hist5)
#     stack.Add(hist4)
    stack.Add(hist3)
    stack.Add(hist2)

    uncBand = buildUncBand(varBins, [hist2, hist3])

    hist1.SetMinimum(0.0001)


    hist1.Draw("E1")
    stack.Draw('hist H same')
    uncBand.Draw("E2 same")
    hist1.Draw("E1 same")

#     else:
#         hist2.Draw("E1same")
#         hist3.Draw("E1same")
#         hist4.Draw("E1same")
#         hist5.Draw("E1same")
#         hist6.Draw("E1same")

    legend.Draw('same')
    r.gPad.RedrawAxis()

    r.gPad.SetLogy()

    r.gPad.SetTicky()
    r.gPad.SetTickx()
    c.Print('sampleCheck_%s_%s.pdf' %(fs, varName))
コード例 #21
0
def run(varName, bins, unit, cat = 'em', eID = 'MVANonTrig80_2', fit = False, region = 'barrel', triggerLeg = 'e'):

    dir = '2016_trigStudy'

    dataFunc = setFunc('dataFunc')

    append_name = ''
    files_mc = [# ("SUSY", '/nfs_scratch/zmao/13TeV_samples_25ns_newSplitting_noChargeMatch/SYNC_SUSY_HToTauTau_M-160_%s_%s.root' %(cat, append_name), r.kRed)
                ]

    hist_mc_all = {}
    hist_mc_pass = {}
    file_data = '/user_data/zmao/%s/%s/data_Electron_all_SYNC_em_noIso.root'  %(dir, eID)#'/nfs_scratch/zmao/supy-output//slice/ee//data_Electron_events.root'# %(cat, append_name)

    hist_data_all = r.TH1F('hist_data_all', '', len(bins)-1, bins)
    hist_data_pass = r.TH1F('hist_data_pass', '', len(bins)-1, bins)
    
    for iName, iSample, iColor in files_mc:
        if iName not in hist_mc_all.keys():
            hist_mc_all[iName] = r.TH1F("hist_%s_all" %iName, "", len(bins)-1, bins)
            hist_mc_pass[iName] = r.TH1F("hist_%s_pass" %iName, "", len(bins)-1, bins)
        loop_one_sample(iSample, varName, hist_mc_all[iName], hist_mc_pass[iName], cat, False, region, triggerLeg)

    if file_data != '':
        loop_one_sample(file_data, varName, hist_data_all, hist_data_pass, cat, True, region, triggerLeg)


    g_mc = []
    histList = []
    funcs = []
    i = 0
    for iKey in hist_mc_all.keys():
        g_mc.append(r.TGraphAsymmErrors())
        g_mc[i].BayesDivide(hist_mc_pass[iKey], hist_mc_all[iKey])
        g_mc[i].SetMarkerStyle(8)
        g_mc[i].SetMarkerSize(0.9)
        color = getColor(iKey)
        g_mc[i].SetMarkerColor(color)
        g_mc[i].SetLineColor(color)
        if iKey == 'ttbar' and fit:
            funcs.append(setFunc('%sFunc' %iKey))
            funcs[i].SetLineColor(color)
            funcs[i].SetLineStyle(2)
            g_mc[i].Fit('%sFunc' %iKey, "R")
            histList.append((g_mc[i], "%s, plateau: %.3f +- %.3f" %(iKey, funcs[i].GetParameter(0), funcs[i].GetParError(0)), 'ep'))
        else:
            funcs.append(None)
            if len(bins) == 3:
                x = r.Double(0.0)
                y1 = r.Double(0.0)
                y2 = r.Double(0.0)
                g_mc[i].GetPoint(0, x, y1)
                g_mc[i].GetPoint(1, x, y2)
                histList.append((g_mc[i], "%s (%.3f +/- %.3f, %.3f +/- %.3f)" %(iKey, y1, g_mc[i].GetErrorY(0), y2, g_mc[i].GetErrorY(1)), 'ep'))
            else:
                histList.append((g_mc[i], iKey, 'ep'))

        
        i += 1

    g_data = r.TGraphAsymmErrors()
    g_data.BayesDivide(hist_data_pass, hist_data_all)
    dataFunc.SetLineColor(r.kBlack)
    dataFunc.SetLineStyle(2)
    fakeHist = r.TH1F("fakeHist", "", 1, 0,1)
    fakeHist.SetLineColor(r.kWhite)
    if fit:
        g_data.Fit("dataFunc", "R"); 
        histList.append((g_data, 'Observed, plateau: %.3f +/- %.3f' %(dataFunc.GetParameter(0), dataFunc.GetParError(0)), "ep"))
        histList.append((fakeHist, '          halfpoint: %.1f +/- %.1f' %(dataFunc.GetParameter(1), dataFunc.GetParError(1)), "l"))
        histList.append((fakeHist, '          slope: %.3f +/- %.3f' %(dataFunc.GetParameter(2), dataFunc.GetParError(2)), "l"))
    else:
        if len(bins) == 3:
            x = r.Double(0.0)
            data_y1 = r.Double(0.0)
            data_y2 = r.Double(0.0)
            g_data.GetPoint(0, x, data_y1)
            g_data.GetPoint(1, x, data_y2)
            histList.append((g_data, "Observed (%.3f +/- %.3f, %.3f +/- %.3f)" %(data_y1, g_data.GetErrorY(0), data_y2, g_data.GetErrorY(1)), 'ep'))
        else:
            histList.append((g_data, 'Observed', 'ep'))
    
    fakeHist = r.TH1D("fakeHist", "", 1, 0, 1)
    fakeHist.SetLineColor(r.kWhite)

    g_data.SetMarkerStyle(8)
    g_data.SetMarkerSize(0.9)
    g_data.SetMarkerColor(r.kBlack)

    length = 800
#     length = 1800

    c = r.TCanvas("c","Test", length, 800)

    null = r.TH2F("null","", len(bins)-1, bins, 1, 0, 1.1)
    null.SetMaximum(1.2)
    if triggerLeg == 'e':
        psfile = 'eleTrigTurnOnCurve_%s_%s_%s_%s.pdf' %(varName, cat, eID, region)
        null.SetTitle("electron trigger turn-on curve; %s; Effeciency" %unit)
    else:
        psfile = 'muonTrigTurnOnCurve_%s_%s_%s_%s.pdf' %(varName, cat, eID, region)
        null.SetTitle("muon trigger turn-on curve; %s; Effeciency" %unit)
    null.SetStats(False)

    if len(bins) == 3:
        leg = tool.setMyLegend((0.1, 0.4 - 0.06*4, 0.95, 0.4), histList)
    else:
        leg = tool.setMyLegend((0.45, 0.4 - 0.06*4, 0.9, 0.4), histList)


    r.gPad.SetTicky()
    r.gPad.SetTickx()
    r.gPad.SetTicky()
    null.Draw()
    for i in range(len(hist_mc_all.keys())):
        g_mc[i].Draw('same PE')
    g_data.Draw('same PE')
    leg.Draw('same')

    c.Print('%s' %psfile)
    c.Close()
コード例 #22
0
tool.unitNormHists(HistNameList)

legendPosition = (0.58, 0.7, 0.88, 0.80)
legendHist1 = [(jetCSV1_signal,"H -> hh -> #tau^{+}#tau^{-} b#bar{b}"), (jetCSV1_ZZ,"ZZ + jets -> 2q 2l"), (jetCSV1_tt,"t#bar{t} -> b#bar{b} ll")]
legendHist2 = [(jetCSV2_signal,"H -> hh -> #tau^{+}#tau^{-} b#bar{b}"), (jetCSV2_ZZ,"ZZ + jets -> 2q 2l"), (jetCSV2_tt,"t#bar{t} -> b#bar{b} ll")]

jetCSV1_signal.SetTitle("%s; CSV1; Unit Normalized" % (Title))
jetCSV2_ZZ.SetTitle("%s; CSV2; Unit Normalized" % (Title))
jetCSV1_signal.GetYaxis().SetTitleOffset(1.3)
jetCSV2_ZZ.GetYaxis().SetTitleOffset(1.3)

c = r.TCanvas("c","Test", 1400, 600)
r.gPad.SetTickx()
r.gPad.SetTicky()

psfile = os.environ['PYPATH']+'/Plots/'+psfile
ps = r.TPostScript(psfile,112)

c.Divide(2,1)
c.cd(1)
tool.setDrawHists(sigHist=jetCSV1_signal, ttHist=jetCSV1_tt, ZZHist=jetCSV1_ZZ)
l1 = tool.setMyLegend(lPosition=legendPosition, lHistList=legendHist1)
l1.Draw("same")
c.cd(2)
tool.setDrawHists(sigHist=jetCSV2_signal, ttHist=jetCSV2_tt, ZZHist=jetCSV2_ZZ)
l2 = tool.setMyLegend(lPosition=legendPosition, lHistList=legendHist2)
l2.Draw("same")
ps.Close()

print "Plot saved at %s" %(psfile)
コード例 #23
0
def getHistos(signalSelection, sigBoost, location, bTag, tail):
    r.gStyle.SetOptStat(0)
    preFix = 'ClassApp_both_ClassApp_QCD_ClassApp_EWK_TMVARegApp_'

    fileList = [('ZZ', preFix + 'ZZ_eff_all.root', 2500, 5, r.kYellow),
                ('tt_full_lep',preFix+'tt_eff_all.root', 26197.5, r.kRed-7),
                ('tt_semi_lep',preFix+'tt_semi_eff_all.root', 109281, r.kAzure+7),
#                 ('DYJetsToLL', 'DYJetsToLL_eff_all.root', 3504000, r.kGreen-7),
                ('DY2JetsToLL', preFix+'DY2JetsToLL_eff_all.root', 181000, r.kGreen-7),
                ('DY3JetsToLL', preFix+'DY3JetsToLL_eff_all.root', 51100, r.kGreen-7),
                ('W1JetsToLNu', preFix+'W1JetsToLNu_eff_all.root', 5400000, r.kMagenta-9),
                ('W2JetsToLNu', preFix+'W2JetsToLNu_eff_all.root', 1750000, r.kMagenta-9),
                ('W3JetsToLNu', preFix+'W3JetsToLNu_eff_all.root', 519000, r.kMagenta-9)]
    histList = []
    QCDHistList = []
    varRange = [100, -1, 1]
    varRange2 = [20, -1, 1]
    varRange3 = [100, 0, 1]
    varRange4 = [20, -1, 1]

    Lumi = 19.0
    initNEventsList = []
    legendHistos = []

    rootFileName = '%s/BDTEfficiency_%s.root' %(location, tail)
    oFile = r.TFile(rootFileName,"RECREATE")

    tmpFile = []
    tmpTree = []
    var_data = []
    signal_EWK = r.TH1F('signal_EWK',"", varRange[0], varRange[1], varRange[2])
    signal_QCD = r.TH1F('signal_QCD',"", varRange[0], varRange[1], varRange[2])
    signal_both = r.TH1F('signal_both',"", varRange[0], varRange[1], varRange[2])
    signal_2D = r.TH2F('signal_2D',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])
    lkr_2D = r.TH2F('lkr_2D',"", varRange2[0], varRange2[1], varRange2[2], varRange2[0], varRange2[1], varRange2[2])


    eff_QCD = r.TH1F('eff_QCD', '', varRange3[0], varRange3[1], varRange3[2])
    eff_EWK = r.TH1F('eff_EWK', '', varRange3[0], varRange3[1], varRange3[2])
    eff_both = r.TH1F('eff_both', '', varRange3[0], varRange3[1], varRange3[2])
    eff_2D = r.TH1F('eff_2D', '', varRange3[0], varRange3[1], varRange3[2])

    background_EWK = r.TH1F('background_EWK',"", varRange[0], varRange[1], varRange[2])
    background_QCD = r.TH1F('background_QCD',"", varRange[0], varRange[1], varRange[2])
    background_both = r.TH1F('background_both',"", varRange[0], varRange[1], varRange[2])
    background_2D = r.TH2F('background_2D',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])
    total_2D = r.TH2F('total_2D',"", varRange4[0], varRange4[1], varRange4[2], varRange4[0], varRange4[1], varRange4[2])

    MC_EWK = r.TH1F('MC_EWK',"", varRange[0], varRange[1], varRange[2])
    MC_QCD = r.TH1F('MC_QCD',"", varRange[0], varRange[1], varRange[2])
    MC_both = r.TH1F('MC_both',"", varRange[0], varRange[1], varRange[2])
    MC_2D = r.TH2F('MC_2D',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])

    data_EWK = r.TH1F('data_EWK',"", varRange[0], varRange[1], varRange[2])
    data_QCD = r.TH1F('data_QCD',"", varRange[0], varRange[1], varRange[2])
    data_both = r.TH1F('data_both',"", varRange[0], varRange[1], varRange[2])
    data_2D = r.TH2F('data_2D',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])

    dataName = preFix + 'dataTotal_all.root'
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' %dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag)
        if select == 3:
            data_EWK.Fill(varsList.findVar(treeData, 'BDT_EWK'))
            data_QCD.Fill(varsList.findVar(treeData, 'BDT_QCD'))
            data_both.Fill(varsList.findVar(treeData, 'BDT_both'))
            data_2D.Fill(varsList.findVar(treeData, 'BDT_EWK'), varsList.findVar(treeData, 'BDT_QCD'))
    for i in range(len(fileList)):
        print 'Adding events from: %s ...' %(fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        initNEventsList.append(tmpFile[i].Get('preselection'))
        tmpScale = fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1)
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag)
            if select == 1:
                background_EWK.Fill(varsList.findVar(tmpTree[i], 'BDT_EWK'), tmpTree[i].triggerEff*tmpScale)
                background_QCD.Fill(varsList.findVar(tmpTree[i], 'BDT_QCD'), tmpTree[i].triggerEff*tmpScale)
                background_both.Fill(varsList.findVar(tmpTree[i], 'BDT_both'), tmpTree[i].triggerEff*tmpScale)
                background_2D.Fill(varsList.findVar(tmpTree[i], 'BDT_EWK'), varsList.findVar(tmpTree[i], 'BDT_QCD'), tmpTree[i].triggerEff*tmpScale)
            if select == 3:
                MC_EWK.Fill(varsList.findVar(tmpTree[i], 'BDT_EWK'), tmpTree[i].triggerEff*tmpScale)
                MC_QCD.Fill(varsList.findVar(tmpTree[i], 'BDT_QCD'), tmpTree[i].triggerEff*tmpScale)
                MC_both.Fill(varsList.findVar(tmpTree[i], 'BDT_both'), tmpTree[i].triggerEff*tmpScale)
                MC_2D.Fill(varsList.findVar(tmpTree[i], 'BDT_EWK'), varsList.findVar(tmpTree[i], 'BDT_QCD'), tmpTree[i].triggerEff*tmpScale)

    if signalSelection != '':
        var_signal = []
        for i in range(4):
            var_signal.append(r.TH1F('%s_%i' %(signalSelection,i),"", varRange[0], varRange[1], varRange[2]))
        signalDict = {'H260': (preFix+'H2hh260_all.root', 14.76),
                      'H300': (preFix+'H2hh300_all.root', 15.9),
                      'H350': (preFix+'H2hh350_all.root', 8.57)}
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection][0])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' %(signalDict[signalSelection][0])
            initNEventsSignal = fSignal.Get('preselection')
            scaleSignal = signalDict[signalSelection][1]*sigBoost*Lumi/initNEventsSignal.GetBinContent(1)
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag)
                if select == 1:
                    signal_EWK.Fill(varsList.findVar(treeSignal, 'BDT_EWK'), treeSignal.triggerEff)
                    signal_QCD.Fill(varsList.findVar(treeSignal, 'BDT_QCD'), treeSignal.triggerEff)
                    signal_both.Fill(varsList.findVar(treeSignal, 'BDT_both'), treeSignal.triggerEff)
                    signal_2D.Fill(varsList.findVar(treeSignal, 'BDT_EWK'), varsList.findVar(treeSignal, 'BDT_QCD'), treeSignal.triggerEff)
            signal_EWK.Scale(scaleSignal)
            signal_QCD.Scale(scaleSignal)
            signal_both.Scale(scaleSignal)
            signal_2D.Scale(scaleSignal)
        else:
            print '%s not supported, please use H260, H300 or H350' %signalSelection

    background_EWK = estBkg(MC_EWK, data_EWK, background_EWK, 0.025)
    background_QCD = estBkg(MC_QCD, data_QCD, background_QCD, 0.025)
    background_both = estBkg(MC_both, data_both, background_both, 0.025)
    background_2D = estBkg2(MC_2D, data_2D, background_2D, 0.025)
    total_2D = combineSigBkg2(signal_2D, background_2D, total_2D)

    eff_EWK = calcBDTEff(signal_EWK, background_EWK, eff_EWK)
    eff_QCD = calcBDTEff(signal_QCD, background_QCD, eff_QCD)
    eff_both = calcBDTEff(signal_both, background_both, eff_both)
    lkr_2D = calcBDTLikelyhoodRatio2D(signal_2D, background_2D, lkr_2D)
    eff_2D = calcEffFromLKR(signal_2D, background_2D, lkr_2D, eff_2D)

    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == 'Revert':
        titleName = 'Revert b-tag'
        fileName = 'revert_bTag'

    psfile = '%s/BDT_Eff_%s.pdf' %(location, fileName)
    c = r.TCanvas("c","Test", 800, 600)
    r.gPad.SetTickx()
    r.gPad.SetTicky()


    eff_EWK.SetTitle('Background Rejection VS Signal Efficiency ; Background Rejection; Signal Efficiency')
    eff_both.SetTitle('Background Rejection VS Signal Efficiency ; Background Rejection; Signal Efficiency')
    eff_EWK.SetMarkerColor(r.kBlue)
    eff_QCD.SetMarkerColor(r.kRed)
    eff_both.SetMarkerColor(r.kBlack)
    eff_2D.SetMarkerColor(8)
    eff_EWK.SetMarkerSize(1.5)
    eff_QCD.SetMarkerSize(1.5)
    eff_both.SetMarkerSize(1.5)
    eff_2D.SetMarkerSize(1.5)
    eff_EWK.SetMarkerStyle(2)
    eff_QCD.SetMarkerStyle(2)
    eff_both.SetMarkerStyle(2)
    eff_2D.SetMarkerStyle(2)

    eff_EWK.Draw('P')    
    eff_QCD.Draw('SAMEP')    
    eff_both.Draw('sameP')
    eff_2D.Draw('sameP')
    legendPosition = (0.2, 0.6, 0.45, 0.75)
    l = tool.setMyLegend(lPosition=legendPosition, lHistList=[(eff_EWK, "EWK"), (eff_QCD, "QCD"), (eff_both, "Combined"), (eff_2D, "EWK+QCD 2D cut")])
    l.Draw('same')
    c.Update()
    c.Print('%s(' %psfile)
    c.Clear()  
    eff_both.Draw('P')
    eff_2D.Draw('Psame')
    legendPosition = (0.2, 0.6, 0.45, 0.75)
    l_2 = tool.setMyLegend(lPosition=legendPosition, lHistList=[(eff_both, "Combined"), (eff_2D, "EWK+QCD 2D cut")])
    l_2.Draw('same')
    c.Update()
    c.Print('%s' %psfile)
    c.Clear()
    c.Divide(2,2)
    c.cd(1)
    r.gPad.SetLogz()

    signal_2D.SetTitle('OS tight Events 1 Medium 1 Loose b-Tag (%.1f fb^{-1}); BDT_EWK;BDT_QCD; events / bin' %(Lumi))
    signal_2D.Draw("CONTZ")
    legendPosition = (0.65, 0.75, 0.9, 0.9)
    l1 = tool.setMyLegend(lPosition=legendPosition, lHistList=[(signal_2D, "signal x%.0f (%.2f)" %(sigBoost,signal_2D.Integral()))])
    l1.Draw('same')
    c.cd(2)
    r.gPad.SetLogz()

    background_2D.SetTitle('OS tight Events 1 Medium 1 Loose b-Tag (%.1f fb^{-1}); BDT_EWK;BDT_QCD; events / bin' %(Lumi))
    background_2D.Draw("CONTZ")
    l2 = tool.setMyLegend(lPosition=legendPosition, lHistList=[(background_2D, "background (%.2f)" %background_2D.Integral())])
    l2.Draw('same')
    c.cd(3)
    total_2D.SetTitle('OS tight Events 1 Medium 1 Loose b-Tag (%.1f fb^{-1}); BDT_EWK;BDT_QCD; events / bin' %(Lumi))
    total_2D.Draw("CONTZ")
    l3 = tool.setMyLegend(lPosition=legendPosition, lHistList=[(total_2D, "total (%.2f)" %total_2D.Integral())])
    l3.Draw('same')

    c.cd(4)
    r.gPad.SetLogz()
    lkr_2D.SetTitle('Signal/Background ratio; BDT_EWK;BDT_QCD; events / bin')

    lkr_2D.Draw('CONTZ')
    c.Update()
    c.Print('%s)' %psfile)
    print "Plot saved at %s" %(psfile)
    oFile.cd()
    eff_EWK.Write()    
    eff_QCD.Write()    
    eff_both.Write()
    eff_2D.Write()
    lkr_2D.Write()
    oFile.Close()
    print "ROOT file saved at %s" %(rootFileName)
コード例 #24
0
def getHistos(varName, signalSelection, logY, sigBoost, nbins, useData, max, rangeMin, rangeMax, location, bTag, predict, predictPtBin, scale, region):
    r.gStyle.SetOptStat(0)
    preFix = 'ClassApp_both_ClassApp_QCD_ClassApp_EWK_TMVARegApp_'

    fileList = [('ZZ', preFix + 'ZZ_eff_all.root', 2500, 5),
                ('WZJetsTo2L2Q', preFix + 'WZJetsTo2L2Q_eff_all.root', 2207, 5),
                ('tt_full_lep',preFix + 'tt_eff_all.root', 26197.5, r.kRed-7),
                ('tt_semi_lep',preFix + 'tt_semi_eff_all.root', 109281, r.kAzure+7),
                #('DYJetsToLL', 'TMVARegApp_DYJetsToLL_eff_all.root', 3504000, r.kGreen-7),
                ('DY1JetsToLL', preFix + 'DY1JetsToLL_eff2_all.root', 561000, r.kGreen-7),
                ('DY2JetsToLL', preFix + 'DY2JetsToLL_eff2_all.root', 181000, r.kGreen-7),
                ('DY3JetsToLL', preFix + 'DY3JetsToLL_eff2_all.root', 51100, r.kGreen-7),
                ('W1JetsToLNu', preFix + 'W1JetsToLNu_eff2_all.root', 5400000, r.kMagenta-9),
                ('W2JetsToLNu', preFix + 'W2JetsToLNu_eff2_all.root', 1750000, r.kMagenta-9),
                ('W3JetsToLNu', preFix + 'W3JetsToLNu_eff2_all.root', 519000, r.kMagenta-9)]

    histList = []
    QCDHistList = []
    varRange = [nbins, rangeMin, rangeMax]
    Lumi = 19.0
    initNEventsList = []
    legendHistos = []
    var_background = []
    if scale == 1:
        ptBins = [varRange[1], 70, 120, varRange[2]]
    else:
        ptBins = [varRange[1], varRange[2], varRange[2], varRange[2]]
    bins = array('f', ptBins)
    scaleMCPt = 1

    tmpFile = []
    tmpTree = []
    var_data = []

    for i in range(3):
        var_data.append(r.TH1F('data_%i' %(i),"", len(ptBins)-1, bins))
    dataName = preFix + 'dataTotal_all.root'
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' %dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag, region)
        if (select == 0) or (select == 1) or (select > 4):
            continue
        if region == 'LT':
            var_data[select-2].Fill(treeData.pt1.at(0))
        else:
            var_data[select-2].Fill(treeData.pt2.at(0))
    legendHistos.append([])
    for j in range(3):
        var_data[j].SetMarkerStyle(8)
        var_data[j].SetMarkerSize(0.9)
        legendHistos.append([])
        legendHistos[j+1].append((var_data[j], 'observed (%.0f)' %var_data[j].Integral()))

    for i in range(len(fileList)): 
        for j in range(4):
            histList.append(r.TH1F('%s_%i' %(fileList[i][0],j),fileList[i][0], len(ptBins)-1, bins))
        print 'Adding events from: %s ...' %(fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag, region)
            if (not select) or (select > 4):
                continue
            if region == 'LT':
                histList[4*i+select-1].Fill(tmpTree[i].pt1.at(0)*scaleMCPt, tmpTree[i].triggerEff)
            else:
                histList[4*i+select-1].Fill(tmpTree[i].pt2.at(0)*scaleMCPt, tmpTree[i].triggerEff)
    
        initNEventsList.append(tmpFile[i].Get('preselection'))
        for j in range(4):
            var_background.append(r.THStack())
            histList[4*i+j].SetFillColor(fileList[i][3])
            histList[4*i+j].Scale(fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1))
            var_background[j].Add(histList[4*i+j])
            legendHistos[j].append((histList[4*i+j], '%s (%.2f)' %(fileList[i][0], histList[4*i+j].Integral())))

    data_i = []
    MC_i = []
    data_r = []
    MC_r = []
    e = []

    for i in range(3):
        QCDHistList.append(r.TH1F('QCD_%i' %(i),"", len(ptBins)-1, bins))
        for j in range(varRange[0]):
            dataValue = var_data[i].GetBinContent(j+1)
            dataError = var_data[i].GetBinError(j+1)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue +=  histList[4*k+1+i].GetBinContent(j+1)
            if i == 0:
                data_i.append(dataValue)
                e.append(dataError)
                MC_i.append(MCValue)
            if i == 2:
                data_r.append(dataValue)
                MC_r.append(MCValue)
            if dataValue - MCValue > 0:
                QCDHistList[i].SetBinContent(j+1, dataValue - MCValue)
                QCDHistList[i].SetBinError(j+1, dataError)

    QCDDiff = r.TH1F('QCD_diff',"", len(ptBins)-1, bins)
    QCDDiff2 = r.TH1F('QCD_diff2',"", len(ptBins)-1, bins)

    QCDDiff = QCDHistList[1].Clone()
    QCDDiff.Divide(QCDHistList[2])
    QCDDiff.Sumw2()
    QCDDiff2 = QCDHistList[0].Clone()
    QCDDiff2.Divide(QCDHistList[2])
    QCDDiff2.Sumw2()

    DrawSignal = False
    if signalSelection != '':
        var_signal = []
        for i in range(4):
            var_signal.append(r.TH1F('%s_%i' %(signalSelection,i),"", len(ptBins)-1, bins))
        signalDict = {'H260': (preFix + 'H2hh260_all.root', 14.76),
                      'H300': (preFix + 'H2hh300_all.root', 15.9),
                      'H350': (preFix + 'H2hh350_all.root', 8.57)}
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection][0])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' %(signalDict[signalSelection][0])
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag, region)
                if (not select) or (select > 4):
                    continue
                if region == 'LT':
                    var_signal[select-1].Fill(treeSignal.pt1.at(0), treeSignal.triggerEff)
                else:
                    var_signal[select-1].Fill(treeSignal.pt2.at(0), treeSignal.triggerEff)

            initNEventsSignal = fSignal.Get('preselection')
            for i in range(4):
                var_signal[i].SetLineStyle(7)
                var_signal[i].SetLineWidth(4)
                var_signal[i].Scale(signalDict[signalSelection][1]*sigBoost*Lumi/initNEventsSignal.GetBinContent(1))
                if sigBoost != 1:
                    legendHistos[i].append((var_signal[i], '%sx%0.f (%.2f)' %(signalSelection, sigBoost, var_signal[i].Integral())))
                else:
                    legendHistos[i].append((var_signal[i], '%s (%.2f)' %(signalSelection, var_signal[i].Integral())))
            DrawSignal = True
        else:
            print '%s not supported, please use H260, H300 or H350' %signalSelection

    if predict == 'True':
        relaxed2Tight = r.TH1F('relaxed2Tight','', len(ptBins)-1, bins)
        SS2OS = r.TH1F('SS2OS','', len(ptBins)-1, bins)
        relaxed2Signal = r.TH1F('relaxed2Signal','', len(ptBins)-1, bins)
        SS2OS_signal = r.TH1F('SS2OS_signal','', len(ptBins)-1, bins)
        fullHistTranslate = r.TH1F('fullHistTranslate','', len(ptBins)-1, bins)


        scale_SS2OS_l = QCDDiff.GetBinContent(1)
        scale_er_SS2OS_l = QCDDiff.GetBinError(1)
        scale_relaxed2Tight_l = QCDDiff2.GetBinContent(1)
        scale_er_relaxed2Tight_l = QCDDiff2.GetBinError(1)
        scale_SS2OS_m = QCDDiff.GetBinContent(2)
        scale_er_SS2OS_m = QCDDiff.GetBinError(2)
        scale_relaxed2Tight_m = QCDDiff2.GetBinContent(2)
        scale_er_relaxed2Tight_m = QCDDiff2.GetBinError(2)
        scale_SS2OS_h = QCDDiff.GetBinContent(3)
        scale_er_SS2OS_h = QCDDiff.GetBinError(3)
        scale_relaxed2Tight_h = QCDDiff2.GetBinContent(3)
        scale_er_relaxed2Tight_h = QCDDiff2.GetBinError(3)

        for i in range(varRange[0]):

            SS_tight_Events = QCDHistList[0].GetBinContent(i+1)
            SS_tight_Error = QCDHistList[0].GetBinError(i+1)
            OS_relaxed_Events = QCDHistList[1].GetBinContent(i+1)
            OS_relaxed_Error = QCDHistList[1].GetBinError(i+1)
            SS_Events = QCDHistList[2].GetBinContent(i+1)
            SS_Error = QCDHistList[2].GetBinError(i+1)

            if predictPtBin == 'True':
                ptValue1 = QCDHistList[0].GetBinCenter(i+1)
                ptValue2 = QCDHistList[1].GetBinCenter(i+1)
                if ptValue1 <= ptBins[1]:
                    scale_1 = scale_relaxed2Tight_l
                elif ptValue1 <= ptBins[2]:
                    scale_1 = scale_relaxed2Tight_m
                elif ptValue1 > ptBins[2]:
                    scale_1 = scale_relaxed2Tight_h

                if ptValue2 <= ptBins[1]:
                    scale_2 = scale_SS2OS_l
                elif ptValue2 <= ptBins[2]:
                    scale_2 = scale_SS2OS_m
                elif ptValue2 > ptBins[2]:
                    scale_2 = scale_SS2OS_h

            relaxed2Tight.SetBinContent(i+1, scale_1*SS_Events)
            relaxed2Signal.SetBinContent(i+1, scale_1*OS_relaxed_Events)
            SS2OS.SetBinContent(i+1, scale_2*SS_Events)
            SS2OS_signal.SetBinContent(i+1, scale_2*SS_tight_Events)

            if SS_Events > 0:
                fullHistTranslate.SetBinContent(i+1, SS_tight_Events*OS_relaxed_Events/SS_Events)

#             relaxed2Tight.SetBinError(i+1, getCombinedError(scale_relaxed2Tight, scale_er_relaxed2Tight, SS_Events, SS_Error))
#             SS2OS.SetBinError(i+1, getCombinedError(scale_SS2OS, scale_er_SS2OS, SS_Events, SS_Error))
#             relaxed2Tight.SetLineColor(r.kSpring+8)
        relaxed2Tight.SetFillColor(r.kSpring+1)
#             SS2OS.SetLineColor(r.kOrange)
        SS2OS.SetFillColor(r.kOrange-4)
        SS2OS_signal.SetLineColor(r.kSpring+1)
        SS2OS_signal.SetLineWidth(2)
        relaxed2Signal.SetLineStyle(2)
        relaxed2Signal.SetLineColor(r.kOrange-4)
        relaxed2Signal.SetLineWidth(2)
        fullHistTranslate.SetLineColor(r.kPink+1)
        fullHistTranslate.SetLineWidth(2)
        fullHistTranslate.SetLineStyle(2)

        legendHistos[0].append((SS2OS_signal, 'From SS/Tight (%.0f)' %SS2OS_signal.Integral()))
        legendHistos[0].append((relaxed2Signal, 'From OS/Relax (%.0f)' %relaxed2Signal.Integral()))
        #legendHistos[0].append((fullHistTranslate, 'full hist (%.0f)' %fullHistTranslate.Integral()))

        var_background[1].Add(relaxed2Tight)
        var_background[2].Add(SS2OS)
        legendHistos[1].append((relaxed2Tight, 'From SS/Relax (%.0f)' %relaxed2Tight.Integral()))
        legendHistos[2].append((SS2OS, 'From SS/Relax (%.0f)' %SS2OS.Integral()))
        relaxed2Signal = tool.addFakeTHStack(relaxed2Signal,var_background[0])
        SS2OS_signal = tool.addFakeTHStack(SS2OS_signal,var_background[0])
        fullHistTranslate = tool.addFakeTHStack(fullHistTranslate,var_background[0])



    legendPosition = (0.6, 0.7, 0.90, 0.88)
    l = []
    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == 'Revert':
        titleName = 'Revert b-tag'
        fileName = 'revert_bTag'
    elif bTag == 'Loose':
        titleName = 'Loose b-tag'
        fileName = 'loose_bTag'

    psfile = '%s/%s_%s_%s_%i.pdf' %(location, varName, fileName, region, scale)
    c = r.TCanvas("c","Test", 800, 600)
    #ps = r.TPDF(psfile,112)
    c.Divide(2,2)
    drawOpt = ''
    for k in range(4):
        c.cd(k+1)
        if logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+1)
        var_background[k].SetTitle('%s %s Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        var_background[k].SetMaximum(max)
        var_background[k].SetMinimum(0.01)
        var_background[k].Draw()
        if predict == 'True' and k == 0:
            SS2OS_signal.Draw('same')
            relaxed2Signal.Draw('same')
            #fullHistTranslate.Draw('same')
        if k != 0 and useData == 'True':
            var_data[k-1].Draw('PE same')
        legendPosition = (0.63, 0.93 - 0.035*len(legendHistos[k]), 0.93, 0.9)
        l.append(tool.setMyLegend(lPosition=legendPosition, lHistList=legendHistos[k]))
        l[k].Draw('same')
        var_signal[k].Draw('same')
    c.Update()
    c.Print('%s(' %psfile)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff.SetTitle('OS/SS MultiJet Relaxed Events %s (%.1f fb^{-1}); %s; OS/SS' %(titleName, Lumi,varName))
    QCDDiff.SetMarkerStyle(8)
    QCDDiff.SetMarkerSize(0.9)
    QCDDiff.SetMaximum(4)
    QCDDiff.SetMinimum(0)
    QCDDiff.Draw('PE')

    flErr = r.TGraph(4)
    flErr.SetPoint(0, ptBins[0],QCDDiff.GetBinContent(1)+QCDDiff.GetBinError(1))
    flErr.SetPoint(3, ptBins[0],QCDDiff.GetBinContent(1)-QCDDiff.GetBinError(1))
    flErr.SetPoint(1, ptBins[1],QCDDiff.GetBinContent(1)+QCDDiff.GetBinError(1))
    flErr.SetPoint(2, ptBins[1],QCDDiff.GetBinContent(1)-QCDDiff.GetBinError(1))
    flErr.SetFillStyle(3001)
    flErr.SetFillColor(r.kRed)
    fmErr = r.TGraph(4)
    fmErr.SetPoint(0, ptBins[1],QCDDiff.GetBinContent(2)+QCDDiff.GetBinError(2))
    fmErr.SetPoint(3, ptBins[1],QCDDiff.GetBinContent(2)-QCDDiff.GetBinError(2))
    fmErr.SetPoint(1, ptBins[2],QCDDiff.GetBinContent(2)+QCDDiff.GetBinError(2))
    fmErr.SetPoint(2, ptBins[2],QCDDiff.GetBinContent(2)-QCDDiff.GetBinError(2))
    fmErr.SetFillStyle(3001)
    fmErr.SetFillColor(r.kBlue)
    fhErr = r.TGraph(4)
    fhErr.SetPoint(0, ptBins[2],QCDDiff.GetBinContent(3)+QCDDiff.GetBinError(3))
    fhErr.SetPoint(3, ptBins[2],QCDDiff.GetBinContent(3)-QCDDiff.GetBinError(3))
    fhErr.SetPoint(1, ptBins[3],QCDDiff.GetBinContent(3)+QCDDiff.GetBinError(3))
    fhErr.SetPoint(2, ptBins[3],QCDDiff.GetBinContent(3)-QCDDiff.GetBinError(3))
    fhErr.SetFillStyle(3001)
    fhErr.SetFillColor(r.kGreen)
    flErr.Draw('fsame')
    fmErr.Draw('fsame')
    fhErr.Draw('fsame')

    lFit1 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(flErr,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(QCDDiff.GetBinContent(1), QCDDiff.GetBinError(1))),
                                                     (fmErr,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(QCDDiff.GetBinContent(2), QCDDiff.GetBinError(2))),
                                                     (fhErr,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(QCDDiff.GetBinContent(3), QCDDiff.GetBinError(3)))])
    lFit1.Draw('same')


    for k in range(3):
        c.cd(k+2)
        if logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+2)
        QCDHistList[k].SetTitle('%s %s Data - MC Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        QCDHistList[k].SetMarkerStyle(8)
        QCDHistList[k].SetMarkerSize(0.9)
        QCDHistList[k].SetMaximum(max)
        QCDHistList[k].SetMinimum(1)
        QCDHistList[k].Draw('PE')
    c.Update()
    c.Print('%s' %psfile)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff2.SetTitle('tight/relaxed MultiJet SS Events %s (%.1f fb^{-1}); %s; tight/relaxed' %(titleName, Lumi,varName))
    QCDDiff2.SetMarkerStyle(8)
    QCDDiff2.SetMarkerSize(0.9)
    QCDDiff2.SetMinimum(0)
    QCDDiff2.SetMaximum(0.2)
    QCDDiff2.Draw('PE')
 
    flErr2 = r.TGraph(4)
    flErr2.SetPoint(0, ptBins[0],QCDDiff2.GetBinContent(1)+QCDDiff2.GetBinError(1))
    flErr2.SetPoint(3, ptBins[0],QCDDiff2.GetBinContent(1)-QCDDiff2.GetBinError(1))
    flErr2.SetPoint(1, ptBins[1],QCDDiff2.GetBinContent(1)+QCDDiff2.GetBinError(1))
    flErr2.SetPoint(2, ptBins[1],QCDDiff2.GetBinContent(1)-QCDDiff2.GetBinError(1))
    flErr2.SetFillStyle(3001)
    flErr2.SetFillColor(r.kRed)
    fmErr2 = r.TGraph(4)
    fmErr2.SetPoint(0, ptBins[1],QCDDiff2.GetBinContent(2)+QCDDiff2.GetBinError(2))
    fmErr2.SetPoint(3, ptBins[1],QCDDiff2.GetBinContent(2)-QCDDiff2.GetBinError(2))
    fmErr2.SetPoint(1, ptBins[2],QCDDiff2.GetBinContent(2)+QCDDiff2.GetBinError(2))
    fmErr2.SetPoint(2, ptBins[2],QCDDiff2.GetBinContent(2)-QCDDiff2.GetBinError(2))
    fmErr2.SetFillStyle(3001)
    fmErr2.SetFillColor(r.kBlue)
    fhErr2 = r.TGraph(4)
    fhErr2.SetPoint(0, ptBins[2],QCDDiff2.GetBinContent(3)+QCDDiff2.GetBinError(3))
    fhErr2.SetPoint(3, ptBins[2],QCDDiff2.GetBinContent(3)-QCDDiff2.GetBinError(3))
    fhErr2.SetPoint(1, ptBins[3],QCDDiff2.GetBinContent(3)+QCDDiff2.GetBinError(3))
    fhErr2.SetPoint(2, ptBins[3],QCDDiff2.GetBinContent(3)-QCDDiff2.GetBinError(3))
    fhErr2.SetFillStyle(3001)
    fhErr2.SetFillColor(r.kGreen)
    flErr2.Draw('fsame')
    fmErr2.Draw('fsame')
    fhErr2.Draw('fsame')
    lFit2 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(flErr2,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(QCDDiff2.GetBinContent(1), QCDDiff2.GetBinError(1))),
                                                     (fmErr2,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(QCDDiff2.GetBinContent(2), QCDDiff2.GetBinError(2))),
                                                    (fhErr2,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(QCDDiff2.GetBinContent(3), QCDDiff2.GetBinError(3)))])
    lFit2.Draw('same')


    c.Print('%s)' %psfile)
    #ps.Close()
    print "Plot saved at %s" %(psfile)
コード例 #25
0
def go(sig, bkg):

    bins_array = array('d', range(20,151,1))
    sigHist = r.TH2F('sigHist', "", len(bins_array)-1, bins_array,len(bins_array)-1, bins_array)
    bkgHist = r.TH2F('bkgHist', "", len(bins_array)-1, bins_array,len(bins_array)-1, bins_array)
    sigHistJet1 = r.TH2F('sigHistJet1', "", len(bins_array)-1, bins_array,len(bins_array)-1, bins_array)
    bkgHistJet1 = r.TH2F('bkgHistJet1', "", len(bins_array)-1, bins_array,len(bins_array)-1, bins_array)
    sigHistJet2 = r.TH2F('sigHistJet2', "", len(bins_array)-1, bins_array,len(bins_array)-1, bins_array)
    bkgHistJet2 = r.TH2F('bkgHistJet2', "", len(bins_array)-1, bins_array,len(bins_array)-1, bins_array)
    sigHistJet3 = r.TH2F('sigHistJet3', "", len(bins_array)-1, bins_array,len(bins_array)-1, bins_array)
    bkgHistJet3 = r.TH2F('bkgHistJet3', "", len(bins_array)-1, bins_array,len(bins_array)-1, bins_array)

    bkgHist2 = r.TH2F('bkgHist2', "", 10000, 0, 1.0, 10000, 0, 1.0)
    bkgHistJet = r.TH2F('bkgHistJet', "", 10000, 0, 1.0, 10000, 0, 1.0)

    distHist3 = r.TH1F('distHist3', "", len(bins_array)-1, bins_array)

    distHist = r.TGraph()
    distHist_2 = r.TGraph()
    distHist2 = r.TGraph()
    distHist2_2 = r.TGraph()
    distHist4 = r.TGraph()
    distHist4_2 = r.TGraph()
    distHist5 = r.TGraph()
    distHist5_2 = r.TGraph()

    distHist3.SetTitle('; PtHat; weight')

#     distHist2 = r.TH2F('distHist2', "", len(bins_array)-1, bins_array, len(bins_array)-1, bins_array)

    sigHist = getPtDistribution(sig, sigHist, None, None, 0.0, 'central', False, True)
    sigHistJet1 = getPtDistribution(sig, sigHistJet1, None, None, 30.0, 'central', False, True)
    sigHistJet2 = getPtDistribution(sig, sigHistJet2, None, None, 40.0)
    sigHistJet3 = getPtDistribution(sig, sigHistJet3, None, None, 50.0)

    sigHist.SetTitle('h2#tau#tau; Leading jet Pt; Leading #tau Pt')

    bkgHist, bkgHist2, distHist3 = getPtDistribution(bkg, bkgHist, bkgHist2, distHist3, 0.0, 'central', False, True)
    bkgHistJet1, bkgHistJet = getPtDistribution(bkg, bkgHistJet1, bkgHistJet, None, 30.0, 'central', False, True)
    bkgHistJet2, bkgHistJet = getPtDistribution(bkg, bkgHistJet2, bkgHistJet, None, 40.0)
    bkgHistJet3, bkgHistJet = getPtDistribution(bkg, bkgHistJet3, bkgHistJet, None, 50.0)

    bkgHist.SetTitle('QCD; Leading jet Pt; Leading #tau Pt')
    bkgHist2.SetTitle('QCD; 200000*PtHat^{-4.5}; weight')

    getBothDistribution(sigHist, bkgHist, distHist, distHist_2)
    getBothDistribution(sigHist, bkgHist, distHist5, distHist5_2, 5)
    getBothDistribution(sigHist, bkgHist, distHist2, distHist2_2, 10)
    getBothDistribution(sigHist, bkgHist, distHist4, distHist4_2, 15)

    jet1 = r.TGraph()
    jet1_2 = r.TGraph()
    jet2 = r.TGraph()
    jet2_2 = r.TGraph()
    jet3 = r.TGraph()
    jet3_2 = r.TGraph()



    getBothDistribution(sigHistJet1, bkgHistJet1, jet1, jet1_2, 0, 30.5)
    getBothDistribution(sigHistJet2, bkgHistJet2, jet2, jet2_2, 0, 30.5)
    getBothDistribution(sigHistJet3, bkgHistJet3, jet3, jet3_2, 0, 30.5)


    fakeHist1 = r.TH1F()
    fakeHist1.SetMarkerStyle(5)
    fakeHist2 = r.TH1F()
    fakeHist2.SetMarkerStyle(2)
    fakeHist2.SetMarkerColor(r.kBlue)
    fakeHist3 = r.TH1F()
    fakeHist3.SetMarkerStyle(25)
    fakeHist3.SetMarkerColor(r.kRed)
    fakeHist4 = r.TH1F()
    fakeHist4.SetMarkerStyle(32)
    fakeHist4.SetMarkerColor(r.kGreen)
    fakeHist5 = r.TH1F()
    fakeHist5.SetMarkerStyle(5)
    fakeHist5.SetMarkerColor(r.kBlue)
    fakeHist6 = r.TH1F()
    fakeHist6.SetMarkerStyle(5)
    fakeHist6.SetMarkerColor(r.kRed)
    fakeHist7 = r.TH1F()
    fakeHist7.SetMarkerStyle(5)
    fakeHist7.SetMarkerColor(r.kGreen)


    psfile = 'test2.pdf'
    c = r.TCanvas("c","Test", 600, 600)
    c.SetGrid()
    c.SetFillStyle(4000)
#     distHist.GetXaxis().SetLimits(0.998,1.00001)
    distHist.GetXaxis().SetLimits(0.999,1.00001)

    distHist.SetMinimum(0.001)
    distHist.SetMaximum(0.8)

    c.SetLogy()
    distHist.GetXaxis().SetNdivisions(210)
    distHist.Draw("AP")

    distHist.SetMarkerStyle(7)
    distHist.GetYaxis().SetTitleOffset(1.4)
    distHist5.SetMarkerStyle(7)
    distHist5_2.SetMarkerColor(r.kBlue)
    distHist5.SetMarkerColor(r.kBlue)
#     distHist5.Draw('PSame')

    distHist2.SetMarkerStyle(7)
    distHist2_2.SetMarkerColor(r.kRed)

    distHist2.SetMarkerColor(r.kRed)
#     distHist2.Draw('PSame')
    distHist4.SetMarkerStyle(7)
    distHist4_2.SetMarkerColor(r.kGreen)
    distHist4.SetMarkerColor(r.kGreen)
#     distHist4.Draw('PSame')

    distHist_2.SetMarkerStyle(5)
    distHist5_2.SetMarkerStyle(2)
    distHist2_2.SetMarkerStyle(25)
    distHist4_2.SetMarkerStyle(32)

#     distHist2_2.Draw('PSame')
#     distHist5_2.Draw('PSame')
    distHist_2.Draw('PSame')
#     distHist4_2.Draw('PSame')

    jet1.SetMarkerStyle(7)
    jet1.SetMarkerColor(r.kBlue)
    jet1_2.SetMarkerStyle(5)
    jet1_2.SetMarkerColor(r.kBlue)
    jet2.SetMarkerStyle(7)
    jet2.SetMarkerColor(r.kRed)
    jet2_2.SetMarkerStyle(5)
    jet2_2.SetMarkerColor(r.kRed)
    jet3.SetMarkerStyle(7)
    jet3.SetMarkerColor(r.kGreen)
    jet3_2.SetMarkerStyle(5)
    jet3_2.SetMarkerColor(r.kGreen)

    jet1.Draw('PSame')

    jet1_2.Draw('PSame')
    jet2.Draw('PSame')
    jet2_2.Draw('PSame')
    jet3.Draw('PSame')
    jet3_2.Draw('PSame')

    l = tool.setMyLegend(lPosition = [0.2, 0.45, 0.5, 0.25], lHistList = [(fakeHist1, 'same pt cut (tau pt 40)'), 
#                                                                         (fakeHist2, 'leading + 5 (35, 40, 45)'),
#                                                                         (fakeHist3, 'leading + 10 (35, 40, 45)'),
#                                                                         (fakeHist4, 'leading + 15 (35, 40, 45)'),
                                                                        (fakeHist5, 'same with jet pt 30 (tau pt 30)'),
                                                                        (fakeHist6, 'same with jet pt 40 (tau pt 30)'),
                                                                        (fakeHist7, 'same with jet pt 50 (tau pt 30)'),
])
    l.Draw('same')
    c.Print('%s(' %psfile)
    c.SetLogy(0)

    c.Clear()
    distHist3.Draw()
    c.Print('%s' %psfile)
    c.Clear()

#     p1 = r.TPad("p1","p1",0.,1,1.,0.0)
#     p1.SetMargin(0.13, 0.13, 0.13, 0.13)
#     p1.SetGrid()
    p2 = r.TPad("p1","p1",0.,1,1.,0.0)
    p2.SetMargin(0.13, 0.13, 0.13, 0.13)
    p2.SetGrid()
# 
# #     p1.Draw()
# #     p1.cd()
# #     distHist2.GetXaxis().SetNdivisions(216)
# #     distHist2.GetYaxis().SetNdivisions(216)
# #     distHist2.GetYaxis().SetTitleOffset(1.2)
# #     distHist2.Draw('COLZ')
# #     c.Print('%s' %psfile) 
# #     c.Clear()
    p2.Draw()
    p2.cd()
    sigHist.Draw('COLZ')
    sigHist.GetYaxis().SetTitleOffset(1.2)
    sigHist.GetXaxis().SetNdivisions(216)
    sigHist.GetYaxis().SetNdivisions(216)
    c.Print('%s' %psfile)
    c.Clear()
    p3 = r.TPad("p1","p1",0.,1,1.,0.0)
    p3.SetMargin(0.13, 0.13, 0.13, 0.13)
    p3.SetGrid()

    p3.Draw()
    p3.cd()
    bkgHist.Draw('COLZ')
    bkgHist.GetYaxis().SetTitleOffset(1.2)
    bkgHist.GetXaxis().SetNdivisions(216)
    bkgHist.GetYaxis().SetNdivisions(216)
    c.Print('%s' %psfile) 
    c.Clear()
    bkgHistJet2.Draw('COLZ')
    bkgHistJet2.GetYaxis().SetTitleOffset(1.2)
    bkgHistJet2.GetXaxis().SetNdivisions(216)
    bkgHistJet2.GetYaxis().SetNdivisions(216)
    c.Print('%s' %psfile) 
    c.Clear()
    sigHistJet2.Draw('COLZ')
    sigHistJet2.GetYaxis().SetTitleOffset(1.2)
    sigHistJet2.GetXaxis().SetNdivisions(216)
    sigHistJet2.GetYaxis().SetNdivisions(216)

    c.Print('%s)' %psfile) 


    c.Close()
コード例 #26
0
def yieldCalculator(dy_mc, tt_full_mc, dy_embed, tt_embed, massWindow, pairOption = 'iso', nBtag = '', doDraw = False):

    yieldForMediumCat = {}
    eventCounterForMediumCat = {}
    yieldForLooseCat = {}
    eventCounterForLooseCat = {}
    inclusiveYields = {}
    eventCounterForInclusive = {}

    bins = [19, 225, 700]
    dy_embed_1M = r.TH1F('dy_embed_1M', '', bins[0], bins[1], bins[2])
    dy_embed_2M = r.TH1F('dy_embed_2M', '', bins[0], bins[1], bins[2])
    tt_embed_1M = r.TH1F('tt_embed_1M', '', bins[0], bins[1], bins[2])
    tt_embed_2M = r.TH1F('tt_embed_2M', '', bins[0], bins[1], bins[2])

    fileList = [('DY_inclusive', dy_mc), ('tt_inclusive', tt_full_mc), ('DY_embed', dy_embed), ('tt_embed', tt_embed)]

    for indexFile in range(len(fileList)):
        name = fileList[indexFile][0]
        iFile =  r.TFile(fileList[indexFile][1])
        iTree = iFile.Get('eventTree')
        yieldForMediumCat[name+'_1M'] = 0.0
        yieldForMediumCat[name+'_2M'] = 0.0
        yieldForLooseCat[name+'_1L'] = 0.0
        yieldForLooseCat[name+'_2L'] = 0.0
        eventCounterForInclusive[name] = 0
        eventCounterForMediumCat[name+'_1M'] = 0
        eventCounterForMediumCat[name+'_2M'] = 0
        eventCounterForLooseCat[name+'_1L'] = 0
        eventCounterForLooseCat[name+'_2L'] = 0
        total = iTree.GetEntries()
        inclusiveYields[name] = 0.0
        counter = 0
        counter_0 = 0
        isEmbed = False
        isData = False
        if 'emb' in name:
            isEmbed = True
        if name == 'DY_embed':
            isData = True

        for i in range(0, total):
            tool.printProcessStatus(iCurrent=i+1, total=total, processName = 'Looping sample [%s]' %name, iPrevious=i)
            #Fill Histograms
            iTree.GetEntry(i)

            #get the right pair of taus based on isoMin or ptMax
            if (iTree.nElectrons > 0 or iTree.nMuons > 0):
                continue

            #get event category
            signSelection, isoSelection, bTagSelection = makeWholeTools2.findCategory(tree = iTree, 
                                                                                      iso = makeWholeSample_cfg.iso, 
                                                                                      option = pairOption,
                                                                                      isData = isData,
                                                                                      relaxedRegionOption = makeWholeSample_cfg.Relax,
                                                                                      isEmbed = isEmbed,
                                                                                      usePassJetTrigger = makeWholeSample_cfg.usePassJetTrigger,
                                                                                      nBtag = nBtag)
            if signSelection == None or isoSelection == None or bTagSelection == None:
                continue
            looseTag, mediumTag = getRightBTagCatName(bTagSelection)

            if iTree.HLT_Any == 0:
                continue
            if iTree.ZTT == 0:
                continue
            if 'tt' not in name:
                tmpEventYield = iTree.triggerEff*iTree.decayModeWeight
            else:
                tmpEventYield = iTree.triggerEff

            if  massWindow and not makeWholeTools2.passCut(iTree, pairOption):
                continue

            #calculate inclusiveYield
            if (signSelection == "OS") and (isoSelection == "Tight"):
                eventCounterForInclusive[name] += 1
                if 'data' in iTree.sampleName:
                    inclusiveYields[name] += tmpEventYield*iTree.embeddedWeight
                elif isEmbed:
                    inclusiveYields[name] += iTree.triggerEff*iTree.xs*0.983*(lumi/tt_semi_InitEvents)*iTree.embeddedWeight*iTree.PUWeight
                else:
                    if not makeWholeTools2.passJetTrigger(iTree):
                        continue
                    inclusiveYields[name] += tmpEventYield*iTree.xs*lumi*iTree.PUWeight/(iTree.initEvents+0.0)
            else:
                continue
                
            fillValue = iTree.fMassKinFit

            #calculate category yield
            if mediumTag != '0M':
                if isEmbed:
                    if 'data' in iTree.sampleName:
                        yieldForMediumCat["%s_%s" %(name, mediumTag)] += tmpEventYield*iTree.embeddedWeight
                        if mediumTag == '1M':
                            dy_embed_1M.Fill(fillValue, tmpEventYield*iTree.embeddedWeight)
                        else:
                            dy_embed_2M.Fill(fillValue, tmpEventYield*iTree.embeddedWeight)
                    else:
                        yieldForMediumCat["%s_%s" %(name, mediumTag)] += tmpEventYield*iTree.xs*0.983*(lumi/tt_semi_InitEvents)*iTree.embeddedWeight*iTree.PUWeight
                        if mediumTag == '1M':
                            tt_embed_1M.Fill(fillValue, tmpEventYield*iTree.xs*0.983*(lumi/tt_semi_InitEvents)*iTree.embeddedWeight*iTree.PUWeight)
                        else:
                            tt_embed_2M.Fill(fillValue, tmpEventYield*iTree.xs*0.983*(lumi/tt_semi_InitEvents)*iTree.embeddedWeight*iTree.PUWeight)

                else:
                    yieldForMediumCat["%s_%s" %(name, mediumTag)] += tmpEventYield*iTree.xs*lumi*iTree.PUWeight/iTree.initEvents
                eventCounterForMediumCat["%s_%s" %(name, mediumTag)] += 1


            #calculate loose cat yield for embed samples
            if isEmbed and (looseTag != '0L'):
                if 'data' in iTree.sampleName:
                    yieldForLooseCat["%s_%s" %(name, looseTag)] += tmpEventYield*iTree.embeddedWeight
                else:
                    yieldForLooseCat["%s_%s" %(name, looseTag)] += tmpEventYield*iTree.embeddedWeight*iTree.xs*0.983*lumi/tt_semi_InitEvents
                eventCounterForLooseCat["%s_%s" %(name, looseTag)] += 1

        print ''

        if isEmbed:
            print name
            print 'inclusive yield for %s: %.2f +/- %.2f' %(name, inclusiveYields[name], calcSysUncSingle(inclusiveYields[name], eventCounterForInclusive[name]))
            print '1-Medium %s yield: %.2f +/- %.2f \t events: %i' %(name, yieldForMediumCat[name+'_1M'], calcSysUncSingle(yieldForMediumCat[name+'_1M'], eventCounterForMediumCat[name+'_1M']), eventCounterForMediumCat[name+'_1M'])
            print '1-Loose %s yield: %.2f  +/- %.2f \t events: %i' %(name, yieldForLooseCat[name+'_1L'], calcSysUncSingle(yieldForLooseCat[name+'_1L'], eventCounterForLooseCat[name+'_1L']), eventCounterForLooseCat[name+'_1L'])
            print '2-Medium %s yield: %.2f +/- %.2f \t events: %i' %(name, yieldForMediumCat[name+'_2M'], calcSysUncSingle(yieldForMediumCat[name+'_2M'], eventCounterForMediumCat[name+'_2M']), eventCounterForMediumCat[name+'_2M'])
            print '2-Loose %s yield: %.2f +/- %.2f \t events: %i' %(name, yieldForLooseCat[name+'_2L'], calcSysUncSingle(yieldForLooseCat[name+'_2L'], eventCounterForLooseCat[name+'_2L']), eventCounterForLooseCat[name+'_2L'])

        else:
            print 'inclusive yield for %s: %.2f' %(name, inclusiveYields[name])

    delta_dy_inclusive = calcSysUncSingle(inclusiveYields['DY_embed'], eventCounterForInclusive['DY_embed'])
    delta_tt_inclusive = calcSysUncSingle(inclusiveYields['tt_embed'], eventCounterForInclusive['tt_embed'])
    delta_dy_1M = calcSysUncSingle(yieldForMediumCat['DY_embed_1M'], eventCounterForMediumCat['DY_embed_1M'])
    delta_tt_1M = calcSysUncSingle(yieldForMediumCat['tt_embed_1M'], eventCounterForMediumCat['tt_embed_1M'])
    delta_dy_2M = calcSysUncSingle(yieldForMediumCat['DY_embed_2M'], eventCounterForMediumCat['DY_embed_2M'])
    delta_tt_2M = calcSysUncSingle(yieldForMediumCat['tt_embed_2M'], eventCounterForMediumCat['tt_embed_2M'])

    sysUnc_1M = calcSysUnc(sf = (yieldForMediumCat['DY_embed_1M']-yieldForMediumCat['tt_embed_1M'])/(inclusiveYields['DY_embed'] - inclusiveYields['tt_embed']), 
                        numA = yieldForMediumCat['DY_embed_1M'], 
                        numB = yieldForMediumCat['tt_embed_1M'],
                        denomA = inclusiveYields['DY_embed'],
                        denomB = inclusiveYields['tt_embed'],
                        delta_numA = delta_dy_1M,
                        delta_numB = delta_tt_1M,
                        delta_denomA = delta_dy_inclusive,
                        delta_denomB = delta_tt_inclusive)

    sysUnc_2M = calcSysUnc(sf = (yieldForMediumCat['DY_embed_2M']-yieldForMediumCat['tt_embed_2M'])/(inclusiveYields['DY_embed'] - inclusiveYields['tt_embed']), 
                        numA = yieldForMediumCat['DY_embed_2M'], 
                        numB = yieldForMediumCat['tt_embed_2M'],
                        denomA = inclusiveYields['DY_embed'],
                        denomB = inclusiveYields['tt_embed'],
                        delta_numA = delta_dy_2M,
                        delta_numB = delta_tt_2M,
                        delta_denomA = delta_dy_inclusive,
                        delta_denomB = delta_tt_inclusive)

    sysUnc_xs_1M = calcSysUnc(sf = (yieldForMediumCat['DY_embed_1M']-yieldForMediumCat['tt_embed_1M'])/(inclusiveYields['DY_embed'] - inclusiveYields['tt_embed']), 
                        numA = yieldForMediumCat['DY_embed_1M'], 
                        numB = yieldForMediumCat['tt_embed_1M'],
                        denomA = inclusiveYields['DY_embed'],
                        denomB = inclusiveYields['tt_embed'],
                        delta_numA = 0,
                        delta_numB = yieldForMediumCat['tt_embed_1M']*0.1,
                        delta_denomA = 0,
                        delta_denomB = inclusiveYields['tt_embed']*0.1)

    sysUnc_xs_2M = calcSysUnc(sf = (yieldForMediumCat['DY_embed_2M']-yieldForMediumCat['tt_embed_2M'])/(inclusiveYields['DY_embed'] - inclusiveYields['tt_embed']), 
                        numA = yieldForMediumCat['DY_embed_2M'], 
                        numB = yieldForMediumCat['tt_embed_2M'],
                        denomA = inclusiveYields['DY_embed'],
                        denomB = inclusiveYields['tt_embed'],
                        delta_numA = 0,
                        delta_numB = yieldForMediumCat['tt_embed_2M']*0.1,
                        delta_denomA = 0,
                        delta_denomB = inclusiveYields['tt_embed']*0.1)

    preScaleFactor = inclusiveYields['DY_inclusive']/(inclusiveYields['DY_embed'] - inclusiveYields['tt_embed'])
    scaleFactor_1M = preScaleFactor*(yieldForMediumCat['DY_embed_1M']-yieldForMediumCat['tt_embed_1M'])
    scaleFactor_2M = preScaleFactor*(yieldForMediumCat['DY_embed_2M']-yieldForMediumCat['tt_embed_2M'])

    preScaleFactor2 = (inclusiveYields['DY_inclusive']+inclusiveYields['tt_inclusive'])/(inclusiveYields['DY_embed'])
    scaleFactor_1M2 = preScaleFactor2*(yieldForMediumCat['DY_embed_1M'])
    scaleFactor_2M2 = preScaleFactor2*(yieldForMediumCat['DY_embed_2M'])

    print ''
    print 'predicted DY in 1M: %.2fx(%.2f +/- %.2f - %.2f +/- %.2f)/(%.2f +/- %.2f - %.2f +/- %.2f) = %.2f +/- %.2f%% (statistical)' %(inclusiveYields['DY_inclusive'],
                                                                         yieldForMediumCat['DY_embed_1M'],
                                                                         calcSysUncSingle(yieldForMediumCat['DY_embed_1M'], eventCounterForMediumCat['DY_embed_1M']),
                                                                         yieldForMediumCat['tt_embed_1M'],
                                                                         calcSysUncSingle(yieldForMediumCat['tt_embed_1M'], eventCounterForMediumCat['tt_embed_1M']),
                                                                         inclusiveYields['DY_embed'],
                                                                         calcSysUncSingle(inclusiveYields['DY_embed'], eventCounterForInclusive['DY_embed']),
                                                                         inclusiveYields['tt_embed'],
                                                                         calcSysUncSingle(inclusiveYields['tt_embed'], eventCounterForInclusive['tt_embed']),
                                                                         scaleFactor_1M,
                                                                         sysUnc_1M*inclusiveYields['DY_inclusive']/scaleFactor_1M*100
                                                                        )
    print 'predicted DY in 2M: %.2fx(%.2f +/- %.2f - %.2f +/- %.2f)/(%.2f +/- %.2f - %.2f +/- %.2f) = %.2f +/- %.2f%% (statistical)' %(inclusiveYields['DY_inclusive'],
                                                                         yieldForMediumCat['DY_embed_2M'],
                                                                         calcSysUncSingle(yieldForMediumCat['DY_embed_2M'], eventCounterForMediumCat['DY_embed_2M']),
                                                                         yieldForMediumCat['tt_embed_2M'],
                                                                         calcSysUncSingle(yieldForMediumCat['tt_embed_2M'], eventCounterForMediumCat['tt_embed_2M']),
                                                                         inclusiveYields['DY_embed'],
                                                                         calcSysUncSingle(inclusiveYields['DY_embed'], eventCounterForInclusive['DY_embed']),
                                                                         inclusiveYields['tt_embed'],
                                                                         calcSysUncSingle(inclusiveYields['tt_embed'], eventCounterForInclusive['tt_embed']),
                                                                         scaleFactor_2M,
                                                                         sysUnc_2M*inclusiveYields['DY_inclusive']/scaleFactor_2M*100
                                                                        )
    print ''
    print 'predicted DY in 1M: %.2fx(%.2f - %.2f +/- %.2f)/(%.2f - %.2f +/- %.2f) = %.2f +/- %.2f%% (tt_xs)' %(inclusiveYields['DY_inclusive'],
                                                                         yieldForMediumCat['DY_embed_1M'],
                                                                         yieldForMediumCat['tt_embed_1M'],
                                                                         yieldForMediumCat['tt_embed_1M']*0.1,
                                                                         inclusiveYields['DY_embed'],
                                                                         inclusiveYields['tt_embed'],
                                                                         inclusiveYields['tt_embed']*0.1,
                                                                         scaleFactor_1M,
                                                                         sysUnc_xs_1M*inclusiveYields['DY_inclusive']/scaleFactor_1M*100
                                                                        )
    print 'predicted DY in 2M: %.2fx(%.2f - %.2f +/- %.2f)/(%.2f - %.2f +/- %.2f) = %.2f +/- %.2f%% (tt_xs)' %(inclusiveYields['DY_inclusive'],
                                                                         yieldForMediumCat['DY_embed_2M'],
                                                                         yieldForMediumCat['tt_embed_2M'],
                                                                         yieldForMediumCat['tt_embed_2M']*0.1,
                                                                         inclusiveYields['DY_embed'],
                                                                         inclusiveYields['tt_embed'],
                                                                         inclusiveYields['tt_embed']*0.1,
                                                                         scaleFactor_2M,
                                                                         sysUnc_xs_2M*inclusiveYields['DY_inclusive']/scaleFactor_2M*100
                                                                        )
    print ''
    print 'DY MC in 1M: %.2f' %yieldForMediumCat['DY_inclusive_1M']
    print 'DY MC in 2M: %.2f' %yieldForMediumCat['DY_inclusive_2M']
#     print 'predicted DY+tt in 1M: %.2f' %scaleFactor_1M2
#     print 'predicted DY+tt in 2M: %.2f' %scaleFactor_2M2


    if doDraw:
        position = (0.6, 0.9 - 0.06*2, 0.87, 0.9)
        l1 = tool.setMyLegend(position, [(dy_embed_1M, 'dy_embed_1M'), (tt_embed_1M, 'tt_embed_1M')])
        l2 = tool.setMyLegend(position, [(dy_embed_2M, 'dy_embed_2M'), (tt_embed_2M, 'tt_embed_2M')])

        psfile = 'DY_embed_tauUp.pdf'
        c = r.TCanvas("c","Test", 800, 600)
        dy_embed_1M.Draw()
        dy_embed_1M.SetTitle(';fMassKinFit;')
        tt_embed_1M.SetLineStyle(2)
        tt_embed_1M.SetLineColor(r.kRed)
        tt_embed_1M.Draw('same')
        l1.Draw('same')

        c.Print('%s(' %psfile)
        dy_embed_2M.Draw()
        dy_embed_2M.SetTitle(';fMassKinFit;')

        tt_embed_2M.SetLineStyle(2)
        tt_embed_2M.SetLineColor(r.kRed)
        tt_embed_2M.Draw('same')
        l2.Draw('same')

        c.Print('%s)' %psfile)


    return scaleFactor_1M, scaleFactor_2M, scaleFactor_1M2, scaleFactor_2M2, preScaleFactor
コード例 #27
0
HistMaxList[0][1].SetTitle("BDT training at %s; BDT; " %(trainMass))

#draw from the highest histogram


c = r.TCanvas("c","Test", 800, 600);
ps = r.TPostScript(psfile,112);
r.gPad.SetTickx()
r.gPad.SetTicky()

ps.NewPage()
HistMaxList[0][1].Draw()
HistMaxList[1][1].Draw("same")
HistMaxList[2][1].Draw("same")
HistMaxList[3][1].Draw("same")
l = tool.setMyLegend(lPosition=legendPosition, lHistList=histList)
l.Draw("same")
c.Update()
ps.NewPage()
c.cd()
r.gPad.SetGrid()
for i in range(49):
    bkgRejection = 1 - BDT_bkg.Integral(98-i*2,99)
    sigEff1 = BDT_1.Integral(98-i*2,99)
    sigEff2 = BDT_2.Integral(98-i*2,99)
    sigEff3 = BDT_3.Integral(98-i*2,99)
    if bkgRejection == 1.0 or sigEff1 >= 1.0 or sigEff2 >= 1.0 or sigEff3 >= 1.0:
        continue
    
    eff_1.Fill(sigEff1, bkgRejection)
    eff_2.Fill(sigEff2, bkgRejection)
コード例 #28
0
def getHistos(varName, signalSelection, logY, sigBoost, nbins, useData, max,
              rangeMin, rangeMax, location, bTag, predict, predictPtBin,
              region, thirdLeptonVeto):
    r.gStyle.SetOptStat(0)
    fileList = draw_cfg.MCFileList
    histList = []
    histList_4QCD = []
    QCDHistList = []
    QCDHistList_4KS = []
    QCDHistList_withScale = []
    varRange = [nbins, rangeMin, rangeMax]
    nBins = 10000
    Lumi = 19.7
    initNEventsList = []
    legendHistos = []
    var_background = []

    scaleMCPt = 1.0

    tmpFile = []
    tmpTree = []
    var_data_4KS = []
    var_data = []
    var_data_4QCD = []
    histList_4KS = []

    for i in range(5):
        var_data.append(
            r.TH1F('data_%i' % (i), "", varRange[0], varRange[1], varRange[2]))
        var_data_4KS.append(
            r.TH1F('data_4KS_%i' % (i), "", nBins, varRange[1], varRange[2]))
        if i < 5:
            var_data_4QCD.append(
                r.TH1F('data_4QCD_%i' % (i), "", varRange[0], varRange[1],
                       varRange[2]))

    dataName = draw_cfg.dataFile
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' % dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag, region, thirdLeptonVeto)
        if (select == 0) or (select == 1) or (select > 6):
            continue
        var_data[select - 2].Fill(varsList.findVar(treeData, varName))
        var_data_4KS[select - 2].Fill(varsList.findVar(treeData, varName))
        if select == 2:
            var_data_4QCD[0].Fill(
                varsList.findVar(treeData, varName),
                findPtScale(treeData.pt1.at(0), treeData.pt2.at(0), 'left',
                            '%s%s' % (region, bTag)))
        elif select == 3:
            var_data_4QCD[1].Fill(
                varsList.findVar(treeData, varName),
                findPtScale(treeData.pt1.at(0), treeData.pt2.at(0), 'up',
                            '%s%s' % (region, bTag)))
        elif select == 4:
            var_data_4QCD[2].Fill(
                varsList.findVar(treeData, varName),
                findPtScale(treeData.pt1.at(0), treeData.pt2.at(0), 'left',
                            '%s%s' % (region, bTag)))
            var_data_4QCD[3].Fill(
                varsList.findVar(treeData, varName),
                findPtScale(treeData.pt1.at(0), treeData.pt2.at(0), 'up',
                            '%s%s' % (region, bTag)))

    legendHistos.append([])
    for j in range(5):
        var_data[j].SetMarkerStyle(8)
        var_data[j].SetMarkerSize(0.9)
        legendHistos.append([])
        legendHistos[j + 1].append(
            (var_data[j], 'observed (%.0f)' % var_data[j].Integral()))

    for i in range(len(fileList)):
        for j in range(6):
            histList_4KS.append(
                r.TH1F('%s_%i_KS' % (fileList[i][0], j), fileList[i][0], nBins,
                       varRange[1], varRange[2]))
            histList.append(
                r.TH1F('%s_%i' % (fileList[i][0], j), fileList[i][0],
                       varRange[0], varRange[1], varRange[2]))
            histList_4QCD.append(
                r.TH1F('%s_%i_2' % (fileList[i][0], j), fileList[i][0],
                       varRange[0], varRange[1], varRange[2]))
        print 'Adding events from: %s ...' % (fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag, region, thirdLeptonVeto)
            if (not select) or (select > 6):
                continue
            histList[6 * i + select - 1].Fill(
                varsList.findVar(tmpTree[i], varName) * scaleMCPt,
                tmpTree[i].triggerEff)
            histList_4KS[6 * i + select - 1].Fill(
                varsList.findVar(tmpTree[i], varName) * scaleMCPt,
                tmpTree[i].triggerEff)
            if select == 2:
                histList_4QCD[6 * i].Fill(
                    varsList.findVar(tmpTree[i], varName) * scaleMCPt,
                    tmpTree[i].triggerEff *
                    findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0),
                                'left', '%s%s' % (region, bTag)))
            elif select == 3:
                histList_4QCD[6 * i + 1].Fill(
                    varsList.findVar(tmpTree[i], varName) * scaleMCPt,
                    tmpTree[i].triggerEff *
                    findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0),
                                'up', '%s%s' % (region, bTag)))
            elif select == 4:
                histList_4QCD[6 * i + 2].Fill(
                    varsList.findVar(tmpTree[i], varName) * scaleMCPt,
                    tmpTree[i].triggerEff *
                    findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0),
                                'left', '%s%s' % (region, bTag)))
                histList_4QCD[6 * i + 3].Fill(
                    varsList.findVar(tmpTree[i], varName) * scaleMCPt,
                    tmpTree[i].triggerEff *
                    findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0),
                                'up', '%s%s' % (region, bTag)))

        initNEventsList.append(tmpFile[i].Get('preselection'))
        for j in range(6):
            var_background.append(r.THStack())
            histList[6 * i + j].SetFillColor(fileList[i][3])
            histList[6 * i + j].Scale(fileList[i][2] * Lumi /
                                      initNEventsList[i].GetBinContent(1))
            histList_4QCD[6 * i + j].Scale(fileList[i][2] * Lumi /
                                           initNEventsList[i].GetBinContent(1))
            histList_4KS[6 * i + j].Scale(fileList[i][2] * Lumi /
                                          initNEventsList[i].GetBinContent(1))

            var_background[j].Add(histList[6 * i + j])
            legendHistos[j].append(
                (histList[6 * i + j], '%s (%.2f)' %
                 (fileList[i][0], histList[6 * i + j].Integral())))

    data_i = []
    MC_i = []
    data_r = []
    MC_r = []
    e = []
    MC_List = []
    for i in range(3):
        QCDHistList.append(
            r.TH1F('QCD_%i' % (i), "", varRange[0], varRange[1], varRange[2]))
        QCDHistList_4KS.append(
            r.TH1F('QCD_%i_KS' % (i), "", nBins, varRange[1], varRange[2]))
        MC_List.append(
            r.TH1F('MC_total_%i' % (i), "", varRange[0], varRange[1],
                   varRange[2]))

        for j in range(varRange[0]):
            dataValue = var_data[i].GetBinContent(j + 1)
            dataError = var_data[i].GetBinError(j + 1)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue += histList[6 * k + 1 + i].GetBinContent(j + 1)
            if i == 0:
                data_i.append(dataValue)
                e.append(dataError)
                MC_i.append(MCValue)
            if i == 2:
                data_r.append(dataValue)
                MC_r.append(MCValue)
            MC_List[i].SetBinContent(j + 1, MCValue)
            if dataValue - MCValue > 0:
                QCDHistList[i].SetBinContent(j + 1, dataValue - MCValue)
                QCDHistList[i].SetBinError(j + 1, dataError)
        MC_List[i].Sumw2()
        for j in range(nBins):
            dataValue4KS = var_data_4KS[i].GetBinContent(j + 1)
            MCValue4KS = 0
            for k in range(len(fileList)):
                MCValue4KS += histList_4KS[6 * k + 1 + i].GetBinContent(j + 1)
            if dataValue4KS - MCValue4KS > 0:
                QCDHistList_4KS[i].SetBinContent(j + 1,
                                                 dataValue4KS - MCValue4KS)
    ss_t = QCDHistList[0].Integral()
    ss_l = QCDHistList[2].Integral()

    os_l = QCDHistList[1].Integral()
    os_l_data = var_data[1].Integral()
    print "QCD in SS_T: %.4f" % ss_t
    print "QCD in SS_L: %.4f" % ss_l

    print "QCD in OS_L: %.4f" % os_l
    print "Data in OS_L:%.4f" % os_l_data

    print "SF: %.4f" % (ss_t / ss_l)
    print "SF qcd/data: %.4f" % (os_l / os_l_data)

    for i in range(4):
        QCDHistList_withScale.append(
            r.TH1F('QCD_withScale_%i' % (i), "", varRange[0], varRange[1],
                   varRange[2]))
        for j in range(varRange[0]):
            dataValue = var_data_4QCD[i].GetBinContent(j + 1)
            dataError = var_data_4QCD[i].GetBinError(j + 1)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue += histList_4QCD[6 * k + i].GetBinContent(j + 1)
            if dataValue - MCValue > 0:
                QCDHistList_withScale[i].SetBinContent(j + 1,
                                                       dataValue - MCValue)

    QCDDiff = r.TH1F('QCD_diff', "", varRange[0], varRange[1], varRange[2])
    QCDDiff2 = r.TH1F('QCD_diff2', "", varRange[0], varRange[1], varRange[2])
    QCDDiff_R2T = r.TH1F('QCDDiff_R2T', "", varRange[0], varRange[1],
                         varRange[2])

    #     QCDDiff2.Sumw2()

    fit1 = r.TF1("fit1", "[0]", varRange[1], varRange[2])
    fit1.SetParName(0, 'scale')
    fit1.FixParameter(0, 1.0)

    QCDDiff.Fit('fit1', '0EM')
    fit1.SetLineStyle(2)
    fit1.SetLineColor(r.kRed)
    fit2 = r.TF1("fit2", "[0]", varRange[1], varRange[2])
    fit2.SetParName(0, 'scale')
    fit2.FixParameter(0, 1.0)
    QCDDiff2.Fit('fit2', '0EM')
    fit2.SetLineStyle(2)
    fit2.SetLineColor(r.kRed)

    DrawSignal = False
    if signalSelection != '':
        var_signal = []
        var_signal_4KS = []
        for i in range(6):
            var_signal.append(
                r.TH1F('%s_%i' % (signalSelection, i), "", varRange[0],
                       varRange[1], varRange[2]))
            var_signal_4KS.append(
                r.TH1F('%s_%i_4KS' % (signalSelection, i), "", nBins,
                       varRange[1], varRange[2]))
        signalDict = draw_cfg.signalDict
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection][0])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' % (
                signalDict[signalSelection][0])
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag, region, thirdLeptonVeto)
                if (not select) or (select > 6):
                    continue
                var_signal[select - 1].Fill(
                    varsList.findVar(treeSignal, varName),
                    treeSignal.triggerEff)
                var_signal_4KS[select - 1].Fill(
                    varsList.findVar(treeSignal, varName),
                    treeSignal.triggerEff)
            initNEventsSignal = fSignal.Get('preselection')
            for i in range(6):
                var_signal[i].SetLineStyle(7)
                var_signal[i].SetLineWidth(4)
                var_signal[i].Scale(signalDict[signalSelection][1] * sigBoost *
                                    Lumi / initNEventsSignal.GetBinContent(1))
                if sigBoost != 1:
                    sum = var_signal[i].Integral(0,
                                                 var_signal[i].GetNbinsX() + 1)
                    legendHistos[i].append((
                        var_signal[i], '%sx%0.f (%.2f)' %
                        (signalSelection, sigBoost, var_signal[i].Integral())))
                else:
                    legendHistos[i].append(
                        (var_signal[i], '%s (%.2f)' %
                         (signalSelection, var_signal[i].Integral())))
            DrawSignal = True
        else:
            print '%s not supported, please use H260, H300 or H350' % signalSelection

    if predict == 'True':

        scale_SS2OS = fit1.GetParameter(0)
        scale_er_SS2OS = fit1.GetParError(0)
        scale_relaxed2Tight = fit2.GetParameter(0)
        scale_er_relaxed2Tight = fit2.GetParError(0)

        QCDHistList_withScale[0].Scale(scale_SS2OS)
        QCDHistList_withScale[1].Scale(scale_relaxed2Tight)
        QCDHistList_withScale[2].Scale(scale_SS2OS)
        QCDHistList_withScale[3].Scale(scale_relaxed2Tight)

        QCDHistList_withScale[3].SetFillColor(r.kSpring + 1)
        QCDHistList_withScale[2].SetFillColor(r.kOrange - 4)
        QCDHistList_withScale[0].SetLineColor(r.kSpring + 1)
        QCDHistList_withScale[0].SetLineWidth(2)
        QCDHistList_withScale[1].SetLineStyle(2)
        QCDHistList_withScale[1].SetLineColor(r.kOrange - 4)
        QCDHistList_withScale[1].SetLineWidth(2)

        legendHistos[0].append(
            (QCDHistList_withScale[0],
             'From SS/Tight (%.0f)' % QCDHistList_withScale[0].Integral()))
        legendHistos[0].append(
            (QCDHistList_withScale[1],
             'From OS/Relax (%.0f)' % QCDHistList_withScale[1].Integral()))

        var_background[1].Add(QCDHistList_withScale[3])
        var_background[2].Add(QCDHistList_withScale[2])
        legendHistos[1].append(
            (QCDHistList_withScale[3],
             'From SS/Relax (%.0f)' % QCDHistList_withScale[3].Integral()))
        legendHistos[2].append(
            (QCDHistList_withScale[2],
             'From SS/Relax (%.0f)' % QCDHistList_withScale[2].Integral()))
        QCDHistList_withScale[1] = tool.addFakeTHStack(
            QCDHistList_withScale[1], var_background[0])
        QCDHistList_withScale[0] = tool.addFakeTHStack(
            QCDHistList_withScale[0], var_background[0])


#     var_data[1].Sumw2()
#     MC_List[1].Sumw2()
    for i in range(varRange[0]):
        oldValue = var_data[1].GetBinContent(i + 1)
        mcValue = MC_List[1].GetBinContent(i + 1)
        if oldValue - mcValue > 0:
            QCDDiff2.SetBinContent(i + 1, (oldValue - mcValue) / oldValue)
            QCDDiff2.SetBinError(i + 1,
                                 MC_List[1].GetBinError(i + 1) / oldValue)
    print QCDDiff2.Integral()

    QCDDiff = var_data[1].Clone()
    QCDDiff_sub = QCDHistList_withScale[2].Clone() + MC_List[1].Clone()
    QCDDiff.Divide(QCDDiff_sub)

    QCDDiff_R2T = var_data[0].Clone()
    QCDDiff_R2T_sub = QCDHistList_withScale[3].Clone() + MC_List[0].Clone()
    QCDDiff_R2T.Divide(QCDDiff_R2T_sub)

    legendPosition = (0.6, 0.7, 0.90, 0.88)
    l = []
    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == '2M':
        titleName = '2 Medium b-tags'
        fileName = '2MbTag'
    elif bTag == '1M':
        titleName = '1 Medium b-tag'
        fileName = '1MbTag'

    KS1 = QCDHistList_4KS[0].KolmogorovTest(QCDHistList_4KS[2])
    KS2 = QCDHistList_4KS[1].KolmogorovTest(QCDHistList_4KS[2])

    ks_values = []
    tmpHists = []
    ks_values2 = []
    tmpHists2 = []
    nTimes = 10000
    #     for i in range(nTimes):
    #         tool.printProcessStatus(i, nTimes, processName = 'Making Sample Histograms')
    #         tmpHists.append(r.TH1F('tmpHist_%i' %(i),"", nBins, varRange[1], varRange[2]))
    #         tmpHists[i].FillRandom(QCDHistList_4KS[2], 100)
    #         ks_values.append(QCDHistList_4KS[0].KolmogorovTest(tmpHists[i]))
    #         tmpHists2.append(r.TH1F('tmpHist2_%i' %(i),"", nBins, varRange[1], varRange[2]))
    #         tmpHists2[i].FillRandom(QCDHistList_4KS[2], 100)
    #         ks_values2.append(QCDHistList_4KS[2].KolmogorovTest(tmpHists[i]))
    print ''
    print 'KS Test 1: %.3f' % KS1
    print 'KS Test 2: %.3f' % KS2

    psfile = '%s_%s_%s.pdf' % (varName, fileName, signalSelection)
    c = r.TCanvas("c", "Test", 800, 900)
    #ps = r.TPDF(psfile,112)
    c.Divide(2, 3)
    drawOpt = ''
    QCDDiff.SetTitle(
        'Data/Background OS Relaxed Events %s (%.1f fb^{-1}); %s; Data/Background'
        % (titleName, Lumi, varName))
    QCDDiff.SetMarkerStyle(8)
    QCDDiff.SetMarkerSize(0.9)
    QCDDiff.SetMaximum(4)
    QCDDiff.SetMinimum(0)
    QCDDiff_R2T.SetTitle(
        'Data/Background OS Relaxed Events %s (%.1f fb^{-1}); %s; Data/Background'
        % (titleName, Lumi, varName))
    QCDDiff_R2T.SetMarkerStyle(8)
    QCDDiff_R2T.SetMarkerSize(0.9)
    QCDDiff_R2T.SetMaximum(4)
    QCDDiff_R2T.SetMinimum(0)

    for k in range(6):
        c.cd(k + 1)
        r.gPad.SetTicky()
        if k > 1 and logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k + 1)
        var_background[k].SetTitle(
            '%s %s Events %s (%.1f fb^{-1}); %s; events / bin' %
            (signSelection, iso, titleName, Lumi, varName))
        if k < 2:
            var_background[k].SetMaximum(250)
        else:
            var_background[k].SetMaximum(max)
        var_background[k].SetMinimum(0.01)
        var_background[k].Draw()
        if predict == 'True' and k == 0:
            QCDHistList_withScale[0].Draw('same')
            QCDHistList_withScale[1].Draw('same')
        if k != 0 and useData == 'True':
            var_data[k - 1].Draw('PE same')
        legendPosition = (0.63, 0.93 - 0.03 * len(legendHistos[k]), 0.93, 0.9)
        l.append(
            tool.setMyLegend(lPosition=legendPosition,
                             lHistList=legendHistos[k]))
        if k == 1:
            ksLegend1 = tool.setMyLegend(
                (0.3, 0.8, 0.6, 0.9),
                [(QCDHistList_withScale[3], 'KS Test: %.3f' % KS1)])
            ksLegend1.Draw('same')
        if k == 2:
            ksLegend2 = tool.setMyLegend(
                (0.3, 0.8, 0.6, 0.9),
                [(QCDHistList_withScale[2], 'KS Test: %.3f' % KS2)])
            ksLegend2.Draw('same')
        l[k].Draw('same')
        var_signal[k].Draw('same')

    c.Update()
    c.cd(5)
    r.gPad.SetLogy(0)
    QCDDiff.Draw('PE')
    fit1.Draw('same')
    c.cd(6)
    r.gPad.SetLogy(0)
    QCDDiff_R2T.Draw('PE')
    fit2.Draw('same')
    c.Update()
    c.Print('%s(' % psfile)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff.Draw('PE')

    fit1.Draw('same')
    lFit1 = tool.setMyLegend(
        (0.15, 0.7, 0.9, 0.85),
        [(fit1, 'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %
          (fit1.GetParameter(0), fit1.GetParError(0)))])
    lFit1.Draw('same')
    for k in range(3):
        c.cd(k + 2)
        if logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k + 2)
        QCDHistList_withScale[k + 1].SetTitle(
            '%s %s Data - MC Events %s (%.1f fb^{-1}); %s; events / bin' %
            (signSelection, iso, titleName, Lumi, varName))
        QCDHistList_withScale[k + 1].SetMarkerStyle(8)
        QCDHistList_withScale[k + 1].SetMarkerSize(0.9)
        QCDHistList_withScale[k + 1].SetMaximum(max)
        QCDHistList_withScale[k + 1].SetMinimum(1)
        QCDHistList_withScale[k + 1].Draw('PE')
    c.Update()
    c.Print('%s' % psfile)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff2.SetTitle(
        'QCD/Data OS Relaxed Events %s (%.1f fb^{-1}); %s; QCD/Data' %
        (titleName, Lumi, varName))
    QCDDiff2.SetMarkerStyle(8)
    QCDDiff2.SetMarkerSize(0.9)
    QCDDiff2.SetMinimum(0.0)
    QCDDiff2.SetMaximum(1.0)
    QCDDiff2.Draw('PE')
    fit2.Draw('same')
    lFit2 = tool.setMyLegend(
        (0.15, 0.7, 0.9, 0.85),
        [(fit2, 'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %
          (fit2.GetParameter(0), fit2.GetParError(0)))])
    lFit2.Draw('same')
    c.Update()
    c.Print('%s' % psfile)
    #     c.Clear()
    #     c.Divide(1,2)
    #     c.cd(1)
    #     graph = r.TH1F('graph', '', 20, 0, 1.0)
    #     graph2 = r.TH1F('graph2', '', 20, 0, 1.0)

    #     for i in range(nTimes):
    #         tool.printProcessStatus(i, nTimes, processName = 'Plotting Sample Histograms')
    #         graph.Fill(ks_values[i])
    #         graph2.Fill(ks_values2[i])
    #     print ''
    #     graph.SetTitle('KS Tests Between SS Tight and Relaxed; KS; ')
    #     graph.SetMarkerStyle(8)
    #     graph.Draw('PE')
    #     c.cd(2)
    #     graph2.SetTitle('KS Self-test in SS Relaxed; KS; ')
    #     graph2.SetMarkerStyle(8)
    #     graph2.Draw('PE')
    #     c.Update()
    #     c.Print('%s' %psfile)
    #     c.Clear()
    #
    #     a1 = getAccuDist(QCDHistList_4KS[0], varRange[1], varRange[2], 'SS Tight')
    #     a2 = getAccuDist(QCDHistList_4KS[2], varRange[1], varRange[2], 'SS Relax')
    #     a1.SetLineColor(r.kRed)
    #     l3 = tool.setMyLegend((0.15, 0.75, 0.3, 0.85),[(a1,'SS Tight'),
    #                                                   (a2,'SS Relax')])
    #
    #     a1.SetTitle('Cumulative Distribution; %s;' %varName)
    #     a1.Draw()
    #     a2.Draw('same')
    #     l3.Draw('same')
    c.Print('%s)' % psfile)
    #ps.Close()
    print "Plot saved at %s" % (psfile)
    c.Close()
コード例 #29
0
def KSTest(ifile, ofile, name):

    f = r.TFile(ifile)
    testTree = f.Get("TestTree")
    trainTree = f.Get("TrainTree")

    nBins = 20
    nBins2 = 100000
    xMin = -1.0
    xMax = 1.0

    BDT_Sig_Train = r.TH1F('BDT_Sig_Train', 'BDT_Sig_Train', nBins, xMin, xMax)
    BDT_Sig_Test = r.TH1F('BDT_Sig_Test',
                          'Overtraining Check (%s)' % name[:name.find('_')],
                          nBins, xMin, xMax)
    BDT_Bkg_Train = r.TH1F('BDT_Bkg_Train', 'BDT_Bkg_Train', nBins, xMin, xMax)
    BDT_Bkg_Test = r.TH1F('BDT_Bkg_Test', 'BDT_Bkg_Test', nBins, xMin, xMax)

    BDT_Sig_Train_4KS = r.TH1F('BDT_Sig_Train_4KS', 'BDT_Sig_Train_4KS',
                               nBins2, xMin, xMax)
    BDT_Sig_Test_4KS = r.TH1F('BDT_Sig_Test_4KS', 'BDT_Sig_Test_4KS', nBins2,
                              xMin, xMax)
    BDT_Bkg_Train_4KS = r.TH1F('BDT_Bkg_Train_4KS', 'BDT_Bkg_Train_4KS',
                               nBins2, xMin, xMax)
    BDT_Bkg_Test_4KS = r.TH1F('BDT_Bkg_Test_4KS', 'BDT_Bkg_Test_4KS', nBins2,
                              xMin, xMax)

    totalTest = testTree.GetEntries()
    for i in range(totalTest):
        testTree.GetEntry(i)
        if testTree.className == "Signal":
            BDT_Sig_Test.Fill(testTree.BDT, testTree.weight)
            BDT_Sig_Test_4KS.Fill(testTree.BDT, testTree.weight)
        else:
            BDT_Bkg_Test.Fill(testTree.BDT, testTree.weight)
            BDT_Bkg_Test_4KS.Fill(testTree.BDT, testTree.weight)

    totalTrain = trainTree.GetEntries()
    for i in range(totalTrain):
        trainTree.GetEntry(i)
        if trainTree.className == "Signal":
            BDT_Sig_Train.Fill(trainTree.BDT, trainTree.weight)
            BDT_Sig_Train_4KS.Fill(trainTree.BDT, trainTree.weight)
        else:
            BDT_Bkg_Train.Fill(trainTree.BDT, trainTree.weight)
            BDT_Bkg_Train_4KS.Fill(trainTree.BDT, trainTree.weight)

    BDT_Bkg_Train.Sumw2()
    BDT_Sig_Train.Sumw2()
    sigKS = BDT_Sig_Test_4KS.KolmogorovTest(BDT_Sig_Train_4KS)
    bkgKS = BDT_Bkg_Test_4KS.KolmogorovTest(BDT_Bkg_Train_4KS)
    print 'signal: %.4f' % sigKS
    print 'background: %.4f' % bkgKS

    BDT_Bkg_Train.Scale(1 / BDT_Bkg_Train.Integral())
    BDT_Bkg_Train.SetMarkerColor(r.kRed)
    BDT_Bkg_Train.SetMarkerStyle(21)

    BDT_Bkg_Test.SetLineColor(r.kRed)
    BDT_Bkg_Test.SetFillColor(r.kRed)
    BDT_Bkg_Test.SetFillStyle(3354)
    BDT_Bkg_Test.Scale(1 / BDT_Bkg_Test.Integral())

    BDT_Sig_Train.Scale(1 / BDT_Sig_Train.Integral())
    BDT_Sig_Train.SetMarkerColor(r.kBlue)
    BDT_Sig_Train.SetMarkerStyle(21)

    BDT_Sig_Test.SetLineColor(r.kBlue)
    BDT_Sig_Test.SetFillColor(r.kBlue)
    BDT_Sig_Test.SetFillStyle(3001)
    BDT_Sig_Test.Scale(1 / BDT_Sig_Test.Integral())

    legendHistos1 = []
    legendHistos1.append((BDT_Bkg_Test, 'bkg test'))
    legendHistos1.append((BDT_Bkg_Train, 'bkg train'))
    #     legendHistos1.append((BDT_Bkg_Train, 'KS: %0.3f' %bkgKS))

    legendHistos2 = []
    legendHistos2.append((BDT_Sig_Test, 'sig test'))
    legendHistos2.append((BDT_Sig_Train, 'sig train'))
    #     legendHistos2.append((BDT_Sig_Train, 'KS: %0.3f' %sigKS))

    l1 = tool.setMyLegend(lPosition=(0.2, 0.67, 0.5, 0.82),
                          lHistList=legendHistos1)
    l2 = tool.setMyLegend(lPosition=(0.6, 0.67, 0.9, 0.82),
                          lHistList=legendHistos2)

    r.gStyle.SetOptStat(0)
    c = r.TCanvas("c", "Test", 800, 600)
    BDT_Sig_Test.Draw()
    BDT_Sig_Test.GetXaxis().SetTitle("BDT")

    BDT_Sig_Test.SetMaximum(0.5)
    BDT_Sig_Train.Draw('sameE1P')
    BDT_Bkg_Test.Draw('same')
    BDT_Bkg_Train.Draw('sameE1P')
    l1.Draw('same')
    l2.Draw('same')

    c.Print('%s.pdf' % ofile)
コード例 #30
0
ファイル: drawSign.py プロジェクト: zaixingmao/H2hh2bbTauTau
# 
# for i in range(1,histRange2[0]+1):

#     tmpHist5_eta.SetBinContent(i, frac1)
#     tmpHist6_eta.SetBinContent(i, frac2)

c = r.TCanvas("c","Test", 800, 600)
ps = r.TPDF('%sPt_%s.pdf' %(psfile, title),112)
c.Divide(2,2)
c.cd(1)
r.gPad.SetLogy()
tmpHist3.SetTitle('%s tau1 pt; pt1; events' %(title))
tmpHist3.Draw()
tmpHist1.SetLineColor(r.kRed)
tmpHist1.Draw("same")
l1 = tool.setMyLegend(lPosition=legendPosition, lHistList=histList1)
l1.Draw("same")
c.Update()
c.cd(2)
r.gPad.SetLogy()
tmpHist4.SetTitle('%s tau2 pt; pt2; events' %(title))
tmpHist4.Draw("")
tmpHist2.SetLineColor(r.kRed)
tmpHist2.Draw("same")
l2 = tool.setMyLegend(lPosition=legendPosition, lHistList=histList2)
l2.Draw("same")
c.Update()
c.cd(3)
tmpHist5.SetTitle('tau1 same charge rate; pt1; SS/(SS+OS)')
tmpHist5.SetMaximum(1.0)
tmpHist5.SetMinimum(0.0)
コード例 #31
0
def run(varName,
        bins,
        unit,
        cat='em',
        eID='MVANonTrig80_2',
        fit=False,
        region='barrel',
        triggerLeg='e'):

    dir = '2016_trigStudy'

    dataFunc = setFunc('dataFunc')

    append_name = ''
    files_mc = [  # ("SUSY", '/nfs_scratch/zmao/13TeV_samples_25ns_newSplitting_noChargeMatch/SYNC_SUSY_HToTauTau_M-160_%s_%s.root' %(cat, append_name), r.kRed)
    ]

    hist_mc_all = {}
    hist_mc_pass = {}
    file_data = '/user_data/zmao/%s/%s/data_Electron_all_SYNC_em_noIso.root' % (
        dir, eID
    )  #'/nfs_scratch/zmao/supy-output//slice/ee//data_Electron_events.root'# %(cat, append_name)

    hist_data_all = r.TH1F('hist_data_all', '', len(bins) - 1, bins)
    hist_data_pass = r.TH1F('hist_data_pass', '', len(bins) - 1, bins)

    for iName, iSample, iColor in files_mc:
        if iName not in hist_mc_all.keys():
            hist_mc_all[iName] = r.TH1F("hist_%s_all" % iName, "",
                                        len(bins) - 1, bins)
            hist_mc_pass[iName] = r.TH1F("hist_%s_pass" % iName, "",
                                         len(bins) - 1, bins)
        loop_one_sample(iSample, varName, hist_mc_all[iName],
                        hist_mc_pass[iName], cat, False, region, triggerLeg)

    if file_data != '':
        loop_one_sample(file_data, varName, hist_data_all, hist_data_pass, cat,
                        True, region, triggerLeg)

    g_mc = []
    histList = []
    funcs = []
    i = 0
    for iKey in hist_mc_all.keys():
        g_mc.append(r.TGraphAsymmErrors())
        g_mc[i].BayesDivide(hist_mc_pass[iKey], hist_mc_all[iKey])
        g_mc[i].SetMarkerStyle(8)
        g_mc[i].SetMarkerSize(0.9)
        color = getColor(iKey)
        g_mc[i].SetMarkerColor(color)
        g_mc[i].SetLineColor(color)
        if iKey == 'ttbar' and fit:
            funcs.append(setFunc('%sFunc' % iKey))
            funcs[i].SetLineColor(color)
            funcs[i].SetLineStyle(2)
            g_mc[i].Fit('%sFunc' % iKey, "R")
            histList.append(
                (g_mc[i], "%s, plateau: %.3f +- %.3f" %
                 (iKey, funcs[i].GetParameter(0), funcs[i].GetParError(0)),
                 'ep'))
        else:
            funcs.append(None)
            if len(bins) == 3:
                x = r.Double(0.0)
                y1 = r.Double(0.0)
                y2 = r.Double(0.0)
                g_mc[i].GetPoint(0, x, y1)
                g_mc[i].GetPoint(1, x, y2)
                histList.append((
                    g_mc[i], "%s (%.3f +/- %.3f, %.3f +/- %.3f)" %
                    (iKey, y1, g_mc[i].GetErrorY(0), y2, g_mc[i].GetErrorY(1)),
                    'ep'))
            else:
                histList.append((g_mc[i], iKey, 'ep'))

        i += 1

    g_data = r.TGraphAsymmErrors()
    g_data.BayesDivide(hist_data_pass, hist_data_all)
    dataFunc.SetLineColor(r.kBlack)
    dataFunc.SetLineStyle(2)
    fakeHist = r.TH1F("fakeHist", "", 1, 0, 1)
    fakeHist.SetLineColor(r.kWhite)
    if fit:
        g_data.Fit("dataFunc", "R")
        histList.append(
            (g_data, 'Observed, plateau: %.3f +/- %.3f' %
             (dataFunc.GetParameter(0), dataFunc.GetParError(0)), "ep"))
        histList.append(
            (fakeHist, '          halfpoint: %.1f +/- %.1f' %
             (dataFunc.GetParameter(1), dataFunc.GetParError(1)), "l"))
        histList.append(
            (fakeHist, '          slope: %.3f +/- %.3f' %
             (dataFunc.GetParameter(2), dataFunc.GetParError(2)), "l"))
    else:
        if len(bins) == 3:
            x = r.Double(0.0)
            data_y1 = r.Double(0.0)
            data_y2 = r.Double(0.0)
            g_data.GetPoint(0, x, data_y1)
            g_data.GetPoint(1, x, data_y2)
            histList.append(
                (g_data, "Observed (%.3f +/- %.3f, %.3f +/- %.3f)" %
                 (data_y1, g_data.GetErrorY(0), data_y2, g_data.GetErrorY(1)),
                 'ep'))
        else:
            histList.append((g_data, 'Observed', 'ep'))

    fakeHist = r.TH1D("fakeHist", "", 1, 0, 1)
    fakeHist.SetLineColor(r.kWhite)

    g_data.SetMarkerStyle(8)
    g_data.SetMarkerSize(0.9)
    g_data.SetMarkerColor(r.kBlack)

    length = 800
    #     length = 1800

    c = r.TCanvas("c", "Test", length, 800)

    null = r.TH2F("null", "", len(bins) - 1, bins, 1, 0, 1.1)
    null.SetMaximum(1.2)
    if triggerLeg == 'e':
        psfile = 'eleTrigTurnOnCurve_%s_%s_%s_%s.pdf' % (varName, cat, eID,
                                                         region)
        null.SetTitle("electron trigger turn-on curve; %s; Effeciency" % unit)
    else:
        psfile = 'muonTrigTurnOnCurve_%s_%s_%s_%s.pdf' % (varName, cat, eID,
                                                          region)
        null.SetTitle("muon trigger turn-on curve; %s; Effeciency" % unit)
    null.SetStats(False)

    if len(bins) == 3:
        leg = tool.setMyLegend((0.1, 0.4 - 0.06 * 4, 0.95, 0.4), histList)
    else:
        leg = tool.setMyLegend((0.45, 0.4 - 0.06 * 4, 0.9, 0.4), histList)

    r.gPad.SetTicky()
    r.gPad.SetTickx()
    r.gPad.SetTicky()
    null.Draw()
    for i in range(len(hist_mc_all.keys())):
        g_mc[i].Draw('same PE')
    g_data.Draw('same PE')
    leg.Draw('same')

    c.Print('%s' % psfile)
    c.Close()
コード例 #32
0
ファイル: compare.py プロジェクト: zaixingmao/samples-plots
def main():
    file_13TeV = '/nfs_scratch/zmao/test/DYJetsToLL_all.root'#'/nfs_scratch/zmao/test/TTJets_all.root'#
    file_8TeV = '/nfs_scratch/zmao/samples_Iso/tauESOn/normal/dy.root'#'/nfs_scratch/zmao/samples_Iso/tauESOff/normal/TT.root'#

    vars2compare = [("tau1Pt", [50, 30, 230]),
#                     ("tau2Pt", [50, 30, 230]),
#                     ("tau1Eta", [25, -2.5, 2.5]),
#                     ("tau2Eta", [25, -2.5, 2.5]),
#                     ("tau1Iso", [40, 0, 2.]),
#                     ("tau2Iso", [40, 0, 2.]),
#                     ("J1Pt", [50, 30, 230]),
#                     ("J2Pt", [50, 30, 230]),
#                     ("J1Eta", [40, -4, 4]),
#                     ("J2Eta", [40, -4, 4]),
#                     ("J1CSVbTag", [50, 0, 1]),
#                     ("J2CSVbTag", [50, 0, 1]),
# 
#                     ("CSVJ1Pt", [50, 30, 230]),
#                     ("CSVJ2Pt", [50, 30, 230]),
#                     ("CSVJ1Eta", [40, -4, 4]),
#                     ("CSVJ2Eta", [40, -4, 4]),
#                     ("CSVJ1", [50, 0, 1]),
#                     ("CSVJ2", [50, 0, 1]),
# 
#                     ("svMass", [35, 0, 350]),
#                     ("met", [25, 0, 200]),
#                     ("mJJ", [50, 0, 500])

]

    histDicts = buildHistDict(vars2compare)


    psfile = 'out.pdf'
    c = r.TCanvas("c","Test", 800, 600)

    counter = 0
    for iVar, Range in vars2compare:
        unc13TeV = readFile(file = file_13TeV, hist = histDicts[iVar]['13TeV'], varName = iVar, which = '13TeV')
        unc8TeV = readFile(file = file_8TeV, hist = histDicts[iVar]['8TeV'], varName = iVar, which = '8TeV')

        #normalization
#         histDicts[iVar]['13TeV'].Scale(1.0/histDicts[iVar]['13TeV'].Integral(0, histDicts[iVar]['13TeV'].GetNbinsX()+1))
#         histDicts[iVar]['8TeV'].Scale(1.0/histDicts[iVar]['8TeV'].Integral(0, histDicts[iVar]['8TeV'].GetNbinsX()+1))

        counter += 1
        c.Clear()
        histDicts[iVar]['13TeV'].SetTitle("13 TeV vs 8 TeV; %s; a.u" %iVar)
        histDicts[iVar]['8TeV'].SetTitle("13 TeV vs 8 TeV; %s; a.u" %iVar)
        histDicts[iVar]['8TeV'].SetLineColor(r.kRed)

        if histDicts[iVar]['13TeV'].GetMaximum() >= histDicts[iVar]['8TeV'].GetMaximum():
            histDicts[iVar]['13TeV'].Draw()
            histDicts[iVar]['8TeV'].Draw('same')
        else:
            histDicts[iVar]['8TeV'].Draw()
            histDicts[iVar]['13TeV'].Draw('same')
        if counter == 1:
            l = tool.setMyLegend(lPosition = [0.7, 0.85, 0.9, 0.7], lHistList = [(histDicts[iVar]['13TeV'], '13TeV'), (histDicts[iVar]['8TeV'], '8TeV')])
            l.Draw('same')
            c.Print('%s(' %psfile)
        if counter == len(vars2compare):
            l.Draw('same')
            c.Print('%s)' %psfile)
        else:
            l.Draw('same')
            c.Print('%s' %psfile)

        print "13TeV Integral: %.2f +- %.2f (fb)" %(histDicts[iVar]['13TeV'].Integral(0, histDicts[iVar]['13TeV'].GetNbinsX()+1), unc13TeV) 
        print "8TeV Integral : %.2f +- %.2f (fb)" %(histDicts[iVar]['8TeV'].Integral(0, histDicts[iVar]['8TeV'].GetNbinsX()+1), unc8TeV) 

    c.Close()
コード例 #33
0
def loop_one_sample(iSample, iLocation, iFS):
    print 'combining sample [%s] for LUT' % (iSample)
    if 'data' in iSample:
        return 0
    if ('H2hh' in iSample) or ('ggH' in iSample) or ('Zprime' in iSample):
        return 0

    #pdfWeights
    pdfHists = []
    nWeights = 101
    initSumPDF = []
    for i in range(nWeights):
        pdfHists.append(r.TH1F("pdf_%i" % i, "", len(bins) - 1, bins))
        pdfHists[i].Sumw2()
    iFile = r.TFile(iLocation)
    iTree = iFile.Get("Ntuple")
    nEntries = iTree.GetEntries()
    iTree.SetBranchStatus("*", 1)
    iTree.SetBranchStatus("sampleName", 0)

    eventCount = iFile.Get('eventCount')
    eventCountWeighted = iFile.Get('eventCountWeighted')

    if options.signal:
        for i in range(100):
            initSumPDF.append(
                int((iFile.Get('eventCountWeightedPDF_%i' %
                               i)).GetBinContent(1)))
    hist_highPUWeight = r.TH1F("hist_highPUWeight", "", 50, 0.5, 1.5)
    hist_lowPUWeight = r.TH1F("hist_lowPUWeight", "", 50, 0.5, 1.5)

    yieldEstimator_OS = 0.0
    yieldEstimator_SS = 0.0
    fillcounter = 0
    met = lvClass()
    nBins = len(plots_cfg.list)
    #    nEntries = int(nEntries/3.)
    for iEntry in range(nEntries):
        iTree.GetEntry(iEntry)
        tool.printProcessStatus(iEntry, nEntries,
                                'looping over file %s' % (iSample), iEntry - 1)
        met.SetCoordinates(iTree.pfMetEt, 0.0, iTree.pfMetPhi, 0)
        l1.SetCoordinates(iTree.pt_1, iTree.eta_1, iTree.phi_1, iTree.m_1)
        l2.SetCoordinates(iTree.pt_2, iTree.eta_2, iTree.phi_2, iTree.m_2)

        if not plots.passCut(iTree, iFS, False, l1, l2, met, ''):
            continue
        if options.method != 'SS' and iTree.q_1 == iTree.q_2:
            continue

        if plots.regionSelection(iTree, iFS, "control", options.method,
                                 plots_cfg.scanRange[0],
                                 plots_cfg.scanRange[1]):
            sampleName = 'MC' + controlRegionName
        elif plots.regionSelection(iTree, iFS, "signal", options.method,
                                   plots_cfg.scanRange[0],
                                   plots_cfg.scanRange[1]):
            sampleName = iSample
        else:
            continue

        triggerEff = iTree.trigweight_1 * iTree.trigweight_2
        xs = iTree.xs

        if 'WJets' in iSample:
            xs = xs * plots_cfg.WJetsScanRange[0]
        if "Zprime" in iSample:
            xs = plots.getZPrimeXS(iSample[7:])

        if eventCount:
            initEvents = int(eventCount.GetBinContent(1))
        else:
            initEvents = int(iTree.initEvents)
        if eventCountWeighted:
            initSumWeights = int(eventCountWeighted.GetBinContent(1))
        else:
            initSumWeights = int(iTree.initWeightedEvents)

        m_effective = (l1 + l2 + met).mass()
        #overflow and underflow
        if m_effective < plots_cfg.list[0]:
            m_effective = (plots_cfg.list[0] + plots_cfg.list[1]) / 2.0
        if m_effective > plots_cfg.list[nBins - 1]:
            m_effective = (plots_cfg.list[nBins - 1] +
                           plots_cfg.list[nBins - 2]) / 2.0
        if options.PUWeight:
            PUWeight = cutSampleTools.getPUWeight(iTree.nTruePU)
        else:
            PUWeight = 1.0

        genEventWeight = iTree.genEventWeight
        if options.noNegGenEvts and genEventWeight < 0:
            continue
        if options.noGenEvtWeight:
            genEventWeight = 1.0

        if (sampleName == 'MC' + controlRegionName) and ("WJets" in iSample):
            totalNormalWeights = triggerEff * xs * (
                plots.lumi) * genEventWeight * PUWeight
            pdfHists[0].Fill(m_effective, totalNormalWeights)
            for i in range(1, nWeights):
                pdfID = getPDFWeightID(i, iSample, iTree.pdfID)
                pdfHists[i].Fill(
                    m_effective,
                    totalNormalWeights * iTree.pdfWeight.at(pdfID))
        elif (controlRegionName not in sampleName) and ("WJets"
                                                        not in iSample):
            totalNormalWeights = triggerEff * xs * (
                plots.lumi) * genEventWeight * PUWeight
            absMax = 0
            for i in range(1, nWeights):
                pdfID = getPDFWeightID(i, iSample, iTree.pdfID)
                if abs(iTree.pdfWeight.at(pdfID)) > absMax:
                    absMax = iTree.pdfWeight.at(pdfID)
            if absMax > 2.5:
                continue
            pdfHists[0].Fill(m_effective, totalNormalWeights)
            for i in range(1, nWeights):
                pdfID = getPDFWeightID(i, iSample, iTree.pdfID)
                pdfHists[i].Fill(
                    m_effective,
                    totalNormalWeights * iTree.pdfWeight.at(pdfID))
                #hist_highPUWeight.Fill(PUWeight)
                if PUWeight > 1.0:
                    hist_highPUWeight.Fill(iTree.pdfWeight.at(pdfID),
                                           genEventWeight * PUWeight)
                else:
                    hist_lowPUWeight.Fill(iTree.pdfWeight.at(pdfID),
                                          genEventWeight * PUWeight)

    c = r.TCanvas("c", "Test", 600, 600)
    c.Range(0, 0, 1, 1)
    c.SetFillColor(0)
    #    r.gPad.SetLogy()

    hist_highPUWeight.SetLineColor(r.kBlue)

    hist_lowPUWeight.SetLineColor(r.kRed)
    #    hist_lowPUWeight.Scale(1./hist_lowPUWeight.Integral(0, hist_lowPUWeight.GetNbinsX()+1))
    hist_highPUWeight.Draw()
    hist_lowPUWeight.Draw("same")

    position = (0.15, 0.85 - 0.05 * 2, 0.47, 0.85)
    histList = []
    histList.append((hist_highPUWeight, "high PU-weight events", 'l'))
    histList.append((hist_lowPUWeight, "low PU-weight events", 'l'))

    legends = tool.setMyLegend(position, histList)
    legends.Draw("same")

    c.Print('pdfSys.pdf')

    return getVariations(pdfHists, initSumPDF, initSumWeights)
コード例 #34
0
def getHistos(varName, signalSelection, logY, sigBoost, nbins, useData, max, rangeMin, rangeMax, location, bTag, predict, predictPtBin):
    r.gStyle.SetOptStat(0)
    preFix = 'ClassApp_both_ClassApp_QCD_ClassApp_EWK_TMVARegApp_'

    fileList = [('ZZ', preFix + 'ZZ_eff_all.root', 2500, 5),
                ('tt_full_lep',preFix + 'tt_eff_all.root', 26197.5, r.kRed-7),
                ('tt_semi_lep',preFix + 'tt_semi_eff_all.root', 109281, r.kAzure+7),
                #('DYJetsToLL', 'TMVARegApp_DYJetsToLL_eff_all.root', 3504000, r.kGreen-7),
                ('DY2JetsToLL', preFix + 'DY2JetsToLL_eff_all.root', 181000, r.kGreen-7),
                ('DY3JetsToLL', preFix + 'DY3JetsToLL_eff_all.root', 51100, r.kGreen-7),
                ('W1JetsToLNu', preFix + 'W1JetsToLNu_eff_all.root', 5400000, r.kMagenta-9),
                ('W2JetsToLNu', preFix + 'W2JetsToLNu_eff_all.root', 1750000, r.kMagenta-9),
                ('W3JetsToLNu', preFix + 'W3JetsToLNu_eff_all.root', 519000, r.kMagenta-9)]
    histList = []
    QCDHistList = []
    varRange = [nbins, rangeMin, rangeMax]
    Lumi = 19.0
    initNEventsList = []
    legendHistos = []
    var_background = []
    fitList = []
    for i in range(6):
        fitList.append(r.TF1("Fit%i" %i,"[0]+[1]*x", rangeMin, rangeMax))
        fitList[i].SetLineColor(r.kRed)
        fitList[i].SetLineStyle(2)
        fitList[i].SetParameter(0,0)
        fitList[i].SetParameter(1,0)

    tmpFile = []
    tmpTree = []
    var_data = []

    for i in range(5):
        var_data.append(r.TH1F('data_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
    dataName = preFix + 'dataTotal_all.root'
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' %dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag)
        if (select == 0) or (select == 1):
            continue
        var_data[select-2].Fill(varsList.findVar(treeData, varName))
    legendHistos.append([])
    for j in range(5):
        var_data[j].SetMarkerStyle(8)
        var_data[j].SetMarkerSize(0.9)
        legendHistos.append([])
        legendHistos[j+1].append((var_data[j], 'observed (%.0f)' %var_data[j].Integral()))

    for i in range(len(fileList)): 
        for j in range(6):
            histList.append(r.TH1F('%s_%i' %(fileList[i][0],j),fileList[i][0], varRange[0], varRange[1], varRange[2]))
        print 'Adding events from: %s ...' %(fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag)
            if not select:
                continue
            histList[6*i+select-1].Fill(varsList.findVar(tmpTree[i], varName), tmpTree[i].triggerEff)
    
        initNEventsList.append(tmpFile[i].Get('preselection'))
        for j in range(6):
            var_background.append(r.THStack())
            histList[6*i+j].SetFillColor(fileList[i][3])
            histList[6*i+j].Scale(fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1))
            var_background[j].Add(histList[6*i+j])
            legendHistos[j].append((histList[6*i+j], '%s (%.2f)' %(fileList[i][0], histList[6*i+j].Integral())))

    data_i = []
    MC_i = []
    data_r = []
    MC_r = []
    e = []

    for i in range(5):
        QCDHistList.append(r.TH1F('QCD_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        for j in range(varRange[0]):
            dataValue = var_data[i].GetBinContent(j+1)
            dataError = var_data[i].GetBinError(j+1)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue +=  histList[6*k+1+i].GetBinContent(j+1)
            if i == 0:
                data_i.append(dataValue)
                e.append(dataError)
                MC_i.append(MCValue)
            if i == 2:
                data_r.append(dataValue)
                MC_r.append(MCValue)
            if dataValue - MCValue > 0:
                QCDHistList[i].SetBinContent(j+1, dataValue - MCValue)
                QCDHistList[i].SetBinError(j+1, dataError)

    QCDDiff = r.TH1F('QCD_diff',"", varRange[0], varRange[1], varRange[2])
    QCDDiff2 = r.TH1F('QCD_diff2',"", varRange[0], varRange[1], varRange[2])

    for j in range(varRange[0]):
        SS_tight_Events = QCDHistList[0].GetBinContent(j+1)
        OS_Events = QCDHistList[1].GetBinContent(j+1)
        SS_Events = QCDHistList[2].GetBinContent(j+1)
        SS_tight_Error = QCDHistList[0].GetBinError(j+1)
        OS_Error = QCDHistList[1].GetBinError(j+1)
        SS_Error = QCDHistList[2].GetBinError(j+1)

        if SS_Events != 0:
            QCDDiff.SetBinContent(j+1, OS_Events/SS_Events)
            QCDDiff.SetBinError(j+1, OS_Events/SS_Events*getCombinedError(OS_Events, OS_Error, SS_Events, SS_Error))
            QCDDiff2.SetBinContent(j+1, SS_tight_Events/SS_Events)
            QCDDiff2.SetBinError(j+1, SS_tight_Events/SS_Events*getCombinedError(SS_tight_Events, SS_tight_Error, SS_Events, SS_Error))
    fit1 = r.TF1("fit1","[0]", varRange[1],varRange[2])
    fit1.SetParName(0,'scale')
    QCDDiff.Fit('fit1', '0E')
    fit1.SetLineStyle(2)
    fit1.SetLineColor(r.kRed)
    fit2 = r.TF1("fit2","[0]", varRange[1],varRange[2])
    fit2.SetParName(0,'scale')
    QCDDiff2.Fit('fit2', '0E')
    fit2.SetLineStyle(2)
    fit2.SetLineColor(r.kRed)
    ptBins = [varRange[1], 100, 200, varRange[2]]
    if predictPtBin == 'True':
        fit_l = r.TF1("fit_l","[0]", ptBins[0], ptBins[1])
        fit_l.SetLineColor(r.kRed)
        fit_m = r.TF1("fit_m","[0]", ptBins[1], ptBins[2])
        fit_m.SetLineColor(r.kBlue)
        fit_h = r.TF1("fit_h","[0]", ptBins[2], ptBins[3])
        fit_h.SetLineColor(r.kGreen)
        QCDDiff.Fit('fit_l', '0ER')
        QCDDiff.Fit('fit_m', '0ER')
        QCDDiff.Fit('fit_h', '0ER')
        fit2_l = r.TF1("fit2_l","[0]", ptBins[0], ptBins[1])
        fit2_m = r.TF1("fit2_m","[0]", ptBins[1], ptBins[2])
        fit2_h = r.TF1("fit2_h","[0]", ptBins[2], ptBins[3])
        fit2_l.SetLineColor(r.kRed)
        fit2_m.SetLineColor(r.kBlue)
        fit2_h.SetLineColor(r.kGreen)
        fit2_l.SetLineStyle(2)
        fit2_m.SetLineStyle(2)
        fit2_h.SetLineStyle(2)
        fit_l.SetLineStyle(2)
        fit_m.SetLineStyle(2)
        fit_h.SetLineStyle(2)
        QCDDiff2.Fit('fit2_l', '0ER')
        QCDDiff2.Fit('fit2_m', '0ER')
        QCDDiff2.Fit('fit2_h', '0ER')

    DrawSignal = False
    if signalSelection != '':
        var_signal = []
        for i in range(6):
            var_signal.append(r.TH1F('%s_%i' %(signalSelection,i),"", varRange[0], varRange[1], varRange[2]))
        signalDict = {'H260': (preFix + 'H2hh260_all.root', 14.76),
                      'H300': (preFix + 'H2hh300_all.root', 15.9),
                      'H350': (preFix + 'H2hh350_all.root', 8.57)}
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection][0])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' %(signalDict[signalSelection][0])
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag)
                if not select:
                    continue
                var_signal[select-1].Fill(varsList.findVar(treeSignal, varName), treeSignal.triggerEff)
            initNEventsSignal = fSignal.Get('preselection')
            for i in range(6):
                var_signal[i].SetLineStyle(7)
                var_signal[i].SetLineWidth(4)
                var_signal[i].Scale(signalDict[signalSelection][1]*sigBoost*Lumi/initNEventsSignal.GetBinContent(1))
                if sigBoost != 1:
                    legendHistos[i].append((var_signal[i], '%sx%0.f (%.2f)' %(signalSelection, sigBoost, var_signal[i].Integral())))
                else:
                    legendHistos[i].append((var_signal[i], '%s (%.2f)' %(signalSelection, var_signal[i].Integral())))
            DrawSignal = True
        else:
            print '%s not supported, please use H260, H300 or H350' %signalSelection

    if predict == 'True':
        relaxed2Tight = r.TH1F('relaxed2Tight','', varRange[0], varRange[1], varRange[2])
        SS2OS = r.TH1F('SS2OS','', varRange[0], varRange[1], varRange[2])
        relaxed2Signal = r.TH1F('relaxed2Signal','', varRange[0], varRange[1], varRange[2])
        SS2OS_signal = r.TH1F('SS2OS_signal','', varRange[0], varRange[1], varRange[2])
        fullHistTranslate = r.TH1F('fullHistTranslate','', varRange[0], varRange[1], varRange[2])

        scale_SS2OS = fit1.GetParameter(0)
        scale_er_SS2OS = fit1.GetParError(0)
        scale_relaxed2Tight = fit2.GetParameter(0)
        scale_er_relaxed2Tight = fit2.GetParError(0)

        if predictPtBin == 'True':
            scale_SS2OS_l = fit_l.GetParameter(0)
            scale_er_SS2OS_l = fit_l.GetParError(0)
            scale_relaxed2Tight_l = fit2_l.GetParameter(0)
            scale_er_relaxed2Tight_l = fit2_l.GetParError(0)
            scale_SS2OS_m = fit_m.GetParameter(0)
            scale_er_SS2OS_m = fit_m.GetParError(0)
            scale_relaxed2Tight_m = fit2_m.GetParameter(0)
            scale_er_relaxed2Tight_m = fit2_m.GetParError(0)
            scale_SS2OS_h = fit_h.GetParameter(0)
            scale_er_SS2OS_h = fit_h.GetParError(0)
            scale_relaxed2Tight_h = fit2_h.GetParameter(0)
            scale_er_relaxed2Tight_h = fit2_h.GetParError(0)

        for i in range(varRange[0]):

            SS_tight_Events = QCDHistList[0].GetBinContent(i+1)
            SS_tight_Error = QCDHistList[0].GetBinError(i+1)
            OS_relaxed_Events = QCDHistList[1].GetBinContent(i+1)
            OS_relaxed_Error = QCDHistList[1].GetBinError(i+1)
            SS_Events = QCDHistList[2].GetBinContent(i+1)
            SS_Error = QCDHistList[2].GetBinError(i+1)

            scale_1 = scale_relaxed2Tight
            scale_2 = scale_SS2OS

            if predictPtBin == 'True':
                ptValue = QCDHistList[0].GetBinCenter(i+1)
                if ptValue <= ptBins[1]:
                    scale_1 = scale_relaxed2Tight_l
                    scale_2 = scale_SS2OS_l
                elif ptValue <= ptBins[2]:
                    scale_1 = scale_relaxed2Tight_m
                    scale_2 = scale_SS2OS_m
                else:
                    scale_1 = scale_relaxed2Tight_h
                    scale_2 = scale_SS2OS_h

            relaxed2Tight.SetBinContent(i+1, scale_1*SS_Events)
            relaxed2Signal.SetBinContent(i+1, scale_1*OS_relaxed_Events)
            SS2OS.SetBinContent(i+1, scale_2*SS_Events)
            SS2OS_signal.SetBinContent(i+1, scale_2*SS_tight_Events)

            if SS_Events > 0:
                fullHistTranslate.SetBinContent(i+1, SS_tight_Events*OS_relaxed_Events/SS_Events)

#             relaxed2Tight.SetBinError(i+1, getCombinedError(scale_relaxed2Tight, scale_er_relaxed2Tight, SS_Events, SS_Error))
#             SS2OS.SetBinError(i+1, getCombinedError(scale_SS2OS, scale_er_SS2OS, SS_Events, SS_Error))
#             relaxed2Tight.SetLineColor(r.kSpring+8)
        relaxed2Tight.SetFillColor(r.kSpring+1)
#             SS2OS.SetLineColor(r.kOrange)
        SS2OS.SetFillColor(r.kOrange-4)
        SS2OS_signal.SetLineColor(r.kSpring+1)
        SS2OS_signal.SetLineWidth(2)
        relaxed2Signal.SetLineStyle(2)
        relaxed2Signal.SetLineColor(r.kOrange-4)
        relaxed2Signal.SetLineWidth(2)
        fullHistTranslate.SetLineColor(r.kPink+1)
        fullHistTranslate.SetLineWidth(2)
        fullHistTranslate.SetLineStyle(2)

        legendHistos[0].append((SS2OS_signal, 'From SS/Tight (%.0f)' %SS2OS_signal.Integral()))
        legendHistos[0].append((relaxed2Signal, 'From OS/Relax (%.0f)' %relaxed2Signal.Integral()))
        #legendHistos[0].append((fullHistTranslate, 'full hist (%.0f)' %fullHistTranslate.Integral()))

        var_background[1].Add(relaxed2Tight)
        var_background[2].Add(SS2OS)
        legendHistos[1].append((relaxed2Tight, 'From SS/Relax (%.0f)' %relaxed2Tight.Integral()))
        legendHistos[2].append((SS2OS, 'From SS/Relax (%.0f)' %SS2OS.Integral()))
        relaxed2Signal = tool.addFakeTHStack(relaxed2Signal,var_background[0])
        SS2OS_signal = tool.addFakeTHStack(SS2OS_signal,var_background[0])
        fullHistTranslate = tool.addFakeTHStack(fullHistTranslate,var_background[0])



    legendPosition = (0.6, 0.7, 0.90, 0.88)
    l = []
    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == 'Revert':
        titleName = 'Revert b-tag'
        fileName = 'revert_bTag'

    psfile = '%s/%s_%s_IsoRatio.pdf' %(location, varName, fileName)
    c = r.TCanvas("c","Test", 800, 1000)
    #ps = r.TPDF(psfile,112)
    c.Divide(2,3)
    drawOpt = ''
    for k in range(6):
        c.cd(k+1)
        if logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+1)
        var_background[k].SetTitle('%s %s Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        var_background[k].SetMaximum(max)
        var_background[k].SetMinimum(0.01)
        var_background[k].Draw()
        if predict == 'True' and k == 0:
            SS2OS_signal.Draw('same')
            relaxed2Signal.Draw('same')
            #fullHistTranslate.Draw('same')
        if k != 0 and useData == 'True':
            var_data[k-1].Draw('PE same')
        legendPosition = (0.63, 0.93 - 0.035*len(legendHistos[k]), 0.93, 0.9)
        l.append(tool.setMyLegend(lPosition=legendPosition, lHistList=legendHistos[k]))
        l[k].Draw('same')
        var_signal[k].Draw('same')
    c.Update()
    c.Print('%s(' %psfile)
    c.Clear()
    c.Divide(2,3)

    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff.SetTitle('OS/SS MultiJet Relaxed Events %s (%.1f fb^{-1}); %s; OS/SS' %(titleName, Lumi,varName))
    QCDDiff.SetMarkerStyle(8)
    QCDDiff.SetMarkerSize(0.9)
    QCDDiff.SetMaximum(2)
    QCDDiff.SetMinimum(0)
    QCDDiff.Draw('PE')
    if predictPtBin == 'True':
        lFit1 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fit_l,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(fit_l.GetParameter(0), fit_l.GetParError(0))),
                                                         (fit_m,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(fit_m.GetParameter(0), fit_m.GetParError(0))),
                                                         (fit_h,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(fit_h.GetParameter(0), fit_h.GetParError(0)))])
        fit_l.Draw('same')
        fit_m.Draw('same')
        fit_h.Draw('same')
    else:
        fit1.Draw('same')
        lFit1 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fit1,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(fit1.GetParameter(0), fit1.GetParError(0)))])
    lFit1.Draw('same')
    for k in range(5):
        c.cd(k+2)
        if logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+2)
        QCDHistList[k].SetTitle('%s %s Data - MC Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        QCDHistList[k].SetMarkerStyle(8)
        QCDHistList[k].SetMarkerSize(0.9)
        QCDHistList[k].SetMaximum(max)
        QCDHistList[k].SetMinimum(1)
        QCDHistList[k].Draw('PE')
    c.Update()
    c.Print('%s' %psfile)
    c.Clear()
    c.Divide(2,3)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff2.SetTitle('tight/relaxed MultiJet SS Events %s (%.1f fb^{-1}); %s; tight/relaxed' %(titleName, Lumi,varName))
    QCDDiff2.SetMarkerStyle(8)
    QCDDiff2.SetMarkerSize(0.9)
    QCDDiff2.SetMinimum(0)
    QCDDiff2.SetMaximum(1)
    QCDDiff2.Draw('PE')
    if predictPtBin == 'True':
        lFit2 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fit2_l,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(fit2_l.GetParameter(0), fit2_l.GetParError(0))),
                                                         (fit2_m,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(fit2_m.GetParameter(0), fit2_m.GetParError(0))),
                                                         (fit2_h,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(fit2_h.GetParameter(0), fit2_h.GetParError(0)))])
        fit2_l.Draw('same')
        fit2_m.Draw('same')
        fit2_h.Draw('same')
    else:
        fit2.Draw('same')
        lFit2 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fit2,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(fit2.GetParameter(0), fit2.GetParError(0)))])
    lFit2.Draw('same')

    c.Print('%s' %psfile)
    c.Clear()
    c.Divide(2,3)

    lineInfoList = []
    i = 0
    tmpQCDHist2 = QCDHistList[2].Clone()
    tmpQCDHist2.Divide(QCDHistList[4])
    tmpQCDHist1 = QCDHistList[1].Clone()
    tmpQCDHist1.Divide(QCDHistList[3])
    c.cd(1)
    tmpQCDHist1.SetTitle('1.5<iso<4/4<iso<10 OS QCD Events %s (%.1f fb^{-1}); %s; relaxed1/relaxed2' %(titleName, Lumi,varName))
    tmpQCDHist1.GetXaxis().SetTitleOffset(1.2)
    tmpQCDHist1.SetMaximum(0.3)
    tmpQCDHist1.SetMinimum(0)
    tmpQCDHist1.Draw()
    tmpQCDHist1.Fit('Fit0', '0ER')

    l1 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fitList[0],'Ratio between relaxed1/relaxed2: y = %.2f\pm%.2f + (%.4f\pm%.4f)x' %(fitList[0].GetParameter(0), fitList[0].GetParError(0), fitList[0].GetParameter(1), fitList[0].GetParError(1)))])
    l1.Draw('same')
    fitList[0].Draw('same')
    c.cd(2)
    tmpQCDHist2.SetTitle('1.5<iso<4/4<iso<10 SS QCD Events %s (%.1f fb^{-1}); %s; relaxed1/relaxed2' %(titleName, Lumi,varName))
    tmpQCDHist2.SetMaximum(0.3)
    tmpQCDHist2.GetXaxis().SetTitleOffset(1.2)
    tmpQCDHist2.SetMinimum(0)
    tmpQCDHist2.Draw()
    tmpQCDHist2.Fit('Fit1', '0ER')
    l2 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fitList[1],'Ratio between relaxed1/relaxed2: y = %.2f\pm%.2f + (%.4f\pm%.4f)x' %(fitList[1].GetParameter(0), fitList[1].GetParError(0), fitList[1].GetParameter(1), fitList[1].GetParError(1)))])
    l2.Draw('same')
    fitList[1].Draw('same')

    QCDHistList[1].SetTitle('OS Relaxed1 / SS Relaxed1 QCD Events %s (%.1f fb^{-1}); %s; OS/SS' %(titleName, Lumi,varName))
    QCDHistList[3].SetTitle('OS Relaxed2 / SS Relaxed2 QCD Events %s (%.1f fb^{-1}); %s; OS/SS' %(titleName, Lumi,varName))
    QCDHistList[2].SetTitle('SS Relaxed1 / SS Tight QCD Events %s (%.1f fb^{-1}); %s; Relaxed1/SS' %(titleName, Lumi,varName))
    QCDHistList[4].SetTitle('SS Relaxed2 / SS Tight QCD Events %s (%.1f fb^{-1}); %s; Relaxed2/SS' %(titleName, Lumi,varName))

    for k in [1,3]:
        c.cd(k+2)
        QCDHistList[k].Divide(QCDHistList[k+1])
        QCDHistList[k].SetMarkerStyle(8)
        QCDHistList[k].SetMaximum(3)
        QCDHistList[k].SetMinimum(0)
        QCDHistList[k].SetMarkerSize(0.9)
        QCDHistList[k].Draw('PE')
        QCDHistList[k].Fit('Fit%i' %(k+1), '0ER')
        lineInfoList.append(tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fitList[k+1],'Ratio between OS/SS: y = %.3f\pm%.3f + (%.4f\pm%.4f)x' %(fitList[k+1].GetParameter(0), fitList[k+1].GetParError(0), fitList[k+1].GetParameter(1), fitList[k+1].GetParError(1)))]))
        lineInfoList[i].Draw('same')
        fitList[k+1].Draw('same')
        i += 1
    QCDHistList[2].SetMaximum(9)
    QCDHistList[4].SetMaximum(80)

    for k in [2,4]:
        c.cd(k+2)
        QCDHistList[k].Divide(QCDHistList[0])
        QCDHistList[k].SetMarkerStyle(8)
        QCDHistList[k].SetMinimum(0)
        QCDHistList[k].SetMarkerSize(0.9)
        QCDHistList[k].Draw('PE')
        QCDHistList[k].Fit('Fit%i' %(k+1), '0ER')
        lineInfoList.append(tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fitList[k+1],'Ratio between relaxed%i/iso: y = %.3f\pm%.3f + (%.4f\pm%.4f)x' %(k/2,fitList[k+1].GetParameter(0), fitList[k+1].GetParError(0), fitList[k+1].GetParameter(1), fitList[k+1].GetParError(1)))]))
        lineInfoList[i].Draw('same')
        fitList[k+1].Draw('same')
        i += 1

    c.Print('%s)' %psfile)
    #ps.Close()
    print "Plot saved at %s" %(psfile)
コード例 #35
0
ファイル: drawBDT.py プロジェクト: zaixingmao/H2hh2bbTauTau
def getHistos(signalSelection, sigBoost, location, bTag):
    r.gStyle.SetOptStat(0)
    preFix = 'ClassApp_both_ClassApp_QCD_ClassApp_EWK_TMVARegApp_'

    fileList = [('ZZ', preFix + 'ZZ_eff_all.root', 2500, 5, r.kYellow),
                ('tt_full_lep',preFix+'tt_eff_all.root', 26197.5, r.kRed-7),
                ('tt_semi_lep',preFix+'tt_semi_eff_all.root', 109281, r.kAzure+7),
#                 ('DYJetsToLL', 'DYJetsToLL_eff_all.root', 3504000, r.kGreen-7),
                ('DY2JetsToLL', preFix+'DY2JetsToLL_eff_all.root', 181000, r.kGreen-7),
                ('DY3JetsToLL', preFix+'DY3JetsToLL_eff_all.root', 51100, r.kGreen-7),
                ('W1JetsToLNu', preFix+'W1JetsToLNu_eff_all.root', 5400000, r.kMagenta-9),
                ('W2JetsToLNu', preFix+'W2JetsToLNu_eff_all.root', 1750000, r.kMagenta-9),
                ('W3JetsToLNu', preFix+'W3JetsToLNu_eff_all.root', 519000, r.kMagenta-9)]
    histList = []
    QCDHistList = []
    varRange = [20, -1, 1, 20, -1, 1]
    Lumi = 19.0
    initNEventsList = []
    legendHistos = []

    tmpFile = []
    tmpTree = []
    var_data = []
    signal = r.TH2F('signal',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])
    EWK = r.TH2F('EWK',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])
    QCD = r.TH2F('QCD',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])
    data = r.TH2F('data',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])
    MC = r.TH2F('MC',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])

    background = r.TH2F('background',"", varRange[0], varRange[1], varRange[2], varRange[0], varRange[1], varRange[2])
    dataName = preFix + 'dataTotal_all.root'
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' %dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag)
        if select == 3:
            data.Fill(varsList.findVar(treeData, 'BDT_EWK'), varsList.findVar(treeData, 'BDT_QCD'))

    for i in range(len(fileList)):
        print 'Adding events from: %s ...' %(fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        initNEventsList.append(tmpFile[i].Get('preselection'))
        tmpScale = fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1)
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag)
            if select == 1:
                background.Fill(varsList.findVar(tmpTree[i], 'BDT_EWK'), varsList.findVar(tmpTree[i], 'BDT_QCD'), tmpTree[i].triggerEff*tmpScale)
                EWK.Fill(varsList.findVar(tmpTree[i], 'BDT_EWK'), varsList.findVar(tmpTree[i], 'BDT_QCD'), tmpTree[i].triggerEff*tmpScale)
            if select == 3:
                MC.Fill(varsList.findVar(tmpTree[i], 'BDT_EWK'), varsList.findVar(tmpTree[i], 'BDT_QCD'), tmpTree[i].triggerEff*tmpScale)
    if signalSelection != '':
        var_signal = []
        for i in range(4):
            var_signal.append(r.TH1F('%s_%i' %(signalSelection,i),"", varRange[0], varRange[1], varRange[2]))
        signalDict = {'H260': (preFix+'H2hh260_all.root', 14.76),
                      'H300': (preFix+'H2hh300_all.root', 15.9),
                      'H350': (preFix+'H2hh350_all.root', 8.57)}
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection][0])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' %(signalDict[signalSelection][0])
            initNEventsSignal = fSignal.Get('preselection')
            scaleSignal = signalDict[signalSelection][1]*sigBoost*Lumi/initNEventsSignal.GetBinContent(1)
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag)
                if select == 1:
                    signal.Fill(varsList.findVar(treeSignal, 'BDT_EWK'), varsList.findVar(treeSignal, 'BDT_QCD'), treeSignal.triggerEff)
                    background.Fill(varsList.findVar(treeSignal, 'BDT_EWK'), varsList.findVar(treeSignal, 'BDT_QCD'), treeSignal.triggerEff*scaleSignal)
            signal.Scale(scaleSignal)
        else:
            print '%s not supported, please use H260, H300 or H350' %signalSelection

    background = estBkg2(MC, data, background, 0.025)
    QCD = estBkg2(MC, data, QCD, 0.025)

    legendHistos.append((background, 'background (%.2f)' %background.Integral()))

    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == 'Revert':
        titleName = 'Revert b-tag'
        fileName = 'revert_bTag'

    psfile = '%s/BDT2D_%s.pdf' %(location, fileName)
    c = r.TCanvas("c","Test", 800, 600)
    #ps = r.TPDF(psfile,112)
    drawOpt = ''
    c.Divide(2,2)
    c.cd(1)
    signSelection, iso = conditions(1)
    EWK.SetTitle('%s %s Events %s (%.1f fb^{-1}); BDT_EWK;BDT_QCD; events / bin' %(signSelection, iso, titleName, Lumi))
    EWK.Draw("CONTZ")    
    legendPosition = (0.5, 0.75, 0.75, 0.9)
    l = tool.setMyLegend(lPosition=legendPosition, lHistList=[(EWK, "EWK (%.2f)" %EWK.Integral())])
    l.Draw('same')
    c.cd(2)
    QCD.SetTitle('%s %s Events %s (%.1f fb^{-1}); BDT_EWK;BDT_QCD; events / bin' %(signSelection, iso, titleName, Lumi))
    QCD.Draw("CONTZ")    
    l2 = tool.setMyLegend(lPosition=legendPosition, lHistList=[(QCD, "QCD (%.2f)" %QCD.Integral())])
    l2.Draw('same')
    c.cd(3)
    signal.SetTitle('%s %s Events %s (%.1f fb^{-1}); BDT_EWK;BDT_QCD; events / bin' %(signSelection, iso, titleName, Lumi))
    signal.Draw("CONTZ")    
    l3 = tool.setMyLegend(lPosition=legendPosition, lHistList=[(signal, "signal x%.0f (%.2f)" %(sigBoost,signal.Integral()))])
    l3.Draw('same')
    c.cd(4)
    background.SetTitle('%s %s Events %s (%.1f fb^{-1}); BDT_EWK;BDT_QCD; events / bin' %(signSelection, iso, titleName, Lumi))
    background.Draw("CONTZ")    
    l4 = tool.setMyLegend(lPosition=legendPosition, lHistList=[(background, "total (%.2f)" %background.Integral())])
    l4.Draw('total')
    c.Update()
    c.Print('%s' %psfile)
    #ps.Close()
    print "Plot saved at %s" %(psfile)
コード例 #36
0
        if jetsList[0][1].pt() < 20 or abs(jetsList[0][1].eta()) >= 2.4:
            continue
        if jetsList[1][1].pt() < 20 or abs(jetsList[1][1].eta()) >= 2.4:
            continue
        if jetsList[0][0] > CSVCut1 and jetsList[1][0] > CSVCut2:
            iHist.Fill((jetsList[0][1]+jetsList[1][1]).mass())
    print ''
            
intList = tool.unitNormHists(HistNameList)
            
legendPosition = (0.58, 0.7, 0.88, 0.80)
legendHistos = [(h_mjj_h,"H -> hh -> #tau^{+}#tau^{-} b#bar{b}"),#(%.2f events/20 fb^{-1})" %(intList[0]*xsList[0]*20/sigPreSelection)),
                (h_mjj_tt,"t#bar{t} -> b#bar{b} ll"), #(%.1f events/20 fb^{-1})" %(intList[1]*xsList[1]*20/ttPreSelection)),
                (h_mjj_zz,"ZZ + jets -> 2q 2l")]#(%.1f events/20 fb^{-1})" %(intList[2]*xsList[2]*20/ZZPreSelection))]

h_mjj_zz.SetTitle("%s; mJJCSVSort; Unit Normalized" % (Title))
h_mjj_zz.GetYaxis().SetTitleOffset(1.2)
c = r.TCanvas("c","Test", 800, 600)
r.gPad.SetTickx()
r.gPad.SetTicky()

psfile = os.environ['PYPATH']+'/Plots/'+psfile
ps = r.TPostScript(psfile,112)

tool.setDrawHists(sigHist=h_mjj_h, ttHist=h_mjj_tt, ZZHist=h_mjj_zz)
l = tool.setMyLegend(lPosition=legendPosition, lHistList=legendHistos)
l.Draw("same")
ps.Close()

print "Plot saved at %s" %(psfile)
コード例 #37
0
tHist1.SetLineColor(r.kAzure+9)
tHist1.SetFillColor(r.kAzure+9)
tHist1.SetFillStyle(3003) 
tHist2 = r.TH1F() 
tHist2.SetLineColor(2)
tHist2.SetLineWidth(2)
tHist2.SetLineStyle(2)

legendPosition = (0.5, 0.75, 0.9, 0.85)
legendHistos = [(tHist1,"%s with %d events" %(options.file1, tree1.GetEntries())),
                (tHist2,"%s with %d events" %(options.file2, tree2.GetEntries()))]
listBranch = tree1.GetListOfBranches()

oFileName = "diff.root"
ofile = r.TFile(oFileName, "RECREATE")

nBranches = listBranch.GetEntries()

for i in range(nBranches):
    iBranchName = listBranch.At(i).GetName()
    tmpCanvas = r.TCanvas(iBranchName,"c",800,600)

    tree1.Draw("%s" %(iBranchName), "")
    tree2.Draw("%s" %(iBranchName), "", "same")
    l = tool.setMyLegend(lPosition=legendPosition, lHistList=legendHistos)
    l.Draw("same")
    tmpCanvas.Write()
    tool.printProcessStatus(i+1, nBranches, 'Saving to file %s.root' %(oFileName))
print '  -- saved %d branches' %(nBranches)
    
コード例 #38
0
    tmpHist4 = iFile_1.Get("InputVariables_Id/%s__Background_Id" %(varsList[i]))    

    tool.unitNormHists([tmpHist1, tmpHist2, tmpHist3, tmpHist4])
    tool.setDrawHists4(tmpHist3, tmpHist4, tmpHist1, tmpHist2)
    tmpHist1.SetTitle('%s; %s; Unit Normalized' %(varsList[i], varsList[i]))
    tmpHist2.SetTitle('%s; %s; Unit Normalized' %(varsList[i], varsList[i]))
    tmpHist3.SetTitle('%s; %s; Unit Normalized' %(varsList[i], varsList[i]))
    tmpHist4.SetTitle('%s; %s; Unit Normalized' %(varsList[i], varsList[i]))
    tmpHist1.GetXaxis().SetRangeUser(varRanges[varsList[i]][0],varRanges[varsList[i]][1])
    tmpHist2.GetXaxis().SetRangeUser(varRanges[varsList[i]][0],varRanges[varsList[i]][1])
    tmpHist3.GetXaxis().SetRangeUser(varRanges[varsList[i]][0],varRanges[varsList[i]][1])
    tmpHist4.GetXaxis().SetRangeUser(varRanges[varsList[i]][0],varRanges[varsList[i]][1])


    legendList.append(tool.setMyLegend(lPosition=legendPosition, lHistList = [(tmpHist1, '%s_pt45: Sig' %(trainMass)),
                                                                (tmpHist2, '%s_pt45: Bkg' %(trainMass)),
                                                                (tmpHist3, '%s_old:  Sig' %(trainMass)),
                                                                (tmpHist4, '%s_old:  Bkg' %(trainMass))]))
    legendList[i].Draw("same")
    c.Update()
ps.Close()

c2 = r.TCanvas("c2","Test", 1000, 600)
ps = r.TPDF('%s_2.pdf' %(psfile[0: psfile.rfind('.')]),112)
c2.Divide(3,2)
for i in range(6, len(varsList)):
    c2.cd(i%6 +1)
    tmpHist1 = iFile_2.Get("InputVariables_Id/%s__Signal_Id" %(varsList[i]))
    tmpHist2 = iFile_2.Get("InputVariables_Id/%s__Background_Id" %(varsList[i]))    
    tmpHist3 = iFile_1.Get("InputVariables_Id/%s__Signal_Id" %(varsList[i]))
    tmpHist4 = iFile_1.Get("InputVariables_Id/%s__Background_Id" %(varsList[i]))    
コード例 #39
0
def getHistos(varName, signalSelection, logY, sigBoost, nbins, useData, max, rangeMin, rangeMax, location, bTag, predict, predictPtBin, region):
    r.gStyle.SetOptStat(0)
    preFix = 'ClassApp_both_ClassApp_QCD_ClassApp_EWK_TMVARegApp_'

    fileList = [('ZZ', preFix + 'ZZ_eff_all.root', 2500, 5),
                ('WZJetsTo2L2Q', preFix + 'WZJetsTo2L2Q_eff_all.root', 2207, 5),
                ('W1JetsToLNu', preFix + 'W1JetsToLNu_eff2_all.root', 5400000, r.kMagenta-9),
                ('W2JetsToLNu', preFix + 'W2JetsToLNu_eff2_all.root', 1750000, r.kMagenta-9),
                ('W3JetsToLNu', preFix + 'W3JetsToLNu_eff2_all.root', 519000, r.kMagenta-9),
                #('DYJetsToLL', 'TMVARegApp_DYJetsToLL_eff_all.root', 3504000, r.kGreen-7),
                ('DY1JetsToLL', preFix + 'DY1JetsToLL_eff2_all.root', 561000, r.kGreen-7),
                ('DY2JetsToLL', preFix + 'DY2JetsToLL_eff2_all.root', 181000, r.kGreen-7),
                ('DY3JetsToLL', preFix + 'DY3JetsToLL_eff2_all.root', 51100, r.kGreen-7),
                ('tt_full_lep',preFix + 'tt_eff_all.root', 26197.5, r.kRed-7),
                ('tt_semi_lep',preFix + 'tt_semi_eff_all.root', 109281, r.kAzure+7)]

    histList = []
    histList_4QCD = []
    QCDHistList = []
    QCDHistList_4KS = []
    QCDHistList_withScale = []
    varRange = [nbins, rangeMin, rangeMax]
    nBins = 10000
    Lumi = 19.0
    initNEventsList = []
    legendHistos = []
    var_background = []

    scaleMCPt = 1.0

    tmpFile = []
    tmpTree = []
    var_data_4KS = []
    var_data = []
    var_data_4QCD = []
    histList_4KS = []


    for i in range(5):
        var_data.append(r.TH1F('data_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        var_data_4KS.append(r.TH1F('data_4KS_%i' %(i),"", nBins, varRange[1], varRange[2]))
        if i < 5:
            var_data_4QCD.append(r.TH1F('data_4QCD_%i' %(i),"", varRange[0], varRange[1], varRange[2]))

    dataName = preFix + 'dataTotal_all.root'
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' %dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag, region)
        if (select == 0) or (select == 1) or (select > 6):
            continue
        var_data[select-2].Fill(varsList.findVar(treeData, varName))
        var_data_4KS[select-2].Fill(varsList.findVar(treeData, varName))
        if select == 2:
            var_data_4QCD[0].Fill(varsList.findVar(treeData, varName), findPtScale(treeData.pt1.at(0),treeData.pt2.at(0), 'left', region))
        elif select == 3:
            var_data_4QCD[1].Fill(varsList.findVar(treeData, varName), findPtScale(treeData.pt1.at(0),treeData.pt2.at(0), 'up', region))
        elif select == 4:
            var_data_4QCD[2].Fill(varsList.findVar(treeData, varName), findPtScale(treeData.pt1.at(0),treeData.pt2.at(0), 'left', region))
            var_data_4QCD[3].Fill(varsList.findVar(treeData, varName), findPtScale(treeData.pt1.at(0),treeData.pt2.at(0), 'up', region))

    legendHistos.append([])
    for j in range(5):
        var_data[j].SetMarkerStyle(8)
        var_data[j].SetMarkerSize(0.9)
        legendHistos.append([])
        legendHistos[j+1].append((var_data[j], 'observed (%.0f)' %var_data[j].Integral()))

    for i in range(len(fileList)): 
        for j in range(6):
            histList_4KS.append(r.TH1F('%s_%i_KS' %(fileList[i][0],j),fileList[i][0], nBins, varRange[1], varRange[2]))
            histList.append(r.TH1F('%s_%i' %(fileList[i][0],j),fileList[i][0], varRange[0], varRange[1], varRange[2]))
            histList_4QCD.append(r.TH1F('%s_%i_2' %(fileList[i][0],j),fileList[i][0], varRange[0], varRange[1], varRange[2]))
        print 'Adding events from: %s ...' %(fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag, region)
            if (not select) or (select > 6):
                continue
            histList[6*i+select-1].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff)
            histList_4KS[6*i+select-1].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff)
            if select == 2:
                histList_4QCD[6*i].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff*findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0), 'left', region))
            elif select == 3:
                histList_4QCD[6*i+1].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff*findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0), 'up', region))
            elif select == 4:             
                histList_4QCD[6*i+2].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff*findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0), 'left', region))
                histList_4QCD[6*i+3].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff*findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0), 'up', region))

        initNEventsList.append(tmpFile[i].Get('preselection'))
        for j in range(6):
            var_background.append(r.THStack())
            histList[6*i+j].SetFillColor(fileList[i][3])
            histList[6*i+j].Scale(fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1))
            histList_4QCD[6*i+j].Scale(fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1))
            histList_4KS[6*i+j].Scale(fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1))                

            var_background[j].Add(histList[6*i+j])
            legendHistos[j].append((histList[6*i+j], '%s (%.2f)' %(fileList[i][0], histList[6*i+j].Integral())))

    data_i = []
    MC_i = []
    data_r = []
    MC_r = []
    e = []

    for i in range(3):
        QCDHistList.append(r.TH1F('QCD_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        QCDHistList_4KS.append(r.TH1F('QCD_%i_KS' %(i),"", nBins, varRange[1], varRange[2]))

        for j in range(varRange[0]):
            dataValue = var_data[i].GetBinContent(j+1)
            dataError = var_data[i].GetBinError(j+1)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue +=  histList[6*k+1+i].GetBinContent(j+1)
            if i == 0:
                data_i.append(dataValue)
                e.append(dataError)
                MC_i.append(MCValue)
            if i == 2:
                data_r.append(dataValue)
                MC_r.append(MCValue)
            if dataValue - MCValue > 0:
                QCDHistList[i].SetBinContent(j+1, dataValue - MCValue)
                QCDHistList[i].SetBinError(j+1, dataError)
        for j in range(nBins):
            dataValue4KS = var_data_4KS[i].GetBinContent(j+1)
            MCValue4KS = 0
            for k in range(len(fileList)):
                MCValue4KS += histList_4KS[6*k+1+i].GetBinContent(j+1)
            if dataValue4KS - MCValue4KS > 0:
                QCDHistList_4KS[i].SetBinContent(j+1, dataValue4KS - MCValue4KS)

    for i in range(4):
        QCDHistList_withScale.append(r.TH1F('QCD_withScale_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        for j in range(varRange[0]):
            dataValue = var_data_4QCD[i].GetBinContent(j+1)
            dataError = var_data_4QCD[i].GetBinError(j+1)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue +=  histList_4QCD[6*k+i].GetBinContent(j+1)
            if dataValue - MCValue > 0:
                QCDHistList_withScale[i].SetBinContent(j+1, dataValue - MCValue)

    QCDDiff = r.TH1F('QCD_diff',"", varRange[0], varRange[1], varRange[2])
    QCDDiff2 = r.TH1F('QCD_diff2',"", varRange[0], varRange[1], varRange[2])

    QCDDiff = QCDHistList[1].Clone()
    QCDDiff.Divide(QCDHistList_withScale[2])
    QCDDiff.Sumw2()
    QCDDiff2 = QCDHistList[0].Clone()
    QCDDiff2.Divide(QCDHistList_withScale[3])
    QCDDiff2.Sumw2()

    fit1 = r.TF1("fit1","[0]", varRange[1],varRange[2])
    fit1.SetParName(0,'scale')
    fit1.FixParameter(0,1.0)

    QCDDiff.Fit('fit1', '0EM')
    fit1.SetLineStyle(2)
    fit1.SetLineColor(r.kRed)
    fit2 = r.TF1("fit2","[0]", varRange[1],varRange[2])
    fit2.SetParName(0,'scale')
    fit2.FixParameter(0,1.0)
    QCDDiff2.Fit('fit2', '0EM')
    fit2.SetLineStyle(2)
    fit2.SetLineColor(r.kRed)


    DrawSignal = False
    if signalSelection != '':
        var_signal = []
        var_signal_4KS = []
        for i in range(6):
            var_signal.append(r.TH1F('%s_%i' %(signalSelection,i),"", varRange[0], varRange[1], varRange[2]))
            var_signal_4KS.append(r.TH1F('%s_%i_4KS' %(signalSelection,i),"", nBins, varRange[1], varRange[2]))
        signalDict = {'H260': (preFix + 'H2hh260_all.root', 14.76),
                      'H300': (preFix + 'H2hh300_all.root', 15.9),
                      'H350': (preFix + 'H2hh350_all.root', 8.57)}
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection][0])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' %(signalDict[signalSelection][0])
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag, region)
                if (not select) or (select > 6):
                    continue
                var_signal[select-1].Fill(varsList.findVar(treeSignal, varName), treeSignal.triggerEff)
                var_signal_4KS[select-1].Fill(varsList.findVar(treeSignal, varName), treeSignal.triggerEff)
            initNEventsSignal = fSignal.Get('preselection')
            for i in range(6):
                var_signal[i].SetLineStyle(7)
                var_signal[i].SetLineWidth(4)
                var_signal[i].Scale(signalDict[signalSelection][1]*sigBoost*Lumi/initNEventsSignal.GetBinContent(1))
                if sigBoost != 1:
                    legendHistos[i].append((var_signal[i], '%sx%0.f (%.2f)' %(signalSelection, sigBoost, var_signal[i].Integral())))
                else:
                    legendHistos[i].append((var_signal[i], '%s (%.2f)' %(signalSelection, var_signal[i].Integral())))
            DrawSignal = True
        else:
            print '%s not supported, please use H260, H300 or H350' %signalSelection

    if predict == 'True':

        scale_SS2OS = fit1.GetParameter(0)
        scale_er_SS2OS = fit1.GetParError(0)
        scale_relaxed2Tight = fit2.GetParameter(0)
        scale_er_relaxed2Tight = fit2.GetParError(0)

        QCDHistList_withScale[0].Scale(scale_SS2OS)
        QCDHistList_withScale[1].Scale(scale_relaxed2Tight)
        QCDHistList_withScale[2].Scale(scale_SS2OS)
        QCDHistList_withScale[3].Scale(scale_relaxed2Tight)

        QCDHistList_withScale[3].SetFillColor(r.kSpring+1)
        QCDHistList_withScale[2].SetFillColor(r.kOrange-4)
        QCDHistList_withScale[0].SetLineColor(r.kSpring+1)
        QCDHistList_withScale[0].SetLineWidth(2)
        QCDHistList_withScale[1].SetLineStyle(2)
        QCDHistList_withScale[1].SetLineColor(r.kOrange-4)
        QCDHistList_withScale[1].SetLineWidth(2)

        legendHistos[0].append((QCDHistList_withScale[0], 'From SS/Tight (%.0f)' %QCDHistList_withScale[0].Integral()))
        legendHistos[0].append((QCDHistList_withScale[1], 'From OS/Relax (%.0f)' %QCDHistList_withScale[1].Integral()))

        var_background[1].Add(QCDHistList_withScale[3])
        var_background[2].Add(QCDHistList_withScale[2])
        legendHistos[1].append((QCDHistList_withScale[3], 'From SS/Relax (%.0f)' %QCDHistList_withScale[3].Integral()))
        legendHistos[2].append((QCDHistList_withScale[2], 'From SS/Relax (%.0f)' %QCDHistList_withScale[2].Integral()))
        QCDHistList_withScale[1] = tool.addFakeTHStack(QCDHistList_withScale[1],var_background[0])
        QCDHistList_withScale[0] = tool.addFakeTHStack(QCDHistList_withScale[0],var_background[0])


    legendPosition = (0.6, 0.7, 0.90, 0.88)
    l = []
    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == 'Revert':
        titleName = 'Revert b-tag'
        fileName = 'revert_bTag'
    elif bTag == 'Loose':
        titleName = 'Loose b-tag'
        fileName = 'loose_bTag'

    KS1 = QCDHistList_4KS[0].KolmogorovTest(QCDHistList_4KS[2])
    KS2 = QCDHistList_4KS[1].KolmogorovTest(QCDHistList_4KS[2])

    print 'KS Test 1: %.3f' %KS1
    print 'KS Test 2: %.3f' %KS2

    psfile = '%s/%s_%s_all.pdf' %(location, varName, fileName)
    c = r.TCanvas("c","Test", 800, 900)
    #ps = r.TPDF(psfile,112)
    c.Divide(2,3)
    drawOpt = ''
    for k in range(6):
        c.cd(k+1)
        r.gPad.SetTicky()
        if logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+1)
        var_background[k].SetTitle('%s %s Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        var_background[k].SetMaximum(max)
        var_background[k].SetMinimum(0.01)
        var_background[k].Draw()
        if predict == 'True' and k == 0:
            QCDHistList_withScale[0].Draw('same')
            QCDHistList_withScale[1].Draw('same')
        if k != 0 and useData == 'True':
            var_data[k-1].Draw('PE same')
        legendPosition = (0.63, 0.93 - 0.03*len(legendHistos[k]), 0.93, 0.9)
        l.append(tool.setMyLegend(lPosition=legendPosition, lHistList=legendHistos[k]))
        if k == 1:
            ksLegend1 = tool.setMyLegend((0.3, 0.8, 0.6, 0.9), [(QCDHistList_withScale[3], 'KS Test: %.3f' %KS1)])
            ksLegend1.Draw('same')
        if k == 2:
            ksLegend2 = tool.setMyLegend((0.3, 0.8, 0.6, 0.9), [(QCDHistList_withScale[2], 'KS Test: %.3f' %KS2)])
            ksLegend2.Draw('same')
        l[k].Draw('same')
        var_signal[k].Draw('same')

    c.Update()
    c.Print('%s(' %psfile)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff.SetTitle('OS/SS MultiJet Relaxed Events %s (%.1f fb^{-1}); %s; OS/SS' %(titleName, Lumi,varName))
    QCDDiff.SetMarkerStyle(8)
    QCDDiff.SetMarkerSize(0.9)
    QCDDiff.SetMaximum(4)
    QCDDiff.SetMinimum(0)
    QCDDiff.Draw('PE')

    fit1.Draw('same')
    lFit1 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fit1,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(fit1.GetParameter(0), fit1.GetParError(0)))])
    lFit1.Draw('same')
    for k in range(3):
        c.cd(k+2)
        if logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+2)
        QCDHistList_withScale[k+1].SetTitle('%s %s Data - MC Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        QCDHistList_withScale[k+1].SetMarkerStyle(8)
        QCDHistList_withScale[k+1].SetMarkerSize(0.9)
        QCDHistList_withScale[k+1].SetMaximum(max)
        QCDHistList_withScale[k+1].SetMinimum(1)
        QCDHistList_withScale[k+1].Draw('PE')
    c.Update()
    c.Print('%s' %psfile)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff2.SetTitle('tight/relaxed MultiJet SS Events %s (%.1f fb^{-1}); %s; tight/relaxed' %(titleName, Lumi,varName))
    QCDDiff2.SetMarkerStyle(8)
    QCDDiff2.SetMarkerSize(0.9)
    QCDDiff2.SetMinimum(3)
    QCDDiff2.SetMaximum(0)
    QCDDiff2.Draw('PE')
    fit2.Draw('same')
    lFit2 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fit2,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(fit2.GetParameter(0), fit2.GetParError(0)))])
    lFit2.Draw('same')
    c.Print('%s)' %psfile)
    #ps.Close()
    print "Plot saved at %s" %(psfile)
コード例 #40
0
def go(sig, bkg):

    bins_array = array('d', range(20, 151, 1))
    sigHist = r.TH2F('sigHist', "",
                     len(bins_array) - 1, bins_array,
                     len(bins_array) - 1, bins_array)
    bkgHist = r.TH2F('bkgHist', "",
                     len(bins_array) - 1, bins_array,
                     len(bins_array) - 1, bins_array)
    sigHistJet1 = r.TH2F('sigHistJet1', "",
                         len(bins_array) - 1, bins_array,
                         len(bins_array) - 1, bins_array)
    bkgHistJet1 = r.TH2F('bkgHistJet1', "",
                         len(bins_array) - 1, bins_array,
                         len(bins_array) - 1, bins_array)
    sigHistJet2 = r.TH2F('sigHistJet2', "",
                         len(bins_array) - 1, bins_array,
                         len(bins_array) - 1, bins_array)
    bkgHistJet2 = r.TH2F('bkgHistJet2', "",
                         len(bins_array) - 1, bins_array,
                         len(bins_array) - 1, bins_array)
    sigHistJet3 = r.TH2F('sigHistJet3', "",
                         len(bins_array) - 1, bins_array,
                         len(bins_array) - 1, bins_array)
    bkgHistJet3 = r.TH2F('bkgHistJet3', "",
                         len(bins_array) - 1, bins_array,
                         len(bins_array) - 1, bins_array)

    bkgHist2 = r.TH2F('bkgHist2', "", 10000, 0, 1.0, 10000, 0, 1.0)
    bkgHistJet = r.TH2F('bkgHistJet', "", 10000, 0, 1.0, 10000, 0, 1.0)

    distHist3 = r.TH1F('distHist3', "", len(bins_array) - 1, bins_array)

    distHist = r.TGraph()
    distHist_2 = r.TGraph()
    distHist2 = r.TGraph()
    distHist2_2 = r.TGraph()
    distHist4 = r.TGraph()
    distHist4_2 = r.TGraph()
    distHist5 = r.TGraph()
    distHist5_2 = r.TGraph()

    distHist3.SetTitle('; PtHat; weight')

    #     distHist2 = r.TH2F('distHist2', "", len(bins_array)-1, bins_array, len(bins_array)-1, bins_array)

    sigHist = getPtDistribution(sig, sigHist, None, None, 0.0, 'central',
                                False, True)
    sigHistJet1 = getPtDistribution(sig, sigHistJet1, None, None, 30.0,
                                    'central', False, True)
    sigHistJet2 = getPtDistribution(sig, sigHistJet2, None, None, 40.0)
    sigHistJet3 = getPtDistribution(sig, sigHistJet3, None, None, 50.0)

    sigHist.SetTitle('h2#tau#tau; Leading jet Pt; Leading #tau Pt')

    bkgHist, bkgHist2, distHist3 = getPtDistribution(bkg, bkgHist, bkgHist2,
                                                     distHist3, 0.0, 'central',
                                                     False, True)
    bkgHistJet1, bkgHistJet = getPtDistribution(bkg, bkgHistJet1, bkgHistJet,
                                                None, 30.0, 'central', False,
                                                True)
    bkgHistJet2, bkgHistJet = getPtDistribution(bkg, bkgHistJet2, bkgHistJet,
                                                None, 40.0)
    bkgHistJet3, bkgHistJet = getPtDistribution(bkg, bkgHistJet3, bkgHistJet,
                                                None, 50.0)

    bkgHist.SetTitle('QCD; Leading jet Pt; Leading #tau Pt')
    bkgHist2.SetTitle('QCD; 200000*PtHat^{-4.5}; weight')

    getBothDistribution(sigHist, bkgHist, distHist, distHist_2)
    getBothDistribution(sigHist, bkgHist, distHist5, distHist5_2, 5)
    getBothDistribution(sigHist, bkgHist, distHist2, distHist2_2, 10)
    getBothDistribution(sigHist, bkgHist, distHist4, distHist4_2, 15)

    jet1 = r.TGraph()
    jet1_2 = r.TGraph()
    jet2 = r.TGraph()
    jet2_2 = r.TGraph()
    jet3 = r.TGraph()
    jet3_2 = r.TGraph()

    getBothDistribution(sigHistJet1, bkgHistJet1, jet1, jet1_2, 0, 30.5)
    getBothDistribution(sigHistJet2, bkgHistJet2, jet2, jet2_2, 0, 30.5)
    getBothDistribution(sigHistJet3, bkgHistJet3, jet3, jet3_2, 0, 30.5)

    fakeHist1 = r.TH1F()
    fakeHist1.SetMarkerStyle(5)
    fakeHist2 = r.TH1F()
    fakeHist2.SetMarkerStyle(2)
    fakeHist2.SetMarkerColor(r.kBlue)
    fakeHist3 = r.TH1F()
    fakeHist3.SetMarkerStyle(25)
    fakeHist3.SetMarkerColor(r.kRed)
    fakeHist4 = r.TH1F()
    fakeHist4.SetMarkerStyle(32)
    fakeHist4.SetMarkerColor(r.kGreen)
    fakeHist5 = r.TH1F()
    fakeHist5.SetMarkerStyle(5)
    fakeHist5.SetMarkerColor(r.kBlue)
    fakeHist6 = r.TH1F()
    fakeHist6.SetMarkerStyle(5)
    fakeHist6.SetMarkerColor(r.kRed)
    fakeHist7 = r.TH1F()
    fakeHist7.SetMarkerStyle(5)
    fakeHist7.SetMarkerColor(r.kGreen)

    psfile = 'test2.pdf'
    c = r.TCanvas("c", "Test", 600, 600)
    c.SetGrid()
    c.SetFillStyle(4000)
    #     distHist.GetXaxis().SetLimits(0.998,1.00001)
    distHist.GetXaxis().SetLimits(0.999, 1.00001)

    distHist.SetMinimum(0.001)
    distHist.SetMaximum(0.8)

    c.SetLogy()
    distHist.GetXaxis().SetNdivisions(210)
    distHist.Draw("AP")

    distHist.SetMarkerStyle(7)
    distHist.GetYaxis().SetTitleOffset(1.4)
    distHist5.SetMarkerStyle(7)
    distHist5_2.SetMarkerColor(r.kBlue)
    distHist5.SetMarkerColor(r.kBlue)
    #     distHist5.Draw('PSame')

    distHist2.SetMarkerStyle(7)
    distHist2_2.SetMarkerColor(r.kRed)

    distHist2.SetMarkerColor(r.kRed)
    #     distHist2.Draw('PSame')
    distHist4.SetMarkerStyle(7)
    distHist4_2.SetMarkerColor(r.kGreen)
    distHist4.SetMarkerColor(r.kGreen)
    #     distHist4.Draw('PSame')

    distHist_2.SetMarkerStyle(5)
    distHist5_2.SetMarkerStyle(2)
    distHist2_2.SetMarkerStyle(25)
    distHist4_2.SetMarkerStyle(32)

    #     distHist2_2.Draw('PSame')
    #     distHist5_2.Draw('PSame')
    distHist_2.Draw('PSame')
    #     distHist4_2.Draw('PSame')

    jet1.SetMarkerStyle(7)
    jet1.SetMarkerColor(r.kBlue)
    jet1_2.SetMarkerStyle(5)
    jet1_2.SetMarkerColor(r.kBlue)
    jet2.SetMarkerStyle(7)
    jet2.SetMarkerColor(r.kRed)
    jet2_2.SetMarkerStyle(5)
    jet2_2.SetMarkerColor(r.kRed)
    jet3.SetMarkerStyle(7)
    jet3.SetMarkerColor(r.kGreen)
    jet3_2.SetMarkerStyle(5)
    jet3_2.SetMarkerColor(r.kGreen)

    jet1.Draw('PSame')

    jet1_2.Draw('PSame')
    jet2.Draw('PSame')
    jet2_2.Draw('PSame')
    jet3.Draw('PSame')
    jet3_2.Draw('PSame')

    l = tool.setMyLegend(
        lPosition=[0.2, 0.45, 0.5, 0.25],
        lHistList=[
            (fakeHist1, 'same pt cut (tau pt 40)'),
            #                                                                         (fakeHist2, 'leading + 5 (35, 40, 45)'),
            #                                                                         (fakeHist3, 'leading + 10 (35, 40, 45)'),
            #                                                                         (fakeHist4, 'leading + 15 (35, 40, 45)'),
            (fakeHist5, 'same with jet pt 30 (tau pt 30)'),
            (fakeHist6, 'same with jet pt 40 (tau pt 30)'),
            (fakeHist7, 'same with jet pt 50 (tau pt 30)'),
        ])
    l.Draw('same')
    c.Print('%s(' % psfile)
    c.SetLogy(0)

    c.Clear()
    distHist3.Draw()
    c.Print('%s' % psfile)
    c.Clear()

    #     p1 = r.TPad("p1","p1",0.,1,1.,0.0)
    #     p1.SetMargin(0.13, 0.13, 0.13, 0.13)
    #     p1.SetGrid()
    p2 = r.TPad("p1", "p1", 0., 1, 1., 0.0)
    p2.SetMargin(0.13, 0.13, 0.13, 0.13)
    p2.SetGrid()
    #
    # #     p1.Draw()
    # #     p1.cd()
    # #     distHist2.GetXaxis().SetNdivisions(216)
    # #     distHist2.GetYaxis().SetNdivisions(216)
    # #     distHist2.GetYaxis().SetTitleOffset(1.2)
    # #     distHist2.Draw('COLZ')
    # #     c.Print('%s' %psfile)
    # #     c.Clear()
    p2.Draw()
    p2.cd()
    sigHist.Draw('COLZ')
    sigHist.GetYaxis().SetTitleOffset(1.2)
    sigHist.GetXaxis().SetNdivisions(216)
    sigHist.GetYaxis().SetNdivisions(216)
    c.Print('%s' % psfile)
    c.Clear()
    p3 = r.TPad("p1", "p1", 0., 1, 1., 0.0)
    p3.SetMargin(0.13, 0.13, 0.13, 0.13)
    p3.SetGrid()

    p3.Draw()
    p3.cd()
    bkgHist.Draw('COLZ')
    bkgHist.GetYaxis().SetTitleOffset(1.2)
    bkgHist.GetXaxis().SetNdivisions(216)
    bkgHist.GetYaxis().SetNdivisions(216)
    c.Print('%s' % psfile)
    c.Clear()
    bkgHistJet2.Draw('COLZ')
    bkgHistJet2.GetYaxis().SetTitleOffset(1.2)
    bkgHistJet2.GetXaxis().SetNdivisions(216)
    bkgHistJet2.GetYaxis().SetNdivisions(216)
    c.Print('%s' % psfile)
    c.Clear()
    sigHistJet2.Draw('COLZ')
    sigHistJet2.GetYaxis().SetTitleOffset(1.2)
    sigHistJet2.GetXaxis().SetNdivisions(216)
    sigHistJet2.GetYaxis().SetNdivisions(216)

    c.Print('%s)' % psfile)

    c.Close()
コード例 #41
0
def getHistos(varName, signalSelection, logY, sigBoost, nbins, useData, max, rangeMin, rangeMax, location, bTag, predict, predictPtBin, region, thirdLeptonVeto):
    r.gStyle.SetOptStat(0)
    fileList = draw_cfg.MCFileList
    histList = []
    histList_4QCD = []
    QCDHistList = []
    QCDHistList_4KS = []
    QCDHistList_withScale = []
    varRange = [nbins, rangeMin, rangeMax]
    nBins = 10000
    Lumi = 19.7
    initNEventsList = []
    legendHistos = []
    var_background = []

    scaleMCPt = 1.0

    tmpFile = []
    tmpTree = []
    var_data_4KS = []
    var_data = []
    var_data_4QCD = []
    histList_4KS = []

    for i in range(5):
        var_data.append(r.TH1F('data_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        var_data_4KS.append(r.TH1F('data_4KS_%i' %(i),"", nBins, varRange[1], varRange[2]))
        if i < 5:
            var_data_4QCD.append(r.TH1F('data_4QCD_%i' %(i),"", varRange[0], varRange[1], varRange[2]))

    dataName = draw_cfg.dataFile
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' %dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag, region, thirdLeptonVeto)
        if (select == 0) or (select == 1) or (select > 6):
            continue
        var_data[select-2].Fill(varsList.findVar(treeData, varName))
        var_data_4KS[select-2].Fill(varsList.findVar(treeData, varName))
        if select == 2:
            var_data_4QCD[0].Fill(varsList.findVar(treeData, varName), findPtScale(treeData.pt1.at(0),treeData.pt2.at(0), 'left', '%s%s' %(region, bTag)))
        elif select == 3:
            var_data_4QCD[1].Fill(varsList.findVar(treeData, varName), findPtScale(treeData.pt1.at(0),treeData.pt2.at(0), 'up', '%s%s' %(region, bTag)))
        elif select == 4:
            var_data_4QCD[2].Fill(varsList.findVar(treeData, varName), findPtScale(treeData.pt1.at(0),treeData.pt2.at(0), 'left', '%s%s' %(region, bTag)))
            var_data_4QCD[3].Fill(varsList.findVar(treeData, varName), findPtScale(treeData.pt1.at(0),treeData.pt2.at(0), 'up', '%s%s' %(region, bTag)))

    legendHistos.append([])
    for j in range(5):
        var_data[j].SetMarkerStyle(8)
        var_data[j].SetMarkerSize(0.9)
        legendHistos.append([])
        legendHistos[j+1].append((var_data[j], 'observed (%.0f)' %var_data[j].Integral()))

    for i in range(len(fileList)): 
        for j in range(6):
            histList_4KS.append(r.TH1F('%s_%i_KS' %(fileList[i][0],j),fileList[i][0], nBins, varRange[1], varRange[2]))
            histList.append(r.TH1F('%s_%i' %(fileList[i][0],j),fileList[i][0], varRange[0], varRange[1], varRange[2]))
            histList_4QCD.append(r.TH1F('%s_%i_2' %(fileList[i][0],j),fileList[i][0], varRange[0], varRange[1], varRange[2]))
        print 'Adding events from: %s ...' %(fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag, region, thirdLeptonVeto)
            if (not select) or (select > 6):
                continue
            histList[6*i+select-1].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff)
            histList_4KS[6*i+select-1].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff)
            if select == 2:
                histList_4QCD[6*i].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff*findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0), 'left', '%s%s' %(region, bTag)))
            elif select == 3:
                histList_4QCD[6*i+1].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff*findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0), 'up', '%s%s' %(region, bTag)))
            elif select == 4:             
                histList_4QCD[6*i+2].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff*findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0), 'left', '%s%s' %(region, bTag)))
                histList_4QCD[6*i+3].Fill(varsList.findVar(tmpTree[i], varName)*scaleMCPt, tmpTree[i].triggerEff*findPtScale(tmpTree[i].pt1.at(0), tmpTree[i].pt2.at(0), 'up', '%s%s' %(region, bTag)))

        initNEventsList.append(tmpFile[i].Get('preselection'))
        for j in range(6):
            var_background.append(r.THStack())
            histList[6*i+j].SetFillColor(fileList[i][3])
            histList[6*i+j].Scale(fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1))
            histList_4QCD[6*i+j].Scale(fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1))
            histList_4KS[6*i+j].Scale(fileList[i][2]*Lumi/initNEventsList[i].GetBinContent(1))   

            var_background[j].Add(histList[6*i+j])
            legendHistos[j].append((histList[6*i+j], '%s (%.2f)' %(fileList[i][0], histList[6*i+j].Integral())))

    data_i = []
    MC_i = []
    data_r = []
    MC_r = []
    e = []
    MC_List = []
    for i in range(3):
        QCDHistList.append(r.TH1F('QCD_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        QCDHistList_4KS.append(r.TH1F('QCD_%i_KS' %(i),"", nBins, varRange[1], varRange[2]))
        MC_List.append(r.TH1F('MC_total_%i' %(i),"", varRange[0], varRange[1], varRange[2]))

        for j in range(varRange[0]):
            dataValue = var_data[i].GetBinContent(j+1)
            dataError = var_data[i].GetBinError(j+1)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue +=  histList[6*k+1+i].GetBinContent(j+1)
            if i == 0:
                data_i.append(dataValue)
                e.append(dataError)
                MC_i.append(MCValue)
            if i == 2:
                data_r.append(dataValue)
                MC_r.append(MCValue)
            MC_List[i].SetBinContent(j+1, MCValue)
            if dataValue - MCValue > 0:
                QCDHistList[i].SetBinContent(j+1, dataValue - MCValue)
                QCDHistList[i].SetBinError(j+1, dataError)
        MC_List[i].Sumw2()
        for j in range(nBins):
            dataValue4KS = var_data_4KS[i].GetBinContent(j+1)
            MCValue4KS = 0
            for k in range(len(fileList)):
                MCValue4KS += histList_4KS[6*k+1+i].GetBinContent(j+1)
            if dataValue4KS - MCValue4KS > 0:
                QCDHistList_4KS[i].SetBinContent(j+1, dataValue4KS - MCValue4KS)
    ss_t = QCDHistList[0].Integral()
    ss_l = QCDHistList[2].Integral()

    os_l = QCDHistList[1].Integral()
    os_l_data = var_data[1].Integral()
    print "QCD in SS_T: %.4f" %ss_t
    print "QCD in SS_L: %.4f" %ss_l

    print "QCD in OS_L: %.4f" %os_l
    print "Data in OS_L:%.4f" %os_l_data

    print "SF: %.4f" %(ss_t/ss_l)
    print "SF qcd/data: %.4f" %(os_l/os_l_data)


    for i in range(4):
        QCDHistList_withScale.append(r.TH1F('QCD_withScale_%i' %(i),"", varRange[0], varRange[1], varRange[2]))
        for j in range(varRange[0]):
            dataValue = var_data_4QCD[i].GetBinContent(j+1)
            dataError = var_data_4QCD[i].GetBinError(j+1)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue +=  histList_4QCD[6*k+i].GetBinContent(j+1)
            if dataValue - MCValue > 0:
                QCDHistList_withScale[i].SetBinContent(j+1, dataValue - MCValue)

    QCDDiff = r.TH1F('QCD_diff',"", varRange[0], varRange[1], varRange[2])
    QCDDiff2 = r.TH1F('QCD_diff2',"", varRange[0], varRange[1], varRange[2])
    QCDDiff_R2T = r.TH1F('QCDDiff_R2T',"", varRange[0], varRange[1], varRange[2])

#     QCDDiff2.Sumw2()

    fit1 = r.TF1("fit1","[0]", varRange[1],varRange[2])
    fit1.SetParName(0,'scale')
    fit1.FixParameter(0,1.0)

    QCDDiff.Fit('fit1', '0EM')
    fit1.SetLineStyle(2)
    fit1.SetLineColor(r.kRed)
    fit2 = r.TF1("fit2","[0]", varRange[1],varRange[2])
    fit2.SetParName(0,'scale')
    fit2.FixParameter(0,1.0)
    QCDDiff2.Fit('fit2', '0EM')
    fit2.SetLineStyle(2)
    fit2.SetLineColor(r.kRed)


    DrawSignal = False
    if signalSelection != '':
        var_signal = []
        var_signal_4KS = []
        for i in range(6):
            var_signal.append(r.TH1F('%s_%i' %(signalSelection,i),"", varRange[0], varRange[1], varRange[2]))
            var_signal_4KS.append(r.TH1F('%s_%i_4KS' %(signalSelection,i),"", nBins, varRange[1], varRange[2]))
        signalDict = draw_cfg.signalDict
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection][0])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' %(signalDict[signalSelection][0])
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag, region, thirdLeptonVeto)
                if (not select) or (select > 6):
                    continue
                var_signal[select-1].Fill(varsList.findVar(treeSignal, varName), treeSignal.triggerEff)
                var_signal_4KS[select-1].Fill(varsList.findVar(treeSignal, varName), treeSignal.triggerEff)
            initNEventsSignal = fSignal.Get('preselection')
            for i in range(6):
                var_signal[i].SetLineStyle(7)
                var_signal[i].SetLineWidth(4)
                var_signal[i].Scale(signalDict[signalSelection][1]*sigBoost*Lumi/initNEventsSignal.GetBinContent(1))
                if sigBoost != 1:
                    sum = var_signal[i].Integral(0, var_signal[i].GetNbinsX()+1)
                    legendHistos[i].append((var_signal[i], '%sx%0.f (%.2f)' %(signalSelection, sigBoost, var_signal[i].Integral())))
                else:
                    legendHistos[i].append((var_signal[i], '%s (%.2f)' %(signalSelection, var_signal[i].Integral())))
            DrawSignal = True
        else:
            print '%s not supported, please use H260, H300 or H350' %signalSelection

    if predict == 'True':

        scale_SS2OS = fit1.GetParameter(0)
        scale_er_SS2OS = fit1.GetParError(0)
        scale_relaxed2Tight = fit2.GetParameter(0)
        scale_er_relaxed2Tight = fit2.GetParError(0)

        QCDHistList_withScale[0].Scale(scale_SS2OS)
        QCDHistList_withScale[1].Scale(scale_relaxed2Tight)
        QCDHistList_withScale[2].Scale(scale_SS2OS)
        QCDHistList_withScale[3].Scale(scale_relaxed2Tight)

        QCDHistList_withScale[3].SetFillColor(r.kSpring+1)
        QCDHistList_withScale[2].SetFillColor(r.kOrange-4)
        QCDHistList_withScale[0].SetLineColor(r.kSpring+1)
        QCDHistList_withScale[0].SetLineWidth(2)
        QCDHistList_withScale[1].SetLineStyle(2)
        QCDHistList_withScale[1].SetLineColor(r.kOrange-4)
        QCDHistList_withScale[1].SetLineWidth(2)

        legendHistos[0].append((QCDHistList_withScale[0], 'From SS/Tight (%.0f)' %QCDHistList_withScale[0].Integral()))
        legendHistos[0].append((QCDHistList_withScale[1], 'From OS/Relax (%.0f)' %QCDHistList_withScale[1].Integral()))

        var_background[1].Add(QCDHistList_withScale[3])
        var_background[2].Add(QCDHistList_withScale[2])
        legendHistos[1].append((QCDHistList_withScale[3], 'From SS/Relax (%.0f)' %QCDHistList_withScale[3].Integral()))
        legendHistos[2].append((QCDHistList_withScale[2], 'From SS/Relax (%.0f)' %QCDHistList_withScale[2].Integral()))
        QCDHistList_withScale[1] = tool.addFakeTHStack(QCDHistList_withScale[1],var_background[0])
        QCDHistList_withScale[0] = tool.addFakeTHStack(QCDHistList_withScale[0],var_background[0])

#     var_data[1].Sumw2()
#     MC_List[1].Sumw2()
    for i in range(varRange[0]):
        oldValue = var_data[1].GetBinContent(i+1)
        mcValue = MC_List[1].GetBinContent(i+1)
        if oldValue - mcValue > 0:
            QCDDiff2.SetBinContent(i+1, (oldValue - mcValue)/oldValue)
            QCDDiff2.SetBinError(i+1, MC_List[1].GetBinError(i+1)/oldValue)
    print QCDDiff2.Integral()


    QCDDiff = var_data[1].Clone()
    QCDDiff_sub = QCDHistList_withScale[2].Clone() + MC_List[1].Clone()
    QCDDiff.Divide(QCDDiff_sub)

    QCDDiff_R2T = var_data[0].Clone()
    QCDDiff_R2T_sub = QCDHistList_withScale[3].Clone() + MC_List[0].Clone()
    QCDDiff_R2T.Divide(QCDDiff_R2T_sub)



    legendPosition = (0.6, 0.7, 0.90, 0.88)
    l = []
    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == '2M':
        titleName = '2 Medium b-tags'
        fileName = '2MbTag'
    elif bTag == '1M':
        titleName = '1 Medium b-tag'
        fileName = '1MbTag'

    KS1 = QCDHistList_4KS[0].KolmogorovTest(QCDHistList_4KS[2])
    KS2 = QCDHistList_4KS[1].KolmogorovTest(QCDHistList_4KS[2])

    ks_values = []
    tmpHists = []
    ks_values2 = []
    tmpHists2 = []
    nTimes = 10000
#     for i in range(nTimes):
#         tool.printProcessStatus(i, nTimes, processName = 'Making Sample Histograms')
#         tmpHists.append(r.TH1F('tmpHist_%i' %(i),"", nBins, varRange[1], varRange[2]))
#         tmpHists[i].FillRandom(QCDHistList_4KS[2], 100)
#         ks_values.append(QCDHistList_4KS[0].KolmogorovTest(tmpHists[i]))
#         tmpHists2.append(r.TH1F('tmpHist2_%i' %(i),"", nBins, varRange[1], varRange[2]))
#         tmpHists2[i].FillRandom(QCDHistList_4KS[2], 100)
#         ks_values2.append(QCDHistList_4KS[2].KolmogorovTest(tmpHists[i]))
    print ''
    print 'KS Test 1: %.3f' %KS1
    print 'KS Test 2: %.3f' %KS2

    psfile = '%s_%s_%s.pdf' %(varName, fileName, signalSelection)
    c = r.TCanvas("c","Test", 800, 900)
    #ps = r.TPDF(psfile,112)
    c.Divide(2,3)
    drawOpt = ''
    QCDDiff.SetTitle('Data/Background OS Relaxed Events %s (%.1f fb^{-1}); %s; Data/Background' %(titleName, Lumi,varName))
    QCDDiff.SetMarkerStyle(8)
    QCDDiff.SetMarkerSize(0.9)
    QCDDiff.SetMaximum(4)
    QCDDiff.SetMinimum(0)
    QCDDiff_R2T.SetTitle('Data/Background OS Relaxed Events %s (%.1f fb^{-1}); %s; Data/Background' %(titleName, Lumi,varName))
    QCDDiff_R2T.SetMarkerStyle(8)
    QCDDiff_R2T.SetMarkerSize(0.9)
    QCDDiff_R2T.SetMaximum(4)
    QCDDiff_R2T.SetMinimum(0)

    for k in range(6):
        c.cd(k+1)
        r.gPad.SetTicky()
        if k > 1 and logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+1)
        var_background[k].SetTitle('%s %s Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        if k < 2:
            var_background[k].SetMaximum(250)
        else:
            var_background[k].SetMaximum(max)
        var_background[k].SetMinimum(0.01)
        var_background[k].Draw()
        if predict == 'True' and k == 0:
            QCDHistList_withScale[0].Draw('same')
            QCDHistList_withScale[1].Draw('same')
        if k != 0 and useData == 'True':
            var_data[k-1].Draw('PE same')
        legendPosition = (0.63, 0.93 - 0.03*len(legendHistos[k]), 0.93, 0.9)
        l.append(tool.setMyLegend(lPosition=legendPosition, lHistList=legendHistos[k]))
        if k == 1:
            ksLegend1 = tool.setMyLegend((0.3, 0.8, 0.6, 0.9), [(QCDHistList_withScale[3], 'KS Test: %.3f' %KS1)])
            ksLegend1.Draw('same')
        if k == 2:
            ksLegend2 = tool.setMyLegend((0.3, 0.8, 0.6, 0.9), [(QCDHistList_withScale[2], 'KS Test: %.3f' %KS2)])
            ksLegend2.Draw('same')
        l[k].Draw('same')
        var_signal[k].Draw('same')

    c.Update()
    c.cd(5)
    r.gPad.SetLogy(0)
    QCDDiff.Draw('PE')
    fit1.Draw('same')
    c.cd(6)
    r.gPad.SetLogy(0)
    QCDDiff_R2T.Draw('PE')
    fit2.Draw('same')
    c.Update()
    c.Print('%s(' %psfile)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff.Draw('PE')

    fit1.Draw('same')
    lFit1 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fit1,'Scale between OS/SS in relaxed region: %.2f \pm %.2f' %(fit1.GetParameter(0), fit1.GetParError(0)))])
    lFit1.Draw('same')
    for k in range(3):
        c.cd(k+2)
        if logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k+2)
        QCDHistList_withScale[k+1].SetTitle('%s %s Data - MC Events %s (%.1f fb^{-1}); %s; events / bin' %(signSelection, iso, titleName, Lumi,varName))
        QCDHistList_withScale[k+1].SetMarkerStyle(8)
        QCDHistList_withScale[k+1].SetMarkerSize(0.9)
        QCDHistList_withScale[k+1].SetMaximum(max)
        QCDHistList_withScale[k+1].SetMinimum(1)
        QCDHistList_withScale[k+1].Draw('PE')
    c.Update()
    c.Print('%s' %psfile)
    c.cd(1)
    r.gPad.SetLogy(0)
    QCDDiff2.SetTitle('QCD/Data OS Relaxed Events %s (%.1f fb^{-1}); %s; QCD/Data' %(titleName, Lumi,varName))
    QCDDiff2.SetMarkerStyle(8)
    QCDDiff2.SetMarkerSize(0.9)
    QCDDiff2.SetMinimum(0.0)
    QCDDiff2.SetMaximum(1.0)
    QCDDiff2.Draw('PE')
    fit2.Draw('same')
    lFit2 = tool.setMyLegend((0.15, 0.7, 0.9, 0.85),[(fit2,'Scale between relaxed/tight in SS region: %.3f \pm %.3f' %(fit2.GetParameter(0), fit2.GetParError(0)))])
    lFit2.Draw('same')
    c.Update()
    c.Print('%s' %psfile)
#     c.Clear()
#     c.Divide(1,2)
#     c.cd(1)
#     graph = r.TH1F('graph', '', 20, 0, 1.0)
#     graph2 = r.TH1F('graph2', '', 20, 0, 1.0)

#     for i in range(nTimes):
#         tool.printProcessStatus(i, nTimes, processName = 'Plotting Sample Histograms')
#         graph.Fill(ks_values[i])
#         graph2.Fill(ks_values2[i])
#     print ''
#     graph.SetTitle('KS Tests Between SS Tight and Relaxed; KS; ')
#     graph.SetMarkerStyle(8)
#     graph.Draw('PE')
#     c.cd(2)
#     graph2.SetTitle('KS Self-test in SS Relaxed; KS; ')
#     graph2.SetMarkerStyle(8)
#     graph2.Draw('PE')
#     c.Update()
#     c.Print('%s' %psfile)
#     c.Clear()
# 
#     a1 = getAccuDist(QCDHistList_4KS[0], varRange[1], varRange[2], 'SS Tight')
#     a2 = getAccuDist(QCDHistList_4KS[2], varRange[1], varRange[2], 'SS Relax')
#     a1.SetLineColor(r.kRed)
#     l3 = tool.setMyLegend((0.15, 0.75, 0.3, 0.85),[(a1,'SS Tight'),
#                                                   (a2,'SS Relax')])
# 
#     a1.SetTitle('Cumulative Distribution; %s;' %varName)
#     a1.Draw()
#     a2.Draw('same')
#     l3.Draw('same')
    c.Print('%s)' %psfile)
    #ps.Close()
    print "Plot saved at %s" %(psfile)
    c.Close()
コード例 #42
0
    legendPosition = (0.1, 0.2, 0.85, 0.5)
    f.close()


    effList_both[0].SetTitle('Background Rejection VS Signal Efficiency (%s); Signal Efficiency; Background Rejection' %massPoint)
    effList_both[0].SetMinimum(0.5)
    effList_both[0].GetXaxis().SetRangeUser(0.5, 1)
    effList_both[0].Draw('L')
    for j in range(1, len(iFileList)):
        effList_both[j].Draw('sameL')
    line = r.TLine(0.8, 0.5, 0.8, 1)
    line.SetLineColor(r.kRed)
    line.SetLineStyle(2)
    line.Draw('same')

    l.append(tool.setMyLegend(legendPosition, lHistList2))
    l[iMassPoint].Draw('same')
    for j in range(0, len(ROCCurves)):
        ROCCurves[j].Draw('PLsame')
    c.Update()
    if massPoint == massPoints[0]:
        c.Print('%s(' %psfile)
    elif massPoint == massPoints[len(massPoints)-1]:
        c.Print('%s' %psfile)
        c.Clear()
        bkgEffs[0].SetTitle('Bkg Efficiency with Sig Efficency at %.2f; H Mass; Background Efficiency' %sigEff)

        bkgEffs[0].Draw('APL')
        bkgEffs[0].SetMinimum(0.00)
        bkgEffs[0].SetMaximum(0.2)
        for j in range(1, len(iFileList)):
コード例 #43
0
def getHistos(varName, signalSelection, logY, sigBoost, nbins, useData, max,
              rangeMin, rangeMax, location, bTag, predict, predictPtBin,
              region, thirdLeptonVeto, SF, yMax, relaxedRegionOption, usePU):
    r.gStyle.SetOptStat(0)
    SF = float(SF)
    fileList = draw_cfg.MCFileList
    histList = []
    histList_4QCD = []
    QCDHistList = []
    QCDHistList_4KS = []
    QCDHistList_withScale = []
    varRange = [nbins, rangeMin, rangeMax]
    nBins = 10000
    Lumi = 19.7
    legendHistos = []
    var_background = []
    scaleMCPt = 1.0
    tmpFile = []
    tmpTree = []
    var_data_4KS = []
    var_data = []
    var_data_4QCD = []
    histList_4KS = []
    MC_Counts_0 = 0.0
    MC_Counts_1 = 0.0
    MC_Counts_2 = 0.0

    for i in range(6):
        var_data.append(
            r.TH1F('data_%i' % (i), "", varRange[0], varRange[1], varRange[2]))
        var_data_4KS.append(
            r.TH1F('data_4KS_%i' % (i), "", nBins, varRange[1], varRange[2]))
        if i < 5:
            var_data_4QCD.append(
                r.TH1F('data_4QCD_%i' % (i), "", varRange[0], varRange[1],
                       varRange[2]))

    dataName = draw_cfg.dataFile
    fData = r.TFile(dataName)
    treeData = fData.Get('eventTree')
    print 'Adding events from: %s ...' % dataName
    for iEntry in range(treeData.GetEntries()):
        treeData.GetEntry(iEntry)
        select = passCut(treeData, bTag, region, thirdLeptonVeto,
                         relaxedRegionOption)
        if (select == 0) or (select > 6):
            continue
        if (select == 1) and dontUnblind(treeData):
            continue
        var_data[select - 1].Fill(varsList.findVar(treeData, varName))
        if (select != 1):
            var_data_4KS[select - 2].Fill(varsList.findVar(treeData, varName))
        if select == 2:
            var_data_4QCD[0].Fill(varsList.findVar(treeData, varName), 1.0)
        elif select == 3:
            var_data_4QCD[1].Fill(varsList.findVar(treeData, varName), SF)
        elif select == 4:
            var_data_4QCD[2].Fill(varsList.findVar(treeData, varName), 1.0)
            var_data_4QCD[3].Fill(varsList.findVar(treeData, varName), SF)

    legendHistos.append([])
    for j in range(6):
        var_data[j].SetMarkerStyle(8)
        var_data[j].SetMarkerSize(0.9)
        legendHistos.append([])
        integral = 'observed'
        if j != 0 or (region != 'tight') or (bTag == 'None'):
            integral = 'observed (%.0f)' % var_data[j].Integral(
                0, varRange[0] + 1)
        legendHistos[j].append((var_data[j], integral))

    for i in range(len(fileList)):
        for j in range(6):
            histList_4KS.append(
                r.TH1F('%s_%i_KS' % (fileList[i][0], j), fileList[i][0], nBins,
                       varRange[1], varRange[2]))
            histList.append(
                r.TH1F('%s_%i' % (fileList[i][0], j), fileList[i][0],
                       varRange[0], varRange[1], varRange[2]))
            histList_4QCD.append(
                r.TH1F('%s_%i_2' % (fileList[i][0], j), fileList[i][0],
                       varRange[0], varRange[1], varRange[2]))
        print 'Adding events from: %s ...' % (fileList[i][1])
        tmpFile.append(r.TFile(fileList[i][1]))
        tmpTree.append(tmpFile[i].Get('eventTree'))
        for iEntry in range(tmpTree[i].GetEntries()):
            tmpTree[i].GetEntry(iEntry)
            select = passCut(tmpTree[i], bTag, region, thirdLeptonVeto,
                             relaxedRegionOption)
            if (not select) or (select > 6):
                continue
            if usePU:
                allWeights = tmpTree[i].triggerEff * tmpTree[i].PUWeight
            else:
                allWeights = tmpTree[i].triggerEff
            histList[6 * i + select - 1].Fill(
                varsList.findVar(tmpTree[i], varName),
                allWeights * tmpTree[i].xs / (tmpTree[i].initEvents))
            histList_4KS[6 * i + select - 1].Fill(
                varsList.findVar(tmpTree[i], varName),
                allWeights * tmpTree[i].xs / (tmpTree[i].initEvents))
            if select == 2:
                histList_4QCD[6 * i].Fill(
                    varsList.findVar(tmpTree[i], varName),
                    allWeights * 1.0 * tmpTree[i].xs / (tmpTree[i].initEvents))
            elif select == 3:
                histList_4QCD[6 * i + 1].Fill(
                    varsList.findVar(tmpTree[i], varName),
                    allWeights * SF * tmpTree[i].xs / (tmpTree[i].initEvents))
            elif select == 4:
                histList_4QCD[6 * i + 2].Fill(
                    varsList.findVar(tmpTree[i], varName),
                    allWeights * 1.0 * tmpTree[i].xs / (tmpTree[i].initEvents))
                histList_4QCD[6 * i + 3].Fill(
                    varsList.findVar(tmpTree[i], varName),
                    allWeights * SF * tmpTree[i].xs / (tmpTree[i].initEvents))

        for j in range(6):
            var_background.append(r.THStack())
            histList[6 * i + j].SetFillColor(fileList[i][2])
            histList[6 * i + j].Scale(Lumi)
            histList_4QCD[6 * i + j].Scale(Lumi)
            histList_4KS[6 * i + j].Scale(Lumi)
            var_background[j].Add(histList[6 * i + j])
            legendHistos[j].append(
                (histList[6 * i + j],
                 '%s (%.2f)' % (fileList[i][0], histList[6 * i + j].Integral(
                     0, varRange[0] + 1))))

    data_i = []
    MC_i = []
    data_r = []
    MC_r = []
    e = []
    MC_List = []
    for i in range(3):
        QCDHistList.append(
            r.TH1F('QCD_%i' % (i), "", varRange[0], varRange[1], varRange[2]))
        QCDHistList_4KS.append(
            r.TH1F('QCD_%i_KS' % (i), "", nBins, varRange[1], varRange[2]))
        MC_List.append(
            r.TH1F('MC_total_%i' % (i), "", varRange[0], varRange[1],
                   varRange[2]))

        for j in range(varRange[0] + 2):
            dataValue = var_data[i + 1].GetBinContent(j)
            dataError = var_data[i + 1].GetBinError(j)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue += histList[6 * k + 1 + i].GetBinContent(j)
            if i == 0:
                data_i.append(dataValue)
                e.append(dataError)
                MC_i.append(MCValue)
            if i == 2:
                data_r.append(dataValue)
                MC_r.append(MCValue)
            MC_List[i].SetBinContent(j, MCValue)
            if dataValue - MCValue > 0:
                QCDHistList[i].SetBinContent(j, dataValue - MCValue)
                QCDHistList[i].SetBinError(j, dataError)
        MC_List[i].Sumw2()
        for j in range(nBins + 2):
            dataValue4KS = var_data_4KS[i].GetBinContent(j)
            MCValue4KS = 0
            for k in range(len(fileList)):
                MCValue4KS += histList_4KS[6 * k + 1 + i].GetBinContent(j)
            if dataValue4KS - MCValue4KS > 0:
                QCDHistList_4KS[i].SetBinContent(j, dataValue4KS - MCValue4KS)

    ss_t = QCDHistList[0].Integral(0, varRange[0] + 1)
    ss_l = QCDHistList[2].Integral(0, varRange[0] + 1)

    os_l = QCDHistList[1].Integral(0, varRange[0] + 1)
    os_l_data = var_data[2].Integral(0, varRange[0] + 1)
    print "QCD in SS_T: %.4f" % ss_t
    print "QCD in SS_L: %.4f" % ss_l

    print "QCD in OS_L: %.4f" % os_l
    print "Data in OS_L:%.4f" % os_l_data

    print "SF: %.4f" % (ss_t / ss_l)
    print "SF qcd/data: %.4f" % (os_l / os_l_data)

    for i in range(4):
        QCDHistList_withScale.append(
            r.TH1F('QCD_withScale_%i' % (i), "", varRange[0], varRange[1],
                   varRange[2]))
        for j in range(varRange[0] + 2):
            dataValue = var_data_4QCD[i].GetBinContent(j)
            dataError = var_data_4QCD[i].GetBinError(j)
            MCValue = 0
            for k in range(len(fileList)):
                MCValue += histList_4QCD[6 * k + i].GetBinContent(j)
            if dataValue - MCValue > 0:
                QCDHistList_withScale[i].SetBinContent(j, dataValue - MCValue)

    QCDDiff = r.TH1F('QCD_diff', "", varRange[0], varRange[1], varRange[2])
    QCDDiff2 = r.TH1F('QCD_diff2', "", varRange[0], varRange[1], varRange[2])
    QCDDiff_R2T = r.TH1F('QCDDiff_R2T', "", varRange[0], varRange[1],
                         varRange[2])

    #     QCDDiff2.Sumw2()

    fit1 = r.TF1("fit1", "[0]", varRange[1], varRange[2])
    fit1.SetParName(0, 'scale')
    fit1.FixParameter(0, 1.0)

    QCDDiff.Fit('fit1', '0EM')
    fit1.SetLineStyle(2)
    fit1.SetLineColor(r.kRed)
    fit2 = r.TF1("fit2", "[0]", varRange[1], varRange[2])
    fit2.SetParName(0, 'scale')
    fit2.FixParameter(0, 1.0)
    QCDDiff2.Fit('fit2', '0EM')
    fit2.SetLineStyle(2)
    fit2.SetLineColor(r.kRed)

    DrawSignal = False
    if signalSelection != '':
        var_signal = []
        var_signal_4KS = []
        for i in range(6):
            var_signal.append(
                r.TH1F('%s_%i' % (signalSelection, i), "", varRange[0],
                       varRange[1], varRange[2]))
            var_signal_4KS.append(
                r.TH1F('%s_%i_4KS' % (signalSelection, i), "", nBins,
                       varRange[1], varRange[2]))
        signalDict = draw_cfg.signalDict
        if signalSelection in signalDict:
            fSignal = r.TFile(signalDict[signalSelection])
            treeSignal = fSignal.Get('eventTree')
            print 'Adding events from: %s ...' % (signalDict[signalSelection])
            for iEntry in range(treeSignal.GetEntries()):
                treeSignal.GetEntry(iEntry)
                select = passCut(treeSignal, bTag, region, thirdLeptonVeto,
                                 relaxedRegionOption)
                if (not select) or (select > 6):
                    continue
                if usePU:
                    allWeights = treeSignal.triggerEff * treeSignal.PUWeight
                else:
                    allWeights = treeSignal.triggerEff
                var_signal[select - 1].Fill(
                    varsList.findVar(treeSignal, varName),
                    allWeights * treeSignal.xs / (treeSignal.initEvents))
                var_signal_4KS[select - 1].Fill(
                    varsList.findVar(treeSignal, varName),
                    allWeights * treeSignal.xs / (treeSignal.initEvents))
            initNEventsSignal = fSignal.Get('preselection')
            for i in range(6):
                var_signal[i].SetLineStyle(7)
                var_signal[i].SetLineWidth(4)
                var_signal[i].Scale(sigBoost * Lumi)
                if sigBoost != 1:
                    sum = var_signal[i].Integral(0,
                                                 var_signal[i].GetNbinsX() + 1)
                    legendHistos[i].append(
                        (var_signal[i], '%sx%0.f (%.2f)' %
                         (signalSelection, sigBoost, var_signal[i].Integral(
                             0, varRange[0] + 1))))
                else:
                    legendHistos[i].append(
                        (var_signal[i], '%s (%.2f)' %
                         (signalSelection, var_signal[i].Integral(
                             0, varRange[0] + 1))))
            DrawSignal = True
        else:
            print '%s not supported, please use H260, H300 or H350' % signalSelection

    scale_SS2OS = fit1.GetParameter(0)
    scale_er_SS2OS = fit1.GetParError(0)
    scale_relaxed2Tight = fit2.GetParameter(0)
    scale_er_relaxed2Tight = fit2.GetParError(0)

    QCDHistList_withScale[0].Scale(scale_SS2OS)
    QCDHistList_withScale[1].Scale(scale_relaxed2Tight)
    QCDHistList_withScale[2].Scale(scale_SS2OS)
    QCDHistList_withScale[3].Scale(scale_relaxed2Tight)

    QCDHistList_withScale[3].SetFillColor(r.TColor.GetColor(250, 202, 255))
    QCDHistList_withScale[2].SetFillColor(r.TColor.GetColor(250, 202, 255))
    QCDHistList_withScale[0].SetLineColor(r.TColor.GetColor(250, 202, 255))
    QCDHistList_withScale[0].SetLineWidth(2)
    QCDHistList_withScale[1].SetLineStyle(2)
    QCDHistList_withScale[1].SetLineColor(r.TColor.GetColor(250, 202, 255))
    QCDHistList_withScale[1].SetLineWidth(2)

    var_background[1].Add(QCDHistList_withScale[3])
    var_background[2].Add(QCDHistList_withScale[2])
    legendHistos[1].append(
        (QCDHistList_withScale[3],
         'QCD (%.2f)' % QCDHistList_withScale[3].Integral(0, varRange[0] + 1)))
    legendHistos[2].append(
        (QCDHistList_withScale[2],
         'QCD (%.2f)' % QCDHistList_withScale[2].Integral(0, varRange[0] + 1)))
    allStacked = var_background[0].Clone()
    QCDPredict = QCDHistList_withScale[1].Clone()
    QCDPredict.SetLineStyle(1)
    QCDPredict.SetLineWidth(1)

    QCDPredict.SetLineColor(r.kBlack)
    legendHistos[0].append((QCDPredict, 'QCD (%.0f, SF = %.3f)' %
                            (QCDPredict.Integral(0, varRange[0] + 1), SF)))

    QCDPredict.SetFillColor(r.TColor.GetColor(250, 202, 255))
    allStacked.Add(QCDPredict)

    QCDHistList_withScale[1] = tool.addFakeTHStack(QCDHistList_withScale[1],
                                                   var_background[0])
    QCDHistList_withScale[0] = tool.addFakeTHStack(QCDHistList_withScale[0],
                                                   var_background[0])
    #     var_data[1].Sumw2()
    #     MC_List[1].Sumw2()
    for i in range(varRange[0]):
        oldValue = var_data[2].GetBinContent(i + 1)
        mcValue = MC_List[1].GetBinContent(i + 1)
        if oldValue - mcValue > 0:
            QCDDiff2.SetBinContent(i + 1, (oldValue - mcValue) / oldValue)
            QCDDiff2.SetBinError(i + 1,
                                 MC_List[1].GetBinError(i + 1) / oldValue)
    print QCDDiff2.Integral(0, varRange[0] + 1)

    QCDDiff = var_data[2].Clone()
    QCDDiff_sub = QCDHistList_withScale[2].Clone() + MC_List[1].Clone()
    QCDDiff.Divide(QCDDiff_sub)

    QCDDiff_R2T = var_data[1].Clone()
    QCDDiff_R2T_sub = QCDHistList_withScale[3].Clone() + MC_List[0].Clone()
    QCDDiff_R2T.Divide(QCDDiff_R2T_sub)

    legendPosition = (0.6, 0.7, 0.90, 0.88)
    l = []
    r.gROOT.SetBatch(True)  # to suppress canvas pop-outs
    if bTag == 'True':
        titleName = '1 Medium 1 Loose b-tag'
        fileName = 'bTag'
    elif bTag == 'False':
        titleName = ''
        fileName = 'all'
    elif bTag == '2M':
        titleName = '2 Medium b-tags'
        fileName = '2MbTag'
    elif bTag == '1M':
        titleName = '1 Medium b-tag'
        fileName = '1MbTag'
    elif bTag == '1M1NonM':
        titleName = '1 Medium 1 Anti-Medium b-tag'
        fileName = '1M1NonMbTag'
    elif bTag == 'None':
        titleName = '0 b-tag'
        fileName = '0bTag'

    KS1 = QCDHistList_4KS[0].KolmogorovTest(QCDHistList_4KS[2])
    KS2 = QCDHistList_4KS[1].KolmogorovTest(QCDHistList_4KS[2])

    ks_values = []
    tmpHists = []
    ks_values2 = []
    tmpHists2 = []
    nTimes = 10000
    #     for i in range(nTimes):
    #         tool.printProcessStatus(i, nTimes, processName = 'Making Sample Histograms')
    #         tmpHists.append(r.TH1F('tmpHist_%i' %(i),"", nBins, varRange[1], varRange[2]))
    #         tmpHists[i].FillRandom(QCDHistList_4KS[2], 100)
    #         ks_values.append(QCDHistList_4KS[0].KolmogorovTest(tmpHists[i]))
    #         tmpHists2.append(r.TH1F('tmpHist2_%i' %(i),"", nBins, varRange[1], varRange[2]))
    #         tmpHists2[i].FillRandom(QCDHistList_4KS[2], 100)
    #         ks_values2.append(QCDHistList_4KS[2].KolmogorovTest(tmpHists[i]))
    print ''
    print 'KS Test 1: %.3f' % KS1
    print 'KS Test 2: %.3f' % KS2
    fakeHist = r.TH1F()
    fakeHist.SetLineColor(0)
    usePUWeightName = ''
    if usePU:
        usePUWeightName = '_usePU'
    psfile = '%s_%s_%s_%s_%s%s.pdf' % (varName, fileName, signalSelection,
                                       region, relaxedRegionOption,
                                       usePUWeightName)
    c = r.TCanvas("c", "Test", 800, 900)
    #ps = r.TPDF(psfile,112)
    c.Divide(2, 3)
    drawOpt = ''
    QCDDiff.SetTitle(
        'Data/Background OS Relaxed Events %s (%.1f fb^{-1}); %s; Data/Background'
        % (titleName, Lumi, varName))
    QCDDiff.SetMarkerStyle(8)
    QCDDiff.SetMarkerSize(0.9)
    QCDDiff.SetMaximum(4)
    QCDDiff.SetMinimum(0)
    QCDDiff_R2T.SetTitle(
        'Data/Background OS Relaxed Events %s (%.1f fb^{-1}); %s; Data/Background'
        % (titleName, Lumi, varName))
    QCDDiff_R2T.SetMarkerStyle(8)
    QCDDiff_R2T.SetMarkerSize(0.9)
    QCDDiff_R2T.SetMaximum(4)
    QCDDiff_R2T.SetMinimum(0)

    pl_1 = r.TPad("pl_1", "pl_1", 0., 1, 0.5, 0.65)
    pl_1_delta = r.TPad("pl_1_delta", "pl_1_delta", 0., 0.65, 0.5, 0.45)
    pl_2 = r.TPad("pl_2", "pl_2", 0., 0.45, 0.5, 0.0)
    pl_1.SetMargin(1, 1, 0, 1)
    pl_1_delta.SetMargin(1, 1, 0.2, 0.05)

    pr_1 = r.TPad("pr_1", "pr_1", 0.5, 1, 1., 0.65)
    pr_1_delta = r.TPad("pr_1_delta", "pr_1_delta", 0.5, 0.65, 1.0, 0.45)
    pr_2 = r.TPad("pr_2", "pr_2", 0.5, 0.45, 1.0, 0.0)
    pr_1.SetMargin(1, 1, 0, 1)
    pr_1_delta.SetMargin(1, 1, 0.2, 0.05)

    pl_1.Draw()
    pl_1_delta.Draw()
    pl_2.Draw()
    pr_1.Draw()
    pr_1_delta.Draw()
    pr_2.Draw()

    pl_1.cd()
    r.gPad.SetTicky()
    signSelection, iso = conditions(1, region)
    allStacked.SetMaximum(int(yMax))
    allStacked.SetTitle(
        'CMS Preliminary %.1f fb^{-1} at 8 TeV; %s; events / bin' %
        (Lumi, varName))
    allStacked.Draw()
    var_data[0].Draw('PE same')
    legendPosition = (0.43, 0.9 - 0.06 * len(legendHistos[0]), 0.87, 0.9)
    l.append(
        tool.setMyLegend(lPosition=legendPosition,
                         lHistList=getNewLegend(legendHistos[0], fakeHist)))
    l[0].Draw('same')
    var_signal[0].Draw('same')

    pl_1_delta.cd()
    r.gPad.SetTicky()
    r.gPad.SetTickx()
    pl_1_delta.SetGridy(1)
    bkgEst = QCDHistList_withScale[1].Clone()
    delta = var_data[0].Clone()
    delta.Sumw2()
    bkgEst.Sumw2()
    delta.Divide(bkgEst)
    delta.SetMinimum(0.5)
    delta.SetMaximum(1.5)
    delta.GetXaxis().SetTitle(varName)
    delta.GetXaxis().SetLabelSize(0.07)
    delta.GetXaxis().SetTitleSize(0.07)
    delta.GetYaxis().SetLabelSize(0.07)
    delta.GetYaxis().SetNdivisions(5, 5, 0)
    delta.Draw()

    pList = [pr_1, pl_2, pr_2]

    for k in range(1, len(pList) + 1):
        pList[k - 1].cd()
        r.gPad.SetTicky()
        if k > 1 and logY == 'True':
            r.gPad.SetLogy()
        signSelection, iso = conditions(k + 1, region)
        var_background[k].SetTitle(
            '%s %s Events %s (%.1f fb^{-1}); %s; events / bin' %
            (signSelection, iso, titleName, Lumi, varName))
        if k < 2:
            var_background[k].SetMaximum(int(yMax))
        else:
            var_background[k].SetMaximum(max)
        var_background[k].SetMinimum(0.01)
        var_background[k].Draw()
        if useData == 'True':
            var_data[k].Draw('PE same')
        legendPosition = (0.47, 0.9 - 0.06 * len(legendHistos[k]), 0.87, 0.9)
        l.append(
            tool.setMyLegend(lPosition=legendPosition,
                             lHistList=getNewLegend(legendHistos[k],
                                                    fakeHist)))
        if k == 1:
            ksLegend1 = tool.setMyLegend(
                (0.2, 0.8, 0.5, 0.9),
                [(QCDHistList_withScale[3], 'KS Test: %.3f' % KS1)])
            ksLegend1.Draw('same')
        if k == 2:
            ksLegend2 = tool.setMyLegend(
                (0.2, 0.8, 0.5, 0.9),
                [(QCDHistList_withScale[2], 'KS Test: %.3f' % KS2)])
            ksLegend2.Draw('same')
        l[k].Draw('same')
        var_signal[k].Draw('same')

    pr_1_delta.cd()
    r.gPad.SetTicky()
    r.gPad.SetTickx()
    pr_1_delta.SetGridy(1)
    bkgEst2 = QCDHistList_withScale[3].Clone()
    delta2 = var_data[1].Clone()
    delta2.Sumw2()
    bkgEst2.Sumw2()
    delta2.Divide(bkgEst2)
    delta2.SetMinimum(0.5)
    delta2.SetMaximum(1.5)
    delta2.GetXaxis().SetTitle(varName)
    delta2.GetXaxis().SetLabelSize(0.07)
    delta2.GetXaxis().SetTitleSize(0.07)
    delta2.GetYaxis().SetLabelSize(0.07)
    delta2.GetYaxis().SetNdivisions(5, 5, 0)
    delta2.Draw()

    c.Update()
    c.Print('%s(' % psfile)

    c.Clear()

    p1 = r.TPad("p1", "p1", 0., 1, 1., 0.4)
    p1_r = r.TPad("p1_r", "p1_r", 0., 0.39, 1., 0.06)
    p1.SetMargin(1, 1, 0, 1)
    p1_r.SetMargin(1, 1, 0.2, 1)

    p1.Draw()
    p1_r.Draw()
    p1.cd()
    r.gPad.SetTicky()
    allStacked.Draw()

    var_data[0].Draw('PE same')
    l[0].Draw('same')
    var_signal[0].Draw('same')

    p1_r.cd()
    r.gPad.SetTicky()
    r.gPad.SetTickx()
    p1_r.SetGridy(1)

    delta.Draw()
    c.Print('%s)' % psfile)

    print "Plot saved at %s" % (psfile)
    c.Close()