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 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")
class Test_lhcb:
def setUp(self):
from e5.lhcb.util import setup_roofit, silence_roofit
setup_roofit()
silence_roofit()
from ROOT import RooArgSet, RooGaussian, RooRealVar
self.x = RooRealVar('x', 'x', -10, 10)
self.mean = RooRealVar('mean', 'mean', 1, -10, 10)
self.sigma = RooRealVar('sigma', 'sigma', 1, 0, 10)
self.model = RooGaussian('model', 'model', self.x, self.mean, self.sigma)
self.data = self.model.generate(RooArgSet(self.x), 1000)
def test_max_ap(self):
from e5.lhcb.fit import max_ap
max_ap(self.model, self.data)
def test_assemble_model(self):
from e5.lhcb.model import assemble_model
w = assemble_model(os.path.dirname(__file__) + '/../testdata/test.model')
assert w
def test_save_dataset(self):
from e5.lhcb.util import save_dataset
#from lhcb.fit import load_dataset
save_dataset(self.data, 'mytest.root')
assert os.path.exists('mytest.root')
os.remove('mytest.root')
def test_get_cmdline_parser(self):
from e5.lhcb.config import get_cmdline_parser
parser = get_cmdline_parser()
args = parser.parse_args('show --graph model test.model'.split())
def test_get_named_section(self):
from e5.lhcb.config import get_config, get_named_section
config = get_config(os.path.dirname(__file__) + '/../testdata/test.cfg')
assert bool(get_named_section(config, 'named', 'first'))
def test_add_weights(self):
from e5.lhcb.fit import add_weights
sigData, bkgData = add_weights(self.model, self.data, ['sigN', 'bkgN'])
assert sigData
assert bkgData
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 test_plot():
c = TCanvas('c', 'canvas', 300, 300)
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)
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
#gauss.plotOn(xframe)
sigma.setVal(3)
as_x = RooArgSet(x)
data = gauss.generate(as_x, 10000)
data.plotOn(xframe, RooFit.MarkerSize(0.6), RooFit.MarkerStyle(20))
xframe.Draw()
pdffile = 'test.pdf'
c.SaveAs(pdffile)
def test_plot():
c = TCanvas('c', 'canvas', 300, 300)
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)
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
#gauss.plotOn(xframe)
sigma.setVal(3)
as_x = RooArgSet(x)
data = gauss.generate(as_x,10000)
data.plotOn(xframe, RooFit.MarkerSize(0.6), RooFit.MarkerStyle(20))
xframe.Draw()
pdffile = 'test.pdf'
c.SaveAs(pdffile)
"""
# -------------------------------------------
# 7. use ext PDF to fit SB only and plot
xframe7 = x.frame(RooFit.Title("7. use ext PDF to fit SB only and plot"))
# gauss 10
mean10 = RooRealVar("mean10","mean of gaussian",3,-10,10)
sigma10 = RooRealVar("sigma10","width of gaussian",2,0.1,10)
gauss10 = RooGaussian("gauss10","gaussian PDF",x,mean10,sigma10)
# generate to MC
data3 = gauss10.generate(RooArgSet(x),1000)
# split to half dataset
data3_half = RooDataSet("data3_half", "data3 half", RooArgSet(x), RooFit.Import( data3 ), RooFit.Cut("x<3") )
# set range
x.setRange("whole_range",-10 ,10 )
x.setRange("right_gaussian_range",3 ,10 )
x.setRange("left_gaussian_range",-10 ,3 )
# another PDF gauss 11
mean11 = RooRealVar("mean11","mean of gaussian",2,-10,10)
sigma11 = RooRealVar("sigma11","width of gaussian",3,0.1,10)
gauss11 = RooGaussian("gauss11","gaussian PDF",x ,mean11 ,sigma11)
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()
# -------------------------------------------------
# use Gaussian to generate toy MC
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))
# -------------------------------------------
# 1. gau1 generate toy MC, use gau2 to fit
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)
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)
# F i t m o d e l t o d a t a
gauss.fitTo(data)
mean.Print()
sigma.Print()
c = TCanvas("rf101_basics", "rf101_basics", 800, 400)
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()
sumfail = RooAddPdf("sumfail", "fixed extended sum pdf", componentsfail,
yieldsfail)
#Creates category
myFitCat = RooCategory("myFitCat", "Category: pass or fail")
myFitCat.defineType("fail", 1)
myFitCat.defineType("pass", 0)
#Create PDF for simultaneous fit
totalPdf = RooSimultaneous("totalPdf", "totalPdf", myFitCat)
totalPdf.addPdf(sumpass, "pass")
totalPdf.addPdf(sumfail, "fail")
#Generate data and combine
#For combining binned data look rf_combine_binned_data.py
data_pass = gauss1.generate(RooArgSet(Mkk), 6000)
data_fail = gauss1.generate(RooArgSet(Mkk), 4000)
combData = RooDataSet("combData", "combined data", RooArgSet(Mkk),
RooFit.Index(myFitCat), RooFit.Import("pass", data_pass),
RooFit.Import("fail", data_fail))
#FIT
totalPdf.fitTo(combData)
#PLOT
sampleSet = RooArgSet(myFitCat)
frame1 = Mkk.frame(RooFit.Bins(50), RooFit.Title("Passed sample"))
# Plot all data tagged as passed sample
combData.plotOn(frame1, RooFit.Cut("myFitCat==myFitCat::pass"))
totalPdf.plotOn(frame1, RooFit.Slice(myFitCat, "pass"),
result = model.fitTo(data, RooFit.Extended(), RooFit.Save())
cf_p = TCanvas('cf_p', 'fit, parametrized')
cf_p_frame = x.frame()
data.plotOn(cf_p_frame)
model.plotOn(cf_p_frame)
cf_p_frame.Draw()
######### model definition, template
nsig_tpl = 10000
nbgd_tpl = 1000000
exp_sig_data = sig.generate(RooArgSet(x), nsig_tpl)
exp_sig_hist = exp_sig_data.binnedClone()
tsig = RooHistPdf('tsig', 'tsig', RooArgSet(x), exp_sig_hist)
exp_bgd_data = bgd.generate(RooArgSet(x), nbgd_tpl)
exp_bgd_hist = exp_bgd_data.binnedClone()
tbgd = RooHistPdf('tbgd', 'tbgd', RooArgSet(x), exp_bgd_hist)
# modelsig = RooAddPdf("modelsig", "modelsig", RooArgList(tsig), RooArgList(vysig))
# tmodel = RooAddPdf("tmodel", "tmodel", RooArgList(tsig), RooArgList(vysig))
tmodel = RooAddPdf("tmodel", "tmodel", RooArgList(tsig, tbgd),
RooArgList(vysig, vybgd))
######### data generation, template
tdata = tmodel.generate(RooArgSet(x), ndata)
# Second Gaussian PDF
mean2 = RooRealVar("mean2", "Mean of Gaussian 2", 1.02052, 1.0, 1.1)
sigma2 = RooRealVar("sigma2", "Width of Gaussian 2", 0.0072, 0.001, 1)
gauss2 = RooGaussian("gauss2", "gauss1(Mkk,mean2,sigma2)", Mkk, mean2, sigma2)
r2 = RooRealVar("r2", "ratio of width of gaussian 2", 3.2, 0, 10)
customGaussR = RooGenericPdf(
"customGaussR", "custom PDF build",
"1/(sigma1*r2) * exp(- (Mkk - mean2)**2 / (2 * (sigma1*r2) ** 2))",
RooArgList(Mkk, mean2, sigma1, r2))
# faster method:
r_sigma2 = RooFormulaVar("r_sigma2", "sigma1 * r2", RooArgList(sigma1, r2))
gauss2R = RooGaussian("gauss2R", "gauss1(Mkk,mean2,sigma2)", Mkk, mean2,
r_sigma2)
toyDataCustom = customGaussR.generate(RooArgSet(Mkk), 100000)
toyData = gauss2.generate(RooArgSet(Mkk), 100000)
toyDataR = gauss2R.generate(RooArgSet(Mkk), 100000)
c = TCanvas("c", "c", 800, 800)
frame1 = Mkk.frame(RooFit.Bins(50), RooFit.Title("Comparison of PDFs"))
# Plot all data tagged as passed sample
toyData.plotOn(frame1)
toyDataR.plotOn(frame1)
toyDataCustom.plotOn(frame1)
#totalPdf.paramOn(frame1, RooFit.Layout(0.55, 0.9, 0.9), RooFit.Format("NEU", RooFit.AutoPrecision(1)))
frame1.Draw()
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 toy_run(n_params,
n_gauss,
n_toys,
toys_nevents,
run_zfit,
intermediate_result_factory=None):
# pdf = chebys[0]
# zfit.settings.set_verbosity(10)
performance = {}
performance["column"] = "number of events"
for nevents in toys_nevents:
# n_toys = 30 if nevents < 50000 else 10
if run_zfit:
zfit.run.create_session(reset_graph=True)
# zfit.sess.close()
# zfit.sess = tf.Session
# initial_param_val, obs, pdf = build_pdf(n_gauss, n_params, run_zfit)
lower = -1
upper = 1
# create observables
if run_zfit:
obs = zfit.Space("obs1", limits=(lower, upper))
else:
obs = RooRealVar("obs", "obs1", lower, upper)
ROOT.SetOwnership(obs, False)
# create parameters
params = []
params_initial = []
mu_lower, mu_upper = 1, 3
sigma_lower, sigma_upper = 0.5, 2
# step_size = 0.003
for i in range(n_params):
if run_zfit:
mu = zfit.Parameter(
f"mu_{i}_{nevents}",
np.random.uniform(low=mu_lower, high=mu_upper),
mu_lower,
mu_upper,
# step_size=step_size
)
sigma = zfit.Parameter(
f"sigma_{i}_{nevents}",
np.random.uniform(low=sigma_lower, high=sigma_upper),
sigma_lower,
sigma_upper,
# step_size=step_size
)
else:
mu_initial = np.random.uniform(mu_lower, mu_upper)
mu = RooRealVar(f"mu_{i}_{nevents}", "Mean of Gaussian",
mu_initial, mu_lower, mu_upper)
ROOT.SetOwnership(mu, False)
sigma_initial = np.random.uniform(mu_lower, mu_upper)
sigma = RooRealVar(f"sigma_{i}_{nevents}", "Width of Gaussian",
sigma_initial, sigma_lower, sigma_upper)
ROOT.SetOwnership(sigma, False)
params_initial.append((mu_initial, sigma_initial))
params.append((mu, sigma))
# create pdfs
pdfs = []
for i in range(n_gauss):
mu, sigma = params[i % n_params]
if run_zfit:
shifted_mu = mu + 0.3 * i
shifted_sigma = sigma + 0.1 * i
pdf = zfit.pdf.Gauss(obs=obs,
mu=shifted_mu,
sigma=shifted_sigma)
# from zfit.models.basic import CustomGaussOLD
# pdf = CustomGaussOLD(obs=obs, mu=shifted_mu, sigma=shifted_sigma)
# pdf.update_integration_options(mc_sampler=tf.random_uniform)
else:
shift1 = RooFit.RooConst(float(0.3 * i))
shifted_mu = RooAddition(f"mu_shifted_{i}_{nevents}",
f"Shifted mu {i}",
RooArgList(mu, shift1))
shift2 = RooFit.RooConst(float(0.1 * i))
shifted_sigma = RooAddition(f"sigma_shifted_{i}_{nevents}",
f"Shifted sigma {i}",
RooArgList(sigma, shift2))
pdf = RooGaussian(f"pdf_{i}_{nevents}", "Gaussian pdf", obs,
shifted_mu, shifted_sigma)
ROOT.SetOwnership(pdf, False)
ROOT.SetOwnership(shift1, False)
ROOT.SetOwnership(shifted_mu, False)
ROOT.SetOwnership(shift2, False)
ROOT.SetOwnership(shifted_sigma, False)
pdfs.append(pdf)
initial_param_val = 1 / n_gauss
fracs = []
for i in range(n_gauss - 1):
frac_value = 1 / n_gauss
lower_value = 0.0001
upper_value = 1.5 / n_gauss
if run_zfit:
frac = zfit.Parameter(f"frac_{i}",
value=1 / n_gauss,
lower_limit=lower_value,
upper_limit=upper_value)
frac.floating = False
else:
frac = RooRealVar(f"frac_{i}_{nevents}", "Fraction of a gauss",
frac_value)
ROOT.SetOwnership(frac, False)
fracs.append(frac)
if run_zfit:
sum_pdf = zfit.pdf.SumPDF(pdfs=pdfs, fracs=fracs)
# sum_pdf.update_integration_options(mc_sampler=tf.random_uniform)
else:
sum_pdf = RooAddPdf(f"sum_pdf_{nevents}", "sum of pdfs",
RooArgList(*pdfs), RooArgList(*fracs))
ROOT.SetOwnership(sum_pdf, False)
pdf = sum_pdf
# Create dictionary to save fit results
failed_fits = 0
successful_fits = 0
performance[nevents] = {"success": [], "fail": []}
if run_zfit:
sampler = pdf.create_sampler(n=nevents, fixed_params=True)
sampler.set_data_range(obs)
nll = zfit.loss.UnbinnedNLL(pdf, sampler)
minimizer = zfit.minimize.MinuitMinimizer(
zfit.minimizers.baseminimizer.ToyStrategyFail(),
verbosity=5,
minimize_strategy=1)
# minimizer.minimizer_options['tol'] = 100
# minimizer._use_tfgrad = False
timer = zfit_benchmark.timer.Timer(f"Toys {nevents}")
if run_zfit:
sampler.resample()
# with tf.device("/device:GPU:0"):
jit_scope = tf.contrib.compiler.jit.experimental_jit_scope
# with jit_scope():
to_run = [nll.value(), nll.gradients()]
zfit.run(to_run)
dependents = pdf.get_dependents()
else:
mgr = ROOT.RooMCStudy(pdf, RooArgSet(obs), RooFit.Silence())
ROOT.SetOwnership(mgr, False)
run_toystudy = False
with progressbar.ProgressBar(max_value=n_toys) as bar:
ident = 0
with timer:
if not run_toystudy:
while successful_fits < n_toys:
# print(f"starting run number {len(fitResults)}")
if run_zfit:
sampler.resample()
for param in dependents:
param.randomize()
else:
for (mu, sigma), (mu_val, sigma_val) in zip(
params, params_initial):
mu.setVal(mu_val)
sigma.setVal(sigma_val)
data = pdf.generate(RooArgSet(obs), nevents)
for mu, sigma in params:
mu.setVal(np.random.uniform(
mu_lower, mu_upper))
sigma.setVal(
np.random.uniform(sigma_lower,
sigma_upper))
with timer.child(
f"toy number {successful_fits} {ident}"
) as child:
if run_zfit:
# sampler.resample()
# with tf.device("/device:GPU:0"):
minimum = minimizer.minimize(nll)
# print(minimum.hesse())
else:
# for mu, sigma in params:
# mu.setVal(np.random.uniform(mu_lower, mu_upper))
# sigma.setVal(np.random.uniform(sigma_lower, sigma_upper))
# for frac in fracs:
# frac.setVal(np.random.uniform(lower_value, upper_value))
result = pdf.fitTo(data, RooFit.NumCPU(12),
RooFit.Save(True),
RooFit.Hesse(False),
RooFit.Minos(False))
if ident == 0:
ident += 1
continue # warm up run
if run_zfit:
if minimum.converged:
bar.update(successful_fits)
successful_fits += 1
fail_or_success = "success"
else:
child.elapsed = Decimal()
failed_fits += 1
fail_or_success = "fail"
else:
if result.status() == 0:
bar.update(successful_fits)
successful_fits += 1
fail_or_success = "success"
else:
child.elapsed = Decimal()
failed_fits += 1
fail_or_success = "fail"
ident += 1
performance[nevents][fail_or_success].append(
float(child.elapsed))
else:
mgr.generateAndFit(n_toys, nevents)
performance[nevents]["success"].append(
[float(timer.elapsed) / n_toys for _ in range(n_toys)])
with open(f"{run_name}tmp.yaml", "w") as f:
if intermediate_result_factory:
dump_result = intermediate_result_factory(performance)
else:
dump_result = performance.copy()
dump_result["ATTENTION"] = "NOT FINISHED"
yaml.dump(dump_result, f)
return performance
