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 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
a1.setConstant(True)
a2.setConstant(True)
a3.setConstant(True)
a4.setConstant(True)
#nBkg.setConstant(True)
c = TCanvas("canvas","canvas",1200,800)
phiFrame = mass_ref_c_kkk.frame(Title("#mu#muKKK spectrum - B^{+} candidates"),Range(bumin,bumax),Normalization((nSig.getValV() + nBkg.getValV())))
splotData.plotOn(phiFrame)
ratio = 1.0/float(nfits)
tot.plotOn(phiFrame,Normalization(ratio))
bFrac = (nBkg.getValV())/(nSig.getValV() + nBkg.getValV())
bkg.plotOn(phiFrame,LineColor(kRed),Normalization(bFrac),LineStyle(kDashed))
signal.plotOn(phiFrame,LineColor(kGreen),Normalization(1.0-bFrac))
tot.paramOn(phiFrame,RooFit.Layout(0.72,0.99,0.4))#,Parameters(RooArgSet(nSig)))
#signal.paramOn(phiFrame,RooFit.Layout(0.57,0.99,0.65),Parameters(RooArgSet(mean,sigma)))
lowranges = []
uppranges = []
sides = [3.0,5.0,8.0]
for i in sides:
mass_ref_c_kkk.setRange("sigma_"+ str(i),mean.getVal()-float(i)*sigma.getVal(),mean.getVal()+float(i)*sigma.getVal())
lowranges.append(mean.getVal()-float(i)*sigma.getVal())
uppranges.append(mean.getVal()+float(i)*sigma.getVal())
totIntegralSig = signal.createIntegral(RooArgSet(mass_ref_c_kkk)).getVal()
totIntegralBkg = bkg.analyticalIntegral(bkg.getAnalyticalIntegral(RooArgSet(mass_ref_c_kkk),RooArgSet(mass_ref_c_kkk)))
totIntegralTot = tot.createIntegral(RooArgSet(mass_ref_c_kkk)).getVal()
leftsidehist.Scale(theRatio)
rightsidehist.Scale(theRatio)
sidehist = leftsidehist.Clone()
sidehist.Add(rightsidehist)
plotpad.cd()
kkFrame = tt_mass.frame(Range(fitphimin, fitphimax), Title("#phi mass"))
# kkbins = RooBinning(-15,15)
# kkbins.addUniform(30,fitphimin,fitphimax)
traKFitData.plotOn(kkFrame, Name("Data"))
kkTot.plotOn(kkFrame, RooFit.Normalization(1.0 / float(nfit)), Name("Pdf"))
traKFitData.plotOn(kkFrame)
kkTot.paramOn(kkFrame, RooFit.Layout(0.57, 0.99, 0.65))
kkFrame.Draw()
pullpad.cd()
hpull = kkFrame.pullHist("Data", "Pdf")
pullframe = mmtt_mass.frame(Title("Pull Distribution"),
Range(fitphimin, fitphimax))
pullframe.SetAxisRange(-5.0, 5.0, "Y")
#pullframe.GetXaxis().SetTitleSize(0.04)
#pullframe.GetYaxis().SetTitleSize(0.03)
gStyle.SetTitleFontSize(0.07)
pullframe.addPlotable(hpull, "P")
pullframe.Draw()
lineup = TLine(fitphimin, 4.0, fitphimax, 4.0)
def fit_gau2_che(var,
dataset,
title='',
print_pars=False,
test=False,
mean_=None,
sigma_=None,
sigma1_=None,
sigmaFraction_=None):
# define background
c0 = RooRealVar('c0', 'constant', 0.1, -1, 1)
c1 = RooRealVar('c1', 'linear', 0.6, -1, 1)
c2 = RooRealVar('c2', 'quadratic', 0.1, -1, 1)
c3 = RooRealVar('c3', 'c3', 0.1, -1, 1)
bkg = RooChebychev('bkg', 'background pdf', var,
RooArgList(c0, c1, c2, c3))
# define signal
val = 5.28
dmean = 0.05
valL = val - dmean
valR = val + dmean
if mean_ is None:
mean = RooRealVar("mean", "mean", val, valL, valR)
else:
mean = RooRealVar("mean", "mean", mean_)
val = 0.05
dmean = 0.02
valL = val - dmean
valR = val + dmean
if sigma_ is None:
sigma = RooRealVar('sigma', 'sigma', val, valL, valR)
else:
sigma = RooRealVar('sigma', 'sigma', sigma_)
if sigma1_ is None:
sigma1 = RooRealVar('sigma1', 'sigma1', val, valL, valR)
else:
sigma1 = RooRealVar('sigma1', 'sigma1', sigma1_)
peakGaus = RooGaussian("peakGaus", "peakGaus", var, mean, sigma)
peakGaus1 = RooGaussian("peakGaus1", "peakGaus1", var, mean, sigma1)
if sigmaFraction_ is None:
sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", 0.5, 0.,
1.)
else:
sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction",
sigmaFraction_)
glist = RooArgList(peakGaus, peakGaus1)
peakG = RooAddPdf("peakG", "peakG", glist, RooArgList(sigmaFraction))
listPeak = RooArgList("listPeak")
listPeak.add(peakG)
listPeak.add(bkg)
fbkg = 0.45
nEntries = dataset.numEntries()
val = (1 - fbkg) * nEntries
listArea = RooArgList("listArea")
areaPeak = RooRealVar("areaPeak", "areaPeak", val, 0., nEntries)
listArea.add(areaPeak)
nBkg = fbkg * nEntries
areaBkg = RooRealVar("areaBkg", "areaBkg", nBkg, 0., nEntries)
listArea.add(areaBkg)
model = RooAddPdf("model", "fit model", listPeak, listArea)
if not test:
fitres = model.fitTo(dataset, RooFit.Extended(kTRUE),
RooFit.Minos(kTRUE), RooFit.Save(kTRUE))
nbins = 35
frame = var.frame(nbins)
frame.GetXaxis().SetTitle("B^{0} mass (GeV/c^{2})")
frame.GetXaxis().CenterTitle()
frame.GetYaxis().CenterTitle()
frame.SetTitle(title)
mk_size = RooFit.MarkerSize(0.3)
mk_style = RooFit.MarkerStyle(kFullCircle)
dataset.plotOn(frame, mk_size, mk_style)
model.plotOn(frame)
as_bkg = RooArgSet(bkg)
cp_bkg = RooFit.Components(as_bkg)
line_style = RooFit.LineStyle(kDashed)
model.plotOn(frame, cp_bkg, line_style)
if print_pars:
fmt = RooFit.Format('NEU')
lyt = RooFit.Layout(0.65, 0.95, 0.92)
param = model.paramOn(frame, fmt, lyt)
param.getAttText().SetTextSize(0.02)
param.getAttText().SetTextFont(60)
frame.Draw()
pars = [
areaBkg, areaPeak, c0, c1, c2, c3, mean, sigma, sigma1, sigmaFraction
]
return pars
def main():
parser = OptionParser()
parser.add_option("-d", "--dir", type="string", dest="outDir", metavar="DIR", default="./",
help="output directory for .png")
(options, args) = parser.parse_args()
if os.path.exists(options.outDir) and options.outDir!="./":
print "Sorry, file ",options.outDir," already exist, choose another name\n"
exit(1)
else:
os.system("mkdir -p "+options.outDir)
"""
Set the style ...
"""
myNewStyle = TStyle("myNewStyle","A better style for my plots")
setStyle(myNewStyle)
TH1F.SetDefaultSumw2(True)
# Histogram range
xlow = 70.
xup = 110.
# Mass range for fit
minM_fit = 75.
maxM_fit = 105.
# Ratio plot range
minR = 0.8
maxR = 1.2
# TLines for ratio plot
line = TLine(minM_fit,1,maxM_fit,1)
line.SetLineWidth(2)
line.SetLineColor(2)
# Canvas
spectrum_height = 0.75
ratio_correction = 1.4
ratio_height = (1-spectrum_height)*ratio_correction
xOffset = 0.08
yOffset = 0.04
cTest = TCanvas("cTest","cTest")
c2 = TCanvas("c2","c2")
c2.SetFillColor(0)
c2.Divide(1,2)
c3 = TCanvas("c3","c3")
c3.SetFillColor(0)
c3.Divide(1,2)
# Files MuScleFit
fDataBefore = TFile("h3_Z_data_beforeCorrection.root")
fDataAfter = TFile("h3_Z_data_afterCorrection.root")
fMcBefore = TFile("h3_Z_mc_beforeCorrection.root")
fMcAfter = TFile("h3_Z_mc_afterCorrection.root")
# Retrieve histograms and fit
hDataBefore = fDataBefore.Get("h1_Z_data")
hDataAfter = fDataAfter.Get("h1_Z_data")
hMcBefore = fMcBefore.Get("h1_Z_mc")
hMcAfter = fMcAfter.Get("h1_Z_mc")
# Identifiers
ids = ["data_before","data_after","mc_before","mc_after"]
# Create histograms dictionary
histos = {}
histos["data_before"] = hDataBefore
histos["data_after"] = hDataAfter
histos["mc_before"] = hMcBefore
histos["mc_after"] = hMcAfter
histosSubtr = {}
# Create parameters dictionary
expPars = {}
signalPars = {}
for i in ids:
# RooFit definitions
## RooRealVars
x = RooRealVar("x","M_{#mu#mu} (GeV)",minM_fit,maxM_fit)
mean = RooRealVar("mean","mean",91.19,87.,94.)
meanCB = RooRealVar("meanCB","meanCB",0.,-10.,10.)
meanCB.setConstant(True)
width = RooRealVar("width","width",2.4952,2.3,2.6)
width.setConstant(True)
sigma = RooRealVar("sigma","sigma",1.3,0.001,3.)
# sigma.setConstant(True)
slope = RooRealVar("slope","slope",-0.1,-1.0,0.)
# slope.setConstant(True)
alpha = RooRealVar("alpha","alpha",1.,0.,30.)
# alpha.setConstant(True)
N = RooRealVar("N","N",2.,0.,100.)
# N.setConstant(True)
fsig = RooRealVar("fsig","fsig",0.9,0.,1.0)
## PDFs
relBW = RooGenericPdf("relBW","relBW","@0/(pow(@0*@0-@1*@1,2) + @2*@2*@0*@0*@0*@0/(@1*@1))",RooArgList(x,mean,width))
CB = RooCBShape("CB","CB",x,meanCB,sigma,alpha,N)
expo = RooExponential("expo","expo",x,slope)
relBWTimesCB = RooFFTConvPdf("relBWTimesCB","relBWTimesCB",x,relBW,CB)
relBWTimesCBPlusExp = RooAddPdf("relBWTimesCBPlusExp","relBWTimesCBPlusExp",relBWTimesCB,expo,fsig)
# Fit
frame = x.frame()
h = histos[i]
# h.Rebin(10)
h.Sumw2()
nbin = h.GetNbinsX()
dh = RooDataHist("dh","dh",RooArgList(x),h)
dh.plotOn(frame)
relBWTimesCBPlusExp.fitTo(dh)
relBWTimesCBPlusExp.plotOn(frame)
relBWTimesCBPlusExp.paramOn(frame)
# Plot
c = TCanvas("c_"+i,"c_"+i)
c.SetFillColor(0)
c.cd()
frame.Draw()
c.SaveAs(options.outDir+"/DimuonWithFit_"+i+".png")
# Extract the result of the fit
expParams = []
expCoef = slope.getValV()
fSig = fsig.getValV()
binLow = h.GetXaxis().FindBin(minM_fit)
binHigh = h.GetXaxis().FindBin(maxM_fit)
nEntries = h.Integral(binLow,binHigh)
expParams = [expCoef,fSig,nEntries,binLow,binHigh]
expPars[i] = expParams
signalParams = [mean.getVal(),width.getVal(),meanCB.getVal(),sigma.getVal(),alpha.getVal(),N.getVal()]
signalPars[i] = signalParams
# Subtract the bkg from the histograms
h_woBkg = h.Clone()
h_bkg = TH1F("h_bkg_"+i,"Histogram of bkg events",nbin,xlow,xup)
h_bkg.Sumw2()
expNorm = (math.fabs(expCoef)*(1-fSig)*nEntries)/(math.exp(expCoef*minM_fit)-math.exp(expCoef*maxM_fit))
for ibin in range(binLow,binHigh):
w = integrateExp(expNorm,expCoef,h_bkg.GetBinLowEdge(ibin),h_bkg.GetBinLowEdge(ibin+1))
h_bkg.SetBinContent(ibin,w)
h_woBkg.Add(h_bkg,-1)
nEvts_woBkg = h_woBkg.Integral(binLow,binHigh)
h_woBkg.Scale(1/nEvts_woBkg)
histosSubtr[i] = h_woBkg
del expParams, c
del relBWTimesCBPlusExp, relBW, CB, relBWTimesCB, expo
del x, mean, width, sigma, fsig, N, alpha, slope, meanCB
del frame, dh, h, h_woBkg, h_bkg
# BEFORE CORRECTIONS
# # RooFit definitions (again, sorry)
# ## RooRealVars
# x = RooRealVar("x","M_{#mu#mu} (GeV)",minM_fit,maxM_fit)
# mean = RooRealVar("mean","mean",91.19)
# meanCB = RooRealVar("meanCB","meanCB",0.)
# width = RooRealVar("width","width",2.4952)
# sigma = RooRealVar("sigma","sigma",1.3)
# alpha = RooRealVar("alpha","alpha",1.)
# N = RooRealVar("N","N",2.)
# ## PDFs (again, sorry)
# relBW = RooGenericPdf("relBW","relBW","@0/(pow(@0*@0-@1*@1,2) + @2*@2*@0*@0*@0*@0/(@1*@1))",RooArgList(x,mean,width))
# CB = RooCBShape("CB","CB",x,meanCB,sigma,alpha,N)
# relBWTimesCB = RooFFTConvPdf("relBWTimesCB","relBWTimesCB",x,relBW,CB)
# Ratio plot after background subtraction
histosSubtr["data_before"].GetXaxis().SetRangeUser(minM_fit,maxM_fit)
histosSubtr["data_before"].GetYaxis().SetRangeUser(0.,histosSubtr["data_before"].GetMaximum()+0.1*histosSubtr["data_before"].GetMaximum())
histosSubtr["data_before"].SetLineColor(1)
histosSubtr["mc_before"].GetXaxis().SetRangeUser(minM_fit,maxM_fit)
if histosSubtr["mc_before"].GetMaximum()>histosSubtr["data_before"].GetMaximum():
histosSubtr["data_before"].GetYaxis().SetRangeUser(0.,histosSubtr["mc_before"].GetMaximum()+0.1*histosSubtr["mc_before"].GetMaximum())
histosSubtr["mc_before"].SetLineColor(2)
## This is the simple overlay of the normalized spectra
# c2.cd(1)
r.SetOwnership(c2, False)
c2_spectrum = c2.GetListOfPrimitives().FindObject("c2_1")
c2_ratio = c2.GetListOfPrimitives().FindObject("c2_2")
c2_spectrum.SetPad(0.+xOffset, (1 - spectrum_height)+yOffset, 1.+xOffset, 1.+yOffset)
c2_ratio.SetPad(0.+xOffset, 0.+yOffset, 1.+xOffset, ratio_height+yOffset)
c2_ratio.SetTopMargin(0)
c2_ratio.SetBottomMargin(0.2)
c2_spectrum.SetLeftMargin(0.12)
c2_spectrum.SetRightMargin(0.15)
c2_ratio.SetLeftMargin(0.12)
c2_ratio.SetRightMargin(0.15)
leg=0
leg = TLegend(0.10,0.75,0.40,0.90)
leg.SetHeader("Before corrections")
leg.SetFillColor(0)
leg.SetTextSize(0.06)
leg.AddEntry(histosSubtr["data_before"],"DATA")
leg.AddEntry(histosSubtr["mc_before"],"MC")
setHistoStyle(histosSubtr["data_before"])
setHistoStyle(histosSubtr["mc_before"])
histosSubtr["data_before"].SetTitle("Dimuon mass spectrum (after background subtraction) data vs. MC")
histosSubtr["data_before"].GetXaxis().SetTitle("M_{#mu#mu} (GeV)")
histosSubtr["data_before"].GetYaxis().SetTitle("Arbitrary units")
histosSubtr["mc_before"].GetXaxis().SetTitle("M_{#mu#mu} (GeV)")
histosSubtr["mc_before"].GetYaxis().SetTitle("Arbitrary units")
c2_spectrum.cd()
# c2_spectrum.SetLogy()
histosSubtr["data_before"].Draw("HIST")
histosSubtr["mc_before"].Draw("HISTsame")
tpt_pars_data = TPaveText(0.13, 0.45, 0.4, 0.59, "NDC")
tpt_pars_data.SetTextSize(0.045)
tpt_pars_data.SetTextFont(42)
tpt_pars_data.SetFillColor(0)
tpt_pars_data.SetBorderSize(0)
tpt_pars_data.SetMargin(0.01)
tpt_pars_data.SetTextAlign(12)
tpt_pars_data.AddText(0.0,0.9,"M^{fit}_{Z,data} = "+str(round(signalPars["data_before"][0],2))+" GeV")
tpt_pars_data.AddText(0.0,0.4,"#sigma_{CB,data} = "+str(round(signalPars["data_before"][3],2))+" GeV")
tpt_pars_data.Draw("same")
tpt_pars_mc = TPaveText(0.13, 0.30, 0.4, 0.44, "NDC")
tpt_pars_mc.SetTextSize(0.045)
tpt_pars_mc.SetTextFont(42)
tpt_pars_mc.SetFillColor(0)
tpt_pars_mc.SetBorderSize(0)
tpt_pars_mc.SetMargin(0.01)
tpt_pars_mc.SetTextAlign(12)
tpt_pars_mc.SetTextColor(2)
tpt_pars_mc.AddText(0.0,0.9,"M^{fit}_{Z,MC} = "+str(round(signalPars["mc_before"][0],2))+" GeV")
tpt_pars_mc.AddText(0.0,0.4,"#sigma_{CB,MC} = "+str(round(signalPars["mc_before"][3],2))+" GeV")
tpt_pars_mc.Draw("same")
leg.Draw("same")
# mean.setVal(signalPars["data_before"][0])
# sigma.setVal(signalPars["data_before"][3])
# alpha.setVal(signalPars["data_before"][4])
# N.setVal(signalPars["data_before"][5])
# dh_data = RooDataHist("dh_data","dh_data",RooArgList(x),histosSubtr["data_before"])
# frame_data = x.frame()
# dh_data.plotOn(frame_data,RooFit.LineColor(1),RooFit.DrawOption("B"))
# # relBWTimesCB.plotOn(frame_data,RooFit.LineColor(1))
# frame_data.Draw()
# mean.setVal(signalPars["mc_before"][0])
# # mean.setVal(97)
# sigma.setVal(signalPars["mc_before"][3])
# alpha.setVal(signalPars["mc_before"][4])
# N.setVal(signalPars["mc_before"][5])
# dh_mc = RooDataHist("dh_mc","dh_mc",RooArgList(x),histosSubtr["mc_before"])
# frame_mc = x.frame()
# # dh_mc.plotOn(frame_mc,RooFit.LineColor(2),RooFit.MarkerColor(2),RooFit.MarkerSize(0.4),RooFit.DrawOption("HIST"))
# # relBWTimesCB.plotOn(frame_mc,RooFit.LineColor(2))
# # frame_mc.Draw("same")
## Ratio histogram
h_Num_woBkg = histosSubtr["data_before"].Clone()
h_Den_woBkg = histosSubtr["mc_before"].Clone()
# h_Num_woBkg.Rebin(10)
# h_Den_woBkg.Rebin(10)
h_Num_woBkg.Divide(h_Den_woBkg)
h_Num_woBkg.GetXaxis().SetRangeUser(minM_fit,maxM_fit)
h_Num_woBkg.GetYaxis().SetRangeUser(minR,maxR)
h_Num_woBkg.GetXaxis().SetTitleSize(0.09)
h_Num_woBkg.GetYaxis().SetTitleSize(0.09)
h_Num_woBkg.GetXaxis().SetLabelSize(0.08)
h_Num_woBkg.GetYaxis().SetLabelSize(0.08)
h_Num_woBkg.GetYaxis().SetTitleOffset(0.45)
## This is the DATA/MC ratio
c2_ratio.cd()
h_Num_woBkg.GetYaxis().SetTitle("DATA/MC Ratio")
h_Num_woBkg.SetTitle("")
# setHistoStyle(h_Num_woBkg)
h_Num_woBkg.SetMarkerStyle(20)
h_Num_woBkg.SetMarkerSize(0.85)
h_Num_woBkg.Draw("E")
line.Draw("same")
c2.SaveAs(options.outDir+"/DimuonAfterBkgSub_beforeCorrections.png")
c2.SaveAs(options.outDir+"/DimuonAfterBkgSub_beforeCorrections.pdf")
c2.SaveAs(options.outDir+"/DimuonAfterBkgSub_beforeCorrections.eps")
del tpt_pars_data, tpt_pars_mc, h_Num_woBkg
# AFTER CORRECTIONS
# # RooFit definitions (again, sorry)
# ## RooRealVars
# x = RooRealVar("x","M_{#mu#mu} (GeV)",minM_fit,maxM_fit)
# mean = RooRealVar("mean","mean",91.19)
# meanCB = RooRealVar("meanCB","meanCB",0.)
# width = RooRealVar("width","width",2.4952)
# sigma = RooRealVar("sigma","sigma",1.3)
# alpha = RooRealVar("alpha","alpha",1.)
# N = RooRealVar("N","N",2.)
# ## PDFs (again, sorry)
# relBW = RooGenericPdf("relBW","relBW","@0/(pow(@0*@0-@1*@1,2) + @2*@2*@0*@0*@0*@0/(@1*@1))",RooArgList(x,mean,width))
# CB = RooCBShape("CB","CB",x,meanCB,sigma,alpha,N)
# relBWTimesCB = RooFFTConvPdf("relBWTimesCB","relBWTimesCB",x,relBW,CB)
# Ratio plot after background subtraction
histosSubtr["data_after"].GetXaxis().SetRangeUser(minM_fit,maxM_fit)
histosSubtr["data_after"].GetYaxis().SetRangeUser(0.,histosSubtr["data_after"].GetMaximum()+0.1*histosSubtr["data_after"].GetMaximum())
histosSubtr["data_after"].SetLineColor(1)
histosSubtr["mc_after"].GetXaxis().SetRangeUser(minM_fit,maxM_fit)
if histosSubtr["mc_after"].GetMaximum()>histosSubtr["data_after"].GetMaximum():
histosSubtr["data_after"].GetYaxis().SetRangeUser(0.,histosSubtr["mc_after"].GetMaximum()+0.1*histosSubtr["mc_after"].GetMaximum())
histosSubtr["mc_after"].SetLineColor(2)
## This is the simple overlay of the normalized spectra
# c3.cd(1)
r.SetOwnership(c3, False)
c3_spectrum = c3.GetListOfPrimitives().FindObject("c3_1")
c3_ratio = c3.GetListOfPrimitives().FindObject("c3_2")
c3_spectrum.SetPad(0.+xOffset, (1 - spectrum_height)+yOffset, 1.+xOffset, 1.+yOffset)
c3_ratio.SetPad(0.+xOffset, 0.+yOffset, 1.+xOffset, ratio_height+yOffset)
c3_ratio.SetTopMargin(0)
c3_ratio.SetBottomMargin(0.2)
c3_spectrum.SetLeftMargin(0.12)
c3_spectrum.SetRightMargin(0.15)
c3_ratio.SetLeftMargin(0.12)
c3_ratio.SetRightMargin(0.15)
leg=0
leg = TLegend(0.10,0.75,0.40,0.90)
leg.SetHeader("After corrections")
leg.SetFillColor(0)
leg.SetTextSize(0.06)
leg.AddEntry(histosSubtr["data_after"],"DATA")
leg.AddEntry(histosSubtr["mc_after"],"MC")
setHistoStyle(histosSubtr["data_after"])
setHistoStyle(histosSubtr["mc_after"])
histosSubtr["data_after"].SetTitle("Dimuon mass spectrum (after background subtraction) data vs. MC")
histosSubtr["data_after"].GetXaxis().SetTitle("M_{#mu#mu} (GeV)")
histosSubtr["data_after"].GetYaxis().SetTitle("Arbitrary units")
histosSubtr["mc_after"].GetXaxis().SetTitle("M_{#mu#mu} (GeV)")
histosSubtr["mc_after"].GetYaxis().SetTitle("Arbitrary units")
c3_spectrum.cd()
# c3_spectrum.SetLogy()
histosSubtr["data_after"].Draw("HIST")
histosSubtr["mc_after"].Draw("HISTsame")
tpt_pars_data = 0
tpt_pars_data = TPaveText(0.13, 0.45, 0.4, 0.59, "NDC")
tpt_pars_data.SetTextSize(0.045)
tpt_pars_data.SetTextFont(42)
tpt_pars_data.SetFillColor(0)
tpt_pars_data.SetBorderSize(0)
tpt_pars_data.SetMargin(0.01)
tpt_pars_data.SetTextAlign(12)
tpt_pars_data.AddText(0.0,0.9,"M^{fit}_{Z,data} = "+str(round(signalPars["data_after"][0],2))+" GeV")
tpt_pars_data.AddText(0.0,0.4,"#sigma_{CB,data} = "+str(round(signalPars["data_after"][3],2))+" GeV")
tpt_pars_data.Draw("same")
tpt_pars_mc = 0
tpt_pars_mc = TPaveText(0.13, 0.30, 0.4, 0.44, "NDC")
tpt_pars_mc.SetTextSize(0.045)
tpt_pars_mc.SetTextFont(42)
tpt_pars_mc.SetFillColor(0)
tpt_pars_mc.SetBorderSize(0)
tpt_pars_mc.SetMargin(0.01)
tpt_pars_mc.SetTextAlign(12)
tpt_pars_mc.SetTextColor(2)
tpt_pars_mc.AddText(0.0,0.9,"M^{fit}_{Z,MC} = "+str(round(signalPars["mc_after"][0],2))+" GeV")
tpt_pars_mc.AddText(0.0,0.4,"#sigma_{CB,MC} = "+str(round(signalPars["mc_after"][3],2))+" GeV")
tpt_pars_mc.Draw("same")
leg.Draw("same")
# mean.setVal(signalPars["data_after"][0])
# sigma.setVal(signalPars["data_after"][3])
# alpha.setVal(signalPars["data_after"][4])
# N.setVal(signalPars["data_after"][5])
# dh_data = RooDataHist("dh_data","dh_data",RooArgList(x),histosSubtr["data_after"])
# frame_data = x.frame()
# dh_data.plotOn(frame_data,RooFit.LineColor(1),RooFit.DrawOption("B"))
# # relBWTimesCB.plotOn(frame_data,RooFit.LineColor(1))
# frame_data.Draw()
# mean.setVal(signalPars["mc_after"][0])
# # mean.setVal(97)
# sigma.setVal(signalPars["mc_after"][3])
# alpha.setVal(signalPars["mc_after"][4])
# N.setVal(signalPars["mc_after"][5])
# dh_mc = RooDataHist("dh_mc","dh_mc",RooArgList(x),histosSubtr["mc_after"])
# frame_mc = x.frame()
# # dh_mc.plotOn(frame_mc,RooFit.LineColor(2),RooFit.MarkerColor(2),RooFit.MarkerSize(0.4),RooFit.DrawOption("HIST"))
# # relBWTimesCB.plotOn(frame_mc,RooFit.LineColor(2))
# # frame_mc.Draw("same")
## Ratio histogram
h_Num_woBkg = histosSubtr["data_after"].Clone()
h_Den_woBkg = histosSubtr["mc_after"].Clone()
# h_Num_woBkg.Rebin(10)
# h_Den_woBkg.Rebin(10)
h_Num_woBkg.Divide(h_Den_woBkg)
h_Num_woBkg.GetXaxis().SetRangeUser(minM_fit,maxM_fit)
h_Num_woBkg.GetYaxis().SetRangeUser(minR,maxR)
h_Num_woBkg.GetXaxis().SetTitleSize(0.09)
h_Num_woBkg.GetYaxis().SetTitleSize(0.09)
h_Num_woBkg.GetXaxis().SetLabelSize(0.08)
h_Num_woBkg.GetYaxis().SetLabelSize(0.08)
h_Num_woBkg.GetYaxis().SetTitleOffset(0.45)
## This is the DATA/MC ratio
c3_ratio.cd()
h_Num_woBkg.GetYaxis().SetTitle("DATA/MC Ratio")
h_Num_woBkg.SetTitle("")
# setHistoStyle(h_Num_woBkg)
h_Num_woBkg.SetMarkerStyle(20)
h_Num_woBkg.SetMarkerSize(0.85)
h_Num_woBkg.Draw("E")
line.Draw("same")
c3.SaveAs(options.outDir+"/DimuonAfterBkgSub_afterCorrections.png")
c3.SaveAs(options.outDir+"/DimuonAfterBkgSub_afterCorrections.pdf")
c3.SaveAs(options.outDir+"/DimuonAfterBkgSub_afterCorrections.eps")
def fitChicSpectrum(dataset, binname):
""" Fit chic spectrum"""
x = RooRealVar('s', 's', -2, 2)
x.setBins(200)
#signal model
q_chi1 = RooRealVar('qchi1', 'q_{#chi 1}', 0.414, 0.2, 0.6)
q_chi2 = RooRealVar('qchi2', 'q_{#chi 2}', 0.430, 0.2, 0.6)
delta_chi10 = RooRealVar('delta_chi10', 'delta_chi10', 0.09591)
q_chi0 = RooFormulaVar('q_chi0', '@0 - @1',
RooArgList(q_chi1, delta_chi10))
alphacb_chi1 = RooRealVar('alphacb_chi1', '#alpha^{CB}_{#chi 1}', 0.6, 0,
2)
alphacb_chi2 = RooRealVar('alphacb_chi2', '#alpha^{CB}_{#chi 2}', 0.4, 0,
2)
sigmacb_chi1 = RooRealVar('sigmacb_chi1', '#sigma^{CB}_{#chi 1}', 0.005, 0,
1)
sigmacb_chi2 = RooRealVar('sigmacb_chi2', '#sigma^{CB}_{#chi 2}', 0.005, 0,
1)
n_cb = RooRealVar('ncb', 'n^{CB}', 3.0, 0., 5.)
gamma_chi0 = RooRealVar('gamma_chi0', 'gamma_chi0', 0.0104)
sigmacb_chi0 = RooRealVar('sigmacb_chi0', '#sigma^{CB}_{#chi 0}', 0.005)
chi0_sig = RooVoigtian('chi0sig', 'chi0sig,', x, q_chi0, sigmacb_chi0,
gamma_chi0)
chi1_sig = RooCBShape('chi1sig', 'chi1sig', x, q_chi1, sigmacb_chi1,
alphacb_chi1, n_cb)
chi2_sig = RooCBShape('chi2sig', 'chi2sig', x, q_chi2, sigmacb_chi2,
alphacb_chi2, n_cb)
fchi0 = RooRealVar('fchi0', 'f_{#chi 0}', 0.01, 0, 1)
fchi1 = RooRealVar('fchi1', 'f_{#chi 1}', 0.5, 0, 1)
fchi2 = RooFormulaVar('fchi2', '1-@0-@1', RooArgList(fchi0, fchi1))
fbck = RooRealVar('fbck', 'f_{bck}', 0.2, 0, 1)
sigmodel = RooAddPdf('sigm', 'sigm',
RooArgList(chi0_sig, chi1_sig, chi2_sig),
RooArgList(fchi0, fchi1, fchi2))
#background model
q0Start = 0.0
a_bck = RooRealVar('a_bck', 'a_{bck}', 0.5, -5, 5)
b_bck = RooRealVar('b_bck', 'b_{bck}', -2.5, -7., 0.)
q0 = RooRealVar('q0', 'q0', q0Start)
delta = RooFormulaVar('delta', 'TMath::Abs(@0-@1)', RooArgList(x, q0))
bfun = RooFormulaVar('bfun', '@0*(@1-@2)', RooArgList(b_bck, x, q0))
signum = RooFormulaVar('signum', '( TMath::Sign( -1.,@0-@1 )+1 )/2.',
RooArgList(x, q0))
background = RooGenericPdf('background', 'Background',
'signum*pow(delta,a_bck)*exp(bfun)',
RooArgList(signum, delta, a_bck, bfun))
modelPdf = RooAddPdf('chicmodel', 'chicmodel',
RooArgList(sigmodel, background), RooArgList(fbck))
frame = x.frame(RooFit.Title('Q'))
range = x.setRange('range', 0, 2)
# result = modelPdf.fitTo(dataset,RooFit.Save(),RooFit.Range('range'))
dataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
#plotting
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
canvas.SaveAs('out-' + binname + '.png')
canvas.SaveAs('out-' + binname + '.root')
#nk1 = model3.createNLL(data)
#RooMinuit(nk1).migrad()
#Rk1 = k2.frame()
#nk1.plotOn(Rk1,RooFit.ShiftToZero())
#cRcc = TCanvas("Rcc", "Rcc", 500, 500)
#Rk1.SetMaximum(4.);Rk1.SetMinimum(0)
#Rk1.GetXaxis().SetTitle("nttbar/nmc")
#Rk1.SetTitle("")
#Rk1.Draw()
cR11 = TCanvas("R11", "R", 500, 500)
xframe = x.frame()
data.plotOn(xframe, RooFit.DataError(RooAbsData.SumW2))
model3.paramOn(xframe, RooFit.Layout(0.65, 0.9, 0.9))
model3.plotOn(xframe)
chi2 = xframe.chiSquare(2)
ndof = xframe.GetNbinsX()
print "chi2 = " + str(chi2)
print "ndof = " + str(ndof)
xframe.Draw()
print "k1:" + str(k1.getVal()) + ", err:" + str(
k1.getError()) + ", init:" + str(rttbar)
print "k2:" + str(k2.getVal()) + ", err:" + str(k2.getError())
n_mctotal = n_ttbar + n_background
print "####################"
print "ttbar = " + str(n_ttbar)
print "wjets = " + str(n_wjets)
# In[10]:
tot.fitTo(dh)
# In[11]:
massFrame = mass.frame()
massFrame.SetTitle("Phi signal")
dh.plotOn(massFrame)
tot.plotOn(massFrame)
gauss.plotOn(massFrame,LineColor(kGreen),LineStyle(kDashed),Normalization((sFrac.getValV()*numEvts)/(numEvts)))
cheb.plotOn(massFrame,LineColor(kMagenta),LineStyle(kDotted),Normalization(((1.0-sFrac.getValV())*numEvts)/(numEvts)))
tot.paramOn(massFrame,Layout(0.60,0.99,0.75));
massFrame.Draw()
# In[12]:
plotmax = hist.GetMaximum()*1.05
sidesigma = sigma.getValV()
leftlowside = -7.*sidesigma + mean.getValV()
leftupside = -5.*sidesigma + mean.getValV()
rightlowside = +5.*sidesigma + mean.getValV()
rightupside = +7.*sidesigma + mean.getValV()
signallow = -3.*sidesigma + mean.getValV()
signalup = +3.*sidesigma + mean.getValV()
print 'Calculate sWeights'
## fit the model to the data.
r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(),
RooFit.Range(lowRange, highRange))
frame = theBMass.frame()
data.plotOn(frame, RooFit.Binning(50), RooFit.MarkerSize(.5))
fitFunction.plotOn(frame, )
fitFunction.plotOn(frame, RooFit.Components("bkg_exp"),
RooFit.LineStyle(ROOT.kDashed))
fitFunction.plotOn(frame, RooFit.Components("signalCB"),
RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kOrange + 1))
fitFunction.paramOn(frame, RooFit.Layout(0.62, 0.86, 0.88))
frame.SetTitle('')
frame.GetYaxis().SetTitleOffset(1.35)
frame.getAttText().SetTextSize(0.022)
frame.getAttText().SetTextFont(42)
frame.getAttLine().SetLineColor(0)
c1 = ROOT.TCanvas()
frame.Draw()
c1.SaveAs('fitLMNRKstar_forSplot.pdf')
print 'sigma: ', sigma.getVal()
print 'nsig: ', nsig.getVal()
print 'nbkg: ', nbkg.getVal()
# ROOT.RooMsgService.instance().setSilentMode(True)
def dofit(roodataset, hname):
x = RooRealVar("ups_mass", "m_{#mu #mu}", 8.5, 11.0)
# choose here binning of mass plot
x.setBins(250)
# model signal
# one CB for each Y(nS) or sum of two CB for each Y(nS)
# CB parameters
mass1S = RooRealVar('mass1S', 'mass1S', 9.4603, 9.400, 9.500)
mass2S = RooRealVar('mass2S', 'mass2S', 10.022, 10.000, 10.040)
mass3S = RooRealVar('mass3S', 'mass3S', 10.3552, 10.300, 10.370)
sigma1S_1 = RooRealVar('sigma1S_1', 'sigma1S_1', 0.080, 0.010, 0.100)
sigma1S_2 = RooRealVar('sigma1S_2', 'sigma1S_2', 0.085, 0.010, 0.100)
sigma2S_1 = RooRealVar('sigma2S_1', 'sigma2S_1', 0.085, 0.020, 0.100)
sigma2S_2 = RooRealVar('sigma2S_2', 'sigma2S_2', 0.090, 0.020, 0.100)
sigma3S_1 = RooRealVar('sigma3S_1', 'sigma3S_1', 0.090, 0.020, 0.100)
sigma3S_2 = RooRealVar('sigma3S_2', 'sigma3S_2', 0.095, 0.020, 0.100)
alpha = RooRealVar('alpha', 'alpha', 0.5, 0, 5)
n = RooRealVar('n', 'n', 0.5, 0, 5) # fix n
#signal model
cb1S_1 = RooCBShape('y1S_1', 'y1S_1', x, mass1S, sigma1S_1, alpha, n)
cb1S_2 = RooCBShape('y1S_2', 'y1S_2', x, mass1S, sigma1S_2, alpha, n)
cb2S_1 = RooCBShape('y2S_1', 'y2S_1', x, mass2S, sigma2S_1, alpha, n)
cb2S_2 = RooCBShape('y2S_2', 'y2S_2', x, mass2S, sigma2S_2, alpha, n)
cb3S_1 = RooCBShape('y3S_1', 'y3S_1', x, mass3S, sigma3S_1, alpha, n)
cb3S_2 = RooCBShape('y3S_2', 'y3S_2', x, mass3S, sigma3S_2, alpha, n)
cb1frac1S = RooRealVar("cb1frac1S", "cc", 0.1, 0., 1.)
cb1frac2S = RooRealVar("cb1frac2S", "cc", 0.1, 0., 1.)
cb1frac3S = RooRealVar("cb1frac3S", "cc", 0.1, 0., 1.)
# sum of two CB
sig1S = RooAddPdf("sig1S", "Signal1S", RooArgList(cb1S_1, cb1S_2),
RooArgList(cb1frac1S))
sig2S = RooAddPdf("sig2S", "Signal2S", RooArgList(cb2S_1, cb2S_2),
RooArgList(cb1frac2S))
sig3S = RooAddPdf("sig3S", "Signal3S", RooArgList(cb3S_1, cb3S_2),
RooArgList(cb1frac3S))
#background model
c1 = RooRealVar('c1', 'c1', 200, 0, 3000000)
c2 = RooRealVar('c2', 'c2', -1, -50, 50)
background = RooPolynomial('bkg', 'bkg', x, RooArgList(c1, c2))
# complete model
n1S = RooRealVar('n1s', '', 100000, 0, 10000000)
n2S = RooRealVar('n2s', '', 100000, 0, 10000000)
n3S = RooRealVar('n3s', '', 100000, 0, 10000000)
nbck = RooRealVar('nbck', '', 100000, 0, 10000000)
# sum of two CB for each Y(nS)
modelPdf = RooAddPdf('model', 'model',
RooArgList(sig1S, sig2S, sig3S, background),
RooArgList(n1S, n2S, n3S, nbck))
# or one CB for each Y(nS)
#modelPdf = RooAddPdf('model','model',RooArgList(cb1S_1,cb2S_1,cb3S_1,background),RooArgList(n1S,n2S,n3S,nbck))
rcut = x.setRange('rcut', 8.5, 11.0)
result = modelPdf.fitTo(roodataset, RooFit.Save(), RooFit.Range('rcut'))
frame = x.frame(RooFit.Title('mass'))
roodataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
#plotting
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
canvas.SaveAs(str(hname) + '.png')
RooFit.Range(4.9, 5.6))
# r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save())#, RooFit.Range(B0Mass_-0.28, B0Mass_+0.28))
frame = theBMass.frame()
data.plotOn(frame, RooFit.Binning(75), RooFit.MarkerSize(.5))
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))
parList = RooArgSet(nsig, sigma, 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))
frame.GetYaxis().SetTitleOffset(1.35)
frame.getAttText().SetTextSize(0.022)
frame.getAttText().SetTextFont(42)
frame.getAttLine().SetLineColor(0)
c1 = ROOT.TCanvas()
frame.Draw()
c1.SaveAs('save_fit.pdf')
# if args.doubleg==1:
# resSigma1 = sigma.getVal()
# resSigma2 = sigma2.getVal()
# resF = f1.getVal()
#
splotData.plotOn(phiFrame) ratio = 1.0 / float(nfits) tot.plotOn(phiFrame, Normalization(ratio)) bFrac = (nBkg.getValV()) / (nSig.getValV() + nBkg.getValV()) bkg.plotOn(phiFrame, LineColor(kRed), Normalization(bFrac), LineStyle(kDashed)) signal.plotOn(phiFrame, LineColor(kGreen), Normalization(1.0 - bFrac)) a0.setConstant(True) a1.setConstant(True) a2.setConstant(True) a3.setConstant(True) a4.setConstant(True) nBkg.setConstant(True) tot.paramOn(phiFrame, RooFit.Layout(0.65, 0.99, 0.4)) phiFrame.Draw() plotmax = 1.5 * float(nentries / binning) lowside = -3. * sigma.getValV() + mean.getValV() upside = +3. * sigma.getValV() + mean.getValV() linelow = TLine(lowside, 0.0, lowside, plotmax * 1.2) lineup = TLine(upside, 0.0, upside, plotmax * 1.2) linelow.SetLineColor(kGreen) lineup.SetLineColor(kGreen) linelow.SetLineWidth(2) lineup.SetLineWidth(2) linelow.Draw()
kkFrame = tt_mass.frame(Range(fitphimin + 0.005, fitphimax - 0.005))
leftlowside_kk = -6. * sigmaside_kk + kkMean.getValV()
leftupside_kk = -4. * sigmaside_kk + kkMean.getValV()
rightlowside_kk = +4. * sigmaside_kk + kkMean.getValV()
rightupside_kk = +6. * sigmaside_kk + kkMean.getValV()
signallow = -3. * sigmaside_kk + kkMean.getValV()
signalup = +3. * sigmaside_kk + kkMean.getValV()
trakData.plotOn(kkFrame)
kkTot.plotOn(kkFrame, RooFit.Normalization(1.0 / float(nfit)))
traKFitData.plotOn(kkFrame)
kkTot.paramOn(kkFrame, RooFit.Layout(0.57, 0.99, 0.65))
kkFrame.Draw()
c.SaveAs("kk_Phi_fit.png")
c.SaveAs("kk_Phi_fit.root")
if args.nofitkk and args.notrig:
##L3
kkSigma = RooRealVar("#sigma", "#sigma", 0.0013)
kkGamma = RooRealVar("#Gamma", "#Gamma", gammavalue, 0.001, 0.01)
kkMean = RooRealVar("mean", "mean", phimean, phimean - 0.007,
phimean + 0.007)
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 fit_gau2_che(var, dataset, title='', print_pars=False, test=False,
mean_=None, sigma_=None, sigma1_=None, sigmaFraction_=None):
# define background
c0 = RooRealVar('c0', 'constant', 0.1, -1, 1)
c1 = RooRealVar('c1', 'linear', 0.6, -1, 1)
c2 = RooRealVar('c2', 'quadratic', 0.1, -1, 1)
c3 = RooRealVar('c3', 'c3', 0.1, -1, 1)
bkg = RooChebychev('bkg', 'background pdf', var,
RooArgList(c0, c1, c2, c3))
# define signal
val = 5.28
dmean = 0.05
valL = val - dmean
valR = val + dmean
if mean_ is None:
mean = RooRealVar("mean", "mean", val, valL, valR)
else:
mean = RooRealVar("mean", "mean", mean_)
val = 0.05
dmean = 0.02
valL = val - dmean
valR = val + dmean
if sigma_ is None:
sigma = RooRealVar('sigma', 'sigma', val, valL, valR)
else:
sigma = RooRealVar('sigma', 'sigma', sigma_)
if sigma1_ is None:
sigma1 = RooRealVar('sigma1', 'sigma1', val, valL, valR)
else:
sigma1 = RooRealVar('sigma1', 'sigma1', sigma1_)
peakGaus = RooGaussian("peakGaus", "peakGaus", var, mean, sigma)
peakGaus1 = RooGaussian("peakGaus1", "peakGaus1", var, mean, sigma1)
if sigmaFraction_ is None:
sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", 0.5, 0., 1.)
else:
sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", sigmaFraction_)
glist = RooArgList(peakGaus, peakGaus1)
peakG = RooAddPdf("peakG","peakG", glist, RooArgList(sigmaFraction))
listPeak = RooArgList("listPeak")
listPeak.add(peakG)
listPeak.add(bkg)
fbkg = 0.45
nEntries = dataset.numEntries()
val=(1-fbkg)* nEntries
listArea = RooArgList("listArea")
areaPeak = RooRealVar("areaPeak", "areaPeak", val, 0.,nEntries)
listArea.add(areaPeak)
nBkg = fbkg*nEntries
areaBkg = RooRealVar("areaBkg","areaBkg", nBkg, 0.,nEntries)
listArea.add(areaBkg)
model = RooAddPdf("model", "fit model", listPeak, listArea)
if not test:
fitres = model.fitTo(dataset, RooFit.Extended(kTRUE),
RooFit.Minos(kTRUE),RooFit.Save(kTRUE))
nbins = 35
frame = var.frame(nbins)
frame.GetXaxis().SetTitle("B^{0} mass (GeV/c^{2})")
frame.GetXaxis().CenterTitle()
frame.GetYaxis().CenterTitle()
frame.SetTitle(title)
mk_size = RooFit.MarkerSize(0.3)
mk_style = RooFit.MarkerStyle(kFullCircle)
dataset.plotOn(frame, mk_size, mk_style)
model.plotOn(frame)
as_bkg = RooArgSet(bkg)
cp_bkg = RooFit.Components(as_bkg)
line_style = RooFit.LineStyle(kDashed)
model.plotOn(frame, cp_bkg, line_style)
if print_pars:
fmt = RooFit.Format('NEU')
lyt = RooFit.Layout(0.65, 0.95, 0.92)
param = model.paramOn(frame, fmt, lyt)
param.getAttText().SetTextSize(0.02)
param.getAttText().SetTextFont(60)
frame.Draw()
pars = [areaBkg, areaPeak, c0, c1, c2, c3, mean, sigma, sigma1, sigmaFraction]
return pars
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 fitChicSpectrum(dataset,binname):
""" Fit chic spectrum"""
x = RooRealVar('Qvalue','Q',9.7,10.1)
x.setBins(80)
mean_1 = RooRealVar("mean_1","mean ChiB1",9.892,9,10,"GeV")
sigma_1 = RooRealVar("sigma_1","sigma ChiB1",0.0058,'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', 0.748)
n1_1 = RooRealVar('n1_1', 'n1_1',2.8 )
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1',1.739)
n2_1 = RooRealVar('n2_1', 'n2_1', 3.0)
deltam = RooRealVar('deltam','deltam',0.01943)
mean_2 = RooFormulaVar("mean_2","@0+@1", RooArgList(mean_1,deltam))
sigma_2 = RooRealVar("sigma_2","sigma ChiB2",0.0059,'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', 0.738)
n1_2 = RooRealVar('n1_2', 'n1_2', 2.8)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', 1.699)
n2_2 = RooRealVar('n2_2', 'n2_2', 3.0)
parameters=RooArgSet()
parameters.add(RooArgSet(sigma_1, sigma_2))
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
parameters.add(RooArgSet( a1_2, a2_2, n1_2, n2_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2)
#background
q01S_Start = 9.5
alpha = RooRealVar("#alpha","#alpha",1.5,-1,3.5)#0.2 anziche' 1
beta = RooRealVar("#beta","#beta",-2.5,-7.,0.)
q0 = RooRealVar("q0","q0",q01S_Start)#,9.5,9.7)
delta = RooFormulaVar("delta","TMath::Abs(@0-@1)",RooArgList(x,q0))
b1 = RooFormulaVar("b1","@0*(@1-@2)",RooArgList(beta,x,q0))
signum1 = RooFormulaVar( "signum1","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q0) )
background = RooGenericPdf("background","Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1,delta,alpha,b1) )
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf,chib2_pdf,background)
n_chib = RooRealVar("n_chib","n_chib",2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21","ratio_21",0.5,0,1)
n_chib1 = RooFormulaVar("n_chib1","@0/(1+@1)",RooArgList(n_chib, ratio_21))
n_chib2 = RooFormulaVar("n_chib2","@0/(1+1/@1)",RooArgList(n_chib, ratio_21))
n_background = RooRealVar('n_background','n_background',4550, 0, 50000)
ratio_list = RooArgList(n_chib1, n_chib2, n_background)
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
frame = x.frame(RooFit.Title('m'))
range = x.setRange('range',9.7,10.1)
result = modelPdf.fitTo(dataset,RooFit.Save(),RooFit.Range('range'))
dataset.plotOn(frame,RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(2) )
#plotting
canvas = TCanvas('fit', "", 1400, 700 )
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
modelPdf.paramOn(frame, RooFit.Layout(0.725,0.9875,0.9))
frame.Draw()
canvas.SaveAs( 'out-'+binname + '.png' )
def dofit(roodataset, hname):
mass_chib = 10.5103 # from PES uncorrected mass measurement
deltaM = 0.0105 # MeV theoretical expectations
ratio21 = 0.45 # same as chic2/chic1 and chib2/chib1
# the following numbers are from an old 3P gun simulation
# that needs to be re-done
sigma1 = 0.003#0.0031
sigma2 = 0.003#0.0035
alpha1 = 0.95
alpha2 = 1.12
n = 2.5
mass1_v = RooRealVar('mchi1','m_{#chi1}',mass_chib)
deltaM_v = RooRealVar('deltaM','#Delta_{m}',deltaM,0.005,0.015)
mass2_v = RooFormulaVar('mchi2','@0+@1',RooArgList(mass1_v,deltaM_v))
sigma1_v = RooRealVar('sigma1','#sigma_1',sigma1)
sigma2_v = RooRealVar('sigma2','#sigma_2',sigma2)
alpha1_v = RooRealVar('alpha1','#alpha_1',alpha1)
alpha2_v = RooRealVar('alpha2','#alpha_2',alpha2)
n_v = RooRealVar('n','n',n)
ratio21_v = RooRealVar('ratio21','r_{21}',ratio21)
x = RooRealVar("invm3S","#chi_{b} Data",10.4,10.7)
# choose here binning of mass plot
x.setBins(150)
#signal pdf
chib1 = RooCBShape('chib1','chib1',x,mass1_v,sigma1_v,alpha1_v,n_v)
chib2 = RooCBShape('chib2','chib2',x,mass2_v,sigma2_v,alpha2_v,n_v)
# define background
q01S_Start = 10.4
alpha = RooRealVar("#alpha","#alpha",1.5,0.2,3.5)
beta = RooRealVar("#beta","#beta",-2.5,-7.,0.)
#q0 = RooRealVar("q0","q0",q01S_Start,q01S_Start-0.05,q01S_Start+0.05)
q0 = RooRealVar("q0","q0",q01S_Start)
delta = RooFormulaVar("delta","TMath::Abs(@0-@1)",RooArgList(x,q0))
b1 = RooFormulaVar("b1","@0*(@1-@2)",RooArgList(beta,x,q0))
signum1 = RooFormulaVar( "signum1","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q0) )
background = RooGenericPdf("background","Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1,delta,alpha,b1) )
n_evts_1 = RooRealVar('N_{3P_{1}}','N_{3P_{1}}',50,30,1000)
n_evts_2 = RooFormulaVar('N_{3P_{2}}','@0*@1',RooArgList(n_evts_1,ratio21_v))
n_bck = RooRealVar('nbkg','n_{bkg}',500,0,100000)
#build final pdf
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', RooArgList(chib1,chib2,background),RooArgList(n_evts_1,n_evts_2,n_bck))
# fit
low_cut = x.setRange("low_cut",10.4,10.7)
result = modelPdf.fitTo(roodataset, RooFit.Save(), RooFit.Range("low_cut") )
frame = x.frame(RooFit.Title("m(#chi_{b}(3P))"))
roodataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(1))
modelPdf.plotOn(frame, RooFit.LineWidth(2) )
frame.GetXaxis().SetTitle('m_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon(3S)} [GeV/c^{2}]' )
#frame.GetYaxis().SetTitle( "Events/15.0 MeV " )
frame.GetXaxis().SetTitleSize(0.04)
frame.GetYaxis().SetTitleSize(0.04)
frame.GetXaxis().SetTitleOffset(1.1)
frame.GetXaxis().SetLabelSize(0.04)
frame.GetYaxis().SetLabelSize(0.04)
frame.SetLineWidth(1)
frame.SetName("fit_resonance")
chi2 = frame.chiSquare()
chi2 = round(chi2,2)
leg=TLegend(0.50,0.7,0.60,0.8)
leg.AddEntry(0,'#chi^{2} ='+str(chi2),'')
leg.SetBorderSize(0)
leg.SetFillColor(0)
leg.SetTextSize(0.06)
gROOT.SetStyle("Plain")
frame.SaveAs(str(hname) + '.root')
# param_set = RooArgSet(n_evts_Roo4, m_chib[1][3],alpha, beta, q0)
canvas = TCanvas('fit', "", 1400, 700 )
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
# modelPdf.paramOn(frame, RooFit.Layout(0.725,0.9875,0.9), RooFit.Parameters(param_set))
modelPdf.paramOn(frame, RooFit.Layout(0.725,0.9875,0.9))
frame.Draw()
leg.Draw("same")
canvas.SaveAs( str(hname) + '.png' )
def dofit(roodataset, hname):
mass_chib = 10.5103 # from PES uncorrected mass measurement
deltaM = 0.0105 # MeV theoretical expectations
ratio21 = 0.45 # same as chic2/chic1 and chib2/chib1
# the following numbers are from an old 3P gun simulation
# that needs to be re-done
sigma1 = 0.003 #0.0031
sigma2 = 0.003 #0.0035
alpha1 = 0.95
alpha2 = 1.12
n = 2.5
mass1_v = RooRealVar('mchi1', 'm_{#chi1}', mass_chib)
deltaM_v = RooRealVar('deltaM', '#Delta_{m}', deltaM, 0.005, 0.015)
mass2_v = RooFormulaVar('mchi2', '@0+@1', RooArgList(mass1_v, deltaM_v))
sigma1_v = RooRealVar('sigma1', '#sigma_1', sigma1)
sigma2_v = RooRealVar('sigma2', '#sigma_2', sigma2)
alpha1_v = RooRealVar('alpha1', '#alpha_1', alpha1)
alpha2_v = RooRealVar('alpha2', '#alpha_2', alpha2)
n_v = RooRealVar('n', 'n', n)
ratio21_v = RooRealVar('ratio21', 'r_{21}', ratio21)
x = RooRealVar("invm3S", "#chi_{b} Data", 10.4, 10.7)
# choose here binning of mass plot
x.setBins(150)
#signal pdf
chib1 = RooCBShape('chib1', 'chib1', x, mass1_v, sigma1_v, alpha1_v, n_v)
chib2 = RooCBShape('chib2', 'chib2', x, mass2_v, sigma2_v, alpha2_v, n_v)
# define background
q01S_Start = 10.4
alpha = RooRealVar("#alpha", "#alpha", 1.5, 0.2, 3.5)
beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.)
#q0 = RooRealVar("q0","q0",q01S_Start,q01S_Start-0.05,q01S_Start+0.05)
q0 = RooRealVar("q0", "q0", q01S_Start)
delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0))
b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0))
signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.",
RooArgList(x, q0))
background = RooGenericPdf("background", "Background",
"signum1*pow(delta,#alpha)*exp(b1)",
RooArgList(signum1, delta, alpha, b1))
n_evts_1 = RooRealVar('N_{3P_{1}}', 'N_{3P_{1}}', 50, 30, 1000)
n_evts_2 = RooFormulaVar('N_{3P_{2}}', '@0*@1',
RooArgList(n_evts_1, ratio21_v))
n_bck = RooRealVar('nbkg', 'n_{bkg}', 500, 0, 100000)
#build final pdf
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf',
RooArgList(chib1, chib2, background),
RooArgList(n_evts_1, n_evts_2, n_bck))
# fit
low_cut = x.setRange("low_cut", 10.4, 10.7)
result = modelPdf.fitTo(roodataset, RooFit.Save(), RooFit.Range("low_cut"))
frame = x.frame(RooFit.Title("m(#chi_{b}(3P))"))
roodataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(1))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
frame.GetXaxis().SetTitle(
'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon(3S)} [GeV/c^{2}]'
)
#frame.GetYaxis().SetTitle( "Events/15.0 MeV " )
frame.GetXaxis().SetTitleSize(0.04)
frame.GetYaxis().SetTitleSize(0.04)
frame.GetXaxis().SetTitleOffset(1.1)
frame.GetXaxis().SetLabelSize(0.04)
frame.GetYaxis().SetLabelSize(0.04)
frame.SetLineWidth(1)
frame.SetName("fit_resonance")
chi2 = frame.chiSquare()
chi2 = round(chi2, 2)
leg = TLegend(0.50, 0.7, 0.60, 0.8)
leg.AddEntry(0, '#chi^{2} =' + str(chi2), '')
leg.SetBorderSize(0)
leg.SetFillColor(0)
leg.SetTextSize(0.06)
gROOT.SetStyle("Plain")
frame.SaveAs(str(hname) + '.root')
# param_set = RooArgSet(n_evts_Roo4, m_chib[1][3],alpha, beta, q0)
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
# modelPdf.paramOn(frame, RooFit.Layout(0.725,0.9875,0.9), RooFit.Parameters(param_set))
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
leg.Draw("same")
canvas.SaveAs(str(hname) + '.png')
splotData.plotOn(phiFrame) ratio = 1.0/float(nfits) tot.plotOn(phiFrame,Normalization(ratio)) bFrac = (nBkg.getValV())/(nSig.getValV() + nBkg.getValV()) bkg.plotOn(phiFrame,LineColor(kRed),Normalization(bFrac),LineStyle(kDashed)) signal.plotOn(phiFrame,LineColor(kGreen),Normalization(1.0-bFrac)) a0.setConstant(True) a1.setConstant(True) a2.setConstant(True) a3.setConstant(True) a4.setConstant(True) nBkg.setConstant(True) tot.paramOn(phiFrame,RooFit.Layout(0.57,0.99,0.65)) phiFrame.Draw() sidesigma = np.sqrt((rFrac.getValV())*sigma_1.getValV()**2 + (1.0 - (rFrac.getValV()))*sigma_2.getValV()**2) plotmax = 1.5 * float(nentries/binning) lowside = -3.*sidesigma + mean.getValV() upside = +3.*sidesigma + mean.getValV() linelow = TLine(lowside,0.0,lowside,plotmax) lineup = TLine(upside,0.0,upside,plotmax) linelow.SetLineColor(kGreen) lineup.SetLineColor(kGreen) linelow.SetLineWidth(2) lineup.SetLineWidth(2)
# In[10]:
tot.fitTo(dh)
# In[11]:
massFrame = mass.frame()
massFrame.SetTitle("Phi signal")
dh.plotOn(massFrame)
tot.plotOn(massFrame)
gauss.plotOn(massFrame, LineColor(kGreen), LineStyle(kDashed),
Normalization((sFrac.getValV() * numEvts) / (numEvts)))
cheb.plotOn(massFrame, LineColor(kMagenta), LineStyle(kDotted),
Normalization(((1.0 - sFrac.getValV()) * numEvts) / (numEvts)))
tot.paramOn(massFrame, Layout(0.60, 0.99, 0.75))
massFrame.Draw()
# In[12]:
plotmax = hist.GetMaximum() * 1.05
sidesigma = sigma.getValV()
leftlowside = -7. * sidesigma + mean.getValV()
leftupside = -5. * sidesigma + mean.getValV()
rightlowside = +5. * sidesigma + mean.getValV()
rightupside = +7. * sidesigma + mean.getValV()
signallow = -3. * sidesigma + mean.getValV()
signalup = +3. * sidesigma + mean.getValV()
print "Side Sigma"
def bw_fit(ecm, infile, outdir, reconstruction):
"""Breit-Wigner fit of the Mw distribution"""
file_ = TFile(infile, "r")
file_.cd()
mass_ = 'h_mW2'
h_mass = gDirectory.Get(mass_)
scale = h_mass.GetXaxis().GetBinWidth(1) / (h_mass.Integral("width"))
h_mass.Scale(scale)
mass_min = 40
mass_max = 120
mass = RooRealVar("Dijet mass", "Dijet mass", mass_min, mass_max, "GeV")
# parameters for gaussian function
gaus_sig = RooRealVar("#sigma_{G}", "Core Width", 1., 0.5, 10., "GeV")
# gaus_sig.setConstant()
# parameters for Crystall Ball distribution
m_ = RooRealVar("#Delta m", "Bias", 0., -3., 3., "GeV")
sigma = RooRealVar("#sigma", "Width", 1.7, 0., 10., "GeV")
alpha = RooRealVar("#alpha", "Cut", -0.15, -5., 0.)
n = RooRealVar("n", "Power", 2.4, 0.5, 10.)
alpha.setConstant()
n.setConstant()
# Parameters for Breit-Wigner distribution
m_res = RooRealVar("M_{W}", "W boson mass", 80.385, 80.0, 81.0, "GeV")
width = RooRealVar("#Gamma", "W width", 2.085, 1.5, 2.5, "GeV")
m_res.setConstant()
width.setConstant()
# Cristall-Ball lineshape
resG = RooGaussian("resG", "Gaussian distribution", mass, m_, gaus_sig)
resCB = RooCBShape("resCB", "Crystal Ball distribution", mass, m_, sigma,
alpha, n)
fracG = RooRealVar("f_{G}", "Gaussian Fraction", 0., 0., 1.)
res = RooAddPdf("res", "Resolution Model", resG, resCB, fracG)
# Breit-wigner lineshape
bw = RooBreitWigner("bw", "Breit-Wigner distribution", mass, m_res, width)
# Convolution
bw_CB_conv = RooFFTConvPdf("bw_CB_conv", "Convolution", mass, bw, res)
# Background p.d.f
bgtau = RooRealVar("a_{BG}", "Backgroung Shape", -0.15, -1.0, 0.0,
"1/GeV/c^{2}")
bg = RooExponential("bg", "Background distribution", mass, bgtau)
# Fit model
nentries = h_mass.GetEntries()
nsigmin = 0.5 * nentries
nsigmean = 1.0 * nentries
nsigmax = 1.05 * nentries
nbkgmean = 0.01 * nentries
nbkgmax = 0.1 * nentries
nsig = RooRealVar("N_S", "#signal events", nsigmean, nsigmin, nsigmax)
nbkg = RooRealVar("N_B", "#background events", nbkgmean, 0, nbkgmax)
model = RooAddPdf("model", "W mass fit", RooArgList(bw_CB_conv, bg),
RooArgList(nsig, nbkg))
###### FIT
c_name = "c_ " + mass_ + "_" + str(ecm) + "_" + reconstruction + "_fit"
c_mass_fit = TCanvas(
c_name,
'Fit of the reconstructed mass distribution with a convolution of Breit-Wigner and Crystal-Ball',
700, 500)
c_mass_fit.cd()
data = RooDataHist("data", "data", RooArgList(mass), h_mass)
frame = mass.frame()
data.plotOn(frame)
model.fitTo(data, RooFit.Optimize(0))
model.plotOn(frame)
model.paramOn(frame, RooFit.Layout(0.6, 0.90, 0.85))
frame.Draw()
# norm = h_mass.Integral()/bw_CB_conv.createIntegral(RooArgSet(mass)).getValV()
# m = m_.getValV()*norm
# s = sigma.getValV()*norm
m = m_.getVal()
s = sigma.getVal()
print("\n\n----------------------------------------------")
print(" Fit results :")
print(" Bias to apply on mW : {} GeV".format(m))
print(" Mw = {} +/- {} GeV".format((m + 80.385), s))
print("--------------------------------------------------")
raw_input("")
c_mass_fit.Print("{}fit/fit_{}_{}_{}.pdf".format(outdir, mass_, ecm,
reconstruction))
# write into an output file and close the file
outfilename = "{}fit/fit_{}_{}.root".format(outdir, mass_, ecm)
outfile = TFile(outfilename, "UPDATE")
c_mass_fit.Write("", TObject.kOverwrite)
outfile.Write()
outfile.Close()
mean = RooRealVar("mean", "MeanofGaussian", 0, -10, 10)
sigma = RooRealVar("sigma", "WidthofGaussian", 3, -10, 10)
gauss = RooGaussian("gauss", "gauss(x,mean,sigma)", x, mean, sigma)
g1sig = RooRealVar("g1sig", "fraction of gauss1", 10, 0, 100000.0)
# Build signal PDF: f1
signalPDF = RooAddPdf("signalPDF", "g1sig * g1", RooArgList(gauss),
RooArgList(g1sig))
#mean.setConstant(kTRUE); #fix mean
sigma.setRange(0.1, 3)
# change range for sigma
gauss.fitTo(data, RooFit.PrintLevel(-1))
# ffit gauss on data
signalPDF.fitTo(data, RooFit.PrintLevel(-1))
#PrintLevel(-1) almost no output
# Minos(kTRUE)?
mean.Print()
sigma.Print()
#Show parameters on plot
signalPDF.paramOn(xframe, RooFit.Layout(0.55, 0.9, 0.9),
RooFit.Format("NEU", RooFit.AutoPrecision(1)))
signalPDF.plotOn(xframe)
xframe.Draw()
chi2txt = TLatex()
chi2txt.SetNDC()
chi2txt.DrawLatex(0.13, 0.83, "\chi^2/n.d.f = %0.3f" %
xframe.chiSquare()) #Put chi² on plot
def doDataFit(Chib1_parameters,Chib2_parameters, cuts, inputfile_name = None, RooDataSet = None, ptBin_label='', plotTitle = "#chi_{b}",fittedVariable='qValue', printSigReso = False, noPlots = False, useOtherSignalParametrization = False, useOtherBackgroundParametrization = False, massFreeToChange = False, sigmaFreeToChange = False, legendOnPlot=True, drawPulls=False, titleOnPlot=False, cmsOnPlot=True, printLegend=True):
if RooDataSet != None:
dataSet = RooDataSet
elif inputfile_name != None:
print "Creating DataSet from file "+str(inputfile_name)
dataSet = makeRooDataset(inputfile_name)
else:
raise ValueError('No dataset and no inputfile passed to function doDataFit')
if(fittedVariable == 'refittedMass'):
x_var = 'rf1S_chib_mass'
output_suffix = '_refit'
x_axis_label= 'm_{#mu^{+} #mu^{-} #gamma} [GeV]'
else:
x_var = 'invm1S'
output_suffix = '_qValue'
x_axis_label = 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon} [GeV]'
cuts_str = str(cuts)
#cuts_str = quality_cut + "photon_pt > 0.5 && abs(photon_eta) < 1.0 && ctpv < 0.01 && abs(dimuon_rapidity) < 1.3 && pi0_abs_mass > 0.025 && abs(dz) < 0.5"
data = dataSet.reduce( RooFit.Cut(cuts_str) )
print 'Creating pdf'
x=RooRealVar(x_var, 'm(#mu #mu #gamma) - m(#mu #mu) + m_{#Upsilon}',9.7,10.1,'GeV')
numBins = 80 # define here so that if I change it also the ndof change accordingly
x.setBins(numBins)
# cristal balls
mean_1 = RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,"GeV")
sigma_1 = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', Chib1_parameters.a1)
n1_1 = RooRealVar('n1_1', 'n1_1', Chib1_parameters.n1)
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1',Chib1_parameters.a2)
n2_1 = RooRealVar('n2_1', 'n2_1', Chib1_parameters.n2)
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
mean_2 = RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,"GeV")
sigma_2 = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', Chib2_parameters.a1)
n1_2 = RooRealVar('n1_2', 'n1_2', Chib2_parameters.n1)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', Chib2_parameters.a2)
n2_2 = RooRealVar('n2_2', 'n2_2', Chib2_parameters.n2)
parameters.add(RooArgSet( a1_2, a2_2, n1_2, n2_2))
if massFreeToChange:
# scale_mean = RooRealVar('scale_mean', 'Scale that multiplies masses found with MC', 0.8,1.2)
# mean_1_fixed = RooRealVar("mean_1_fixed","mean ChiB1",Chib1_parameters.mean,"GeV")
# mean_2_fixed = RooRealVar("mean_2_fixed","mean ChiB2",Chib2_parameters.mean,"GeV")
# mean_1 = RooFormulaVar("mean_1",'@0*@1', RooArgList(scale_mean, mean_1_fixed))
# mean_2 = RooFormulaVar("mean_2",'@0*@1', RooArgList(scale_mean, mean_2_fixed))
variazione_m = 0.05 # 50 MeV
diff_m_12 = RooRealVar('diff_m_12', 'Difference between masses chib1 and chib2',0.0194,'GeV') # 19.4 MeV from PDG
mean_1=RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,Chib1_parameters.mean-variazione_m,Chib1_parameters.mean+variazione_m ,"GeV")
mean_2=RooFormulaVar('mean_2', '@0+@1',RooArgList(mean_1, diff_m_12))
# mean_2=RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,Chib2_parameters.mean-variazione_m,Chib2_parameters.mean+variazione_m ,"GeV")
parameters.add(mean_1)
else:
parameters.add(RooArgSet(mean_1, mean_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2)
if sigmaFreeToChange:
scale_sigma = RooRealVar('scale_sigma', 'Scale that multiplies sigmases found with MC', 1, 1.1)#1.01
sigma_1_fixed = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV')
sigma_2_fixed = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV')
sigma_1 = RooFormulaVar("sigma_1",'@0*@1', RooArgList(scale_sigma, sigma_1_fixed))
sigma_2 = RooFormulaVar("sigma_2",'@0*@1', RooArgList(scale_sigma, sigma_2_fixed))
parameters.add(scale_sigma)
else:
parameters.add(RooArgSet(sigma_1, sigma_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2)
if useOtherSignalParametrization: # In this case I redefine cb_pdf
cb1 = RooCBShape('cb1', 'cb1', x, mean_1, sigma_1, a1_1, n1_1)
cb2 = RooCBShape('cb2', 'cb2', x, mean_2, sigma_2, a1_2, n1_2)
# I use a2 as the sigma of my gaussian
gauss1 = RooCBShape('gauss1', 'gauss1',x, mean_1, a2_1, a1_1, n1_1)
gauss2 = RooCBShape('gauss2', 'gauss2',x, mean_2, a2_2, a1_2, n1_2)
# I use n2 as the ratio of cb with respect to gauss
chib1_pdf = RooAddPdf('chib1','chib1',RooArgList(cb1, gauss1),RooArgList(n2_1))
chib2_pdf = RooAddPdf('chib2','chib2',RooArgList(cb2, gauss2),RooArgList(n2_2))
#background
q01S_Start = 9.5
alpha = RooRealVar("#alpha","#alpha",1.5,-1,3.5)#0.2 anziche' 1
beta = RooRealVar("#beta","#beta",-2.5,-7.,0.)
q0 = RooRealVar("q0","q0",q01S_Start)#,9.5,9.7)
delta = RooFormulaVar("delta","TMath::Abs(@0-@1)",RooArgList(x,q0))
b1 = RooFormulaVar("b1","@0*(@1-@2)",RooArgList(beta,x,q0))
signum1 = RooFormulaVar( "signum1","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q0) )
background = RooGenericPdf("background","Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1,delta,alpha,b1) )
if useOtherBackgroundParametrization: # in thies case I redefine background
a0 = RooRealVar('a0','a0',1.,-1.,1.) #,0.5,0.,1.)
a1 = RooRealVar('a1','a1',0.1,-1.,1.) #-0.2,0.,1.)
#a2 = RooRealVar('a2','a2',-0.1,1.,-1.)
background = RooChebychev('background','Background',x,RooArgList(a0,a1))
parameters.add(RooArgSet(a0, a1))
else:
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf,chib2_pdf,background)
# ndof
floatPars = parameters.selectByAttrib("Constant",ROOT.kFALSE)
ndof = numBins - floatPars.getSize() - 1
# # Here I have as parameters N1, N2, and N_background
# n_chib1 = RooRealVar("n_chib1","n_chib1",1250, 0, 50000)
# n_chib2 = RooRealVar("n_chib2","n_chib2",825, 0, 50000)
# n_background = RooRealVar('n_background','n_background',4550, 0, 50000)
# ratio_list = RooArgList(n_chib1, n_chib2, n_background)
# modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
# Here I have as parameters N_12, ratio_12, N_background
n_chib = RooRealVar("n_chib","n_chib",2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21","ratio_21",0.6, 0, 1)
n_chib1 = RooFormulaVar("n_chib1","@0/(1+@1)",RooArgList(n_chib, ratio_21))
n_chib2 = RooFormulaVar("n_chib2","@0/(1+1/@1)",RooArgList(n_chib, ratio_21))
n_background = RooRealVar('n_background','n_background',4550, 0, 50000)
ratio_list = RooArgList(n_chib1, n_chib2, n_background)
parameters.add(RooArgSet(n_chib1, n_chib2, n_background))
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
print 'Fitting to data'
fit_region = x.setRange("fit_region",9.7,10.1)
result=modelPdf.fitTo(data,RooFit.Save(), RooFit.Range("fit_region"))
# define frame
frame = x.frame()
frame.SetNameTitle("fit_resonance","Fit Resonanace")
frame.GetXaxis().SetTitle(x_axis_label )
frame.GetYaxis().SetTitle( "Events/5 MeV " )
frame.GetXaxis().SetTitleSize(0.04)
frame.GetYaxis().SetTitleSize(0.04)
frame.GetXaxis().SetTitleOffset(1.1)
frame.GetXaxis().SetLabelSize(0.04)
frame.GetYaxis().SetLabelSize(0.04)
frame.SetLineWidth(1)
frame.SetTitle(plotTitle)
# plot things on frame
data.plotOn(frame, RooFit.MarkerSize(0.7))
chib1P_set = RooArgSet(chib1_pdf)
modelPdf.plotOn(frame,RooFit.Components(chib1P_set), RooFit.LineColor(ROOT.kGreen+2), RooFit.LineStyle(2), RooFit.LineWidth(1))
chib2P_set = RooArgSet(chib2_pdf)
modelPdf.plotOn(frame, RooFit.Components(chib2P_set),RooFit.LineColor(ROOT.kRed), RooFit.LineStyle(2), RooFit.LineWidth(1))
background_set = RooArgSet(background)
modelPdf.plotOn(frame,RooFit.Components(background_set), RooFit.LineColor(ROOT.kBlack), RooFit.LineStyle(2), RooFit.LineWidth(1))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
frame.SetName("fit_resonance")
# Make numChib object
numChib = NumChib(numChib=n_chib.getVal(), s_numChib=n_chib.getError(), ratio_21=ratio_21.getVal(), s_ratio_21=ratio_21.getError(), numBkg=n_background.getVal(), s_numBkg=n_background.getError(), corr_NB=result.correlation(n_chib, n_background),corr_NR=result.correlation(n_chib, ratio_21) , name='numChib'+output_suffix+ptBin_label,q0=q0.getVal(),s_q0=q0.getError(),alpha=alpha.getVal(),s_alpha=alpha.getError(), beta=beta.getVal(), s_beta=beta.getError(), chiSquare=frame.chiSquare())
#numChib.saveToFile('numChib'+output_suffix+'.txt')
if noPlots:
chi2 = frame.chiSquare()
del frame
return numChib, chi2
# Legend
parameters_on_legend = RooArgSet()#n_chib, ratio_21, n_background)
if massFreeToChange:
#parameters_on_legend.add(scale_mean)
parameters_on_legend.add(mean_1)
#parameters_on_legend.add(mean_2)
if sigmaFreeToChange:
parameters_on_legend.add(scale_sigma)
if massFreeToChange or sigmaFreeToChange:
modelPdf.paramOn(frame, RooFit.Layout(0.1,0.6,0.2),RooFit.Parameters(parameters_on_legend))
if printLegend: #chiquadro, prob, numchib...
leg = TLegend(0.48,0.75,0.97,0.95)
leg.SetBorderSize(0)
#leg.SetTextSize(0.04)
leg.SetFillStyle(0)
chi2 = frame.chiSquare()
probChi2 = TMath.Prob(chi2*ndof, ndof)
chi2 = round(chi2,2)
probChi2 = round(probChi2,2)
leg.AddEntry(0,'#chi^{2} = '+str(chi2),'')
leg.AddEntry(0,'Prob #chi^{2} = '+str(probChi2),'')
N_bkg, s_N_bkg = roundPair(numChib.numBkg, numChib.s_numBkg)
leg.AddEntry(0,'N_{bkg} = '+str(N_bkg)+' #pm '+str(s_N_bkg),'')
N_chib12, s_N_chib12 = roundPair(numChib.numChib, numChib.s_numChib)
leg.AddEntry(0,'N_{#chi_{b}} = '+str(N_chib12)+' #pm '+str(s_N_chib12),'')
Ratio = numChib.calcRatio()
s_Ratio = numChib.calcRatioError()
Ratio, s_Ratio = roundPair(Ratio, s_Ratio)
leg.AddEntry(0,'N_{2}/N_{1} = '+str(Ratio)+' #pm '+str(s_Ratio),'')
if printSigReso: # Add Significance
Sig = numChib.calcSignificance()
s_Sig = numChib.calcSignificanceError()
Sig, s_Sig = roundPair(Sig, s_Sig)
leg.AddEntry(0,'Sig = '+str(Sig)+' #pm '+str(s_Sig),'')
if(Chib1_parameters.sigma>Chib2_parameters.sigma):
Reso = Chib1_parameters.sigma * 1000 # So it's in MeV and not in GeV
s_Reso = Chib1_parameters.s_sigma * 1000 # So it's in MeV and not in GeV
else:
Reso = Chib2_parameters.sigma * 1000 # So it's in MeV and not in GeV
s_Reso = Chib2_parameters.s_sigma * 1000 # So it's in MeV and not in GeV
Reso, s_Reso =roundPair(Reso, s_Reso)
leg.AddEntry(0,'Reso = '+str(Reso)+' #pm '+str(s_Reso)+' MeV','')
#N1 = numChib.numChib1
#s_N1 = numChib.s_numChib1
#N1, s_N1 = roundPair(N1, s_N1)
#leg.AddEntry(0,'N_{1} = '+str(N1)+' #pm '+str(s_N1),'')
#N2 = numChib.numChib2
#s_N2 = numChib.s_numChib2
#N2, s_N2 = roundPair(N2, s_N2)
#leg.AddEntry(0,'N_{2} = '+str(N2)+' #pm '+str(s_N2),'')
frame.addObject(leg)
if legendOnPlot: # < pT <
legend = TLegend(.06,.75,.53,.93)
legend.SetFillStyle(0)
legend.SetBorderSize(0)
#legend.AddEntry(0,'CMS','')
legend.AddEntry(0,str(cuts.upsilon_pt_lcut)+' GeV < p_{T}(#Upsilon) < '+str(cuts.upsilon_pt_hcut)+' GeV','')
#legend.AddEntry(0,'p_{T}(#Upsilon)<'+str(cuts.upsilon_pt_hcut),'')
frame.addObject(legend)
if titleOnPlot:
titleLegend = TLegend(.06,.4,.55,.73)
#titleLegend.SetTextSize(0.03)
titleLegend.SetFillStyle(0)
titleLegend.SetBorderSize(0)
titleLegend.AddEntry(0,plotTitle,'')
frame.addObject(titleLegend)
if cmsOnPlot:
if printLegend:
pvtxt = TPaveText(.1,.55,.55,.73,"NDC")
else:
pvtxt = TPaveText(0.5,0.75,0.97,0.9,"NDC") #(.06,.4,.55,.73)
pvtxt.AddText('CMS Preliminary')
pvtxt.AddText('pp, #sqrt{s} = 8 TeV')
pvtxt.AddText('L = 20.7 fb^{-1}')
pvtxt.SetFillStyle(0)
pvtxt.SetBorderSize(0)
pvtxt.SetTextSize(0.04)
frame.addObject(pvtxt)
# Canvas
c1=TCanvas('Chib12_1P'+output_suffix+ptBin_label,'Chib12_1P'+output_suffix+ptBin_label)
frame.Draw()
if drawPulls:
#c1=TCanvas(output_name+output_suffix,output_name+output_suffix,700, 625)
hpull = frame.pullHist()
framePulls = x.frame()
framePulls.SetTitle(';;Pulls')
framePulls.GetYaxis().SetLabelSize(0.18)
framePulls.GetYaxis().SetTitle('Pulls')
framePulls.GetYaxis().SetTitleSize(0.18)
framePulls.GetYaxis().SetTitleOffset(0.15)
framePulls.GetYaxis().SetNdivisions(005)
framePulls.GetXaxis().SetLabelSize(0.16)
framePulls.GetXaxis().SetTitle('')
line0 = TLine(9.7, 0, 10.1, 0)
line0.SetLineColor(ROOT.kBlue)
line0.SetLineWidth(2)
framePulls.addObject(line0)
framePulls.addPlotable(hpull,"P")
framePulls.SetMaximum(5)
framePulls.SetMinimum(-5)
pad1 = TPad("pad1", "The pad 80% of the height",0.0,0.2,1.0,1.0)
pad1.cd()
frame.Draw()
pad2 = TPad("pad2", "The pad 20% of the height",0.0,0.01,1.0,0.2)
pad2.cd()
framePulls.Draw()
c1.cd()
pad1.Draw()
pad2.Draw()
#c1.SaveAs('Chib12_1P'+output_suffix+'.png')
print 'Chi2 = '+str(frame.chiSquare())
# print ratio background/all in the signal refion
signal_region = x.setRange("signal_region",9.87,9.92)
pdf_integral = modelPdf.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * (n_chib.getVal() + n_background.getVal())
bkg_integral = background.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * n_background.getVal()
print 'Ratio bkg/all in signal region = '+str(bkg_integral/pdf_integral)
return numChib, c1
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 fitChicSpectrum(dataset, binname):
""" Fit chic spectrum"""
x = RooRealVar('Qvalue', 'Q', 9.7, 10.1)
x.setBins(80)
mean_1 = RooRealVar("mean_1", "mean ChiB1", 9.892, 9, 10, "GeV")
sigma_1 = RooRealVar("sigma_1", "sigma ChiB1", 0.0058, 'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', 0.748)
n1_1 = RooRealVar('n1_1', 'n1_1', 2.8)
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1', 1.739)
n2_1 = RooRealVar('n2_1', 'n2_1', 3.0)
deltam = RooRealVar('deltam', 'deltam', 0.01943)
mean_2 = RooFormulaVar("mean_2", "@0+@1", RooArgList(mean_1, deltam))
sigma_2 = RooRealVar("sigma_2", "sigma ChiB2", 0.0059, 'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', 0.738)
n1_2 = RooRealVar('n1_2', 'n1_2', 2.8)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', 1.699)
n2_2 = RooRealVar('n2_2', 'n2_2', 3.0)
parameters = RooArgSet()
parameters.add(RooArgSet(sigma_1, sigma_2))
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
parameters.add(RooArgSet(a1_2, a2_2, n1_2, n2_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1,
a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2,
a2_2, n2_2)
#background
q01S_Start = 9.5
alpha = RooRealVar("#alpha", "#alpha", 1.5, -1, 3.5) #0.2 anziche' 1
beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.)
q0 = RooRealVar("q0", "q0", q01S_Start) #,9.5,9.7)
delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0))
b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0))
signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.",
RooArgList(x, q0))
background = RooGenericPdf("background", "Background",
"signum1*pow(delta,#alpha)*exp(b1)",
RooArgList(signum1, delta, alpha, b1))
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf, chib2_pdf, background)
n_chib = RooRealVar("n_chib", "n_chib", 2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21", "ratio_21", 0.5, 0, 1)
n_chib1 = RooFormulaVar("n_chib1", "@0/(1+@1)",
RooArgList(n_chib, ratio_21))
n_chib2 = RooFormulaVar("n_chib2", "@0/(1+1/@1)",
RooArgList(n_chib, ratio_21))
n_background = RooRealVar('n_background', 'n_background', 4550, 0, 50000)
ratio_list = RooArgList(n_chib1, n_chib2, n_background)
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
frame = x.frame(RooFit.Title('m'))
range = x.setRange('range', 9.7, 10.1)
result = modelPdf.fitTo(dataset, RooFit.Save(), RooFit.Range('range'))
dataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
#plotting
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
canvas.SaveAs('out-' + binname + '.png')
#nk1 = model3.createNLL(data)
#RooMinuit(nk1).migrad()
#Rk1 = k2.frame()
#nk1.plotOn(Rk1,RooFit.ShiftToZero())
#cRcc = TCanvas("Rcc", "Rcc", 500, 500)
#Rk1.SetMaximum(4.);Rk1.SetMinimum(0)
#Rk1.GetXaxis().SetTitle("nttbar/nmc")
#Rk1.SetTitle("")
#Rk1.Draw()
cR11 = TCanvas("R11", "R", 500, 500)
xframe = x.frame()
data.plotOn(xframe, RooFit.DataError(RooAbsData.SumW2) )
model3.paramOn(xframe, RooFit.Layout(0.65,0.9,0.9) )
model3.plotOn(xframe)
chi2 = xframe.chiSquare(2)
ndof = xframe.GetNbinsX()
print "chi2 = "+ str(chi2)
print "ndof = "+ str(ndof)
xframe.Draw()
print "k1:"+str(k1.getVal())+", err:"+str(k1.getError())+", init:"+str(rttbar)
print "k2:"+str(k2.getVal())+", err:"+str(k2.getError())
n_mctotal = n_ttbar+n_background
print "####################"
print "ttbar = " + str(n_ttbar)
