def model_hist_fast(xvar, yvar, modfuncs, nbins=95): """Construct histogram of model functions, based on bin centers. xvar, yvar: Coordinate variables. modfuncs: Model functions used in fit. nbins: Number of bins in histograms. """ hists = [ modfuncs[j].createHistogram('hmodel{0}{1}'.format(c, i), xvar, RooFit.Binning(nbins), RooFit.YVar(yvar, RooFit.Binning(nbins))) for j, (i, c) in enumerate(ic) ] return hists
def data_hist(xvar, yvar, datahist, nbins=95): """Construct histogram of data. xvar, yvar: Coordinate variables. datahist: Histogram of data used in fit. nbins: Number of bins in histograms. """ hists = [ datahist[j].createHistogram('hdata{0}{1}'.format(c, i), xvar, RooFit.Binning(nbins), RooFit.YVar(yvar, RooFit.Binning(nbins))) for j, (i, c) in enumerate(ic) ] return hists
def bkg_fit(tree, outputfile, branches): print "combinatorial" wspace, dataset, bMass, theBMass = define_workspace_bmass_data( "wspace_comb_bkg", branches[0], tree) wspace.factory('exp_alpha[-1.0, -100.0, -1.e-4]') wspace.factory('Exponential::bkg(x,exp_alpha)') wspace.factory('nbkg[1000,0,10e+6]') wspace.factory('RooExtendPdf::ebkg(bkg,nbkg)') nbkg = wspace.var('nbkg') ebkg = wspace.pdf('ebkg') results = ebkg.fitTo(dataset, RooFit.Extended(True), RooFit.Save(), RooFit.Range(4.7, 5.7), RooFit.PrintLevel(-1)) results.Print() bkgframe = theBMass.frame() dataset.plotOn(bkgframe, RooFit.Binning(nbin_data), RooFit.Name("datas")) ebkg.plotOn(bkgframe, RooFit.Name("ebkg"), RooFit.LineColor(49), RooFit.Normalization(1.0, ROOT.RooAbsReal.RelativeExpected), RooFit.LineWidth(3)) params = ebkg.getParameters(ROOT.RooArgSet(bMass)) #c1=canvas_create(bkgframe,4.7,5.7,nbin_data,'m (e^{+}e^{-}K) [GeV]') c1, top, bottom = canvas_create_pull(bkgframe, 4.7, 5.7, nbin_data, 'm(e^{+}e^{-}K) [GeV]', theBMass) top.cd() CMS_lumi() c1.SaveAs('bkg_comb_' + outputfile + '.pdf') n_param = results.floatParsFinal().getSize() print "chi2", bkgframe.chiSquare(n_param), "ndof", n_param print "edm", results.edm(), "log", results.minNll() residuals(bkgframe, theBMass, 'bkg_comb_' + outputfile) return {"exp_alpha": params.getRealValue('exp_alpha')}
def fitNBkg(ibdt, fullbkg, isample): slope = RooRealVar("slope", "slope", 0.5, -10, 10) bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass) cut = cut_base + '&& bdt_prob > %s' % (ibdt) theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt], B0Mass_ + 3 * dict_sigma[ibdt]) databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut) r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right'), RooFit.PrintLevel(-1)) frame = theBMass.frame() databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7)) bkg_exp.plotOn(frame, ) canv = ROOT.TCanvas() frame.Draw() nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000) ebkg = RooExtendPdf( 'ebkg', 'ebkg', bkg_exp, nbkg, 'sigRangeMC') ## here imposing the range to calculate bkg yield ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right'), RooFit.PrintLevel(-1)) ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6)) frame.Draw() # canv.SaveAs('bkg_fit_bdt%f_sample%i.pdf'%(ibdt,isample)) dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def fitNBkg(ibdt, fullbkg): slope = RooRealVar("slope", "slope", 0.5, -10, 10) bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass) cut = cut_base + '&& bdt_prob > %s' % (ibdt) theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt], B0Mass_ + 3 * dict_sigma[ibdt]) databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut) r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right')) frame = theBMass.frame() databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7)) bkg_exp.plotOn(frame, ) # bkg_exp.fixCoefRange('left,right') nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000) ebkg = RooExtendPdf('ebkg', 'ebkg', bkg_exp, nbkg, 'sigRangeMC') ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right')) ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6)) frame.Draw() dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def kde_fit(tree, outputfile, branches, pdfname, SavePlot=True): print "KDE - {}".format(pdfname) wspace, dataset, bMass, theBMass = define_workspace_bmass_data( "wspace_kde", branches[0], tree) kde_frame = theBMass.frame() wspace.factory('KeysPdf::{0}(x,data,MirrorLeft,2.0)'.format(pdfname)) kde = wspace.pdf(pdfname) dataset.plotOn(kde_frame, RooFit.Binning(nbin_data), RooFit.Name("datas")) kde.plotOn(kde_frame, RooFit.LineColor(ROOT.kBlue), RooFit.LineWidth(2)) #wf = ROOT.TFile('ws_bkg_kde_'+outputfile+'_{}.root'.format(pdfname), "RECREATE") #wspace.Write() #wf.Close() #c1=canvas_create(kde_frame,4.7,5.7,nbin_data,'m (e^{+}e^{-}K) [GeV] ') c1, top, bottom = canvas_create_pull(kde_frame, 4.7, 5.7, nbin_data, 'm(e^{+}e^{-}K) [GeV]', theBMass) top.cd() CMS_lumi() if SavePlot: c1.SaveAs('bkg_kde_' + outputfile + '_{}.pdf'.format(pdfname)) residuals(kde_frame, theBMass, 'bkg_kde_' + outputfile + '_' + pdfname) return kde
def fitNSig(ibdt, fulldata, isample): mean = RooRealVar("mass", "mean", B0Mass_, 3, 7, "GeV") sigma = RooRealVar("#sigma_{1}", "sigma", 0.028, 0, 10, "GeV") signalGauss = RooGaussian("signalGauss", "signal gauss", theBMass, mean, sigma) sigma2 = RooRealVar("#sigma_{2}", "sigma2", 0.048, 0, 0.09, "GeV") signalGauss2 = RooGaussian("signalGauss2", "signal gauss2", theBMass, mean, sigma2) f1 = RooRealVar("f1", "f1", 0.8, 0., 1.) gaus = RooAddPdf("gaus", "gaus1+gaus2", RooArgList(signalGauss, signalGauss2), RooArgList(f1)) pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10) pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10) # pol_c3 = RooRealVar ("p3" , "coeff x^2 term", 0.5, -10, 10); # slope = RooRealVar ("slope" , "slope" , 0.5, -10, 10); # bkg_exp = RooExponential("bkg_exp" , "exponential" , slope, theBMass ); bkg_pol = RooChebychev("bkg_pol", "2nd order pol", theBMass, RooArgList(pol_c1)) nsig = RooRealVar("Yield", "signal frac", 40000, 0, 1000000) nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000) cut = cut_base + '&& bdt_prob > %s' % (ibdt) data = fulldata.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut) fitFunction = RooAddPdf("fitfunction", "fit function", RooArgList(gaus, bkg_pol), RooArgList(nsig, nbkg)) r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range(4.9, 5.6), RooFit.PrintLevel(-1)) frame = theBMass.frame() data.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame, ) fitFunction.plotOn(frame, RooFit.Components("bkg_pol"), RooFit.LineStyle(ROOT.kDashed)) fitFunction.plotOn(frame, RooFit.Components("signalGauss"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen + 1)) fitFunction.plotOn(frame, RooFit.Components("signalGauss2"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kOrange + 1)) parList = RooArgSet(nsig, sigma, sigma2, mean) ###### fitFunction.plotOn(frame, RooFit.Components("signalGauss2"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen+2)); fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62, 0.86, 0.88)) canv = ROOT.TCanvas() frame.Draw() # canv.SaveAs('sig_fit_bdt%f_sample%i.pdf'%(ibdt,isample)) dict_s_v1[ibdt] = [nsig.getVal(), nsig.getError()] dict_sigma[ibdt] = math.sqrt(f1.getVal() * (sigma.getVal()**2) + (1 - f1.getVal()) * (sigma2.getVal()**2))
def drawBtnClicked(self): self.readParameters() self.displayParameters() modelFunctions = self.model.model_functions() self._hists = [] for i in range(4): self._canvas[i].GetCanvas().cd() hist = modelFunctions[i].createHistogram( 'model{0}'.format(i), self.model.xvar(), RooFit.Binning(95), RooFit.YVar(self.model.yvar(), RooFit.Binning(95)) ) hist.SetTitle('') hist.GetXaxis().SetTitle('') hist.GetYaxis().SetTitle('') hist.GetZaxis().SetTitle('') hist.Draw('COLZ') self._hists.append(hist) self._canvas[i].GetCanvas().Update()
def signal_fit(tree, outputfile, branches, SavePlot=True): print "Signal" wspace, dataset, bMass, theBMass = define_workspace_bmass_data( "wspace_signal", branches[0], tree) # signal wspace.factory('mean[5.2873e+00, 5.25e+00, 5.3e+00]') wspace.factory('width[5.0642e-02, 1.0e-6, 5.0e-1]') wspace.factory('alpha1[8.1430e-01, 0.0, 10.0]') wspace.factory('n1[9.8615e+01, 0.0, 100.0]') wspace.factory('CBShape::sigcb(x,mean,width,alpha1,n1)') wspace.factory('mean2[5.2274e+00, 5.0e+00, 5.30e+00]') wspace.factory('width2[9.3738e-02, 1.0e-6, 5.0e-1]') wspace.factory('RooGaussian::sigg(x,mean2,width2)') wspace.factory('frac[4.4875e-01, 0, 1.0]') wspace.factory('SUM::sig(sigcb,frac*sigg)') sgnframe = theBMass.frame() wspace.factory('nsig[1000,0,100000000]') wspace.factory('RooExtendPdf::esig(sig,nsig)') sig = wspace.pdf('sig') nsig = wspace.var('nsig') esig = wspace.pdf('esig') results = esig.fitTo(dataset, RooFit.Extended(True), RooFit.Save(), RooFit.Range(4.7, 5.7), RooFit.PrintLevel(-1)) results.Print() dataset.plotOn(sgnframe, RooFit.Binning(nbin_data), RooFit.Name("datas")) esig.plotOn(sgnframe, RooFit.Normalization(1.0, ROOT.RooAbsReal.RelativeExpected), RooFit.LineColor(ROOT.kBlue), RooFit.LineWidth(2)) n_param = results.floatParsFinal().getSize() print "chi2", sgnframe.chiSquare(n_param), "ndof", n_param print "edm", results.edm(), "log", results.minNll() #c1=canvas_create(sgnframe,4.7,5.7,nbin_data,'m (e^{+}e^{-}K) [GeV] ') c1, top, bottom = canvas_create_pull(sgnframe, 4.7, 5.7, nbin_data, 'm(e^{+}e^{-}K) [GeV]', theBMass) top.cd() CMS_lumi() if SavePlot: c1.SaveAs('sgn_eek_' + outputfile + '.pdf') residuals(sgnframe, theBMass, 'sgn_eek_' + outputfile) params = esig.getParameters(ROOT.RooArgSet(bMass)) #return {"mean":1} return { "mean": params.getRealValue('mean'), "width": params.getRealValue('width'), "alpha1": params.getRealValue('alpha1'), "n1": params.getRealValue('n1'), "frac": params.getRealValue('frac'), "gauss_mean": params.getRealValue('mean2'), "gauss_width": params.getRealValue('width2') }
def signal_fit(tree, outputfile, branches): print "Signal" wspace, dataset, bMass, theBMass = define_workspace_bmass_data( "wspace_signal", branches[0], tree) # signal wspace.factory('mean[5.272e+00, 5.22e+00, 5.5e+00]') wspace.factory('width[4.1858e-02, 1.0e-6, 5.0e-1]') wspace.factory('alpha1[1.0, 0.0, 10.0]') wspace.factory('n1[1.0, 1.0, 20.0]') wspace.factory('alpha2[1.0, 0.0, 10.0]') wspace.factory('n2[1.0, 1.0, 20.0]') wspace.factory( 'GenericPdf::sig( "DoubleSidedCB2(x,mean,width,alpha1,n1,alpha2,n2)",{x,mean,width,alpha1,n1,alpha2,n2})' ) sgnframe = theBMass.frame() wspace.factory('nsig[1000,0,100000000]') wspace.factory('RooExtendPdf::esig(sig,nsig)') sig = wspace.pdf('sig') nsig = wspace.var('nsig') esig = wspace.pdf('esig') results = esig.fitTo(dataset, RooFit.Extended(True), RooFit.Save(), RooFit.Range(4.7, 5.7), RooFit.PrintLevel(-1)) results.Print() dataset.plotOn(sgnframe, RooFit.Binning(nbin_data), RooFit.Name("datas")) esig.plotOn(sgnframe, RooFit.Normalization(1.0, ROOT.RooAbsReal.RelativeExpected), RooFit.LineColor(ROOT.kBlue), RooFit.LineWidth(2)) n_param = results.floatParsFinal().getSize() print "chi2", sgnframe.chiSquare(n_param), "ndof", n_param print "edm", results.edm(), "log", results.minNll() #c1=canvas_create(sgnframe,4.7,5.7,nbin_data,'m (e^{+}e^{-}K) [GeV] ') c1, top, bottom = canvas_create_pull(sgnframe, 4.7, 5.7, nbin_data, 'm(e^{+}e^{-}K) [GeV]', theBMass) top.cd() CMS_lumi() c1.SaveAs('sgn_eek_' + outputfile + '.pdf') residuals(sgnframe, theBMass, 'sgn_eek_' + outputfile) params = esig.getParameters(ROOT.RooArgSet(bMass)) return { "mean": params.getRealValue('mean'), "width": params.getRealValue('width'), "alpha1": params.getRealValue('alpha1'), "n1": params.getRealValue('n1'), "alpha2": params.getRealValue('alpha2'), "n2": params.getRealValue('n2') }
def otherB_fit(tree, outputfile, branches, SavePlot=True): print "otherB" wspace, dataset, bMass, theBMass = define_workspace_bmass_data( "wspace_otherB_bkg", branches[0], tree) #wspace.factory('exp_alpha_otherb[-15.7, -100.0, -1.e-4]') wspace.factory('exp_alpha_otherb[-15.7, -100.0, -5.0]') exp_alpha_otherb = wspace.var('exp_alpha_otherb') wspace.factory('Exponential::exp_otherb(x,exp_alpha_otherb)') wspace.factory('notherB[1000,0,10e+6]') wspace.factory('RooExtendPdf::eexp_otherb(exp_otherb,notherB)') notherB = wspace.var('notherB') eexp_otherb = wspace.pdf('eexp_otherb') results = eexp_otherb.fitTo(dataset, RooFit.Extended(True), RooFit.Save(), RooFit.Range(4.7, 5.7), RooFit.PrintLevel(-1)) results.Print() otherb_frame = theBMass.frame() dataset.plotOn(otherb_frame, RooFit.Binning(nbin_data), RooFit.Name("datas")) eexp_otherb.plotOn( otherb_frame, RooFit.Name("eexpOB"), RooFit.LineColor(30), RooFit.Normalization(1.0, ROOT.RooAbsReal.RelativeExpected), RooFit.LineWidth(3)) #c1=canvas_create(otherb_frame,4.7,5.7,nbin_data,'m (e^{+}e^{-}K) [GeV] ') c1, top, bottom = canvas_create_pull(otherb_frame, 4.7, 5.7, nbin_data, 'm(e^{+}e^{-}K) [GeV]', theBMass) top.cd() CMS_lumi() if SavePlot: c1.SaveAs('bkg_otherB_' + outputfile + '.pdf') residuals(otherb_frame, theBMass, 'bkg_otherB_' + outputfile) params = eexp_otherb.getParameters(ROOT.RooArgSet(bMass)) n_param = results.floatParsFinal().getSize() print "chi2", otherb_frame.chiSquare(n_param), "ndof", n_param print "edm", results.edm(), "log", results.minNll() return {"exp_alpha_otherb": params.getRealValue('exp_alpha_otherb')}
def kjpsi_fit(tree, outputfile, branches): print "kjpsi" wspace, dataset, bMass, theBMass = define_workspace_bmass_data( "wspace_kjpsi_bkg", branches[0], tree) wspace.factory('mean_kjpsi[4.7, 1.0, 5.0]') wspace.factory('width_kjpsi[0.1, 0.001, 5.0]') wspace.factory("RooGaussian::kjpsi(x,mean_kjpsi,width_kjpsi)") wspace.factory('nkjpsi[1000,0,10e+6]') wspace.factory('RooExtendPdf::ekjpsi(kjpsi,nkjpsi)') nkjpsi = wspace.var('nkjpsi') ekjpsi = wspace.pdf('ekjpsi') results = ekjpsi.fitTo(dataset, RooFit.Extended(True), RooFit.Save(), RooFit.Range(4.7, 5.7), RooFit.PrintLevel(-1)) results.Print() kjpframe = theBMass.frame() dataset.plotOn(kjpframe, RooFit.Binning(nbin_data), RooFit.Name("datas")) ekjpsi.plotOn(kjpframe, RooFit.Name("ekjpsi"), RooFit.LineColor(30), RooFit.Normalization(1.0, ROOT.RooAbsReal.RelativeExpected), RooFit.LineWidth(3)) #c1=canvas_create(kjpframe,4.7,5.7,nbin_data,'m (e^{+}e^{-}K) [GeV] ') c1, top, bottom = canvas_create_pull(kjpframe, 4.7, 5.7, nbin_data, 'm(e^{+}e^{-}K) [GeV]', theBMass) top.cd() CMS_lumi() c1.SaveAs('bkg_jpsik_' + outputfile + '.pdf') residuals(kjpframe, theBMass, 'bkg_jpsik_' + outputfile) params = ekjpsi.getParameters(ROOT.RooArgSet(bMass)) n_param = results.floatParsFinal().getSize() print "chi2", kjpframe.chiSquare(n_param), "ndof", n_param print "edm", results.edm(), "log", results.minNll() return { "mean_kjpsi": params.getRealValue('mean_kjpsi'), "width_kjpsi": params.getRealValue('width_kjpsi') }
def fitData(fulldata, ibin, n_bkg, w): cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)' % ( q2binning[ibin], q2binning[ibin + 1]) fulldata_v2 = fulldata.reduce( RooArgSet(tagged_mass, mumuMass, mumuMassE, randVar), cut) ## reduce to data-like statistics nDataEntries = fulldata_v2.sumEntries() nDesired = n_bin[ibin] / nDataEntries cut = 'rand < %f' % nDesired signaldata = fulldata_v2.reduce( RooArgSet(tagged_mass, mumuMass, mumuMassE), cut) n_realsignal = signaldata.sumEntries() nrt_mc = _getFittedVar("nRT_%s" % ibin, w) nwt_mc = _getFittedVar("nWT_%s" % ibin, w) fraction = nrt_mc / (nrt_mc + nwt_mc) ### creating RT component w.loadSnapshot("reference_fit_RT_%s" % ibin) meanrt = w.var("mean^{RT%s}" % ibin) sigmart = RooRealVar() sigmart1 = RooRealVar() sigmart2 = RooRealVar() alphart1 = RooRealVar() alphart2 = RooRealVar() nrt1 = RooRealVar() nrt2 = RooRealVar() ## double cb fast if ibin < 5: sigmart = w.var("#sigma_{CB}^{RT%s}" % ibin) alphart1 = w.var("#alpha_{1}^{RT%s}" % ibin) alphart2 = w.var("#alpha_{2}^{RT%s}" % ibin) nrt1 = w.var("n_{1}^{RT%s}" % ibin) nrt2 = w.var("n_{2}^{RT%s}" % ibin) ## double cb old else: sigmart1 = w.var("#sigma_{CBRT0}^{%s}" % ibin) sigmart2 = w.var("#sigma_{CBRT1}^{%s}" % ibin) alphart1 = w.var("#alpha_{RT0}^{%s}" % ibin) alphart2 = w.var("#alpha_{RT1}^{%s}" % ibin) nrt1 = w.var("n_{RT0}^{%s}" % ibin) nrt2 = w.var("n_{RT1}^{%s}" % ibin) pars_init_vals = {} theRTgauss = w.pdf("doublecb_RT%s" % ibin) if ibin < 5: c_sigma_rt = _constrainVar(sigmart, 1, pars_init_vals) else: c_sigma_rt1 = _constrainVar(sigmart1, 1, pars_init_vals) c_sigma_rt2 = _constrainVar(sigmart2, 1, pars_init_vals) c_alpha_rt1 = _constrainVar(alphart1, 1, pars_init_vals) c_alpha_rt2 = _constrainVar(alphart2, 1, pars_init_vals) c_n_rt1 = _constrainVar(nrt1, 1, pars_init_vals) c_n_rt2 = _constrainVar(nrt2, 1, pars_init_vals) ### creating WT component w.loadSnapshot("reference_fit_WT_%s" % ibin) meanwt = w.var("mean^{WT%s}" % ibin) sigmawt = w.var("#sigma_{CB}^{WT%s}" % ibin) alphawt1 = w.var("#alpha_{1}^{WT%s}" % ibin) alphawt2 = w.var("#alpha_{2}^{WT%s}" % ibin) nwt1 = w.var("n_{1}^{WT%s}" % ibin) nwt2 = w.var("n_{2}^{WT%s}" % ibin) theWTgauss = w.pdf("doublecb_%s" % ibin) c_sigma_wt = _constrainVar(sigmawt, 1, pars_init_vals) c_alpha_wt1 = _constrainVar(alphawt1, 1, pars_init_vals) c_alpha_wt2 = _constrainVar(alphawt2, 1, pars_init_vals) c_n_wt1 = _constrainVar(nwt1, 1, pars_init_vals) c_n_wt2 = _constrainVar(nwt2, 1, pars_init_vals) ### creating constraints for the RT component c_vars = RooArgSet() if ibin < 5: c_RTgauss = RooProdPdf( "c_RTgauss", "c_RTgauss", RooArgList(theRTgauss, c_alpha_rt1, c_n_rt1, c_sigma_rt, c_alpha_rt2, c_n_rt2)) c_vars = RooArgSet(c_sigma_rt, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) else: c_RTgauss = RooProdPdf( "c_RTgauss", "c_RTgauss", RooArgList(theRTgauss, c_alpha_rt1, c_n_rt1, c_sigma_rt1, c_sigma_rt2, c_alpha_rt2, c_n_rt2)) c_vars = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) ### creating constraints for the WT component c_WTgauss = RooProdPdf( "c_WTgauss", "c_WTgauss", RooArgList(theWTgauss, c_alpha_wt1, c_n_wt1, c_sigma_wt, c_alpha_wt2, c_n_wt2)) c_vars.add(c_sigma_wt) c_vars.add(c_alpha_wt1) c_vars.add(c_alpha_wt2) c_vars.add(c_n_wt1) c_vars.add(c_n_wt2) frt = RooRealVar("F_{RT}", "frt", fraction.n, 0, 1) signalFunction = RooAddPdf("sumgaus", "rt+wt", RooArgList(c_RTgauss, c_WTgauss), RooArgList(frt)) c_frt = RooGaussian("c_frt", "c_frt", frt, ROOT.RooFit.RooConst(fraction.n), ROOT.RooFit.RooConst(fraction.s)) ### creating constraints for the difference between the two peaks deltaPeaks = RooFormulaVar("deltaPeaks", "@0 - @1", RooArgList(meanrt, meanwt)) c_deltaPeaks = RooGaussian( "c_deltaPeaks", "c_deltaPeaks", deltaPeaks, ROOT.RooFit.RooConst(deltaPeaks.getVal()), ROOT.RooFit.RooConst(0.0005) ## value to be checked ) c_signalFunction = RooProdPdf( "c_signalFunction", "c_signalFunction", RooArgList(signalFunction, c_frt, c_deltaPeaks)) c_vars.add(frt) c_vars.add(deltaPeaks) ### now create background parametrization slope = RooRealVar("slope", "slope", 0.5, -10, 10) bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass) pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10) pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10) bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass, RooArgList(pol_c1, pol_c2)) nsig = RooRealVar("Yield", "signal frac", nrt_mc.n + nwt_mc.n, 0, 1000000) nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000) print nsig.getVal() fitFunction = RooAddPdf("fitfunction", "fit function", RooArgList(c_signalFunction, bkg_pol), RooArgList(nsig, nbkg)) pars_to_tune = [ sigmawt, alphawt1, alphawt2, nwt1, nwt2, alphart1, alphart2, nrt1, nrt2 ] if ibin < 5: pars_to_tune.append(sigmart) else: pars_to_tune.append(sigmart1) pars_to_tune.append(sigmart2) ## add toy bkg for itoy in range(args.ntoys): data = deepcopy(signaldata) toy_bkg = generateBkg(tagged_mass, ibin, n_bkg) data.append(toy_bkg) print 'toy number', itoy for ipar in pars_to_tune: ipar.setVal(pars_init_vals[ipar.GetName()]) # r = fitFunction.fitTo(data, # RooFit.Extended(True), # RooFit.Range("full"), # ROOT.RooFit.Constrain(c_vars), # # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), # ROOT.RooFit.Strategy(2), # ROOT.RooFit.Minos(False), # ) # # print 'fit with Hesse strategy 2 done, now Minos' r = fitFunction.fitTo( data, RooFit.Extended(True), RooFit.Save(), RooFit.Range("full"), RooFit.Verbose(False), ROOT.RooFit.Constrain(c_vars), # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), ROOT.RooFit.Strategy(2), ROOT.RooFit.Minos(True), ) # # r.Print() # # r.correlationMatrix().Print() fitStats['data%s_itoy%s' % (ibin, itoy)] = r.status() covStats['data%s_itoy%s' % (ibin, itoy)] = r.covQual() frame = tagged_mass.frame(RooFit.Range("full")) data.plotOn(frame, RooFit.Binning(nbins), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame, RooFit.NormRange("full"), RooFit.Range("full")) ## evaluate sort of chi2 and save number of RT/WT events observables = RooArgSet(tagged_mass) flparams = fitFunction.getParameters(observables) nparam = int( flparams.selectByAttrib("Constant", ROOT.kFALSE).getSize()) pdfstring = "fitfunction_Norm[tagged_mass]_Range[full]_NormRange[full]" chi2s['data%s_itoy%s' % (ibin, itoy)] = frame.chiSquare( pdfstring, "h_fulldata", nparam) frame.addObject(_writeChi2(chi2s['data%s_itoy%s' % (ibin, itoy)])) ## save plot only if 1 toy is run if args.ntoys == 1: drawPdfComponents(fitFunction, frame, ROOT.kAzure, RooFit.NormRange("full"), RooFit.Range("full"), isData=True) fitFunction.paramOn(frame, RooFit.Layout(0.62, 0.86, 0.89)) # parList = RooArgSet (nsig, nbkg, meanrt, meanwt, alphart1, alphart2, meanwt, sigmawt) # if ibin < 5 : # parList.add(sigmart) # else: # parList.add(sigmart1) # parList.add(sigmart2) # parList.add(alphawt1) # parList.add(alphawt2) # parList.add(nwt1) # parList.add(nwt2) # parList.add(frt) # fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62,0.86,0.89)) frame.Draw() niceFrame(frame, '') frame.addObject(_writeFitStatus(r)) c1 = ROOT.TCanvas() upperPad = ROOT.TPad('upperPad', 'upperPad', 0., 0.35, 1., 1.) lowerPad = ROOT.TPad('lowerPad', 'lowerPad', 0., 0.0, 1., 0.345) upperPad.SetBottomMargin(0.012) lowerPad.SetTopMargin(0) lowerPad.SetBottomMargin(0.2) upperPad.Draw() lowerPad.Draw() upperPad.cd() frame.Draw() if not args.year == 'test': writeCMS(frame, args.year, [q2binning[ibin], q2binning[ibin + 1]], 1) frame.Draw() ## add plot of pulls lowerPad.cd() hpull = frame.pullHist("h_fulldata", pdfstring) frame2 = tagged_mass.frame(RooFit.Range("full"), RooFit.Title('')) frame2.addPlotable(hpull, "P") niceFrameLowerPad(frame2, 'pull') frame2.Draw() line = ROOT.TLine(5.0, 1, 5.6, 1) line.SetLineColor(ROOT.kGreen + 3) line.Draw() for ilog in [True, False]: upperPad.SetLogy(ilog) c1.SaveAs( 'fit_results_mass_checkOnMC/toybkg/save_fit_data_%s_%s_nbkg%s_LMNR_Final%s_%s_update_pol2bkg.pdf' % (ibin, args.year, n_bkg, '_logScale' * ilog, itoy)) out_f.cd() # r.Write('results_data_%s_ntoy%s'%(ibin,itoy)) ## compare nkbg fitted w/ original value nbkgs['data%s_itoy%s' % (ibin, itoy)] = (toy_bkg.sumEntries() - nbkg.getVal()) / toy_bkg.sumEntries() nsigs['data%s_itoy%s' % (ibin, itoy)] = (n_realsignal - nsig.getVal()) / n_realsignal
def plot(self, outputfile): ROOT.gStyle.SetOptFit(0000) ROOT.gROOT.SetBatch(True) ROOT.gROOT.SetStyle("Plain") ROOT.gStyle.SetGridStyle(3) ROOT.gStyle.SetOptStat(000000) ROOT.gStyle.SetOptTitle(0) #ROOT.TH1.AddDirectory(False) #xframe = wspace.var('x').frame(RooFit.Title("PF electron")) xframe = self.mass.frame() if self.isMC: self.data.plotOn(xframe, RooFit.Binning(self.nbin_data), RooFit.Name("datapoint")) self.pdf['model'].plotOn(xframe, RooFit.Name("global"), RooFit.Range("Full"), RooFit.LineColor(2), RooFit.MoveToBack()) if self.paramOn: self.pdf['model'].paramOn(xframe, RooFit.Layout(0.60, 0.92, 0.73)) #self.pdf['model'].paramOn(xframe,RooFit.Layout(0.15,0.45,0.73)) xframe.getAttText().SetTextSize(0.03) legend = ROOT.TLegend(0.65, 0.75, 0.92, 0.85) pt = ROOT.TPaveText(0.72, 0.38, 0.92, 0.50, "brNDC") #legend = ROOT.TLegend(0.15,0.75,0.42,0.85) #pt = ROOT.TPaveText(0.15,0.38,0.45,0.50,"brNDC") legend.AddEntry(xframe.findObject("global"), "Total Fit", "l") else: if self.blinded: self.data.plotOn(xframe, RooFit.Binning(self.nbin_data), RooFit.CutRange("SB1,SB2"), RooFit.Name("datapoint")) else: self.data.plotOn(xframe, RooFit.Binning(self.nbin_data), RooFit.Name("datapoint")) self.pdf['model'].plotOn(xframe, RooFit.Name("global"), RooFit.Range("Full"), RooFit.LineColor(2), RooFit.MoveToBack()) self.pdf['model'].plotOn(xframe, RooFit.Name("bkg"), RooFit.Components("bkg"), RooFit.Range("Full"), RooFit.DrawOption("F"), RooFit.VLines(), RooFit.FillColor(42), RooFit.LineColor(42), RooFit.LineWidth(1), RooFit.MoveToBack()) plotted_partial = [] for name, info in self.partialfit.items(): self.pdf['model'].plotOn( xframe, RooFit.Name(name), RooFit.Components("bkg," + ",".join(plotted_partial) + ",{}".format(name)), RooFit.Range("Full"), RooFit.DrawOption("F"), RooFit.VLines(), RooFit.FillColor(info['color']), RooFit.LineColor(info['color']), RooFit.LineWidth(1), RooFit.MoveToBack()) plotted_partial.append(name) self.pdf['model'].plotOn(xframe, RooFit.Name("sig"), RooFit.Components("sig"), RooFit.Range("Full"), RooFit.DrawOption("L"), RooFit.LineStyle(2), RooFit.LineColor(1)) legend = ROOT.TLegend( 0.56, 0.65, 0.92, 0.85 ) #if prefix == 'BToKEE' else ROOT.TLegend(0.46,0.70,0.92,0.85) legend.AddEntry(xframe.findObject("bkg"), "Combinatorial", "f") for name, info in self.partialfit.items(): legend.AddEntry(xframe.findObject(name), info['label'], "f") legend.AddEntry(xframe.findObject("sig"), self.sigName, "l") xframe.GetYaxis().SetTitleOffset(0.9) xframe.GetYaxis().SetTitleFont(42) xframe.GetYaxis().SetTitleSize(0.05) xframe.GetYaxis().SetLabelSize(0.04) xframe.GetYaxis().SetLabelFont(42) xframe.GetXaxis().SetTitleOffset(0.9) xframe.GetXaxis().SetTitleFont(42) xframe.GetXaxis().SetTitleSize(0.05) xframe.GetXaxis().SetLabelSize(0.04) xframe.GetXaxis().SetLabelFont(42) xframe.GetYaxis().SetTitle("Events / {0:.0f} MeV".format( (self.fit_up - self.fit_low) / self.nbin_data * 1000.)) xtitle = "m(K^{+}e^{+}e^{-}) [GeV]" #if prefix == 'BToKEE' else "m(K^{+}K^{-}e^{+}e^{-}) [GeV]" xframe.GetXaxis().SetTitle(xtitle) xframe.SetStats(0) xframe.SetMinimum(0) legend.SetTextFont(42) legend.SetTextSize(0.04) legend.AddEntry(xframe.findObject("datapoint"), "Data", "lpe") if self.drawSNR: pt = ROOT.TPaveText(0.7, 0.35, 0.92, 0.63, "brNDC") #pt = ROOT.TPaveText(0.72,0.30,0.92,0.63,"brNDC") pt.SetFillColor(0) pt.SetBorderSize(1) pt.SetTextFont(42) pt.SetTextSize(0.04) pt.SetTextAlign(12) if self.mvaCut: pt.AddText("MVA cut: {0:.2f}".format(self.mvaCut)) pt.AddText("S_{{total}}: {0:.0f}#pm{1:.0f}".format( self.nsig_total, self.nsig_total_err)) pt.AddText("S: {0:.0f}#pm{1:.0f}".format(self.nsig_interested, self.nsig_interested_err)) if not self.isMC: pt.AddText("B: {0:.0f}#pm{1:.0f}".format( self.nbkg_total, self.nbkg_total_err)) pt.AddText("S/#sqrt{{S+B}}: {0:.1f}".format(self.SNR)) #pt.AddText("Punzi: {0:.1f}".format(Punzi(nbkgWindow, 2.0, 5.0))) if not self.fitConverged: pt.AddText("Fit is not converged") # Plot results of fit on a different frame c2 = ROOT.TCanvas('canvas', 'canvas', 800, 600) c2.SetGrid() c2.cd() ROOT.gPad.SetLeftMargin(0.10) ROOT.gPad.SetRightMargin(0.05) xframe.Draw() legend.Draw() if self.drawSNR: pt.Draw() CMS_lumi(self.isMC) c2.cd() c2.Update() c2.SaveAs(outputfile.replace('.pdf', '') + '.pdf') print("=" * 80)
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() roohistSig = RooDataHist('roohist', 'roohist', RooArgList(x), hSig) roohistSig.Print() res_sig = signal.fitTo(roohistSig, RooFit.Save(ROOT.kTRUE)) res_sig.Print() frame = x.frame() roohistSig.plotOn(frame, RooFit.Binning(166)) signal.plotOn(frame) signal.plotOn(frame, RooFit.Components('bkg'), RooFit.LineColor(ROOT.kRed), RooFit.LineWidth(2), RooFit.LineStyle(ROOT.kDashed)) #frame.GetXaxis().SetRangeUser(1118,6099) frame.GetXaxis().SetRangeUser(minX_mass, maxX_mass) frame.GetXaxis().SetTitle('m_{jj} (GeV)') frame.Draw() parsSig = signal.getParameters(roohistSig) parsSig.setAttribAll('Constant', True) if histpdfSig: # ----------------------------------------- # hist pdf signal
def fit(tree, outputfile, sigPDF=3, bkgPDF=2, fitJpsi=False, isMC=False, doPartial=False, partialinputfile='part_workspace.root', drawSNR=False, mvaCut=0.0, blinded=False, expS=100): msgservice = ROOT.RooMsgService.instance() msgservice.setGlobalKillBelow(RooFit.FATAL) wspace = ROOT.RooWorkspace('myWorkSpace') ROOT.gStyle.SetOptFit(0000) ROOT.gROOT.SetBatch(True) ROOT.gROOT.SetStyle("Plain") ROOT.gStyle.SetGridStyle(3) ROOT.gStyle.SetOptStat(000000) ROOT.gStyle.SetOptTitle(0) thevars = ROOT.RooArgSet() if fitJpsi: xmin, xmax = 2.5, 3.5 bMass = ROOT.RooRealVar("BToKEE_mll_fullfit", "m(e^{+}e^{-})", 2.0, 4.0, "GeV") wspace.factory('mean[3.096916, 2.9, 3.3]') else: bMass = ROOT.RooRealVar("BToKEE_fit_mass", "m(K^{+}e^{+}e^{-})", 4.0, 6.0, "GeV") dieleMass = ROOT.RooRealVar("BToKEE_mll_fullfit", "m(e^{+}e^{-})", 2.0, 4.0, "GeV") if isMC: xmin, xmax = 4.5, 6.0 wspace.factory('mean[5.272e+00, 5.22e+00, 5.3e+00]') else: xmin, xmax = FIT_LOW, FIT_UP wspace.factory('mean[5.2694, 5.2694, 5.2694]') #wspace.factory('mean[5.2681, 5.2681, 5.2681]') thevars.add(dieleMass) thevars.add(bMass) fulldata = ROOT.RooDataSet('fulldata', 'fulldata', tree, ROOT.RooArgSet(thevars)) theBMassfunc = ROOT.RooFormulaVar("x", "x", "@0", ROOT.RooArgList(bMass)) theBMass = fulldata.addColumn(theBMassfunc) theBMass.setRange(xmin, xmax) thevars.add(theBMass) cut = '' #print cut data = fulldata.reduce(thevars, cut) getattr(wspace, 'import')(data, RooFit.Rename("data")) if not blinded: wspace.factory('nsig[5000.0, 0.0, 1000000.0]') else: wspace.factory('nsig[{0}, {0}, {0}]'.format(expS)) wspace.factory('nbkg[10000.0, 0.0, 1000000.0]') wspace.factory('npartial[1000.0, 0.0, 100000.0]') if sigPDF == 0: # Voigtian wspace.factory('width[1.000e-02, 1.000e-04, 1.000e-01]') wspace.factory('sigma[7.1858e-02, 1.e-3, 1.e-1]') wspace.factory('Voigtian::sig(x,mean,width,sigma)') if sigPDF == 1: # Gaussian wspace.factory('sigma[7.1858e-02, 1.0e-3, 5.0e-1]') wspace.factory('Gaussian::sig(x,mean,sigma)') if sigPDF == 2: # Crystal-ball wspace.factory('sigma[7.1858e-02, 1.0e-6, 5.0e-1]') wspace.factory('alpha[1.0, 0.0, 10.0]') wspace.factory('n[2, 1, 10]') wspace.factory('CBShape::sig(x,mean,sigma,alpha,n)') if sigPDF == 3: # Double-sided Crystal-ball if isMC: wspace.factory('width[4.1858e-02, 1.0e-6, 5.0e-1]') wspace.factory('alpha1[1.0, 0.0, 10.0]') wspace.factory('n1[1.0, 1.0, 10.0]') wspace.factory('alpha2[1.0, 0.0, 10.0]') wspace.factory('n2[1.0, 1.0, 10.0]') else: # PF wspace.factory('width[0.06187, 0.06187, 0.06187]') wspace.factory('alpha1[0.667, 0.667, 0.667]') wspace.factory('n1[2.39, 2.39, 2.39]') wspace.factory('alpha2[2.442, 2.442, 2.442]') wspace.factory('n2[3.09, 3.09, 3.09]') # Mix #wspace.factory('width[0.0561, 0.0561, 0.0561]') #wspace.factory('alpha1[0.642, 0.642, 0.642]') #wspace.factory('n1[2.31, 2.31, 2.31]') #wspace.factory('alpha2[1.700, 1.700, 1.700]') #wspace.factory('n2[10.0, 10.0, 10.0]') wspace.factory( 'GenericPdf::sig("DoubleCBFast(x,mean,width,alpha1,n1,alpha2,n2)", {x,mean,width,alpha1,n1,alpha2,n2})' ) if sigPDF == 4: # Two Double-sided Crystal-ball wspace.factory('width[7.1858e-02, 1.0e-6, 5.0e-1]') wspace.factory('alpha1[1.0, 0.0, 10.0]') wspace.factory('n1[2.0, 1.0, 10.0]') wspace.factory('alpha2[1.0, 0.0, 10.0]') wspace.factory('n2[2.0, 1.0, 10.0]') wspace.factory( 'GenericPdf::cb("DoubleCBFast(x,mean,width,alpha1,n1,alpha2,n2)", {x,mean,width,alpha1,n1,alpha2,n2})' ) wspace.factory('sigma[7.1858e-03, 1.0e-6, 5.0e-1]') wspace.factory('Gaussian::gaus(x,mean,sigma)') wspace.factory('f1[0.5, 0.0, 1.0]') wspace.factory('SUM::sig(f1*cb, gaus)') if bkgPDF == 0: # Polynomial wspace.factory('c0[1.0, -1.0, 1.0]') wspace.factory('c1[-0.1, -1.0, 1.0]') wspace.factory('c2[-0.1, -1.0, 1.0]') wspace.factory('Chebychev::bkg(x,{c0,c1,c2})') if bkgPDF == 1: wspace.factory('c1[0.0, -100.0, 100.0]') wspace.factory('Polynomial::bkg(x,{c1})') if bkgPDF == 2: # Exponential wspace.factory('exp_alpha[-3.0, -100.0, -1.0e-5]') alpha = wspace.var('alpha') wspace.factory('Exponential::bkg(x,exp_alpha)') if not isMC: if doPartial: wpf = ROOT.TFile(partialinputfile, "READ") wp = wpf.Get("myPartialWorkSpace") partial = wp.pdf("partial") getattr(wspace, "import")(partial, RooFit.Rename("partial")) wspace.factory('SUM::model1(f1[0.5,0.0,1.0]*partial,bkg)') print('Finished loading KDE!') wspace.factory('SUM::model(nsig*sig,nbkg*model1)') else: wspace.factory('SUM::model(nsig*sig,nbkg*bkg)') else: wspace.factory('ExtendPdf::model(sig,nsig)') model = wspace.pdf('model') bkg = wspace.pdf('model1') sig = wspace.pdf('sig') nsig = wspace.var('nsig') nbkg = wspace.var('nbkg') # define the set obs = (x) wspace.defineSet('obs', 'x') # make the set obs known to Python obs = wspace.set('obs') theBMass.setRange("window", B_LOW, B_UP) theBMass.setRange("SB1", FIT_LOW, BLIND_LOW) theBMass.setRange("SB2", BLIND_UP, FIT_UP) ## fit the model to the data. print('Fitting data...') if not blinded: results = model.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range(xmin, xmax), RooFit.PrintLevel(-1)) else: results = model.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range("SB1,SB2"), RooFit.PrintLevel(-1)) results.Print() if not isMC: fracBkgRange = bkg.createIntegral(obs, obs, "window") fracBkgRangeErr = fracBkgRange.getPropagatedError(results, obs) nbkgWindow = nbkg.getVal() * fracBkgRange.getVal() #print(nbkg.getVal(), fracBkgRange.getVal()) #print(fracBkgRange.getVal(), fracBkgRange.getPropagatedError(results, obs)) fb = fracBkgRange.getVal() dfb = fracBkgRangeErr nb = nbkg.getVal() dnb = nbkg.getError() #print(nb*fb*np.sqrt(pow(dfb/fb,2)+pow(dnb/nb,2))) print( "Number of signals: %f, Number of background: %f, S/sqrt(S+B): %f" % (nsig.getVal(), nbkgWindow, nsig.getVal() / np.sqrt(nsig.getVal() + nbkgWindow))) else: fracSigRange = sig.createIntegral(obs, obs, "window") print(data.sumEntries(), fracSigRange.getVal()) # Plot results of fit on a different frame c2 = ROOT.TCanvas('fig_binnedFit', 'fit', 800, 600) c2.SetGrid() c2.cd() ROOT.gPad.SetLeftMargin(0.10) ROOT.gPad.SetRightMargin(0.05) #xframe = wspace.var('x').frame(RooFit.Title("PF electron")) xframe = theBMass.frame() nbin_data = 30 if blinded else 50 if isMC: data.plotOn(xframe, RooFit.Binning(nbin_data), RooFit.Name("data")) model.plotOn( xframe, RooFit.Name("global"), RooFit.Range("Full"), RooFit.LineColor(2), RooFit.MoveToBack()) # this will show fit overlay on canvas model.paramOn(xframe, RooFit.Layout(0.15, 0.45, 0.85)) xframe.getAttText().SetTextSize(0.03) else: if blinded: nd = data.reduce( '((BToKEE_fit_mass > {}) & (BToKEE_fit_mass < {})) | ((BToKEE_fit_mass > {}) & (BToKEE_fit_mass < {}))' .format(FIT_LOW, BLIND_LOW, BLIND_UP, FIT_UP)).sumEntries( ) / data.reduce( '(BToKEE_fit_mass > {}) & (BToKEE_fit_mass < {})'.format( FIT_LOW, FIT_UP)).sumEntries() data.plotOn(xframe, RooFit.Binning(nbin_data), RooFit.CutRange("SB1,SB2"), RooFit.Name("data")) else: nd = 1.0 data.plotOn(xframe, RooFit.Binning(nbin_data), RooFit.Name("data")) model.plotOn( xframe, RooFit.Name("global"), RooFit.Range("Full"), RooFit.Normalization(nd, ROOT.RooAbsReal.Relative), RooFit.LineColor(2), RooFit.MoveToBack()) # this will show fit overlay on canvas model.plotOn(xframe, RooFit.Name("bkg"), RooFit.Components("bkg"), RooFit.Range("Full"), RooFit.Normalization(nd, ROOT.RooAbsReal.Relative), RooFit.DrawOption("F"), RooFit.VLines(), RooFit.FillColor(42), RooFit.LineColor(42), RooFit.LineWidth(1), RooFit.MoveToBack()) if doPartial: model.plotOn(xframe, RooFit.Name("partial"), RooFit.Components("bkg,partial"), RooFit.Range("Full"), RooFit.Normalization(nd, ROOT.RooAbsReal.Relative), RooFit.DrawOption("F"), RooFit.VLines(), RooFit.FillColor(40), RooFit.LineColor(40), RooFit.LineWidth(1), RooFit.MoveToBack()) model.plotOn(xframe, RooFit.Name("sig"), RooFit.Components("sig"), RooFit.Range("Full"), RooFit.Normalization(nd, ROOT.RooAbsReal.Relative), RooFit.DrawOption("L"), RooFit.LineStyle(2), RooFit.LineColor(1)) xframe.GetYaxis().SetTitleOffset(0.9) xframe.GetYaxis().SetTitleFont(42) xframe.GetYaxis().SetTitleSize(0.05) xframe.GetYaxis().SetLabelSize(0.04) xframe.GetYaxis().SetLabelFont(42) xframe.GetXaxis().SetTitleOffset(0.9) xframe.GetXaxis().SetTitleFont(42) xframe.GetXaxis().SetTitleSize(0.05) xframe.GetXaxis().SetLabelSize(0.04) xframe.GetXaxis().SetLabelFont(42) xframe.GetYaxis().SetTitle("Events") xframe.GetXaxis().SetTitle( "m(e^{+}e^{-}) [GeV]" if fitJpsi else "m(K^{+}e^{+}e^{-}) [GeV]") xframe.SetStats(0) xframe.SetMinimum(0) xframe.Draw() CMS_lumi(isMC) if isMC: legend = ROOT.TLegend(0.65, 0.75, 0.92, 0.85) legend.AddEntry(xframe.findObject("global"), "Total Fit", "l") pt = ROOT.TPaveText(0.72, 0.38, 0.92, 0.50, "brNDC") else: legend = ROOT.TLegend(0.60, 0.65, 0.92, 0.85) legend.AddEntry(xframe.findObject("bkg"), "Combinatorial", "f") pt = ROOT.TPaveText(0.72, 0.38, 0.92, 0.63, "brNDC") if doPartial: legend.AddEntry(xframe.findObject("partial"), "Partially Reco.", "f") legend.AddEntry( xframe.findObject("sig"), "B^{+}#rightarrow K^{+} J/#psi(#rightarrow e^{+}e^{-})", "l") legend.SetTextFont(42) legend.SetTextSize(0.04) legend.AddEntry(xframe.findObject("data"), "Data", "lpe") legend.Draw() if drawSNR: pt.SetFillColor(0) pt.SetBorderSize(1) pt.SetTextFont(42) pt.SetTextSize(0.04) pt.SetTextAlign(12) pt.AddText("MVA cut: {0:.2f}".format(mvaCut)) pt.AddText("S: {0:.0f}#pm{1:.0f}".format(nsig.getVal(), nsig.getError())) if not isMC: pt.AddText("B: {0:.0f}".format(nbkgWindow)) pt.AddText("S/#sqrt{{S+B}}: {0:.1f}".format( nsig.getVal() / np.sqrt(nsig.getVal() + nbkgWindow))) pt.Draw() c2.cd() c2.Update() c2.SaveAs(outputfile) print("=" * 80) if not isMC: return nsig.getVal(), nsig.getError(), nbkgWindow else: return 0.0, 0.0, 0.0
def bkg_unc_propagation(self, outputfile): # define the set obs = (x) self.wspace.defineSet('obs', 'x') # make the set obs known to Python obs = self.wspace.set('obs') nsig_interested_pdf = self.pdf['sig'].createIntegral( obs, obs, "fom_window") nsig_interested_pdf_err = nsig_interested_pdf.getPropagatedError( self.results, obs) self.nsig_interested = self.var['nsig'].getVal( ) * nsig_interested_pdf.getVal() self.nsig_interested_err = self.nsig_interested * np.sqrt( pow(self.var['nsig'].getError() / self.var['nsig'].getVal(), 2) + pow(nsig_interested_pdf_err / nsig_interested_pdf.getVal(), 2) ) if self.var['nsig'].getVal() != 0.0 else 0.0 nbkg_comb_pdf = self.pdf['bkg'].createIntegral(obs, obs, "fom_window") nbkg_comb_pdf_err = nbkg_comb_pdf.getPropagatedError(self.results, obs) nbkg_comb = self.var['nbkg'].getVal() * nbkg_comb_pdf.getVal() nbkg_comb_err = nbkg_comb * np.sqrt( pow(self.var['nbkg'].getError() / self.var['nbkg'].getVal(), 2) + pow(nbkg_comb_pdf_err / nbkg_comb_pdf.getVal(), 2) ) if self.var['nbkg'].getVal() != 0.0 else 0.0 self.nbkg_total = nbkg_comb print("*" * 80) print("MVA Cut: {}".format(self.mvaCut)) if not self.fitConverged: print("*" * 20 + "NOT COVERGE" + "*" * 20) print("Number of signals: {}".format(self.var['nsig'].getVal())) print("Number of signals in 3.0 sigma: {}, uncertainty: {}".format( self.nsig_interested, self.nsig_interested_err)) print( "Number of background - combinatorial: {}, uncertainty: {}".format( nbkg_comb, nbkg_comb_err)) for name in partialfit.keys(): nbkg_pdf_pdf = self.pdf[name].createIntegral( obs, obs, "fom_window") nbkg_partial = self.var[name].getVal() * nbkg_pdf_pdf.getVal() self.nbkg_total += nbkg_partial print("Number of background - {}: {}".format(name, nbkg_partial)) # Calculate 1-sigma error band of the total bkg through linear error propagation bkgframe = self.mass.frame() self.data.plotOn(bkgframe, RooFit.Binning(self.nbin_data)) nbinx = 1000 xvar = np.linspace(self.fom_low, self.fom_up, nbinx) self.fit_params = self.pdf['model'].getVariables() ordered_fit_params = ['exp_alpha', 'nbkg'] + [ 'n' + name for name in self.partialfit.keys() ] if not self.blinded: ordered_fit_params += [ 'nsig', ] full_bkg = [ 'bkg', ] + [name for name in self.partialfit.keys()] fit_params_info = OrderedDict() for name in ordered_fit_params: fit_params_info[name] = { 'mean': self.fit_params.find(name).getVal(), 'error': self.fit_params.find(name).getError() } self.pdf['model'].plotOn(bkgframe, RooFit.Components(",".join(full_bkg))) model_curve = bkgframe.getCurve() model_cen = np.array([model_curve.interpolate(x) for x in xvar]) bkgframe.remove(str(0), False) #self.results.covarianceMatrix().Print() #self.results.correlationMatrix().Print() covMatrix = root_numpy.matrix(self.results.covarianceMatrix()) exp_event = self.pdf['model'].expectedEvents(self.fit_params) fa = [] for name, info in fit_params_info.items(): adjust_norm = info['error'] if (name in ([ 'nsig', 'nbkg', ] + ['n' + p for p in self.partialfit.keys()])) else 0.0 self.fit_params.setRealValue(name, info['mean'] + info['error']) self.pdf['model'].plotOn( bkgframe, RooFit.Components(",".join(full_bkg)), RooFit.Normalization(exp_event + adjust_norm, ROOT.RooAbsReal.NumEvent)) model_curve = bkgframe.getCurve() fa_plus = np.array([model_curve.interpolate(x) for x in xvar]) bkgframe.remove(str(0), False) self.fit_params.setRealValue(name, info['mean'] - 2.0 * info['error']) self.pdf['model'].plotOn( bkgframe, RooFit.Components(",".join(full_bkg)), RooFit.Normalization(exp_event - adjust_norm, ROOT.RooAbsReal.NumEvent)) model_curve = bkgframe.getCurve() fa_minus = np.array([model_curve.interpolate(x) for x in xvar]) bkgframe.remove(str(0), False) if name == 'nsig': fa.append(np.zeros(nbinx)) else: fa.append((fa_plus - fa_minus) / (2.0 * info['error'])) # reset the params matrix self.fit_params.setRealValue(name, info['mean']) fa = np.array(fa).T tmp = np.array( [np.asarray(np.matmul(FA, covMatrix)).flatten() for FA in fa]) bkg_unc = np.sqrt(np.array([np.dot(t, FA) for t, FA in zip(tmp, fa)])) self.nbkg_total_err = np.sqrt(np.trapz(bkg_unc * bkg_unc, x=xvar)) / ( (self.fit_up - self.fit_low) / self.nbin_data) if self.plotBkgUnc: fig, ax = plt.subplots() ax.plot(xvar, model_cen, 'b-', label=r'$N_{{\rm bkg}}={0:.1f}\pm{1:.1f}$'.format( self.nbkg_total, self.nbkg_total_err)) ax.fill_between(xvar, model_cen - bkg_unc, model_cen + bkg_unc, facecolor='red', alpha=0.5, linewidth=0.0, label=r'$1\sigma$') ax.set_xlabel(r'$m(K^{+}e^{+}e^{-}) [{\rm GeV}]$') ax.set_ylabel(r'a.u.') ax.set_ylim(bottom=0) ax.legend(loc='upper right') fig.savefig(outputfile.replace('.pdf', '') + '_totalbkg_1sigma.pdf', bbox_inches='tight') self.SNR = self.nsig_interested / np.sqrt(self.nsig_interested + self.nbkg_total) print("Total number of background: {}, uncertainty: {}".format( self.nbkg_total, self.nbkg_total_err)) print("S/sqrt(S+B): {}".format(self.SNR)) print("*" * 80)
def drawPlot(name, channel, variable, model, dataset, fitRes=[], norm=-1, reg=None, cat="", alt=None, anorm=-1, signal=None, snorm=-1): isData = norm > 0 isMass = "Mass" in name isSignal = '_M' in name mass = name[8:12] isCategory = reg is not None #isBottomPanel = not isSignal isBottomPanel = True postfix = "Mass" if isMass else ('SR' if 'SR' in name else ('SB' if 'SB' in name else "")) cut = "reg==reg::" + cat if reg is not None else "" normRange = "h_extended_reasonable_range" if isMass else "X_reasonable_range" dataRange = "LSBrange,HSBrange" if isMass and isData else normRange cmsLabel = "Preliminary" if isData else "Simulation Preliminary" #if not type(fitRes) is list: cmsLabel = "Preliminary" if 'paper' in name: cmsLabel = "" pullRange = 5 dataMin, dataMax = array('d', [0.]), array('d', [0.]) dataset.getRange(variable, dataMin, dataMax) xmin, xmax = dataMin[0], dataMax[0] lastBin = variable.getMax() if not isMass and not isSignal: if 'nn' in channel or 'll' in channel or 'ee' in channel or 'mm' in channel: lastBin = 3500. else: lastBin = 4500. # ====== CONTROL PLOT ====== c = TCanvas("c_" + name, "Fitting " + name, 800, 800 if isBottomPanel else 600) if isBottomPanel: c.Divide(1, 2) setTopPad(c.GetPad(1), RATIO) setBotPad(c.GetPad(2), RATIO) else: setPad(c.GetPad(0)) c.cd(1) frame = variable.frame() if isBottomPanel: setPadStyle(frame, 1.25, True) # Plot Data data, res = None, None if dataset is not None: data = dataset.plotOn( frame, RooFit.Cut(cut), RooFit.Binning(variable.getBinning("PLOT")), RooFit.DataError( RooAbsData.Poisson if isData else RooAbsData.SumW2), RooFit.Range(dataRange), RooFit.DrawOption("PE0"), RooFit.Name("data_obs")) if data is not None and isData: fixData(data.getHist(), True) # Simple fit if isCategory: if type(fitRes) is list: for f in fitRes: if f is not None: model.plotOn(frame, RooFit.Slice(reg, cat), RooFit.ProjWData(RooArgSet(reg), dataset), RooFit.VisualizeError(f, 1, False), RooFit.SumW2Error(True), RooFit.FillColor(1), RooFit.FillStyle(3002)) if VERBOSE: model.plotOn(frame, RooFit.Slice(reg, cat), RooFit.ProjWData(RooArgSet(reg), dataset), RooFit.VisualizeError(f), RooFit.SumW2Error(True), RooFit.FillColor(2), RooFit.FillStyle(3004)) elif fitRes is not None: frame.addObject(fitRes, "E3") model.plotOn(frame, RooFit.Slice(reg, cat), RooFit.ProjWData(RooArgSet(reg), dataset), RooFit.LineColor(getColor(name, channel))) res = frame.pullHist() if alt is not None: alt.plotOn(frame, RooFit.Normalization(anorm, RooAbsReal.NumEvent), RooFit.LineStyle(7), RooFit.LineColor(922), RooFit.Name("Alternate")) else: if type(fitRes) is list: for f in fitRes: if f is not None: model.plotOn( frame, RooFit.VisualizeError(f, 1, False), RooFit.Normalization( norm if norm > 0 or dataset is None else dataset.sumEntries(), RooAbsReal.NumEvent), RooFit.SumW2Error(True), RooFit.Range(normRange), RooFit.FillColor(1), RooFit.FillStyle(3002), RooFit.DrawOption("F")) if VERBOSE: model.plotOn( frame, RooFit.VisualizeError(f), RooFit.Normalization( norm if norm > 0 or dataset is None else dataset.sumEntries(), RooAbsReal.NumEvent), RooFit.SumW2Error(True), RooFit.Range(normRange), RooFit.FillColor(2), RooFit.FillStyle(3004), RooFit.DrawOption("F")) model.paramOn(frame, RooFit.Label(model.GetTitle()), RooFit.Layout(0.5, 0.95, 0.94), RooFit.Format("NEAU")) elif fitRes is not None: frame.addObject(fitRes, "E3") model.plotOn( frame, RooFit.LineColor(getColor(name, channel)), RooFit.Range(normRange), RooFit.Normalization( norm if norm > 0 or dataset is None else dataset.sumEntries(), RooAbsReal.NumEvent) ) #RooFit.Normalization(norm if norm>0 or dataset is None else dataset.sumEntries(), RooAbsReal.NumEvent) res = frame.pullHist() #if not isSignal else frame.residHist() # plot components for comp in [ "baseTop", "gausW", "gausT", "baseVV", "gausVW", "gausVZ", "gausVH" ]: model.plotOn( frame, RooFit.LineColor(getColor(name, channel)), RooFit.Range(normRange), RooFit.LineStyle(2), RooFit.Components(comp), RooFit.Normalization( norm if norm > 0 or dataset is None else dataset.sumEntries(), RooAbsReal.NumEvent)) if alt is not None: alt.plotOn(frame, RooFit.Range(normRange), RooFit.LineStyle(7), RooFit.LineColor(922), RooFit.Name("Alternate")) # Replot data if dataset is not None: data = dataset.plotOn( frame, RooFit.Cut(cut), RooFit.Binning(variable.getBinning("PLOT")), RooFit.DataError( RooAbsData.Poisson if isData else RooAbsData.SumW2), RooFit.Range(dataRange), RooFit.DrawOption("PE0"), RooFit.Name("data_obs")) if not isMass and not isSignal: # Log scale frame.SetMaximum(frame.GetMaximum() * 10) frame.SetMinimum(max(frame.SetMinimum(), 8.e-2 if isData else 1.e-4)) c.GetPad(1).SetLogy() else: frame.GetYaxis().SetRangeUser(0, frame.GetMaximum()) frame.SetMaximum(frame.GetMaximum() * 1.25) frame.SetMinimum(0) #frame.GetYaxis().SetTitleOffset(frame.GetYaxis().GetTitleOffset()*0.8) frame.GetYaxis().SetTitleOffset(1.4) frame.Draw() #drawCMS(LUMI, cmsLabel) #drawCMS(LUMI, "Work in Progress", suppressCMS=True) drawCMS(LUMI, "Simulation Preliminary") #drawCMS(LUMI, "", suppressCMS=True) drawAnalysis(channel) drawRegion( channel + ("" if isData and not isCategory else ('SR' if 'SR' in name else ('SB' if 'SB' in name else ""))), True) if isSignal: drawMass("M_{Z'} = " + mass + " GeV") if isBottomPanel: c.cd(2) frame_res = variable.frame() setPadStyle(frame_res, 1.25) #res = frame.residHist() if res is not None and isData: fixData(res) if dataset is not None: frame_res.addPlotable(res, "P") setBotStyle(frame_res, RATIO, False) frame_res.GetYaxis().SetRangeUser(-pullRange, pullRange) #frame_res.GetYaxis().SetTitleOffset(frame_res.GetYaxis().GetTitleOffset()*0.4) frame_res.GetYaxis().SetTitle("pulls (#sigma)") frame_res.GetYaxis().SetTitleOffset(0.4) frame_res.Draw() chi2, nbins, npar = 0., 0, 0 if not res == None: for i in range(0, res.GetN()): if data.getHist().GetY()[i] > 1.e-3: nbins = nbins + 1 chi2 += res.GetY()[i]**2 #if isData and not isMass: frame.GetXaxis().SetRangeUser(variable.getMin(), lastBin) frame_res.GetXaxis().SetRangeUser(variable.getMin(), lastBin) line_res = drawLine(frame_res.GetXaxis().GetXmin(), 0, lastBin, 0) c.SaveAs(PLOTDIR + "MC_signal_" + YEAR + "/" + name + ".pdf") c.SaveAs(PLOTDIR + "MC_signal_" + YEAR + "/" + name + ".png")
def fitData(fulldata, ibin): cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)' % ( q2binning[ibin], q2binning[ibin + 1]) data = fulldata.reduce(RooArgSet(tagged_mass, mumuMass, mumuMassE), cut) fraction = dict_s_rt[ibin] / (dict_s_rt[ibin] + dict_s_wt[ibin]) print 'mistag fraction on MC for bin ', ibin, ' : ', fraction.n, '+/-', fraction.s ### creating RT component w.loadSnapshot("reference_fit_RT_%s" % ibin) sigmart1 = w.var("#sigma_{1}^{RT%s}" % ibin) sigmart2 = w.var("#sigma_{2}^{RT%s}" % ibin) massrt = w.var("mean^{RT%s}" % ibin) f1rt = w.var("f^{RT%s}" % ibin) theRTgauss = w.pdf("doublegaus_RT%s" % ibin) c_sigma_rt1 = _constrainVar(sigmart1) c_sigma_rt2 = _constrainVar(sigmart2) c_mean_rt = _constrainVar(massrt) c_f1rt = _constrainVar(f1rt) ### creating WT component w.loadSnapshot("reference_fit_WT_%s" % ibin) meanwt = w.var("mean^{WT%s}" % ibin) sigmawt = w.var("#sigma_{CB}^{WT%s}" % ibin) alphawt1 = w.var("#alpha_{1}^{WT%s}" % ibin) alphawt2 = w.var("#alpha_{2}^{WT%s}" % ibin) nwt1 = w.var("n_{1}^{WT%s}" % ibin) nwt2 = w.var("n_{2}^{WT%s}" % ibin) theWTgauss = w.pdf("doublecb_%s" % ibin) c_mean_wt = _constrainVar(meanwt) c_sigma_wt = _constrainVar(sigmawt) c_alpha_wt1 = _constrainVar(alphawt1) c_alpha_wt2 = _constrainVar(alphawt2) c_n_wt1 = _constrainVar(nwt1) c_n_wt2 = _constrainVar(nwt2) ### creating constraints for the RT component c_RTgauss = RooProdPdf( "c_RTgauss", "c_RTgauss", RooArgList(theRTgauss, c_sigma_rt1, c_sigma_rt2, c_mean_rt, c_f1rt)) c_vars = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_f1rt, c_mean_rt) c_vars.add(c_sigma_wt) c_vars.add(c_mean_wt) c_vars.add(c_alpha_wt1) c_vars.add(c_alpha_wt2) c_vars.add(c_n_wt1) c_vars.add(c_n_wt2) ### creating constraints for the WT component c_WTgauss = RooProdPdf( "c_WTgauss", "c_WTgauss", RooArgList(theWTgauss, c_alpha_wt1, c_n_wt1, c_sigma_wt, c_mean_wt, c_alpha_wt2, c_n_wt2)) frt = RooRealVar("F_{RT}", "frt", fraction.n, 0, 1) signalFunction = RooAddPdf("sumgaus", "rt+wt", RooArgList(c_RTgauss, c_WTgauss), RooArgList(frt)) c_frt = RooGaussian("c_frt", "c_frt", frt, ROOT.RooFit.RooConst(fraction.n), ROOT.RooFit.RooConst(fraction.s)) c_signalFunction = RooProdPdf("c_signalFunction", "c_signalFunction", RooArgList(signalFunction, c_frt)) c_vars.add(frt) ### now create background parametrization slope = RooRealVar("slope", "slope", 0.5, -10, 10) bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass) pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10) pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10) bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass, RooArgList(pol_c1, pol_c2)) nsig = RooRealVar("Yield", "signal frac", 4000, 0, 1000000) nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000) # fitFunction = RooAddPdf ("fitfunction" , "fit function" , RooArgList(c_signalFunction, bkg_pol), RooArgList(nsig, nbkg)) fitFunction = RooAddPdf("fitfunction", "fit function", RooArgList(c_signalFunction, bkg_exp), RooArgList(nsig, nbkg)) r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range("full"), RooFit.Verbose(False), ROOT.RooFit.Constrain(c_vars)) frame = tagged_mass.frame(RooFit.Range("full")) data.plotOn(frame, RooFit.Binning(35), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame) drawPdfComponents(fitFunction, frame, ROOT.kAzure, RooFit.NormRange("full"), RooFit.Range("full"), isData=True) parList = RooArgSet(nsig, massrt, sigmart1, sigmart2, f1rt, meanwt, sigmawt, alphawt1) parList.add(alphawt2) parList.add(nwt1) parList.add(nwt2) parList.add(frt) fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62, 0.86, 0.89)) frame.Draw() niceFrame(frame, '') frame.addObject(_writeFitStatus(r)) if not args.year == 'test': writeCMS(frame, args.year, [q2binning[ibin], q2binning[ibin + 1]]) frame.Draw() c1.SaveAs('fit_results_mass/save_fit_data_%s_%s_LMNR.pdf' % (ibin, args.year))
def drawFit(name, category, variable, model, dataset, binning, fitRes=[], norm=-1): isData = (not 'MC' in dataset.GetTitle()) order = int(name[-1]) npar = fitRes[0].floatParsFinal().getSize() if len(fitRes) > 0 else 0 varArg = RooArgSet(variable) c = TCanvas("c_" + category, category, 800, 800) c.Divide(1, 2) setTopPad(c.GetPad(1), RATIO) setBotPad(c.GetPad(2), RATIO) c.cd(1) frame = variable.frame() setPadStyle(frame, 1.25, True) dataset.plotOn(frame, RooFit.Binning(binning), RooFit.Invisible()) if len(fitRes) > 0: model.plotOn( frame, RooFit.VisualizeError(fitRes[0], 1, False), RooFit.Normalization(norm if norm > 0 else dataset.sumEntries(), RooAbsReal.NumEvent), RooFit.LineColor(getColor(order, category)[0]), RooFit.FillColor(getColor(order, category)[1]), RooFit.FillStyle(1001), RooFit.DrawOption("FL")) model.plotOn( frame, RooFit.Normalization(norm if norm > 0 else dataset.sumEntries(), RooAbsReal.NumEvent), RooFit.LineColor(getColor(order, category)[0]), RooFit.FillColor(getColor(order, category)[1]), RooFit.FillStyle(1001), RooFit.DrawOption("L"), RooFit.Name(model.GetName())) model.paramOn(frame, RooFit.Label(model.GetTitle()), RooFit.Layout(0.45, 0.95, 0.94), RooFit.Format("NEAU")) graphData = dataset.plotOn( frame, RooFit.Binning(binning), RooFit.DataError(RooAbsData.Poisson if isData else RooAbsData.SumW2), RooFit.DrawOption("PE0"), RooFit.Name(dataset.GetName())) fixData(graphData.getHist(), True, True, not isData) pulls = frame.pullHist(dataset.GetName(), model.GetName(), True) residuals = frame.residHist(dataset.GetName(), model.GetName(), False, True) # this is y_i - f(x_i) roochi2 = frame.chiSquare( ) #dataset.GetName(), model.GetName()) #model.GetName(), dataset.GetName() frame.SetMaximum(frame.GetMaximum() * 10) frame.SetMinimum(max(frame.GetMinimum(), 1.e-2)) c.GetPad(1).SetLogy() frame.Draw() drawAnalysis(category) drawRegion(category, True) #drawCMS(LUMI, "Simulation Preliminary") drawCMS(LUMI, "Work in Progress", suppressCMS=True) c.cd(2) frame_res = variable.frame() setPadStyle(frame_res, 1.25) frame_res.addPlotable(pulls, "P") setBotStyle(frame_res, RATIO, False) frame_res.GetYaxis().SetRangeUser(-5, 5) frame_res.GetYaxis().SetTitle("pulls(#sigma)") frame_res.GetYaxis().SetTitleOffset(0.4) frame_res.Draw() fixData(pulls, False, True, False) # calculate RSS nbins, res, rss, chi1, chi2 = 0, 0., 0., 0., 0. hist = graphData.getHist() xmin, xmax = array('d', [0.]), array('d', [0.]) dataset.getRange(variable, xmin, xmax) #print "hist.GetN() =", hist.GetN() for i in range(0, hist.GetN()): if hist.GetX()[i] - hist.GetErrorXlow(i) > xmax[0] and hist.GetX( )[i] + hist.GetErrorXhigh(i) > xmax[0]: continue # and abs(pulls.GetY()[i]) < 5: if hist.GetY()[i] <= 0.: continue #print "i =", i #print "residuals.GetY() =", residuals.GetY() #print "residuals.GetY()[i] =", residuals.GetY()[i] res += residuals.GetY()[i] rss += residuals.GetY()[i]**2 #print i, pulls.GetY()[i] chi1 += abs(pulls.GetY()[i]) chi2 += pulls.GetY()[i]**2 nbins = nbins + 1 #data = hist.GetY()[i] #bkg = norm * (model.createIntegral(varArg, RooFit.NormSet(varArg), RooFit.Range(bins[i], bins[i+1]))).getVal() / (bins[i+1] - bins[i]) #bkg2 = model.Eval( (bins[i+1] - bins[i])/2. ) #print i, bins[i], bins[i+1], data, bkg#, bkg2 rss = math.sqrt(rss) out = { "chi2": chi2, "chi1": chi1, "rss": rss, "res": res, "nbins": nbins, "npar": npar } drawChi2(chi2, binning.numBins() - npar) line = drawLine(variable.getMin(), 0, variable.getMax(), 0) if len(name) > 0 and len(category) > 0: c.SaveAs(PLOTDIR + "/" + name + "_" + category + ".pdf") c.SaveAs(PLOTDIR + "/" + name + "_" + category + ".png") # if( hMassNEW.GetXaxis().GetBinLowEdge(bin+1)>=fFitXmin and hMassNEW.GetXaxis().GetBinUpEdge(bin-1)<=fFitXmax ): # NumberOfVarBins += 1 # data = hMassNEW.GetBinContent(bin) # # data = g.Integral(hMassNEW.GetXaxis().GetBinLowEdge(bin) , hMassNEW.GetXaxis().GetBinUpEdge(bin) ) # err_data_low = g.GetErrorYlow(bin-1) # err_data_high= g.GetErrorYhigh(bin-1) # fit = BKGfit.Integral(hMassNEW.GetXaxis().GetBinLowEdge(bin) , hMassNEW.GetXaxis().GetBinUpEdge(bin) ) # fit = fit / ( hMassNEW.GetBinWidth(bin) ) # # fit = BKGfit.Eval(hMassNEW.GetBinCenter(bin)) #yields same results # if(fit > data): # err_tot = err_data_high # else: # err_tot = err_data_low # fit_residual = (data - fit) / err_tot # err_fit_residual = 1 # # if (hMassNEW.GetBinContent(bin)>0): # NumberOfObservations_VarBin+=1 # chi2_VarBin += pow( (data - fit) , 2 ) / pow( err_tot , 2 ) #chi2_VarBin_notNorm += pow( (data - fit) , 2 ) #print " Integral:", integral, "-", norm #print " RSS:", rss #print " Chi2:", chi2, " - ", roochi2 return out
def FitMassPoint(massin, massmin, massmax, nbins=50): # massin = 800; # massmin = 400; # massmax = 1400; # nbins = 50; # massin = 600; # massmin = 200; # massmax = 1000; # nbins = 40; inputFile = ROOT.TFile( "/uscms_data/d2/andersj/Wjj/2012/data/Moriond2013/ReducedTrees/RD_mu_HWWMH" + str(massin) + "_CMSSW532_private.root") tree = inputFile.Get("WJet") # tree.Print(); print "n entries: ", tree.GetEntries() ############################################################ # RooFitting rrv_mass = ROOT.RooRealVar("rrv_mass", "rrv_mass", massmin, massmax) rrv_weight = RooRealVar("rrv_weight", "rrv_weight", 0., 10000000.) rrv_mH = ROOT.RooRealVar("rrv_mH", "rrv_mH", massin, massmin, massmax) rrv_gamma = ROOT.RooRealVar("rrv_gamma", "rrv_gamma", 20., massmax) rrv_mH2 = ROOT.RooRealVar("rrv_mH2", "rrv_mH2", massin, massmin, massmax) rrv_gamma2 = ROOT.RooRealVar("rrv_gamma2", "rrv_gamma2", 20., massmax) # rrv_gamma2 = ROOT.RooRealVar("rrv_gamma2","rrv_gamma2",350.,600.) rrv_mH3 = ROOT.RooRealVar("rrv_mH3", "rrv_mH3", massin, massmin, massmax) rrv_gamma3 = ROOT.RooRealVar("rrv_gamma3", "rrv_gamma3", 20., massmax) rrv_mH4 = ROOT.RooRealVar("rrv_mH4", "rrv_mH4", massin, massmin, massmax) rrv_gamma4 = ROOT.RooRealVar("rrv_gamma4", "rrv_gamma4", 20., massmax) rds_raw = ROOT.RooDataSet("rds_raw", "rds_raw", RooArgSet(rrv_mass, rrv_weight), RooFit.WeightVar(rrv_weight)) rds_cps = ROOT.RooDataSet("rds_cps", "rds_cps", RooArgSet(rrv_mass, rrv_weight), RooFit.WeightVar(rrv_weight)) rds_cps_intf = ROOT.RooDataSet("rds_cps_intf", "rds_cps_intf", RooArgSet(rrv_mass, rrv_weight), RooFit.WeightVar(rrv_weight)) model_pdf = ROOT.RooRelBWHighMass("model_pdf", "model_pdf", rrv_mass, rrv_mH, rrv_gamma) model2_pdf = ROOT.RooRelBWRunningWidth("model2_pdf", "model2_pdf", rrv_mass, rrv_mH2, rrv_gamma2) model3_pdf = ROOT.RooRelBWRunningWidth("model3_pdf", "model3_pdf", rrv_mass, rrv_mH3, rrv_gamma3) model4_pdf = ROOT.RooRelBWRunningWidth("model4_pdf", "model4_pdf", rrv_mass, rrv_mH4, rrv_gamma4) for i in range(tree.GetEntries()): if i % 10000 == 0: print "i: ", i tree.GetEntry(i) curmass = getattr(tree, "W_H_mass_gen") if curmass < massmax and curmass > massmin: rrv_mass.setVal(curmass) tmpweight_cps = getattr( tree, "complexpolewtggH" + str(massin)) / getattr( tree, "avecomplexpolewtggH" + str(massin)) tmpweight_cps_intf = getattr( tree, "complexpolewtggH" + str(massin)) * getattr( tree, "interferencewtggH" + str(massin)) / getattr( tree, "avecomplexpolewtggH" + str(massin)) rds_raw.add(RooArgSet(rrv_mass), 1.) rds_cps.add(RooArgSet(rrv_mass), tmpweight_cps) rds_cps_intf.add(RooArgSet(rrv_mass), tmpweight_cps_intf) ############################################################ rfresult = model_pdf.fitTo(rds_cps, RooFit.Save(1), RooFit.SumW2Error(kTRUE)) rfresult2 = model2_pdf.fitTo(rds_cps, RooFit.Save(1), RooFit.SumW2Error(kTRUE)) rrv_mH3.setVal(rrv_mH2.getVal()) rrv_gamma3.setVal(0.5 * rrv_gamma2.getVal()) rrv_mH4.setVal(rrv_mH2.getVal()) rrv_gamma4.setVal(0.2 * rrv_gamma2.getVal()) mplot = rrv_mass.frame(RooFit.Title("mass plot")) rds_raw.plotOn(mplot, RooFit.MarkerColor(kBlack), RooFit.LineColor(kBlack), RooFit.Binning(nbins, massmin, massmax), RooFit.DataError(RooAbsData.SumW2)) rds_cps_intf.plotOn(mplot, RooFit.MarkerColor(kBlue), RooFit.LineColor(kBlue), RooFit.Binning(nbins, massmin, massmax), RooFit.DataError(RooAbsData.SumW2)) rds_cps.plotOn(mplot, RooFit.MarkerColor(kRed), RooFit.LineColor(kRed), RooFit.Binning(nbins, massmin, massmax), RooFit.DataError(RooAbsData.SumW2)) # model_pdf.plotOn(mplot, RooFit.LineColor(kRed)); model2_pdf.plotOn(mplot, RooFit.LineColor(kRed), RooFit.LineStyle(2)) model3_pdf.plotOn(mplot, RooFit.LineColor(ROOT.kGreen + 2), RooFit.LineStyle(2)) model4_pdf.plotOn(mplot, RooFit.LineColor(ROOT.kGreen + 2), RooFit.LineStyle(3)) print "rds_cps_intf.sumEntries() = ", rds_cps_intf.sumEntries() print "model_pdf: mH = ", rrv_mH.getVal(), ", gamma = ", rrv_gamma.getVal( ) print "model2_pdf: mH = ", rrv_mH2.getVal( ), ", gamma = ", rrv_gamma2.getVal() dummy_h1 = ROOT.TH1F("dummy_h1", "dummy_h1", 1, 0, 1) dummy_h1.SetMarkerColor(ROOT.kBlack) dummy_h2 = ROOT.TH1F("dummy_h2", "dummy_h2", 1, 0, 1) dummy_h2.SetMarkerColor(ROOT.kRed) dummy_h3 = ROOT.TH1F("dummy_h3", "dummy_h3", 1, 0, 1) dummy_h3.SetMarkerColor(ROOT.kBlue) dummy_h4 = ROOT.TH1F("dummy_h4", "dummy_h4", 1, 0, 1) dummy_h4.SetLineColor(ROOT.kRed) dummy_h5 = ROOT.TH1F("dummy_h5", "dummy_h5", 1, 0, 1) dummy_h5.SetLineColor(ROOT.kRed) dummy_h5.SetLineStyle(2) dummy_h6 = ROOT.TH1F("dummy_h6", "dummy_h6", 1, 0, 1) dummy_h6.SetLineColor(ROOT.kGreen + 2) dummy_h6.SetLineStyle(2) dummy_h7 = ROOT.TH1F("dummy_h7", "dummy_h7", 1, 0, 1) dummy_h7.SetLineColor(ROOT.kGreen + 2) dummy_h6.SetLineStyle(3) L = TLegend(0.65, 0.60, 0.93, 0.85) L.SetFillStyle(0) L.AddEntry(dummy_h1, "Powheg", "p") L.AddEntry(dummy_h2, "w/CPS weight", "p") L.AddEntry(dummy_h3, "w/CPS,Intf weight", "p") # L.AddEntry(dummy_h4,"Fit, BW (Mario)","l"); L.AddEntry(dummy_h5, "Fit, BW (running)", "l") L.AddEntry(dummy_h6, "BW (running), width*0.5", "l") L.AddEntry(dummy_h7, "Fit, BW (running), width*0.2", "l") can2 = ROOT.TCanvas("can2", "can2", 800, 800) mplot.Draw() L.Draw() ROOT.gPad.SetLogy() can2.SaveAs("massFits/mass_rf_" + str(massin) + ".eps") can2.SaveAs("massFits/mass_rf_" + str(massin) + ".png") outputpar = [] outputpar.append(rrv_mH2.getVal()) outputpar.append(rrv_gamma2.getVal()) outputpar.append(rrv_mH.getVal()) outputpar.append(rrv_gamma.getVal()) return outputpar
def fitMC(fulldata, correctTag, ibin): print 'now fitting: ', ibin, ' for ', correctTag * 'correctTag ', ( 1 - correctTag) * 'wrongTag' cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)' % ( q2binning[ibin], q2binning[ibin + 1]) data = fulldata.reduce(RooArgSet(thevarsMC), cut) pol_c1 = RooRealVar("p1", "coeff x^0 term", -0.5, -10, 10) bkg_pol = RooChebychev("bkg_pol", "bkg_pol", tagged_mass, RooArgList(pol_c1)) signalFunction = bkg_pol ### just a placeholder nsig = RooRealVar("Yield", "nsig", 10000, 0, 1000000) nbkg = RooRealVar("nbkg", "nbkg", 10, 0, 100000) doextended = False fitrange = "mcrange" nbins = 70 if correctTag: doubleG(B0Mass_, initial_sigma1, initial_sigma2, 0.8, tagged_mass, w, "RT%s" % ibin) ## (mean_ , sigma1_, sigma2_, f1_) signalFunction = w.pdf("doublegaus_RT%s" % ibin) fitFunction = RooAddPdf("fitfunction", "fit function", RooArgList(signalFunction, bkg_pol), RooArgList(nsig, nbkg)) doextended = True fitrange = "full" nbins = 60 else: mean = RooRealVar("mean^{WT%s}" % ibin, "massWT", B0Mass_, 5, 6, "GeV") sigmaCB = RooRealVar("#sigma_{CB}^{WT%s}" % ibin, "sigmaCB", 0.03, 0, 1) alpha1 = RooRealVar("#alpha_{1}^{WT%s}" % ibin, "#alpha_{1}", 0.5, 0, 10) alpha2 = RooRealVar("#alpha_{2}^{WT%s}" % ibin, "#alpha_{2}", 0.5, 0, 10) n1 = RooRealVar("n_{1}^{WT%s}" % ibin, "n_1", 2, 0, 90) n2 = RooRealVar("n_{2}^{WT%s}" % ibin, "n_2", 1, 0, 90) doublecb = ROOT.RooDoubleCBFast("doublecb_%s" % ibin, "doublecb", tagged_mass, mean, sigmaCB, alpha1, n1, alpha2, n2) # getattr(w, 'import')(doublecb) signalFunction = doublecb fitFunction = doublecb getattr(w, "import")(signalFunction) r = fitFunction.fitTo(data, RooFit.Extended(doextended), RooFit.Save(), RooFit.Range(fitrange)) print 'fit status: ', r.status(), r.covQual() if not _goodFit(r): r = fitFunction.fitTo(data, RooFit.Extended(doextended), RooFit.Save(), RooFit.Range(fitrange)) print 'fit status (redo): ', r.status(), r.covQual() if not _goodFit(r) and correctTag: r = fitFunction.fitTo(data, RooFit.Extended(doextended), RooFit.Save(), RooFit.Range(fitrange)) print 'fit status (redo2): ', r.status(), r.covQual() params = signalFunction.getParameters(RooArgSet(tagged_mass)) w.saveSnapshot( "reference_fit_%s_%s" % ('RT' * correctTag + 'WT' * (1 - correctTag), ibin), params, ROOT.kTRUE) frame = tagged_mass.frame(RooFit.Range(fitrange)) data.plotOn(frame, RooFit.Binning(nbins), RooFit.MarkerSize(.7)) drawPdfComponents(fitFunction, frame, ROOT.kGreen if correctTag else ROOT.kViolet, RooFit.NormRange(fitrange), RooFit.Range(fitrange), isData=False) fitFunction.plotOn(frame, RooFit.NormRange(fitrange), RooFit.Range(fitrange)) fitFunction.paramOn(frame, RooFit.Layout(0.62, 0.86, 0.88)) frame.Draw() niceFrame(frame, '') frame.addObject(_writeFitStatus(r)) ## evaluate sort of chi2 and save number of RT/WT events observables = RooArgSet(tagged_mass) flparams = fitFunction.getParameters(observables) nparam = int(flparams.selectByAttrib("Constant", ROOT.kFALSE).getSize()) if correctTag: frame.addObject( _writeChi2( frame.chiSquare( "fitfunction_Norm[tagged_mass]_Range[full]_NormRange[full]", "h_fullmc", nparam))) dict_s_rt[ibin] = _getFittedVar(nsig) nRT = RooRealVar("nRT_%s" % ibin, "yield of RT signal", 0, 1.E6) nRT.setVal(dict_s_rt[ibin].n) nRT.setError(dict_s_rt[ibin].s) getattr(w, "import")(nRT) else: frame.addObject( _writeChi2( frame.chiSquare( "doublecb_%s_Norm[tagged_mass]_Comp[doublecb_%s]_Range[mcrange]_NormRange[mcrange]" % (ibin, ibin), "h_fullmc", nparam))) dict_s_wt[ibin] = ufloat(data.sumEntries(), math.sqrt(data.sumEntries())) nWT = RooRealVar("nWT_%s" % ibin, "yield of WT signal", 0, 1.E6) nWT.setVal(dict_s_wt[ibin].n) nWT.setError(dict_s_wt[ibin].s) getattr(w, "import")(nWT) # chi2 = frame.chiSquare("doublecb_%s_Norm[tagged_mass]_Comp[doublecb_%s]_Range[mcrange]_NormRange[mcrange]"%(ibin,ibin), "h_fullmc", nparam) # if chi2 == -1: # chi2 = frame.chiSquare("gauscb_%s_Norm[tagged_mass]_Comp[gauscb_%s]_Range[mcrange]_NormRange[mcrange]"%(ibin,ibin), "h_fullmc", nparam) # frame. addObject(_writeChi2( chi2 ) ) frame.Draw() frame.SetTitle('correctly' * correctTag + 'wrongly' * (1 - correctTag) + ' tagged events') # c1.SetLogy() c1.SaveAs('fit_results_mass/save_fit_mc_%s_%s_%sT_newCB.pdf' % (ibin, args.year, "R" * correctTag + "W" * (1 - correctTag))) out_f.cd() r.Write('results_%s_%s' % (correctTag * 'RT' + (1 - correctTag) * 'WT', ibin))
def total_fit(tree, outputfile, branches, sgn_parameters=None, kjpsi_pdf=None, kstaree_pdf=None, bkg_parameters=None, set_sgn_yield=None, Blind_range={ "min": 4.7, "max": 5.7 }, number_of_mctoys=None, mva=None, log='log.csv'): wspace, dataset, bMass, theBMass = define_workspace_bmass_data( "wspace_total", branches[0], tree) print "Total" #amplitudes wspace.factory('nsig[10.0, 0.0, 1000000.0]') wspace.factory('nbkg[100.0, 0.0, 100000000.0]') wspace.factory('nkjpsi[10.0, 0.0, 1000000.0]') wspace.factory('nkstaree[10.0, 0.0, 1000000.0]') # signal wspace.factory('mean[5.272e+00, 5.22e+00, 5.5e+00]') wspace.factory('width[4.1858e-02, 1.0e-6, 5.0e-1]') wspace.factory('alpha1[1.0, 0.0, 10.0]') wspace.factory('n1[1.0, 1.0, 20.0]') wspace.factory('alpha2[1.0, 0.0, 10.0]') wspace.factory('n2[1.0, 1.0, 20.0]') wspace.factory( 'GenericPdf::sig( "DoubleSidedCB2(x,mean,width,alpha1,n1,alpha2,n2)",{x,mean,width,alpha1,n1,alpha2,n2})' ) # Exponential - bkg wspace.factory('exp_alpha[-1.0, -100.0, -1.e-4]') alpha = wspace.var('alpha') wspace.factory('Exponential::bkg(x,exp_alpha)') # Gaussian - bkg #wspace.factory('mean_kjpsi[4.7, 1.0, 5.0]') #wspace.factory('width_kjpsi[0.1, 0.001, 5.0]') #wspace.factory("RooGaussian::kjpsi(x,mean_kjpsi,width_kjpsi)") # KJpsi - bkg getattr(wspace, "import")(kjpsi_pdf, RooFit.Rename('kjpsi')) # K* ee - bkg getattr(wspace, "import")(kstaree_pdf, RooFit.Rename('kstaree')) #sum #wspace.factory('SUM::model(nsig*sig,nbkg*bkg,nkjpsi*kjpsi,nkstaree*kstaree)') wspace.factory('SUM::model(nsig*sig,nbkg*bkg,nkjpsi*kjpsi)') model = wspace.pdf('model') bkg = wspace.pdf('bkg') sig = wspace.pdf('sig') kjpsi = wspace.pdf('kjpsi') nsig = wspace.var('nsig') nbkg = wspace.var('nbkg') nkjpsi = wspace.var('nkjpsi') #mean = wspace.var('mean') nkstaree = wspace.var('nkstaree') kstaree = wspace.pdf('kstaree') if set_sgn_yield != None: nsig.setVal(set_sgn_yield) nsig.setConstant(True) for par in sgn_parameters.keys(): (wspace.var(par)).setVal(sgn_parameters[par]) (wspace.var(par)).setConstant(True) #for par in kjpsi_parameters.keys(): # (wspace.var(par)).setVal(kjpsi_parameters[par]) # (wspace.var(par)).setConstant(True) for par in bkg_parameters.keys(): (wspace.var(par)).setVal(bkg_parameters[par]) results = model.fitTo(dataset, RooFit.Extended(True), RooFit.Save(), RooFit.Range(4.7, 5.7), RooFit.PrintLevel(-1)) print results.Print() xframe = theBMass.frame(RooFit.Title("")) if Blind_range["min"] > 4.7 and Blind_range["max"] < 5.7: norm = dataset.reduce( '(({0} > {1}) & ({0} < {2})) | (({0}> {3}) & ({0} < {4}))'.format( branches[0], "4.7", str(Blind_range["min"]), str(Blind_range["max"]), "5.7")).sumEntries() / dataset.reduce( '({0} > {1}) & ({0} < {2})'.format(branches[0], "4.7", "5.7")).sumEntries() # blind= ROOT.RooRealVar("blind","blind",Blind_range["min"],Blind_range["max"]) # blind.setRange("left",4.7,Blind_range["min"]) # blind.setRange("right",Blind_range["max"],5.7) theBMass.setRange("left", 4.7, Blind_range["min"]) theBMass.setRange("right", Blind_range["max"], 5.7) norm = 1.0 dataset.plotOn(xframe, RooFit.Binning(nbin_data), RooFit.Name("datas"), RooFit.CutRange("left,right")) else: norm = 1. dataset.plotOn(xframe, RooFit.Binning(nbin_data), RooFit.Name("datas")) #norm=1. #dataset.plotOn(xframe,RooFit.Binning(nbin_data), RooFit.Name("datas")) model.plotOn(xframe, RooFit.Name("bkg"), RooFit.Components("bkg"), RooFit.Range("Full"), RooFit.DrawOption("L"), RooFit.VLines(), RooFit.FillColor(49), RooFit.LineColor(49), RooFit.LineStyle(2), RooFit.Normalization(norm, ROOT.RooAbsReal.RelativeExpected), RooFit.LineWidth(3)) model.plotOn(xframe, RooFit.Name("kjpsi"), RooFit.Components("kjpsi"), RooFit.Range("Full"), RooFit.FillColor(30), RooFit.LineColor(30), RooFit.Normalization(norm, ROOT.RooAbsReal.RelativeExpected), RooFit.LineStyle(2), RooFit.LineWidth(3), RooFit.DrawOption("L"), RooFit.MoveToBack()) #model.plotOn(xframe,RooFit.Name("kstaree"),RooFit.Components("kstaree"),RooFit.Range("Full"),RooFit.FillColor(30),RooFit.LineColor(12),RooFit.Normalization(norm, ROOT.RooAbsReal.RelativeExpected),RooFit.LineStyle(2), RooFit.LineWidth(3),RooFit.DrawOption("L"),RooFit.MoveToBack()) model.plotOn(xframe, RooFit.Name("sig"), RooFit.Components("sig"), RooFit.Range("Full"), RooFit.DrawOption("L"), RooFit.LineStyle(2), RooFit.LineColor(ROOT.kBlue), RooFit.Normalization(norm, ROOT.RooAbsReal.RelativeExpected), RooFit.LineWidth(3)) model.plotOn(xframe, RooFit.Normalization(norm, ROOT.RooAbsReal.RelativeExpected), RooFit.LineColor(ROOT.kRed)) wspace.defineSet('obs', 'x') obs = wspace.set('obs') theBMass.setRange("window", Blind_range["min"], Blind_range["max"]) #theBMass.setRange("window",5.0,5.4) obs2 = ROOT.RooRealVar("obs2", "obs2", Blind_range["min"], Blind_range["max"]) nset = ROOT.RooArgSet(obs2) print sig.getVal(), sig.getVal(nset) print Blind_range print nbkg.getVal(), nkjpsi.getVal(), nsig.getVal() nbkg_visible, nbkg_visible_err = get_visible_yield_error( obs, results, bkg, nbkg) nsig_visible, nsig_visible_err = get_visible_yield_error( obs, results, sig, nsig) nkjpsi_visible, nkjpsi_visible_err = get_visible_yield_error( obs, results, kjpsi, nkjpsi) print "hereee", nbkg_visible, nsig_visible, nkjpsi_visible # c1=canvas_create(xframe,4.7,5.7,nbin_data,'m(e^{+}e^{-}K) [GeV]') n_param = results.floatParsFinal().getSize() print "chi2", xframe.chiSquare(n_param), "ndof", n_param print "edm", results.edm(), "log", results.minNll() #c1=canvas_create(xframe,4.7,5.7,nbin_data,'m(e^{+}e^{-}K) [GeV]') c1, top, bottom = canvas_create_pull(xframe, 4.7, 5.7, nbin_data, 'm(e^{+}e^{-}K) [GeV]', theBMass) top.cd() legend = ROOT.TLegend(0.65, 0.65, 0.92, 0.85) legend.AddEntry(xframe.findObject("bkg"), "Combinatorial", "l") legend.AddEntry(xframe.findObject("kjpsi"), "B -> J/#psiK", "l") #legend.AddEntry(xframe.findObject("kstaree"),"B -> eeK*","l"); legend.AddEntry(xframe.findObject("sig"), "B -> eeK", "l") legend.SetLineColor(ROOT.kWhite) legend.SetTextFont(42) legend.SetTextSize(0.04) legend.AddEntry(xframe.findObject("datas"), "Data", "lpe") legend.Draw() pt = pt_create(mva, nsig_visible, nsig_visible_err, nkjpsi_visible + nbkg_visible) pt.Draw() CMS_lumi() c1.cd() c1.Update() c1.SaveAs('total_fit_' + outputfile + '.pdf') print nsig_visible, nsig_visible_err, nbkg_visible_err, nkjpsi_visible_err residuals(xframe, theBMass, outputfile + "_poutana") if number_of_mctoys != None: nsig.setConstant(False) mctoys = ROOT.RooMCStudy( model, ROOT.RooArgSet(theBMass), RooFit.Binned(ROOT.kTRUE), #RooFit.Binned( ROOT.kFALSE), ROOT.RooFit.Silence(), RooFit.Extended(), RooFit.FitOptions(RooFit.Save(), RooFit.Range(4.7, 5.7), RooFit.PrintLevel(-1))) mctoys.generateAndFit(number_of_mctoys) frame1 = mctoys.plotParam(nsig, ROOT.RooFit.Bins(40)) frame2 = mctoys.plotError(nsig, ROOT.RooFit.Bins(40)) frame3 = mctoys.plotPull(nsig, ROOT.RooFit.Bins(40), ROOT.RooFit.FitGauss(ROOT.kTRUE)) # Plot distribution of minimized likelihood frame4 = mctoys.plotNLL(ROOT.RooFit.Bins(40)) cpr = canvas_create(frame1, 4.7, 5.7, 1, 'Distribution of the fitted value of N_{sgn}', False) cpr.SaveAs("cpr_" + outputfile + ".pdf") cerr = canvas_create(frame2, 0, 1, 1, 'Distribution of the fitted error of N_{sgn}', False) cerr.SaveAs("cerr_" + outputfile + ".pdf") cpull = canvas_create(frame3, 4.7, 5.7, 1, ' Pull of N_{sgn}', False) cpull.SaveAs("cpull_" + outputfile + ".pdf") clog = canvas_create(frame4, 4.7, 5.7, 1, '- log (L)') clog.SaveAs("clog_" + outputfile + ".pdf") postfit_data = mctoys.fitParDataSet() postfit_nsig = np.array([ postfit_data.get(i).getRealValue("nsig") for i in range(int(postfit_data.sumEntries())) ]) #postfit_nsig = np.array([get_visible_yield(obs, sig, postfit_data.get(i).getRealValue("nsig")) for i in range(int(postfit_data.sumEntries()))]) #postfit_mu = np.array([s/nsig_visible for s in postfit_nsig]) postfit_mu = np.array([s / set_sgn_yield for s in postfit_nsig]) rms_mu = np.std(postfit_mu) fig, ax = plt.subplots() ax.hist(postfit_mu, bins=50, normed=True, histtype='step', label='MVA={}, RMS={}'.format(mva, rms_mu)) ax.set_xlabel(r'$\mu$') ax.set_ylabel('a.u.') ax.legend(loc='best') fig.savefig('cmu_{}.pdf'.format(outputfile), bbox_inches='tight') csv_header = ['cut', 'nsig', 'nbkg', 'njpsi', 'snr', 'rms_mu'] df = {} df['cut'] = mva df['nsig'] = nsig_visible df['nbkg'] = nbkg_visible df['njpsi'] = nkjpsi_visible df['snr'] = nsig_visible / np.sqrt(nsig_visible + nbkg_visible + nkjpsi_visible) df['rms_mu'] = 0.0 if number_of_mctoys == None else rms_mu_ csv_outputfile = log file_exists = os.path.isfile(csv_outputfile) with open(csv_outputfile, 'a+') as filedata: writer = csv.DictWriter(filedata, delimiter=',', fieldnames=csv_header) if not file_exists: writer.writeheader() writer.writerow(df) return (nsig_visible, nbkg_visible, nkjpsi_visible)
def morph(hist1, hist2, mass1, mass2, targetMass, debug=False): from ROOT import gROOT, RooRealVar, RooIntegralMorph,\ kRed,kBlue,kViolet, RooDataHist, RooArgSet,\ RooArgList, RooHistPdf, RooAbsReal, RooFit import re if mass1 < mass2: histLow = hist1 massLow = mass1 histHigh = hist2 massHigh = mass2 else: histLow = hist2 massLow = mass2 histHigh = hist1 massHigh = mass1 x = RooRealVar("x", "x", histLow.GetXaxis().GetXmin(), histLow.GetXaxis().GetXmax()) mAlpha = 1.0 - float(targetMass - massLow) / float(massHigh - massLow) print 'alpha:', mAlpha, newIntegral = histLow.Integral() + \ (targetMass - massLow) * \ (histHigh.Integral()-histLow.Integral()) / \ (massHigh-massLow) print 'low integral:', histLow.Integral(), \ 'high integral:', histHigh.Integral(), \ 'new integral:', newIntegral newHistLow = RooDataHist("sigHistLow_hist", "sigHistLow_hist", RooArgList(x), histLow) sigHistLow = RooHistPdf("sigHistLow", "sigHistLow", RooArgList(x), RooArgList(x), newHistLow) newHistHigh = RooDataHist("sigHistHigh_hist", "sigHistHigh_hist", RooArgList(x), histHigh) sigHistHigh = RooHistPdf("sigHistHigh", "sigHistHigh", RooArgList(x), RooArgList(x), newHistHigh) #x.Print("v") x.setBins(histLow.GetNbinsX(), "cache") alpha_morph = RooRealVar("alpha_morph", "#alpha_{morph}", mAlpha, 0., 1.) alpha_morph.setBins(10, "cache") sigModel = RooIntegralMorph("sigModel", "sigModel", sigHistLow, sigHistHigh, x, alpha_morph) if (debug): from ROOT import gPad, RooFit frame = x.frame() sigHistLow.plotOn(frame, RooFit.LineColor(kRed + 1), RooFit.LineStyle(2)) sigHistHigh.plotOn(frame, RooFit.LineColor(kBlue + 1), RooFit.LineStyle(2)) sigModel.plotOn(frame, RooFit.LineColor(kViolet + 1), RooFit.LineStyle(9)) frame.Draw() gPad.Update() gPad.WaitPrimitive() morphHist = sigModel.createHistogram( re.sub(r'\d+', '%i' % targetMass, hist1.GetName()), x, RooFit.Binning(histLow.GetNbinsX())) morphHist.Scale(newIntegral / morphHist.Integral()) morphHist.SetName(re.sub(r'\d+', '%i' % targetMass, hist1.GetName())) # if debug: # morphHist.Print() return morphHist
def fitData(fulldata, ibin, w): cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)'%(q2binning[ibin], q2binning[ibin+1]) data = fulldata.reduce(RooArgSet(tagged_mass,mumuMass,mumuMassE), cut) nrt_mc = _getFittedVar("nRT_%s"%ibin, w) nwt_mc = _getFittedVar("nWT_%s"%ibin, w) fraction = nrt_mc / (nrt_mc + nwt_mc) print 'mistag fraction on MC for bin ', ibin , ' : ' , fraction.n , '+/-', fraction.s ### creating RT component w.loadSnapshot("reference_fit_RT_%s"%ibin) mean_rt = w.var("mean^{RT%s}"%ibin) sigma_rt1 = w.var("#sigma_{RT1}^{%s}"%ibin) sigma_rt2 = RooRealVar() alpha_rt1 = RooRealVar() alpha_rt2 = RooRealVar() n_rt1 = RooRealVar() n_rt2 = RooRealVar() f1rt = RooRealVar() ## double cb fast if ibin < 4: alpha_rt1 = w.var("#alpha_{RT1}^{%s}"%ibin) alpha_rt2 = w.var("#alpha_{RT2}^{%s}"%ibin) n_rt1 = w.var("n_{RT1}^{%s}"%ibin) n_rt2 = w.var("n_{RT2}^{%s}"%ibin) ## double cb old else: sigma_rt2 = w.var("#sigma_{RT2}^{%s}"%ibin) alpha_rt1 = w.var("#alpha_{RT1}^{%s}"%ibin) alpha_rt2 = w.var("#alpha_{RT2}^{%s}"%ibin) n_rt1 = w.var("n_{RT1}^{%s}"%ibin) n_rt2 = w.var("n_{RT2}^{%s}"%ibin) f1rt = w.var("f^{RT%s}"%ibin) theRTgauss = w.pdf("doublecb_RT%s"%ibin) ### creating WT component w.loadSnapshot("reference_fit_WT_%s"%ibin) mean_wt = w.var("mean_{WT}^{%s}"%ibin) sigma_wt = w.var("#sigma_{WT1}^{%s}"%ibin) alpha_wt1 = w.var("#alpha_{WT1}^{%s}"%ibin) alpha_wt2 = w.var("#alpha_{WT2}^{%s}"%ibin) n_wt1 = w.var("n_{WT1}^{%s}"%ibin) n_wt2 = w.var("n_{WT2}^{%s}"%ibin) theWTgauss = w.pdf("doublecb_%s"%ibin) ### creating variable for the difference between the two peaks deltaPeaks = RooFormulaVar("deltaPeaks%s"%ibin, "@0 - @1", RooArgList(mean_rt, mean_wt)) frt = RooRealVar ("F_{RT}%s"%ibin , "frt" , fraction.n , 0, 1) signalFunction = RooAddPdf ("sumgaus%s"%ibin , "rt+wt" , RooArgList(theRTgauss,theWTgauss), RooArgList(frt)) ### now create background parametrization slope = RooRealVar ("slope_%s"%ibin , "slope" , 0.5, -10, 10); bkg_exp = RooExponential("bkg_exp%s"%ibin , "exponential" , slope, tagged_mass ); pol_c1 = RooRealVar ("p1_%s"%ibin , "coeff x^0 term" , 0.5, -10, 10); pol_c2 = RooRealVar ("p2_%s"%ibin , "coeff x^1 term" , 0.5, -10, 10); bkg_pol = RooPolynomial ("bkg_pol%s"%ibin , "2nd order pol" , tagged_mass, RooArgList(pol_c1, pol_c2)); fsig = RooRealVar("fsig%s"%ibin , "fsig" , 0.9, 0, 1); # nsig = RooRealVar("Yield%s"%ibin , "signal frac" , 1000, 0, 10000); # nbkg = RooRealVar("nbkg%s"%ibin , "bkg fraction" , 1000, 0, 500000); nsig = RooRealVar("Yield" , "signal frac" , 600000, 0, 5000000); nbkg = RooRealVar("nbkg" , "bkg fraction" , 100000, 0, 2000000); # if ibin==4: # nsig.setRange(500000,1500000) # nsig.setVal(900000) # nbkg.setRange(80000,1000000) # nbkg.setVal(100000) ### creating constraints c_vars = RooArgSet() c_pdfs = RooArgSet() c_sigma_rt1 = _constrainVar(sigma_rt1, 1) c_alpha_rt1 = _constrainVar(alpha_rt1, 1) c_alpha_rt2 = _constrainVar(alpha_rt2, 1) c_n_rt1 = _constrainVar(n_rt1, 1) c_n_rt2 = _constrainVar(n_rt2, 1) c_sigma_wt = _constrainVar(sigma_wt, 1) c_alpha_wt1 = _constrainVar(alpha_wt1, 1) c_alpha_wt2 = _constrainVar(alpha_wt2, 1) c_n_wt1 = _constrainVar(n_wt1, 1) c_n_wt2 = _constrainVar(n_wt2, 1) if ibin < 4: c_pdfs = RooArgSet(c_sigma_rt1, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) c_vars = RooArgSet(sigma_rt1, alpha_rt1, alpha_rt2, n_rt1, n_rt2) else: c_sigma_rt2 = _constrainVar(sigma_rt2, 1) c_pdfs = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) c_vars = RooArgSet( sigma_rt1, sigma_rt2, alpha_rt1, alpha_rt2, n_rt1, n_rt2) c_pdfs.add(c_sigma_wt); c_vars.add(sigma_wt) c_pdfs.add(c_alpha_wt1); c_vars.add(alpha_wt1) c_pdfs.add(c_alpha_wt2); c_vars.add(alpha_wt2) c_pdfs.add(c_n_wt1); c_vars.add(n_wt1) c_pdfs.add(c_n_wt2); c_vars.add(n_wt2) c_deltaPeaks = RooGaussian("c_deltaPeaks%s"%ibin , "c_deltaPeaks", deltaPeaks, ROOT.RooFit.RooConst( deltaPeaks.getVal() ), ROOT.RooFit.RooConst( 0.0005 ) ## value to be checked ) c_pdfs.add(c_deltaPeaks) c_vars.add(deltaPeaks) c_frt = RooGaussian("c_frt%s"%ibin , "c_frt" , frt, ROOT.RooFit.RooConst(fraction.n) , ROOT.RooFit.RooConst(frt_sigma[ibin]) ) c_pdfs.add(c_frt) c_vars.add(frt) constr_list = RooArgList(c_pdfs) constr_list.add(signalFunction) c_signalFunction = RooProdPdf ("c_signalFunction", "c_signalFunction", constr_list) # mean = RooRealVar ("mass" , "mean" , B0Mass_, 3, 7, "GeV") # sigma = RooRealVar ("#sigma_{1}" , "sigma" , 0.028, 0, 10, "GeV") # signalGauss = RooGaussian("signalGauss" , "signal gauss" , tagged_mass, mean,sigma) # # sigma2 = RooRealVar ("#sigma_{2}" , "sigma2" , 0.048, 0, 0.07, "GeV") # signalGauss2 = RooGaussian("signalGauss2" , "signal gauss2" , tagged_mass, mean,sigma2) # f1 = RooRealVar ("f1" , "f1" , 0.8 , 0., 1.) # gaus = RooAddPdf ("gaus" , "gaus1+gaus2" , RooArgList(signalGauss,signalGauss2), RooArgList(f1)) # pol_c1 = RooRealVar ("p1" , "coeff x^0 term", 0.5, -10, 10); # pol_c2 = RooRealVar ("p2" , "coeff x^1 term", 0.5, -10, 10); # pol_c3 = RooRealVar ("p3" , "coeff x^2 term", 0.5, -10, 10); # slope = RooRealVar ("slope" , "slope" , 0.5, -10, 10); # bkg_exp = RooExponential("bkg_exp" , "exponential" , slope, tagged_mass ); # bkg_pol = RooChebychev("bkg_pol" , "2nd order pol" , tagged_mass, RooArgList(pol_c1,pol_c2)); fitFunction = RooAddPdf ("fitfunction%s"%ibin , "fit function" , RooArgList(c_signalFunction, bkg_exp), RooArgList(nsig, nbkg)) # r = fitFunction.fitTo(data, # # RooFit.Extended(True), # RooFit.Range("full"), # ROOT.RooFit.Constrain(c_vars), # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), # ROOT.RooFit.Strategy(2), # ROOT.RooFit.Minos(False), # ) print 'fit with Hesse strategy 2 done, now Minos' r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range("full"), RooFit.Verbose(False), ROOT.RooFit.Constrain(c_vars), # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), # ROOT.RooFit.Strategy(2), # ROOT.RooFit.Minos(False), ) r.Print() r.correlationMatrix().Print() fitStats['data%s'%(ibin)] = r.status() covStats['data%s'%(ibin)] = r.covQual() frame = tagged_mass.frame( RooFit.Range("full") ) data.plotOn(frame, RooFit.Binning(nbins), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame, RooFit.NormRange("full"), RooFit.Range("full")) ## evaluate sort of chi2 and save number of RT/WT events observables = RooArgSet(tagged_mass) flparams = fitFunction.getParameters(observables) nparam = int(flparams.selectByAttrib("Constant",ROOT.kFALSE).getSize()) pdfstring = "fitfunction%s_Norm[tagged_mass]_Range[full]_NormRange[full]"%ibin chi2s['data%s'%ibin] = frame.chiSquare(pdfstring, "h_fulldata", nparam) frame. addObject(_writeChi2( chi2s['data%s'%ibin] )) drawPdfComponents(fitFunction, frame, ROOT.kAzure, RooFit.NormRange("full"), RooFit.Range("full"), isData = True) # fitFunction.paramOn(frame, RooFit.Layout(0.62,0.86,0.89)) parList = RooArgSet (nsig, mean_rt, sigma_rt, alpha_rt1, alpha_rt2, n_rt1, n_rt2, mean_wt, sigma_wt) # parList.add(alphawt1) # parList.add(alphawt2) # parList.add(nwt1) # parList.add(nwt2) parList.add(frt) fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62,0.86,0.89)) frame.Draw() niceFrame(frame, '') frame. addObject(_writeFitStatus(r)) c1 = ROOT.TCanvas() upperPad = ROOT.TPad('upperPad' , 'upperPad' , 0., 0.35 , 1., 1. ) lowerPad = ROOT.TPad('lowerPad' , 'lowerPad' , 0., 0.0 , 1., 0.345 ) upperPad.SetBottomMargin(0.012) lowerPad.SetTopMargin(0) lowerPad.SetBottomMargin(0.2) upperPad.Draw(); lowerPad.Draw() upperPad.cd() frame.Draw() if not args.year=='test': writeCMS(frame, args.year, [ q2binning[ibin], q2binning[ibin+1] ], 0) frame.Draw() ## add plot of pulls lowerPad.cd() hpull = frame.pullHist("h_fulldata", pdfstring) frame2 = tagged_mass.frame(RooFit.Range("full"), RooFit.Title('')) frame2.addPlotable(hpull,"P") niceFrameLowerPad(frame2, 'pull') frame2.Draw() line = ROOT.TLine(5.0,1,5.6,1) line.SetLineColor(ROOT.kGreen+3) line.Draw() for ilog in [True,False]: upperPad.SetLogy(ilog) c1.SaveAs('fit_results_mass/save_fit_data_%s_%s_LMNR_Update%s_newSigmaFRT_pars_Jpsi.pdf'%(ibin, args.year, '_logScale'*ilog)) out_f.cd() r.Write('results_data_%s'%(ibin)) params = fitFunction.getParameters(RooArgSet(tagged_mass)) out_w.saveSnapshot("reference_fit_data_%s"%(ibin),params,ROOT.kTRUE) getattr(out_w, 'import')(fitFunction)
def fit_kde(tree, outputfile, isMC=True): #msgservice = ROOT.RooMsgService.instance() #msgservice.setGlobalKillBelow(RooFit.FATAL) wspace = ROOT.RooWorkspace('myPartialWorkSpace') ROOT.gStyle.SetOptFit(0000) #ROOT.gStyle.SetOptFit(1); ROOT.gROOT.SetBatch(True) ROOT.gROOT.SetStyle("Plain") ROOT.gStyle.SetGridStyle(3) ROOT.gStyle.SetOptStat(000000) ROOT.gStyle.SetOptTitle(0) xmin, xmax = 4.5, 6.0 bMass = ROOT.RooRealVar("BToKEE_fit_mass", "m(K^{+}e^{+}e^{-})", 4.0, 6.0, "GeV") thevars = ROOT.RooArgSet() thevars.add(bMass) fulldata = ROOT.RooDataSet('fulldata', 'fulldata', tree, ROOT.RooArgSet(thevars)) theBMassfunc = ROOT.RooFormulaVar("x", "x", "@0", ROOT.RooArgList(bMass)) theBMass = fulldata.addColumn(theBMassfunc) theBMass.setRange(xmin, xmax) thevars.add(theBMass) cut = '' print cut data = fulldata.reduce(thevars, cut) getattr(wspace, 'import')(data, RooFit.Rename("data")) # define the set obs = (x) wspace.defineSet('obs', 'x') # make the set obs known to Python obs = wspace.set('obs') #wspace.factory('KeysPdf::partial(x,data,MirrorBoth,2.0)') wspace.factory('KeysPdf::partial(x,data,MirrorLeft,2.0)') model = wspace.pdf('partial') # Plot results of fit on a different frame c2 = ROOT.TCanvas('fig_binnedFit', 'fit', 800, 600) c2.SetGrid() c2.cd() ROOT.gPad.SetLeftMargin(0.10) ROOT.gPad.SetRightMargin(0.05) #xframe = wspace.var('x').frame(RooFit.Title("PF electron")) xframe = theBMass.frame() data.plotOn(xframe, RooFit.Binning(50), RooFit.Name("data")) model.plotOn(xframe, RooFit.Name("global"), RooFit.LineColor(2), RooFit.MoveToBack()) # this will show fit overlay on canvas xframe.GetYaxis().SetTitleOffset(0.9) xframe.GetYaxis().SetTitleFont(42) xframe.GetYaxis().SetTitleSize(0.05) xframe.GetYaxis().SetLabelSize(0.04) xframe.GetYaxis().SetLabelFont(42) xframe.GetXaxis().SetTitleOffset(0.9) xframe.GetXaxis().SetTitleFont(42) xframe.GetXaxis().SetTitleSize(0.05) xframe.GetXaxis().SetLabelSize(0.04) xframe.GetXaxis().SetLabelFont(42) xframe.GetYaxis().SetTitle("Events") xframe.GetXaxis().SetTitle("m(K^{+}e^{+}e^{-}) [GeV]") xframe.SetStats(0) xframe.SetMinimum(0) xframe.Draw() CMS_lumi(isMC) legend = ROOT.TLegend(0.65, 0.75, 0.92, 0.85) #legend = ROOT.TLegend(0.65,0.15,0.92,0.35); legend.SetTextFont(72) legend.SetTextSize(0.04) legend.AddEntry(xframe.findObject("data"), "Data", "lpe") legend.AddEntry(xframe.findObject("global"), "Global Fit", "l") legend.Draw() c2.cd() c2.Update() c2.SaveAs(outputfile.replace('.root', '') + '.pdf') #wf = ROOT.TFile("part_workspace.root", "RECREATE") wf = ROOT.TFile(outputfile.replace('.root', '') + '.root', "RECREATE") wspace.Write() wf.Close() print("=" * 80)
background = RooGenericPdf('background','(pow(1-@0/8000,@1)/pow(@0/8000,@2+@3*log(@0/8000)))',RooArgList(x,p1,p2,p3)) roohistBkg = RooDataHist('roohist','roohist',RooArgList(x),hDat) res = background.fitTo(roohistBkg) # ----------------------------------------- # plot background canBname = 'can_Mjj_Data' if useSub: canBname = 'can_Sub_Mjj_Data' canB = TCanvas(canBname,canBname,900,600) gPad.SetLogy() canB.cd(1).SetBottomMargin(0.4) frame1 = x.frame() frame2 = x.frame() roohistBkg.plotOn(frame1,RooFit.Binning(NBINS)) background.plotOn(frame1) hpull = frame1.pullHist() frame2.addPlotable(hpull,'p') frame1.SetMinimum(0.5) frame1.GetXaxis().SetTitle('') if useSub: frame1.GetXaxis().SetRangeUser(900,2500) frame1.GetXaxis().SetLabelSize(0.0) frame1.GetYaxis().SetTickLength(0.06) frame1.Draw() pad = TPad('pad','pad',0.,0.,1.,1.) pad.SetTopMargin(0.6) pad.SetFillColor(0)
def doBiasStudy(self, pdf_alt_name="dijet", pdf_fit_name="dijet", data_name="data_bkg", n_bins=-1, pdf_sgn_name="buk", sgn_name="Spin0_M750", sgn_xsec=0., ntoys=10, nproc=0, randomize_params=False, parameter_set="default"): is_data = (data_name == "data_obs") mass_range = self.fname.split("_")[-1] FTestCfg = {} if is_data: FTestCfg = FTestCfg_data else: FTestCfg = FTestCfg_mc self.plot_blind = False self.out = ROOT.TFile.Open( self.save_dir + "/" + self.get_save_name() + "_bias_" + pdf_alt_name + "_" + pdf_fit_name + "_deg" + str(FTestCfg[pdf_fit_name]['ndof'][mass_range]) + "_" + data_name + "_" + pdf_sgn_name + "_" + sgn_name + "_" + ("xsec%.0f" % sgn_xsec) + "_" + str(nproc) + ".root", "RECREATE") tree = ROOT.TTree("toys", "") # sgn/bkg normalisation from toy fit ns_fit = n.zeros(1, dtype=float) nb_fit = n.zeros(1, dtype=float) # sgn/bkg normalisation error from toy fit ns_err = n.zeros(1, dtype=float) nb_err = n.zeros(1, dtype=float) # number of sgn/bkg events generated in toy ns_gen = n.zeros(1, dtype=float) nb_gen = n.zeros(1, dtype=float) # central value of sgn/bkg normalisation used for toy generation ns_asy = n.zeros(1, dtype=float) nb_asy = n.zeros(1, dtype=float) # expected signal yield from workspace ns_exp = n.zeros(1, dtype=float) # parameters nparams = n.zeros(1, dtype=int) params = n.zeros(8, dtype=float) # edm, minll edm = n.zeros(1, dtype=float) minll = n.zeros(1, dtype=float) # pdf index alt = n.zeros(1, dtype=int) fit = n.zeros(1, dtype=int) alt[0] = FTestCfg.keys().index(pdf_alt_name) fit[0] = FTestCfg.keys().index(pdf_fit_name) tree.Branch('ns_fit', ns_fit, 'ns_fit/D') tree.Branch('ns_gen', ns_gen, 'ns_gen/D') tree.Branch('ns_err', ns_err, 'ns_err/D') tree.Branch('ns_asy', ns_asy, 'ns_asy/D') tree.Branch('ns_exp', ns_exp, 'ns_asy/D') tree.Branch('nb_fit', nb_fit, 'nb_fit/D') tree.Branch('nb_gen', nb_gen, 'nb_gen/D') tree.Branch('nb_err', nb_err, 'nb_err/D') tree.Branch('nb_asy', nb_asy, 'nb_asy/D') tree.Branch('nparams', nparams, 'nparams/I') tree.Branch('params', params, 'params[nparams]/D') tree.Branch('edm', edm, 'edm/D') tree.Branch('minll', minll, 'minll/D') tree.Branch('alt', alt, 'alt/I') tree.Branch('fit', fit, 'fit/I') # make sure we use random numbers ROOT.RooRandom.randomGenerator().SetSeed(0) # data set for initial fit self.data = self.w.data(data_name) self.data.Print() self.x.setBins(self.data.numEntries() if n_bins < 0 else n_bins) print "Total number of bins: ", self.x.getBins() # for debugging... #mean = ROOT.RooRealVar("mean", "", 750) #sigma = ROOT.RooRealVar("sigma", "", 5) #pdf_sgn = ROOT.RooGaussian(pdf_sgn_name+"_pdf_sgn_"+sgn_name, "", self.x, mean, sigma) # sgn pdf #pdf_sgn = ROOT.RooBukinPdf(pdf_sgn_name+"_pdf_sgn_"+sgn_name, "", self.x, mean, sigma, xi, rho1, rho2) pdf_sgn = self.w.pdf(pdf_sgn_name + "_pdf_sgn_" + sgn_name) self.w.var("mean_sgn_" + sgn_name).setConstant(1) self.w.var("sigma_sgn_" + sgn_name).setConstant(1) sgn_norm = self.w.var(pdf_sgn_name + "_pdf_sgn_" + sgn_name + "_norm") sgn_norm_val = sgn_norm.getVal() sgn_norm.setVal(sgn_norm_val * sgn_xsec if sgn_xsec > 0. else sgn_norm_val) pdf_sgn_ext = ROOT.RooExtendPdf("pdf_sgn_ext", "", pdf_sgn, sgn_norm) # fit the alternative pdf to data (use it for toy generation) [pdf_bkg_alt, coeff_bkg_alt] = generate_pdf( x=self.x, pdf_name=pdf_alt_name, n_param=FTestCfg[pdf_alt_name]['MaxOrder'][mass_range], n_iter=0, mass_range=mass_range, parameter_set=parameter_set, is_data=is_data) res_bkg_alt = pdf_bkg_alt.fitTo( self.data #) , RooFit.Strategy(1), RooFit.Minimizer("Minuit2"), RooFit.Minos(1), RooFit.Save(1), RooFit.PrintLevel(-1), RooFit.PrintEvalErrors(0), RooFit.Warnings(ROOT.kFALSE)) res_bkg_alt.Print() res_bkg_alt.correlationMatrix().Print() # normalise the background to data_obs bkg_norm = ROOT.RooRealVar("bkg_norm", "", self.w.data("data_obs").sumEntries()) pdf_bkg_alt_ext = ROOT.RooExtendPdf("pdf_bkg_alt_ext", "", pdf_bkg_alt, bkg_norm) # fit the nominal pdf to data [pdf_bkg_nom, coeff_bkg_nom] = generate_pdf( x=self.x, pdf_name=pdf_fit_name, n_param=FTestCfg[pdf_fit_name]['MaxOrder'][mass_range], n_iter=1, mass_range=mass_range, parameter_set=parameter_set, is_data=is_data) res_bkg_nom = pdf_bkg_nom.fitTo(self.data, RooFit.Strategy(1), RooFit.Minimizer("Minuit2"), RooFit.Minos(1), RooFit.Save(1), RooFit.PrintLevel(-1), RooFit.PrintEvalErrors(0), RooFit.Warnings(ROOT.kFALSE)) res_bkg_nom.Print() res_bkg_nom.correlationMatrix().Print() # save a snapshot of the initial fits h_rebinned = self.data.createHistogram( "h_" + data_name + "_rebinned", self.x, RooFit.Binning(int((self.x.getMax() - self.x.getMin()) / 5.0), self.x.getMin(), self.x.getMax())) data_rebinned = ROOT.RooDataHist(data_name + "_rebinned", "", ROOT.RooArgList(self.x), h_rebinned, 1.0) self.plot( data=data_rebinned, hdata=h_rebinned, pdfs=[pdf_bkg_nom, pdf_bkg_alt], params=[coeff_bkg_nom, coeff_bkg_alt], res=[res_bkg_nom, res_bkg_alt], probs=[0., 0.], npars=[ FTestCfg[pdf_fit_name]['MaxOrder'][mass_range], FTestCfg[pdf_alt_name]['MaxOrder'][mass_range] ], legs=["Nominal: " + pdf_fit_name, "Alternative: " + pdf_alt_name], add_ratio=True, title="bias_" + pdf_fit_name + "_" + pdf_alt_name + "_" + data_name, header="Data fit (B-only)") # Ns and Nb (fit) n_s = ROOT.RooRealVar("n_s", "", 0.) n_s.setConstant(0) n_b = ROOT.RooRealVar("n_b", "", bkg_norm.getVal()) n_b.setConstant(0) [pdf_bkg_fit, coeff_bkg_fit] = generate_pdf( x=self.x, pdf_name=pdf_fit_name, n_param=FTestCfg[pdf_fit_name]['MaxOrder'][mass_range], n_iter=2, mass_range=mass_range, parameter_set=parameter_set, is_data=is_data) coeff_bkg_fit_reset = [] nparams[0] = FTestCfg[pdf_fit_name]['ndof'][mass_range] for p in xrange(FTestCfg[pdf_fit_name]['ndof'][mass_range]): coeff_bkg_fit_reset.append(coeff_bkg_fit[p].getVal()) pdf_fit_ext = ROOT.RooAddPdf("pdf_fit_ext", "", ROOT.RooArgList(pdf_sgn, pdf_bkg_fit), ROOT.RooArgList(n_s, n_b)) ntoy = 0 # run on self.data for ntoys=-1 run_ntoys = ntoys if ntoys >= 0 else 1 while ntoy < run_ntoys: # randomize parameters using covariance matrix if randomize_params: coeff_bkg_alt = res_bkg_alt.randomizePars() for p in xrange(FTestCfg[pdf_alt_name]['ndof'][mass_range]): print "\tRandomize alternative parameter ", p, " at value ", coeff_bkg_alt[ p].getVal() # generate the toy data set (binned by default) data_toy = pdf_bkg_alt_ext.generateBinned(ROOT.RooArgSet( self.x), RooFit.Extended()) if ntoys > 0 else self.data data_toy_sgn = None if sgn_xsec > 0.: data_toy_sgn = pdf_sgn_ext.generateBinned( ROOT.RooArgSet(self.x), RooFit.Extended()) data_toy.add(data_toy_sgn) nb_toy = data_toy.sumEntries() - (data_toy_sgn.sumEntries() if data_toy_sgn != None else 0.) ns_toy = data_toy_sgn.sumEntries() if data_toy_sgn != None else 0. n_toy = data_toy.sumEntries() # reset all fit parameters n_s.setVal(0.) n_b.setVal(bkg_norm.getVal()) for p in xrange(FTestCfg[pdf_fit_name]['ndof'][mass_range]): coeff_bkg_fit[p].setVal(coeff_bkg_fit_reset[p]) print "\tReset parameter ", p, " at value ", coeff_bkg_fit[ p].getVal() res_fit = pdf_fit_ext.fitTo(data_toy, RooFit.Strategy(1), RooFit.Minimizer("Minuit2", "migrad"), RooFit.Minos(1), RooFit.Save(1), RooFit.PrintLevel(-1), RooFit.PrintEvalErrors(0), RooFit.Warnings(ROOT.kFALSE), RooFit.Extended(ROOT.kTRUE)) if res_fit == None or res_fit.status() > 0: continue res_fit.Print() print "Nb=%.0f -- Ns=%.0f ==> tot: %.0f" % (nb_toy, ns_toy, n_toy) print "Toy ", ntoy, ">>>>>>>>>>", n_s.getVal() / n_s.getError() ns_fit[0] = n_s.getVal() ns_err[0] = n_s.getError() ns_gen[0] = ns_toy ns_asy[0] = sgn_norm.getVal() ns_exp[0] = sgn_norm_val nb_fit[0] = n_b.getVal() nb_err[0] = n_b.getError() nb_gen[0] = nb_toy nb_asy[0] = bkg_norm.getVal() edm[0] = res_fit.edm() minll[0] = res_fit.minNll() for p in xrange(FTestCfg[pdf_fit_name]['ndof'][mass_range]): params[p] = coeff_bkg_fit[p].getVal() tree.Fill() ntoy += 1 self.out.cd() tree.Write("", ROOT.TObject.kOverwrite) self.out.Close()
# Construct frames for plotting B_DTF_PV_consJpsi_M_frame = B_DTF_PV_consJpsi_M.frame() B_DTF_PV_consJpsi_M_frame2 = B_DTF_PV_consJpsi_M.frame() mass_data.plotOn(B_DTF_PV_consJpsi_M_frame, RF.Name("data"), RF.DataError(0)) sum_pdf.plotOn(B_DTF_PV_consJpsi_M_frame, RF.Name("arg1_pdf"), RF.Components("arg_1pi_pdf"), RF.Range(min_inv_mass, arg_1pi_m0.getValV()+20), RF.LineColor(8), RF.LineStyle(R.kDashed)) sum_pdf.plotOn(B_DTF_PV_consJpsi_M_frame, RF.Name("arg2_pdf"), RF.Components("arg_2pi_pdf"), RF.Range(min_inv_mass, arg_2pi_m0.getValV()+20), RF.LineColor(6), RF.LineStyle(R.kDashed)) sum_pdf.plotOn(B_DTF_PV_consJpsi_M_frame, RF.Name("bkg_pdf"), RF.Components("bkg_pdf"), RF.LineColor(R.kRed), RF.LineStyle(R.kDashed)) sum_pdf.plotOn(B_DTF_PV_consJpsi_M_frame, RF.Name("sum_pdf")) B_DTF_PV_consJpsi_M_frame.SetTitle(""); B_DTF_PV_consJpsi_M_frame.GetXaxis().SetTitle("invariant mass [MeV/c^{2}]") c1 = R.TCanvas("c1", "canvas 1", 1200, 800); c1.SetLeftMargin(0.12) B_DTF_PV_consJpsi_M_frame.Print() sum_pdf_cut.fitTo(mass_data_cut) mass_data_cut.plotOn(B_DTF_PV_consJpsi_M_frame2, RF.Name("data"), RF.DataError(0), RF.Binning(100, 4850, 5750)) sum_pdf_cut.plotOn(B_DTF_PV_consJpsi_M_frame2, RF.Name("sum_pdf_cut")) sum_pdf_cut.plotOn(B_DTF_PV_consJpsi_M_frame2, RF.Name("arg1_pdf_cut"), RF.Components("arg_1pi_pdf_const"), RF.Range(min_inv_mass, arg_1pi_m0.getValV() + 50), RF.LineColor(8), RF.LineStyle(R.kDashed)) sum_pdf_cut.plotOn(B_DTF_PV_consJpsi_M_frame2, RF.Name("arg2_pdf_cut"), RF.Components("arg_2pi_pdf_const"), RF.Range(min_inv_mass, arg_2pi_m0.getValV() + 20), RF.LineColor(6), RF.LineStyle(R.kDashed)) B_DTF_PV_consJpsi_M_frame2.SetTitle(""); B_DTF_PV_consJpsi_M_frame2.GetXaxis().SetTitle("invariant mass [MeV/c^{2}]") B_DTF_PV_consJpsi_M_frame2.Print() Leg1 = R.TLegend(0.55, 0.5, 0.89, 0.89); Leg1.SetBorderSize(0) Leg1.AddEntry(B_DTF_PV_consJpsi_M_frame.findObject("arg1_pdf"), "#it{B #rightarrow J#kern[0.1]{#/}#kern[-0.5]{#psi} K #pi}" , "L") Leg1.AddEntry(B_DTF_PV_consJpsi_M_frame.findObject("arg2_pdf"), "#it{B #rightarrow J#kern[0.1]{#/}#kern[-0.5]{#psi} K #pi #pi}", "L") Leg1.AddEntry(B_DTF_PV_consJpsi_M_frame.findObject("bkg_pdf"), "Background", "L") Leg1.AddEntry(B_DTF_PV_consJpsi_M_frame.findObject("sum_pdf"), "Total fit", "L") makePlotWithPulls(c1, B_DTF_PV_consJpsi_M_frame, data = "data", curve = "sum_pdf", legend = Leg1) Leg2 = R.TLegend(0.55, 0.6, 0.89, 0.89); Leg2.SetBorderSize(0) Leg2.AddEntry(B_DTF_PV_consJpsi_M_frame2.findObject("arg1_pdf_cut"), "#it{B #rightarrow J#kern[0.1]{#/}#kern[-0.5]{#psi} K #pi}" , "L")
def dijet(category): channel = 'bb' stype = channel isSB = True # relict from using Alberto's more complex script isData = not ISMC nTupleDir = NTUPLEDIR samples = data if isData else back pd = [] for sample_name in samples: if YEAR == 'run2': pd += sample[sample_name]['files'] else: pd += [x for x in sample[sample_name]['files'] if YEAR in x] print "datasets:", pd if not os.path.exists(PLOTDIR): os.makedirs(PLOTDIR) if BIAS: print "Running in BIAS mode" order = 0 RSS = {} X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV") weight = RooRealVar("MANtag_weight", "", -1.e9, 1.e9) variables = RooArgSet(X_mass) variables.add(RooArgSet(weight)) if VARBINS: binsXmass = RooBinning(len(abins) - 1, abins) X_mass.setBinning(RooBinning(len(abins_narrow) - 1, abins_narrow)) plot_binning = RooBinning( int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(), X_mass.getMax()) else: X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10)) binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(), X_mass.getMax()) plot_binning = binsXmass baseCut = "" print stype, "|", baseCut print " - Reading from Tree" treeBkg = TChain("tree") for ss in pd: if os.path.exists(nTupleDir + ss + "_" + BTAGGING + ".root"): treeBkg.Add(nTupleDir + ss + "_" + BTAGGING + ".root") else: print "found no file for sample:", ss setData = RooDataSet("setData", "Data (QCD+TTbar MC)", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeBkg)) nevents = setData.sumEntries() dataMin, dataMax = array('d', [0.]), array('d', [0.]) setData.getRange(X_mass, dataMin, dataMax) xmin, xmax = dataMin[0], dataMax[0] lastBin = X_mass.getMax() if VARBINS: for b in narrow_bins: if b > xmax: lastBin = b break print "Imported", ( "data" if isData else "MC" ), "RooDataSet with", nevents, "events between [%.1f, %.1f]" % (xmin, xmax) #xmax = xmax+binsXmass.averageBinWidth() # start form next bin # 1 parameter print "fitting 1 parameter model" p1_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p1_1", "p1", 7.0, 0., 2000.) modelBkg1 = RooGenericPdf("Bkg1", "Bkg. fit (2 par.)", "1./pow(@0/13000, @1)", RooArgList(X_mass, p1_1)) normzBkg1 = RooRealVar( modelBkg1.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) #range dependent of actual number of events! modelExt1 = RooExtendPdf(modelBkg1.GetName() + "_ext", modelBkg1.GetTitle(), modelBkg1, normzBkg1) fitRes1 = modelExt1.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes1.Print() RSS[1] = drawFit("Bkg1", category, X_mass, modelBkg1, setData, binsXmass, [fitRes1], normzBkg1.getVal()) # 2 parameters print "fitting 2 parameter model" p2_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_1", "p1", 0., -100., 1000.) p2_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_2", "p2", p1_1.getVal(), -100., 600.) modelBkg2 = RooGenericPdf("Bkg2", "Bkg. fit (3 par.)", "pow(1-@0/13000, @1) / pow(@0/13000, @2)", RooArgList(X_mass, p2_1, p2_2)) normzBkg2 = RooRealVar(modelBkg2.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt2 = RooExtendPdf(modelBkg2.GetName() + "_ext", modelBkg2.GetTitle(), modelBkg2, normzBkg2) fitRes2 = modelExt2.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes2.Print() RSS[2] = drawFit("Bkg2", category, X_mass, modelBkg2, setData, binsXmass, [fitRes2], normzBkg2.getVal()) # 3 parameters print "fitting 3 parameter model" p3_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_1", "p1", p2_1.getVal(), -2000., 2000.) p3_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_2", "p2", p2_2.getVal(), -400., 2000.) p3_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_3", "p3", -2.5, -500., 500.) modelBkg3 = RooGenericPdf( "Bkg3", "Bkg. fit (4 par.)", "pow(1-@0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(X_mass, p3_1, p3_2, p3_3)) normzBkg3 = RooRealVar(modelBkg3.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt3 = RooExtendPdf(modelBkg3.GetName() + "_ext", modelBkg3.GetTitle(), modelBkg3, normzBkg3) fitRes3 = modelExt3.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes3.Print() RSS[3] = drawFit("Bkg3", category, X_mass, modelBkg3, setData, binsXmass, [fitRes3], normzBkg3.getVal()) # 4 parameters print "fitting 4 parameter model" p4_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_1", "p1", p3_1.getVal(), -2000., 2000.) p4_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_2", "p2", p3_2.getVal(), -2000., 2000.) p4_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_3", "p3", p3_3.getVal(), -50., 50.) p4_4 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_4", "p4", 0.1, -50., 50.) modelBkg4 = RooGenericPdf( "Bkg4", "Bkg. fit (5 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000)+@4*pow(log(@0/13000), 2))", RooArgList(X_mass, p4_1, p4_2, p4_3, p4_4)) normzBkg4 = RooRealVar(modelBkg4.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt4 = RooExtendPdf(modelBkg4.GetName() + "_ext", modelBkg4.GetTitle(), modelBkg4, normzBkg4) fitRes4 = modelExt4.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes4.Print() RSS[4] = drawFit("Bkg4", category, X_mass, modelBkg4, setData, binsXmass, [fitRes4], normzBkg4.getVal()) # Normalization parameters are should be set constant, but shape ones should not # if BIAS: # p1_1.setConstant(True) # p2_1.setConstant(True) # p2_2.setConstant(True) # p3_1.setConstant(True) # p3_2.setConstant(True) # p3_3.setConstant(True) # p4_1.setConstant(True) # p4_2.setConstant(True) # p4_3.setConstant(True) # p4_4.setConstant(True) normzBkg1.setConstant(True) normzBkg2.setConstant(True) normzBkg3.setConstant(True) normzBkg4.setConstant(True) #*******************************************************# # # # Fisher # # # #*******************************************************# # Fisher test with open(PLOTDIR + "/Fisher_" + category + ".tex", 'w') as fout: fout.write(r"\begin{tabular}{c|c|c|c|c}") fout.write("\n") fout.write(r"function & $\chi^2$ & RSS & ndof & F-test \\") fout.write("\n") fout.write("\hline") fout.write("\n") CL_high = False for o1 in range(1, 5): o2 = min(o1 + 1, 5) fout.write("%d par & %.2f & %.2f & %d & " % (o1 + 1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"] - RSS[o1]["npar"])) if o2 > len(RSS): fout.write(r"\\") fout.write("\n") continue #order==0 and CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1 + 1., o2 + 1., RSS[o1]["nbins"]) fout.write("CL=%.3f " % (CL)) if CL > 0.10: # The function with less parameters is enough if not CL_high: order = o1 #fout.write( "%d par are sufficient " % (o1+1)) CL_high = True else: #fout.write( "%d par are needed " % (o2+1)) if not CL_high: order = o2 fout.write(r"\\") fout.write("\n") fout.write("\hline") fout.write("\n") fout.write(r"\end{tabular}") print "saved F-test table as", PLOTDIR + "/Fisher_" + category + ".tex" #print "-"*25 #print "function & $\\chi^2$ & RSS & ndof & F-test & result \\\\" #print "\\multicolumn{6}{c}{", "Zprime_to_bb", "} \\\\" #print "\\hline" #CL_high = False #for o1 in range(1, 5): # o2 = min(o1 + 1, 5) # print "%d par & %.2f & %.2f & %d & " % (o1+1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"]-RSS[o1]["npar"]), # if o2 > len(RSS): # print "\\\\" # continue #order==0 and # CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1+1., o2+1., RSS[o1]["nbins"]) # print "%d par vs %d par CL=%f & " % (o1+1, o2+1, CL), # if CL > 0.10: # The function with less parameters is enough # if not CL_high: # order = o1 # print "%d par are sufficient" % (o1+1), # CL_high=True # else: # print "%d par are needed" % (o2+1), # if not CL_high: # order = o2 # print "\\\\" #print "\\hline" #print "-"*25 #print "@ Order is", order, "("+category+")" #order = min(3, order) #order = 2 if order == 1: modelBkg = modelBkg1 #.Clone("Bkg") modelAlt = modelBkg2 #.Clone("BkgAlt") normzBkg = normzBkg1 #.Clone("Bkg_norm") fitRes = fitRes1 elif order == 2: modelBkg = modelBkg2 #.Clone("Bkg") modelAlt = modelBkg3 #.Clone("BkgAlt") normzBkg = normzBkg2 #.Clone("Bkg_norm") fitRes = fitRes2 elif order == 3: modelBkg = modelBkg3 #.Clone("Bkg") modelAlt = modelBkg4 #.Clone("BkgAlt") normzBkg = normzBkg3 #.Clone("Bkg_norm") fitRes = fitRes3 elif order == 4: modelBkg = modelBkg4 #.Clone("Bkg") modelAlt = modelBkg3 #.Clone("BkgAlt") normzBkg = normzBkg4 #.Clone("Bkg_norm") fitRes = fitRes4 else: print "Functions with", order + 1, "or more parameters are needed to fit the background" exit() modelBkg.SetName("Bkg_" + YEAR + "_" + category) modelAlt.SetName("Alt_" + YEAR + "_" + category) normzBkg.SetName("Bkg_" + YEAR + "_" + category + "_norm") print "-" * 25 # Generate pseudo data setToys = RooDataSet() setToys.SetName("data_toys") setToys.SetTitle("Data (toys)") if not isData: print " - Generating", nevents, "events for toy data" setToys = modelBkg.generate(RooArgSet(X_mass), nevents) #setToys = modelAlt.generate(RooArgSet(X_mass), nevents) print "toy data generated" if VERBOSE: raw_input("Press Enter to continue...") #*******************************************************# # # # Plot # # # #*******************************************************# print "starting to plot" c = TCanvas("c_" + category, category, 800, 800) c.Divide(1, 2) setTopPad(c.GetPad(1), RATIO) setBotPad(c.GetPad(2), RATIO) c.cd(1) frame = X_mass.frame() setPadStyle(frame, 1.25, True) if VARBINS: frame.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin) signal = getSignal( category, stype, 2000) #replacing Alberto's getSignal by own dummy function graphData = setData.plotOn(frame, RooFit.Binning(plot_binning), RooFit.Scaling(False), RooFit.Invisible()) modelBkg.plotOn(frame, RooFit.VisualizeError(fitRes, 1, False), RooFit.LineColor(602), RooFit.FillColor(590), RooFit.FillStyle(1001), RooFit.DrawOption("FL"), RooFit.Name("1sigma")) modelBkg.plotOn(frame, RooFit.LineColor(602), RooFit.FillColor(590), RooFit.FillStyle(1001), RooFit.DrawOption("L"), RooFit.Name(modelBkg.GetName())) modelAlt.plotOn(frame, RooFit.LineStyle(7), RooFit.LineColor(613), RooFit.FillColor(609), RooFit.FillStyle(1001), RooFit.DrawOption("L"), RooFit.Name(modelAlt.GetName())) if not isSB and signal[0] is not None: # FIXME remove /(2./3.) signal[0].plotOn( frame, RooFit.Normalization(signal[1] * signal[2], RooAbsReal.NumEvent), RooFit.LineStyle(3), RooFit.LineWidth(6), RooFit.LineColor(629), RooFit.DrawOption("L"), RooFit.Name("Signal")) graphData = setData.plotOn( frame, RooFit.Binning(plot_binning), RooFit.Scaling(False), RooFit.XErrorSize(0 if not VARBINS else 1), RooFit.DataError(RooAbsData.Poisson if isData else RooAbsData.SumW2), RooFit.DrawOption("PE0"), RooFit.Name(setData.GetName())) fixData(graphData.getHist(), True, True, not isData) pulls = frame.pullHist(setData.GetName(), modelBkg.GetName(), True) chi = frame.chiSquare(setData.GetName(), modelBkg.GetName(), True) #setToys.plotOn(frame, RooFit.DataError(RooAbsData.Poisson), RooFit.DrawOption("PE0"), RooFit.MarkerColor(2)) frame.GetYaxis().SetTitle("Events / ( 100 GeV )") frame.GetYaxis().SetTitleOffset(1.05) frame.Draw() #print "frame drawn" # Get Chi2 # chi2[1] = frame.chiSquare(modelBkg1.GetName(), setData.GetName()) # chi2[2] = frame.chiSquare(modelBkg2.GetName(), setData.GetName()) # chi2[3] = frame.chiSquare(modelBkg3.GetName(), setData.GetName()) # chi2[4] = frame.chiSquare(modelBkg4.GetName(), setData.GetName()) frame.SetMaximum(frame.GetMaximum() * 10) frame.SetMinimum(max(frame.GetMinimum(), 1.e-1)) c.GetPad(1).SetLogy() drawAnalysis(category) drawRegion(category, True) #drawCMS(LUMI, "Simulation Preliminary") drawCMS(LUMI, "Work in Progress", suppressCMS=True) leg = TLegend(0.575, 0.6, 0.95, 0.9) leg.SetBorderSize(0) leg.SetFillStyle(0) #1001 leg.SetFillColor(0) leg.AddEntry(setData.GetName(), setData.GetTitle() + " (%d events)" % nevents, "PEL") leg.AddEntry(modelBkg.GetName(), modelBkg.GetTitle(), "FL") #.SetTextColor(629) leg.AddEntry(modelAlt.GetName(), modelAlt.GetTitle(), "L") if not isSB and signal[0] is not None: leg.AddEntry("Signal", signal[0].GetTitle(), "L") leg.SetY1(0.9 - leg.GetNRows() * 0.05) leg.Draw() latex = TLatex() latex.SetNDC() latex.SetTextSize(0.04) latex.SetTextFont(42) if not isSB: latex.DrawLatex(leg.GetX1() * 1.16, leg.GetY1() - 0.04, "HVT model B (g_{V}=3)") # latex.DrawLatex(0.67, leg.GetY1()-0.045, "#sigma_{X} = 1.0 pb") c.cd(2) frame_res = X_mass.frame() setPadStyle(frame_res, 1.25) frame_res.addPlotable(pulls, "P") setBotStyle(frame_res, RATIO, False) if VARBINS: frame_res.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin) frame_res.GetYaxis().SetRangeUser(-5, 5) frame_res.GetYaxis().SetTitle("pulls(#sigma)") frame_res.GetYaxis().SetTitleOffset(0.3) frame_res.Draw() fixData(pulls, False, True, False) drawChi2(RSS[order]["chi2"], RSS[order]["nbins"] - (order + 1), True) line = drawLine(X_mass.getMin(), 0, lastBin, 0) if VARBINS: c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf") c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png") else: c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf") c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# if BIAS: gSystem.Load("libHiggsAnalysisCombinedLimit.so") from ROOT import RooMultiPdf cat = RooCategory("pdf_index", "Index of Pdf which is active") pdfs = RooArgList(modelBkg, modelAlt) roomultipdf = RooMultiPdf("roomultipdf", "All Pdfs", cat, pdfs) normulti = RooRealVar("roomultipdf_norm", "Number of background events", nevents, 0., 1.e6) normzBkg.setConstant( False ) ## newly put here to ensure it's freely floating in the combine fit # create workspace w = RooWorkspace("Zprime_" + YEAR, "workspace") # Dataset if isData: getattr(w, "import")(setData, RooFit.Rename("data_obs")) else: getattr(w, "import")(setToys, RooFit.Rename("data_obs")) #getattr(w, "import")(setData, RooFit.Rename("data_obs")) if BIAS: getattr(w, "import")(cat, RooFit.Rename(cat.GetName())) getattr(w, "import")(normulti, RooFit.Rename(normulti.GetName())) getattr(w, "import")(roomultipdf, RooFit.Rename(roomultipdf.GetName())) getattr(w, "import")(modelBkg, RooFit.Rename(modelBkg.GetName())) getattr(w, "import")(modelAlt, RooFit.Rename(modelAlt.GetName())) getattr(w, "import")(normzBkg, RooFit.Rename(normzBkg.GetName())) w.writeToFile(WORKDIR + "%s_%s.root" % (DATA_TYPE + "_" + YEAR, category), True) print "Workspace", WORKDIR + "%s_%s.root" % ( DATA_TYPE + "_" + YEAR, category), "saved successfully" if VERBOSE: raw_input("Press Enter to continue...")