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...")
