def crystalBall(mean, sigma_, alpha_, n_, tagged_mass, w, fn, bin, rangeAlpha): sigmaCB = RooRealVar ("#sigma_{%s}^{%s}"%(fn, bin) , "sigmaCB_%s"%fn , sigma_ , 0, 1 ) alpha = RooRealVar ("#alpha_{%s}^{%s}"%(fn, bin) , "#alpha_{%s}^{%s}"%(fn, bin) , alpha_ , rangeAlpha[0], rangeAlpha[1] ) # was 0 - 5 n = RooRealVar ("n_{%s}^{%s}"%(fn, bin) , "n_%s"%fn , n_ , 0.001, 100 ) cbshape = RooCBShape ("cbshape_%s_%s"%(fn,bin) , "cbshape_%s_%s"%(fn, bin) , tagged_mass, mean, sigmaCB, alpha, n) _import(w,cbshape)
def RooFitSig(mbbarray, bdtarray, weightarray, TC_mass, binstart, binend): fitstart = 40 fitend = 150 mbbarray = range(200) bdtarray = range(200) weightarray = range(200) mass = RooRealVar("X", "m(bb)[GeV]", fitstart, fitend) BDT = RooRealVar("BDT", "BDT", -1, 100) weight = RooRealVar("weight", "weight", -100, 200) branchnames = ["X", "BDT", "weight"] dtype = np.dtype([(branchnames[idx], np.float64) for idx in range(len(branchnames))]) treearray = np.array([(mbbarray[idx], bdtarray[idx], weightarray[idx]) for idx in range(len(mbbarray))], dtype) tree = rnp.array2tree(treearray) m0 = RooRealVar("m0", "m0", TC_mass * 1., TC_mass * 1. - 60., TC_mass * 1. + 60.) m02 = RooRealVar("m02", "m02", TC_mass * 1., TC_mass * 1. - 60., TC_mass * 1. + 60.) alpha = RooRealVar("alpha", "alpha", 1.295, 1.0, 1.6) sigma2 = RooRealVar("sigma2", "sigma2", 35, 8., 100) n = RooRealVar("n", "n", 5, 1, 35) mean = RooRealVar("mean", "mean of gaussian", 750, 0, 6000) sigma = RooRealVar("sigma", "width of gaussian", 90, 38, 300) gauss = RooGaussian("gauss", "gaussian PDF", mass, m0, sigma) gauss2 = RooGaussian("gauss2", "gaussian PDF", mass, m02, sigma2) CBshape = RooCBShape("CBshape", "Crystal Ball PDF", mass, m0, sigma2, alpha, n) ##PDF normalization num1 = RooRealVar("num1", "number of events", 400, 0, 5000) ##relative weight of 2 PDFs f = RooRealVar("f", "f", 0.95, 0.6, 1) sigPdf = RooAddPdf("sigPdf", "Signal PDF", RooArgList(CBshape, gauss), RooArgList(f)) extPdf = RooExtendPdf("extPdf", "extPdf", sigPdf, num1) data = RooDataSet("data", "data", tree, RooArgSet(mass, BDT, weight), "BDT>0", "weight") xframe = mass.frame() mass.setBins(20) data.plotOn(xframe) extPdf.plotOn( xframe) #,Normalization(1.0,RooAbsReal.RelativeExpected),LineColor(1)) hist = extPdf.createHistogram("X", fitend - fitstart) hist.SetAxisRange(binstart, binend) return deepcopy(hist)
def DoRooFit(histo, title): can = makeCMSCanvas(str(random.random()),"Fit result ",900,700) #Varible if "ele" in title: x1 = RooRealVar("x1","m_{e^{+}e^{-}}",80,100) if "mu" in title: x1 = RooRealVar("x1","m_{#mu^{+}#mu^{-}}",80,100) #Define CB function m = RooRealVar("mean_{CB}","mean of gaussian",60,120) s = RooRealVar("#sigma_{CB}","width of gaussian",0,3) a = RooRealVar("#alpha_{CB}","mean of gaussian",0,100) n = RooRealVar("n_{CB}","width of gaussian",0,5) CB = RooCBShape("CB","CB PDF",x1, m, s, a, n) m.setConstant(kFALSE) s.setConstant(kFALSE) a.setConstant(kFALSE) n.setConstant(kFALSE) #Define Gaussian function mean1 = RooRealVar("mean_{G}","mean of gaussian",-60,60) sigma1 = RooRealVar("#sigma_{G}","width of gaussian",0,10) gauss1 = RooGaussian("gauss1","gaussian PDF",x1,mean1,sigma1) mean1.setConstant(kFALSE) sigma1.setConstant(kFALSE) #Starting values of the parameters mean1.setVal(1.0) sigma1.setVal(1.0) m.setVal(90.0) s.setVal(1.0) a.setVal(10.0) n.setVal(2.0) # Construct CB (x) gauss x1.setBins(10000, "cache") CBxG = RooFFTConvPdf("CBxG", "CB (X) gauss", x1, CB, gauss1) can.cd() d = RooDataHist("d","d",RooArgList(x1),RooFit.Import(histo)) CBxG.fitTo(d, RooLinkedList()) # Plot PDF and toy data overlaid xframe2 = x1.frame(RooFit.Name("xframe"),RooFit.Title("")) # RooPlot d.plotOn(xframe2, RooLinkedList() ) CBxG.paramOn(xframe2, RooFit.Layout(0.65,0.99,0.9)) xframe2.getAttText().SetTextSize(0.03) CBxG.plotOn(xframe2) xframe2.Draw() can.SaveAs("DataVsMC/FitResults/"+title+"_Roofit.pdf") can.SaveAs("DataVsMC/FitResults/"+title+"_Roofit.png") return;
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 bwcb(mean_, width_, sigma_, alpha_, n_, fn, tagged_mass, w): ## Breit-Wigner meanBW = RooRealVar ("massBW_%s"%fn , "massBW_%s"%fn , mean_ , 3, 7, "GeV") widthBW = RooRealVar ("widthBW_%s"%fn , "widthBW_%s"%fn , width_ , 0, 10 ) bwshape = RooBreitWigner ("bwshape_%s"%fn , "bwshape_%s"%fn , tagged_mass, meanBW, widthBW) meanCB = RooRealVar ("massBW_%s"%fn , "massBW_%s"%fn , 0.) sigmabwCB = RooRealVar ("#sigma_{bwCB}_%s"%fn , "sigmabwCB_%s"%fn , sigma_ , 0, 1 ) alphabw = RooRealVar ("#alphabw_%s"%fn , "alphabw_%s"%fn , alpha_ , 0, 10 ) # was 0 - 5 nbw = RooRealVar ("nbw_%s"%fn , "nbw_%s"%fn , n_ , 0, 25 ) cbshape = RooCBShape ("cbshapebw_%s"%fn , "cbshapebw_%s"%fn , tagged_mass, meanCB, sigmabwCB, alphabw, nbw) cbbw = RooFFTConvPdf( "cbbw_%s"%fn, "cbbw_%s"%fn, tagged_mass, bwshape, cbshape); _import(w,cbbw)
def __init__(self, adc, name): #input ADC values self.adc = adc #2+n reversed Crystal Ball #mean mean_nam = "mean_2n_" + name self.mean_2n = RooRealVar(mean_nam, mean_nam, 50., 250.) # 200. 250. min 150 #sigma sigma_nam = "sigma_2n_" + name self.sigma_2n = RooRealVar(sigma_nam, sigma_nam, 0., 100.) #alpha alpha_nam = "alpha_2xn_" + name self.alpha_2xn = RooRealVar(alpha_nam, alpha_nam, -10., 0.) #n n_nam = "n_2xn_" + name self.n_2xn = RooRealVar(n_nam, n_nam, 0., 20.) #CrystalBall cb_name = "cb_2xn_" + name self.cb_2xn = RooCBShape(cb_name, cb_name, self.adc, self.mean_2n, self.sigma_2n, self.alpha_2xn, self.n_2xn)
def dofit(roodataset, hname): x = RooRealVar("ups_mass", "m_{#mu #mu}", 8.5, 11.0) # choose here binning of mass plot x.setBins(250) # model signal # one CB for each Y(nS) or sum of two CB for each Y(nS) # CB parameters mass1S = RooRealVar('mass1S', 'mass1S', 9.4603, 9.400, 9.500) mass2S = RooRealVar('mass2S', 'mass2S', 10.022, 10.000, 10.040) mass3S = RooRealVar('mass3S', 'mass3S', 10.3552, 10.300, 10.370) sigma1S_1 = RooRealVar('sigma1S_1', 'sigma1S_1', 0.080, 0.010, 0.100) sigma1S_2 = RooRealVar('sigma1S_2', 'sigma1S_2', 0.085, 0.010, 0.100) sigma2S_1 = RooRealVar('sigma2S_1', 'sigma2S_1', 0.085, 0.020, 0.100) sigma2S_2 = RooRealVar('sigma2S_2', 'sigma2S_2', 0.090, 0.020, 0.100) sigma3S_1 = RooRealVar('sigma3S_1', 'sigma3S_1', 0.090, 0.020, 0.100) sigma3S_2 = RooRealVar('sigma3S_2', 'sigma3S_2', 0.095, 0.020, 0.100) alpha = RooRealVar('alpha', 'alpha', 0.5, 0, 5) n = RooRealVar('n', 'n', 0.5, 0, 5) # fix n #signal model cb1S_1 = RooCBShape('y1S_1', 'y1S_1', x, mass1S, sigma1S_1, alpha, n) cb1S_2 = RooCBShape('y1S_2', 'y1S_2', x, mass1S, sigma1S_2, alpha, n) cb2S_1 = RooCBShape('y2S_1', 'y2S_1', x, mass2S, sigma2S_1, alpha, n) cb2S_2 = RooCBShape('y2S_2', 'y2S_2', x, mass2S, sigma2S_2, alpha, n) cb3S_1 = RooCBShape('y3S_1', 'y3S_1', x, mass3S, sigma3S_1, alpha, n) cb3S_2 = RooCBShape('y3S_2', 'y3S_2', x, mass3S, sigma3S_2, alpha, n) cb1frac1S = RooRealVar("cb1frac1S", "cc", 0.1, 0., 1.) cb1frac2S = RooRealVar("cb1frac2S", "cc", 0.1, 0., 1.) cb1frac3S = RooRealVar("cb1frac3S", "cc", 0.1, 0., 1.) # sum of two CB sig1S = RooAddPdf("sig1S", "Signal1S", RooArgList(cb1S_1, cb1S_2), RooArgList(cb1frac1S)) sig2S = RooAddPdf("sig2S", "Signal2S", RooArgList(cb2S_1, cb2S_2), RooArgList(cb1frac2S)) sig3S = RooAddPdf("sig3S", "Signal3S", RooArgList(cb3S_1, cb3S_2), RooArgList(cb1frac3S)) #background model c1 = RooRealVar('c1', 'c1', 200, 0, 3000000) c2 = RooRealVar('c2', 'c2', -1, -50, 50) background = RooPolynomial('bkg', 'bkg', x, RooArgList(c1, c2)) # complete model n1S = RooRealVar('n1s', '', 100000, 0, 10000000) n2S = RooRealVar('n2s', '', 100000, 0, 10000000) n3S = RooRealVar('n3s', '', 100000, 0, 10000000) nbck = RooRealVar('nbck', '', 100000, 0, 10000000) # sum of two CB for each Y(nS) modelPdf = RooAddPdf('model', 'model', RooArgList(sig1S, sig2S, sig3S, background), RooArgList(n1S, n2S, n3S, nbck)) # or one CB for each Y(nS) #modelPdf = RooAddPdf('model','model',RooArgList(cb1S_1,cb2S_1,cb3S_1,background),RooArgList(n1S,n2S,n3S,nbck)) rcut = x.setRange('rcut', 8.5, 11.0) result = modelPdf.fitTo(roodataset, RooFit.Save(), RooFit.Range('rcut')) frame = x.frame(RooFit.Title('mass')) roodataset.plotOn(frame, RooFit.MarkerSize(0.7)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) #plotting canvas = TCanvas('fit', "", 1400, 700) canvas.Divide(1) canvas.cd(1) gPad.SetRightMargin(0.3) gPad.SetFillColor(10) modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9)) frame.Draw() canvas.SaveAs(str(hname) + '.png')
def bw_fit(ecm, infile, outdir, reconstruction): """Breit-Wigner fit of the Mw distribution""" file_ = TFile(infile, "r") file_.cd() mass_ = 'h_mW2' h_mass = gDirectory.Get(mass_) scale = h_mass.GetXaxis().GetBinWidth(1) / (h_mass.Integral("width")) h_mass.Scale(scale) mass_min = 40 mass_max = 120 mass = RooRealVar("Dijet mass", "Dijet mass", mass_min, mass_max, "GeV") # parameters for gaussian function gaus_sig = RooRealVar("#sigma_{G}", "Core Width", 1., 0.5, 10., "GeV") # gaus_sig.setConstant() # parameters for Crystall Ball distribution m_ = RooRealVar("#Delta m", "Bias", 0., -3., 3., "GeV") sigma = RooRealVar("#sigma", "Width", 1.7, 0., 10., "GeV") alpha = RooRealVar("#alpha", "Cut", -0.15, -5., 0.) n = RooRealVar("n", "Power", 2.4, 0.5, 10.) alpha.setConstant() n.setConstant() # Parameters for Breit-Wigner distribution m_res = RooRealVar("M_{W}", "W boson mass", 80.385, 80.0, 81.0, "GeV") width = RooRealVar("#Gamma", "W width", 2.085, 1.5, 2.5, "GeV") m_res.setConstant() width.setConstant() # Cristall-Ball lineshape resG = RooGaussian("resG", "Gaussian distribution", mass, m_, gaus_sig) resCB = RooCBShape("resCB", "Crystal Ball distribution", mass, m_, sigma, alpha, n) fracG = RooRealVar("f_{G}", "Gaussian Fraction", 0., 0., 1.) res = RooAddPdf("res", "Resolution Model", resG, resCB, fracG) # Breit-wigner lineshape bw = RooBreitWigner("bw", "Breit-Wigner distribution", mass, m_res, width) # Convolution bw_CB_conv = RooFFTConvPdf("bw_CB_conv", "Convolution", mass, bw, res) # Background p.d.f bgtau = RooRealVar("a_{BG}", "Backgroung Shape", -0.15, -1.0, 0.0, "1/GeV/c^{2}") bg = RooExponential("bg", "Background distribution", mass, bgtau) # Fit model nentries = h_mass.GetEntries() nsigmin = 0.5 * nentries nsigmean = 1.0 * nentries nsigmax = 1.05 * nentries nbkgmean = 0.01 * nentries nbkgmax = 0.1 * nentries nsig = RooRealVar("N_S", "#signal events", nsigmean, nsigmin, nsigmax) nbkg = RooRealVar("N_B", "#background events", nbkgmean, 0, nbkgmax) model = RooAddPdf("model", "W mass fit", RooArgList(bw_CB_conv, bg), RooArgList(nsig, nbkg)) ###### FIT c_name = "c_ " + mass_ + "_" + str(ecm) + "_" + reconstruction + "_fit" c_mass_fit = TCanvas( c_name, 'Fit of the reconstructed mass distribution with a convolution of Breit-Wigner and Crystal-Ball', 700, 500) c_mass_fit.cd() data = RooDataHist("data", "data", RooArgList(mass), h_mass) frame = mass.frame() data.plotOn(frame) model.fitTo(data, RooFit.Optimize(0)) model.plotOn(frame) model.paramOn(frame, RooFit.Layout(0.6, 0.90, 0.85)) frame.Draw() # norm = h_mass.Integral()/bw_CB_conv.createIntegral(RooArgSet(mass)).getValV() # m = m_.getValV()*norm # s = sigma.getValV()*norm m = m_.getVal() s = sigma.getVal() print("\n\n----------------------------------------------") print(" Fit results :") print(" Bias to apply on mW : {} GeV".format(m)) print(" Mw = {} +/- {} GeV".format((m + 80.385), s)) print("--------------------------------------------------") raw_input("") c_mass_fit.Print("{}fit/fit_{}_{}_{}.pdf".format(outdir, mass_, ecm, reconstruction)) # write into an output file and close the file outfilename = "{}fit/fit_{}_{}.root".format(outdir, mass_, ecm) outfile = TFile(outfilename, "UPDATE") c_mass_fit.Write("", TObject.kOverwrite) outfile.Write() outfile.Close()
crystal_mean = RooRealVar("crystal_mean", "mean of crystal ball", 1.77, 1.5, 1.9) crystal_sigma = RooRealVar("crystal_sigma", "width of crystal ball", 0.02, 0.0, 0.1) n = RooRealVar("n", "power parameter in the crystal ball", 1, 0, 20) alpha = RooRealVar("alpha", "boundry in the crystal ball", 1.75, 1.6, 1.9) crystal_constant = RooRealVar("crystal_constant", "constant", 7417.0, 1769.0, 8011.0) #Parameters of gaussian fit gaus_mean = RooRealVar("gaus_mean", "mean of the gaussian", 1.77, 1.5, 1.9) gaus_sigma = RooRealVar("gaus_sigma", "width of the gaussian", 0.01, 0.0, 0.1) gaus_constant = RooRealVar("gau_constant", "constant of the gaussian", 100, 0, 1000) # Build crystall p.d.f in terms of x,mean and sigma crystalball = RooCBShape("CBShape", "Cystal Ball Function", x, crystal_mean, crystal_sigma, alpha, n) gaus = RooGaussian("GaussShape", "Gaussian Function", x, gaus_mean, gaus_sigma) model = RooAddPdf("model", "model", RooArgList(crystalball, gaus), RooArgList(crystal_constant, gaus_constant)) # Construct plot frame in 'x' #xframe = x.frame(Title("Crystalball p.d.f.")) xframe = x.frame() # --------------------------------------- # Plot model and change parameter values # --------------------------------------- # Change the values of the parameters crystal_mean.setVal(1.776)
def fitChicSpectrum(dataset, binname): """ Fit chic spectrum""" x = RooRealVar('s', 's', -2, 2) x.setBins(200) #signal model q_chi1 = RooRealVar('qchi1', 'q_{#chi 1}', 0.414, 0.2, 0.6) q_chi2 = RooRealVar('qchi2', 'q_{#chi 2}', 0.430, 0.2, 0.6) delta_chi10 = RooRealVar('delta_chi10', 'delta_chi10', 0.09591) q_chi0 = RooFormulaVar('q_chi0', '@0 - @1', RooArgList(q_chi1, delta_chi10)) alphacb_chi1 = RooRealVar('alphacb_chi1', '#alpha^{CB}_{#chi 1}', 0.6, 0, 2) alphacb_chi2 = RooRealVar('alphacb_chi2', '#alpha^{CB}_{#chi 2}', 0.4, 0, 2) sigmacb_chi1 = RooRealVar('sigmacb_chi1', '#sigma^{CB}_{#chi 1}', 0.005, 0, 1) sigmacb_chi2 = RooRealVar('sigmacb_chi2', '#sigma^{CB}_{#chi 2}', 0.005, 0, 1) n_cb = RooRealVar('ncb', 'n^{CB}', 3.0, 0., 5.) gamma_chi0 = RooRealVar('gamma_chi0', 'gamma_chi0', 0.0104) sigmacb_chi0 = RooRealVar('sigmacb_chi0', '#sigma^{CB}_{#chi 0}', 0.005) chi0_sig = RooVoigtian('chi0sig', 'chi0sig,', x, q_chi0, sigmacb_chi0, gamma_chi0) chi1_sig = RooCBShape('chi1sig', 'chi1sig', x, q_chi1, sigmacb_chi1, alphacb_chi1, n_cb) chi2_sig = RooCBShape('chi2sig', 'chi2sig', x, q_chi2, sigmacb_chi2, alphacb_chi2, n_cb) fchi0 = RooRealVar('fchi0', 'f_{#chi 0}', 0.01, 0, 1) fchi1 = RooRealVar('fchi1', 'f_{#chi 1}', 0.5, 0, 1) fchi2 = RooFormulaVar('fchi2', '1-@0-@1', RooArgList(fchi0, fchi1)) fbck = RooRealVar('fbck', 'f_{bck}', 0.2, 0, 1) sigmodel = RooAddPdf('sigm', 'sigm', RooArgList(chi0_sig, chi1_sig, chi2_sig), RooArgList(fchi0, fchi1, fchi2)) #background model q0Start = 0.0 a_bck = RooRealVar('a_bck', 'a_{bck}', 0.5, -5, 5) b_bck = RooRealVar('b_bck', 'b_{bck}', -2.5, -7., 0.) q0 = RooRealVar('q0', 'q0', q0Start) delta = RooFormulaVar('delta', 'TMath::Abs(@0-@1)', RooArgList(x, q0)) bfun = RooFormulaVar('bfun', '@0*(@1-@2)', RooArgList(b_bck, x, q0)) signum = RooFormulaVar('signum', '( TMath::Sign( -1.,@0-@1 )+1 )/2.', RooArgList(x, q0)) background = RooGenericPdf('background', 'Background', 'signum*pow(delta,a_bck)*exp(bfun)', RooArgList(signum, delta, a_bck, bfun)) modelPdf = RooAddPdf('chicmodel', 'chicmodel', RooArgList(sigmodel, background), RooArgList(fbck)) frame = x.frame(RooFit.Title('Q')) range = x.setRange('range', 0, 2) # result = modelPdf.fitTo(dataset,RooFit.Save(),RooFit.Range('range')) dataset.plotOn(frame, RooFit.MarkerSize(0.7)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) #plotting canvas = TCanvas('fit', "", 1400, 700) canvas.Divide(1) canvas.cd(1) gPad.SetRightMargin(0.3) gPad.SetFillColor(10) modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9)) frame.Draw() canvas.SaveAs('out-' + binname + '.png') canvas.SaveAs('out-' + binname + '.root')
def fit_mbc(): from tools import normalizedRooFitIntegral, RooFitIntegral from ROOT import RooRealVar, RooDataSet, RooArgList, RooArgSet, \ RooGaussian, RooArgusBG, RooCBShape, RooAddPdf, RooPolynomial, \ RooDataHist, RooFit, kTRUE, kFALSE signal_margins = [1.86, 1.87] sb_margins = [1.84, 1.85] # Right here we compute background yield mbc = RooRealVar('mbc', 'mbc', 1.83, 1.89, 'GeV') arg_cutoff = RooRealVar('arg_cutoff', 'Argus cutoff', 1.8869, 1.885, 1.888, 'GeV') arg_slope = RooRealVar('arg_slope', 'Argus slope', -13, -100, -1) mbc_d0 = RooRealVar('mbc_d0', 'D0 Mbc', 1.8647, 'GeV') mbc_dp = RooRealVar('mbc_dp', 'D+ Mbc', 1.8694, 'GeV') mbc_float = RooRealVar('mbc_float', 'Floating D mass', 1.869, 1.855, 1.875, 'GeV') sigma = RooRealVar('sigma', 'D width', 0.00145, 0.0001, 0.0025, 'GeV') sigma2 = RooRealVar('sigma2', 'CB width', 0.00145, 0.0001, 0.005, 'GeV') alpha = RooRealVar('alpha', 'CB shape cutoff', -1.515, -2., 2) n = RooRealVar('n', 'CB tail parameter', 6, 0, 20) gauss_d0 = RooGaussian('gauss_d0', 'D0 gaussian', mbc, mbc_d0, sigma2) gauss_dp = RooGaussian('gauss_dp', 'D+ gaussian', mbc, mbc_dp, sigma2) gauss_float = RooGaussian('gauss_float', 'Floating gaussian', mbc, mbc_float, sigma2) cb_d0 = RooCBShape('cb_d0', 'D0 Crystal Barrel', mbc, mbc_d0, sigma, alpha, n) cb_dp = RooCBShape('cb_dp', 'D+ Crystal Barrel', mbc, mbc_dp, sigma, alpha, n) cb_float = RooCBShape('cb_float', 'Floating Crystal Barrel', mbc, mbc_float, sigma, alpha, n) argus = RooArgusBG('argus', 'Argus BG', mbc, arg_cutoff, arg_slope) yld = RooRealVar('yield', 'D yield', 25700, 0, 100000) yld2 = RooRealVar('yield2', '2nd yield', 100, 0, 2000) bkg = RooRealVar('bkg', 'Background', 1300, 0, 40000) a = RooRealVar('a', 'Norm', 1) poly = RooPolynomial('poly', 'poly PDF', mbc, RooArgList(a), 0) sumpdf_d0 = RooAddPdf('sumpdf_d0', 'D0 sum pdf', RooArgList(cb_d0, argus), RooArgList(yld, bkg)) sumpdf_dp = RooAddPdf('sumpdf_dp', 'Dp sum pdf', RooArgList(cb_dp, argus), RooArgList(yld, bkg)) sumpdf_float = RooAddPdf('sumpdf_float', 'Generic D sum pdf', RooArgList(cb_float, argus), RooArgList(yld, bkg)) width_modes = { '0': 0.00150, '1': 0.001831, '3': 0.001426, '200': 0.001387, '202': 0.001407 } n_modes = { '0': 2.68, '1': 4.06, '3': 4.34, '200': 4.05, '202': 5.26 } alpha_modes = { '0': -1.6145, '1': -1.4562, '3': -1.5834, '200': -1.6538, '202': -1.5598 } pdf = sumpdf_float sigma.setVal(width_modes['1']) # sigma.setConstant() n.setVal(n_modes['1']) #n.setConstant() alpha.setVal(alpha_modes['1']) #alpha.setConstant() #sigma.setConstant() #arg_cutoff.setVal(1.8865); #arg_cutoff.setConstant() c1.Divide(1,2) c1.cd(1) dset = RooDataHist('dsetmc', 'title', RooArgList(mbc), h_mbc['mc']) #pdf.fitTo(dset, 'eq') Extended = RooFit.Extended(kTRUE) # e Verbose = RooFit.Verbose(kFALSE) #q pdf.fitTo(dset, Extended, Verbose) # xframe = mbc.frame() # dset.plotOn(xframe) # pdf.plotOn(xframe) # pdf.paramOn(xframe,dset) # xframe.SetTitle('Fake type 1, MC') # xframe.Draw() c1.cd(2) dset = RooDataHist('dsetdata', 'title', RooArgList(mbc), h_mbc['data']) #pdf.fitTo(dset, 'eq') pdf.fitTo(dset, Extended, Verbose) # xframe = mbc.frame() # dset.plotOn(xframe) # pdf.plotOn(xframe) # pdf.paramOn(xframe,dset) # xframe.SetTitle('Fake type 1, data') # xframe.Draw() sb_scale = (normalizedRooFitIntegral(argus, mbc, signal_margins[0], signal_margins[1])/ normalizedRooFitIntegral(argus, mbc, sb_margins[0], sb_margins[1]))
def PeakFit_likelihood(Likelihood_cut: pd.DataFrame, mass_energy: pd.DataFrame, cutval, plots=True, constant_mean=True, constant_width=True, classifier_name='Likelihood', CB=True, Gauss=False, bkg_comb=True, bkg_exp=False, bkg_cheb=False): print('Starting fit...') matplotlib.use('Agg') # Check if we have mass in MeV or GeV if np.mean(mass_energy) > 1000: normalization_mass = 1000 else: normalization_mass = 1 sns.set_style("whitegrid") # White background on plot prediction = Likelihood_cut # rename to prediction # Set range mZmin = 60.0 mZmax = 130.0 # Number of bins NbinsZmass = 100 #Initiate the mass variable m_ee = ROOT.RooRealVar("m_ee", "Invariant mass (GeV/c^{2})", mZmin, mZmax) m_ee.setRange("MC_mZfit_range", mZmin, mZmax) # ============================================================================= # fit signal # ============================================================================= # Make a mask in the signal range. Prediction is 0 or 1, so above 0.5 is signal mask_mass = (mass_energy / normalization_mass > mZmin) & ( mass_energy / normalization_mass < mZmax) & (prediction > 0.5) Z_mass_signal = np.array(mass_energy[mask_mass] / normalization_mass) #Make np.array # Initiate 1D histogram h_mZ_all = ROOT.TH1D("h_mZ_all", "Histogram of Z mass", NbinsZmass, mZmin, mZmax) for isample in range(Z_mass_signal.shape[0]): score = Z_mass_signal[isample] h_mZ_all.Fill(score) # Constructs histogram with m_ee as argument from the 1d histogram h_mZ_all mc_Zee_mZ = ROOT.RooDataHist("mc_Zee_mZ", "Dataset with Zee m_ee", RooArgList(m_ee), h_mZ_all) # Define variables for the fits. # BW: Breit-Wigner. CB: Crystal-Ball meanBW = ROOT.RooRealVar("meanBW", "meanBW", 91.1876, 60.0, 120.0) #91.1876 meanBW.setConstant(True) # this is a theoretical constant sigmaBW = ROOT.RooRealVar("sigmaBW", "sigmaBW", 2.4952, 2.0, 20.0) #2.4952 sigmaBW.setConstant(True) # this is a theoretical constant # if constant_mean: func_BW = ROOT.RooBreitWigner("func_BW", "Breit-Wigner", m_ee, meanBW, sigmaBW) # Make the function from the constants # Crystal ball if CB: meanCB = RooRealVar("meanCB", "meanCB", -0.0716, -10.0, 10.0) # meanCB.setConstant(True) #if commented out, it can float between the minimum and maximum sigmaCB = RooRealVar("sigmaCB", "sigmaCB", 0.193, 0, 15) # sigmaCB.setConstant(True) alphaCB = RooRealVar("alphaCB", "alphaCB", 1.58, 0.0, 10.0) # alphaCB.setConstant(True) nCB = RooRealVar("nCB", "nCB", 0.886, -10, 50.0) # nCB.setConstant(True) func_sig_CB = RooCBShape("func_CB", "Crystal Ball", m_ee, meanCB, sigmaCB, alphaCB, nCB) # Define Crystal-Ball function # Gaussian elif Gauss: # Use Gaussian if True in function call meanGA = RooRealVar("meanGA", "meanGA", 10.0, -10.0, 10.0) sigmaGA = RooRealVar("sigmaGA", "sigmaGA", 3.0, 0.01, 10.0) if constant_width: sigmaGA.setConstant(True) nGA = RooRealVar("nGA", "nGA", 1.5, 0.0, 20.0) func_GA = RooGaussian("func_GA", "Gaussian", m_ee, meanGA, sigmaGA) #, nGA); if CB: # Convolute Breit-Wigner and Crystal-Ball print("Convoluting a Crystal-Ball and Breit-Wigner for signal") func_BWxCB_unextended = RooFFTConvPdf("func_BWxCB_unextended", "Breit-Wigner (X) Crystal Ball", m_ee, func_BW, func_sig_CB) elif Gauss: # Convolute Breit-Wigner and Gauss print("Convoluting a Gauss and Breit-Wigner for signal") func_BWxCB_unextended = RooFFTConvPdf("func_BWxCB_unextended", "Breit-Wigner (X) Gaussian", m_ee, func_BW, func_GA) else: # only Breit-Wigner fit on the signal print("Fitting only with Breit-Wigner for signal") func_BWxCB_unextended = func_BW m_ee.setRange("MC_mZfit_range", 85, 97) # Set the fit range for the signal nsig = RooRealVar("ntotal", "ntotal", 1000, 0, 10e6) # Define the variable for the number of signal func_BWxCB = ROOT.RooExtendPdf("signal_func_Zee", "signal_func_Zee", func_BWxCB_unextended, nsig) # Adding the nsig term to the pdf func_BWxCB.fitTo(mc_Zee_mZ, RooFit.Range("MC_mZfit_range")) # Fit the signal if plots: # Plots the signal using the function "root_plot" defined above mc_Zee_signal = root_plot(m_ee=m_ee, distribution=mc_Zee_mZ, fit=func_BWxCB, mZmin=mZmin, mZmax=mZmax, title=f'signal for cut {cutval}') #cut {cutval} # ============================================================================= # background # ============================================================================= nbkg = RooRealVar("nbkg", "nbkg", 1000, 0, 10e6) # Define the variable for the number of background #if True: m_ee.setRange("MC_mZfit_range", mZmin, mZmax) # Set range for fit as defined in the beginning c_bkg_mZ = ROOT.TCanvas("c_bkg_mZ", "", 0, 0, 1000, 500) # Make the canvas for plotting Z_mass_background = np.array(mass_energy[mask_mass] / normalization_mass) # Mask for background h_mZWenu_all = ROOT.TH1D("h_mZ_all", "Histogram of Z mass", NbinsZmass, mZmin, mZmax) # Initiate 1D histogram for isample in range(Z_mass_background.shape[0]): score = Z_mass_background[isample] h_mZWenu_all.Fill(score) # Create the lin + exponential fit lam = RooRealVar("lambda", "Exponent", -0.04, -5.0, 0.0) func_expo = ROOT.RooExponential("func_expo", "Exponential PDF", m_ee, lam) #coef_pol1 = RooRealVar("coef_pol1", "Slope of background", 0.0, -10.0, 10.0); #func_pol1 = ROOT.RooPolynomial("func_pol1", "Linear PDF", m_ee, RooArgList(coef_pol1)); # Create Chebychev polymonial a0 = RooRealVar("a0", "a0", -0.4, -5.0, 5.0) a1 = RooRealVar("a1", "a1", -0.03, -5.0, 5.0) a2 = RooRealVar("a2", "a2", 0.02, -5.0, 5.0) a3 = RooRealVar("a3", "a3", 0.02, -5.0, 5.0) # Polynomials with different order func_Cpol1 = RooChebychev("func_Cpol1", "Chebychev polynomial of 1st order", m_ee, RooArgList(a0, a1)) func_Cpol2 = RooChebychev("func_Cpol2", "Chebychev polynomial of 2nd order", m_ee, RooArgList(a0, a1, a2)) func_Cpol3 = RooChebychev("func_Cpol3", "Chebychev polynomial of 3rd order", m_ee, RooArgList(a0, a1, a2, a3)) f_exp_mZ = RooRealVar("N_lin_mZ", "CLinear fraction", 0.50, 0, 1) m_ee.setRange("low", 60, 70) m_ee.setRange("high", 110, 130) # Adding exponential and Chebychev if comb: if bkg_comb: func_ExpLin_mZ_unextended = ROOT.RooAddPdf( "func_ExpLin_mZ_unextended", "Exponential and Linear PDF", RooArgList(func_Cpol3, func_expo), RooArgList(f_exp_mZ)) elif bkg_exp: func_ExpLin_mZ_unextended = func_expo elif bkg_cheb: func_ExpLin_mZ_unextended = func_Cpol3 else: print("No background fit called. Exiting") return None func_ExpLin_mZ = ROOT.RooExtendPdf("func_ExpLin_mZ", "func_ExpLin_mZ", func_ExpLin_mZ_unextended, nbkg) # Adding the nbkg term to the pdf # Constructs histogram with m_ee as argument from the 1d histogram h_mZ_all mc_Wenu_mZ = ROOT.RooDataHist("mc_Zee_mZ", "Dataset with Zee m_ee", RooArgList(m_ee), h_mZWenu_all) func_ExpLin_mZ.fitTo(mc_Wenu_mZ, RooFit.Range("MC_mZfit_range")) #ROOT.RooFit.Range("low,high")); # Fits background #Plotting background residue = root_plot(m_ee=m_ee, distribution=mc_Wenu_mZ, fit=func_ExpLin_mZ, mZmin=mZmin, mZmax=mZmax, title=f'Background for cut {cutval}') # # ============================================================================= # Combining signal and background # ============================================================================= m_ee.setRange("MC_mZfit_range", mZmin, mZmax) Z_mass = np.array(mass_energy[mask_mass] / normalization_mass) h_mZWenu = ROOT.TH1D("h_mZ_all", "Histogram of Z mass", NbinsZmass, mZmin, mZmax) for isample in range(Z_mass.shape[0]): score = Z_mass[isample] h_mZWenu.Fill(score) # Constructs histogram with m_ee as argument from the 1d hist ogram h_mZ_all mc_ZeeWenu_mZ = ROOT.RooDataHist("mc_Zee_mZ", "Dataset with Zee m_ee", RooArgList(m_ee), h_mZWenu) ## Fits the data and returns the fraction of background f_bkg_mZ = RooRealVar("f_bkg_mZ", "Signal fraction", nbkg.getVal() / nsig.getVal(), 0.0, 1) ## Combining the signal and background fits func_SigBkg_mZ_unextended = ROOT.RooAddPdf( "func_SigBkg_mZ", "Signal and Background PDF", RooArgList(func_ExpLin_mZ_unextended, func_BWxCB_unextended), RooArgList(f_bkg_mZ)) # func_SigBkg_mZ_unextended = func_BWxCB_unextended;#ROOT.RooAddPdf("func_SigBkg_mZ", "Signal and Background PDF", RooArgList(func_BWxCB_unextended, func_BWxCB_unextended), RooArgList(f_bkg_mZ)); ntotal = RooRealVar("ntotal", "ntotal", 10000, 0, 10e6) func_SigBkg_mZ = ROOT.RooExtendPdf("func_ExpLin_mZ", "func_ExpLin_mZ", func_SigBkg_mZ_unextended, ntotal) func_SigBkg_mZ.fitTo(mc_ZeeWenu_mZ) # Fits the full data set if plots: mc_ZeeWenu_mZ_resid = root_plot(m_ee=m_ee, distribution=mc_ZeeWenu_mZ, fit=func_SigBkg_mZ, mZmin=mZmin, mZmax=mZmax, title=f'Bkg+Sig for cut {cutval}') # Baseline ntotal = 41231 (Data) # fraction 0.9333 # Baseline ntotal = 74747 (MC) # fraction 0.4427 # Malte script len(Z_mass) bkg = len(Z_mass) * f_bkg_mZ.getVal() sig = len(Z_mass) * (1 - f_bkg_mZ.getVal()) print(f_bkg_mZ.getVal()) #DATA #BL_sig = 41231*(1-0.9333) # BL = baseline, the number is the fraction of bkg in baseline #BL_bkg = 41231*0.9333 # BL = baseline # DATA OS # BL_sig = 22276 * (1-0.853) # BL = baseline, the number is the fraction of bkg in baseline # BL_bkg = 22276 * 0.853 # BL = baseline # DATA SS # BL_sig = 18925 * (1-0.993552)#74747 * (1-0.4427)#41054 # BL_bkg = 18925 - BL_sig #MC OS # exp BL_sig = 46547 * (1 - 0.0350) #74747 * (1-0.4427)#41054 BL_bkg = 46547 * 0.0350 #comb #BL_sig = 74747*(1-0.4427) # BL = baseline, the number is the fraction of bkg in baseline #BL_bkg = 74747*0.4427 # BL = baseline bkg_ratio = bkg / BL_bkg sig_ratio = sig / BL_sig max_residue = max(abs(mc_ZeeWenu_mZ_resid.getYAxisMax()), abs(mc_ZeeWenu_mZ_resid.getYAxisMin())) print(max_residue) print(bkg_ratio) print(sig_ratio) if (bkg_ratio < 1.009) & (sig_ratio < 1.009) & (abs( mc_ZeeWenu_mZ_resid.getYAxisMin()) < 4) & (abs( mc_ZeeWenu_mZ_resid.getYAxisMax()) < 4): # input('....') return BL_sig, BL_bkg, sig_ratio, bkg_ratio #max_residue, ntotal.getVal(), nsig.getVal(), nbkg.getVal()return sigmaCB if CB else sigmaGA #sig_ratio, sigma_sig, bkg_ratio, sigma_bkg else: return 0, 0, 0, 0
def doMCFit(inputfile_name, mass_chib, cuts, output_name='ChiB', plotTitle="#Chi_{b}", fittedVariable='qValue', returnOnlyFitResult=False, useOtherSignalParametrization=False, drawPulls=False, legendOnPlot=True): mass_error = 0.15 print "Creating DataSet from file " + str(inputfile_name) dataSet = makeRooDataset(inputfile_name) if (fittedVariable == 'refittedMass'): x_var = 'rf1S_chib_mass' output_suffix = '_refit' x_axis_label = 'm_{#mu^{+} #mu^{-} #gamma} [GeV]' else: x_var = 'invm1S' output_suffix = '_qValue' x_axis_label = 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon} [GeV]' cuts_str = str(cuts) #cuts_str = quality_cut +"photon_pt > 0.5 && abs(photon_eta) < 1.0 && abs(dimuon_rapidity) < 1.0 && dimuon_pt>5.0 && pi0_abs_mass > 0.025 && fabs(dz) < 0.1 "#&& numPrimaryVertices < 16" data = dataSet.reduce(RooFit.Cut(cuts_str)) print 'Creating pdf' x = RooRealVar(x_var, 'm(#mu #mu #gamma) - m(#mu #mu) + m_{#Upsilon}', 9.8, 9.96) #9.7,10.1,'GeV') numBins = 32 # define here so that if I change it also the ndof change accordingly x.setBins(numBins) # Double sided Crystal Ball mean = RooRealVar("#mu", "mean ChiB", mass_chib, mass_chib - mass_error, mass_chib + mass_error, "GeV") sigma = RooRealVar("#sigma", "sigma ChiB", 0.006, 0, 0.2, 'GeV') a1 = RooRealVar('#alpha1', '#alpha1', 0.75, 0, 3) a2 = RooRealVar('#alpha2', '#alpha2', 1.6, 0, 3) n1 = RooRealVar('n1', 'n1', 2.8) #, 1.0,4.0) # 2 per 2S n2 = RooRealVar('n2', 'n2', 3) #, 1.,4.0) # 1 per 2S parameters = RooArgSet(mean, sigma, a1, a2, n1, n2) cb_pdf = My_double_CB('chib', 'chib', x, mean, sigma, a1, n1, a2, n2) #cb_pdf = RooCBShape('chib', 'chib', x, mean, sigma, a1, n1) # ndof floatPars = parameters.selectByAttrib("Constant", ROOT.kFALSE) ndof = numBins - floatPars.getSize() - 1 if useOtherSignalParametrization: # In this case I redefine cb_pdf n1 = RooRealVar('n1', 'n1', 2) cb = RooCBShape('cb1', 'cb1', x, mean, sigma, a1, n1) # I use a2 as the sigma of my second CB a2 = RooRealVar('#alpha2', '#alpha2', 0.5, 0, 3) gauss = RooCBShape('cb2', 'cb2', x, mean, a2, a1, n1) # I use n2 as the ratio of cb1 with respect to cb2 n2 = RooRealVar('n2', 'n2', 0., 1.) cb_pdf = RooAddPdf('chib', 'chib', RooArgList(cb, gauss), RooArgList(n2)) #cb_pdf = cb print 'Fitting to data' fit_region = x.setRange("fit_region", 9.8, 9.96) result = cb_pdf.fitTo(data, RooFit.Save(), RooFit.Range("fit_region")) # a1_val = a1.getVal() # a2_val = a2.getVal() # a1 = RooRealVar('#alpha1', '#alpha1', a1_val) # a2 = RooRealVar('#alpha2', '#alpha2', a2_val) # n1 = RooRealVar('n1', 'n1', 1.7,1.0,5.) # n2 = RooRealVar('n2', 'n2', 1.7,0.,4.) # cb_pdf = My_double_CB('chib', 'chib', x, mean, sigma, a1, n1, a2, n2) # result = cb_pdf.fitTo(data, RooFit.Save()) if returnOnlyFitResult: return result # define frame frame = x.frame() frame.SetNameTitle("fit_resonance", "Fit Resonanace") frame.GetXaxis().SetTitle(x_axis_label) frame.GetYaxis().SetTitle("Events/5 MeV ") frame.GetXaxis().SetTitleSize(0.04) frame.GetYaxis().SetTitleSize(0.04) frame.GetXaxis().SetTitleOffset(1.1) frame.GetXaxis().SetLabelSize(0.04) frame.GetYaxis().SetLabelSize(0.04) frame.SetLineWidth(1) frame.SetTitle(plotTitle) # plot things on frame data.plotOn(frame, RooFit.MarkerSize(0.7)) cb_pdf.plotOn(frame, RooFit.LineWidth(2)) # chiSquare legend chi2 = frame.chiSquare() probChi2 = TMath.Prob(chi2 * ndof, ndof) chi2 = round(chi2, 2) probChi2 = round(probChi2, 2) leg = TLegend(0.3, 0, .10, .10) leg.SetBorderSize(0) leg.SetFillStyle(0) cb_pdf.paramOn(frame, RooFit.Layout(0.17, 0.56, 0.93)) leg.AddEntry(0, '#chi^{2} =' + str(chi2), '') leg.AddEntry(0, 'Prob #chi^{2} = ' + str(probChi2), '') leg.SetTextSize(0.04) frame.addObject(leg) if legendOnPlot: legend = TLegend(.08, .5, .55, .7) #legend.SetTextSize(0.04) legend.SetFillStyle(0) legend.SetBorderSize(0) #legend.AddEntry(0,'CMS','') legend.AddEntry( 0, str(cuts.upsilon_pt_lcut) + ' GeV < p_{T}(#Upsilon) < ' + str(cuts.upsilon_pt_hcut) + ' GeV', '') #legend.AddEntry(0,'p_{T}(#Upsilon)<'+str(cuts.upsilon_pt_hcut),'') frame.addObject(legend) title = TLegend(.8, .75, .9, .93) title.SetTextSize(0.15) title.SetFillStyle(0) title.SetBorderSize(0) title.AddEntry(0, plotTitle, '') frame.addObject(title) # Canvas c1 = TCanvas(output_name + output_suffix, output_name + output_suffix) frame.Draw() if drawPulls: #c1=TCanvas(output_name+output_suffix,output_name+output_suffix,700, 625) hpull = frame.pullHist() framePulls = x.frame() framePulls.SetTitle(';;Pulls') framePulls.GetYaxis().SetLabelSize(0.18) framePulls.GetYaxis().SetTitle('Pulls') framePulls.GetYaxis().SetTitleSize(0.18) framePulls.GetYaxis().SetTitleOffset(0.15) framePulls.GetYaxis().SetNdivisions(005) framePulls.GetXaxis().SetLabelSize(0.16) framePulls.GetXaxis().SetTitle('') line0 = TLine(9.8, 0, 9.96, 0) line0.SetLineColor(ROOT.kBlue) line0.SetLineWidth(2) framePulls.addObject(line0) framePulls.addPlotable(hpull, "P") framePulls.SetMaximum(5) framePulls.SetMinimum(-5) pad1 = TPad("pad1", "The pad 80% of the height", 0.0, 0.2, 1.0, 1.0) pad1.cd() frame.Draw() pad2 = TPad("pad2", "The pad 20% of the height", 0.0, 0.01, 1.0, 0.2) pad2.cd() framePulls.Draw() c1.cd() pad1.Draw() pad2.Draw() #c1.SaveAs(output_name+output_suffix+'.png') print 'Chi2 = ' + str(frame.chiSquare()) pdf_parameters = CB_parameters(mean=mean.getVal(), sigma=sigma.getVal(), n1=n1.getVal(), n2=n2.getVal(), a1=a1.getVal(), a2=a2.getVal(), s_mean=mean.getError(), s_sigma=sigma.getError(), s_n1=n1.getError(), s_n2=n2.getError(), s_a1=a1.getError(), s_a2=a2.getError(), chiSquare=frame.chiSquare()) #pdf_parameters.saveToFile("CB_"+output_name+output_suffix+".txt") return pdf_parameters, c1
def plot_rec_minus_gen_pt2(): #reconstructed pT^2 vs. generated pT^2 for resolution #distribution range ptbin = 0.001 ptmin = -0.1 ptmax = 0.15 #generated pT^2 selection to input data ptlo = 0.04 pthi = 0.1 #mass selection mmin = 2.8 mmax = 3.2 fitran = [-0.003, 0.05] #fitran = [-0.003, 0.003] strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax) strsel += " && (jGenPt*jGenPt)>{0:.3f}".format(ptlo) strsel += " && (jGenPt*jGenPt)<{0:.3f}".format(pthi) print strsel nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax) hPt2 = ut.prepare_TH1D("hPt2", ptbin, ptmin, ptmax) ytit = "Events / ({0:.3f}".format(ptbin) + " GeV^{2})" xtit = "#it{p}_{T, reconstructed}^{2} - #it{p}_{T, generated}^{2} (GeV^{2})" ut.put_yx_tit(hPt2, ytit, xtit) draw = "(jRecPt*jRecPt)-(jGenPt*jGenPt)" mctree.Draw(draw + " >> hPt2", strsel) #roofit binned data x = RooRealVar("x", "x", -1, 1) dataH = RooDataHist("dataH", "dataH", RooArgList(x), hPt2) x.setRange("fitran", fitran[0], fitran[1]) #reversed Crystal Ball mean = RooRealVar("mean", "mean", 0., -0.1, 0.1) sigma = RooRealVar("sigma", "sigma", 0.0011, 0., 0.1) alpha = RooRealVar("alpha", "alpha", -1.046, -10., 0.) n = RooRealVar("n", "n", 1.403, 0., 20.) pdf = RooCBShape("pdf", "pdf", x, mean, sigma, alpha, n) #gaus = RooGaussian("gaus", "gaus", x, mean, sigma) #make the fit #res = pdf.fitTo(dataH, rf.Range("fitran"), rf.Save()) #res = gaus.fitTo(dataH, rf.Range("fitran"), rf.Save()) can = ut.box_canvas() ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.015, 0.03) frame = x.frame(rf.Bins(nbins), rf.Title("")) frame.SetTitle("") frame.SetYTitle(ytit) frame.SetXTitle(xtit) frame.GetXaxis().SetTitleOffset(1.2) frame.GetYaxis().SetTitleOffset(1.7) dataH.plotOn(frame, rf.Name("data")) pdf.plotOn(frame, rf.Precision(1e-6), rf.Name("pdf")) #gaus.plotOn(frame, rf.Precision(1e-6), rf.Name("gaus")) frame.Draw() ut.invert_col(rt.gPad) can.SaveAs("01fig.pdf")
def RooFitHist(inputhist,title='title',path='.'): # RooFit.gErrorIgnoreLevel = RooFit.kInfo # <6.02 # RooFit.SetSilentMode()# >6.02 # RooMsgService().instance().SetSilentMode(kTRUE) fitbinning=array('d') binwidth=200 #NBins=(14000/binwidth) - ( (1040/binwidth) + 1 ) Mjj NBins=(8000/binwidth) - ( (200/binwidth)+1 )#pT for i in range(NBins+1): fitbinning.append(210+i*binwidth)# Mjj 1050 # print(fitbinning) #import numpy as np #fitbinning=np.linspace(0,8000,81) hist=inputhist.Rebin(NBins,"fit parameter",fitbinning) #hist=inputhist.Rebin(80,"fit parameter", fitbinning) #meanstart=hist.GetBinCenter(2000) meanstart=hist.GetBinCenter(hist.GetMaximumBin())#maximum sigmastart=hist.GetRMS() #sigmastart=3000 print('meanstart:',meanstart,'sigmastart:',sigmastart) # inputhist.Draw() # hist.Draw() # hold=raw_input('press enter to exit.') gStyle.SetOptFit(1111) gStyle.SetOptTitle(0) RooFit.SumW2Error(kTRUE) RooFit.Extended(kTRUE) # RooDataHist::adjustBinning(dh): fit range of variable mjj expanded to nearest bin boundaries: [1050,13850] --> [1050,13850] mjj=RooRealVar('mjj','P_{T-AK8}',fitbinning[0],fitbinning[len(fitbinning)-1],'GeV') mjjral=RooArgList(mjj) dh=RooDataHist('dh','dh',mjjral,RooFit.Import(hist)) #shape.fitTo(dh,RooFit.Range("FitRange"),RooFit.Extended(True),RooFit.SumW2Error(False)) shapes={} #Gaussian not really # 3rd, 4th and 5th arguments are: (starting value, minimum possible value, maximum possible value) -- not goot gaussmean = RooRealVar('#mu_{gauss}','mass mean value',meanstart,0,2*meanstart) gausssigma= RooRealVar('#sigma_{gauss}','mass resolution',sigmastart,0,2*meanstart) gauss=RooGaussian('gauss','gauss',mjj,gaussmean,gausssigma) shapes.update({'Gauss':gauss}) #poisson poissonmean = RooRealVar('#mu_{poisson}', 'pT mean value', meanstart,0,2*meanstart) poissonsigma = RooRealVar('#sigma_{poisson]', 'pT resolution', sigmastart, 0, 2*sigmastart) poisson = RooPoisson('poisson', 'poisson', mjj, poissonmean, False) shapes.update({'Poisson': poisson}) #Landau -- not good landaumean=RooRealVar('#mu_{landau}','mean landau',meanstart,0,2*meanstart) landausigma= RooRealVar('#sigma_{landau}','mass resolution',sigmastart,0,2*sigmastart)#bzw8 landau=RooLandau('landau','landau',mjj,landaumean,landausigma) shapes.update({'Landau':landau}) #CrystalBall -> this is close to be good but matrix error :( mean = RooRealVar('#mu','mean',meanstart,0,2*meanstart) sigma= RooRealVar('#sigma','sigma',sigmastart,0,2*sigmastart) alpha=RooRealVar('#alpha','Gaussian tail',-1000,0) n=RooRealVar('n','Normalization',-1000,1000) cbshape=RooCBShape('cbshape','crystalball PDF',mjj,mean,sigma,alpha,n) shapes.update({'CrystalBall':cbshape}) #Voigt ---pff voigtmean = RooRealVar('#mu','mass mean value',meanstart,0,2*meanstart) voigtwidth = RooRealVar('#gamma','width of voigt',0,100) voigtsigma= RooRealVar('#sigma','mass resolution',sigmastart,0,150) voigt=RooVoigtian('voigt','voigt',mjj,voigtmean,voigtwidth,voigtsigma) shapes.update({'Voigt':voigt}) #BreitWigner--worst bwmean = RooRealVar('#mu','mass mean value',meanstart,0,2*meanstart) bwwidth = RooRealVar('#sigma','width of bw',sigmastart,100, 150) bw=RooBreitWigner('bw','bw',mjj,bwmean,bwwidth) shapes.update({'BreitWigner':bw}) #Logistics #logisticsmean=RooRealVar('#mu_{logistics}','mean logistics',meanstart,0,2*meanstart) #logisticssigma= RooRealVar('#sigma_{logistics}','mass resolution',sigmastart,0,2*sigmastart) #logistics=RooLogistics('logistics','logistics',mjj,logisticsmean,logisticssigma) #shapes.update({'Logistics':logistics}) #ExpAndGauss expgaussmean=RooRealVar('#mu_{expgauss}','mean expgauss',meanstart,490,900) expgausssigma= RooRealVar('#sigma_{expgauss}','mass resolution',sigmastart,20,3*sigmastart) expgausstrans= RooRealVar('trans','trans',0,1000) ExpAndGauss=RooExpAndGauss('expgauss','expgauss',mjj,expgaussmean,expgausssigma,expgausstrans) shapes.update({'ExpAndGauss':ExpAndGauss}) #Exp #expmean=RooRealVar('') #BifurGauss -bad BifurGaussmean=RooRealVar('#mu_{BifurGauss}','mean BifurGauss',meanstart,0,2*meanstart) BifurGausslsigma= RooRealVar('#sigma_{left}','mass resolution',sigmastart,200,2*sigmastart)#2*sigmastart BifurGaussrsigma= RooRealVar('#sigma_{right}','mass resolution',sigmastart,200,2*sigmastart) BifurGauss=RooBifurGauss('BifurGauss','BifurGauss',mjj,BifurGaussmean,BifurGausslsigma,BifurGaussrsigma) shapes.update({'BifurGauss':BifurGauss}) #Chebychev -nope Chebychev1=RooRealVar('c0','Chebychev0',-1000,1000) Chebychev2= RooRealVar('c1','Chebychev1',-1000,1000) Chebychev3= RooRealVar('c2','Chebychev2',2,-1000,1000) Chebychev=RooChebychev('Chebychev','Chebychev',mjj,RooArgList(Chebychev1,Chebychev2,Chebychev3)) shapes.update({'Chebychev':Chebychev}) #Polynomial -nope Polynomial1=RooRealVar('Polynomial1','Polynomial1',100,0,1000) Polynomial2= RooRealVar('Polynomial2','Polynomial2',100,0,1000) Polynomial=RooPolynomial('Polynomial','Polynomial',mjj,RooArgList(Polynomial1,Polynomial2)) shapes.update({'Polynomial':Polynomial}) #pareto #___________________________________________________________We will see #Convolutions #-> use bin > 1000 for better accuracy -----cyclic trouble #-> Convolution depends on order!!! RooFFTConvPdf the first p.d.f. is the theory model and that the second p.d.f. is the resolution model # #LandauGauss Convolution - really bad landaugauss=RooFFTConvPdf('landaugauss','landau x gauss',mjj,landau, gauss) #landaugauss.setBufferFraction(126) shapes.update({'LandauGauss':landaugauss}) #GaussLandau Convolution -> Better but NOT posdef. ...but for 100 it is gausslandau=RooFFTConvPdf('gausslandau','gauss x landau ',mjj,gauss,landau) #gausslandau.setBufferFraction(126) shapes.update({'GaussLandau':gausslandau}) #CrystalBallLandau Convolution cbshape x landau looks better -> status failed crystlandau=RooFFTConvPdf('crystallandau','cbshape x landau', mjj, landau, cbshape) crystlandau.setBufferFraction(39) shapes.update({'CrystLandau': crystlandau}) #BifurGaussLandau Convolution -> Better in look, NO matrix error for Binwidth 200 BifurGaussLandau=RooFFTConvPdf('bifurgausslandau','landau x bifurgauss',mjj,landau, BifurGauss) BifurGaussLandau.setBufferFraction(39) #against over cycling shapes.update({'BifurGaussLandau':BifurGaussLandau}) #CrystalGauss Convolution looks better -> status failed crystgauss=RooFFTConvPdf('crystalgauss','cbshape x gauss', mjj, cbshape, gauss) #crystgauss.setBufferFraction(39) shapes.update({'CrystGauss': crystgauss}) #BreitWignerLandau Convolution (Breitwigner = Lorentz)-> status OK.... BreitWignerLandau=RooFFTConvPdf('breitwignerlandau','breitwigner x landau',mjj,landau,bw,3) #BreitWignerLandau.setBufferFraction(48) #setBufferFraction(fraction of the sampling array size) ->cyclic behaviour fix #crystgauss.setShift(0,0) #s1 and s2 are the amounts by which the sampling ranges for pdf's are shifted respectively #(0,-(xmin+xmax)/2) replicates the default behavior #(0,0) disables the shifting feature altogether shapes.update({'BreitWignerLandau':BreitWignerLandau}) for fname in ['ExpAndGauss']: plottitle='%s Fit of %s'%(fname,title) shape=shapes[fname] # shape.fitTo(dh,RooFit.Range("FitRange"),RooFit.SumW2Error(True)) #shape.fitTo(dh,RooFit.Extended(True),RooFit.SumW2Error(True)) mjj.setRange("FitRange",500,4000)#tried shape.fitTo(dh,RooFit.Range("FitRange"),RooFit.Extended(False),RooFit.SumW2Error(True)) frame=mjj.frame(RooFit.Title(plottitle)) #frame.GetYaxis().SetTitleOffset(2) dh.plotOn(frame,RooFit.MarkerStyle(4)) shape.plotOn(frame,RooFit.LineColor(2)) ndof=dh.numEntries()-3 print ('ndof', ndof) #chiSquare legend chi2 = frame.chiSquare()#there are 2 chiSquare. the 2cond returns chi2/ndf /// \return \f$ \chi^2 / \mathrm{ndf} \f$ print ('chi2', chi2) probChi2 = TMath.Prob(chi2*ndof, ndof)# why chi2*ndof ?! makes no sense to me #Double_t Prob(Double_t chi2, Int_t ndf) #Computation of the probability for a certain Chi-squared (chi2) #and number of degrees of freedom (ndf). #P(a,x) represents the probability that the observed Chi-squared #for a correct model should be less than the value chi2. #The returned probability corresponds to 1-P(a,x), !!!! #which denotes the probability that an observed Chi-squared exceeds #the value chi2 by chance, even for a correct model. #--- NvE 14-nov-1998 UU-SAP Utrecht #probChi2=TMath.Prob(chi2, ndof) chi2 = round(chi2,2) #probChi2 = round(probChi2,2) leg = TLegend(0.5,0.5,0.5,0.65)#0.9 leg.SetBorderSize(0) leg.SetFillStyle(0) shape.paramOn(frame, RooFit.Layout(0.5,0.9,0.9)) leg.AddEntry(0,'#chi^{2} ='+str(chi2),'') leg.AddEntry(0,'Prob #chi^{2} = '+str(probChi2),'') leg.SetTextSize(0.04) frame.addObject(leg) canv=TCanvas(plottitle,plottitle,700,700) canv.SetLogy() canv.SetLeftMargin(0.20) canv.cd() frame.SetMaximum(10**(1)) frame.SetMinimum(10**(-11))#from -3 -> -6 frame.Draw() #canv.Print(path+'/%s__%sS2MoreLessY.pdf'%(title,fname)) raw_input('press enter to continue') return chi2
def plot_rec_minus_gen_pt(): #reconstructed pT vs. generated pT for resolution #distribution range ptbin = 0.005 ptmin = -0.2 ptmax = 0.4 #generated pT selection to input data ptlo = 0 pthi = 0.1 #mass selection mmin = 2.8 mmax = 3.2 #range for the fit fitran = [-0.02, 0.2] strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax) strsel += " && jGenPt>{0:.3f}".format(ptlo) strsel += " && jGenPt<{0:.3f}".format(pthi) nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax) hPtDiff = ut.prepare_TH1D("hPtDiff", ptbin, ptmin, ptmax) ytit = "Events / ({0:.3f}".format(ptbin) + " GeV)" xtit = "#it{p}_{T, reconstructed} - #it{p}_{T, generated} (GeV)" mctree.Draw("jRecPt-jGenPt >> hPtDiff", strsel) #roofit binned data x = RooRealVar("x", "x", -1, 1) x.setRange("fitran", fitran[0], fitran[1]) rfPt = RooDataHist("rfPt", "rfPt", RooArgList(x), hPtDiff) #reversed Crystal Ball mean = RooRealVar("mean", "mean", 0., -0.1, 0.1) sigma = RooRealVar("sigma", "sigma", 0.01, 0., 0.1) alpha = RooRealVar("alpha", "alpha", -1.046, -10., 0.) n = RooRealVar("n", "n", 1.403, 0., 20.) pdf = RooCBShape("pdf", "pdf", x, mean, sigma, alpha, n) #make the fit res = pdf.fitTo(rfPt, rf.Range("fitran"), rf.Save()) can = ut.box_canvas() ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.05, 0.03) frame = x.frame(rf.Bins(nbins), rf.Title("")) ut.put_frame_yx_tit(frame, ytit, xtit) rfPt.plotOn(frame, rf.Name("data")) pdf.plotOn(frame, rf.Precision(1e-6), rf.Name("pdf")) frame.Draw() ut.invert_col(rt.gPad) can.SaveAs("01fig.pdf")
def plot_rec_gen_pt_relative(): # relative dielectron pT resolution as ( pT_rec - pT_gen )/pT_gen ptbin = 0.01 ptmin = -1.2 ptmax = 4 #generated pT selection to input data ptlo = 0.2 pthi = 1. fitran = [-0.1, 3] mmin = 2.8 mmax = 3.2 #output log file out = open("out.txt", "w") #log fit parameters loglist1 = [(x, eval(x)) for x in ["infile_mc", "ptbin", "ptmin", "ptmax"]] loglist2 = [(x, eval(x)) for x in ["ptlo", "pthi", "fitran", "mmin", "mmax"]] strlog = ut.make_log_string(loglist1, loglist2) ut.log_results(out, strlog + "\n") strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax) strsel += " && jGenPt>{0:.3f}".format(ptlo) strsel += " && jGenPt<{0:.3f}".format(pthi) nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax) hPtRel = ut.prepare_TH1D("hPtRel", ptbin, ptmin, ptmax) ytit = "Events / ({0:.3f})".format(ptbin) xtit = "(#it{p}_{T, rec} - #it{p}_{T, gen})/#it{p}_{T, gen}" mctree.Draw("(jRecPt-jGenPt)/jGenPt >> hPtRel", strsel) x = RooRealVar("x", "x", ptmin, ptmax) x.setRange("fitran", fitran[0], fitran[1]) rfPtRel = RooDataHist("rfPtRel", "rfPtRel", RooArgList(x), hPtRel) #reversed Crystal Ball mean = RooRealVar("mean", "mean", 0., -0.1, 0.1) sigma = RooRealVar("sigma", "sigma", 0.2, 0., 0.9) alpha = RooRealVar("alpha", "alpha", -1.2, -10., 0.) n = RooRealVar("n", "n", 1.3, 0., 20.) cbpdf = RooCBShape("cbpdf", "cbpdf", x, mean, sigma, alpha, n) res = cbpdf.fitTo(rfPtRel, rf.Range("fitran"), rf.Save()) #log fit results ut.log_results(out, ut.log_fit_result(res)) can = ut.box_canvas() ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.05, 0.03) frame = x.frame(rf.Bins(nbins), rf.Title("")) ut.put_frame_yx_tit(frame, ytit, xtit) rfPtRel.plotOn(frame, rf.Name("data")) cbpdf.plotOn(frame, rf.Precision(1e-6), rf.Name("cbpdf")) frame.Draw() desc = pdesc(frame, 0.65, 0.8, 0.057) #x, y, sep desc.set_text_size(0.03) desc.itemD("#chi^{2}/ndf", frame.chiSquare("cbpdf", "data", 4), -1, rt.kBlue) desc.prec = 5 desc.itemR("mean", mean, rt.kBlue) desc.prec = 4 desc.itemR("#sigma", sigma, rt.kBlue) desc.itemR("#alpha", alpha, rt.kBlue) desc.prec = 3 desc.itemR("#it{n}", n, rt.kBlue) desc.draw() leg = ut.prepare_leg(0.6, 0.82, 0.21, 0.12, 0.03) # x, y, dx, dy, tsiz leg.SetMargin(0.05) leg.AddEntry(0, "#bf{%.1f < #it{p}_{T}^{pair} < %.1f GeV}" % (ptlo, pthi), "") leg.Draw("same") #ut.invert_col(rt.gPad) can.SaveAs("01fig.pdf")
def plot_rec_gen_track_pt(): #track pT resolution as ( pT_track_rec - pT_track_gen )/pT_track_gen ptbin = 0.001 ptmin = -0.3 ptmax = 0.1 #generated dielectron pT selection to input data ptlo = 0.2 pthi = 1 fitran = [-0.15, 0.018] mmin = 2.8 mmax = 3.2 ccb = rt.kBlue #output log file out = open("out.txt", "w") #log fit parameters loglist1 = [(x, eval(x)) for x in ["infile_mc", "ptbin", "ptmin", "ptmax"]] loglist2 = [(x, eval(x)) for x in ["ptlo", "pthi", "fitran", "mmin", "mmax"]] strlog = ut.make_log_string(loglist1, loglist2) ut.log_results(out, strlog + "\n") strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax) strsel += " && jGenPt>{0:.3f}".format(ptlo) strsel += " && jGenPt<{0:.3f}".format(pthi) #strsel = "" nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax) hPtTrackRel = ut.prepare_TH1D_n("hPtTrackRel", nbins, ptmin, ptmax) ytit = "Events / ({0:.3f})".format(ptbin) xtit = "(#it{p}_{T, rec}^{track} - #it{p}_{T, gen}^{track})/#it{p}_{T, gen}^{track}" mctree.Draw("(jT0pT-jGenP0pT)/jGenP0pT >> hPtTrackRel", strsel) # positive charge mctree.Draw("(jT1pT-jGenP1pT)/jGenP1pT >>+hPtTrackRel", strsel) # add negative charge x = RooRealVar("x", "x", ptmin, ptmax) x.setRange("fitran", fitran[0], fitran[1]) rfPtTrackRel = RooDataHist("rfPtTrackRel", "rfPtTrackRel", RooArgList(x), hPtTrackRel) #standard Crystal Ball mean = RooRealVar("mean", "mean", -0.003, -0.1, 0.1) sigma = RooRealVar("sigma", "sigma", 0.01, 0., 0.9) alpha = RooRealVar("alpha", "alpha", 1.2, 0., 10.) n = RooRealVar("n", "n", 1.3, 0., 20.) cbpdf = RooCBShape("cbpdf", "cbpdf", x, mean, sigma, alpha, n) res = cbpdf.fitTo(rfPtTrackRel, rf.Range("fitran"), rf.Save()) #log fit results ut.log_results(out, ut.log_fit_result(res)) #generate new distribution according to the fit gROOT.LoadMacro("cb_gen.h") #Crystal Ball generator, min, max, mean, sigma, alpha, n #cbgen = rt.cb_gen(-0.18, 0.05, -0.00226, 0.00908, 1.40165, 1.114) # -0.18, 0.05 ptmin, ptmax cbgen = rt.cb_gen(-0.5, 0.05, -0.00226, 0.00908, 0.2, 2.) # -0.18, 0.05 ptmin, ptmax hRelGen = ut.prepare_TH1D_n("hRelGen", nbins, ptmin, ptmax) ut.set_H1D_col(hRelGen, rt.kBlue) #rt.cb_generate_n(cbgen, hRelGen, int(hPtTrackRel.GetEntries())) rfRelGen = RooDataHist("rfRelGen", "rfRelGen", RooArgList(x), hRelGen) #generate distribution with additional smearing applied hRelSmear = ut.prepare_TH1D_n("hRelSmear", nbins, ptmin, ptmax) ut.set_H1D_col(hRelSmear, rt.kOrange) #tcopy = mctree.CopyTree(strsel) #rt.cb_apply_smear(cbgen, mctree, hRelSmear) can = ut.box_canvas() ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.05, 0.03) frame = x.frame(rf.Bins(nbins), rf.Title("")) ut.put_frame_yx_tit(frame, ytit, xtit) rfPtTrackRel.plotOn(frame, rf.Name("data")) #rfRelGen.plotOn(frame, rf.Name("data")) cbpdf.plotOn(frame, rf.Precision(1e-6), rf.Name("cbpdf"), rf.LineColor(ccb)) frame.Draw() #hRelGen.Draw("e1same") #hRelSmear.Draw("e1same") desc = pdesc(frame, 0.2, 0.8, 0.057) #x, y, sep desc.set_text_size(0.03) desc.itemD("#chi^{2}/ndf", frame.chiSquare("cbpdf", "data", 4), -1, ccb) desc.prec = 5 desc.itemR("mean", mean, ccb) desc.itemR("#sigma", sigma, ccb) desc.itemR("#alpha", alpha, ccb) desc.prec = 3 desc.itemR("#it{n}", n, ccb) desc.draw() leg = ut.prepare_leg(0.2, 0.82, 0.21, 0.12, 0.03) # x, y, dx, dy, tsiz leg.SetMargin(0.05) leg.AddEntry(0, "#bf{%.1f < #it{p}_{T}^{pair} < %.1f GeV}" % (ptlo, pthi), "") leg.Draw("same") #ut.invert_col(rt.gPad) can.SaveAs("01fig.pdf")
alpha_1S = RooRealVar("alpha_1S","#alpha(3P)1S", 0.6) alpha_2S = RooRealVar("alpha_2S","#alpha(3P)2S", 0.6) n_1S = RooRealVar("n_1S","n(3P1)1S", 2.5) n_2S = RooRealVar("n_2S","n(3P1)2S", 2.5) rawmass = RooRealVar('rm','rm',10.5,10.4,10.6) mass3P_1S2 =RooFormulaVar("m1","(@0+@1)",RooArgList(rawmass,deltaM_v3s)) mass3P_2S2 =RooFormulaVar("m2","(@0+@1)",RooArgList(rawmass,deltaM_v3s)) mass3P_3S2 =RooFormulaVar("m3","(@0+@1)",RooArgList(rawmass,deltaM_v3s)) signal1S_1 = RooCBShape('signal1S1','s1S1',x,rawmass,sigma_1S,alpha_1S,n_1S) signal1S_2 = RooCBShape('signal1S2','s1S2',x,mass3P_1S2,sigma_1S,alpha_1S,n_1S) signal2S_1 = RooCBShape('signal2S1','s2S1',x,rawmass,sigma_2S,alpha_2S,n_2S) signal2S_2 = RooCBShape('signal2S2','s2S1',x,mass3P_2S2,sigma_2S,alpha_2S,n_2S) #3S parameters # the following numbers are from an old 3P gun simulation # that needs to be re-done sigma13s = 0.003#0.0031 sigma23s = 0.003#0.0035
def RooFitHist(inputhist, title='title', path='.'): # RooFit.gErrorIgnoreLevel = RooFit.kInfo # <6.02 # RooFit.SetSilentMode()# >6.02 # RooMsgService().instance().SetSilentMode(kTRUE) fitbinning = array('d') binwidth = 200 #NBins=(14000/binwidth) - ( (1040/binwidth) + 1 ) NBins = (14000 / binwidth) - ((1040 / binwidth) + 1) for i in range(NBins + 1): fitbinning.append(1050 + i * binwidth) # print(fitbinning) hist = inputhist.Rebin(NBins, "fit parameter", fitbinning) meanstart = hist.GetBinCenter(hist.GetMaximumBin()) sigmastart = hist.GetRMS() print('meanstart:', meanstart, 'sigmastart:', sigmastart) # inputhist.Draw() # hist.Draw() # hold=raw_input('press enter to exit.') gStyle.SetOptFit(1100) gStyle.SetOptTitle(0) RooFit.SumW2Error(kTRUE) mjj = RooRealVar('mjj', 'M_{jj-AK8}', fitbinning[0], fitbinning[len(fitbinning) - 1], 'GeV') mjjral = RooArgList(mjj) dh = RooDataHist('dh', 'dh', mjjral, RooFit.Import(hist)) shapes = {} #Gaussian gaussmean = RooRealVar('#mu_{gauss}', 'mass mean value', meanstart, 0, 2 * meanstart) gausssigma = RooRealVar('#sigma_{gauss}', 'mass resolution', sigmastart, 0, 2 * sigmastart) gauss = RooGaussian('gauss', 'gauss', mjj, gaussmean, gausssigma) shapes.update({'Gauss': gauss}) #CrystalBall mean = RooRealVar('#mu', 'mean', meanstart, 0, 2 * meanstart) sigma = RooRealVar('#sigma', 'sigma', sigmastart, 0, 2 * sigmastart) alpha = RooRealVar('#alpha', 'Gaussian tail', -1000, 0) n = RooRealVar('n', 'Normalization', -1000, 1000) cbshape = RooCBShape('cbshape', 'crystalball PDF', mjj, mean, sigma, alpha, n) shapes.update({'CrystalBall': cbshape}) #Voigt voigtmean = RooRealVar('#mu', 'mass mean value', meanstart, 0, 2 * meanstart) voigtwidth = RooRealVar('#gamma', 'width of voigt', 0, 5000) voigtsigma = RooRealVar('#sigma', 'mass resolution', sigmastart, 0, 2 * sigmastart) voigt = RooVoigtian('voigt', 'voigt', mjj, voigtmean, voigtwidth, voigtsigma) shapes.update({'Voigt': voigt}) #BreitWigner bwmean = RooRealVar('#mu', 'mass mean value', meanstart, 0, 2 * meanstart) bwwidth = RooRealVar('#sigma', 'width of bw', sigmastart, 0, 2 * sigmastart) bw = RooBreitWigner('bw', 'bw', mjj, bwmean, bwwidth) shapes.update({'BreitWigner': bw}) #Landau landaumean = RooRealVar('#mu_{landau}', 'mean landau', meanstart, 0, 2 * meanstart) landausigma = RooRealVar('#sigma_{landau}', 'mass resolution', sigmastart, 0, 2 * sigmastart) landau = RooLandau('landau', 'landau', mjj, landaumean, landausigma) shapes.update({'Landau': landau}) #LandauGauss Convolution landaugauss = RooFFTConvPdf('landaugauss', 'landau x gauss', mjj, landau, gauss) shapes.update({'LandauGauss': landaugauss}) #Logistics # logisticsmean=RooRealVar('#mu_{logistics}','mean logistics',meanstart,0,2*meanstart) # logisticssigma= RooRealVar('#sigma_{logistics}','mass resolution',sigmastart,0,2*sigmastart) # logistics=RooLogistics('logistics','logistics',mjj,logisticsmean,logisticssigma) # shapes.update({'Logistics':logistics}) #ExpAndGauss # expgaussmean=RooRealVar('#mu_{expgauss}','mean expgauss',meanstart,0,2*meanstart) # expgausssigma= RooRealVar('#sigma_{expgauss}','mass resolution',sigmastart,0,2*sigmastart) # expgausstrans= RooRealVar('trans','trans',0,100) # expgauss=RooExpAndGauss('expgauss','expgauss',mjj,expgaussmean,expgausssigma,expgausstrans) # shapes.update({'ExpAndGauss':expgauss}) #BifurGauss BifurGaussmean = RooRealVar('#mu_{BifurGauss}', 'mean BifurGauss', meanstart, 0, 2 * meanstart) BifurGausslsigma = RooRealVar('#sigma_{left}', 'mass resolution', sigmastart, 0, 2 * sigmastart) BifurGaussrsigma = RooRealVar('#sigma_{right}', 'mass resolution', sigmastart, 0, 2 * sigmastart) BifurGauss = RooBifurGauss('BifurGauss', 'BifurGauss', mjj, BifurGaussmean, BifurGausslsigma, BifurGaussrsigma) shapes.update({'BifurGauss': BifurGauss}) #Chebychev Chebychev1 = RooRealVar('c0', 'Chebychev0', -1000, 1000) Chebychev2 = RooRealVar('c1', 'Chebychev1', -1000, 1000) Chebychev3 = RooRealVar('c2', 'Chebychev2', 2, -1000, 1000) Chebychev = RooChebychev('Chebychev', 'Chebychev', mjj, RooArgList(Chebychev1, Chebychev2, Chebychev3)) shapes.update({'Chebychev': Chebychev}) #Polynomial Polynomial1 = RooRealVar('Polynomial1', 'Polynomial1', 100, 0, 1000) Polynomial2 = RooRealVar('Polynomial2', 'Polynomial2', 100, 0, 1000) Polynomial = RooPolynomial('Polynomial', 'Polynomial', mjj, RooArgList(Polynomial1, Polynomial2)) shapes.update({'Polynomial': Polynomial}) # mjj.setRange("FitRange",1050.,14000.) # for fname in ['Gauss','Logistics','BifurGauss']: for fname in ['BifurGauss']: plottitle = '%s Fit of %s' % (fname, title) shape = shapes[fname] # shape.fitTo(dh,RooFit.Range("FitRange"),RooFit.SumW2Error(True)) shape.fitTo(dh, RooFit.SumW2Error(True)) frame = mjj.frame(RooFit.Title(plottitle)) frame.GetYaxis().SetTitleOffset(2) dh.plotOn(frame, RooFit.MarkerStyle(4)) shape.plotOn(frame, RooFit.LineColor(2)) ndof = dh.numEntries() - 3 #chiSquare legend chi2 = frame.chiSquare() probChi2 = TMath.Prob(chi2 * ndof, ndof) chi2 = round(chi2, 2) probChi2 = round(probChi2, 2) leg = TLegend(0.5, 0.5, 0.9, 0.65) leg.SetBorderSize(0) leg.SetFillStyle(0) shape.paramOn(frame, RooFit.Layout(0.5, 0.9, 0.9)) leg.AddEntry(0, '#chi^{2} =' + str(chi2), '') leg.AddEntry(0, 'Prob #chi^{2} = ' + str(probChi2), '') leg.SetTextSize(0.04) frame.addObject(leg) canv = TCanvas(plottitle, plottitle, 700, 700) canv.SetLogy() canv.SetLeftMargin(0.20) canv.cd() frame.SetMinimum(10**(-3)) frame.Draw() canv.Print(path + '/%s__%s.eps' % (title, fname)) return chi2
# x = RooRealVar("x", "x variable", 4800, 6000) # TODO: export somewhere? does not need to be defined inside... mean = RooRealVar("mean", "Mean of Double CB PDF", 5280, 5270, 5290) #, 5300, 5500) sigma = RooRealVar("sigma", "Sigma of Double CB PDF", 40, 0, 45) alpha_0 = RooRealVar("alpha_0", "alpha_0 of one side", 40, 30, 50) alpha_1 = RooRealVar("alpha_1", "alpha_1 of other side", -40, -50, -30.) lambda_0 = RooRealVar("lambda_0", "Exponent of one side", 40, 30, 50) lambda_1 = RooRealVar("lambda_1", "Exponent of other side", 40, 30, 50) # TODO: export somewhere? pdf construction frac = RooRealVar("frac", "Fraction of crystal ball pdfs", 0.479, 0.01, 0.99) crystalball1 = RooCBShape("crystallball1", "First CrystalBall PDF", x, mean, sigma, alpha_0, lambda_0) crystalball2 = RooCBShape("crystallball2", "Second CrystalBall PDF", x, mean, sigma, alpha_1, lambda_1) doubleCB = RooAddPdf("doubleCB", "Double CrystalBall PDF", crystalball1, crystalball2, frac) # create signal pdf END # create bkg-pdf BEGIN lambda_exp = RooRealVar("lambda_exp", "lambda exp pdf bkg", -0.002, -10., -0.000001) bkg_pdf = RooExponential("bkg_pdf", "Background PDF exp", x, lambda_exp) # create bkg-pdf END n_sig = 2500 data = pd.DataFrame(np.random.normal(loc=5280, scale=37, size=(n_sig, 3)),
#test -- restrict mjj range #x = RooRealVar('mjj','mjj',1500,6000) x = RooRealVar('mjj', 'mjj', minX_mass, maxX_mass) dataHist_data = RooDataHist("RooDataHist", "RooDataHist", RooArgList(x), hDat) if fitSig: # define parameters for signal fit m = RooRealVar('mean', 'mean', float(mass), float(mass) - 200, float(mass) + 200) s = RooRealVar('sigma', 'sigma', 0.1 * float(mass), 0, 10000) a = RooRealVar('alpha', 'alpha', 1, -10, 10) n = RooRealVar('n', 'n', 1, 0, 100) sig = RooCBShape('sig', 'sig', x, m, s, a, n) p = RooRealVar('p', 'p', 1, 0, 5) x0 = RooRealVar('x0', 'x0', 1000, 100, 5000) bkg = RooGenericPdf('bkg', '1/(exp(pow(@0/@1,@2))+1)', RooArgList(x, x0, p)) fsig = RooRealVar('fsig', 'fsig', 0.5, 0., 1.) signal = RooAddPdf('signal', 'signal', sig, bkg, fsig) # ----------------------------------------- # fit signal canSname = 'can_Mjj' + str(mass) canS = TCanvas(canSname, canSname, 900, 600) gPad.SetLogy()
alpha_initial = 0.5 n_initial = 7 if crystal != 'C3': alpha_initial = -1. n_initial = 0.5 a.append( RooRealVar("alpha_%s_%s" % (crystal, energy), "alpha_%s_%s" % (crystal, energy), alpha_initial, -10., 10)) n.append( RooRealVar("exp_%s_%s" % (crystal, energy), "exp_%s_%s" % (crystal, energy), n_initial, 0., 150)) sig.append( RooCBShape("signal_%s_%s" % (crystal, energy), "signal_%s_%s" % (crystal, energy), x[file_num], m[file_num], s[file_num], a[file_num], n[file_num])) res.append(sig[file_num].fitTo(roohist[file_num])) #RooFit.Save()) #res.Print() frame.append(x[file_num].frame()) roohist[file_num].plotOn( frame[file_num], RooFit.Name("roohist_%s_%s" % (crystal, energy))) sig[file_num].plotOn( frame[file_num], RooFit.Name("signal_%s_%s" % (crystal, energy))) hists_fits.append(hist_ampl) chi2s.append(frame[file_num].chiSquare( "signal_%s_%s" % (crystal, energy),
theBMassfunc = RooFormulaVar("theBMass", "theBMass", "@0", RooArgList(bMass)) theBMass = fulldata.addColumn(theBMassfunc) theBMass.setRange(lowRange, highRange) thevars.add(theBMass) cut = '' print cut data = fulldata.reduce(thevars, cut) ## mass model mean = RooRealVar("mass", "mean", B0Mass_, 5, 5.5, "GeV") sigma = RooRealVar("sigma", "sigma", 9.0e-2, 1.0e-4, 1.0, "GeV") alpha = RooRealVar("alpha", "alpha", 1.0, 0.0, 1.0e+4) n = RooRealVar("n", "n", 5, 1, 100) signalCB = RooCBShape("signalCB", "signal cb", theBMass, mean, sigma, alpha, n) sigma2 = RooRealVar("sigma2", "sigma2", 9.0e-3, 1.0e-5, 1.0, "GeV") alpha2 = RooRealVar("alpha2", "alpha2", 1.0, 0.0, 1.0e+4) n2 = RooRealVar("n2", "n2", 5, 1, 100) signalCB2 = RooCBShape("signalCB2", "signal cb 2", theBMass, mean, sigma2, alpha2, n2) f1 = RooRealVar("f1", "f1", 0.5, 0., 1.) CB = RooAddPdf("CB", "CB1+CB2", RooArgList(signalCB, signalCB2), RooArgList(f1)) ## make bkg model exp_alpha = RooRealVar("exp_alpha", "exp_alpha", -1.0, -100, 0) bkg_exp = RooExponential("bkg_exp", "bkg_exp", theBMass, exp_alpha)
def studyVqqResolution(rootFile): #get all from file histos = {} inF = TFile.Open(rootFile) keys = inF.GetListOfKeys() for k in keys: obj = inF.Get(k.GetName()) obj.SetDirectory(0) histos[k.GetName()] = obj inF.Close() #plot gROOT.SetBatch() gROOT.SetStyle('Plain') gStyle.SetOptStat(0) gStyle.SetOptFit(1111) gStyle.SetOptTitle(0) gStyle.SetStatFont(42) kin = ['', '30to40', '40to50', '50to75', '75to100', '100toInf'] for k in kin: c = TCanvas('c', 'c', 600, 600) c.cd() c.SetCanvasSize(1000, 500) c.SetWindowSize(1000, 500) c.Divide(2, 1) c.cd(1) histos['deta' + k + 'barrel'].SetLineWidth(2) histos['deta' + k + 'barrel'].SetTitle('barrel') histos['deta' + k + 'barrel'].Draw('hist') histos['deta' + k + 'endcap'].SetLineWidth(2) histos['deta' + k + 'endcap'].SetLineStyle(7) histos['deta' + k + 'endcap'].SetTitle('endcap') histos['deta' + k + 'endcap'].Draw('histsame') leg = TLegend(0.6, 0.92, 0.9, 0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) leg.AddEntry(histos['deta' + k + 'barrel'], 'barrel', 'f') leg.AddEntry(histos['deta' + k + 'endcap'], 'endcap', 'f') leg.SetNColumns(2) leg.Draw() drawHeader() c.cd(2) histos['dphi' + k + 'barrel'].SetLineWidth(2) histos['dphi' + k + 'barrel'].SetTitle('barrel') histos['dphi' + k + 'barrel'].Draw('hist') histos['dphi' + k + 'endcap'].SetLineWidth(2) histos['dphi' + k + 'endcap'].SetLineStyle(7) histos['dphi' + k + 'endcap'].SetTitle('endcap') histos['dphi' + k + 'endcap'].Draw('histsame') c.Modified() c.Update() c.SaveAs('dr_%s.png' % k) labels = [] responseVars = ['dpt', 'den', 'dphi', 'deta', 'dr'] for r in responseVars: barrelResponse = TGraphErrors() barrelResponse.SetName(r + 'barrelresponse') barrelResponse.SetLineWidth(2) barrelResponse.SetFillStyle(0) barrelResponse.SetMarkerStyle(20) barrelCoreResponse = barrelResponse.Clone(r + 'barrelcoreresponse') endcapResponse = TGraphErrors() endcapResponse.SetName(r + 'endcapresponse') endcapResponse.SetLineWidth(2) endcapResponse.SetFillStyle(0) endcapResponse.SetMarkerStyle(24) endcapCoreResponse = endcapResponse.Clone(r + 'endcapresponse') for k in kin: c.cd() c.Clear() c.SetWindowSize(1000, 500) c.Divide(2, 1) for i in [1, 2]: c.cd(i) reg = 'barrel' if i == 2: reg = 'endcap' h = histos[r + k + reg] x = RooRealVar("x", h.GetXaxis().GetTitle(), h.GetXaxis().GetXmin(), h.GetXaxis().GetXmax()) data = RooDataHist("data", "dataset with x", RooArgList(x), h) frame = x.frame() RooAbsData.plotOn(data, frame, RooFit.DataError(RooAbsData.SumW2)) mean1 = RooRealVar("mean1", "mean1", 0, -0.5, 0.5) sigma1 = RooRealVar("sigma1", "sigma1", 0.1, 0.01, 1.0) gauss1 = RooGaussian("g1", "g", x, mean1, sigma1) if r == 'dpt' or r == 'den': mean2 = RooRealVar("mean2", "mean2", 0, -0.5, 0.5) sigma2 = RooRealVar("sigma2", "sigma2", 0.1, 0.01, 1.0) alphacb = RooRealVar("alphacb", "alphacb", 1, 0.1, 3) ncb = RooRealVar("ncb", "ncb", 4, 1, 100) gauss2 = RooCBShape("cb2", "cb", x, mean2, sigma2, alphacb, ncb) else: mean1.setRange(0, 0.5) mean2 = RooRealVar("mean2", "mean", 0, 0, 1) sigma2 = RooRealVar("sigma2", "sigma", 0.1, 0.01, 1.0) gauss2 = RooGaussian("g2", "g", x, mean2, sigma2) frac = RooRealVar("frac", "fraction", 0.9, 0.0, 1.0) if data.sumEntries() < 100: frac.setVal(1.0) frac.setConstant(True) model = RooAddPdf("sum", "g1+g2", RooArgList(gauss1, gauss2), RooArgList(frac)) status = model.fitTo(data, RooFit.Save()).status() if status != 0: continue model_cdf = model.createCdf(RooArgSet(x)) cl = 0.90 ul = 0.5 * (1.0 + cl) closestToCL = 1.0 closestToUL = -1 closestToMedianCL = 1.0 closestToMedian = -1 for ibin in xrange(1, h.GetXaxis().GetNbins() * 10): xval = h.GetXaxis().GetXmin() + ( ibin - 1) * h.GetXaxis().GetBinWidth(ibin) / 10. x.setVal(xval) cdfValToCL = math.fabs(model_cdf.getVal() - ul) if cdfValToCL < closestToCL: closestToCL = cdfValToCL closestToUL = xval cdfValToCL = math.fabs(model_cdf.getVal() - 0.5) if cdfValToCL < closestToMedianCL: closestToMedianCL = cdfValToCL closestToMedian = xval RooAbsPdf.plotOn(model, frame) frame.Draw() if i == 1: drawHeader() labels.append(TPaveText(0.6, 0.92, 0.9, 0.98, 'brNDC')) ilab = len(labels) - 1 labels[ilab].SetName(r + k + 'txt') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) kinReg = k.replace('to', '-') kinReg = kinReg.replace('Inf', '#infty') labels[ilab].AddText('[' + reg + '] ' + kinReg) labels[ilab].Draw() resolutionVal = math.fabs(closestToUL - closestToMedian) responseGr = barrelResponse responseCoreGr = barrelCoreResponse coreResolutionVal = sigma1.getVal() coreResolutionErr = sigma1.getError() if frac.getVal() < 0.7 and (sigma2.getVal() < sigma1.getVal()): coreResolutionVal = sigma2.getVal() coreResolutionErr = sigma2.getError() if i == 2: responseGr = endcapResponse responseCoreGr = endcapCoreResponse if k != '': nrespPts = responseGr.GetN() kinAvg = 150 kinWidth = 50 if k == '30to40': kinAvg = 35 kinWidth = 5 if k == '40to50': kinAvg = 45 kinWidth = 5 if k == '50to75': kinAvg = 62.5 kinWidth = 12.5 elif k == '75to100': kinAvg = 87.5 kinWidth = 12.5 responseGr.SetPoint(nrespPts, kinAvg, resolutionVal) responseCoreGr.SetPoint(nrespPts, kinAvg, coreResolutionVal) responseCoreGr.SetPointError(nrespPts, kinWidth, coreResolutionErr) labels.append(TPaveText(0.15, 0.7, 0.4, 0.9, 'brNDC')) ilab = len(labels) - 1 labels[ilab].SetName(r + k + 'fitrestxt') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) labels[ilab].AddText('Gaussian #1 (f=%3.3f)' % frac.getVal()) labels[ilab].AddText('#mu=%3.3f#pm%3.3f' % (mean1.getVal(), mean1.getError())) labels[ilab].AddText('#sigma=%3.3f#pm%3.3f' % (sigma1.getVal(), sigma1.getError())) labels[ilab].AddText('Gaussian #2 (f=%3.3f)' % (1 - frac.getVal())) labels[ilab].AddText('#mu=%3.3f#pm%3.3f' % (mean2.getVal(), mean2.getError())) labels[ilab].AddText('#sigma=%3.3f#pm%3.3f' % (sigma2.getVal(), sigma2.getError())) labels[ilab].Draw() c.Modified() c.Update() c.SaveAs(r + 'res_' + k + '.png') frame = TGraphErrors() frame.SetPoint(0, 0, 0) frame.SetPoint(1, 200, 0.3) frame.SetMarkerStyle(1) frame.SetFillStyle(0) frame.SetName('frame') cresp = TCanvas('cresp', 'cresp', 500, 500) cresp.cd() frame.Draw('ap') barrelResponse.Draw('pl') endcapResponse.Draw('pl') frame.GetXaxis().SetTitle("Quark transverse momentum [GeV]") frame.GetYaxis().SetTitle("Resolution %3.2f C.L." % cl) frame.GetYaxis().SetTitleOffset(1.4) frame.GetYaxis().SetNdivisions(10) drawHeader() leg = TLegend(0.6, 0.92, 0.9, 0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) leg.AddEntry(barrelResponse, 'barrel', 'fp') leg.AddEntry(endcapResponse, 'endcap', 'fp') leg.SetNColumns(2) leg.Draw() cresp.Modified() cresp.Update() cresp.SaveAs(r + 'res_evol.png') frameCore = frame.Clone('framecore') cresp.Clear() frameCore.Draw('ap') barrelCoreResponse.Draw('pl') endcapCoreResponse.Draw('pl') frameCore.GetXaxis().SetTitle("Quark transverse momentum [GeV]") frameCore.GetYaxis().SetTitle("Core resolution") frameCore.GetYaxis().SetTitleOffset(1.4) frameCore.GetYaxis().SetNdivisions(10) frameCore.GetYaxis().SetRangeUser(0, 0.2) drawHeader() leg = TLegend(0.6, 0.92, 0.9, 0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) leg.AddEntry(barrelCoreResponse, 'barrel', 'fp') leg.AddEntry(endcapCoreResponse, 'endcap', 'fp') leg.SetNColumns(2) leg.Draw() cresp.Modified() cresp.Update() cresp.SaveAs(r + 'rescore_evol.png') bosons = ['h', 'z', 'w'] kin = ['', '50', '100'] region = ['', 'bb', 'eb', 'ee'] for k in kin: for r in region: c = TCanvas('c', 'c', 600, 600) c.cd() histos['mjj' + k + r].Rebin() histos['mjj' + k + r].Draw() ic = 1 leg = TLegend(0.6, 0.92, 0.9, 0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) leg.AddEntry(histos['mjj' + k + r], 'inclusive', 'f') for b in bosons: if histos[b + 'mjj' + k + r].Integral() <= 0: continue ic = ic + 1 histos[b + 'mjj' + k + r].Rebin() histos[b + 'mjj' + k + r].SetLineColor(ic) histos[b + 'mjj' + k + r].SetLineWidth(2) histos[b + 'mjj' + k + r].SetMarkerColor(ic) histos[b + 'mjj' + k + r].SetMarkerStyle(1) histos[b + 'mjj' + k + r].SetFillStyle(3000 + ic) histos[b + 'mjj' + k + r].SetFillColor(ic) histos[b + 'mjj' + k + r].Draw('histsame') leg.AddEntry(histos[b + 'mjj' + k + r], b, "f") leg.SetNColumns(ic) leg.Draw() drawHeader() labels.append(TPaveText(0.65, 0.8, 0.9, 0.9, 'brNDC')) ilab = len(labels) - 1 labels[ilab].SetName(k + r + 'mjj') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) regionTitle = "inclusive" if r == 'bb': regionTitle = 'barrel-barrel' if r == 'eb': regionTitle = 'endcap-barrel' if r == 'ee': regionTitle = 'endcap-endcap' labels[ilab].AddText(regionTitle) ptthreshold = 30 if k != '': ptthreshold = float(k) labels[ilab].AddText('p_{T}>%3.0f GeV' % ptthreshold) labels[ilab].Draw() c.Modified() c.Update() c.SaveAs('mjj' + k + r + '.png') massResolutionGrs = [] for r in region: massResolution = TGraphErrors() massResolution.SetName(r + 'dm') massResolution.SetLineWidth(2) massResolution.SetFillStyle(0) massResolution.SetMarkerStyle(20 + len(massResolutionGrs)) massResolution.SetMarkerColor(1 + len(massResolutionGrs)) massResolution.SetLineColor(1 + len(massResolutionGrs)) massResolution.SetFillColor(1 + len(massResolutionGrs)) massResolutionGrs.append(massResolution) for k in kin: c = TCanvas('c', 'c', 600, 600) c.cd() h = histos['dmjj' + k + r] x = RooRealVar("x", h.GetXaxis().GetTitle(), h.GetXaxis().GetXmin(), h.GetXaxis().GetXmax()) data = RooDataHist("data", "dataset with x", RooArgList(x), h) frame = x.frame() RooAbsData.plotOn(data, frame, RooFit.DataError(RooAbsData.SumW2)) mean1 = RooRealVar("mean1", "mean1", 0, -0.5, 0.5) sigma1 = RooRealVar("sigma1", "sigma1", 0.1, 0.01, 1.0) gauss1 = RooGaussian("g1", "g", x, mean1, sigma1) mean2 = RooRealVar("mean2", "mean2", 0, -0.5, 0.5) sigma2 = RooRealVar("sigma2", "sigma2", 0.1, 0.01, 1.0) alphacb = RooRealVar("alphacb", "alphacb", 1, 0.1, 3) ncb = RooRealVar("ncb", "ncb", 4, 1, 100) gauss2 = RooCBShape("cb2", "cb", x, mean2, sigma2, alphacb, ncb) frac = RooRealVar("frac", "fraction", 0.9, 0.0, 1.0) model = RooAddPdf("sum", "g1+g2", RooArgList(gauss1, gauss2), RooArgList(frac)) status = model.fitTo(data, RooFit.Save()).status() if status != 0: continue RooAbsPdf.plotOn(model, frame) frame.Draw() labels.append(TPaveText(0.6, 0.65, 0.85, 0.9, 'brNDC')) ilab = len(labels) - 1 labels[ilab].SetName(r + k + 'dmfitrestxt') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) labels[ilab].AddText('Gaussian #1 (f=%3.3f)' % frac.getVal()) labels[ilab].AddText('#mu=%3.3f#pm%3.3f' % (mean1.getVal(), mean1.getError())) labels[ilab].AddText('#sigma=%3.3f#pm%3.3f' % (sigma1.getVal(), sigma1.getError())) labels[ilab].AddText('Gaussian #2 (f=%3.3f)' % (1 - frac.getVal())) labels[ilab].AddText('#mu=%3.3f#pm%3.3f' % (mean2.getVal(), mean2.getError())) labels[ilab].AddText('#sigma=%3.3f#pm%3.3f' % (sigma2.getVal(), sigma2.getError())) labels[ilab].Draw() drawHeader() labels.append(TPaveText(0.15, 0.8, 0.4, 0.9, 'brNDC')) ilab = len(labels) - 1 labels[ilab].SetName(k + r + 'dmjj') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) regionTitle = "inclusive" if r == 'bb': regionTitle = 'barrel-barrel' if r == 'eb': regionTitle = 'endcap-barrel' if r == 'ee': regionTitle = 'endcap-endcap' labels[ilab].AddText(regionTitle) ptthreshold = 30 if k != '': ptthreshold = float(k) labels[ilab].AddText('p_{T}>%3.0f GeV' % ptthreshold) labels[ilab].Draw() c.Modified() c.Update() c.SaveAs('dmjj' + k + r + '.png') massResolution.SetTitle(regionTitle) ip = massResolution.GetN() x = 40 xerr = 10 if k == '50': x = 75 xerr = 25 elif k == '100': x = 150 xerr = 50 y = sigma1.getVal() yerr = sigma1.getError() if frac.getVal() < 0.8: if sigma2.getVal() < sigma1.getVal(): y = sigma2.getVal() ey = sigma2.getError() massResolution.SetPoint(ip, x, y) massResolution.SetPointError(ip, xerr, yerr) frame = TGraphErrors() frame.SetPoint(0, 0, 0) frame.SetPoint(1, 200, 0.2) frame.SetMarkerStyle(1) frame.SetFillStyle(0) frame.SetName('dmframe') cdmevol = TCanvas('cdmevol', 'cdmevol', 500, 500) cdmevol.cd() frame.Draw('ap') leg = TLegend(0.6, 0.92, 0.9, 0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) for dmGr in massResolutionGrs: dmGr.Draw('pl') leg.AddEntry(dmGr, dmGr.GetTitle(), 'fp') frame.GetXaxis().SetTitle("Leading quark transverse momentum [GeV]") frame.GetYaxis().SetTitle("Core resolution") frame.GetYaxis().SetTitleOffset(1.4) frame.GetYaxis().SetNdivisions(10) drawHeader() leg.SetNColumns(2) leg.Draw() cdmevol.Modified() cdmevol.Update() cdmevol.SaveAs('dm_evol.png') c = TCanvas('c', 'c', 600, 600) c.cd() histos['sel'].Draw('histtext') drawHeader() c.Modified() c.Update() c.SaveAs('selection.png') return
def dofit(roodataset, hname): mass_chib = 10.5103 # from PES uncorrected mass measurement deltaM = 0.0105 # MeV theoretical expectations ratio21 = 0.45 # same as chic2/chic1 and chib2/chib1 # the following numbers are from an old 3P gun simulation # that needs to be re-done sigma1 = 0.003 #0.0031 sigma2 = 0.003 #0.0035 alpha1 = 0.95 alpha2 = 1.12 n = 2.5 mass1_v = RooRealVar('mchi1', 'm_{#chi1}', mass_chib) deltaM_v = RooRealVar('deltaM', '#Delta_{m}', deltaM, 0.005, 0.015) mass2_v = RooFormulaVar('mchi2', '@0+@1', RooArgList(mass1_v, deltaM_v)) sigma1_v = RooRealVar('sigma1', '#sigma_1', sigma1) sigma2_v = RooRealVar('sigma2', '#sigma_2', sigma2) alpha1_v = RooRealVar('alpha1', '#alpha_1', alpha1) alpha2_v = RooRealVar('alpha2', '#alpha_2', alpha2) n_v = RooRealVar('n', 'n', n) ratio21_v = RooRealVar('ratio21', 'r_{21}', ratio21) x = RooRealVar("invm3S", "#chi_{b} Data", 10.4, 10.7) # choose here binning of mass plot x.setBins(150) #signal pdf chib1 = RooCBShape('chib1', 'chib1', x, mass1_v, sigma1_v, alpha1_v, n_v) chib2 = RooCBShape('chib2', 'chib2', x, mass2_v, sigma2_v, alpha2_v, n_v) # define background q01S_Start = 10.4 alpha = RooRealVar("#alpha", "#alpha", 1.5, 0.2, 3.5) beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.) #q0 = RooRealVar("q0","q0",q01S_Start,q01S_Start-0.05,q01S_Start+0.05) q0 = RooRealVar("q0", "q0", q01S_Start) delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0)) b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0)) signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x, q0)) background = RooGenericPdf("background", "Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1, delta, alpha, b1)) n_evts_1 = RooRealVar('N_{3P_{1}}', 'N_{3P_{1}}', 50, 30, 1000) n_evts_2 = RooFormulaVar('N_{3P_{2}}', '@0*@1', RooArgList(n_evts_1, ratio21_v)) n_bck = RooRealVar('nbkg', 'n_{bkg}', 500, 0, 100000) #build final pdf modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', RooArgList(chib1, chib2, background), RooArgList(n_evts_1, n_evts_2, n_bck)) # fit low_cut = x.setRange("low_cut", 10.4, 10.7) result = modelPdf.fitTo(roodataset, RooFit.Save(), RooFit.Range("low_cut")) frame = x.frame(RooFit.Title("m(#chi_{b}(3P))")) roodataset.plotOn(frame, RooFit.MarkerSize(0.7)) modelPdf.plotOn(frame, RooFit.LineWidth(1)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) frame.GetXaxis().SetTitle( 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon(3S)} [GeV/c^{2}]' ) #frame.GetYaxis().SetTitle( "Events/15.0 MeV " ) frame.GetXaxis().SetTitleSize(0.04) frame.GetYaxis().SetTitleSize(0.04) frame.GetXaxis().SetTitleOffset(1.1) frame.GetXaxis().SetLabelSize(0.04) frame.GetYaxis().SetLabelSize(0.04) frame.SetLineWidth(1) frame.SetName("fit_resonance") chi2 = frame.chiSquare() chi2 = round(chi2, 2) leg = TLegend(0.50, 0.7, 0.60, 0.8) leg.AddEntry(0, '#chi^{2} =' + str(chi2), '') leg.SetBorderSize(0) leg.SetFillColor(0) leg.SetTextSize(0.06) gROOT.SetStyle("Plain") frame.SaveAs(str(hname) + '.root') # param_set = RooArgSet(n_evts_Roo4, m_chib[1][3],alpha, beta, q0) canvas = TCanvas('fit', "", 1400, 700) canvas.Divide(1) canvas.cd(1) gPad.SetRightMargin(0.3) gPad.SetFillColor(10) # modelPdf.paramOn(frame, RooFit.Layout(0.725,0.9875,0.9), RooFit.Parameters(param_set)) modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9)) frame.Draw() leg.Draw("same") canvas.SaveAs(str(hname) + '.png')
def fitMass(rangem=[0.4, 2.0], iflag=1, iopt_bkgshape=0, CBpar=[0., 0., 0.]): global myc, fitres m0 = sum(rangem) / 2 #w0=(rangem[1]-rangem[0])/10 w0 = 0.004 mass = RooRealVar("ee_ivm", "ee_ivm", rangem[0], rangem[1]) if iflag == 1: ###Construct signal pdf with gaus mean = RooRealVar("mean", "mean", m0) sigma = RooRealVar("sigma", "sigma", w0) signal = RooGaussian("signal", "signal", mass, mean, sigma) elif iflag == 2 or iflag == 3: ## Construct signal pdf with CB function ##print "outinfo",x,CBpar[0],CBpar[1],CBpar[2],CBpar[3] cbmean = RooRealVar("cbmean", "cbmean", m0) cbsigma = RooRealVar("cbsigma", "cbsigma", CBpar[0]) n1 = RooRealVar("n1", "", CBpar[1]) alpha = RooRealVar("alpha", "", CBpar[2]) cbsigma.setConstant(ROOT.kTRUE) n1.setConstant(ROOT.kTRUE) alpha.setConstant(ROOT.kTRUE) signal = RooCBShape("cball", "crystal ball1", mass, cbmean, cbsigma, alpha, n1) # elif iflag ==3: # pass else: print "ERROR, please specify signal shape for fitting!!" sys.exit() # Construct background pdf a0 = RooRealVar("a0", "a0", 0.1, -1, 1) a1 = RooRealVar("a1", "a1", 0.004, -1, 1) a2 = RooRealVar("a2", "a2", 0.001, -1, 1) if iopt_bkgshape == 0: background = RooChebychev("background", "background", mass, RooArgList(a0, a1)) else: background = RooChebychev("background", "background", mass, RooArgList(a0, a1, a2)) # Construct composite pdf if iflag == 1: up_nsig = 40 else: up_nsig = 60 nsig = RooRealVar("nsig", "nsig", 5, 0.0, up_nsig) nbkg = RooRealVar("nbkg", "nbkg", 800, 0, 3000) #frac = RooRealVar("frac", "frac", 0.001, 0.0001, 0.1) model = RooAddPdf("model", "model", RooArgList(signal, background), RooArgList(nsig, nbkg)) #model = RooAddPdf("model", "model", RooArgList(signal, background), RooArgList(frac)) mcdata = RooDataSet( "ds", "ds", RooArgSet(mass), RooFit.Import(data), RooFit.Cut("ee_ivm<" + str(rangem[1]) + "&&ee_ivm>" + str(rangem[0]))) if optp == 1: ipr = 1 verbose = 0 elif optp == 2: ipr = 1 verbose = 1 else: ipr = -1 verbose = 0 fitres=model.fitTo(mcdata,RooFit.Save(),RooFit.Minos(1), RooFit.Strategy(2),\ RooFit.PrintLevel(ipr), RooFit.Verbose(verbose)) nll = RooNLLVar("nll", "nll", model, mcdata, RooFit.Range(rangem[0], rangem[1])) pll = nll.createProfile(RooArgSet(nsig)) Profile = RooProfileLL("Profile", "Profile", nll, RooArgSet(nsig)) llhoodP = RooFormulaVar("llhoodP", "exp(-0.5*Profile)", RooArgList(Profile)) xframe2 = nsig.frame(RooFit.Title("number of signal")) nllplot = nll.plotOn(xframe2, RooFit.ShiftToZero()) themin = RooConstVar("themin", "themin", nllplot.GetMinimum()) llhood = RooFormulaVar("llhood", "exp(-0.5*(nll-themin*0.95))", RooArgList(nll, themin)) if optp: xframe = mass.frame(RooFit.Title("mass of ee pair")) xframe3 = nsig.frame(RooFit.Title("number of signal")) xframe3.SetYTitle("Likelihood") mcdata.plotOn(xframe) model.plotOn(xframe) model.plotOn(xframe, RooFit.Components("background"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kRed)) model.plotOn(xframe, RooFit.Components("cball"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen)) myc.cd(1) xframe.Draw() #pll.plotOn(xframe2,RooFit.LineColor(ROOT.kRed)) if optp: print "***** archmin ", themin.Print() #llhoodP.plotOn(xframe3, RooFit.LineColor(ROOT.kRed)) llhood.plotOn(xframe3) myc.cd(2) xframe2.SetMinimum(0) xframe2.Draw() myc.cd(3) xframe3.Draw() myc.Update() raw_input() nsig.setRange("IntRange1", 0, 1000.) Int1 = llhood.createIntegral(RooArgSet(nsig), ROOT.RooFit.Range('IntRange1')) Int1Val = Int1.getVal() i = 0 hit = False while not (hit): i = i + 1 nsig.setRange("IntRange2", 0, float(i)) Int2 = llhood.createIntegral(RooArgSet(nsig), ROOT.RooFit.Range('IntRange2')) if Int2.getVal() >= Int1Val * 0.9: if optp: print "&&& ", i hit = True return i
else: fun = dx_funs[tag] fun.SetLineColor(kBlue) dx_results[tag] = g.Fit(fun, 'S') g.Draw('AP') from ROOT import RooCBShape cb_mean = RooRealVar('cb_mean', 'cb_mean', 0, -100, 100) cb_s1 = RooRealVar('cb_s1', 'cb_s1', 100, 0, 500) cb_sf = RooRealVar('cb_sf', 'cb_sf', 100, 0.1, 500) cb_s2 = RooFormulaVar('cb_s2', 'cb_s2', "@0 * @1", RooArgList(cb_sf, cb_s1)) cb_frac = RooRealVar('cb_f', 'f' + tag, 0.2, 0.001, 0.99) cb_n = RooRealVar('cb_n', 'n', 1) cb_a1 = RooRealVar('cb_a', 'alpha', 20, 0.001, 200) cb_a2 = RooFormulaVar('cb_a2', 'cb_a2', "@0 * @1", RooArgList(cb_sf, cb_a1)) cb1 = RooCBShape("cb1", "cb1", match_res_x, cb_mean, cb_s1, cb_a1, cb_n) cb2 = RooCBShape("cb2", "cb2", match_res_x, cb_mean, cb_s2, cb_a2, cb_n) dcb = RooAddModel("dcb", "double_cb", RooArgList(cb1, cb2), RooArgList(cb_frac)) cor_xy = defaultdict(list) sigmas_m = [] err_m = [] x_m = [] for i, (vname, j) in enumerate(product(['x', 'y'], range(1, 5))): x_m += [i + 1] r = results[(j, vname)] # if (vname, j) == ('x', 2) or vname == 'y': # par = r.floatParsFinal().find('s1_' + vname) # else: par = r.floatParsFinal().find('sm_' + vname)
def signal(channel, stype): if 'VBF' in channel: stype = 'XZHVBF' else: stype = 'XZH' # HVT model if stype.startswith('X'): signalType = 'HVT' genPoints = [800, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500, 4000, 4500, 5000] massPoints = [x for x in range(800, 5000+1, 100)] interPar = True else: print "Signal type", stype, "not recognized" return n = len(genPoints) category = channel cColor = color[category] if category in color else 1 nElec = channel.count('e') nMuon = channel.count('m') nLept = nElec + nMuon nBtag = channel.count('b') if '0b' in channel: nBtag = 0 X_name = "VH_mass" if not os.path.exists(PLOTDIR+stype+category): os.makedirs(PLOTDIR+stype+category) #*******************************************************# # # # Variables and selections # # # #*******************************************************# X_mass = RooRealVar( "X_mass", "m_{ZH}", XBINMIN, XBINMAX, "GeV") J_mass = RooRealVar( "H_mass", "jet mass", LOWMIN, HIGMAX, "GeV") V_mass = RooRealVar( "V_mass", "V jet mass", -9., 1.e6, "GeV") CSV1 = RooRealVar( "H_csv1", "", -999., 2. ) CSV2 = RooRealVar( "H_csv2", "", -999., 2. ) DeepCSV1= RooRealVar( "H_deepcsv1", "", -999., 2. ) DeepCSV2= RooRealVar( "H_deepcsv2", "", -999., 2. ) H_ntag = RooRealVar( "H_ntag", "", -9., 9. ) H_dbt = RooRealVar( "H_dbt", "", -2., 2. ) H_tau21 = RooRealVar( "H_tau21", "", -9., 2. ) H_eta = RooRealVar( "H_eta", "", -9., 9. ) H_tau21_ddt = RooRealVar( "H_ddt", "", -9., 2. ) MaxBTag = RooRealVar( "MaxBTag", "", -10., 2. ) H_chf = RooRealVar( "H_chf", "", -1., 2. ) MinDPhi = RooRealVar( "MinDPhi", "", -1., 99. ) DPhi = RooRealVar( "DPhi", "", -1., 99. ) DEta = RooRealVar( "DEta", "", -1., 99. ) Mu1_relIso = RooRealVar( "Mu1_relIso", "", -1., 99. ) Mu2_relIso = RooRealVar( "Mu2_relIso", "", -1., 99. ) nTaus = RooRealVar( "nTaus", "", -1., 99. ) Vpt = RooRealVar( "V.Pt()", "", -1., 1.e6 ) V_pt = RooRealVar( "V_pt", "", -1., 1.e6 ) H_pt = RooRealVar( "H_pt", "", -1., 1.e6 ) VH_deltaR=RooRealVar( "VH_deltaR", "", -1., 99. ) isZtoNN = RooRealVar( "isZtoNN", "", 0., 2. ) isZtoEE = RooRealVar( "isZtoEE", "", 0., 2. ) isZtoMM = RooRealVar( "isZtoMM", "", 0., 2. ) isHtobb = RooRealVar( "isHtobb", "", 0., 2. ) isVBF = RooRealVar( "isVBF", "", 0., 2. ) isMaxBTag_loose = RooRealVar( "isMaxBTag_loose", "", 0., 2. ) weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1.e9 ) Xmin = XBINMIN Xmax = XBINMAX # Define the RooArgSet which will include all the variables defined before # there is a maximum of 9 variables in the declaration, so the others need to be added with 'add' variables = RooArgSet(X_mass, J_mass, V_mass, CSV1, CSV2, H_ntag, H_dbt, H_tau21) variables.add(RooArgSet(DEta, DPhi, MaxBTag, MinDPhi, nTaus, Vpt)) variables.add(RooArgSet(DeepCSV1, DeepCSV2,VH_deltaR, H_tau21_ddt)) variables.add(RooArgSet(isZtoNN, isZtoEE, isZtoMM, isHtobb, isMaxBTag_loose, weight)) variables.add(RooArgSet(isVBF, Mu1_relIso, Mu2_relIso, H_chf, H_pt, V_pt,H_eta)) #X_mass.setRange("X_extended_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_integration_range", Xmin, Xmax) X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/100)) binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax()) X_mass.setBinning(binsXmass, "PLOT") massArg = RooArgSet(X_mass) # Cuts SRcut = selection[category]+selection['SR'] print " Cut:\t", SRcut #*******************************************************# # # # Signal fits # # # #*******************************************************# treeSign = {} setSignal = {} vmean = {} vsigma = {} valpha1 = {} vslope1 = {} smean = {} ssigma = {} salpha1 = {} sslope1 = {} salpha2 = {} sslope2 = {} a1 = {} a2 = {} sbrwig = {} signal = {} signalExt = {} signalYield = {} signalIntegral = {} signalNorm = {} signalXS = {} frSignal = {} frSignal1 = {} frSignal2 = {} frSignal3 = {} # Signal shape uncertainties (common amongst all mass points) xmean_fit = RooRealVar("sig_p1_fit", "Variation of the resonance position with the fit uncertainty", 0.005, -1., 1.) smean_fit = RooRealVar("CMSRunII_sig_p1_fit", "Change of the resonance position with the fit uncertainty", 0., -10, 10) xmean_jes = RooRealVar("sig_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.010, -1., 1.) #0.001 smean_jes = RooRealVar("CMSRunII_sig_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10) xmean_e = RooRealVar("sig_p1_scale_e", "Variation of the resonance position with the electron energy scale", 0.001, -1., 1.) smean_e = RooRealVar("CMSRunII_sig_p1_scale_e", "Change of the resonance position with the electron energy scale", 0., -10, 10) xmean_m = RooRealVar("sig_p1_scale_m", "Variation of the resonance position with the muon energy scale", 0.001, -1., 1.) smean_m = RooRealVar("CMSRunII_sig_p1_scale_m", "Change of the resonance position with the muon energy scale", 0., -10, 10) xsigma_fit = RooRealVar("sig_p2_fit", "Variation of the resonance width with the fit uncertainty", 0.02, -1., 1.) ssigma_fit = RooRealVar("CMSRunII_sig_p2_fit", "Change of the resonance width with the fit uncertainty", 0., -10, 10) xsigma_jes = RooRealVar("sig_p2_scale_jes", "Variation of the resonance width with the jet energy scale", 0.010, -1., 1.) #0.001 ssigma_jes = RooRealVar("CMSRunII_sig_p2_jes", "Change of the resonance width with the jet energy scale", 0., -10, 10) xsigma_jer = RooRealVar("sig_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.020, -1., 1.) ssigma_jer = RooRealVar("CMSRunII_sig_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10) xsigma_e = RooRealVar("sig_p2_scale_e", "Variation of the resonance width with the electron energy scale", 0.001, -1., 1.) ssigma_e = RooRealVar("CMSRunII_sig_p2_scale_e", "Change of the resonance width with the electron energy scale", 0., -10, 10) xsigma_m = RooRealVar("sig_p2_scale_m", "Variation of the resonance width with the muon energy scale", 0.040, -1., 1.) ssigma_m = RooRealVar("CMSRunII_sig_p2_scale_m", "Change of the resonance width with the muon energy scale", 0., -10, 10) xalpha1_fit = RooRealVar("sig_p3_fit", "Variation of the resonance alpha with the fit uncertainty", 0.03, -1., 1.) salpha1_fit = RooRealVar("CMSRunII_sig_p3_fit", "Change of the resonance alpha with the fit uncertainty", 0., -10, 10) xslope1_fit = RooRealVar("sig_p4_fit", "Variation of the resonance slope with the fit uncertainty", 0.10, -1., 1.) sslope1_fit = RooRealVar("CMSRunII_sig_p4_fit", "Change of the resonance slope with the fit uncertainty", 0., -10, 10) xmean_fit.setConstant(True) smean_fit.setConstant(True) xmean_jes.setConstant(True) smean_jes.setConstant(True) xmean_e.setConstant(True) smean_e.setConstant(True) xmean_m.setConstant(True) smean_m.setConstant(True) xsigma_fit.setConstant(True) ssigma_fit.setConstant(True) xsigma_jes.setConstant(True) ssigma_jes.setConstant(True) xsigma_jer.setConstant(True) ssigma_jer.setConstant(True) xsigma_e.setConstant(True) ssigma_e.setConstant(True) xsigma_m.setConstant(True) ssigma_m.setConstant(True) xalpha1_fit.setConstant(True) salpha1_fit.setConstant(True) xslope1_fit.setConstant(True) sslope1_fit.setConstant(True) # the alpha method is now done. for m in massPoints: signalString = "M%d" % m signalMass = "%s_M%d" % (stype, m) signalName = "%s%s_M%d" % (stype, category, m) signalColor = sample[signalMass]['linecolor'] if signalName in sample else 1 # define the signal PDF vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m*0.5, m*1.25) smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)", RooArgList(vmean[m], xmean_e, smean_e, xmean_m, smean_m, xmean_jes, smean_jes, xmean_fit, smean_fit)) vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m*0.035, m*0.01, m*0.4) sigmaList = RooArgList(vsigma[m], xsigma_e, ssigma_e, xsigma_m, ssigma_m, xsigma_jes, ssigma_jes, xsigma_jer, ssigma_jer) sigmaList.add(RooArgList(xsigma_fit, ssigma_fit)) ssigma[m] = RooFormulaVar(signalName + "_sigma", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)*(1+@9*@10)", sigmaList) valpha1[m] = RooRealVar(signalName + "_valpha1", "Crystal Ball alpha", 1., 0., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0*(1+@1*@2)", RooArgList(valpha1[m], xalpha1_fit, salpha1_fit)) vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope", 10., 1., 60.) # slope of the power tail #10 1 60 sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0*(1+@1*@2)", RooArgList(vslope1[m], xslope1_fit, sslope1_fit)) salpha2[m] = RooRealVar(signalName + "_alpha2", "Crystal Ball alpha", 2, 1., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right sslope2[m] = RooRealVar(signalName + "_slope2", "Crystal Ball slope", 10, 1.e-1, 115.) # slope of the power tail #define polynomial #a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", m, 0.5*m, 2*m) a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", 0.001*m, 0.0005*m, 0.01*m) a2[m] = RooRealVar(signalName + "_a2", "par 2 for polynomial", 0.05, -1.,1.) #if channel=='nnbbVBF' or channel=='nn0bVBF': # signal[m] = RooPolynomial(signalName,"m_{%s'} = %d GeV" % (stype[1], m) , X_mass, RooArgList(a1[m],a2[m])) #else: # signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel # extend the PDF with the yield to perform an extended likelihood fit signalYield[m] = RooRealVar(signalName+"_yield", "signalYield", 100, 0., 1.e6) signalNorm[m] = RooRealVar(signalName+"_norm", "signalNorm", 1., 0., 1.e6) signalXS[m] = RooRealVar(signalName+"_xs", "signalXS", 1., 0., 1.e6) signalExt[m] = RooExtendPdf(signalName+"_ext", "extended p.d.f", signal[m], signalYield[m]) vslope1[m].setMax(50.) vslope1[m].setVal(20.) #valpha1[m].setVal(1.0) #valpha1[m].setConstant(True) if 'bb' in channel and 'VBF' not in channel: if 'nn' in channel: valpha1[m].setVal(0.5) elif '0b' in channel and 'VBF' not in channel: if 'nn' in channel: if m==800: valpha1[m].setVal(2.) vsigma[m].setVal(m*0.04) elif 'ee' in channel: valpha1[m].setVal(0.8) if m==800: #valpha1[m].setVal(1.2) valpha1[m].setVal(2.5) vslope1[m].setVal(50.) elif 'mm' in channel: if m==800: valpha1[m].setVal(2.) vsigma[m].setVal(m*0.03) else: vmean[m].setVal(m*0.9) vsigma[m].setVal(m*0.08) elif 'bb' in channel and 'VBF' in channel: if 'nn' in channel: if m!=1800: vmean[m].setVal(m*0.8) vsigma[m].setVal(m*0.08) valpha1[m].setMin(1.) elif 'ee' in channel: valpha1[m].setVal(0.7) elif 'mm' in channel: if m==800: vslope1[m].setVal(50.) valpha1[m].setVal(0.7) elif '0b' in channel and 'VBF' in channel: if 'nn' in channel: valpha1[m].setVal(3.) vmean[m].setVal(m*0.8) vsigma[m].setVal(m*0.08) valpha1[m].setMin(1.) elif 'ee' in channel: if m<2500: valpha1[m].setVal(2.) if m==800: vsigma[m].setVal(m*0.05) elif m==1000: vsigma[m].setVal(m*0.03) elif m>1000 and m<1800: vsigma[m].setVal(m*0.04) elif 'mm' in channel: if m<2000: valpha1[m].setVal(2.) if m==1000 or m==1800: vsigma[m].setVal(m*0.03) elif m==1200 or m==1600: vsigma[m].setVal(m*0.04) #if m < 1000: vsigma[m].setVal(m*0.06) # If it's not the proper channel, make it a gaussian #if nLept==0 and 'VBF' in channel: # valpha1[m].setVal(5) # valpha1[m].setConstant(True) # vslope1[m].setConstant(True) # salpha2[m].setConstant(True) # sslope2[m].setConstant(True) # ---------- if there is no simulated signal, skip this mass point ---------- if m in genPoints: if VERBOSE: print " - Mass point", m # define the dataset for the signal applying the SR cuts treeSign[m] = TChain("tree") for j, ss in enumerate(sample[signalMass]['files']): treeSign[m].Add(NTUPLEDIR + ss + ".root") if treeSign[m].GetEntries() <= 0.: if VERBOSE: print " - 0 events available for mass", m, "skipping mass point..." signalNorm[m].setVal(-1) vmean[m].setConstant(True) vsigma[m].setConstant(True) salpha1[m].setConstant(True) sslope1[m].setConstant(True) salpha2[m].setConstant(True) sslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) continue setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeSign[m])) if VERBOSE: print " - Dataset with", setSignal[m].sumEntries(), "events loaded" # FIT signalYield[m].setVal(setSignal[m].sumEntries()) if treeSign[m].GetEntries(SRcut) > 5: if VERBOSE: print " - Running fit" frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1), RooFit.Extended(True), RooFit.SumW2Error(True), RooFit.PrintLevel(-1)) if VERBOSE: print "********** Fit result [", m, "] **", category, "*"*40, "\n", frSignal[m].Print(), "\n", "*"*80 if VERBOSE: frSignal[m].correlationMatrix().Print() drawPlot(signalMass, stype+channel, X_mass, signal[m], setSignal[m], frSignal[m]) else: print " WARNING: signal", stype, "and mass point", m, "in channel", channel, "has 0 entries or does not exist" # Remove HVT cross section (which is the same for Zlep and Zinv) if stype == "XZHVBF": sample_name = 'Zprime_VBF_Zh_Zlephinc_narrow_M-%d' % m else: sample_name = 'ZprimeToZHToZlepHinc_narrow_M%d' % m xs = xsection[sample_name]['xsec'] signalXS[m].setVal(xs * 1000.) signalIntegral[m] = signalExt[m].createIntegral(massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range")) boundaryFactor = signalIntegral[m].getVal() if VERBOSE: print " - Fit normalization vs integral:", signalYield[m].getVal(), "/", boundaryFactor, "events" if channel=='nnbb' and m==5000: signalNorm[m].setVal(2.5) elif channel=='nn0b' and m==5000: signalNorm[m].setVal(6.7) else: signalNorm[m].setVal( boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal()) # here normalize to sigma(X) x Br(X->VH) = 1 [fb] a1[m].setConstant(True) a2[m].setConstant(True) vmean[m].setConstant(True) vsigma[m].setConstant(True) valpha1[m].setConstant(True) vslope1[m].setConstant(True) salpha2[m].setConstant(True) sslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) #*******************************************************# # # # Signal interpolation # # # #*******************************************************# # ====== CONTROL PLOT ====== c_signal = TCanvas("c_signal", "c_signal", 800, 600) c_signal.cd() frame_signal = X_mass.frame() for m in genPoints[:-2]: if m in signalExt.keys(): signal[m].plotOn(frame_signal, RooFit.LineColor(sample["%s_M%d" % (stype, m)]['linecolor']), RooFit.Normalization(signalNorm[m].getVal(), RooAbsReal.NumEvent), RooFit.Range("X_reasonable_range")) frame_signal.GetXaxis().SetRangeUser(0, 6500) frame_signal.Draw() drawCMS(-1, YEAR, "Simulation") drawAnalysis(channel) drawRegion(channel) c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.pdf") c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.png") #if VERBOSE: raw_input("Press Enter to continue...") # ====== CONTROL PLOT ====== # Normalization gnorm = TGraphErrors() gnorm.SetTitle(";m_{X} (GeV);integral (GeV)") gnorm.SetMarkerStyle(20) gnorm.SetMarkerColor(1) gnorm.SetMaximum(0) inorm = TGraphErrors() inorm.SetMarkerStyle(24) fnorm = TF1("fnorm", "pol9", 800, 5000) #"pol5" if not channel=="XZHnnbb" else "pol6" #pol5*TMath::Floor(x-1800) + ([5]*x + [6]*x*x)*(1-TMath::Floor(x-1800)) fnorm.SetLineColor(920) fnorm.SetLineStyle(7) fnorm.SetFillColor(2) fnorm.SetLineColor(cColor) # Mean gmean = TGraphErrors() gmean.SetTitle(";m_{X} (GeV);gaussian mean (GeV)") gmean.SetMarkerStyle(20) gmean.SetMarkerColor(cColor) gmean.SetLineColor(cColor) imean = TGraphErrors() imean.SetMarkerStyle(24) fmean = TF1("fmean", "pol1", 0, 5000) fmean.SetLineColor(2) fmean.SetFillColor(2) # Width gsigma = TGraphErrors() gsigma.SetTitle(";m_{X} (GeV);gaussian width (GeV)") gsigma.SetMarkerStyle(20) gsigma.SetMarkerColor(cColor) gsigma.SetLineColor(cColor) isigma = TGraphErrors() isigma.SetMarkerStyle(24) fsigma = TF1("fsigma", "pol1", 0, 5000) fsigma.SetLineColor(2) fsigma.SetFillColor(2) # Alpha1 galpha1 = TGraphErrors() galpha1.SetTitle(";m_{X} (GeV);crystal ball lower alpha") galpha1.SetMarkerStyle(20) galpha1.SetMarkerColor(cColor) galpha1.SetLineColor(cColor) ialpha1 = TGraphErrors() ialpha1.SetMarkerStyle(24) falpha1 = TF1("falpha", "pol0", 0, 5000) falpha1.SetLineColor(2) falpha1.SetFillColor(2) # Slope1 gslope1 = TGraphErrors() gslope1.SetTitle(";m_{X} (GeV);exponential lower slope (1/Gev)") gslope1.SetMarkerStyle(20) gslope1.SetMarkerColor(cColor) gslope1.SetLineColor(cColor) islope1 = TGraphErrors() islope1.SetMarkerStyle(24) fslope1 = TF1("fslope", "pol0", 0, 5000) fslope1.SetLineColor(2) fslope1.SetFillColor(2) # Alpha2 galpha2 = TGraphErrors() galpha2.SetTitle(";m_{X} (GeV);crystal ball upper alpha") galpha2.SetMarkerStyle(20) galpha2.SetMarkerColor(cColor) galpha2.SetLineColor(cColor) ialpha2 = TGraphErrors() ialpha2.SetMarkerStyle(24) falpha2 = TF1("falpha", "pol0", 0, 5000) falpha2.SetLineColor(2) falpha2.SetFillColor(2) # Slope2 gslope2 = TGraphErrors() gslope2.SetTitle(";m_{X} (GeV);exponential upper slope (1/Gev)") gslope2.SetMarkerStyle(20) gslope2.SetMarkerColor(cColor) gslope2.SetLineColor(cColor) islope2 = TGraphErrors() islope2.SetMarkerStyle(24) fslope2 = TF1("fslope", "pol0", 0, 5000) fslope2.SetLineColor(2) fslope2.SetFillColor(2) n = 0 for i, m in enumerate(genPoints): if not m in signalNorm.keys(): continue if signalNorm[m].getVal() < 1.e-6: continue signalString = "M%d" % m signalName = "%s_M%d" % (stype, m) if gnorm.GetMaximum() < signalNorm[m].getVal(): gnorm.SetMaximum(signalNorm[m].getVal()) gnorm.SetPoint(n, m, signalNorm[m].getVal()) gmean.SetPoint(n, m, vmean[m].getVal()) gmean.SetPointError(n, 0, min(vmean[m].getError(), vmean[m].getVal()*0.02)) gsigma.SetPoint(n, m, vsigma[m].getVal()) gsigma.SetPointError(n, 0, min(vsigma[m].getError(), vsigma[m].getVal()*0.05)) galpha1.SetPoint(n, m, valpha1[m].getVal()) galpha1.SetPointError(n, 0, min(valpha1[m].getError(), valpha1[m].getVal()*0.10)) gslope1.SetPoint(n, m, vslope1[m].getVal()) gslope1.SetPointError(n, 0, min(vslope1[m].getError(), vslope1[m].getVal()*0.10)) galpha2.SetPoint(n, m, salpha2[m].getVal()) galpha2.SetPointError(n, 0, min(salpha2[m].getError(), salpha2[m].getVal()*0.10)) gslope2.SetPoint(n, m, sslope2[m].getVal()) gslope2.SetPointError(n, 0, min(sslope2[m].getError(), sslope2[m].getVal()*0.10)) n = n + 1 print "fit on gmean:" gmean.Fit(fmean, "Q0", "SAME") print "fit on gsigma:" gsigma.Fit(fsigma, "Q0", "SAME") print "fit on galpha:" galpha1.Fit(falpha1, "Q0", "SAME") print "fit on gslope:" gslope1.Fit(fslope1, "Q0", "SAME") galpha2.Fit(falpha2, "Q0", "SAME") gslope2.Fit(fslope2, "Q0", "SAME") #for m in [5000, 5500]: gnorm.SetPoint(gnorm.GetN(), m, gnorm.Eval(m, 0, "S")) gnorm.Fit(fnorm, "Q", "SAME", 700, 5000) for m in massPoints: signalName = "%s_M%d" % (stype, m) if vsigma[m].getVal() < 10.: vsigma[m].setVal(10.) # Interpolation method syield = gnorm.Eval(m) spline = gnorm.Eval(m, 0, "S") sfunct = fnorm.Eval(m) #delta = min(abs(1.-spline/sfunct), abs(1.-spline/syield)) delta = abs(1.-spline/sfunct) if sfunct > 0 else 0 syield = spline if interPar: jmean = gmean.Eval(m) jsigma = gsigma.Eval(m) jalpha1 = galpha1.Eval(m) jslope1 = gslope1.Eval(m) else: jmean = fmean.GetParameter(0) + fmean.GetParameter(1)*m + fmean.GetParameter(2)*m*m jsigma = fsigma.GetParameter(0) + fsigma.GetParameter(1)*m + fsigma.GetParameter(2)*m*m jalpha1 = falpha1.GetParameter(0) + falpha1.GetParameter(1)*m + falpha1.GetParameter(2)*m*m jslope1 = fslope1.GetParameter(0) + fslope1.GetParameter(1)*m + fslope1.GetParameter(2)*m*m inorm.SetPoint(inorm.GetN(), m, syield) signalNorm[m].setVal(syield) imean.SetPoint(imean.GetN(), m, jmean) if jmean > 0: vmean[m].setVal(jmean) isigma.SetPoint(isigma.GetN(), m, jsigma) if jsigma > 0: vsigma[m].setVal(jsigma) ialpha1.SetPoint(ialpha1.GetN(), m, jalpha1) if not jalpha1==0: valpha1[m].setVal(jalpha1) islope1.SetPoint(islope1.GetN(), m, jslope1) if jslope1 > 0: vslope1[m].setVal(jslope1) c1 = TCanvas("c1", "Crystal Ball", 1200, 800) c1.Divide(2, 2) c1.cd(1) gmean.SetMinimum(0.) gmean.Draw("APL") imean.Draw("P, SAME") drawRegion(channel) c1.cd(2) gsigma.SetMinimum(0.) gsigma.Draw("APL") isigma.Draw("P, SAME") drawRegion(channel) c1.cd(3) galpha1.Draw("APL") ialpha1.Draw("P, SAME") drawRegion(channel) galpha1.GetYaxis().SetRangeUser(0., 5.) c1.cd(4) gslope1.Draw("APL") islope1.Draw("P, SAME") drawRegion(channel) gslope1.GetYaxis().SetRangeUser(0., 125.) if False: c1.cd(5) galpha2.Draw("APL") ialpha2.Draw("P, SAME") drawRegion(channel) c1.cd(6) gslope2.Draw("APL") islope2.Draw("P, SAME") drawRegion(channel) gslope2.GetYaxis().SetRangeUser(0., 10.) c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.pdf") c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.png") c2 = TCanvas("c2", "Signal Efficiency", 800, 600) c2.cd(1) gnorm.SetMarkerColor(cColor) gnorm.SetMarkerStyle(20) gnorm.SetLineColor(cColor) gnorm.SetLineWidth(2) gnorm.Draw("APL") inorm.Draw("P, SAME") gnorm.GetXaxis().SetRangeUser(genPoints[0]-100, genPoints[-1]+100) gnorm.GetYaxis().SetRangeUser(0., gnorm.GetMaximum()*1.25) drawCMS(-1,YEAR , "Simulation") drawAnalysis(channel) drawRegion(channel) c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.pdf") c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# # create workspace w = RooWorkspace("ZH_RunII", "workspace") for m in massPoints: getattr(w, "import")(signal[m], RooFit.Rename(signal[m].GetName())) getattr(w, "import")(signalNorm[m], RooFit.Rename(signalNorm[m].GetName())) getattr(w, "import")(signalXS[m], RooFit.Rename(signalXS[m].GetName())) w.writeToFile("%s%s.root" % (WORKDIR, stype+channel), True) print "Workspace", "%s%s.root" % (WORKDIR, stype+channel), "saved successfully" sys.exit()
def fitWPeak(): # Get histograms from file mcHist = 0 with root_open(inputFile, 'read') as file: gROOT.cd() mcHist = file.Get(inputHistogram).Clone('histToFit') # mcHist = file.Get(inputHistogram).GetStack().Last().Clone('histToFit') # Data hist gone out of scope? print mcHist # Import the data to fit # Declare variables x,mean,sigma with associated name, title, initial value and allowed range x = RooRealVar("M(jj)", "M(jj)", 40, 180) histToFit = RooDataHist('histToFit', 'histToFit', RooArgList(x), RooFit.Import(mcHist)) frame = x.frame(RooFit.Title("E Plus Jets")) histToFit.plotOn(frame) # Setup fit function fitFunction = None print fitFunction if whatToFit == 'realLife': # Stuff for gauss mg = RooRealVar("mean", "mean of gaussian", 86, 50, 120) sg = RooRealVar("sigma", "width of gaussian", 10, 0, 50) gauss = RooGaussian("gauss", "gaussian PDF", x, mg, sg) CBmean = RooRealVar("CBmean", "CBmean", 110, 60, 200) CBsigma = RooRealVar("CBsigma", "CBsigma", 40, 20, 100) CBalpha = RooRealVar("CBalpha", "CBalpha", -0.5, -20., 0.) # CBalpha = RooRealVar("CBalpha", "CBalpha", 10, 0., 20.) CBn = RooRealVar("CBn", "CBn", 1., 0., 20.) crystalBall = RooCBShape("crystalBall", "Crystal Ball resolution model", x, CBmean, CBsigma, CBalpha, CBn) fracGauss = RooRealVar("fracGauss", "fracGauss", 0.4, 0, 1) gaussPlusCrystalBall = RooAddPdf("gaussPlusCrystalBall", "Gauss plus Crystal Ball", RooArgList(gauss, crystalBall), RooArgList(fracGauss)) fitFunction = gaussPlusCrystalBall elif whatToFit == 'partons': mg = RooRealVar("mean", "mean of gaussian", 86, 50, 120) sg = RooRealVar("sigma", "width of gaussian", 10, 0, 50) breitWigner = RooBreitWigner('bw', 'bw', x, mg, sg) fitFunction = breitWigner elif whatToFit == 'genJetsFromPartons': # mg = RooRealVar("mean","mean of gaussian",86,50,120) # sg = RooRealVar("sigma","width of gaussian",10,0,50) # breitWigner = RooBreitWigner('bw', 'bw', x, mg, sg) # fitFunction = breitWigner # mg = RooRealVar("mean","mean of gaussian",86,50,120) # sg = RooRealVar("sigma","width of gaussian",1,0,20) # width = RooRealVar("width","width of gaussian",5,0,50) # voigtian = RooVoigtian("voigt","voigt",x,mg,sg,width); # fitFunction = voigtian mg = RooRealVar("mean", "mean of gaussian", 86, 50, 120) sg = RooRealVar("sigma", "width of gaussian", 10, 0, 50) gauss = RooGaussian("gauss", "gaussian PDF", x, mg, sg) fitFunction = gauss print fitFunction # # Fit pdf to data fitFunction.fitTo(histToFit) # Plot histogram being fitted histToFit.plotOn(frame) # Plot fit functions and components fitFunction.plotOn(frame, RooFit.LineColor(kRed)) print 'Chi square with 7 : ', frame.chiSquare(7) print frame.chiSquare() print fitFunction.getParameters(histToFit).selectByAttrib( 'Constant', kFALSE).getSize() toPlot = RooArgSet(crystalBall) fitFunction.plotOn(frame, RooFit.Components(toPlot), RooFit.LineStyle(kDashed), RooFit.LineColor(kRed)) toPlot = RooArgSet(gauss) fitFunction.plotOn(frame, RooFit.Components(toPlot), RooFit.LineStyle(kDashed), RooFit.LineColor(kBlue)) fitFunction.paramOn(frame, RooFit.Layout(0.55, 0.9, 0.9)) # Print values of mean and sigma (that now reflect fitted values and errors) mg.Print() sg.Print() # CBmean.Print() # CBsigma.Print() # CBalpha.Print() # CBn.Print() # fracGauss.Print() # # Draw frame on a canvas c = TCanvas("WMass", "WMass", 800, 400) gPad.SetLeftMargin(0.15) frame.GetYaxis().SetTitleOffset(1.6) frame.Draw() gPad.Update() c.Print('EPlusJets_mjj_fit.pdf') raw_input()