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 main1():
m = RooRealVar('evt.m', 'evt.m', 1.92, 2.02)
mode = RooCategory('evt.mode', 'evt.mode')
mode.defineType('phipi', 0)
aset = RooArgSet('aset')
aset.add(m)
aset.add(mode)
tuplist = tupleList('genmc', 7)
dst, _, f = getTree('/'.join([tuplePath(), tuplist[-1]]))
# dst.Print()
# dst.Show(0)
# for evt in dst:
# print('Hello!')
# print(evt.evt.m)
# break
ds = RooDataSet('ds', 'ds', dst, aset)
print(ds.numEntries())
mean = RooRealVar('mean', 'mean', 1.96, 1.92, 2.0)
width = RooRealVar('width', 'width', 0.006, 0.001, 0.010)
pdf = RooGaussian('pdf', 'pdf', m, mean, width)
pdf.fitTo(ds, Verbose(), Timer(True))
makePlot(m, ds, pdf)
raw_input("Press Enter to continue...")
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")
def fitPed(hist, ws, name='x'):
maxBin = hist.GetMaximumBin()
x = ws.var(name)
#rds = ds.reduce('{1}<{0:0.2f}'.format(hist.GetBinLowEdge(maxBin+2),name))
#rds.Print()
x.setRange('ped_fit', x.getMin(), hist.GetBinLowEdge(maxBin+3))
pedMean = RooRealVar('pedMean', 'mean_{ped}', hist.GetBinCenter(maxBin),
x.getMin(), x.getMax())
pedMean.Print()
pedWidth = RooRealVar('pedWidth', 'sigma_{ped}', 1., 0., 10.)
pedWidth.Print()
ped = RooGaussian('ped', 'ped', x, pedMean, pedWidth)
pedMean.setConstant(False)
ped.fitTo(ws.data('ds'), RooFit.Minos(False), RooFit.Range('ped_fit'),
RooFit.PrintLevel(0))
getattr(ws, 'import')(ped)
def fitPed(hist, ws, name='x'):
maxBin = hist.GetMaximumBin()
x = ws.var(name)
#rds = ds.reduce('{1}<{0:0.2f}'.format(hist.GetBinLowEdge(maxBin+2),name))
#rds.Print()
x.setRange('ped_fit', x.getMin(), hist.GetBinLowEdge(maxBin + 3))
pedMean = RooRealVar('pedMean', 'mean_{ped}', hist.GetBinCenter(maxBin),
x.getMin(), x.getMax())
pedMean.Print()
pedWidth = RooRealVar('pedWidth', 'sigma_{ped}', 1., 0., 10.)
pedWidth.Print()
ped = RooGaussian('ped', 'ped', x, pedMean, pedWidth)
pedMean.setConstant(False)
ped.fitTo(ws.data('ds'), RooFit.Minos(False), RooFit.Range('ped_fit'),
RooFit.PrintLevel(0))
getattr(ws, 'import')(ped)
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 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")
# // data and the p.d.f in the frame
# RooPlot* xframe2 = x.frame(Title("Gaussian p.d.f. with data")) ;
xframe2 = x.frame(RooFit.Title("Gaussian p.d.f. with data"))
# data->plotOn(xframe2) ;
data.plotOn(xframe2)
# gauss.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) ;
gauss.fitTo(data)
# // Print values of mean and sigma (that now reflect fitted values and errors)
#// gauss.plotOn(xframe2,LineColor(kRed)) ;
# mean.Print() ;
# sigma.Print() ;
# gauss.Print();
# Double_t val = gauss.getVal();
# cout<<"val: "<< val << endl;
# // Draw all frames on a canvas
# TCanvas* c = new TCanvas("rf101_basics","rf101_basics",800,400) ;
c = TCanvas("rf101_basics","rf101_basics",800,400)
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()
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)
c.Divide(2)
c.cd(1)
ROOT.gPad.SetLeftMargin(0.15)
xframe.GetYaxis().SetTitleOffset(1.6)
xframe.Draw()
#c.cd(2)
#ROOT.gPad.SetLeftMargin(0.15)
#xframe2.GetYaxis().SetTitleOffset(1.6)
#xframe2.Draw()
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
par1_fitresult = fit_result.floatParsFinal().find("mean2")
par2_fitresult = fit_result.floatParsFinal().find("sigma2")
par1_value = par1_fitresult.getVal()
par1_error = par1_fitresult.getError()
par2_value = par2_fitresult.getVal()
par2_error = par2_fitresult.getError()
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")
# 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))
print "for gauss1"
print "mean1: ", mean1.Print()," sigma1: ",sigma1.Print()
print "for gauss2"
print "mean2: ", mean2.Print()," sigma2: ",sigma2.Print()
# -------------------------------------------
# 2. use gau3's extended PDF to fit data1
xframe2 = x.frame(RooFit.Title("2. use gauss3's extended PDF to fit data1 "))
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()
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
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()
xframe.Draw()
#Create PDF
mean = RooRealVar("mean", "MeanofGaussian", 0, -10, 10)
sigma = RooRealVar("sigma", "WidthofGaussian", 3, -10, 10)
gauss = RooGaussian("gauss", "gauss(x,mean,sigma)", x, mean, sigma)
g1sig = RooRealVar("g1sig", "fraction of gauss1", 10, 0, 100000.0)
# Build signal PDF: f1
signalPDF = RooAddPdf("signalPDF", "g1sig * g1", RooArgList(gauss),
RooArgList(g1sig))
#mean.setConstant(kTRUE); #fix mean
sigma.setRange(0.1, 3)
# change range for sigma
gauss.fitTo(data, RooFit.PrintLevel(-1))
# ffit gauss on data
signalPDF.fitTo(data, RooFit.PrintLevel(-1))
#PrintLevel(-1) almost no output
# Minos(kTRUE)?
mean.Print()
sigma.Print()
#Show parameters on plot
signalPDF.paramOn(xframe, RooFit.Layout(0.55, 0.9, 0.9),
RooFit.Format("NEU", RooFit.AutoPrecision(1)))
signalPDF.plotOn(xframe)
xframe.Draw()
chi2txt = TLatex()
