def rooFit106():
print ">>> setup model..."
x = RooRealVar("x", "x", -3, 3)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
gauss = RooGaussian("gauss", "gauss", x, mean, sigma)
data = gauss.generate(RooArgSet(x), 10000) # RooDataSet
gauss.fitTo(data)
print ">>> plot pdf and data..."
frame = x.frame(Name("frame"), Title("RooPlot with decorations"),
Bins(40)) # RooPlot
data.plotOn(frame)
gauss.plotOn(frame)
print ">>> RooGaussian::paramOn - add box with pdf parameters..."
# https://root.cern.ch/doc/master/classRooAbsPdf.html#aa43b2556a1b419bad2b020ba9b808c1b
# Layout(Double_t xmin, Double_t xmax, Double_t ymax)
# left edge of box starts at 20% of x-axis
gauss.paramOn(frame, Layout(0.55))
print ">>> RooDataSet::statOn - add box with data statistics..."
# https://root.cern.ch/doc/master/classRooAbsData.html#a538d58020b296a1623323a84d2bb8acb
# x size of box is from 55% to 99% of x-axis range, top of box is at 80% of y-axis range)
data.statOn(frame, Layout(0.20, 0.55, 0.8))
print ">>> add text and arrow..."
text = TText(2, 100, "Signal")
text.SetTextSize(0.04)
text.SetTextColor(kRed)
frame.addObject(text)
arrow = TArrow(2, 100, -1, 50, 0.01, "|>")
arrow.SetLineColor(kRed)
arrow.SetFillColor(kRed)
arrow.SetLineWidth(3)
frame.addObject(arrow)
print ">>> persist frame with all decorations in ROOT file..."
file = TFile("rooFit106.root", "RECREATE")
frame.Write()
file.Close()
# To read back and plot frame with all decorations in clean root session do
# [0] TFile f("rooFit106.root")
# [1] xframe->Draw()
print ">>> draw functions and toy data on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.05)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit106.png")
def rooFit103():
print ">>> construct generic pdf from interpreted expression..."
# To construct a proper p.d.f, the formula expression is explicitly normalized internally
# by dividing it by a numeric integral of the expresssion over x in the range [-20,20]
x = RooRealVar("x", "x", -20, 20)
alpha = RooRealVar("alpha", "alpha", 5, 0.1, 10)
genpdf = RooGenericPdf("genpdf", "genpdf",
"(1+0.1*abs(x)+sin(sqrt(abs(x*alpha+0.1))))",
RooArgList(x, alpha))
print ">>> generate and fit toy data...\n"
data = genpdf.generate(RooArgSet(x), 10000) # RooDataSet
genpdf.fitTo(data)
frame1 = x.frame(Title("Interpreted expression pdf")) # RooPlot
data.plotOn(frame1, Binning(40))
genpdf.plotOn(frame1)
print "\n>>> construct standard pdf with formula replacing parameter..."
mean2 = RooRealVar("mean2", "mean^2", 10, 0, 200)
sigma = RooRealVar("sigma", "sigma", 3, 0.1, 10)
mean = RooFormulaVar("mean", "mean", "sqrt(mean2)", RooArgList(mean2))
gaus2 = RooGaussian("gaus2", "gaus2", x, mean, sigma)
print ">>> generate and fit toy data...\n"
gaus1 = RooGaussian("gaus1", "gaus1", x, RooConst(10), RooConst(3))
data2 = gaus1.generate(RooArgSet(x), 1000) # RooDataSet
result = gaus2.fitTo(data2, Save()) # RooFitResult
result.Print()
frame2 = x.frame(Title("Tailored Gaussian pdf")) # RooPlot
data2.plotOn(frame2, Binning(40))
gaus2.plotOn(frame2)
print "\n>>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600)
canvas.Divide(2)
canvas.cd(1)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
canvas.cd(2)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame2.GetYaxis().SetLabelOffset(0.008)
frame2.GetYaxis().SetTitleOffset(1.6)
frame2.GetYaxis().SetTitleSize(0.045)
frame2.GetXaxis().SetTitleSize(0.045)
frame2.Draw()
canvas.SaveAs("rooFit103.png")
def rooFit208():
print ">>> setup component pdfs..."
t = RooRealVar("t", "t", -10, 30)
ml = RooRealVar("ml", "mean landau", 5., -20, 20)
sl = RooRealVar("sl", "sigma landau", 1, 0.1, 10)
landau = RooLandau("lx", "lx", t, ml, sl)
mg = RooRealVar("mg", "mg", 0)
sg = RooRealVar("sg", "sg", 2, 0.1, 10)
gauss = RooGaussian("gauss", "gauss", t, mg, sg)
print ">>> construct convolution pdf..."
# Set #bins to be used for FFT sampling to 10000
t.setBins(10000, "cache")
# Construct landau (x) gauss
convolution = RooFFTConvPdf("lxg", "landau (X) gauss", t, landau, gauss)
print ">>> sample, fit and plot convoluted pdf..."
data = convolution.generate(RooArgSet(t), 10000) # RooDataSet
convolution.fitTo(data)
print "\n>>> plot everything..."
frame1 = t.frame(Title("landau #otimes gauss convolution")) # RooPlot
data.plotOn(frame1, Binning(50), Name("data"))
convolution.plotOn(frame1, Name("lxg"))
gauss.plotOn(frame1, LineStyle(kDashed), LineColor(kRed), Name("gauss"))
landau.plotOn(frame1, LineStyle(kDashed), LineColor(kGreen),
Name("landau"))
print "\n>>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
legend = TLegend(0.6, 0.8, 0.8, 0.6)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.5)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend.AddEntry("data", "data", 'LEP')
legend.AddEntry("lxg", "convolution", 'L')
legend.AddEntry("landau", "landau", 'L')
legend.AddEntry("gauss", "gauss", 'L')
legend.Draw()
canvas.SaveAs("rooFit208.png")
def rooFit107():
print ">>> setup model..."
x = RooRealVar("x","x",-3,3)
mean = RooRealVar("mean","mean of gaussian",1,-10,10)
sigma = RooRealVar("sigma","width of gaussian",1,0.1,10)
gauss = RooGaussian("gauss","gauss",x,mean,sigma)
data = gauss.generate(RooArgSet(x),1000) # RooDataSet
gauss.fitTo(data)
print ">>> plot pdf and data..."
frame1 = x.frame(Name("frame1"),Title("Red Curve / SumW2 Histo errors"),Bins(20)) # RooPlot
frame2 = x.frame(Name("frame2"),Title("Dashed Curve / No XError bars"),Bins(20)) # RooPlot
frame3 = x.frame(Name("frame3"),Title("Filled Curve / Blue Histo"),Bins(20)) # RooPlot
frame4 = x.frame(Name("frame4"),Title("Partial Range / Filled Bar chart"),Bins(20)) # RooPlot
print ">>> data plotting styles..."
data.plotOn(frame1,DataError(RooAbsData.SumW2))
data.plotOn(frame2,XErrorSize(0)) # Remove horizontal error bars
data.plotOn(frame3,MarkerColor(kBlue),LineColor(kBlue)) # Blue markers and error bors
data.plotOn(frame4,DrawOption("B"),DataError(RooAbsData.None),
XErrorSize(0),FillColor(kGray)) # Filled bar chart
print ">>> data plotting styles..."
gauss.plotOn(frame1,LineColor(kRed))
gauss.plotOn(frame2,LineStyle(kDashed)) # Change line style to dashed
gauss.plotOn(frame3,DrawOption("F"),FillColor(kOrange),MoveToBack()) # Filled shapes in green color
gauss.plotOn(frame4,Range(-8,3),LineColor(kMagenta))
print ">>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas","canvas",100,100,1000,1200)
canvas.Divide(2,2)
for i, frame in enumerate([frame1,frame2,frame3,frame4],1):
canvas.cd(i)
gPad.SetLeftMargin(0.15); gPad.SetRightMargin(0.05)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit107.png")
def main():
# Mjj0 of TT MC Bkg
f1 = TFile("Merged_TT_TuneCUETP8M1_13TeV-powheg-pythia8-runallAnalysis.root")
h_Mjj = f1.Get("histfacFatJet_ZLight/h_Mjj0")
h_Mjj.GetXaxis().SetRangeUser(0,300)
var_mean = h_Mjj.GetMean()
# Build Gaussian PDF
x = RooRealVar( 'x', 'x', 0, 300 )
mean = RooRealVar( 'mean', 'mean of gaussian', var_mean )
sigma = RooRealVar( 'sigma', 'width of gaussian', 5)
gauss = RooGaussian( 'gauss', 'gaussian PDF', x, mean, sigma)
data = RooDataHist("data","Mjj dataset",RooArgList(x), h_Mjj);
# Plot PDF
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
gauss.plotOn( xframe )
gauss.plotOn(xframe,RooFit.LineColor(2))
# Generate a toy MC set
# data = gauss.generate( RooArgSet(x), 10000 )
# Plot PDF and toy data overlaid
xframe2 = x.frame(RooFit.Title("Gaussian p.d.f. with Mjj"))
# data.plotOn( xframe2, RooLinkedList() )
# data.plotOn( xframe2 )
data.plotOn( xframe2 )
gauss.plotOn( xframe2)
# Fit PDF to toy
mean.setConstant( kFALSE )
sigma.setConstant( kFALSE )
gauss.fitTo(data)
c1 = TCanvas("c1","Example",800,400)
c1.Divide(3)
c1.cd(1)
gPad.SetLeftMargin(0.15)
xframe.GetYaxis().SetTitleOffset(1.6)
xframe.Draw()
c1.cd(2)
gPad.SetLeftMargin(0.15)
xframe2.GetYaxis().SetTitleOffset(1.6)
xframe2.Draw()
c1.SaveAs('testMjj0.png')
# # Print final value of parameters
fout = TFile("output.root","recreate")
c1.Write()
fout.Close()
def rooFit101():
print ">>> build gaussian pdf..."
x = RooRealVar("x", "x", -10, 10)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, sigma)
print ">>> plot pdf..."
frame1 = x.frame(Title("Gaussian pdf")) # RooPlot
#xframe.SetTitle("Gaussian pdf")
gauss.plotOn(frame1)
print ">>> change parameter value and plot..."
sigma.setVal(3)
gauss.plotOn(frame1, LineColor(kRed))
print ">>> generate events..."
data = gauss.generate(RooArgSet(x), 10000) # RooDataSet
frame2 = x.frame()
data.plotOn(frame2, Binning(40))
gauss.plotOn(frame2)
print ">>> fit gaussian...\n"
gauss.fitTo(data)
mean.Print()
sigma.Print()
print "\n>>> draw pdfs and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600)
canvas.Divide(2)
canvas.cd(1)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
canvas.cd(2)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame2.GetYaxis().SetLabelOffset(0.008)
frame2.GetYaxis().SetTitleOffset(1.6)
frame2.GetYaxis().SetTitleSize(0.045)
frame2.GetXaxis().SetTitleSize(0.045)
frame2.Draw()
canvas.SaveAs("rooFit101.png")
x = RooRealVar("x","x",-10,10)
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
mean1 = RooRealVar("mean1","mean of gaussian",2,-10,10)
sigma1 = RooRealVar("sigma1","width of gaussian",1,0.1,10)
mean1.setConstant(True)
sigma1.setConstant(True)
gauss1 = RooGaussian("gauss1","gaussian PDF",x,mean1,sigma1)
data = gauss1.generate(RooArgSet(x),1000)
data.plotOn(xframe)
gauss1.plotOn(xframe,RooFit.LineColor(4))
# -------------------------------------------------
# use another Gaussian to fit toy MC
mean2 = RooRealVar("mean2","mean of gaussian",2,-10,10)
sigma2 = RooRealVar("sigma2","width of gaussian",1,0.1,10)
gauss2 = RooGaussian("gauss2","gaussian PDF",x,mean2,sigma2)
fit_result = gauss2.fitTo(data, RooFit.SumW2Error(True), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1))
gauss2.plotOn(xframe,RooFit.LineColor(2))
# -------------------------------------------------
# get parameter and correlation matrix
x = RooRealVar("x","x",-10,10)
xframe1 = x.frame(RooFit.Title("1. use gauss1 generate toy MC, use gauss2 to fit"))
# gauss1
mean1 = RooRealVar("mean1","mean of gaussian",2,-10,10)
sigma1 = RooRealVar("sigma1","width of gaussian",2,0.1,10)
gauss1 = RooGaussian("gauss1","gaussian PDF",x,mean1,sigma1)
# generate toy MC
data1 = gauss1.generate(RooArgSet(x),500)
data1.plotOn(xframe1)
gauss1.plotOn(xframe1)
#gauss1.plotOn(xframe1, RooFit.Normalization(500, RooAbsReal.NumEvent) , RooFit.LineColor(RooFit.kGreen))
# gauss2
mean2 = RooRealVar("mean2","mean of gaussian",0,-10,10)
sigma2 = RooRealVar("sigma2","width of gaussian",1,0.1,10)
gauss2 = RooGaussian("gauss2","gaussian PDF",x,mean2,sigma2)
# fit
gauss2.fitTo(data1)
gauss2.plotOn(xframe1,RooFit.LineColor(RooFit.kRed))
class CBfunction:
doubleSidedCB = False
gaussian = False
nbins = 600
xmin = 0
xmax = 12000
xaxis_scale = 0.2
a_initial = 0.5
n_initial = 7
a2_initial = 0.5
n2_initial = 7
s_initial = 60
def __init__(self,data):
self.data = data ## data should be TChain already
def set_crystal(self,crystal):
self.crystal = crystal
def set_energy(self,energy):
self.energy = energy
def set_position(self,x=0,y=0,window=20):
self.xcenter = x
self.ycenter = y
self.window = window
def set_selection(self):
self.selection = "n_tracks==1 && fabs(X-(%.2f))<%.2f && fabs(Y-(%.2f))<%.2f"%(self.xcenter,self.window,self.ycenter,self.window)
def prepare_sumhistogram(self,dict_crystals_calibration,matrix):
self.set_selection()
self.hist = ROOT.TH1F("ampl_%s_%s"%(self.crystal,self.energy),"ampl_%s_%s"%(self.crystal,self.energy),self.nbins,self.xmin,self.xmax)
draw_function = '('
for enum,cryst in enumerate(matrix):
#draw_function +='fit_ampl[%s]*%.4f'%(cryst,dict_crystals_calibration[cryst])
draw_function +='((fit_ampl[%s] > 0) ? fit_ampl[%s] : amp_max[%s])*%.4f'%(cryst,cryst,cryst,dict_crystals_calibration[cryst])
if enum!=len(matrix)-1 : draw_function+='+'
# else : draw_function+=")*%.4f>>ampl_%s_%s"%(dict_crystals_calibration['conversion_factor'],self.crystal,self.energy)
else : draw_function+=")>>ampl_%s_%s"%(self.crystal,self.energy)
self.data.Draw(draw_function,self.selection,"goff")
self.peak_position = self.hist.GetXaxis().GetBinCenter(self.hist.GetMaximumBin())
self.ymax_value = self.hist.GetMaximum()
def prepare_histogram(self):
self.set_selection()
self.hist = ROOT.TH1F("ampl_%s_%s"%(self.crystal,self.energy),"ampl_%s_%s"%(self.crystal,self.energy),self.nbins,self.xmin,self.xmax)
self.data.Draw("fit_ampl[%s]>>ampl_%s_%s"%(self.crystal,self.crystal,self.energy),self.selection,"goff")
self.peak_position = self.hist.GetXaxis().GetBinCenter(self.hist.GetMaximumBin())
self.ymax_value = self.hist.GetMaximum()
def prepare_histogram_time(self):
self.set_selection()
self.hist = ROOT.TH1F("ampl_%s_%s"%(self.crystal,self.energy),"ampl_%s_%s"%(self.crystal,self.energy),self.nbins,self.xmin,self.xmax)
self.data.Draw("((fit_time[%s]-fit_time[MCP2]+fit_time[VFE_CLK])-int((fit_time[%s]-fit_time[MCP2]+fit_time[VFE_CLK])/6.238)*6.238)>>ampl_%s_%s"%(self.crystal,self.crystal,self.crystal,self.energy),self.selection,"goff")
self.peak_position = self.hist.GetXaxis().GetBinCenter(self.hist.GetMaximumBin())
self.ymax_value = self.hist.GetMaximum()
def plot_histogram_time(self):
self.hist.Draw("HISTsame")
def CBintialization(self):
round_energy = round(float(self.energy),-1)
if round_energy ==240 : round_energy = 250
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,0.001,1.) #500.
self.a = RooRealVar("alpha_%s_%s"%(self.crystal,self.energy),"alpha_%s_%s"%(self.crystal,self.energy),self.a_initial,-10.,10)
self.n = RooRealVar("exp_%s_%s"%(self.crystal,self.energy),"exp_%s_%s"%(self.crystal,self.energy),self.n_initial,0.,30)
self.sig = RooCBShape("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s,self.a,self.n)
def Gausintialization(self):
round_energy = round(float(self.energy),-1)
if round_energy ==240 : round_energy = 250
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,0.001,1.)
self.sig = RooGaussian("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s)
def CB2intialization(self):
round_energy = round(float(self.energy),-1)
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,10,500)
self.a = RooRealVar("alpha_%s_%s"%(self.crystal,self.energy),"alpha_%s_%s"%(self.crystal,self.energy),self.a_initial,-10.,10)
self.a2 = RooRealVar("alpha2_%s_%s"%(self.crystal,self.energy),"alpha2_%s_%s"%(self.crystal,self.energy),self.a2_initial,-10.,10)
self.n = RooRealVar("exp_%s_%s"%(self.crystal,self.energy),"exp_%s_%s"%(self.crystal,self.energy),self.n_initial,0.,30)
self.n2 = RooRealVar("exp2_%s_%s"%(self.crystal,self.energy),"exp2_%s_%s"%(self.crystal,self.energy),self.n2_initial,0.,30)
self.sig = ROOT.My_double_CB("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s,self.a,self.n,self.a2,self.n2)
def fitToData(self):
self.res = self.sig.fitTo(self.roohist)
def fitResults(self):
self.dict_fit_results = {}
self.dict_fit_results['CBmean'] = [self.m.getVal(),self.m.getError()]
self.dict_fit_results['CBsigma'] = [self.s.getVal(),self.s.getError()]
if (self.gaussian==False) :
self.dict_fit_results['CBalpha'] = [self.a.getVal(),self.a.getError()]
self.dict_fit_results['CBexp'] = [self.n.getVal(),self.n.getError()]
if (self.doubleSidedCB==True) :
self.dict_fit_results['CBalpha2'] = [self.a2.getVal(),self.a2.getError()]
self.dict_fit_results['CBexp2'] = [self.n2.getVal(),self.n2.getError()]
self.dict_fit_results['chi2'] = self.chi2
return self.dict_fit_results
def plot(self):
self.frame = self.x.frame()
self.roohist.plotOn(self.frame,RooFit.Name("roohist_chi2_%s_%s"%(self.crystal,self.energy)))
self.sig.plotOn(self.frame,RooFit.Name("signal_chi2_%s_%s"%(self.crystal,self.energy)))
ndf = 4
self.chi2 = self.frame.chiSquare("signal_chi2_%s_%s"%(self.crystal,self.energy),"roohist_chi2_%s_%s"%(self.crystal,self.energy),ndf) # 4 = nFitParameters from CB
self.sig.paramOn(self.frame,RooFit.Layout(0.65,0.99,0.8))
self.frame.getAttText().SetTextSize(0.02)
txt_chi2 = ROOT.TText(self.peak_position*(1.01-self.xaxis_scale),self.ymax_value*0.95,"Chi2 = %.1f"%self.chi2)
txt_chi2.SetTextSize(0.04)
txt_chi2.SetTextColor(ROOT.kRed)
self.frame.addObject(txt_chi2)
self.frame.Draw()
def plot_time(self):
self.frame = self.x.frame()
self.roohist.plotOn(self.frame,RooFit.Name("roohist_chi2_%s_%s"%(self.crystal,self.energy)))
self.frame.Draw()
# ---------------------
# Declare variables x,mean,sigma with associated name, title, initial value and allowed range
x = RooRealVar("x", "x", -10, 10)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
# Build gaussian p.d.f in terms of x,mean and sigma
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, sigma)
# Construct plot frame in 'x'
xframe = x.frame()
# Plot on X
gauss.plotOn(xframe)
# Change sigma value
sigma.setVal(3)
# Plot on X
gauss.plotOn(xframe, RooFit.LineColor(2))
# Generate data (1000 events in x in a gaussian)
data = gauss.generate(ROOT.RooArgSet(x), 10000)
# Make another frame
xframe2 = x.frame()
data.plotOn(xframe2)
gauss.plotOn(xframe2)
def rooFit109():
print ">>> setup model..."
x = RooRealVar("x", "x", -10, 10)
sigma = RooRealVar("sigma", "sigma", 3, 0.1, 10)
mean = RooRealVar("mean", "mean", 0, -10, 10)
gauss = RooGaussian("gauss", "gauss", x, RooConst(0),
sigma) # RooConst(0) gives segfaults
data = gauss.generate(RooArgSet(x), 100000) # RooDataSet
#sigma = 3.15 # overwrites RooRealVar with a float
sigma.setVal(3.15)
print ">>> plot data and slightly distorted model..."
frame1 = x.frame(Title("Data with distorted Gaussian pdf"),
Bins(40)) # RooPlot
data.plotOn(frame1, DataError(RooAbsData.SumW2))
gauss.plotOn(frame1)
print ">>> calculate chi^2..."
# Show the chi^2 of the curve w.r.t. the histogram
# If multiple curves or datasets live in the frame you can specify
# the name of the relevant curve and/or dataset in chiSquare()
print ">>> chi^2 = %.2f" % frame1.chiSquare()
print ">>> construct histograms with the residuals and pull of the data wrt the curve"
hresid = frame1.residHist() # RooHist
hpull = frame1.pullHist() # RooHist
frame2 = x.frame(Title("Residual Distribution")) # RooPlot
frame2.addPlotable(hresid, "P")
frame3 = x.frame(Title("Pull Distribution")) # RooPlot
frame3.addPlotable(hpull, "P")
print ">>> draw functions and toy data on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 2000, 400)
canvas.Divide(3)
for i, frame in enumerate([frame1, frame2, frame3], 1):
canvas.cd(i)
gPad.SetLeftMargin(0.14)
gPad.SetRightMargin(0.04)
frame.GetYaxis().SetTitleOffset(1.5)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit109.png")
canvas.Close()
# ratio/pull/residual plot
print ">>> draw with pull plot..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1000, 1000)
canvas.Divide(2)
canvas.cd(1)
gPad.SetPad("pad1", "pad1", 0, 0.33, 1, 1, 0, -1, 0)
gPad.SetTopMargin(0.10)
gPad.SetBottomMargin(0.03)
gPad.SetLeftMargin(0.14)
gPad.SetRightMargin(0.04)
gPad.SetBorderMode(0)
gStyle.SetTitleFontSize(0.062)
frame1.GetYaxis().SetTitle("Events / %.3g GeV" % frame1.getFitRangeBinW())
frame1.GetYaxis().SetTitleSize(0.059)
frame1.GetYaxis().SetTitleOffset(1.21)
#frame1.GetYaxis().SetLabelOffset(0.010)
frame1.GetXaxis().SetLabelSize(0)
frame1.GetYaxis().SetLabelSize(0.045)
frame1.Draw()
canvas.cd(2)
gPad.SetPad("pad2", "pad2", 0, 0, 1, 0.33, 0, -1, 0)
gPad.SetTopMargin(0.01)
gPad.SetBottomMargin(0.30)
gPad.SetLeftMargin(0.14)
gPad.SetRightMargin(0.04)
gPad.SetBorderMode(0)
gPad.SetGridy(kTRUE)
line1 = TLine(frame3.GetXaxis().GetXmin(), 0,
frame3.GetXaxis().GetXmax(), 0)
line2 = TLine(frame3.GetXaxis().GetXmin(), 0,
frame3.GetXaxis().GetXmax(), 0)
line1.SetLineColor(0) # white to clear dotted grid lines
line2.SetLineColor(12) # dark grey
line2.SetLineStyle(2)
frame3.SetTitle("")
frame3.GetYaxis().SetTitle("pull")
frame3.GetXaxis().SetTitle("#Deltam^{2}_{ll} [GeV]")
frame3.GetXaxis().SetTitleSize(0.13)
frame3.GetYaxis().SetTitleSize(0.12)
frame3.GetXaxis().SetTitleOffset(1.0)
frame3.GetYaxis().SetTitleOffset(0.58)
frame3.GetXaxis().SetLabelSize(0.10)
frame3.GetYaxis().SetLabelSize(0.10)
frame3.GetXaxis().SetLabelOffset(0.02)
frame3.GetYaxis().SetLabelOffset(0.01)
frame3.GetYaxis().SetRangeUser(-5, 5)
frame3.GetYaxis().CenterTitle(True)
frame3.GetYaxis().SetNdivisions(505)
frame3.Draw("")
line1.Draw("SAME")
line2.Draw("SAME")
frame3.Draw("SAME")
canvas.SaveAs("rooFit109_ratiolike.png")
canvas.Close()
# In[10]:
tot.fitTo(dh)
# In[11]:
massFrame = mass.frame()
massFrame.SetTitle("Phi signal")
dh.plotOn(massFrame)
tot.plotOn(massFrame)
gauss.plotOn(massFrame,LineColor(kGreen),LineStyle(kDashed),Normalization((sFrac.getValV()*numEvts)/(numEvts)))
cheb.plotOn(massFrame,LineColor(kMagenta),LineStyle(kDotted),Normalization(((1.0-sFrac.getValV())*numEvts)/(numEvts)))
tot.paramOn(massFrame,Layout(0.60,0.99,0.75));
massFrame.Draw()
# In[12]:
plotmax = hist.GetMaximum()*1.05
sidesigma = sigma.getValV()
leftlowside = -7.*sidesigma + mean.getValV()
leftupside = -5.*sidesigma + mean.getValV()
rightlowside = +5.*sidesigma + mean.getValV()
rightupside = +7.*sidesigma + mean.getValV()
def rooFit110():
print ">>> setup model..."
x = RooRealVar("x","x",-10,10)
mean = RooConst(-2)
sigma = RooConst(3)
gauss = RooGaussian("gauss","gauss",x,mean,sigma)
frame1 = x.frame(Title("Gaussian pdf")) # RooPlot
gauss.plotOn(frame1)
print ">>> retrieve raw & normalized values of RooFit pdfs...\n>>>"
# Return 'raw' unnormalized value of gauss
print ">>> raw value: gauss.getVal( ) = %.3f" % gauss.getVal() + " depends on x range"
print ">>> normalization: gauss.getVal(x) = %.3f" % gauss.getVal(RooArgSet(x))
print ">>> normalization: gauss.getNorm(x) = %.3f" % gauss.getNorm(RooArgSet(x))
print ">>> 1/(sigma*sqrt(2*pi)) = %.3f" % (1/(sigma.getValV()*sqrt(2*pi)))
# Create object representing integral over gauss
# which is used to calculate gauss_Norm[x] == gauss / gauss_Int[x]
igauss = gauss.createIntegral(RooArgSet(x)) # RooAbsReal
print ">>> integral: igauss.getVal( ) = %.3f" % igauss.getVal()
print ">>> igauss.getVal(x) = %.3f" % igauss.getVal(RooArgSet(x))
print ">>> 1/igauss.getVal(x) = %.3f" % (1/igauss.getVal(RooArgSet(x)))
print ">>> gauss.getVal()/igauss.getVal(x) = %.3f" % (gauss.getVal()/igauss.getVal(RooArgSet(x)))
# maximum
print ">>> maximum: gauss.getMaxVal(x) = %.3f" % gauss.getMaxVal(RooArgSet(x))
print ">>> gauss.getMax(0) = %.3f" % gauss.maxVal(0)
print ">>> gauss.getMax(1) = %.3f" % gauss.maxVal(1)
print ">>> gauss.asTF(x).GetMaximumX() = %.3f" % gauss.asTF(RooArgList(x)).GetMaximumX()
print ">>> gauss.asTF(x).GetMaximum() = %.3f" % gauss.asTF(RooArgList(x)).GetMaximum()
xmaxVal = gauss.asTF(RooArgList(x)).GetMaximumX()
xmax = RooRealVar("x_max","x_max",xmaxVal)
x.setVal(xmaxVal)
print ">>> gauss.getVal( ) = %.3f" % gauss.getVal()
print ">>> gauss.getVal(xmax) = %.3f" % gauss.getVal(RooArgSet(x))
print ">>> gauss.getVal(xmax) = %.3f" % gauss.getVal(RooArgSet(xmax))
print ">>> plot"
frame2 = x.frame(Title("integral of Gaussian pdf")) # RooPlot
line1 = RooLinearVar("line1","line1",x,RooConst(0),RooConst(gauss.getVal()))
line2 = RooLinearVar("line2","line2",x,RooConst(0),RooConst(gauss.getVal(RooArgSet(x))))
igauss.plotOn(frame2,LineColor(kBlue), Name(igauss.GetName()))
line1.plotOn( frame2,LineColor(kRed), Name(line1.GetName()))
line2.plotOn( frame2,LineColor(kGreen),Name(line2.GetName()))
print ">>>\n>>> integrate normalized pdf over subrange..."
# Define a range named "signal" in x from -5,5
x.setRange("signal",-5,5)
# Create an integral of gauss_Norm[x] over x in range "signal"
# This is the fraction of of p.d.f. gauss_Norm[x] which is in
# the range named "signal"
igauss_sig = gauss.createIntegral(RooArgSet(x),NormSet(RooArgSet(x)),Range("signal")) # RooAbsReal
print ">>> gauss_Int[x|signal]_Norm[x] = %.2f" % igauss_sig.getVal()
print ">>> construct cumulative distribution function from pdf..."
# Create the cumulative distribution function of
# gauss, i.e. calculate Int[-10,x] gauss(x') dx'
gauss_cdf = gauss.createCdf(RooArgSet(x)) # RooAbsReal
frame3 = x.frame(Title("cdf of Gaussian pdf")) # RooPlot
gauss_cdf.plotOn(frame3)
print ">>> draw functions on canvas..."
canvas = TCanvas("canvas","canvas",100,100,2000,400)
legend = TLegend(0.6,0.6,0.8,0.42)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
canvas.Divide(3)
for i, frame in enumerate([frame1,frame2,frame3],1):
canvas.cd(i)
gPad.SetLeftMargin(0.14); gPad.SetRightMargin(0.04)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
if i is 2:
legend.AddEntry(line1.GetName(), " gauss.getVal( )",'L')
legend.AddEntry(line2.GetName(), " gauss.getVal(x)",'L')
legend.AddEntry(igauss.GetName(),"igauss.getVal( )",'L')
legend.Draw()
canvas.SaveAs("rooFit110.png")
ysig = 1
ybgd = 8 * ysig
ndata = nsig * (1 + ybgd / ysig)
######### underlying model
mean = RooRealVar("mean","mean", 125, 100, 150);
sigma = RooRealVar("sigma","sigma", 2, 0, 10);
sig = RooGaussian("sig", "sig", x, mean, sigma)
bgd = RooPolynomial("bgd", "bgd", x)
c1 = TCanvas()
pframe = x.frame()
sig.plotOn(pframe)
bgd.plotOn(pframe)
pframe.Draw()
vysig = RooRealVar("nsig", 'nsig', ysig, 0, 100000)
vybgd = RooRealVar("nbgd", 'nbgd', ybgd, 0, 100000)
model = RooAddPdf("model", "model", RooArgList(sig, bgd),
RooArgList(vysig, vybgd))
#model = RooAddPdf("model", "model", RooArgList(sig),
# RooArgList(vysig))
c2 = TCanvas()
mframe = x.frame()
model.plotOn(mframe)
mframe.Draw()
def rooFit111():
print ">>> setup model..."
x = RooRealVar("x", "x", -10, 10)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, sigma)
print ">>> create and plot derivatives wrt x..."
dgdx = gauss.derivative(x, 1) # RooAbsReal
d2gdx2 = gauss.derivative(x, 2) # RooAbsReal
d3gdx3 = gauss.derivative(x, 3) # RooAbsReal
print ">>> plot gaussian and its first two derivatives..."
frame1 = x.frame(Title("d^{n}(Gauss)/dx^{n}")) # RooPlot
norm1 = 10
gauss.plotOn(frame1, LineColor(kBlue), Name(gauss.GetName()),
Normalization(norm1))
dgdx.plotOn(frame1, LineColor(kMagenta), Name("dgdx"))
d2gdx2.plotOn(frame1, LineColor(kRed), Name("d2gdx2"))
d3gdx3.plotOn(frame1, LineColor(kOrange), Name("d3gdx3"))
print ">>> create and plot derivatives wrt sigma..."
dgds = gauss.derivative(sigma, 1) # RooAbsReal
d2gds2 = gauss.derivative(sigma, 2) # RooAbsReal
d3gds3 = gauss.derivative(sigma, 3) # RooAbsReal
print ">>> plot gaussian and its first two derivatives..."
frame2 = sigma.frame(Title("d^{n}(Gauss)/d(sigma)^{n}"),
Range(0., 2.)) # RooPlot
(norm2, norm21, norm22) = (8000, 15, 5)
gauss.plotOn(frame2, LineColor(kBlue), Name(gauss.GetName()),
Normalization(norm2))
dgds.plotOn(frame2, LineColor(kMagenta), Name("dgds"),
Normalization(norm21))
d2gds2.plotOn(frame2, LineColor(kRed), Name("d2gds2"),
Normalization(norm22))
d3gds3.plotOn(frame2, LineColor(kOrange), Name("d3gds3"))
print ">>> draw pdfs and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600)
legend1 = TLegend(0.22, 0.85, 0.4, 0.65)
legend2 = TLegend(0.60, 0.85, 0.8, 0.65)
for legend in [legend1, legend2]:
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
canvas.Divide(2)
canvas.cd(1)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend1.AddEntry(gauss.GetName(), "gaussian G (#times%s)" % norm1, 'L')
legend1.AddEntry("dgdx", "d(G)/dx", 'L')
legend1.AddEntry("d2gdx2", "d^{2}(G)/dx^{2}", 'L')
legend1.AddEntry("d3gdx3", "d^{3}(G)/dx^{3}", 'L')
legend1.Draw()
canvas.cd(2)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame2.GetYaxis().SetLabelOffset(0.008)
frame2.GetYaxis().SetTitleOffset(1.6)
frame2.GetYaxis().SetTitleSize(0.045)
frame2.GetXaxis().SetTitleSize(0.045)
frame2.Draw()
legend2.AddEntry(gauss.GetName(), "gaussian G (#times%s)" % norm2, 'L')
legend2.AddEntry("dgds", "d(G)/ds (#times%s)" % norm21, 'L')
legend2.AddEntry("d2gds2", "d^{2}(G)/ds^{2} (#times%s)" % norm22, 'L')
legend2.AddEntry("d3gds3", "d^{3}(G)/ds^{3}", 'L')
legend2.Draw()
canvas.SaveAs("rooFit111.png")
masslist = RooArgList(mass)
dh = RooDataHist("dh", "dh", masslist, hist)
numEvts = dh.sum(False)
print numEvts
# In[10]:
tot.fitTo(dh)
# In[11]:
massFrame = mass.frame()
massFrame.SetTitle("Phi signal")
dh.plotOn(massFrame)
tot.plotOn(massFrame)
gauss.plotOn(massFrame, LineColor(kGreen), LineStyle(kDashed),
Normalization((sFrac.getValV() * numEvts) / (numEvts)))
cheb.plotOn(massFrame, LineColor(kMagenta), LineStyle(kDotted),
Normalization(((1.0 - sFrac.getValV()) * numEvts) / (numEvts)))
tot.paramOn(massFrame, Layout(0.60, 0.99, 0.75))
massFrame.Draw()
# In[12]:
plotmax = hist.GetMaximum() * 1.05
sidesigma = sigma.getValV()
leftlowside = -7. * sidesigma + mean.getValV()
leftupside = -5. * sidesigma + mean.getValV()
rightlowside = +5. * sidesigma + mean.getValV()
rightupside = +7. * sidesigma + mean.getValV()
signallow = -3. * sidesigma + mean.getValV()
def rf101_basics():
# S e t u p m o d e l
# ---------------------
# Declare variables x,mean,sigma with associated name, title, initial value and allowed range
x = RooRealVar("x","x",-10,10)
mean = RooRealVar("mean","mean of gaussian",1,-10,10)
sigma = RooRealVar("sigma","width of gaussian",1,0.1,10)
# Build gaussian p.d.f in terms of x,mean and sigma
gauss = RooGaussian("gauss","gaussian PDF",x,mean,sigma)
# Construct plot frame in 'x'
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
# P l o t m o d e l a n d c h a n g e p a r a m e t e r v a l u e s
# ---------------------------------------------------------------------------
# Plot gauss in frame (i.e. in x)
gauss.plotOn(xframe)
# Change the value of sigma to 3
sigma.setVal(3)
# Plot gauss in frame (i.e. in x) and draw frame on canvas
gauss.plotOn(xframe,RooFit.LineColor(kRed))
# G e n e r a t e e v e n t s
# -----------------------------
# Generate a dataset of 1000 events in x from gauss
data = gauss.generate(RooArgSet(x),10000.)
# Make a second plot frame in x and draw both the
# data and the p.d.f in the frame
xframe2 = x.frame(RooFit.Title("Gaussian p.d.f. with data"))
data.plotOn(xframe2)
gauss.plotOn(xframe2)
# F i t m o d e l t o d a t a
# -----------------------------
# Fit pdf to data
gauss.fitTo(data)
# Print values of mean and sigma (that now reflect fitted values and errors)
mean.Print()
sigma.Print()
# Draw all frames on a canvas
c = TCanvas("rf101_basics","rf101_basics",800,400)
c.Divide(2)
c.cd(1)
gPad.SetLeftMargin(0.15)
xframe.GetYaxis().SetTitleOffset(1.6)
xframe.Draw()
c.cd(2)
gPad.SetLeftMargin(0.15)
xframe2.GetYaxis().SetTitleOffset(1.6)
xframe2.Draw()
raw_input()
def rf101_basics():
# S e t u p m o d e l
# ---------------------
# Declare variables x,mean,sigma with associated name, title, initial value and allowed range
x = RooRealVar("x", "x", -10, 10)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
# Build gaussian p.d.f in terms of x,mean and sigma
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, sigma)
# Construct plot frame in 'x'
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
# P l o t m o d e l a n d c h a n g e p a r a m e t e r v a l u e s
# ---------------------------------------------------------------------------
# Plot gauss in frame (i.e. in x)
gauss.plotOn(xframe)
# Change the value of sigma to 3
sigma.setVal(3)
# Plot gauss in frame (i.e. in x) and draw frame on canvas
gauss.plotOn(xframe, RooFit.LineColor(kRed))
# G e n e r a t e e v e n t s
# -----------------------------
# Generate a dataset of 1000 events in x from gauss
data = gauss.generate(RooArgSet(x), 10000.)
# Make a second plot frame in x and draw both the
# data and the p.d.f in the frame
xframe2 = x.frame(RooFit.Title("Gaussian p.d.f. with data"))
data.plotOn(xframe2)
gauss.plotOn(xframe2)
# F i t m o d e l t o d a t a
# -----------------------------
# Fit pdf to data
gauss.fitTo(data)
# Print values of mean and sigma (that now reflect fitted values and errors)
mean.Print()
sigma.Print()
# Draw all frames on a canvas
c = TCanvas("rf101_basics", "rf101_basics", 800, 400)
c.Divide(2)
c.cd(1)
gPad.SetLeftMargin(0.15)
xframe.GetYaxis().SetTitleOffset(1.6)
xframe.Draw()
c.cd(2)
gPad.SetLeftMargin(0.15)
xframe2.GetYaxis().SetTitleOffset(1.6)
xframe2.Draw()
raw_input()
#pdf = RooPdfAdd("pdf", 'convolution', x, p2, p1)
# Plot PDF
canvas = TCanvas("c1","",1200,480);
canvas.Divide(3,1);
canvas.cd(1)
xframe = x.frame()
p1.plotOn( xframe )
xframe.Draw()
gPad.SetLogy()
canvas.cd(2)
xframe2 = x.frame()
p2.plotOn( xframe2 )
xframe2.Draw()
gPad.SetLogy()
start_time = timeit.default_timer()
canvas.cd(3)
xframe3 = x.frame()
pdf.plotOn( xframe3 )
xframe3.Draw()
gPad.SetLogy()
elapsed = timeit.default_timer() - start_time
print "Elapsed time: %s" % elapsed
print "Done"
raw_input("Press Enter to continue...")
gauss11_ext.fixAddCoefRange("whole_range")
gauss11_ext.fitTo(data3_half,RooFit.Range("left_gaussian_range"))
print ""
print "mean11: ", mean11.Print(),
print ""
print "sigma11: ", sigma11.Print()
print ""
print "nGauss11: ", nGauss11.Print()
print ""
# plot
#gauss10.plotOn(xframe7, RooFit.Normalization( data3.sumEntries() , RooAbsReal.NumEvent) )
#gauss10.plotOn(xframe7, RooFit.Normalization( data3.sumEntries() , RooAbsReal.NumEvent) , RooFit.Range("left_gaussian_range"))
gauss10.plotOn(xframe7, RooFit.Normalization( 500 , RooAbsReal.NumEvent) , RooFit.Range("left_gaussian_range"))
#gauss11.plotOn(xframe7,RooFit.Normalization( data3_half.sumEntries() , RooAbsReal.NumEvent), RooFit.LineColor(RooFit.kRed))
#gauss11.plotOn(xframe7,RooFit.Normalization( data3_half.sumEntries() , RooAbsReal.NumEvent), RooFit.Range("left_gaussian_range"), RooFit.LineColor(RooFit.kRed))
#gauss11_ext.plotOn(xframe7,RooFit.Normalization( nGauss11.getVal() , RooAbsReal.NumEvent), RooFit.LineColor(RooFit.kRed))
#gauss11_ext.plotOn(xframe7,RooFit.Normalization( 1.0 , RooAbsReal.RelativeExpected ), RooFit.LineColor(RooFit.kRed))
#gauss11_ext.plotOn(xframe7,RooFit.Normalization( 1.0 , RooAbsReal.RelativeExpected ), RooFit.LineColor(RooFit.kRed),RooFit.DrawOption("F"), RooFit.FillColor(RooFit.kRed), RooFit.FillStyle(1001) )
# try to fix the fill color problem
xArg = RooArgSet(x)
iLeft = gauss11_ext.createIntegral(xArg, RooFit.NormSet(xArg), RooFit.Range("left_gaussian_range"))
iTotal = gauss11_ext.createIntegral(xArg, RooFit.NormSet(xArg), RooFit.Range("whole_range"))
# // Build gaussian p.d.f in terms of x,mean and sigma
# RooGaussian gauss("gauss","gaussian PDF",x,mean,sigma) ;
gauss = RooGaussian("gauss","gaussian PDF",x,mean,sigma)
# // Construct plot frame in 'x'
# RooPlot* xframe = x.frame(Title("Gaussian p.d.f.")) ;
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
# // P l o t m o d e l a n d c h a n g e p a r a m e t e r v a l u e s
# // ---------------------------------------------------------------------------
# // Plot gauss in frame (i.e. in x)
gauss.plotOn(xframe) ;
# // Change the value of sigma to 3
sigma.setVal(3) ;
# // Plot gauss in frame (i.e. in x) and draw frame on canvas
gauss.plotOn(xframe,RooFit.LineColor(RooFit.kRed)) ;
# // G e n e r a t e e v e n t s
# // -----------------------------
# // Generate a dataset of 1000 events in x from gauss
# RooDataSet* data = gauss.generate(x,10000) ;
data = gauss.generate(RooArgSet(x),10000)
def rooFit102():
print ">>> import TH1 into RooDataHist..."
hist = makeTH1()
x = RooRealVar("x", "x", -10, 10)
data_hist = RooDataHist("data_hist", "data_hist", RooArgList(x),
Import(hist))
print ">>> plot and fit RooDataHist...\n"
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, sigma)
gauss.fitTo(data_hist)
frame1 = x.frame(Title("Imported TH1 with Poisson error bars")) # RooPlot
data_hist.plotOn(frame1)
gauss.plotOn(frame1)
print "\n>>> plot and fit RooDataHist with internal errors..."
# If histogram has custom error (i.e. its contents is does not originate from a
# Poisson process but e.g. is a sum of weighted events) you can create data with
# symmetric 'sum-of-weights' error instead (i.e. same error bars as shown by ROOT)
frame2 = x.frame(Title("Imported TH1 with internal errors"))
data_hist.plotOn(frame2, DataError(RooAbsData.SumW2))
gauss.plotOn(frame2)
# Please note that error bars shown (Poisson or SumW2) are for visualization only,
# the are NOT used in a maximum likelihood (ML) fit
#
# A (binned) ML fit will ALWAYS assume the Poisson error interpretation of data
# (the mathematical definition of likelihood does not take any external definition
# of errors). Data with non-unit weights can only be correctly fitted with a chi^2
# fit (see rf602_chi2fit.C)
print ">>> import TTree into RooDataHist..."
# Construct unbinned dataset importing tree branches x and y matching between
# branches and RooRealVars is done by name of the branch/RRV
#
# Note that ONLY entries for which x,y have values within their allowed ranges as
# defined in RooRealVar x and y are imported. Since the y values in the import tree
# are in the range [-15,15] and RRV y defines a range [-10,10] this means that the
# RooDataSet below will have less entries than the TTree 'tree'
tree = makeTTree()
px = RooRealVar("px", "px", -10, 10)
py = RooRealVar("py", "py", -10, 10)
data_set = RooDataSet("data_set", "data_set", RooArgSet(px, py),
Import(tree))
data_set.Print()
frame3 = py.frame(Title("Unbinned data shown in default frame binning"))
frame4 = py.frame(Title("Unbinned data shown with custom binning"))
data_set.plotOn(frame3) # default frame binning of 100 bins
data_set.plotOn(frame4, Binning(20)) # custom binning choice
print ">>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1000, 1200)
canvas.Divide(2, 2)
for i, frame in enumerate([frame1, frame2, frame3, frame4], 1):
canvas.cd(i)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.05)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit102.png")
