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