def eff_stuff(h, fs, *xrng):
print "analysis.eff_stuff()"
# some other plots
h1loc = h["pas"].Clone()
h2loc = h["tot"].Clone()
print h1loc, h2loc
h1loc = aux.rebin(h1loc, range(100,201,100))
h2loc = aux.rebin(h2loc, range(100,201,100))
if rt.TEfficiency.CheckConsistency(h1loc, h2loc):
print "consistency checked!"
eff = rt.TEfficiency(h1loc, h2loc)
egraph = eff.CreateGraph()
#egraph.Fit(f, "r")
#fmin = f.GetMinimumX()
#fmax = f.GetMaximumX()
#pmin = (f.Eval(fmin-fmin/2.))
#pmax = (f.Eval(fmax+fmax/2.))
pmin = 0.005
pmax = 0.045
#print "xrng: ", xrng[0][0], xrng[0][1]
if xrng:
egraph.GetXaxis().SetRangeUser(xrng[0][0],xrng[0][1]);
if pmin < pmax:
egraph.SetMinimum(pmin)
egraph.SetMaximum(pmax)
if pmin >= pmax:
egraph.SetMinimum(pmax)
egraph.SetMaximum(pmin)
csize = 800
name = h1loc.GetName() + "_" + h2loc.GetName()
egraph.SetTitle(name)
c = rt.TCanvas("c_"+name,"c_"+name,csize,csize)
c.cd()
egraph.Draw("ap")
#f.Draw("same")
c.Update()
fs.save(c, name)
else:
print "not consistent"
def rebin(self, binEdges):
self.initial = aux.rebin(self.initial, binEdges)
self.target = aux.rebin(self.target, binEdges)
# strange trick:
# clear the overflow bin to avoid strange binning effects
#self.initial.ClearUnderflowAndOverflow()
#self.target.ClearUnderflowAndOverflow()
#if self.h:
# for entry in self.h:
# entry= aux.rebin(entry, binEdges)
return 0
def closure():
# genmatch for e->e and e->g, without Ht100To200 bin
filename = "/user/rmeyer/Dropbox/data_uni/root_selectorFiles/myTestSelector_closureWJetsToLNu__1466503598.root"
# no genmatch for e->e, only leading em object
filename = "/user/rmeyer/Dropbox/data_uni/root_selectorFiles/myTestSelector_closureWJetsToLNu__1466514536.root"
# nur barrell
filename = "/user/rmeyer/Dropbox/data_uni/root_selectorFiles/myTestSelector_closureWJetsToLNu__1466514983.root"
# drell yan
#filename = "/user/rmeyer/Dropbox/data_uni/root_selectorFiles/myTestSelector_closureDY__1466515252.root"
data = rt.TFile(filename)
g = data.Get("clos_gen_g")
e = data.Get("clos_gen_e")
f = 0.0107
f = 0.0077
edges = [50., 60., 70., 70., 80., 90., 100., 120., 140., 160., 250.]
#edges = [40., 250.]
g = aux.rebin(g, edges)
e = aux.rebin(e, edges)
#g.Rebin(10)
#e.Rebin(10)
print "predicted: ", e.Integral()*f/(1-f)
print "matched: ", g.Integral()
e.Scale(f/(1-f))
e.SetMarkerColor(rt.kRed)
g.SetMarkerColor(rt.kBlack)
e.SetMarkerStyle(rt.kFullCircle)
g.SetMarkerStyle(rt.kFullSquare)
# empty histogram
#h = rt.TH1F("h", "h", len(edges)-1, array( 'd', edges ))
### create ratio
#def ratio_hishis(h1, h2):
##returns h1/h2
ratio = aux.ratio_hishis(g, e)
ratio.GetYaxis().SetLabelSize(0.065)
ratio.GetYaxis().SetTitle("gen./pred.")
ratio.GetYaxis().SetTitleSize(0.08)
ratio.GetYaxis().SetTitleOffset(0.5)
ratio.GetXaxis().SetLabelSize(0.)
ratio.GetXaxis().SetTitleSize(0.)
l = rt.TLegend(0.5,0.7,0.9,0.9);
l.AddEntry(g, "N_{e#rightarrow#gamma}", "ep")
l.AddEntry(e, "N_{e#rightarrowe} * f/(1-f)", "ep")
c = rt.TCanvas("c", "c", 700, 700)
c.cd()
p1 = rt.TPad("p1", "p1", 0., 0.3, 1., 1.)
p1.SetLeftMargin(0.12)
p1.Draw()
p1.cd()
g.Draw("ep")
e.Draw("ep same")
l.Draw()
c.cd()
p2 = rt.TPad("p2", "p2", 0., 0.01, 1., 0.3)
p2.SetLeftMargin(0.12)
p2.SetGridy()
p2.Draw()
p2.cd()
ratio.Draw("ep")
raw_input()
return 0
def rebin(self, binEdges):
p = self.pas.Clone()
t = self.tot.Clone()
self.pas = aux.rebin(p, binEdges)
self.tot = aux.rebin(t, binEdges)
return 0
def tagnprobe_new():
print "gen_tp_debugging.tagnprobe_new()"
#rt.gROOT.Reset()
rt.gROOT.SetBatch(rt.kTRUE) # dont show the canvases
plotfilename = "debugging.root"
_fm = fm.FileManager()
tstr = str(dt.datetime.now()).replace(" ", "_").replace(":","-").split(".")[0]
fs = fm.FileSaver(plotfilename,tstr,_fm)
#filename = "myTestSelector_DY_debug_genMatchTagnProbe_1458133145.root"
#filename = "myTestSelector_DY_debug_genMatchTagnProbe_1458257495.root"
#filename = "myTestSelector_DY_debug_genMatchTagnProbe_1458263936.root"
#filename = "myTestSelector_DY_debug_genMatchTagnProbe_1458270353.root"
#filename = "myTestSelector_DY_debug_genMatchTagnProbe_1458271176.root"
#filename = "myTestSelector_DY_debug_genMatchTagnProbe_1458273497.root"
#filename = "myTestSelector_NEW_tnp_forPlots_1460026482.root"
#filename = "myTestSelector_NEW_tnp_forPlots_1460033048.root"
#filename = "myTestSelector_NEW_tnp_forPlots_1460036199.root"
#filename = "myTestSelector_NEW_tnp_forPlots_1460036586.root"
#filename = "myTestSelector_NEW_tnp_forPlots_1460040961.root"
#filename = "myTestSelector_NEW_tnp_forPlots_1460042765.root"
#filename = "myTestSelector_NEW_tnp_forPlots_1460048500.root"
#filename = "myTestSelector_NEW_tnp_forPlots_1460109853.root"
filename = "myTestSelector_NEW_tnp_forPlots_1460109853.root"
h, h2, h3 = _fm.loadfile(filename)
tnp_ee = h2["tnp_ee"].Clone() # pt dependency
tnp_eg = h2["tnp_eg"].Clone()
tnp_ee_ntracks = h2["tnp_ee_ntracks"].Clone()
tnp_eg_ntracks = h2["tnp_eg_ntracks"].Clone()
tnp_ee_nvtx = h2["tnp_ee_nvtx"].Clone()
tnp_eg_nvtx = h2["tnp_eg_nvtx"].Clone()
tnp_ee_eta = h2["tnp_ee_eta"].Clone()
tnp_eg_eta = h2["tnp_eg_eta"].Clone()
samplename = "DYJetsToLL"
strClosure = "_perbin"
'''
# closure on wgamma sample
#filename = "myTestSelector_WG_debug_genMatchTagnProbe_1458286818.root"
if "WG" in filename:
strClosure = "_perbin_wg"
samplename = "WGToLNuG"
del h
del h2
del h3
h, h2, h3 = _fm.loadfile(filename)
# '''
clos_e = h["clos_gen_e"]
clos_g = h["clos_gen_g"]
clos_e_ntracks = h["clos_gen_e_ntracks"]
clos_g_ntracks = h["clos_gen_g_ntracks"]
clos_e_nvtx = h["clos_gen_e_nvtx"]
clos_g_nvtx = h["clos_gen_g_nvtx"]
clos_e_eta = h["clos_gen_e_eta"]
clos_g_eta = h["clos_gen_g_eta"]
# '''
# BINNINGS
#ss = "1bin_" # for the plots
ss = "_1bin"
#pt_binning = range(40, 60, 5)+range(60, 100, 10)+range(100, 200+1, 20)
pt_binning = range(40, 201, 160)
print "pt_binning: ", pt_binning
#ntracks_binning = range(0, 200+1, 10)
ntracks_binning = range(0, 200+1, 200)
print "ntracks_binning: ", ntracks_binning
#nvtx_binning = range(0, 30+1, 1)
nvtx_binning = range(0, 30+1, 30)
print "nvtx_binning: ", nvtx_binning
#eta_binning = range(0, 150+1, 10)
eta_binning = range(0, 150+1, 150)
for i in range(len(eta_binning)):
eta_binning[i] = eta_binning[i]*0.01
# #eta_binning[i] = round(eta_binning[i]*0.01, 2)
# CALCULATIONS
# pt:
tnp_ee.Add(tnp_eg)
tpf = h2f.h2Fakerate("pt", tnp_ee, tnp_eg)
tpf.rebin(pt_binning)
#tpf.addFitModel(rt.TF1("tpf", "[0]+[1]/x+[2]/(x*x)", 40, 200))
tpf.addFitModel(rt.TF1("tpf", "[0]", 40, 200))
tpf.fit()
tpcan = h2f.h2FakerateCanvas(tpf)
tpcan.setLabel("Tag n probe")
clos_e = aux.rebin(clos_e, pt_binning)
clos_g = aux.rebin(clos_g, pt_binning)
tpclos = h2f.closure("tagnprobe"+strClosure, clos_e, clos_g)
tpclos.setLabel("Closure on "+samplename)
#tpclos.addFakerate(tpgenf, "Tag n Probe gen info"+strClosure)
tpclos.addFakerate(tpf, "Tag n Probe"+strClosure)
tpclos.createFitPrediction()
tpclos.createHistoPrediction()
# Ntracks:
tnp_ee_ntracks.Add(tnp_eg_ntracks)
tpf_ntracks = h2f.h2Fakerate("ntracks", tnp_ee_ntracks, tnp_eg_ntracks)
tpf_ntracks.rebin(ntracks_binning)
tpf_ntracks.addFitModel(rt.TF1("tpf_ntracks", "[0]+[1]*x+[2]*x*x", 0, 200))
tpf_ntracks.fit()
tpcan_ntracks = h2f.h2FakerateCanvas(tpf_ntracks)
tpcan_ntracks.setLabel("Tag n probe")
clos_e_ntracks = aux.rebin(clos_e_ntracks, ntracks_binning)
clos_g_ntracks = aux.rebin(clos_g_ntracks, ntracks_binning)
tpclos_ntracks = h2f.closure("tnp_ntracks"+strClosure, clos_e_ntracks, clos_g_ntracks)
#tpclos_ntracks.addFakerate(tpgenf_ntracks, "Tag n Probe gen info"+strClosure)
tpclos_ntracks.addFakerate(tpf_ntracks, "Tag n Probe"+strClosure)
tpclos_ntracks.createFitPrediction()
tpclos_ntracks.createHistoPrediction()
# Nvtx:
tnp_ee_nvtx.Add(tnp_eg_nvtx)
tpf_nvtx = h2f.h2Fakerate("nvtx", tnp_ee_nvtx, tnp_eg_nvtx)
tpf_nvtx.rebin(nvtx_binning)
tpf_nvtx.addFitModel(rt.TF1("tpf_nvtx", "[0]+[1]*x", 0, 30))
tpf_nvtx.fit()
tpcan_nvtx = h2f.h2FakerateCanvas(tpf_nvtx)
tpcan_nvtx.setLabel("Tag n probe")
clos_e_nvtx = aux.rebin(clos_e_nvtx, nvtx_binning)
clos_g_nvtx = aux.rebin(clos_g_nvtx, nvtx_binning)
tpclos_nvtx = h2f.closure("tnp_nvtx"+strClosure, clos_e_nvtx, clos_g_nvtx)
#tpclos_nvtx.addFakerate(tpgenf_nvtx, "Tag n Probe gen info"+strClosure)
tpclos_nvtx.addFakerate(tpf_nvtx, "Tag n Probe"+strClosure)
tpclos_nvtx.createFitPrediction()
tpclos_nvtx.createHistoPrediction()
# Eta:
print "eta_binning: ", eta_binning
tnp_ee_eta.Add(tnp_eg_eta)
tpf_eta = h2f.h2Fakerate("eta", tnp_ee_eta, tnp_eg_eta)
tpf_eta.rebin(eta_binning)
tpf_eta.addFitModel(rt.TF1("tpf_eta", "[0]+[1]*x", 0.1, 1.4))
tpf_eta.fit()
tpcan_eta = h2f.h2FakerateCanvas(tpf_eta)
tpcan_eta.setLabel("Tag n probe")
clos_e_eta = aux.rebin(clos_e_eta, eta_binning)
clos_g_eta = aux.rebin(clos_g_eta, eta_binning)
#clos_e_eta.Rebin(10)
#clos_g_eta.Rebin(10)
tpclos_eta = h2f.closure("tnp_eta"+strClosure, clos_e_eta, clos_g_eta)
#tpclos_eta.addFakerate(tpgenf_eta, "Tag n Probe gen info"+strClosure)
tpclos_eta.addFakerate(tpf_eta, "Tag n Probe"+strClosure)
tpclos_eta.createFitPrediction()
tpclos_eta.createHistoPrediction()
# PLOTS and CANVASES
tpcan.createCanvas(fs, name="f_tnp_pt"+ss)#, yrng=[0.002, 0.015])
tpcan_ntracks.createCanvas(fs, yrng=[0., .03], name="f_tnp_ntracks"+ss)
tpcan_nvtx.createCanvas(fs, name="f_tnp_nvtx"+ss)
tpcan_eta.createCanvas(fs, name="f_tnp_eta"+ss)
# def histoCanvas(self, fs, name, clabel, logy=True, *opt):
tpclos.histoCanvas( fs,
"tnp_pt_closure_ownclass"+ss+strClosure,
"Closure on "+samplename,
logy = True,
opt=[0])
h2f.histoCanvas( fs,
"tnp_pt_closure"+ss+strClosure,
tpclos.target,
tpclos.predictionh[0],
"Closure on "+samplename,
logy = True,
yrng = [1000., 10000000.])
h2f.histoCanvas( fs,
"tnp_ntracks_closure"+ss+strClosure,
tpclos_ntracks.target,
tpclos_ntracks.predictionh[0],
"Closure on "+samplename)
h2f.histoCanvas( fs,
"tnp_nvtx_closure"+ss+strClosure,
tpclos_nvtx.target,
tpclos_nvtx.predictionh[0],
"Closure on "+samplename,
logy = True,
yrng = [1, 10000000])
h2f.histoCanvas( fs,
"tnp_eta_closure"+ss+strClosure,
tpclos_eta.target,
tpclos_eta.predictionh[0],
"Closure on "+samplename,
logy=True)
# '''
#c = rt.TCanvas("c", "c", 600, 600)
#c.cd()
#tpf.egraph.Draw("ap")
#raw_input()
#raw_input()
#x = 50.
#err = [rt.Double(0)]
#xerr = tpf.fitres.GetConfidenceIntervals(1, 1, 1, x, err, 0.683, False);
#print tpf.fitres.GetConfidenceIntervals(10, 1, 2, x, err, 0.94999, True);
#raw_input()
return 0
