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()