class GaussianConstraint(object): def __init__(self, name, expr, deps, mean, sigma): self.name = name self.expr = expr self.deps = deps self.mean = mean self.sigma = sigma # pdf of yield vs coupling modificators dependentlist = RooArgList() for dep in deps: dependentlist.add(dep) self.pdf_yield = RooGenericPdf(name, name, expr, dependentlist) # observable (measurement) obsname = name + 'Obs' self.var_obs = RooRealVar(obsname, obsname, mean) # width of Gaussian pdf sname = name + 'Sigma' self.var_sigma = RooRealVar(sname, sname, sigma) # Gaussian pdf gname = name + "Constraint" self.pdf_constraint = RooGaussian(gname, gname, self.var_obs, self.pdf_yield, self.var_sigma) self.pulls = ROOT.TH1F('pulls_' + name, name, 1000, -10, 10) def fill_pull(self): pull = (self.pdf_yield.getVal() - 1) / self.var_sigma.getVal() self.pulls.Fill(pull) def info(self): print self.name self.pdf_yield.Print() self.var_obs.Print() self.var_sigma.Print() self.pdf_constraint.Print()
def rooFit101(): print ">>> build gaussian pdf..." x = RooRealVar("x", "x", -10, 10) mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10) sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10) gauss = RooGaussian("gauss", "gaussian PDF", x, mean, sigma) print ">>> plot pdf..." frame1 = x.frame(Title("Gaussian pdf")) # RooPlot #xframe.SetTitle("Gaussian pdf") gauss.plotOn(frame1) print ">>> change parameter value and plot..." sigma.setVal(3) gauss.plotOn(frame1, LineColor(kRed)) print ">>> generate events..." data = gauss.generate(RooArgSet(x), 10000) # RooDataSet frame2 = x.frame() data.plotOn(frame2, Binning(40)) gauss.plotOn(frame2) print ">>> fit gaussian...\n" gauss.fitTo(data) mean.Print() sigma.Print() print "\n>>> draw pdfs and fits on canvas..." canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600) 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() 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() canvas.SaveAs("rooFit101.png")
def fit(self, save_to, signal_name=None, fix_p3=False, fit_range=[300., 1200.], fit_strategy=1): # Run a RooFit fit # Create background PDF p1 = RooRealVar('p1','p1',args.p1,0.,100.) p2 = RooRealVar('p2','p2',args.p2,0.,60.) p3 = RooRealVar('p3','p3',args.p3,-10.,10.) if args.fix_p3: p3.setConstant() background_pdf = RooGenericPdf('background_pdf','(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))'%(self.collision_energy,self.collision_energy,self.collision_energy),RooArgList(self.mjj_,p1,p2,p3)) background_pdf.Print() data_integral = data_histogram.Integral(data_histogram.GetXaxis().FindBin(float(fit_range[0])),data_histogram.GetXaxis().FindBin(float(fit_range[1]))) background_norm = RooRealVar('background_norm','background_norm',data_integral,0.,1e+08) background_norm.Print() # Create signal PDF and fit model if signal_name: signal_pdf = RooHistPdf('signal_pdf', 'signal_pdf', RooArgSet(self.mjj_), self.signal_roohistograms_[signal_name]) signal_pdf.Print() signal_norm = RooRealVar('signal_norm','signal_norm',0,-1e+05,1e+05) signal_norm.Print() model = RooAddPdf("model","s+b",RooArgList(background_pdf,signal_pdf),RooArgList(background_norm,signal_norm)) else: model = RooAddPdf("model","b",RooArgList(background_pdf),RooArgList(background_norm)) # Run fit res = model.fitTo(data_, RooFit.Save(kTRUE), RooFit.Strategy(fit_strategy)) # Save to workspace self.workspace_ = RooWorkspace('w','workspace') #getattr(w,'import')(background,ROOT.RooCmdArg()) getattr(self.workspace_,'import')(background_pdf,RooFit.Rename("background")) getattr(self.workspace_,'import')(background_norm,ROOT.RooCmdArg()) getattr(self.workspace_,'import')(self.data_roohistogram_,RooFit.Rename("data_obs")) getattr(self.workspace_, 'import')(model, RooFit.Rename("model")) if signal_name: getattr(self.workspace_,'import')(signal_roohistogram,RooFit.Rename("signal")) getattr(self.workspace_,'import')(signal_pdf,RooFit.Rename("signal_pdf")) getattr(self.workspace_,'import')(signal_norm,ROOT.RooCmdArg()) self.workspace_.Print() self.workspace_.writeToFile(save_to) if signal_name: roofit_results[signal_name] = save_to else: roofit_results["background"] = save_to
def fitPed(hist, ws, name='x'): maxBin = hist.GetMaximumBin() x = ws.var(name) #rds = ds.reduce('{1}<{0:0.2f}'.format(hist.GetBinLowEdge(maxBin+2),name)) #rds.Print() x.setRange('ped_fit', x.getMin(), hist.GetBinLowEdge(maxBin + 3)) pedMean = RooRealVar('pedMean', 'mean_{ped}', hist.GetBinCenter(maxBin), x.getMin(), x.getMax()) pedMean.Print() pedWidth = RooRealVar('pedWidth', 'sigma_{ped}', 1., 0., 10.) pedWidth.Print() ped = RooGaussian('ped', 'ped', x, pedMean, pedWidth) pedMean.setConstant(False) ped.fitTo(ws.data('ds'), RooFit.Minos(False), RooFit.Range('ped_fit'), RooFit.PrintLevel(0)) getattr(ws, 'import')(ped)
def rf101_basics(): # S e t u p m o d e l # --------------------- # Declare variables x,mean,sigma with associated name, title, initial value and allowed range x = RooRealVar("x", "x", -10, 10) mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10) sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10) # Build gaussian p.d.f in terms of x,mean and sigma gauss = RooGaussian("gauss", "gaussian PDF", x, mean, sigma) # Construct plot frame in 'x' xframe = x.frame(RooFit.Title("Gaussian p.d.f.")) # P l o t m o d e l a n d c h a n g e p a r a m e t e r v a l u e s # --------------------------------------------------------------------------- # Plot gauss in frame (i.e. in x) gauss.plotOn(xframe) # Change the value of sigma to 3 sigma.setVal(3) # Plot gauss in frame (i.e. in x) and draw frame on canvas gauss.plotOn(xframe, RooFit.LineColor(kRed)) # G e n e r a t e e v e n t s # ----------------------------- # Generate a dataset of 1000 events in x from gauss data = gauss.generate(RooArgSet(x), 10000.) # Make a second plot frame in x and draw both the # data and the p.d.f in the frame xframe2 = x.frame(RooFit.Title("Gaussian p.d.f. with data")) data.plotOn(xframe2) gauss.plotOn(xframe2) # F i t m o d e l t o d a t a # ----------------------------- # Fit pdf to data gauss.fitTo(data) # Print values of mean and sigma (that now reflect fitted values and errors) mean.Print() sigma.Print() # Draw all frames on a canvas c = TCanvas("rf101_basics", "rf101_basics", 800, 400) c.Divide(2) c.cd(1) gPad.SetLeftMargin(0.15) xframe.GetYaxis().SetTitleOffset(1.6) xframe.Draw() c.cd(2) gPad.SetLeftMargin(0.15) xframe2.GetYaxis().SetTitleOffset(1.6) xframe2.Draw() raw_input()
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)
# normalize signal shape to the expected event yield (works even if input shapes are not normalized to unity) hSig.Scale( signalCrossSection * lumi / hSig.Integral() ) # divide by a number that provides roughly an r value of 1-10 print "[debug] hSig.Integral() = " + str(hSig.Integral()) print "[debug] hSig.GetMean() = " + str(hSig.GetMean()) print "[debug] hSig.GetRMS() = " + str(hSig.GetRMS()) rooSigHist = RooDataHist('rooSigHist', 'rooSigHist', RooArgList(mjj), hSig) rooSigHist.Print() signal = RooHistPdf('signal', 'signal', RooArgSet(mjj), rooSigHist) signal.Print() signal_norm = RooRealVar('signal_norm', 'signal_norm', 0, -1e+05, 1e+05) if args.fitBonly: signal_norm.setConstant() signal_norm.Print() p1 = RooRealVar('p1', 'p1', args.p1, 0., 100.) p2 = RooRealVar('p2', 'p2', args.p2, 0., 60.) p3 = RooRealVar('p3', 'p3', args.p3, -10., 10.) if args.fixP3: p3.setConstant() background = RooGenericPdf( 'background', '(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))' % (sqrtS, sqrtS, sqrtS), RooArgList(mjj, p1, p2, p3)) background.Print() dataInt = hData.Integral(hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background_norm = RooRealVar('background_norm', 'background_norm', dataInt, 0., 1e+08)
def rooFit601(): print ">>> setup pdf and likelihood..." x = RooRealVar("x", "x", -20, 20) mean = RooRealVar("mean", "mean of g1 and g2", 0) sigma1 = RooRealVar("sigma1", "width of g1", 3) sigma2 = RooRealVar("sigma2", "width of g2", 4, 3.0, 6.0) # intentional strong correlations gauss1 = RooGaussian("gauss1", "gauss1", x, mean, sigma1) gauss2 = RooGaussian("gauss2", "gauss2", x, mean, sigma2) frac = RooRealVar("frac", "frac", 0.5, 0.0, 1.0) model = RooAddPdf("model", "model", RooArgList(gauss1, gauss2), RooArgList(frac)) print ">>> generate to data..." data = model.generate(RooArgSet(x), 1000) # RooDataSet print ">>> construct unbinned likelihood of model wrt data..." nll = model.createNLL(data) # RooAbsReal print ">>> interactive minimization and error analysis with MINUIT interface object..." minuit = RooMinuit(nll) print ">>> set avtive verbosity for logging of MINUIT parameter space stepping..." minuit.setVerbose(kTRUE) print ">>> call MIGRAD to minimize the likelihood..." minuit.migrad() print "\n>>> parameter values and error estimates that are back propagated from MINUIT:" model.getParameters(RooArgSet(x)).Print("s") print "\n>>> disable verbose logging..." minuit.setVerbose(kFALSE) print ">>> run HESSE to calculate errors from d2L/dp2..." minuit.hesse() print ">>> value of and error on sigma2 (back propagated from MINUIT):" sigma2.Print() print "\n>>> run MINOS on sigma2 parameter only..." minuit.minos(RooArgSet(sigma2)) print "\n>>> value of and error on sigma2 (back propagated from MINUIT after running MINOS):" sigma2.Print() print "\n>>> saving results, contour plots..." # Save a snapshot of the fit result. This object contains the initial # fit parameters, the final fit parameters, the complete correlation # matrix, the EDM, the minimized FCN , the last MINUIT status code and # the number of times the RooFit function object has indicated evaluation # problems (e.g. zero probabilities during likelihood evaluation) result = minuit.save() # RooFitResult # Make contour plot of mx vs sx at 1,2,3 sigma frame1 = minuit.contour(frac, sigma2, 1, 2, 3) # RooPlot frame1.SetTitle("RooMinuit contour plot") # Print the fit result snapshot result.Print("v") print "\n>>> change value of \"mean\" parameter..." mean.setVal(0.3) # Rerun MIGRAD,HESSE print ">>> rerun MIGRAD, HESSE..." minuit.migrad() minuit.hesse() print ">>> value on and error of frac:" frac.Print() print "\n>>> fix value of \"sigma\" parameter (setConstant)..." sigma2.setConstant(kTRUE) print ">>> rerun MIGRAD, HESSE..." minuit.migrad() minuit.hesse() frac.Print()
def main(): # usage description usage = "Example: ./scripts/createDatacards.py --inputData inputs/rawhistV7_Run2015D_scoutingPFHT_UNBLINDED_649_838_JEC_HLTplusV7_Mjj_cor_smooth.root --dataHistname mjj_mjjcor_gev --inputSig inputs/ResonanceShapes_gg_13TeV_Scouting_Spring15.root -f gg -o datacards -l 1866 --lumiUnc 0.027 --massrange 1000 1500 50 --runFit --p1 5 --p2 7 --p3 0.4 --massMin 838 --massMax 2037 --fitStrategy 2" # input parameters parser = ArgumentParser( description= 'Script that creates combine datacards and corresponding RooFit workspaces', epilog=usage) parser.add_argument("--inputData", dest="inputData", required=True, help="Input data spectrum", metavar="INPUT_DATA") parser.add_argument("--dataHistname", dest="dataHistname", required=True, help="Data histogram name", metavar="DATA_HISTNAME") parser.add_argument("--inputSig", dest="inputSig", required=True, help="Input signal shapes", metavar="INPUT_SIGNAL") parser.add_argument("-f", "--final_state", dest="final_state", required=True, help="Final state (e.g. qq, qg, gg)", metavar="FINAL_STATE") parser.add_argument("-f2", "--type", dest="atype", required=True, help="Type (e.g. hG, lG, hR, lR)") parser.add_argument( "-o", "--output_path", dest="output_path", required=True, help="Output path where datacards and workspaces will be stored", metavar="OUTPUT_PATH") parser.add_argument( "-l", "--lumi", dest="lumi", required=True, default=1000., type=float, help="Integrated luminosity in pb-1 (default: %(default).1f)", metavar="LUMI") parser.add_argument( "--massMin", dest="massMin", default=500, type=int, help= "Lower bound of the mass range used for fitting (default: %(default)s)", metavar="MASS_MIN") parser.add_argument( "--massMax", dest="massMax", default=1200, type=int, help= "Upper bound of the mass range used for fitting (default: %(default)s)", metavar="MASS_MAX") parser.add_argument( "--p1", dest="p1", default=5.0000e-03, type=float, help="Fit function p1 parameter (default: %(default)e)", metavar="P1") parser.add_argument( "--p2", dest="p2", default=9.1000e+00, type=float, help="Fit function p2 parameter (default: %(default)e)", metavar="P2") parser.add_argument( "--p3", dest="p3", default=5.0000e-01, type=float, help="Fit function p3 parameter (default: %(default)e)", metavar="P3") parser.add_argument( "--lumiUnc", dest="lumiUnc", required=True, type=float, help="Relative uncertainty in the integrated luminosity", metavar="LUMI_UNC") parser.add_argument("--jesUnc", dest="jesUnc", type=float, help="Relative uncertainty in the jet energy scale", metavar="JES_UNC") parser.add_argument( "--jerUnc", dest="jerUnc", type=float, help="Relative uncertainty in the jet energy resolution", metavar="JER_UNC") parser.add_argument( "--sqrtS", dest="sqrtS", default=13000., type=float, help="Collision center-of-mass energy (default: %(default).1f)", metavar="SQRTS") parser.add_argument("--fixP3", dest="fixP3", default=False, action="store_true", help="Fix the fit function p3 parameter") parser.add_argument("--runFit", dest="runFit", default=False, action="store_true", help="Run the fit") parser.add_argument("--fitBonly", dest="fitBonly", default=False, action="store_true", help="Run B-only fit") parser.add_argument("--fixBkg", dest="fixBkg", default=False, action="store_true", help="Fix all background parameters") parser.add_argument("--decoBkg", dest="decoBkg", default=False, action="store_true", help="Decorrelate background parameters") parser.add_argument("--fitStrategy", dest="fitStrategy", type=int, default=1, help="Fit strategy (default: %(default).1f)") parser.add_argument("--debug", dest="debug", default=False, action="store_true", help="Debug printout") parser.add_argument( "--postfix", dest="postfix", default='', help="Postfix for the output file names (default: %(default)s)") parser.add_argument("--pyes", dest="pyes", default=False, action="store_true", help="Make files for plots") parser.add_argument("--jyes", dest="jyes", default=False, action="store_true", help="Make files for JES/JER plots") parser.add_argument( "--pdir", dest="pdir", default='testarea', help="Name a directory for the plots (default: %(default)s)") parser.add_argument("--chi2", dest="chi2", default=False, action="store_true", help="Compute chi squared") parser.add_argument("--widefit", dest="widefit", default=False, action="store_true", help="Fit with wide bin hist") mass_group = parser.add_mutually_exclusive_group(required=True) mass_group.add_argument( "--mass", type=int, nargs='*', default=1000, help= "Mass can be specified as a single value or a whitespace separated list (default: %(default)i)" ) mass_group.add_argument( "--massrange", type=int, nargs=3, help="Define a range of masses to be produced. Format: min max step", metavar=('MIN', 'MAX', 'STEP')) mass_group.add_argument("--masslist", help="List containing mass information") args = parser.parse_args() if args.atype == 'hG': fstr = "bbhGGBB" in2 = 'bcorrbin/binmodh.root' elif args.atype == 'hR': fstr = "bbhRS" in2 = 'bcorrbin/binmodh.root' elif args.atype == 'lG': fstr = "bblGGBB" in2 = 'bcorrbin/binmodl.root' else: fstr = "bblRS" in2 = 'bcorrbin/binmodl.root' # check if the output directory exists if not os.path.isdir(os.path.join(os.getcwd(), args.output_path)): os.mkdir(os.path.join(os.getcwd(), args.output_path)) # mass points for which resonance shapes will be produced masses = [] if args.massrange != None: MIN, MAX, STEP = args.massrange masses = range(MIN, MAX + STEP, STEP) elif args.masslist != None: # A mass list was provided print "Will create mass list according to", args.masslist masslist = __import__(args.masslist.replace(".py", "")) masses = masslist.masses else: masses = args.mass # sort masses masses.sort() # import ROOT stuff from ROOT import gStyle, TFile, TH1F, TH1D, TGraph, kTRUE, kFALSE, TCanvas, TLegend, TPad, TLine from ROOT import RooHist, RooRealVar, RooDataHist, RooArgList, RooArgSet, RooAddPdf, RooFit, RooGenericPdf, RooWorkspace, RooMsgService, RooHistPdf, RooExtendPdf if not args.debug: RooMsgService.instance().setSilentMode(kTRUE) RooMsgService.instance().setStreamStatus(0, kFALSE) RooMsgService.instance().setStreamStatus(1, kFALSE) # input data file inputData = TFile(args.inputData) # input data histogram hData = inputData.Get(args.dataHistname) inData2 = TFile(in2) hData2 = inData2.Get('h_data') # input sig file inputSig = TFile(args.inputSig) sqrtS = args.sqrtS # mass variable mjj = RooRealVar('mjj', 'mjj', float(args.massMin), float(args.massMax)) # integrated luminosity and signal cross section lumi = args.lumi signalCrossSection = 1. # set to 1. so that the limit on r can be interpreted as a limit on the signal cross section for mass in masses: print ">> Creating datacard and workspace for %s resonance with m = %i GeV..." % ( args.final_state, int(mass)) # get signal shape hSig = inputSig.Get("h_" + args.final_state + "_" + str(int(mass))) # normalize signal shape to the expected event yield (works even if input shapes are not normalized to unity) hSig.Scale( signalCrossSection * lumi / hSig.Integral() ) # divide by a number that provides roughly an r value of 1-10 rooSigHist = RooDataHist('rooSigHist', 'rooSigHist', RooArgList(mjj), hSig) print 'Signal acceptance:', (rooSigHist.sumEntries() / hSig.Integral()) signal = RooHistPdf('signal', 'signal', RooArgSet(mjj), rooSigHist) signal_norm = RooRealVar('signal_norm', 'signal_norm', 0, -1e+05, 1e+05) signal_norm2 = RooRealVar('signal_norm2', 'signal_norm2', 0, -1e+05, 1e+05) signal_norm3 = RooRealVar('signal_norm3', 'signal_norm3', 0, -1e+05, 1e+05) signal_norm4 = RooRealVar('signal_norm4', 'signal_norm4', 0, -1e+05, 1e+05) signal_norm5 = RooRealVar('signal_norm5', 'signal_norm5', 0, -1e+05, 1e+05) if args.fitBonly: signal_norm.setConstant() signal_norm2.setConstant() signal_norm3.setConstant() signal_norm4.setConstant() signal_norm5.setConstant() p1 = RooRealVar('p1', 'p1', args.p1, 0., 100.) p2 = RooRealVar('p2', 'p2', args.p2, 0., 60.) p3 = RooRealVar('p3', 'p3', args.p3, -10., 10.) p4 = RooRealVar('p4', 'p4', 5.6, -50., 50.) p5 = RooRealVar('p5', 'p5', 10., -50., 50.) p6 = RooRealVar('p6', 'p6', .016, -50., 50.) p7 = RooRealVar('p7', 'p7', 8., -50., 50.) p8 = RooRealVar('p8', 'p8', .22, -50., 50.) p9 = RooRealVar('p9', 'p9', 14.1, -50., 50.) p10 = RooRealVar('p10', 'p10', 8., -50., 50.) p11 = RooRealVar('p11', 'p11', 4.8, -50., 50.) p12 = RooRealVar('p12', 'p12', 7., -50., 50.) p13 = RooRealVar('p13', 'p13', 7., -50., 50.) p14 = RooRealVar('p14', 'p14', 7., -50., 50.) p15 = RooRealVar('p15', 'p15', 1., -50., 50.) p16 = RooRealVar('p16', 'p16', 9., -50., 50.) p17 = RooRealVar('p17', 'p17', 0.6, -50., 50.) if args.fixP3: p3.setConstant() background = RooGenericPdf( 'background', '(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))' % (sqrtS, sqrtS, sqrtS), RooArgList(mjj, p1, p2, p3)) dataInt = hData.Integral(hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background_norm = RooRealVar('background_norm', 'background_norm', dataInt, 0., 1e+08) background2 = RooGenericPdf( 'background2', '(pow(@0/%.1f,-@1)*pow(1-@0/%.1f,@2))' % (sqrtS, sqrtS), RooArgList(mjj, p4, p5)) dataInt2 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background2_norm = RooRealVar('background2_norm', 'background2_norm', dataInt2, 0., 1e+08) background3 = RooGenericPdf('background3', '(1/pow(@1+@0/%.1f,@2))' % (sqrtS), RooArgList(mjj, p6, p7)) dataInt3 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background3_norm = RooRealVar('background3_norm', 'background3_norm', dataInt3, 0., 1e+08) background4 = RooGenericPdf( 'background4', '(1/pow(@1+@2*@0/%.1f+pow(@0/%.1f,2),@3))' % (sqrtS, sqrtS), RooArgList(mjj, p8, p9, p10)) dataInt4 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background4_norm = RooRealVar('background4_norm', 'background4_norm', dataInt4, 0., 1e+08) background5 = RooGenericPdf( 'background5', '(pow(@0/%.1f,-@1)*pow(1-pow(@0/%.1f,1/3),@2))' % (sqrtS, sqrtS), RooArgList(mjj, p11, p12)) dataInt5 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background5_norm = RooRealVar('background5_norm', 'background5_norm', dataInt5, 0., 1e+08) background6 = RooGenericPdf( 'background6', '(pow(@0/%.1f,2)+@1*@0/%.1f+@2)' % (sqrtS, sqrtS), RooArgList(mjj, p13, p14)) dataInt6 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background_norm6 = RooRealVar('background_norm6', 'background_norm6', dataInt6, 0., 1e+08) background7 = RooGenericPdf( 'background7', '((-1+@1*@0/%.1f)*pow(@0/%.1f,@2+@3*log(@0/%.1f)))' % (sqrtS, sqrtS, sqrtS), RooArgList(mjj, p15, p16, p17)) dataInt7 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background_norm7 = RooRealVar('background_norm7', 'background_norm7', dataInt7, 0., 1e+08) #Extend PDFs exts = RooExtendPdf('extsignal', 'Extended Signal Pdf', signal, signal_norm) extb = RooExtendPdf('extbackground', 'Extended Background Pdf', background, background_norm) exts2 = RooExtendPdf('extsignal2', 'Extended Signal Pdf2', signal, signal_norm2) extb2 = RooExtendPdf('extbackground2', 'Extended Background Pdf2', background2, background2_norm) exts3 = RooExtendPdf('extsignal3', 'Extended Signal Pdf3', signal, signal_norm3) extb3 = RooExtendPdf('extbackground3', 'Extended Background Pdf3', background3, background3_norm) exts4 = RooExtendPdf('extsignal4', 'Extended Signal Pdf4', signal, signal_norm4) extb4 = RooExtendPdf('extbackground4', 'Extended Background Pdf4', background4, background4_norm) exts5 = RooExtendPdf('extsignal5', 'Extended Signal Pdf5', signal, signal_norm5) extb5 = RooExtendPdf('extbackground5', 'Extended Background Pdf5', background5, background5_norm) # S+B model model = RooAddPdf("model", "s+b", RooArgList(extb, exts)) model2 = RooAddPdf("model2", "s+b2", RooArgList(extb2, exts2)) model3 = RooAddPdf("model3", "s+b3", RooArgList(extb3, exts3)) model4 = RooAddPdf("model4", "s+b4", RooArgList(extb4, exts4)) model5 = RooAddPdf("model5", "s+b5", RooArgList(extb5, exts5)) #model6 = RooAddPdf("model6","s+b6",RooArgList(background6,signal),RooArgList(background_norm6,signal_norm)) #model7 = RooAddPdf("model7","s+b7",RooArgList(background7,signal),RooArgList(background_norm7,signal_norm)) rooDataHist = RooDataHist('rooDatahist', 'rooDathist', RooArgList(mjj), hData) if args.runFit: mframe = mjj.frame() rooDataHist.plotOn(mframe, ROOT.RooFit.Name("setonedata")) res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) model.plotOn(mframe, ROOT.RooFit.Name("model1"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kRed)) res2 = model2.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) # model2.plotOn(mframe, ROOT.RooFit.Name("model2"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kOrange)) res3 = model3.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) # model3.plotOn(mframe, ROOT.RooFit.Name("model3"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kGreen)) res4 = model4.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) # model4.plotOn(mframe, ROOT.RooFit.Name("model4"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kBlue)) res5 = model5.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) # model5.plotOn(mframe, ROOT.RooFit.Name("model5"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kViolet)) # res6 = model6.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) # model6.plotOn(mframe, ROOT.RooFit.Name("model6"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kPink)) # res7 = model7.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) # model7.plotOn(mframe, ROOT.RooFit.Name("model7"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kAzure)) rooDataHist2 = RooDataHist('rooDatahist2', 'rooDathist2', RooArgList(mjj), hData2) # rooDataHist2.plotOn(mframe, ROOT.RooFit.Name("data")) if args.pyes: c = TCanvas("c", "c", 800, 800) mframe.SetAxisRange(300., 1300.) c.SetLogy() # mframe.SetMaximum(10) # mframe.SetMinimum(1) mframe.Draw() fitname = args.pdir + '/5funcfit_m' + str(mass) + fstr + '.pdf' c.SaveAs(fitname) # cpull = TCanvas("cpull","cpull",800,800) # pulls = mframe.pullHist("data","model1") # pulls.Draw("ABX") # pullname = args.pdir+'/pull_m'+str(mass)+fstr+'.pdf' # cpull.SaveAs(pullname) # cpull2 = TCanvas("cpull2","cpull2",800,800) # pulls2 = mframe.pullHist("setonedata","model1") # pulls2.Draw("ABX") # pull2name = args.pdir+'/pull2_m'+str(mass)+fstr+'.pdf' # cpull2.SaveAs(pull2name) if args.widefit: mframew = mjj.frame() rooDataHist2.plotOn(mframew, ROOT.RooFit.Name("data")) res6 = model.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model.plotOn(mframew, ROOT.RooFit.Name("model1"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kRed)) res7 = model2.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model2.plotOn(mframew, ROOT.RooFit.Name("model2"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kOrange)) res8 = model3.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model3.plotOn(mframew, ROOT.RooFit.Name("model3"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kGreen)) res9 = model4.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model4.plotOn(mframew, ROOT.RooFit.Name("model4"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kBlue)) res10 = model5.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model5.plotOn(mframew, ROOT.RooFit.Name("model5"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kViolet)) if args.pyes: c = TCanvas("c", "c", 800, 800) mframew.SetAxisRange(300., 1300.) c.SetLogy() # mframew.SetMaximum(10) # mframew.SetMinimum(1) mframew.Draw() fitname = args.pdir + '/5funcfittowide_m' + str( mass) + fstr + '.pdf' c.SaveAs(fitname) cpull = TCanvas("cpull", "cpull", 800, 800) pulls = mframew.pullHist("data", "model1") pulls.Draw("ABX") pullname = args.pdir + '/pullwidefit_m' + str( mass) + fstr + '.pdf' cpull.SaveAs(pullname) if args.chi2: fullInt = model.createIntegral(RooArgSet(mjj)) norm = dataInt / fullInt.getVal() chi1 = 0. fullInt2 = model2.createIntegral(RooArgSet(mjj)) norm2 = dataInt2 / fullInt2.getVal() chi2 = 0. fullInt3 = model3.createIntegral(RooArgSet(mjj)) norm3 = dataInt3 / fullInt3.getVal() chi3 = 0. fullInt4 = model4.createIntegral(RooArgSet(mjj)) norm4 = dataInt4 / fullInt4.getVal() chi4 = 0. fullInt5 = model5.createIntegral(RooArgSet(mjj)) norm5 = dataInt5 / fullInt5.getVal() chi5 = 0. for i in range(args.massMin, args.massMax): new = 0 new2 = 0 new3 = 0 new4 = 0 new5 = 0 height = hData.GetBinContent(i) xLow = hData.GetXaxis().GetBinLowEdge(i) xUp = hData.GetXaxis().GetBinLowEdge(i + 1) obs = height * (xUp - xLow) mjj.setRange("intrange", xLow, xUp) integ = model.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp = integ.getVal() * norm new = pow(exp - obs, 2) / exp chi1 = chi1 + new integ2 = model2.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp2 = integ2.getVal() * norm2 new2 = pow(exp2 - obs, 2) / exp2 chi2 = chi2 + new2 integ3 = model3.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp3 = integ3.getVal() * norm3 new3 = pow(exp3 - obs, 2) / exp3 chi3 = chi3 + new3 integ4 = model4.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp4 = integ4.getVal() * norm4 if exp4 != 0: new4 = pow(exp4 - obs, 2) / exp4 else: new4 = 0 chi4 = chi4 + new4 integ5 = model5.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp5 = integ5.getVal() * norm5 new5 = pow(exp5 - obs, 2) / exp5 chi5 = chi5 + new5 print "chi1 %d " % (chi1) print "chi2 %d " % (chi2) print "chi3 %d " % (chi3) print "chi4 %d " % (chi4) print "chi5 %d " % (chi5) if not args.decoBkg: print " " res.Print() res2.Print() res3.Print() res4.Print() res5.Print() # res6.Print() # res7.Print() # decorrelated background parameters for Bayesian limits if args.decoBkg: signal_norm.setConstant() res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) res.Print() ## temp workspace for the PDF diagonalizer w_tmp = RooWorkspace("w_tmp") deco = PdfDiagonalizer("deco", w_tmp, res) # here diagonalizing only the shape parameters since the overall normalization is already decorrelated background_deco = deco.diagonalize(background) print "##################### workspace for decorrelation" w_tmp.Print("v") print "##################### original parameters" background.getParameters(rooDataHist).Print("v") print "##################### decorrelated parameters" # needed if want to evaluate limits without background systematics if args.fixBkg: w_tmp.var("deco_eig1").setConstant() w_tmp.var("deco_eig2").setConstant() if not args.fixP3: w_tmp.var("deco_eig3").setConstant() background_deco.getParameters(rooDataHist).Print("v") print "##################### original pdf" background.Print() print "##################### decorrelated pdf" background_deco.Print() # release signal normalization signal_norm.setConstant(kFALSE) # set the background normalization range to +/- 5 sigma bkg_val = background_norm.getVal() bkg_error = background_norm.getError() background_norm.setMin(bkg_val - 5 * bkg_error) background_norm.setMax(bkg_val + 5 * bkg_error) background_norm.Print() # change background PDF names background.SetName("background_old") background_deco.SetName("background") # needed if want to evaluate limits without background systematics if args.fixBkg: background_norm.setConstant() p1.setConstant() p2.setConstant() p3.setConstant() # ----------------------------------------- # dictionaries holding systematic variations of the signal shape hSig_Syst = {} hSig_Syst_DataHist = {} sigCDF = TGraph(hSig.GetNbinsX() + 1) # JES and JER uncertainties if args.jesUnc != None or args.jerUnc != None: sigCDF.SetPoint(0, 0., 0.) integral = 0. for i in range(1, hSig.GetNbinsX() + 1): x = hSig.GetXaxis().GetBinLowEdge(i + 1) integral = integral + hSig.GetBinContent(i) sigCDF.SetPoint(i, x, integral) if args.jesUnc != None: hSig_Syst['JESUp'] = copy.deepcopy(hSig) hSig_Syst['JESDown'] = copy.deepcopy(hSig) if args.jerUnc != None: hSig_Syst['JERUp'] = copy.deepcopy(hSig) hSig_Syst['JERDown'] = copy.deepcopy(hSig) # reset signal histograms for key in hSig_Syst.keys(): hSig_Syst[key].Reset() hSig_Syst[key].SetName(hSig_Syst[key].GetName() + '_' + key) # produce JES signal shapes if args.jesUnc != None: for i in range(1, hSig.GetNbinsX() + 1): xLow = hSig.GetXaxis().GetBinLowEdge(i) xUp = hSig.GetXaxis().GetBinLowEdge(i + 1) jes = 1. - args.jesUnc xLowPrime = jes * xLow xUpPrime = jes * xUp hSig_Syst['JESUp'].SetBinContent( i, sigCDF.Eval(xUpPrime) - sigCDF.Eval(xLowPrime)) jes = 1. + args.jesUnc xLowPrime = jes * xLow xUpPrime = jes * xUp hSig_Syst['JESDown'].SetBinContent( i, sigCDF.Eval(xUpPrime) - sigCDF.Eval(xLowPrime)) hSig_Syst_DataHist['JESUp'] = RooDataHist('hSig_JESUp', 'hSig_JESUp', RooArgList(mjj), hSig_Syst['JESUp']) hSig_Syst_DataHist['JESDown'] = RooDataHist( 'hSig_JESDown', 'hSig_JESDown', RooArgList(mjj), hSig_Syst['JESDown']) if args.jyes: c2 = TCanvas("c2", "c2", 800, 800) mframe2 = mjj.frame(ROOT.RooFit.Title("JES One Sigma Shifts")) mframe2.SetAxisRange(args.massMin, args.massMax) hSig_Syst_DataHist['JESUp'].plotOn( mframe2, ROOT.RooFit.Name("JESUP"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kRed), ROOT.RooFit.LineColor(ROOT.EColor.kRed)) hSig_Syst_DataHist['JESDown'].plotOn( mframe2, ROOT.RooFit.Name("JESDOWN"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kBlue), ROOT.RooFit.LineColor(ROOT.EColor.kBlue)) rooSigHist.plotOn(mframe2, ROOT.RooFit.DataError(2), ROOT.RooFit.Name("SIG"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kGreen), ROOT.RooFit.LineColor(ROOT.EColor.kGreen)) mframe2.Draw() mframe2.GetXaxis().SetTitle("Dijet Mass (GeV)") leg = TLegend(0.7, 0.8, 0.9, 0.9) leg.SetFillColor(0) leg.AddEntry(mframe2.findObject("SIG"), "Signal Model", "l") leg.AddEntry(mframe2.findObject("JESUP"), "+1 Sigma", "l") leg.AddEntry(mframe2.findObject("JESDOWN"), "-1 Sigma", "l") leg.Draw() jesname = args.pdir + '/jes_m' + str(mass) + fstr + '.pdf' c2.SaveAs(jesname) # produce JER signal shapes if args.jesUnc != None: for i in range(1, hSig.GetNbinsX() + 1): xLow = hSig.GetXaxis().GetBinLowEdge(i) xUp = hSig.GetXaxis().GetBinLowEdge(i + 1) jer = 1. - args.jerUnc xLowPrime = jer * (xLow - float(mass)) + float(mass) xUpPrime = jer * (xUp - float(mass)) + float(mass) hSig_Syst['JERUp'].SetBinContent( i, sigCDF.Eval(xUpPrime) - sigCDF.Eval(xLowPrime)) jer = 1. + args.jerUnc xLowPrime = jer * (xLow - float(mass)) + float(mass) xUpPrime = jer * (xUp - float(mass)) + float(mass) hSig_Syst['JERDown'].SetBinContent( i, sigCDF.Eval(xUpPrime) - sigCDF.Eval(xLowPrime)) hSig_Syst_DataHist['JERUp'] = RooDataHist('hSig_JERUp', 'hSig_JERUp', RooArgList(mjj), hSig_Syst['JERUp']) hSig_Syst_DataHist['JERDown'] = RooDataHist( 'hSig_JERDown', 'hSig_JERDown', RooArgList(mjj), hSig_Syst['JERDown']) if args.jyes: c3 = TCanvas("c3", "c3", 800, 800) mframe3 = mjj.frame(ROOT.RooFit.Title("JER One Sigma Shifts")) mframe3.SetAxisRange(args.massMin, args.massMax) hSig_Syst_DataHist['JERUp'].plotOn( mframe3, ROOT.RooFit.Name("JERUP"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kRed), ROOT.RooFit.LineColor(ROOT.EColor.kRed)) hSig_Syst_DataHist['JERDown'].plotOn( mframe3, ROOT.RooFit.Name("JERDOWN"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kBlue), ROOT.RooFit.LineColor(ROOT.EColor.kBlue)) rooSigHist.plotOn(mframe3, ROOT.RooFit.DrawOption("L"), ROOT.RooFit.Name("SIG"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kGreen), ROOT.RooFit.LineColor(ROOT.EColor.kGreen)) mframe3.Draw() mframe3.GetXaxis().SetTitle("Dijet Mass (GeV)") leg = TLegend(0.7, 0.8, 0.9, 0.9) leg.SetFillColor(0) leg.AddEntry(mframe3.findObject("SIG"), "Signal Model", "l") leg.AddEntry(mframe3.findObject("JERUP"), "+1 Sigma", "l") leg.AddEntry(mframe3.findObject("JERDOWN"), "-1 Sigma", "l") leg.Draw() jername = args.pdir + '/jer_m' + str(mass) + fstr + '.pdf' c3.SaveAs(jername) # ----------------------------------------- # create a datacard and corresponding workspace postfix = (('_' + args.postfix) if args.postfix != '' else '') dcName = 'datacard_' + args.final_state + '_m' + str( mass) + postfix + '.txt' wsName = 'workspace_' + args.final_state + '_m' + str( mass) + postfix + '.root' w = RooWorkspace('w', 'workspace') getattr(w, 'import')(rooSigHist, RooFit.Rename("signal")) if args.jesUnc != None: getattr(w, 'import')(hSig_Syst_DataHist['JESUp'], RooFit.Rename("signal__JESUp")) getattr(w, 'import')(hSig_Syst_DataHist['JESDown'], RooFit.Rename("signal__JESDown")) if args.jerUnc != None: getattr(w, 'import')(hSig_Syst_DataHist['JERUp'], RooFit.Rename("signal__JERUp")) getattr(w, 'import')(hSig_Syst_DataHist['JERDown'], RooFit.Rename("signal__JERDown")) if args.decoBkg: getattr(w, 'import')(background_deco, ROOT.RooCmdArg()) else: getattr(w, 'import')(background, ROOT.RooCmdArg(), RooFit.Rename("background")) getattr(w, 'import')(background2, ROOT.RooCmdArg(), RooFit.Rename("background2")) getattr(w, 'import')(background3, ROOT.RooCmdArg(), RooFit.Rename("background3")) getattr(w, 'import')(background4, ROOT.RooCmdArg(), RooFit.Rename("background4")) getattr(w, 'import')(background5, ROOT.RooCmdArg(), RooFit.Rename("background5")) getattr(w, 'import')(background_norm, ROOT.RooCmdArg(), RooFit.Rename("background_norm")) getattr(w, 'import')(background2_norm, ROOT.RooCmdArg(), RooFit.Rename("background2_norm")) getattr(w, 'import')(background3_norm, ROOT.RooCmdArg(), RooFit.Rename("background3_norm")) getattr(w, 'import')(background4_norm, ROOT.RooCmdArg(), RooFit.Rename("background4_norm")) getattr(w, 'import')(background5_norm, ROOT.RooCmdArg(), RooFit.Rename("background5_norm")) getattr(w, 'import')(res) getattr(w, 'import')(res2) getattr(w, 'import')(res3) getattr(w, 'import')(res4) getattr(w, 'import')(res5) getattr(w, 'import')(background_norm, ROOT.RooCmdArg()) getattr(w, 'import')(signal_norm, ROOT.RooCmdArg()) getattr(w, 'import')(rooDataHist, RooFit.Rename("data_obs")) w.Print() w.writeToFile(os.path.join(args.output_path, wsName)) beffUnc = 0.3 boffUnc = 0.06 datacard = open(os.path.join(args.output_path, dcName), 'w') datacard.write('imax 1\n') datacard.write('jmax 1\n') datacard.write('kmax *\n') datacard.write('---------------\n') if args.jesUnc != None or args.jerUnc != None: datacard.write('shapes * * ' + wsName + ' w:$PROCESS w:$PROCESS__$SYSTEMATIC\n') else: datacard.write('shapes * * ' + wsName + ' w:$PROCESS\n') datacard.write('---------------\n') datacard.write('bin 1\n') datacard.write('observation -1\n') datacard.write('------------------------------\n') datacard.write('bin 1 1\n') datacard.write('process signal background\n') datacard.write('process 0 1\n') datacard.write('rate -1 1\n') datacard.write('------------------------------\n') datacard.write('lumi lnN %f -\n' % (1. + args.lumiUnc)) datacard.write('beff lnN %f -\n' % (1. + beffUnc)) datacard.write('boff lnN %f -\n' % (1. + boffUnc)) datacard.write('bkg lnN - 1.03\n') if args.jesUnc != None: datacard.write('JES shape 1 -\n') if args.jerUnc != None: datacard.write('JER shape 1 -\n') # flat parameters --- flat prior datacard.write('background_norm flatParam\n') if args.decoBkg: datacard.write('deco_eig1 flatParam\n') datacard.write('deco_eig2 flatParam\n') if not args.fixP3: datacard.write('deco_eig3 flatParam\n') else: datacard.write('p1 flatParam\n') datacard.write('p2 flatParam\n') if not args.fixP3: datacard.write('p3 flatParam\n') datacard.close() print '>> Datacards and workspaces created and stored in %s/' % ( os.path.join(os.getcwd(), args.output_path))
minPed = int(minPed) - 2.5 maxPed = int(maxPed) + 2.5 print 'minPed:', minPed, 'maxPed:', maxPed while int((maxPed - minPed) / 2.) * 2. < (maxPed - minPed): maxPed += 1. print 'minPed:', minPed, 'maxPed:', maxPed dataTree.Draw( '{0}>>pedhist({1},{2:0.1f},{3:0.1f}'.format(HOTower, int(maxPed - minPed), minPed, maxPed), pedCut, 'goff') pedhist = gDirectory.Get('pedhist') ws = RooWorkspace('ws') x = RooRealVar('x', 'energy', minPed, maxPed, 'fC') x.Print() ds = fillDataSet(dataTree.GetV1(), x, dataTree.GetSelectedRows()) getattr(ws, 'import')(ds) findOnePe(pedhist, ws, Npe=opts.npe) pedPlusOne = ws.pdf('pedPlusOne') peMean = ws.var('peMean') pedMean = ws.var('pedMean') ## pedhist.Draw() ## onePeF.Draw('same') xf = x.frame(x.getMin(), x.getMax(), int(x.getMax() - x.getMin())) ds.plotOn(xf) pedPlusOne.plotOn(xf) #, #RooFit.Range('pedPlus_fit'))
def shapeCards( process, isData, datahistosFile, histosFile, signalHistosFile, signalSample, hist, signalMass, minMass, maxMass, jesValue, jerValue, lumiUnc, outputName ): """function to run Roofit and save workspace for RooStats""" warnings.filterwarnings( action='ignore', category=RuntimeWarning, message='.*class stack<RooAbsArg\*,deque<RooAbsArg\*> >' ) hSignal = signalHistosFile.Get(hist+'_'+signalSample) hSignal.Rebin(10) htmpSignal = hSignal.Clone() #htmpSignal.Scale(100) signalXS = search(dictXS, 'RPVStopStopToJets_UDD312_M-'+str(signalMass) ) #hSignal.Scale( lumi*signalXS / hSignal.Integral()) massAve = RooRealVar( 'massAve', 'massAve', minMass, maxMass ) rooSigHist = RooDataHist( 'rooSigHist', 'rooSigHist', RooArgList(massAve), hSignal ) rooSigHist.Print() signal = RooHistPdf('signal','signal',RooArgSet(massAve),rooSigHist) signal.Print() signal_norm = RooRealVar('signal_norm','signal_norm',0,-1e+04,1e+04) #if args.fitBonly: signal_norm.setConstant() signal_norm.Print() hBkg = datahistosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj') #hBkg = histosFile.Get(hist+'_QCDPtAll_BCD') bkgAcc = round(hBkg.Integral( hBkg.GetXaxis().FindBin( minMass ), hBkg.GetXaxis().FindBin( maxMass ))) #hBkg.Scale(1/hBkg.Integral()) hPseudo = hBkg.Clone() hPseudo.Reset() #background_norm = RooRealVar('background_norm','background_norm',bkgAcc,0.,1e+07) background_norm = RooRealVar('background_norm','background_norm',1.,0.,1e+07) background_norm.Print() if 'template' in process: rooBkgHist = RooDataHist( 'rooBkgHist', 'rooBkgHist', RooArgList(massAve), hBkg ) rooBkgHist.Print() background = RooHistPdf('background','background',RooArgSet(massAve),rooBkgHist) background.Print() else: p1 = RooRealVar('p1','p1', 1 ,0.,100.) p2 = RooRealVar('p2','p2', 1 ,0.,60.) p3 = RooRealVar('p3','p3', 1 , -10.,10.) background = RooGenericPdf('background','(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))'%(1300,1300,1300),RooArgList(massAve,p1,p2,p3)) background.Print() ### S+B model if not isData: newNumEvents = random.randint( bkgAcc-round(TMath.Sqrt(bkgAcc)), bkgAcc+round(TMath.Sqrt(bkgAcc)) ) print 'Events in MC:', bkgAcc, ', in PseudoExperiment:', newNumEvents hPseudo.FillRandom( hBkg, newNumEvents ) #hPseudo.Scale(1/hPseudo.Integral()) #hData = histosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_ABCDProj') hData = datahistosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj') #hData = histosFile.Get(hist+'_QCDPtAll_A') #hData.Add(htmpSignal) #hData.Scale(1/hData.Integral()) rooDataHist = RooDataHist('rooDatahist','rooDatahist',RooArgList(massAve), hData if isData else hPseudo ) rooDataHist.Print() #model = RooAddPdf("model","s+b",RooArgList(background,signal),RooArgList(background_norm,signal_norm)) #res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(0)) #res.Print() ############# JES and JER uncertainties hSigSyst = {} hSigSystDataHist = {} signalCDF = TGraph(hSignal.GetNbinsX()+1) # JES and JER uncertainties if args.jesUnc or args.jerUnc: signalCDF.SetPoint(0,0.,0.) integral = 0. for i in range(1, hSignal.GetNbinsX()+1): x = hSignal.GetXaxis().GetBinLowEdge(i+1) integral = integral + hSignal.GetBinContent(i) signalCDF.SetPoint(i,x,integral) if args.jesUnc: print ' |---> Adding JES' hSigSyst['JESUp'] = hSignal.Clone() hSigSyst['JESDown'] = hSignal.Clone() if args.jerUnc: print ' |---> Adding JER' hSigSyst['JERUp'] = hSignal.Clone() hSigSyst['JERDown'] = hSignal.Clone() # reset signal histograms for key in hSigSyst: hSigSyst[key].Reset() hSigSyst[key].SetName(hSigSyst[key].GetName() + '_' + key) # produce JES signal shapes if args.jesUnc: for q in range(1, hSignal.GetNbinsX()+1): xLow = hSignal.GetXaxis().GetBinLowEdge(q) xUp = hSignal.GetXaxis().GetBinLowEdge(q+1) jes = 1. - jesValue xLowPrime = jes*xLow xUpPrime = jes*xUp hSigSyst['JESUp'].SetBinContent(q, signalCDF.Eval(xUpPrime) - signalCDF.Eval(xLowPrime)) jes = 1. + jesValue xLowPrime = jes*xLow xUpPrime = jes*xUp hSigSyst['JESDown'].SetBinContent(q, signalCDF.Eval(xUpPrime) - signalCDF.Eval(xLowPrime)) hSigSystDataHist['JESUp'] = RooDataHist('hSignalJESUp','hSignalJESUp',RooArgList(massAve),hSigSyst['JESUp']) hSigSystDataHist['JESDown'] = RooDataHist('hSignalJESDown','hSignalJESDown',RooArgList(massAve),hSigSyst['JESDown']) # produce JER signal shapes if args.jerUnc: for i in range(1, hSignal.GetNbinsX()+1): xLow = hSignal.GetXaxis().GetBinLowEdge(i) xUp = hSignal.GetXaxis().GetBinLowEdge(i+1) jer = 1. - jerValue xLowPrime = jer*(xLow-float(signalMass))+float(signalMass) xUpPrime = jer*(xUp-float(signalMass))+float(signalMass) hSigSyst['JERUp'].SetBinContent(i, signalCDF.Eval(xUpPrime) - signalCDF.Eval(xLowPrime)) jer = 1. + jerValue xLowPrime = jer*(xLow-float(signalMass))+float(signalMass) xUpPrime = jer*(xUp-float(signalMass))+float(signalMass) hSigSyst['JERDown'].SetBinContent(i, signalCDF.Eval(xUpPrime) - signalCDF.Eval(xLowPrime)) hSigSystDataHist['JERUp'] = RooDataHist('hSignalJERUp','hSignalJERUp',RooArgList(massAve),hSigSyst['JERUp']) hSigSystDataHist['JERDown'] = RooDataHist('hSignalJERDown','hSignalJERDown',RooArgList(massAve),hSigSyst['JERDown']) myWS = RooWorkspace("myWS") getattr(myWS,'import')(rooSigHist,RooFit.Rename("signal")) getattr(myWS,'import')(rooBkgHist,RooFit.Rename("background")) #getattr(myWS,'import')(signal_norm) getattr(myWS,'import')(background_norm) if args.jesUnc: getattr(myWS,'import')(hSigSystDataHist['JESUp'],RooFit.Rename("signal__JESUp")) getattr(myWS,'import')(hSigSystDataHist['JESDown'],RooFit.Rename("signal__JESDown")) if args.jerUnc: getattr(myWS,'import')(hSigSystDataHist['JERUp'],RooFit.Rename("signal__JERUp")) getattr(myWS,'import')(hSigSystDataHist['JERDown'],RooFit.Rename("signal__JERDown")) getattr(myWS,'import')(rooDataHist,RooFit.Rename("data_obs")) myWS.Print() outputRootFile = currentDir+'/Rootfiles/workspace_'+outputName+'.root' myWS.writeToFile(outputRootFile, True) print ' |----> Workspace created in root file:\n', outputRootFile # ----------------------------------------- # write a datacard dataCardName = currentDir+'/Datacards/datacard_'+outputName+'.txt' datacard = open( dataCardName ,'w') datacard.write('imax 1\n') datacard.write('jmax 1\n') datacard.write('kmax *\n') datacard.write('---------------\n') if args.jesUnc or args.jerUnc or args.lumiUnc or args.normUnc or args.unc: datacard.write('shapes * * '+outputRootFile+' myWS:$PROCESS myWS:$PROCESS__$SYSTEMATIC\n') else: datacard.write("shapes * * "+outputRootFile+" myWS:$PROCESS \n") datacard.write('---------------\n') datacard.write('bin 1\n') datacard.write('observation -1\n') datacard.write('------------------------------\n') datacard.write('bin 1 1\n') datacard.write('process signal background\n') datacard.write('process 0 1\n') datacard.write('rate -1 -1\n') datacard.write('------------------------------\n') if args.lumiUnc: datacard.write('lumi lnN %f -\n'%(lumiUnc)) if args.jesUnc: datacard.write('JES shape 1 -\n') if args.jerUnc: datacard.write('JER shape 1 -\n') #flat parameters --- flat prior if args.normUnc: datacard.write('background_norm flatParam\n') #datacard.write('p1 flatParam\n') datacard.close() print ' |----> Datacard created:\n', dataCardName
#sys.exit(0); #sys.exit(0); # 0 - etaAvgList (per-category avg. etas) # 1 - etaAvg (avg. eta for all events) # 2 - genEtaList (mistagList?) # 3 - ProcessID0 etaAvgValVarList = keyList.At(0).ReadObj() etaAvg = keyList.At(1).ReadObj() mistagList = keyList.At(2).ReadObj() etaAvgValVarList.Print() etaAvg.Print() mistagList.Print() in_file.Close() mistagVsEtaGraph = TGraphErrors(etaAvgValVarList.GetSize()) linFunc = TF1('linFunc', '[0]+[1]*(x-%f)' % etaAvg.getValV(), 0.0, 0.5) ROOT.SetOwnership(linFunc, False) linFuncList += [linFunc] #linFuncList += [TF1('linFunc','[0]+[1]*x',0.0,0.5)]; linFuncList[-1].SetParameters(etaAvg.getValV(), 1.0) #ROOT.SetOwnership(linFunc, False) for i in range(etaAvgValVarList.GetSize()): mistagVsEtaGraph.SetPoint(i,
mean = RooRealVar("mean", "MeanofGaussian", 0, -10, 10) sigma = RooRealVar("sigma", "WidthofGaussian", 3, -10, 10) gauss = RooGaussian("gauss", "gauss(x,mean,sigma)", x, mean, sigma) g1sig = RooRealVar("g1sig", "fraction of gauss1", 10, 0, 100000.0) # Build signal PDF: f1 signalPDF = RooAddPdf("signalPDF", "g1sig * g1", RooArgList(gauss), RooArgList(g1sig)) #mean.setConstant(kTRUE); #fix mean sigma.setRange(0.1, 3) # change range for sigma gauss.fitTo(data, RooFit.PrintLevel(-1)) # ffit gauss on data signalPDF.fitTo(data, RooFit.PrintLevel(-1)) #PrintLevel(-1) almost no output # Minos(kTRUE)? mean.Print() sigma.Print() #Show parameters on plot signalPDF.paramOn(xframe, RooFit.Layout(0.55, 0.9, 0.9), RooFit.Format("NEU", RooFit.AutoPrecision(1))) signalPDF.plotOn(xframe) xframe.Draw() chi2txt = TLatex() chi2txt.SetNDC() chi2txt.DrawLatex(0.13, 0.83, "\chi^2/n.d.f = %0.3f" % xframe.chiSquare()) #Put chi² on plot
def fitWPeak(): # Get histograms from file mcHist = 0 with root_open(inputFile, 'read') as file: gROOT.cd() mcHist = file.Get(inputHistogram).Clone('histToFit') # mcHist = file.Get(inputHistogram).GetStack().Last().Clone('histToFit') # Data hist gone out of scope? print mcHist # Import the data to fit # Declare variables x,mean,sigma with associated name, title, initial value and allowed range x = RooRealVar("M(jj)", "M(jj)", 40, 180) histToFit = RooDataHist('histToFit', 'histToFit', RooArgList(x), RooFit.Import(mcHist)) frame = x.frame(RooFit.Title("E Plus Jets")) histToFit.plotOn(frame) # Setup fit function fitFunction = None print fitFunction if whatToFit == 'realLife': # Stuff for gauss mg = RooRealVar("mean", "mean of gaussian", 86, 50, 120) sg = RooRealVar("sigma", "width of gaussian", 10, 0, 50) gauss = RooGaussian("gauss", "gaussian PDF", x, mg, sg) CBmean = RooRealVar("CBmean", "CBmean", 110, 60, 200) CBsigma = RooRealVar("CBsigma", "CBsigma", 40, 20, 100) CBalpha = RooRealVar("CBalpha", "CBalpha", -0.5, -20., 0.) # CBalpha = RooRealVar("CBalpha", "CBalpha", 10, 0., 20.) CBn = RooRealVar("CBn", "CBn", 1., 0., 20.) crystalBall = RooCBShape("crystalBall", "Crystal Ball resolution model", x, CBmean, CBsigma, CBalpha, CBn) fracGauss = RooRealVar("fracGauss", "fracGauss", 0.4, 0, 1) gaussPlusCrystalBall = RooAddPdf("gaussPlusCrystalBall", "Gauss plus Crystal Ball", RooArgList(gauss, crystalBall), RooArgList(fracGauss)) fitFunction = gaussPlusCrystalBall elif whatToFit == 'partons': mg = RooRealVar("mean", "mean of gaussian", 86, 50, 120) sg = RooRealVar("sigma", "width of gaussian", 10, 0, 50) breitWigner = RooBreitWigner('bw', 'bw', x, mg, sg) fitFunction = breitWigner elif whatToFit == 'genJetsFromPartons': # mg = RooRealVar("mean","mean of gaussian",86,50,120) # sg = RooRealVar("sigma","width of gaussian",10,0,50) # breitWigner = RooBreitWigner('bw', 'bw', x, mg, sg) # fitFunction = breitWigner # mg = RooRealVar("mean","mean of gaussian",86,50,120) # sg = RooRealVar("sigma","width of gaussian",1,0,20) # width = RooRealVar("width","width of gaussian",5,0,50) # voigtian = RooVoigtian("voigt","voigt",x,mg,sg,width); # fitFunction = voigtian mg = RooRealVar("mean", "mean of gaussian", 86, 50, 120) sg = RooRealVar("sigma", "width of gaussian", 10, 0, 50) gauss = RooGaussian("gauss", "gaussian PDF", x, mg, sg) fitFunction = gauss print fitFunction # # Fit pdf to data fitFunction.fitTo(histToFit) # Plot histogram being fitted histToFit.plotOn(frame) # Plot fit functions and components fitFunction.plotOn(frame, RooFit.LineColor(kRed)) print 'Chi square with 7 : ', frame.chiSquare(7) print frame.chiSquare() print fitFunction.getParameters(histToFit).selectByAttrib( 'Constant', kFALSE).getSize() toPlot = RooArgSet(crystalBall) fitFunction.plotOn(frame, RooFit.Components(toPlot), RooFit.LineStyle(kDashed), RooFit.LineColor(kRed)) toPlot = RooArgSet(gauss) fitFunction.plotOn(frame, RooFit.Components(toPlot), RooFit.LineStyle(kDashed), RooFit.LineColor(kBlue)) fitFunction.paramOn(frame, RooFit.Layout(0.55, 0.9, 0.9)) # Print values of mean and sigma (that now reflect fitted values and errors) mg.Print() sg.Print() # CBmean.Print() # CBsigma.Print() # CBalpha.Print() # CBn.Print() # fracGauss.Print() # # Draw frame on a canvas c = TCanvas("WMass", "WMass", 800, 400) gPad.SetLeftMargin(0.15) frame.GetYaxis().SetTitleOffset(1.6) frame.Draw() gPad.Update() c.Print('EPlusJets_mjj_fit.pdf') raw_input()