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