def fitNBkg(ibdt, fullbkg, isample):
slope = RooRealVar("slope", "slope", 0.5, -10, 10)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass)
cut = cut_base + '&& bdt_prob > %s' % (ibdt)
theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt],
B0Mass_ + 3 * dict_sigma[ibdt])
databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut)
r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right'),
RooFit.PrintLevel(-1))
frame = theBMass.frame()
databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7))
bkg_exp.plotOn(frame, )
canv = ROOT.TCanvas()
frame.Draw()
nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000)
ebkg = RooExtendPdf(
'ebkg', 'ebkg', bkg_exp, nbkg,
'sigRangeMC') ## here imposing the range to calculate bkg yield
ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right'), RooFit.PrintLevel(-1))
ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6))
frame.Draw()
# canv.SaveAs('bkg_fit_bdt%f_sample%i.pdf'%(ibdt,isample))
dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def fitNBkg(ibdt, fullbkg):
slope = RooRealVar("slope", "slope", 0.5, -10, 10)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass)
cut = cut_base + '&& bdt_prob > %s' % (ibdt)
theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt],
B0Mass_ + 3 * dict_sigma[ibdt])
databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut)
r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right'))
frame = theBMass.frame()
databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7))
bkg_exp.plotOn(frame, )
# bkg_exp.fixCoefRange('left,right')
nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000)
ebkg = RooExtendPdf('ebkg', 'ebkg', bkg_exp, nbkg, 'sigRangeMC')
ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right'))
ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6))
frame.Draw()
dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def generateBkg(tagged_mass, ibin, n_bkg):
slope = RooRealVar("slope", "slope", -4.2)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass)
pol_c1 = RooRealVar("p1", "coeff x^0 term", -1.2)
pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.3)
bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass,
RooArgList(pol_c1, pol_c2))
n_togen = np.random.poisson(n_bin[ibin] * n_bkg, 1)
toybkg = bkg_pol.generate(RooArgSet(tagged_mass), n_togen[0])
return toybkg
def MakeGeneralPdf(workspace,label,model,spectrum,wtagger_label, channel,constraint,peak="W"):
print "Making general PDF for ","model_pdf"+label+"_"+channel+spectrum
rrv_x = workspace.var("rrv_mass_j")
gaus_means = 8.2653e+01
gaussigmas = 7
if peak == "t":
gaus_means = 180
gaussigmas = 18
if model == "ErfExp":
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp"+label+"_"+channel+spectrum,"rrv_c_ErfExp"+label+"_"+channel+spectrum,-0.026,-0.05, 0.05)
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum,"rrv_offset_ErfExp"+label+"_"+channel+spectrum,41.,0.,100)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp"+label+"_"+channel+spectrum,"rrv_width_ErfExp"+label+"_"+channel+spectrum,30.,1.,100.)
model_pdf = ROOT.RooErfExpPdf("model_pdf"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,rrv_x,rrv_c_ErfExp,rrv_offset_ErfExp,rrv_width_ErfExp)
if model == "ExpGaus":
if label.find("_STop_failtau2tau1cut")!=-1:
rrv_c_Exp = RooRealVar("rrv_c_Exp"+label+"_"+channel+spectrum,"rrv_c_Exp"+label+"_"+channel+spectrum,-0.03,-0.5,0.5)
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_"+channel+spectrum,"rrv_mean1_gaus"+label+"_"+channel+spectrum,gaus_means,gaus_means*.8,gaus_means*1.2) #Too narrow limits here often lead to error!! eg max 80
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum,"rrv_sigma1_gaus"+label+"_"+channel+spectrum,gaussigmas,gaussigmas*.5,gaussigmas*1.5)
elif label.find("fail")!=-1:
rrv_c_Exp = RooRealVar("rrv_c_Exp"+label+"_"+channel+spectrum,"rrv_c_Exp"+label+"_"+channel+spectrum,-0.05,-0.5,0.5)
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_"+channel+spectrum,"rrv_mean1_gaus"+label+"_"+channel+spectrum,gaus_means,gaus_means*.8,gaus_means*1.2)
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum,"rrv_sigma1_gaus"+label+"_"+channel+spectrum,gaussigmas,gaussigmas*.5,gaussigmas*1.5)
rrv_high = RooRealVar("rrv_high"+label+"_"+channel+spectrum,"rrv_high"+label+"_"+channel+spectrum,0.3,0.3,1.)
else:
rrv_c_Exp = RooRealVar("rrv_c_Exp"+label+"_"+channel+spectrum,"rrv_c_Exp"+label+"_"+channel+spectrum,-0.01,-1.,0.)
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_"+channel+spectrum,"rrv_mean1_gaus"+label+"_"+channel+spectrum,gaus_means,gaus_means*.8,gaus_means*1.2)
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum,"rrv_sigma1_gaus"+label+"_"+channel+spectrum,gaussigmas,gaussigmas*.5,gaussigmas*1.5)
rrv_high = RooRealVar("rrv_high"+label+"_"+channel+spectrum,"rrv_high"+label+"_"+channel+spectrum,0.7,0.,1.)
exp = RooExponential("exp"+label+"_"+channel+spectrum,"exp"+label+"_"+channel+spectrum,rrv_x,rrv_c_Exp)
gaus = RooGaussian("gaus"+label+"_"+channel+spectrum,"gaus"+label+"_"+channel+spectrum, rrv_x,rrv_mean1_gaus,rrv_sigma1_gaus)
model_pdf = RooAddPdf("model_pdf"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,RooArgList(exp,gaus),RooArgList(rrv_high))
if model == "ErfExp_ttbar" or model == "ErfExp_ttbar_ddt" or model == "ErfExp_ttbar_failtau2tau1cut" or model == "ErfExp_ttbar_failtau2tau1cut_fitMC" or model == "ErfExp_ttbar_failtau2tau1cut_ddt":
print "PRINTING MODEL " ,model
if peak == "Wt":
c0_tmp = -3.5239e-02 ; c0_tmp_err = 4.52e-03;
offset_tmp = 9.3695e+01 ; offset_tmp_err = 3.53e+00;
width_tmp = 3.2006e+01 ; width_tmp_err = 1.84e+00;
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,93, 0,200)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,32,30,100)#,width_tmp-10, width_tmp+10)
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp" +label+"_"+channel+spectrum ,"rrv_c_ErfExp" +label+"_"+channel+spectrum ,-0.02 , -2, 2 )
elif model.find("failtau2tau1cut")!=-1:
c0_tmp = -2.6259e-02 ; c0_tmp_err = 1.46e-02;
offset_tmp = 9.1220e+01 ; offset_tmp_err = 4.92;
width_tmp = 3.1356e+01 ; width_tmp_err = 4.69e+00;
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp, offset_tmp-offset_tmp_err,offset_tmp+offset_tmp_err) #Can be fixed to avoid downwoards slope towards zero
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp,width_tmp-10, width_tmp+10)
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp" +label+"_"+channel+spectrum ,"rrv_c_ErfExp" +label+"_"+channel+spectrum ,c0_tmp, c0_tmp-4e-2, c0_tmp+4e-2 )
if model.find("_ddt")!=-1:
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp, 0.,100.) #Can be fixed to avoid downwoards slope towards zero
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp,width_tmp-10, width_tmp+10)
else:
c0_tmp = -3.5239e-02 ; c0_tmp_err = 4.52e-03;
offset_tmp = 9.3695e+01 ; offset_tmp_err = 3.53e+00;
width_tmp = 3.2006e+01 ; width_tmp_err = 1.84e+00;
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp, offset_tmp-offset_tmp_err,offset_tmp+offset_tmp_err)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp, width_tmp-10, width_tmp+10)
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp" +label+"_"+channel+spectrum ,"rrv_c_ErfExp" +label+"_"+channel+spectrum ,c0_tmp , c0_tmp-4e-2, c0_tmp+4e-2 )
rrv_c_ErfExp.Print()
print "PRINTED"
model_pdf = ROOT.RooErfExpPdf("model_pdf"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum ,rrv_x,rrv_c_ErfExp,rrv_offset_ErfExp,rrv_width_ErfExp)
gaus1 = addConstraint(workspace,rrv_c_ErfExp,rrv_c_ErfExp.getVal(),c0_tmp_err,constraint)
if model.find("failtau2tau1cut")==-1:
gaus2 = addConstraint(workspace,rrv_offset_ErfExp,rrv_offset_ErfExp.getVal(),offset_tmp_err,constraint)
gaus3 = addConstraint(workspace,rrv_width_ErfExp,rrv_width_ErfExp.getVal(),width_tmp_err,constraint)
if model == "GausErfExp_ttbar" or model == "GausErfExp_ttbar_fitMC" or model =="GausErfExp_ttbar_failtau2tau1cut" or model =="GausErfExp_ttbar_failtau2tau1cut_fitMC":
frac_tmp = 1.; #Use only Gaussian component to model real W-jets, ErfExp set to zero by setting fraction to 1!
if model.find("fitMC")!=-1:
mean1_tmp = 8.2653e+01;
sigma1_tmp = 7.5932e+00;
rangeMean = 8. ;
rangeWidth = 5. ;
c0_tmp = -2.7180e-02 ; c0_tmp_err = 6.83e-03;
offset_tmp = 8.6888e+01 ; offset_tmp_err = 19.35e+00;
width_tmp = 3.6383e+01 ; width_tmp_err = 1.34e+00;
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_"+channel+spectrum ,"rrv_mean1_gaus"+label+"_"+channel+spectrum ,gaus_means,gaus_means*.8,gaus_means*1.2)
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum ,"rrv_sigma1_gaus"+label+"_"+channel+spectrum ,gaussigmas,gaussigmas*.5,gaussigmas*2.5 )
gaus1 = RooGaussian("gaus1"+label+"_"+channel+spectrum ,"gaus1"+label+"_"+channel+spectrum ,rrv_x,rrv_mean1_gaus,rrv_sigma1_gaus)
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp,offset_tmp-offset_tmp_err,offset_tmp+offset_tmp_err)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp, 30., 100.)
elif model.find("fail")!=-1:
c0_tmp = -7.3903e-03 ; c0_tmp_err = 1.46e-02;
offset_tmp = 8.9205e+01 ; offset_tmp_err = 4.92e+01;
width_tmp = 7.6305e+01 ; width_tmp_err = 14.69;
mean1_tmp = 8.2278e+01;
sigma1_tmp = 9.6909e+00;
#frac_tmp = 5.8066e-01
if label.find("data")!=-1:
gaus1 = workspace.pdf("gaus1_ttbar_data_"+channel+spectrum)
else:
gaus1 = workspace.pdf("gaus1_ttbar_TotalMC_"+channel+spectrum)
# rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_"+channel+spectrum ,"rrv_mean1_gaus"+label+"_"+channel+spectrum ,gaus_means,gaus_means*.8,gaus_means*1.2)
# rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum ,"rrv_sigma1_gaus"+label+"_"+channel+spectrum ,gaussigmas,gaussigmas*.5,gaussigmas*1.5 )
# gaus1 = RooGaussian("gaus1"+label+"_"+channel+spectrum ,"gaus1"+label+"_"+channel+spectrum ,rrv_x,rrv_mean1_gaus,rrv_sigma1_gaus)
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp,offset_tmp-offset_tmp_err,offset_tmp+2*offset_tmp_err)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp, width_tmp-width_tmp_err, width_tmp+2*width_tmp_err)
else:
mean1_tmp = 8.4666e+01;
sigma1_tmp = 8.5006e+00;
rangeMean = 8. ;
rangeWidth = 5. ;
c0_tmp = -5.8699e-02 ; c0_tmp_err = 6.83e-03;
offset_tmp = 1.0199e+02 ; offset_tmp_err = 9.35e+00;
width_tmp = 3.0009e+01 ; width_tmp_err = 1.34e+00;
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_"+channel+spectrum ,"rrv_mean1_gaus"+label+"_"+channel+spectrum ,90,gaus_means*.8,gaus_means*1.2)
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum ,"rrv_sigma1_gaus"+label+"_"+channel+spectrum ,5,0,6)
gaus1 = RooGaussian("gaus1"+label+"_"+channel+spectrum ,"gaus1"+label+"_"+channel+spectrum ,rrv_x,rrv_mean1_gaus,rrv_sigma1_gaus)
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp,offset_tmp-offset_tmp_err,offset_tmp+offset_tmp_err)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp, width_tmp-10, width_tmp+10)
if model.find("fitMC")!=-1:
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp" +label+"_"+channel+spectrum ,"rrv_c_ErfExp" +label+"_"+channel+spectrum ,c0_tmp,c0_tmp-1, c0_tmp+1 )
rrv_frac = RooRealVar("rrv_frac"+label+"_"+channel+spectrum ,"rrv_frac"+label+"_"+channel+spectrum ,frac_tmp,0.,1.)
else:
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp" +label+"_"+channel+spectrum ,"rrv_c_ErfExp" +label+"_"+channel+spectrum ,c0_tmp,c0_tmp-4e-2, c0_tmp+4e-2 )
rrv_frac = RooRealVar("rrv_frac"+label+"_"+channel+spectrum ,"rrv_frac"+label+"_"+channel+spectrum ,frac_tmp)
rrv_frac.setConstant(ROOT.kTRUE)
rrv_c_ErfExp.setConstant(ROOT.kTRUE)#Force to constant, if not RooFit will try to fit them despite frac==0 for ErfExp
rrv_offset_ErfExp.setConstant(ROOT.kTRUE)
rrv_width_ErfExp.setConstant(ROOT.kTRUE)
erfExp = ROOT.RooErfExpPdf("erfExp"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,rrv_x,rrv_c_ErfExp,rrv_offset_ErfExp,rrv_width_ErfExp)
model_pdf = RooAddPdf("model_pdf"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,RooArgList(gaus1,erfExp),RooArgList(rrv_frac),1)
if model == "Gaus2ErfExp_ttbar" or model == "Gaus2ErfExp_ttbar_fitMC" or model =="Gaus2ErfExp_ttbar_failtau2tau1cut" or model =="Gaus2ErfExp_ttbar_failtau2tau1cut_fitMC":
frac_tmp = 1.0; #Use only Gaussian component to model real W-jets, ErfExp set to zero by setting fraction to 1!
if model.find("fitMC")!=-1:
mean1_tmp = 8.2653e+01;
sigma1_tmp = 7.5932e+00;
rangeMean = 8. ;
rangeWidth = 5. ;
c0_tmp = -2.7180e-02 ; c0_tmp_err = 6.83e-03;
offset_tmp = 8.6888e+01 ; offset_tmp_err = 19.35e+00;
width_tmp = 3.6383e+01 ; width_tmp_err = 1.34e+00;
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_"+channel+spectrum ,"rrv_mean1_gaus"+label+"_"+channel+spectrum ,80.,75.,85.)
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum ,"rrv_sigma1_gaus"+label+"_"+channel+spectrum ,7.6,5.,10. )
gaus1 = RooGaussian("gaus1"+label+"_"+channel+spectrum ,"gaus1"+label+"_"+channel+spectrum ,rrv_x,rrv_mean1_gaus,rrv_sigma1_gaus)
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp,offset_tmp-offset_tmp_err,offset_tmp+offset_tmp_err)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp, 30., 100.)
rrv_mean2_gaus = RooRealVar("rrv_mean2_gaus"+label+"_"+channel+spectrum ,"rrv_mean2_gaus"+label+"_"+channel+spectrum ,170,150,180)
rrv_sigma2_gaus = RooRealVar("rrv_sigma2_gaus"+label+"_"+channel+spectrum ,"rrv_sigma2_gaus"+label+"_"+channel+spectrum ,13,10.,20. )
gaus2 = RooGaussian("gaus2"+label+"_"+channel+spectrum ,"gaus2"+label+"_"+channel+spectrum ,rrv_x,rrv_mean2_gaus,rrv_sigma2_gaus)
elif model.find("fail")!=-1:
c0_tmp = -7.3903e-03 ; c0_tmp_err = 1.46e-02;
offset_tmp = 8.9205e+01 ; offset_tmp_err = 4.92e+01;
width_tmp = 7.6305e+01 ; width_tmp_err = 14.69;
mean1_tmp = 8.2278e+01;
sigma1_tmp = 9.6909e+00;
#frac_tmp = 5.8066e-01
if label.find("data")!=-1:
gaus1 = workspace.pdf("gaus1_ttbar_data_"+channel+spectrum)
else:
gaus1 = workspace.pdf("gaus1_ttbar_TotalMC_"+channel+spectrum)
rrv_mean2_gaus = RooRealVar("rrv_mean2_gaus"+label+"_"+channel+spectrum ,"rrv_mean2_gaus"+label+"_"+channel+spectrum ,gaus_means+100,(gaus_means+100)*.8,(gaus_means+100)*1.2)
rrv_sigma2_gaus = RooRealVar("rrv_sigma2_gaus"+label+"_"+channel+spectrum ,"rrv_sigma2_gaus"+label+"_"+channel+spectrum ,gaussigmas+10,(gaussigmas+10)*.5,(gaussigmas+10)*1.5 )
gaus2 = RooGaussian("gaus2"+label+"_"+channel+spectrum ,"gaus2"+label+"_"+channel+spectrum ,rrv_x,rrv_mean2_gaus,rrv_sigma2_gaus)
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp,offset_tmp-offset_tmp_err,offset_tmp+2*offset_tmp_err)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp, width_tmp-width_tmp_err, width_tmp+2*width_tmp_err)
else:
mean1_tmp = 8.4666e+01;
sigma1_tmp = 8.5006e+00;
rangeMean = 8. ;
rangeWidth = 5. ;
c0_tmp = -5.8699e-02 ; c0_tmp_err = 6.83e-03;
offset_tmp = 1.0199e+02 ; offset_tmp_err = 9.35e+00;
width_tmp = 3.0009e+01 ; width_tmp_err = 1.34e+00;
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_"+channel+spectrum ,"rrv_mean1_gaus"+label+"_"+channel+spectrum ,gaus_means,gaus_means*.8,gaus_means*1.2)
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum ,"rrv_sigma1_gaus"+label+"_"+channel+spectrum ,gaussigmas,gaussigmas*.5,gaussigmas*1.5)
gaus1 = RooGaussian("gaus1"+label+"_"+channel+spectrum ,"gaus1"+label+"_"+channel+spectrum ,rrv_x,rrv_mean1_gaus,rrv_sigma1_gaus)
rrv_offset_ErfExp = RooRealVar("rrv_offset_ErfExp"+label+"_"+channel+spectrum ,"rrv_offset_ErfExp"+label+"_"+channel+spectrum ,offset_tmp,offset_tmp-offset_tmp_err,offset_tmp+offset_tmp_err)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp" +label+"_"+channel+spectrum ,"rrv_width_ErfExp" +label+"_"+channel+spectrum ,width_tmp, width_tmp-10, width_tmp+10)
rrv_mean2_gaus = RooRealVar("rrv_mean2_gaus"+label+"_"+channel+spectrum ,"rrv_mean2_gaus"+label+"_"+channel+spectrum ,gaus_means+100,(gaus_means+100)*.8,(gaus_means+100)*1.2)
rrv_sigma2_gaus = RooRealVar("rrv_sigma2_gaus"+label+"_"+channel+spectrum ,"rrv_sigma2_gaus"+label+"_"+channel+spectrum ,gaussigmas+10,(gaussigmas+10)*.5,(gaussigmas+10)*1.5 )
gaus2 = RooGaussian("gaus2"+label+"_"+channel+spectrum ,"gaus2"+label+"_"+channel+spectrum ,rrv_x,rrv_mean2_gaus,rrv_sigma2_gaus)
if model.find("fitMC")!=-1:
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp" +label+"_"+channel+spectrum ,"rrv_c_ErfExp" +label+"_"+channel+spectrum ,c0_tmp,c0_tmp-1, c0_tmp+1 )
rrv_frac = RooRealVar("rrv_frac"+label+"_"+channel+spectrum ,"rrv_frac"+label+"_"+channel+spectrum ,frac_tmp,0.,1.)
else:
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp" +label+"_"+channel+spectrum ,"rrv_c_ErfExp" +label+"_"+channel+spectrum ,c0_tmp,c0_tmp-4e-2, c0_tmp+4e-2 )
rrv_frac = RooRealVar("rrv_frac"+label+"_"+channel+spectrum ,"rrv_frac"+label+"_"+channel+spectrum ,frac_tmp)
rrv_frac.setConstant(ROOT.kTRUE)
rrv_c_ErfExp.setConstant(ROOT.kTRUE)#Force to constant, if not RooFit will try to fit them despite frac==0 for ErfExp
rrv_offset_ErfExp.setConstant(ROOT.kTRUE)
rrv_width_ErfExp.setConstant(ROOT.kTRUE)
erfExp = ROOT.RooErfExpPdf("erfExp"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,rrv_x,rrv_c_ErfExp,rrv_offset_ErfExp,rrv_width_ErfExp)
# model_pdf = RooAddPdf("model_pdf"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,RooArgList(gaus1,erfExp),RooArgList(rrv_frac),1)
model_pdf = RooAddPdf("model_pdf"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,RooArgList(gaus1,gaus2),RooArgList(rrv_frac),1)
if model == "Exp" :
rrv_c_Exp = RooRealVar("rrv_c_Exp"+label+"_"+channel+spectrum,"rrv_c_Exp"+label+"_"+channel+spectrum,-0.030, -2., 0.05)
model_pdf = RooExponential("model_pdf"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,rrv_x,rrv_c_Exp)
if model == "Gaus":
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus" +label+"_"+channel+spectrum ,"rrv_mean1_gaus" +label+"_"+channel+spectrum,gaus_means,gaus_means*.8,gaus_means*1.2)
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_"+channel+spectrum ,"rrv_sigma1_gaus"+label+"_"+channel+spectrum,gaussigmas,gaussigmas*.5,gaussigmas*1.5)
model_pdf = RooGaussian("gaus"+label+"_"+channel+spectrum,"gaus"+label+"_"+channel+spectrum, rrv_x,rrv_mean1_gaus,rrv_sigma1_gaus)
if model == "ErfExpGaus_sp":
rrv_c_ErfExp = RooRealVar("rrv_c_ErfExp"+label+"_" +channel+spectrum,"rrv_c_ErfExp" +label+"_"+channel+spectrum,-0.04,-1.,1.)
rrv_width_ErfExp = RooRealVar("rrv_width_ErfExp"+label+"_"+channel+spectrum,"rrv_width_ErfExp"+label+"_"+channel+spectrum,30.,0.,400.)
rrv_mean1_gaus = RooRealVar("rrv_mean1_gaus"+label+"_" +channel+spectrum,"rrv_mean1_gaus" +label+"_"+channel+spectrum,gaus_means,gaus_means*.8,gaus_means*1.2)
rrv_sigma1_gaus = RooRealVar("rrv_sigma1_gaus"+label+"_" +channel+spectrum,"rrv_sigma1_gaus" +label+"_"+channel+spectrum,gaussigmas,gaussigmas*.5,gaussigmas*1.5)
erfExp = ROOT.RooErfExpPdf("erfExp"+label+"_"+channel+spectrum,"erfExp"+label+"_"+channel+spectrum,rrv_x,rrv_c_ErfExp,rrv_mean1_gaus,rrv_width_ErfExp)
gaus = RooGaussian ("gaus"+label+"_"+channel+spectrum ,"gaus"+label+"_"+channel+spectrum , rrv_x,rrv_mean1_gaus,rrv_sigma1_gaus)
rrv_high = RooRealVar("rrv_high"+label+"_"+channel+spectrum,"rrv_high"+label+"_"+channel+spectrum,0.3,0.0,0.99)
model_pdf = RooAddPdf("model_pdf"+label+"_"+channel+spectrum,"model_pdf"+label+"_"+channel+spectrum,erfExp,gaus,rrv_high)
getattr(workspace,'import')(model_pdf)
return workspace.pdf("model_pdf"+label+"_"+channel+spectrum)
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()
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 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
mean = RooRealVar("mass", "mean", B0Mass_, 3, 7, "GeV")
sigma = RooRealVar("#sigma", "sigma", 0.028, 0, 10, "GeV")
signalGauss = RooGaussian("signalGauss", "signal gauss", theBMass, mean, sigma)
sigma2 = RooRealVar("#sigma2", "sigma2", 0.048, 0, 0.07, "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, pol_c2))
nsig = RooRealVar("Yield", "signal frac", 4000, 0, 10000)
nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 55000)
fitFunction = RooAddPdf("fitfunction", "fit function",
RooArgList(signalGauss, bkg_pol),
RooArgList(nsig, nbkg))
r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(),
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()
c1 = RooRealVar("p_1", "p_1", 0.001, -10., 10.)
c2 = RooRealVar("p_2", "p_2", -0.00001, -10., 10.)
c3 = RooRealVar("p_3", "p_3", -0.000001, -10., 10.)
c4 = RooRealVar("p_4", "p_4", -0.000001, -10., 10.)
c5 = RooRealVar("p_5", "p_5", -0.000001, -10., 10.)
c6 = RooRealVar("p_6", "p_6", -0.000001, -0.01, 0.01)
alpha = RooRealVar("#alpha", "#alpha", -0.1, -10.0, -0.00001)
polyset = RooArgList(c0, c1, c2, c3, c4, c5)
gFraMMKK = RooRealVar("f_{gauss}", "f_{gauss}", 0.3, 0.0, 1.0)
nSigMMKK = RooRealVar("n_{sig}", "n_{sig}", 10000, 0., 10E6)
nBkgMMKK = RooRealVar("n_{bkg}", "n_{bkg}", 10000, 0., 10E6)
##pdf_bkg = RooChebychev("pdf_bkg","pdf_bkg",mmtt_mass,polyset)
pdf_bkg = RooExponential("pdf_bkg", "pdf_bkg", mmtt_mass, alpha)
pdf_sig1 = RooGaussian("pdf_sig1", "pdf_sig1", mmtt_mass, mean, sigma1)
pdf_sig2 = RooGaussian("pdf_sig2", "pdf_sig2", mmtt_mass, mean, sigma2)
pdf_sig = RooAddPdf("pdf_sig", "pdf_sig", pdf_sig1, pdf_sig2, gFraMMKK)
pdf_tot = RooAddPdf("pdf_tot", "pdf_tot", RooArgList(pdf_sig, pdf_bkg),
RooArgList(nSigMMKK, nBkgMMKK))
nfit = 0
if debugging:
mean.setConstant(kTRUE)
sigma1.setConstant(kTRUE)
sigma2.setConstant(kTRUE)
gFraMMKK.setConstant(kTRUE)
c0.setConstant(kTRUE)
def rooFit205():
print ">>> setup model signal components: gaussians..."
x = RooRealVar("x", "x", 0, 10)
mean = RooRealVar("mean", "mean of gaussians", 5)
sigma1 = RooRealVar("sigma1", "width of gaussians", 0.5)
sigma2 = RooRealVar("sigma2", "width of gaussians", 1)
sig1 = RooGaussian("sig1", "Signal component 1", x, mean, sigma1)
sig2 = RooGaussian("sig2", "Signal component 2", x, mean, sigma2)
sig1frac = RooRealVar("sig1frac", "fraction of component 1 in signal", 0.8,
0., 1.)
sig = RooAddPdf("sig", "Signal", RooArgList(sig1, sig2),
RooArgList(sig1frac))
print ">>> setup model background components: Chebychev polynomial plus exponential..."
a0 = RooRealVar("a0", "a0", 0.5, 0., 1.)
a1 = RooRealVar("a1", "a1", -0.2, 0., 1.)
bkg1 = RooChebychev("bkg1", "Background 1", x, RooArgList(a0, a1))
alpha = RooRealVar("alpha", "alpha", -1)
bkg2 = RooExponential("bkg2", "Background 2", x, alpha)
bkg1frac = RooRealVar("bkg1frac", "fraction of component 1 in background",
0.2, 0., 1.)
bkg = RooAddPdf("bkg", "Signal", RooArgList(bkg1, bkg2),
RooArgList(bkg1frac))
print ">>> sum signal and background component..."
bkgfrac = RooRealVar("bkgfrac", "fraction of background", 0.5, 0., 1.)
model = RooAddPdf("model", "g1+g2+a", RooArgList(bkg, sig),
RooArgList(bkgfrac))
print ">>> setup basic plot with data and full pdf..."
data = model.generate(RooArgSet(x), 1000) # RooDataSet
frame1 = x.frame(
Title("Component plotting of pdf=(sig1+sig2)+(bkg1+bkg2)")) # RooPlot
data.plotOn(frame1, Name("data"))
model.plotOn(frame1, Name("model"))
print ">>> clone frame for reuse..."
frame2 = frame1.Clone("frame2") # RooPlot
frame2.SetTitle("Get components with regular expressions")
print ">>> make omponent by object reference..."
# Plot multiple background components specified by object reference
# Note that specified components may occur at any level in object tree
# (e.g bkg is component of 'model' and 'sig2' is component 'sig')
argset1 = RooArgSet(bkg)
argset2 = RooArgSet(bkg2)
argset3 = RooArgSet(bkg, sig2)
model.plotOn(frame1, Components(argset1), LineColor(kRed), Name("bkgs1"))
model.plotOn(frame1, Components(argset2), LineStyle(kDashed),
LineColor(kRed), Name("bkg2"))
model.plotOn(frame1, Components(argset3), LineStyle(kDotted),
Name("bkgssig21"))
print "\n>>> make component by name / regular expressions..."
model.plotOn(frame2, Components("bkg"), LineColor(kAzure - 4),
Name("bkgs2")) # by name
model.plotOn(frame2, Components("bkg1,sig2"), LineColor(kAzure - 4),
LineStyle(kDotted), Name("bkg1sig22")) # by name
model.plotOn(frame2, Components("sig*"), LineColor(kAzure - 4),
LineStyle(kDashed), Name("sigs2")) # with regexp (wildcard *)
model.plotOn(frame2, Components("bkg1,sig*"), LineColor(kYellow),
LineStyle(kDashed),
Name("bkg1sigs2")) # with regexp (,) #Invisible()
print "\n>>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600)
legend1 = TLegend(0.22, 0.85, 0.4, 0.65)
legend2 = TLegend(0.22, 0.85, 0.4, 0.65)
for legend in [legend1, legend2]:
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
canvas.Divide(2)
canvas.cd(1)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend1.AddEntry("data", "data", 'LEP')
legend1.AddEntry("model", "model", 'L')
legend1.AddEntry("bkgs1", "bkg", 'L')
legend1.AddEntry("bkg2", "bkg2", 'L')
legend1.AddEntry("bkgssig21", "bkg,sig2", 'L')
legend1.Draw()
canvas.cd(2)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame2.GetYaxis().SetLabelOffset(0.008)
frame2.GetYaxis().SetTitleOffset(1.6)
frame2.GetYaxis().SetTitleSize(0.045)
frame2.GetXaxis().SetTitleSize(0.045)
frame2.Draw()
legend2.AddEntry("data", "data", 'LEP')
legend2.AddEntry("model", "model", 'L')
legend2.AddEntry("bkgs2", "\"bkg\"", 'L')
legend2.AddEntry("bkg1sig22", "\"bkg1,sig2\"", 'L')
legend2.AddEntry("sigs2", "\"sig*\"", 'L')
legend2.AddEntry("bkg1sigs2", "\"bkg1,sig*\"", 'L')
legend2.Draw()
canvas.SaveAs("rooFit205.png")
# # sum pdfs
# model = RooAddPdf("model{}".format(bin), "model{}".format(bin),
# RooArgList(exp, gaus),
# RooArgList(nbkg, nsig))
# return model
# define signal pdf
bin = "0"
mean0 = RooRealVar("mean{}".format(bin), "mean{}".format(bin), 3090, 2900, 3300)
sigma0 = RooRealVar("sigma{}".format(bin), "sigma{}".format(bin), 10, 0, 30)
gaus0 = RooGaussian("gx{}".format(bin), "gx{}".format(bin), m, mean0, sigma0)
# define background pdf
slope0 = RooRealVar("slope{}".format(bin), "slope{}".format(bin), -0.005, -0.1, -0.0001)
exp0 = RooExponential("exp{}".format(bin), "exp{}".format(bin), m, slope0)
# define yields
nsig0 = RooRealVar("nsig{}".format(bin), "n. sig bin{}".format(bin), 1000, 0., 1000000)
nbkg0 = RooRealVar("nbkg{}".format(bin), "n. bkg bin{}".format(bin), 1000, 0, 2000000)
# sum pdfs
model0 = RooAddPdf("model{}".format(bin), "model{}".format(bin),
RooArgList(exp0, gaus0),
RooArgList(nbkg0, nsig0))
# define signal pdf
bin = "1"
mean1 = RooRealVar("mean{}".format(bin), "mean{}".format(bin), 3090, 2900, 3300)
sigma1 = RooRealVar("sigma{}".format(bin), "sigma{}".format(bin), 10, 0, 30)
gaus1 = RooGaussian("gx{}".format(bin), "gx{}".format(bin), m, mean1, sigma1)
# # # # # #
# #### # # #####
# # # # #
# # #### #
#
###########################################
## signal
mean = RooRealVar('mean', 'mean', 85., 0, 250)
sigma = RooRealVar('sigma', 'sigma', 100.0, 0, 250)
gauss = RooGaussian('gauss', 'gaussian', J_Mass, mean, sigma)
## background model
## exponential
slopeQCD = RooRealVar("slopeQCD", "slopeQCD", -0.1, -20., 20.)
expQCD = RooExponential("expQCD", "exponential PDF", J_Mass, slopeQCD)
##p2mod = 4.99989 +/- 3.9569 (limited)
##p3mod = 11.9997 +/- 0.529866 (limited)
##p4mod = 2.02636 +/- 0.360492 (limited)
##p5mod = 0.220746 +/- 0.0842075 (limited)
## dijet mass function
f_var = RooFormulaVar('f_var', 'f_var', '@0/13000.', RooArgList(J_Mass))
p1mod = RooRealVar('p1mod', 'p1mod', 0., 4000)
p2mod = RooRealVar('p2mod', 'p2mod', -2000., 2000.)
p3mod = RooRealVar('p3mod', 'p3mod', -1000, 1000.)
p4mod = RooRealVar('p4mod', 'p4mod', -100., 100.)
p5mod = RooRealVar('p5mod', 'p5mod', -200., 200.)
p6mod = RooRealVar('p6mod', 'p6mod', -10, 10.)
n = RooRealVar("n", "n", 5, 1, 100)
signalCB = RooCBShape("signalCB", "signal cb", theBMass, mean, sigma, alpha, n)
sigma2 = RooRealVar("sigma2", "sigma2", 9.0e-3, 1.0e-5, 1.0, "GeV")
alpha2 = RooRealVar("alpha2", "alpha2", 1.0, 0.0, 1.0e+4)
n2 = RooRealVar("n2", "n2", 5, 1, 100)
signalCB2 = RooCBShape("signalCB2", "signal cb 2", theBMass, mean, sigma2,
alpha2, n2)
f1 = RooRealVar("f1", "f1", 0.5, 0., 1.)
CB = RooAddPdf("CB", "CB1+CB2", RooArgList(signalCB, signalCB2),
RooArgList(f1))
## make bkg model
exp_alpha = RooRealVar("exp_alpha", "exp_alpha", -1.0, -100, 0)
bkg_exp = RooExponential("bkg_exp", "bkg_exp", theBMass, exp_alpha)
## combined model
nsig = RooRealVar("nsig", "signal frac", 300000, 0, 5000000)
nbkg = RooRealVar("nbkg", "bkg fraction", 100000, 0, 1000000)
#fitFunction = RooAddPdf ("fitFunction" , "fit function" , RooArgList(CB, bkg_exp), RooArgList(nsig, nbkg))
fitFunction = RooAddPdf("fitfunction", "fit function",
RooArgList(signalCB, bkg_exp), RooArgList(nsig, nbkg))
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()
def fitData(fulldata, ibin, nRT_fromMC, nWT_fromMC):
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
data = fulldata_v2.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)
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", "@0 - @1",
RooArgList(mean_rt, mean_wt))
frt = RooRealVar("F_{RT}", "frt", fraction.n, 0, 1)
signalFunction = RooAddPdf("sumgaus", "rt+wt",
RooArgList(theRTgauss, theWTgauss),
RooArgList(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))
nsig = RooRealVar("Yield", "signal frac", nRT_fromMC + nWT_fromMC, 0,
1000000)
nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000)
print nsig.getVal()
### 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_f1rt = _constrainVar(f1rt, 1)
c_pdfs = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_alpha_rt1, c_alpha_rt2,
c_n_rt1, c_n_rt2, c_f1rt)
c_vars = RooArgSet(sigma_rt1, sigma_rt2, alpha_rt1, alpha_rt2, n_rt1,
n_rt2, f1rt)
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)
### creating constraints for the difference between the two peaks
c_deltaPeaks = RooGaussian(
"c_deltaPeaks",
"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)
fitFunction = c_signalFunction
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' % (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 = "c_signalFunction_Norm[tagged_mass]_Range[full]_NormRange[full]"
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)
parList = RooArgSet(nsig, mean_rt, mean_wt, sigma_rt1, sigma_rt2,
alpha_rt1, alpha_rt2, mean_wt, sigma_wt)
parList.add(alpha_wt1)
parList.add(alpha_wt2)
parList.add(n_wt1)
parList.add(n_wt2)
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/save_fit_data_%s_%s_LMNR_newSigmaFRT_%s.pdf'
% (ibin, args.year, '_logScale' * ilog))
out_f.cd()
r.Write('results_data_%s' % (ibin))
params = fitFunction.getParameters(RooArgSet(tagged_mass))
w.saveSnapshot("reference_fit_data_%s" % (ibin), params, ROOT.kTRUE)
getattr(w, 'import')(fitFunction)
# TODO: export somewhere? pdf construction
frac = RooRealVar("frac", "Fraction of crystal ball pdfs", 0.479, 0.01,
0.99)
crystalball1 = RooCBShape("crystallball1", "First CrystalBall PDF", x,
mean, sigma, alpha_0, lambda_0)
crystalball2 = RooCBShape("crystallball2", "Second CrystalBall PDF", x,
mean, sigma, alpha_1, lambda_1)
doubleCB = RooAddPdf("doubleCB", "Double CrystalBall PDF", crystalball1,
crystalball2, frac)
# create signal pdf END
# create bkg-pdf BEGIN
lambda_exp = RooRealVar("lambda_exp", "lambda exp pdf bkg", -0.002, -10.,
-0.000001)
bkg_pdf = RooExponential("bkg_pdf", "Background PDF exp", x, lambda_exp)
# create bkg-pdf END
n_sig = 2500
data = pd.DataFrame(np.random.normal(loc=5280, scale=37, size=(n_sig, 3)),
columns=['x', 'y', 'pred'])
# data['pred'] = np.array([min((abs(y), 0.99)) for y in np.random.normal(loc=0.6, scale=0.25, size=n_sig)])
bkg_data = np.array([
i for i in (np.random.exponential(scale=300, size=(7500, 3)) + 4800)
if i[0] < 6000
])
bkg_data[:, 2] = np.array([
min((abs(y), 0.96))
for y in np.random.normal(loc=0.4, scale=0.4, size=len(bkg_data))
])
def main(infiles=None):
infile = infiles[0]
var = "leadmupt"
bounds = [25, 300]
c1 = ROOT.TCanvas("NLL", "NLL", 1000, 1000)
x = ROOT.RooRealVar(var, var, bounds[0], bounds[1])
aset = ROOT.RooArgSet(x, "aset")
frame = x.frame()
f = ROOT.TFile.Open(infile)
tree = f.Get(f.GetListOfKeys().At(0).GetName())
tree.Print()
nentries = tree.GetEntries()
y = []
dh2 = ROOT.TH1F()
data = ROOT.RooDataSet("Data", "Data", aset)
for n in range(nentries):
tree.GetEntry(n)
y.append(getattr(tree, var))
if y[n] <= bounds[1] and y[n] >= bounds[0]:
x.setVal(y[n])
data.add(aset)
dh2.Fill(y[n])
data.plotOn(frame)
dh = RooDataHist("dh", "dh", RooArgSet(x), data)
nbins = dh2.GetNbinsX()
nbinsy = dh2.GetNbinsX()
print("nbins: ", nbins)
print("nbinsy: ", nbinsy)
for i in range(nbins):
if dh2.GetBinContent(dh2.GetBin(i)) == 0:
print("bin: ", i)
#dh2.SetBinError(bin,0.01)
## CREATE GAUSSIAN MODEL
mx = RooRealVar("mx", "mx", 10, 0, 350)
sx = RooRealVar("sx", "sx", 3, 0, 10)
gx = RooGaussian("gx", "gx", x, mx, sx)
## CREATE EXPONENTIAL MODEL
lambda1 = RooRealVar("lambda1", "slope1", -100, 100)
expo1 = RooExponential("expo1", "exponential PDF 1", x, lambda1)
lambda2 = RooRealVar("lambda2", "slope2", -.03, -1000, 1000)
expo2 = RooExponential("expo2", "exponential PDF 2", x, lambda2)
l1 = RooRealVar("l1", "yield1", 100, 0, 10000)
l2 = RooRealVar("l2", "yield2", 100, 0, 10000)
#sum = RooAddPdf("sum","exp and gauss",RooArgList(expo1,gx),RooArgList(l1,l2))
sum = RooAddPdf("sum", "2 exps", RooArgList(expo1, expo2),
RooArgList(l1, l2))
## Construct binned likelihood
nll = RooNLLVar("nll", "nll", expo1, data, ROOT.RooFit.Extended(True))
## Start Minuit session on NLL
m = RooMinuit(nll)
m.migrad()
m.hesse()
r1 = m.save()
#sum.plotOn(frame,ROOT.RooFit.LineColor(1))
#sum.plotOn(frame,ROOT.RooFit.Components("expo1"),ROOT.RooFit.LineColor(2))
#sum.plotOn(frame,ROOT.RooFit.Components("expo2"),ROOT.RooFit.LineColor(3))
expo1.plotOn(frame)
## Construct Chi2
chi2 = RooChi2Var("chi2", "chi2", expo2, dh)
## Start Minuit session on Chi2
m2 = RooMinuit(chi2)
m2.migrad()
m2.hesse()
r2 = m2.save()
frame.Draw()
c2 = ROOT.TCanvas("Chi2", "Chi2", 1000, 1000)
frame2 = x.frame()
data.plotOn(frame2)
expo2.plotOn(frame2)
#sum.plotOn(frame2,ROOT.RooFit.LineColor(4))
#sum.plotOn(frame2,ROOT.RooFit.Components("expo1"),ROOT.RooFit.LineColor(5))
#sum.plotOn(frame2,ROOT.RooFit.Components("expo2"),ROOT.RooFit.LineColor(6))
## Print results
print("result of likelihood fit")
r1.Print("v")
print("result of chi2 fit")
r2.Print("v")
frame2.Draw()
c1.Draw()
c2.Draw()
rep = ''
while not rep in ['q', 'Q']:
rep = input('enter "q" to quit: ')
if 1 < len(rep):
rep = rep[0]
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 rooFit207():
print ">>> setup model signal components: gaussians..."
x = RooRealVar("x","x",0,10)
mean = RooRealVar("mean","mean of gaussians",5)
sigma = RooRealVar("sigma","width of gaussians",0.5)
sig = RooGaussian("sig","Signal",x,mean,sigma)
print ">>> setup model background components: Chebychev polynomial plus exponential..."
a0 = RooRealVar("a0","a0",0.5,0.,1.)
a1 = RooRealVar("a1","a1",-0.2,0.,1.)
bkg1 = RooChebychev("bkg1","Background 1",x,RooArgList(a0,a1))
alpha = RooRealVar("alpha","alpha",-1)
bkg2 = RooExponential("bkg2","Background 2",x,alpha)
bkg1frac = RooRealVar("bkg1frac","fraction of component 1 in background",0.2,0.,1.)
bkg = RooAddPdf("bkg","Signal",RooArgList(bkg1,bkg2),RooArgList(bkg1frac))
print ">>> sum signal and background component..."
bkgfrac = RooRealVar("bkgfrac","fraction of background",0.5,0.,1.)
model = RooAddPdf("model","g1+g2+a",RooArgList(bkg,sig),RooArgList(bkgfrac))
# Create dummy dataset that has more observables than the above pdf
y = RooRealVar("y","y",-10,10)
data = RooDataSet("data","data",RooArgSet(x,y))
# Basic information requests:"
print ">>> get list of observables of pdf in context of a dataset..."
# Observables are define each context as the variables
# shared between a model and a dataset. In this case
# that is the variable 'x'
model_obs = model.getObservables(data) # RooArgSet
model_obs.Print('v')
print "\n>>> get list of parameters..."
# Get list of parameters, given list of observables
model_params = model.getParameters(RooArgSet(x)) # RooArgSet
print ">>> model_params.getStringValue(\"a0\") = %s" % (model_params.getStringValue("a0"))
print ">>> model_params.getRealValue(\"a0\") = %s" % (model_params.getRealValue("a0"))
print ">>> model_params.find(\"a0\").GetName() = %s" % (model_params.find("a0").GetName())
print ">>> model_params.find(\"a0\").getVal() = %s" % (model_params.find("a0").getVal())
# print ">>> for param in model_params:"
# for param in model_params.():
# print ">>> %s"%(model_params.first())
# print ">>> %s"%(model_params.first())
# model_params.selectByName("a*").Print('v')
model_params.Print('v')
print "\n>>> get list of parameters of a dataset..."
# Gives identical results to operation above
model_params2 = model.getParameters(data) # RooArgSet
model_params2.Print()
print "\n>>> get list of components..."
# Get list of component objects, including top-level node
model_comps = model.getComponents() # RooArgSet
model_comps.Print('v')
print "\n>>> modifications to structure of composites..."
sigma2 = RooRealVar("sigma2","width of gaussians",1)
sig2 = RooGaussian("sig2","Signal component 1",x,mean,sigma2)
sig1frac = RooRealVar("sig1frac","fraction of component 1 in signal",0.8,0.,1.)
sigsum = RooAddPdf("sigsum","sig+sig2",RooArgList(sig,sig2),RooArgList(sig1frac))
print ">>> construct a customizer utility to customize model..."
cust = RooCustomizer(model,"cust")
print ">>> instruct the customizer to replace node 'sig' with node 'sigsum'..."
cust.replaceArg(sig,sigsum)
# Build a clone of the input pdf according to the above customization
# instructions. Each node that requires modified is clone so that the
# original pdf remained untouched. The name of each cloned node is that
# of the original node suffixed by the name of the customizer object
#
# The returned head node own all nodes that were cloned as part of
# the build process so when cust_clone is deleted so will all other
# nodes that were created in the process.
cust_clone = cust.build(kTRUE) # RooAbsPdf
# Print structure of clone of model with sig->sigsum replacement.
cust_clone.Print("t")
# delete clone
del cust_clone
def rooFit206():
print ">>> setup model signal components: gaussians..."
x = RooRealVar("x", "x", 0, 10)
mean = RooRealVar("mean", "mean of gaussians", 5)
sigma1 = RooRealVar("sigma1", "width of gaussians", 0.5)
sigma2 = RooRealVar("sigma2", "width of gaussians", 1)
sig1 = RooGaussian("sig1", "Signal component 1", x, mean, sigma1)
sig2 = RooGaussian("sig2", "Signal component 2", x, mean, sigma2)
sig1frac = RooRealVar("sig1frac", "fraction of component 1 in signal", 0.8,
0., 1.)
sig = RooAddPdf("sig", "Signal", RooArgList(sig1, sig2),
RooArgList(sig1frac))
print ">>> setup model background components: Chebychev polynomial plus exponential..."
a0 = RooRealVar("a0", "a0", 0.5, 0., 1.)
a1 = RooRealVar("a1", "a1", -0.2, 0., 1.)
bkg1 = RooChebychev("bkg1", "Background 1", x, RooArgList(a0, a1))
alpha = RooRealVar("alpha", "alpha", -1)
bkg2 = RooExponential("bkg2", "Background 2", x, alpha)
bkg1frac = RooRealVar("bkg1frac", "fraction of component 1 in background",
0.2, 0., 1.)
bkg = RooAddPdf("bkg", "Signal", RooArgList(bkg1, bkg2),
RooArgList(bkg1frac))
print ">>> sum signal and background component..."
bkgfrac = RooRealVar("bkgfrac", "fraction of background", 0.5, 0., 1.)
model = RooAddPdf("model", "g1+g2+a", RooArgList(bkg, sig),
RooArgList(bkgfrac))
print ">>> composite tree in ASCII:"
model.Print("t")
print "\n>>> write to txt file"
model.printCompactTree("", "rooFit206_asciitree.txt")
print ">>> draw composite tree graphically..."
# Print GraphViz DOT file with representation of tree
model.graphVizTree("rooFit206_model.dot")
# Make graphic output file with one of the GraphViz tools
# (freely available from www.graphviz.org)
#
# 'Top-to-bottom graph'
# unix> dot -Tgif -o rooFit206_model_dot.gif rooFit206_model.dot
#
# 'Spring-model graph'
# unix> fdp -Tgif -o rooFit206_model_fdp.gif rooFit206_model.dot
print ">>> plot everything..."
data = model.generate(RooArgSet(x), 1000) # RooDataSet
frame1 = x.frame(
Title("Component plotting of pdf=(sig1+sig2)+(bkg1+bkg2)")) # RooPlot
data.plotOn(frame1, Name("data"), Binning(40))
model.plotOn(frame1, Name("model"))
argset1 = RooArgSet(bkg)
argset2 = RooArgSet(bkg2)
argset3 = RooArgSet(bkg, sig2)
model.plotOn(frame1, Components(argset1), LineColor(kRed), Name("bkg"))
model.plotOn(frame1, Components(argset2), LineStyle(kDashed),
LineColor(kRed), Name("bkg2"))
model.plotOn(frame1, Components(argset3), LineStyle(kDotted),
Name("bkgsig2"))
print "\n>>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
legend = TLegend(0.22, 0.85, 0.4, 0.65)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend.AddEntry("data", "data", 'LEP')
legend.AddEntry("model", "model", 'L')
legend.AddEntry("bkg", "bkg", 'L')
legend.AddEntry("bkg2", "bkg2", 'L')
legend.AddEntry("bkgsig2", "bkg,sig2", 'L')
legend.Draw()
canvas.SaveAs("rooFit206.png")
