def pdf_logPt2_incoh():
#PDF fit to log_10(pT^2)
#tree_in = tree_incoh
tree_in = tree
#ptbin = 0.04
ptbin = 0.12
ptmin = -5.
ptmax = 1.
mmin = 2.8
mmax = 3.2
#fitran = [-5., 1.]
fitran = [-0.9, 0.1]
binned = False
#gamma-gamma 131 evt for pT<0.18
#output log file
out = open("out.txt", "w")
ut.log_results(
out, "in " + infile + " in_coh " + infile_coh + " in_gg " + infile_gg)
loglist = [(x, eval(x)) for x in
["ptbin", "ptmin", "ptmax", "mmin", "mmax", "fitran", "binned"]]
strlog = ut.make_log_string(loglist)
ut.log_results(out, strlog + "\n")
#input data
pT = RooRealVar("jRecPt", "pT", 0, 10)
m = RooRealVar("jRecM", "mass", 0, 10)
dataIN = RooDataSet("data", "data", tree_in, RooArgSet(pT, m))
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
data = dataIN.reduce(strsel)
#x is RooRealVar for log(Pt2)
draw = "TMath::Log10(jRecPt*jRecPt)"
draw_func = RooFormulaVar("x", "log_{10}( #it{p}_{T}^{2} ) (GeV^{2})",
draw, RooArgList(pT))
x = data.addColumn(draw_func)
x.setRange("fitran", fitran[0], fitran[1])
#binned data
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
hPt = TH1D("hPt", "hPt", nbins, ptmin, ptmax)
tree_in.Draw(draw + " >> hPt", strsel)
dataH = RooDataHist("dataH", "dataH", RooArgList(x), hPt)
#range for plot
x.setMin(ptmin)
x.setMax(ptmax)
x.setRange("plotran", ptmin, ptmax)
#create the pdf
b = RooRealVar("b", "b", 5., 0., 10.)
pdf_func = "log(10.)*pow(10.,x)*exp(-b*pow(10.,x))"
pdf_logPt2 = RooGenericPdf("pdf_logPt2", pdf_func, RooArgList(x, b))
#make the fit
if binned == True:
r1 = pdf_logPt2.fitTo(dataH, rf.Range("fitran"), rf.Save())
else:
r1 = pdf_logPt2.fitTo(data, rf.Range("fitran"), rf.Save())
ut.log_results(out, ut.log_fit_result(r1))
#calculate norm to number of events
xset = RooArgSet(x)
ipdf = pdf_logPt2.createIntegral(xset, rf.NormSet(xset),
rf.Range("fitran"))
print "PDF integral:", ipdf.getVal()
if binned == True:
nevt = tree_incoh.Draw(
"", strsel + " && " + draw + ">{0:.3f}".format(fitran[0]) +
" && " + draw + "<{1:.3f}".format(fitran[0], fitran[1]))
else:
nevt = data.sumEntries("x", "fitran")
print "nevt:", nevt
pdf_logPt2.setNormRange("fitran")
print "PDF norm:", pdf_logPt2.getNorm(RooArgSet(x))
#a = nevt/ipdf.getVal()
a = nevt / pdf_logPt2.getNorm(RooArgSet(x))
ut.log_results(out, "log_10(pT^2) parametrization:")
ut.log_results(out, "A = {0:.2f}".format(a))
ut.log_results(out, ut.log_fit_parameters(r1, 0, 2))
print "a =", a
#Coherent contribution
hPtCoh = ut.prepare_TH1D("hPtCoh", ptbin, ptmin, ptmax)
hPtCoh.Sumw2()
#tree_coh.Draw(draw + " >> hPtCoh", strsel)
tree_coh.Draw("TMath::Log10(jGenPt*jGenPt) >> hPtCoh", strsel)
ut.norm_to_data(hPtCoh, hPt, rt.kBlue, -5., -2.2) # norm for coh
#ut.norm_to_data(hPtCoh, hPt, rt.kBlue, -5, -2.1)
#ut.norm_to_num(hPtCoh, 405, rt.kBlue)
print "Coherent integral:", hPtCoh.Integral()
#TMath::Log10(jRecPt*jRecPt)
#Sartre generated coherent shape
sartre = TFile.Open(
"/home/jaroslav/sim/sartre_tx/sartre_AuAu_200GeV_Jpsi_coh_2p7Mevt.root"
)
sartre_tree = sartre.Get("sartre_tree")
hSartre = ut.prepare_TH1D("hSartre", ptbin, ptmin, ptmax)
sartre_tree.Draw("TMath::Log10(pT*pT) >> hSartre",
"rapidity>-1 && rapidity<1")
ut.norm_to_data(hSartre, hPt, rt.kViolet, -5, -2) # norm for Sartre
#gamma-gamma contribution
hPtGG = ut.prepare_TH1D("hPtGG", ptbin, ptmin, ptmax)
tree_gg.Draw(draw + " >> hPtGG", strsel)
#ut.norm_to_data(hPtGG, hPt, rt.kGreen, -5., -2.9)
ut.norm_to_num(hPtGG, 131., rt.kGreen)
print "Int GG:", hPtGG.Integral()
#psi' contribution
psiP = TFile.Open(basedir_mc + "/ana_slight14e4x1_s6_sel5z.root")
psiP_tree = psiP.Get("jRecTree")
hPtPsiP = ut.prepare_TH1D("hPtPsiP", ptbin, ptmin, ptmax)
psiP_tree.Draw(draw + " >> hPtPsiP", strsel)
ut.norm_to_num(hPtPsiP, 12, rt.kViolet)
#sum of all contributions
hSum = ut.prepare_TH1D("hSum", ptbin, ptmin, ptmax)
hSum.SetLineWidth(3)
#add ggel to the sum
hSum.Add(hPtGG)
#add incoherent contribution
func_logPt2 = TF1("pdf_logPt2",
"[0]*log(10.)*pow(10.,x)*exp(-[1]*pow(10.,x))", -10.,
10.)
func_logPt2.SetParameters(a, b.getVal())
hInc = ut.prepare_TH1D("hInc", ptbin, ptmin, ptmax)
ut.fill_h1_tf(hInc, func_logPt2)
hSum.Add(hInc)
#add coherent contribution
hSum.Add(hPtCoh)
#add psi(2S) contribution
#hSum.Add(hPtPsiP)
#set to draw as a lines
ut.line_h1(hSum, rt.kBlack)
#create canvas frame
can = ut.box_canvas()
ut.set_margin_lbtr(gPad, 0.11, 0.09, 0.01, 0.01)
frame = x.frame(rf.Bins(nbins), rf.Title(""))
frame.SetTitle("")
frame.SetMaximum(75)
frame.SetYTitle("Events / ({0:.3f}".format(ptbin) + " GeV^{2})")
print "Int data:", hPt.Integral()
#plot the data
if binned == True:
dataH.plotOn(frame, rf.Name("data"))
else:
data.plotOn(frame, rf.Name("data"))
pdf_logPt2.plotOn(frame, rf.Range("fitran"), rf.LineColor(rt.kRed),
rf.Name("pdf_logPt2"))
pdf_logPt2.plotOn(frame, rf.Range("plotran"), rf.LineColor(rt.kRed),
rf.Name("pdf_logPt2_full"), rf.LineStyle(rt.kDashed))
frame.Draw()
amin = TMath.Power(10, ptmin)
amax = TMath.Power(10, ptmax) - 1
print amin, amax
pt2func = TF1("f1", "TMath::Power(10, x)", amin,
amax) #TMath::Power(x, 10)
aPt2 = TGaxis(-5, 75, 1, 75, "f1", 510, "-")
ut.set_axis(aPt2)
aPt2.SetTitle("pt2")
#aPt2.Draw();
leg = ut.prepare_leg(0.57, 0.78, 0.14, 0.19, 0.03)
ut.add_leg_mass(leg, mmin, mmax)
hx = ut.prepare_TH1D("hx", 1, 0, 1)
hx.Draw("same")
ln = ut.col_lin(rt.kRed)
leg.AddEntry(hx, "Data")
leg.AddEntry(hPtCoh, "Sartre MC", "l")
leg.AddEntry(hPtGG, "#gamma#gamma#rightarrow e^{+}e^{-} MC", "l")
#leg.AddEntry(ln, "ln(10)*#it{A}*10^{log_{10}#it{p}_{T}^{2}}exp(-#it{b}10^{log_{10}#it{p}_{T}^{2}})", "l")
#leg.AddEntry(ln, "Incoherent fit", "l")
leg.Draw("same")
l0 = ut.cut_line(fitran[0], 0.9, frame)
l1 = ut.cut_line(fitran[1], 0.9, frame)
#l0.Draw()
#l1.Draw()
desc = pdesc(frame, 0.14, 0.8, 0.054)
desc.set_text_size(0.03)
desc.itemD("#chi^{2}/ndf", frame.chiSquare("pdf_logPt2", "data", 2), -1,
rt.kRed)
desc.itemD("#it{A}", a, -1, rt.kRed)
desc.itemR("#it{b}", b, rt.kRed)
desc.draw()
#put the sum
#hSum.Draw("same")
#gPad.SetLogy()
frame.Draw("same")
#put gamma-gamma
hPtGG.Draw("same")
#put coherent J/psi
hPtCoh.Draw("same")
#put Sartre generated coherent shape
#hSartre.Draw("same")
#put psi(2S) contribution
#hPtPsiP.Draw("same")
leg2 = ut.prepare_leg(0.14, 0.9, 0.14, 0.08, 0.03)
leg2.AddEntry(
ln,
"ln(10)*#it{A}*10^{log_{10}#it{p}_{T}^{2}}exp(-#it{b}10^{log_{10}#it{p}_{T}^{2}})",
"l")
#leg2.AddEntry(hPtCoh, "Sartre MC reconstructed", "l")
#leg2.AddEntry(hSartre, "Sartre MC generated", "l")
leg2.Draw("same")
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def doDataFit(Chib1_parameters,Chib2_parameters, cuts, inputfile_name = None, RooDataSet = None, ptBin_label='', plotTitle = "#chi_{b}",fittedVariable='qValue', printSigReso = False, noPlots = False, useOtherSignalParametrization = False, useOtherBackgroundParametrization = False, massFreeToChange = False, sigmaFreeToChange = False, legendOnPlot=True, drawPulls=False, titleOnPlot=False, cmsOnPlot=True, printLegend=True):
if RooDataSet != None:
dataSet = RooDataSet
elif inputfile_name != None:
print "Creating DataSet from file "+str(inputfile_name)
dataSet = makeRooDataset(inputfile_name)
else:
raise ValueError('No dataset and no inputfile passed to function doDataFit')
if(fittedVariable == 'refittedMass'):
x_var = 'rf1S_chib_mass'
output_suffix = '_refit'
x_axis_label= 'm_{#mu^{+} #mu^{-} #gamma} [GeV]'
else:
x_var = 'invm1S'
output_suffix = '_qValue'
x_axis_label = 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon} [GeV]'
cuts_str = str(cuts)
#cuts_str = quality_cut + "photon_pt > 0.5 && abs(photon_eta) < 1.0 && ctpv < 0.01 && abs(dimuon_rapidity) < 1.3 && pi0_abs_mass > 0.025 && abs(dz) < 0.5"
data = dataSet.reduce( RooFit.Cut(cuts_str) )
print 'Creating pdf'
x=RooRealVar(x_var, 'm(#mu #mu #gamma) - m(#mu #mu) + m_{#Upsilon}',9.7,10.1,'GeV')
numBins = 80 # define here so that if I change it also the ndof change accordingly
x.setBins(numBins)
# cristal balls
mean_1 = RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,"GeV")
sigma_1 = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', Chib1_parameters.a1)
n1_1 = RooRealVar('n1_1', 'n1_1', Chib1_parameters.n1)
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1',Chib1_parameters.a2)
n2_1 = RooRealVar('n2_1', 'n2_1', Chib1_parameters.n2)
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
mean_2 = RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,"GeV")
sigma_2 = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', Chib2_parameters.a1)
n1_2 = RooRealVar('n1_2', 'n1_2', Chib2_parameters.n1)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', Chib2_parameters.a2)
n2_2 = RooRealVar('n2_2', 'n2_2', Chib2_parameters.n2)
parameters.add(RooArgSet( a1_2, a2_2, n1_2, n2_2))
if massFreeToChange:
# scale_mean = RooRealVar('scale_mean', 'Scale that multiplies masses found with MC', 0.8,1.2)
# mean_1_fixed = RooRealVar("mean_1_fixed","mean ChiB1",Chib1_parameters.mean,"GeV")
# mean_2_fixed = RooRealVar("mean_2_fixed","mean ChiB2",Chib2_parameters.mean,"GeV")
# mean_1 = RooFormulaVar("mean_1",'@0*@1', RooArgList(scale_mean, mean_1_fixed))
# mean_2 = RooFormulaVar("mean_2",'@0*@1', RooArgList(scale_mean, mean_2_fixed))
variazione_m = 0.05 # 50 MeV
diff_m_12 = RooRealVar('diff_m_12', 'Difference between masses chib1 and chib2',0.0194,'GeV') # 19.4 MeV from PDG
mean_1=RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,Chib1_parameters.mean-variazione_m,Chib1_parameters.mean+variazione_m ,"GeV")
mean_2=RooFormulaVar('mean_2', '@0+@1',RooArgList(mean_1, diff_m_12))
# mean_2=RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,Chib2_parameters.mean-variazione_m,Chib2_parameters.mean+variazione_m ,"GeV")
parameters.add(mean_1)
else:
parameters.add(RooArgSet(mean_1, mean_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2)
if sigmaFreeToChange:
scale_sigma = RooRealVar('scale_sigma', 'Scale that multiplies sigmases found with MC', 1, 1.1)#1.01
sigma_1_fixed = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV')
sigma_2_fixed = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV')
sigma_1 = RooFormulaVar("sigma_1",'@0*@1', RooArgList(scale_sigma, sigma_1_fixed))
sigma_2 = RooFormulaVar("sigma_2",'@0*@1', RooArgList(scale_sigma, sigma_2_fixed))
parameters.add(scale_sigma)
else:
parameters.add(RooArgSet(sigma_1, sigma_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2)
if useOtherSignalParametrization: # In this case I redefine cb_pdf
cb1 = RooCBShape('cb1', 'cb1', x, mean_1, sigma_1, a1_1, n1_1)
cb2 = RooCBShape('cb2', 'cb2', x, mean_2, sigma_2, a1_2, n1_2)
# I use a2 as the sigma of my gaussian
gauss1 = RooCBShape('gauss1', 'gauss1',x, mean_1, a2_1, a1_1, n1_1)
gauss2 = RooCBShape('gauss2', 'gauss2',x, mean_2, a2_2, a1_2, n1_2)
# I use n2 as the ratio of cb with respect to gauss
chib1_pdf = RooAddPdf('chib1','chib1',RooArgList(cb1, gauss1),RooArgList(n2_1))
chib2_pdf = RooAddPdf('chib2','chib2',RooArgList(cb2, gauss2),RooArgList(n2_2))
#background
q01S_Start = 9.5
alpha = RooRealVar("#alpha","#alpha",1.5,-1,3.5)#0.2 anziche' 1
beta = RooRealVar("#beta","#beta",-2.5,-7.,0.)
q0 = RooRealVar("q0","q0",q01S_Start)#,9.5,9.7)
delta = RooFormulaVar("delta","TMath::Abs(@0-@1)",RooArgList(x,q0))
b1 = RooFormulaVar("b1","@0*(@1-@2)",RooArgList(beta,x,q0))
signum1 = RooFormulaVar( "signum1","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q0) )
background = RooGenericPdf("background","Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1,delta,alpha,b1) )
if useOtherBackgroundParametrization: # in thies case I redefine background
a0 = RooRealVar('a0','a0',1.,-1.,1.) #,0.5,0.,1.)
a1 = RooRealVar('a1','a1',0.1,-1.,1.) #-0.2,0.,1.)
#a2 = RooRealVar('a2','a2',-0.1,1.,-1.)
background = RooChebychev('background','Background',x,RooArgList(a0,a1))
parameters.add(RooArgSet(a0, a1))
else:
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf,chib2_pdf,background)
# ndof
floatPars = parameters.selectByAttrib("Constant",ROOT.kFALSE)
ndof = numBins - floatPars.getSize() - 1
# # Here I have as parameters N1, N2, and N_background
# n_chib1 = RooRealVar("n_chib1","n_chib1",1250, 0, 50000)
# n_chib2 = RooRealVar("n_chib2","n_chib2",825, 0, 50000)
# n_background = RooRealVar('n_background','n_background',4550, 0, 50000)
# ratio_list = RooArgList(n_chib1, n_chib2, n_background)
# modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
# Here I have as parameters N_12, ratio_12, N_background
n_chib = RooRealVar("n_chib","n_chib",2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21","ratio_21",0.6, 0, 1)
n_chib1 = RooFormulaVar("n_chib1","@0/(1+@1)",RooArgList(n_chib, ratio_21))
n_chib2 = RooFormulaVar("n_chib2","@0/(1+1/@1)",RooArgList(n_chib, ratio_21))
n_background = RooRealVar('n_background','n_background',4550, 0, 50000)
ratio_list = RooArgList(n_chib1, n_chib2, n_background)
parameters.add(RooArgSet(n_chib1, n_chib2, n_background))
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
print 'Fitting to data'
fit_region = x.setRange("fit_region",9.7,10.1)
result=modelPdf.fitTo(data,RooFit.Save(), RooFit.Range("fit_region"))
# define frame
frame = x.frame()
frame.SetNameTitle("fit_resonance","Fit Resonanace")
frame.GetXaxis().SetTitle(x_axis_label )
frame.GetYaxis().SetTitle( "Events/5 MeV " )
frame.GetXaxis().SetTitleSize(0.04)
frame.GetYaxis().SetTitleSize(0.04)
frame.GetXaxis().SetTitleOffset(1.1)
frame.GetXaxis().SetLabelSize(0.04)
frame.GetYaxis().SetLabelSize(0.04)
frame.SetLineWidth(1)
frame.SetTitle(plotTitle)
# plot things on frame
data.plotOn(frame, RooFit.MarkerSize(0.7))
chib1P_set = RooArgSet(chib1_pdf)
modelPdf.plotOn(frame,RooFit.Components(chib1P_set), RooFit.LineColor(ROOT.kGreen+2), RooFit.LineStyle(2), RooFit.LineWidth(1))
chib2P_set = RooArgSet(chib2_pdf)
modelPdf.plotOn(frame, RooFit.Components(chib2P_set),RooFit.LineColor(ROOT.kRed), RooFit.LineStyle(2), RooFit.LineWidth(1))
background_set = RooArgSet(background)
modelPdf.plotOn(frame,RooFit.Components(background_set), RooFit.LineColor(ROOT.kBlack), RooFit.LineStyle(2), RooFit.LineWidth(1))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
frame.SetName("fit_resonance")
# Make numChib object
numChib = NumChib(numChib=n_chib.getVal(), s_numChib=n_chib.getError(), ratio_21=ratio_21.getVal(), s_ratio_21=ratio_21.getError(), numBkg=n_background.getVal(), s_numBkg=n_background.getError(), corr_NB=result.correlation(n_chib, n_background),corr_NR=result.correlation(n_chib, ratio_21) , name='numChib'+output_suffix+ptBin_label,q0=q0.getVal(),s_q0=q0.getError(),alpha=alpha.getVal(),s_alpha=alpha.getError(), beta=beta.getVal(), s_beta=beta.getError(), chiSquare=frame.chiSquare())
#numChib.saveToFile('numChib'+output_suffix+'.txt')
if noPlots:
chi2 = frame.chiSquare()
del frame
return numChib, chi2
# Legend
parameters_on_legend = RooArgSet()#n_chib, ratio_21, n_background)
if massFreeToChange:
#parameters_on_legend.add(scale_mean)
parameters_on_legend.add(mean_1)
#parameters_on_legend.add(mean_2)
if sigmaFreeToChange:
parameters_on_legend.add(scale_sigma)
if massFreeToChange or sigmaFreeToChange:
modelPdf.paramOn(frame, RooFit.Layout(0.1,0.6,0.2),RooFit.Parameters(parameters_on_legend))
if printLegend: #chiquadro, prob, numchib...
leg = TLegend(0.48,0.75,0.97,0.95)
leg.SetBorderSize(0)
#leg.SetTextSize(0.04)
leg.SetFillStyle(0)
chi2 = frame.chiSquare()
probChi2 = TMath.Prob(chi2*ndof, ndof)
chi2 = round(chi2,2)
probChi2 = round(probChi2,2)
leg.AddEntry(0,'#chi^{2} = '+str(chi2),'')
leg.AddEntry(0,'Prob #chi^{2} = '+str(probChi2),'')
N_bkg, s_N_bkg = roundPair(numChib.numBkg, numChib.s_numBkg)
leg.AddEntry(0,'N_{bkg} = '+str(N_bkg)+' #pm '+str(s_N_bkg),'')
N_chib12, s_N_chib12 = roundPair(numChib.numChib, numChib.s_numChib)
leg.AddEntry(0,'N_{#chi_{b}} = '+str(N_chib12)+' #pm '+str(s_N_chib12),'')
Ratio = numChib.calcRatio()
s_Ratio = numChib.calcRatioError()
Ratio, s_Ratio = roundPair(Ratio, s_Ratio)
leg.AddEntry(0,'N_{2}/N_{1} = '+str(Ratio)+' #pm '+str(s_Ratio),'')
if printSigReso: # Add Significance
Sig = numChib.calcSignificance()
s_Sig = numChib.calcSignificanceError()
Sig, s_Sig = roundPair(Sig, s_Sig)
leg.AddEntry(0,'Sig = '+str(Sig)+' #pm '+str(s_Sig),'')
if(Chib1_parameters.sigma>Chib2_parameters.sigma):
Reso = Chib1_parameters.sigma * 1000 # So it's in MeV and not in GeV
s_Reso = Chib1_parameters.s_sigma * 1000 # So it's in MeV and not in GeV
else:
Reso = Chib2_parameters.sigma * 1000 # So it's in MeV and not in GeV
s_Reso = Chib2_parameters.s_sigma * 1000 # So it's in MeV and not in GeV
Reso, s_Reso =roundPair(Reso, s_Reso)
leg.AddEntry(0,'Reso = '+str(Reso)+' #pm '+str(s_Reso)+' MeV','')
#N1 = numChib.numChib1
#s_N1 = numChib.s_numChib1
#N1, s_N1 = roundPair(N1, s_N1)
#leg.AddEntry(0,'N_{1} = '+str(N1)+' #pm '+str(s_N1),'')
#N2 = numChib.numChib2
#s_N2 = numChib.s_numChib2
#N2, s_N2 = roundPair(N2, s_N2)
#leg.AddEntry(0,'N_{2} = '+str(N2)+' #pm '+str(s_N2),'')
frame.addObject(leg)
if legendOnPlot: # < pT <
legend = TLegend(.06,.75,.53,.93)
legend.SetFillStyle(0)
legend.SetBorderSize(0)
#legend.AddEntry(0,'CMS','')
legend.AddEntry(0,str(cuts.upsilon_pt_lcut)+' GeV < p_{T}(#Upsilon) < '+str(cuts.upsilon_pt_hcut)+' GeV','')
#legend.AddEntry(0,'p_{T}(#Upsilon)<'+str(cuts.upsilon_pt_hcut),'')
frame.addObject(legend)
if titleOnPlot:
titleLegend = TLegend(.06,.4,.55,.73)
#titleLegend.SetTextSize(0.03)
titleLegend.SetFillStyle(0)
titleLegend.SetBorderSize(0)
titleLegend.AddEntry(0,plotTitle,'')
frame.addObject(titleLegend)
if cmsOnPlot:
if printLegend:
pvtxt = TPaveText(.1,.55,.55,.73,"NDC")
else:
pvtxt = TPaveText(0.5,0.75,0.97,0.9,"NDC") #(.06,.4,.55,.73)
pvtxt.AddText('CMS Preliminary')
pvtxt.AddText('pp, #sqrt{s} = 8 TeV')
pvtxt.AddText('L = 20.7 fb^{-1}')
pvtxt.SetFillStyle(0)
pvtxt.SetBorderSize(0)
pvtxt.SetTextSize(0.04)
frame.addObject(pvtxt)
# Canvas
c1=TCanvas('Chib12_1P'+output_suffix+ptBin_label,'Chib12_1P'+output_suffix+ptBin_label)
frame.Draw()
if drawPulls:
#c1=TCanvas(output_name+output_suffix,output_name+output_suffix,700, 625)
hpull = frame.pullHist()
framePulls = x.frame()
framePulls.SetTitle(';;Pulls')
framePulls.GetYaxis().SetLabelSize(0.18)
framePulls.GetYaxis().SetTitle('Pulls')
framePulls.GetYaxis().SetTitleSize(0.18)
framePulls.GetYaxis().SetTitleOffset(0.15)
framePulls.GetYaxis().SetNdivisions(005)
framePulls.GetXaxis().SetLabelSize(0.16)
framePulls.GetXaxis().SetTitle('')
line0 = TLine(9.7, 0, 10.1, 0)
line0.SetLineColor(ROOT.kBlue)
line0.SetLineWidth(2)
framePulls.addObject(line0)
framePulls.addPlotable(hpull,"P")
framePulls.SetMaximum(5)
framePulls.SetMinimum(-5)
pad1 = TPad("pad1", "The pad 80% of the height",0.0,0.2,1.0,1.0)
pad1.cd()
frame.Draw()
pad2 = TPad("pad2", "The pad 20% of the height",0.0,0.01,1.0,0.2)
pad2.cd()
framePulls.Draw()
c1.cd()
pad1.Draw()
pad2.Draw()
#c1.SaveAs('Chib12_1P'+output_suffix+'.png')
print 'Chi2 = '+str(frame.chiSquare())
# print ratio background/all in the signal refion
signal_region = x.setRange("signal_region",9.87,9.92)
pdf_integral = modelPdf.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * (n_chib.getVal() + n_background.getVal())
bkg_integral = background.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * n_background.getVal()
print 'Ratio bkg/all in signal region = '+str(bkg_integral/pdf_integral)
return numChib, c1
def fitChicSpectrum(dataset, binname):
""" Fit chic spectrum"""
x = RooRealVar('s', 's', -2, 2)
x.setBins(200)
#signal model
q_chi1 = RooRealVar('qchi1', 'q_{#chi 1}', 0.414, 0.2, 0.6)
q_chi2 = RooRealVar('qchi2', 'q_{#chi 2}', 0.430, 0.2, 0.6)
delta_chi10 = RooRealVar('delta_chi10', 'delta_chi10', 0.09591)
q_chi0 = RooFormulaVar('q_chi0', '@0 - @1',
RooArgList(q_chi1, delta_chi10))
alphacb_chi1 = RooRealVar('alphacb_chi1', '#alpha^{CB}_{#chi 1}', 0.6, 0,
2)
alphacb_chi2 = RooRealVar('alphacb_chi2', '#alpha^{CB}_{#chi 2}', 0.4, 0,
2)
sigmacb_chi1 = RooRealVar('sigmacb_chi1', '#sigma^{CB}_{#chi 1}', 0.005, 0,
1)
sigmacb_chi2 = RooRealVar('sigmacb_chi2', '#sigma^{CB}_{#chi 2}', 0.005, 0,
1)
n_cb = RooRealVar('ncb', 'n^{CB}', 3.0, 0., 5.)
gamma_chi0 = RooRealVar('gamma_chi0', 'gamma_chi0', 0.0104)
sigmacb_chi0 = RooRealVar('sigmacb_chi0', '#sigma^{CB}_{#chi 0}', 0.005)
chi0_sig = RooVoigtian('chi0sig', 'chi0sig,', x, q_chi0, sigmacb_chi0,
gamma_chi0)
chi1_sig = RooCBShape('chi1sig', 'chi1sig', x, q_chi1, sigmacb_chi1,
alphacb_chi1, n_cb)
chi2_sig = RooCBShape('chi2sig', 'chi2sig', x, q_chi2, sigmacb_chi2,
alphacb_chi2, n_cb)
fchi0 = RooRealVar('fchi0', 'f_{#chi 0}', 0.01, 0, 1)
fchi1 = RooRealVar('fchi1', 'f_{#chi 1}', 0.5, 0, 1)
fchi2 = RooFormulaVar('fchi2', '1-@0-@1', RooArgList(fchi0, fchi1))
fbck = RooRealVar('fbck', 'f_{bck}', 0.2, 0, 1)
sigmodel = RooAddPdf('sigm', 'sigm',
RooArgList(chi0_sig, chi1_sig, chi2_sig),
RooArgList(fchi0, fchi1, fchi2))
#background model
q0Start = 0.0
a_bck = RooRealVar('a_bck', 'a_{bck}', 0.5, -5, 5)
b_bck = RooRealVar('b_bck', 'b_{bck}', -2.5, -7., 0.)
q0 = RooRealVar('q0', 'q0', q0Start)
delta = RooFormulaVar('delta', 'TMath::Abs(@0-@1)', RooArgList(x, q0))
bfun = RooFormulaVar('bfun', '@0*(@1-@2)', RooArgList(b_bck, x, q0))
signum = RooFormulaVar('signum', '( TMath::Sign( -1.,@0-@1 )+1 )/2.',
RooArgList(x, q0))
background = RooGenericPdf('background', 'Background',
'signum*pow(delta,a_bck)*exp(bfun)',
RooArgList(signum, delta, a_bck, bfun))
modelPdf = RooAddPdf('chicmodel', 'chicmodel',
RooArgList(sigmodel, background), RooArgList(fbck))
frame = x.frame(RooFit.Title('Q'))
range = x.setRange('range', 0, 2)
# result = modelPdf.fitTo(dataset,RooFit.Save(),RooFit.Range('range'))
dataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
#plotting
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
canvas.SaveAs('out-' + binname + '.png')
canvas.SaveAs('out-' + binname + '.root')
def create_pdfs(self, paths_to_data, save=True):
"""
Fit amplitude and offset of sinusoidal pdfs
"""
if not isinstance(paths_to_data, list):
paths_to_data = [paths_to_data]
files_H = []
files_A = []
for path in paths_to_data:
# These are merged, so only one of each
if not path.endswith('/'): path += '/'
files_H.append(path+'model_H_merged.h5')
files_A.append(path+'model_A_merged.h5')
# TODO: Background samples: uniform pdf
self.phistar = RooRealVar('phistar', 'phistar', 0, 2*pi)
self.ampl = RooRealVar('ampl', 'ampl', 1, 0, 10) # Must remain in scope
self.offset = RooRealVar('offset', 'offset', 1, 0, 10) # - " -
# Read in the data
# Need only to fit pdf parameters for H, since the pdf for A is
# equal but with a 180 deg phase shift.
starttime = time.time()
dataH_X, _, feats = self.read_array_from_files(files_H)
dataH_X = self.select_features(dataH_X, feats)
print 'Limiting events for pdf creation to 1e6'
dataH_X = dataH_X[:1000000]
templatedataH = RooDataSet('templatedataH', 'templatedataH', RooArgSet(self.phistar))
for phi in dataH_X:
self.phistar.setVal(phi)
templatedataH.add(RooArgSet(self.phistar))
# Reset parameters
self.ampl = RooRealVar('ampl', 'ampl', 1, 0, 10)
self.offset = RooRealVar('offset', 'offset', 1, 0, 10)
# Pdf for scalar decay
scalar_pdf = RooGenericPdf('scalar_pdf', 'scalar_pdf', 'ampl*sin(phistar-1.570796) + offset', RooArgList(self.ampl, self.phistar, self.offset))
scalar_pdf.fitTo(templatedataH)
self.ampl.setConstant()
self.offset.setConstant()
# Fitting only the scalar pdf is enough to get the pseudoscalar parameters too
pseudoscalar_pdf = RooGenericPdf('pseudoscalar_pdf', 'pseudoscalar_pdf', 'ampl*sin(phistar+1.570796) + offset', RooArgList(self.ampl, self.phistar, self.offset))
self.pdfs['H'] = scalar_pdf
self.pdfs['A'] = pseudoscalar_pdf
print 'Creating phistar pdf took %s' % time.strftime("%H:%M:%S", time.gmtime(time.time()-starttime))
if save:
ws = RooWorkspace('ws', 'ws')
getattr(ws, 'import')(self.phistar)
getattr(ws, 'import')(self.ampl)
getattr(ws, 'import')(self.offset)
getattr(ws, 'import')(self.pdfs['H'])
getattr(ws, 'import')(self.pdfs['A'])
ws.writeToFile('%s/pdfs_%s.root' % (self.outdir, self.title))
if fitDat:
# -----------------------------------------
# define parameters for background
# function 0 (standard parametrization)
NBINS = 166
#if fitModel==0:
p1 = RooRealVar('p1','p1',6.21862535247,0.,100)
p2 = RooRealVar('p2','p2',6.48308946408,0,60)
p3 = RooRealVar('p3','p3',0.217160577769,-10,10)
background = RooGenericPdf('background','(pow(1-@0/13000,@1)/pow(@0/13000,@2+@3*log(@0/13000)))',RooArgList(x,p1,p2,p3))
background_norm = RooRealVar('background_norm','background_norm',434176,0,10000000)
ebkg = RooExtendPdf("ebkg","extended background p.d.f",background,background_norm)
roohistSig = RooDataHist('roohist','roohist',RooArgList(x),hSig)
signal = RooHistPdf('signal','signal',RooArgSet(x),roohistSig)
signal_norm = RooRealVar('signal_norm','signal_norm',0,-1000,1000)
model = RooAddPdf("model","s+b",RooArgList(background,signal),RooArgList(background_norm,signal_norm))
##variation 1, with one more parameter
#if fitModel==1:
# TMath::Power(1-x/8000,[1])*(1+[4]*x/8000) ) / ( TMath::Power(x/8000,[2]+[3]*log(x/8000))
#
def dijet(category):
channel = 'bb'
stype = channel
isSB = True # relict from using Alberto's more complex script
isData = not ISMC
nTupleDir = NTUPLEDIR
samples = data if isData else back
pd = []
for sample_name in samples:
if YEAR == 'run2':
pd += sample[sample_name]['files']
else:
pd += [x for x in sample[sample_name]['files'] if YEAR in x]
print "datasets:", pd
if not os.path.exists(PLOTDIR): os.makedirs(PLOTDIR)
if BIAS: print "Running in BIAS mode"
order = 0
RSS = {}
X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV")
weight = RooRealVar("MANtag_weight", "", -1.e9, 1.e9)
variables = RooArgSet(X_mass)
variables.add(RooArgSet(weight))
if VARBINS:
binsXmass = RooBinning(len(abins) - 1, abins)
X_mass.setBinning(RooBinning(len(abins_narrow) - 1, abins_narrow))
plot_binning = RooBinning(
int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(),
X_mass.getMax())
else:
X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10))
binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100),
X_mass.getMin(), X_mass.getMax())
plot_binning = binsXmass
baseCut = ""
print stype, "|", baseCut
print " - Reading from Tree"
treeBkg = TChain("tree")
for ss in pd:
if os.path.exists(nTupleDir + ss + "_" + BTAGGING + ".root"):
treeBkg.Add(nTupleDir + ss + "_" + BTAGGING + ".root")
else:
print "found no file for sample:", ss
setData = RooDataSet("setData", "Data (QCD+TTbar MC)", variables,
RooFit.Cut(baseCut), RooFit.WeightVar(weight),
RooFit.Import(treeBkg))
nevents = setData.sumEntries()
dataMin, dataMax = array('d', [0.]), array('d', [0.])
setData.getRange(X_mass, dataMin, dataMax)
xmin, xmax = dataMin[0], dataMax[0]
lastBin = X_mass.getMax()
if VARBINS:
for b in narrow_bins:
if b > xmax:
lastBin = b
break
print "Imported", (
"data" if isData else "MC"
), "RooDataSet with", nevents, "events between [%.1f, %.1f]" % (xmin, xmax)
#xmax = xmax+binsXmass.averageBinWidth() # start form next bin
# 1 parameter
print "fitting 1 parameter model"
p1_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p1_1", "p1", 7.0, 0.,
2000.)
modelBkg1 = RooGenericPdf("Bkg1", "Bkg. fit (2 par.)",
"1./pow(@0/13000, @1)", RooArgList(X_mass, p1_1))
normzBkg1 = RooRealVar(
modelBkg1.GetName() + "_norm", "Number of background events", nevents,
0., 5. * nevents) #range dependent of actual number of events!
modelExt1 = RooExtendPdf(modelBkg1.GetName() + "_ext",
modelBkg1.GetTitle(), modelBkg1, normzBkg1)
fitRes1 = modelExt1.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes1.Print()
RSS[1] = drawFit("Bkg1", category, X_mass, modelBkg1, setData, binsXmass,
[fitRes1], normzBkg1.getVal())
# 2 parameters
print "fitting 2 parameter model"
p2_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_1", "p1", 0., -100.,
1000.)
p2_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_2", "p2",
p1_1.getVal(), -100., 600.)
modelBkg2 = RooGenericPdf("Bkg2", "Bkg. fit (3 par.)",
"pow(1-@0/13000, @1) / pow(@0/13000, @2)",
RooArgList(X_mass, p2_1, p2_2))
normzBkg2 = RooRealVar(modelBkg2.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt2 = RooExtendPdf(modelBkg2.GetName() + "_ext",
modelBkg2.GetTitle(), modelBkg2, normzBkg2)
fitRes2 = modelExt2.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes2.Print()
RSS[2] = drawFit("Bkg2", category, X_mass, modelBkg2, setData, binsXmass,
[fitRes2], normzBkg2.getVal())
# 3 parameters
print "fitting 3 parameter model"
p3_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_1", "p1",
p2_1.getVal(), -2000., 2000.)
p3_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_2", "p2",
p2_2.getVal(), -400., 2000.)
p3_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_3", "p3", -2.5,
-500., 500.)
modelBkg3 = RooGenericPdf(
"Bkg3", "Bkg. fit (4 par.)",
"pow(1-@0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))",
RooArgList(X_mass, p3_1, p3_2, p3_3))
normzBkg3 = RooRealVar(modelBkg3.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt3 = RooExtendPdf(modelBkg3.GetName() + "_ext",
modelBkg3.GetTitle(), modelBkg3, normzBkg3)
fitRes3 = modelExt3.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes3.Print()
RSS[3] = drawFit("Bkg3", category, X_mass, modelBkg3, setData, binsXmass,
[fitRes3], normzBkg3.getVal())
# 4 parameters
print "fitting 4 parameter model"
p4_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_1", "p1",
p3_1.getVal(), -2000., 2000.)
p4_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_2", "p2",
p3_2.getVal(), -2000., 2000.)
p4_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_3", "p3",
p3_3.getVal(), -50., 50.)
p4_4 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_4", "p4", 0.1, -50.,
50.)
modelBkg4 = RooGenericPdf(
"Bkg4", "Bkg. fit (5 par.)",
"pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000)+@4*pow(log(@0/13000), 2))",
RooArgList(X_mass, p4_1, p4_2, p4_3, p4_4))
normzBkg4 = RooRealVar(modelBkg4.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt4 = RooExtendPdf(modelBkg4.GetName() + "_ext",
modelBkg4.GetTitle(), modelBkg4, normzBkg4)
fitRes4 = modelExt4.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes4.Print()
RSS[4] = drawFit("Bkg4", category, X_mass, modelBkg4, setData, binsXmass,
[fitRes4], normzBkg4.getVal())
# Normalization parameters are should be set constant, but shape ones should not
# if BIAS:
# p1_1.setConstant(True)
# p2_1.setConstant(True)
# p2_2.setConstant(True)
# p3_1.setConstant(True)
# p3_2.setConstant(True)
# p3_3.setConstant(True)
# p4_1.setConstant(True)
# p4_2.setConstant(True)
# p4_3.setConstant(True)
# p4_4.setConstant(True)
normzBkg1.setConstant(True)
normzBkg2.setConstant(True)
normzBkg3.setConstant(True)
normzBkg4.setConstant(True)
#*******************************************************#
# #
# Fisher #
# #
#*******************************************************#
# Fisher test
with open(PLOTDIR + "/Fisher_" + category + ".tex", 'w') as fout:
fout.write(r"\begin{tabular}{c|c|c|c|c}")
fout.write("\n")
fout.write(r"function & $\chi^2$ & RSS & ndof & F-test \\")
fout.write("\n")
fout.write("\hline")
fout.write("\n")
CL_high = False
for o1 in range(1, 5):
o2 = min(o1 + 1, 5)
fout.write("%d par & %.2f & %.2f & %d & " %
(o1 + 1, RSS[o1]["chi2"], RSS[o1]["rss"],
RSS[o1]["nbins"] - RSS[o1]["npar"]))
if o2 > len(RSS):
fout.write(r"\\")
fout.write("\n")
continue #order==0 and
CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1 + 1., o2 + 1.,
RSS[o1]["nbins"])
fout.write("CL=%.3f " % (CL))
if CL > 0.10: # The function with less parameters is enough
if not CL_high:
order = o1
#fout.write( "%d par are sufficient " % (o1+1))
CL_high = True
else:
#fout.write( "%d par are needed " % (o2+1))
if not CL_high:
order = o2
fout.write(r"\\")
fout.write("\n")
fout.write("\hline")
fout.write("\n")
fout.write(r"\end{tabular}")
print "saved F-test table as", PLOTDIR + "/Fisher_" + category + ".tex"
#print "-"*25
#print "function & $\\chi^2$ & RSS & ndof & F-test & result \\\\"
#print "\\multicolumn{6}{c}{", "Zprime_to_bb", "} \\\\"
#print "\\hline"
#CL_high = False
#for o1 in range(1, 5):
# o2 = min(o1 + 1, 5)
# print "%d par & %.2f & %.2f & %d & " % (o1+1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"]-RSS[o1]["npar"]),
# if o2 > len(RSS):
# print "\\\\"
# continue #order==0 and
# CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1+1., o2+1., RSS[o1]["nbins"])
# print "%d par vs %d par CL=%f & " % (o1+1, o2+1, CL),
# if CL > 0.10: # The function with less parameters is enough
# if not CL_high:
# order = o1
# print "%d par are sufficient" % (o1+1),
# CL_high=True
# else:
# print "%d par are needed" % (o2+1),
# if not CL_high:
# order = o2
# print "\\\\"
#print "\\hline"
#print "-"*25
#print "@ Order is", order, "("+category+")"
#order = min(3, order)
#order = 2
if order == 1:
modelBkg = modelBkg1 #.Clone("Bkg")
modelAlt = modelBkg2 #.Clone("BkgAlt")
normzBkg = normzBkg1 #.Clone("Bkg_norm")
fitRes = fitRes1
elif order == 2:
modelBkg = modelBkg2 #.Clone("Bkg")
modelAlt = modelBkg3 #.Clone("BkgAlt")
normzBkg = normzBkg2 #.Clone("Bkg_norm")
fitRes = fitRes2
elif order == 3:
modelBkg = modelBkg3 #.Clone("Bkg")
modelAlt = modelBkg4 #.Clone("BkgAlt")
normzBkg = normzBkg3 #.Clone("Bkg_norm")
fitRes = fitRes3
elif order == 4:
modelBkg = modelBkg4 #.Clone("Bkg")
modelAlt = modelBkg3 #.Clone("BkgAlt")
normzBkg = normzBkg4 #.Clone("Bkg_norm")
fitRes = fitRes4
else:
print "Functions with", order + 1, "or more parameters are needed to fit the background"
exit()
modelBkg.SetName("Bkg_" + YEAR + "_" + category)
modelAlt.SetName("Alt_" + YEAR + "_" + category)
normzBkg.SetName("Bkg_" + YEAR + "_" + category + "_norm")
print "-" * 25
# Generate pseudo data
setToys = RooDataSet()
setToys.SetName("data_toys")
setToys.SetTitle("Data (toys)")
if not isData:
print " - Generating", nevents, "events for toy data"
setToys = modelBkg.generate(RooArgSet(X_mass), nevents)
#setToys = modelAlt.generate(RooArgSet(X_mass), nevents)
print "toy data generated"
if VERBOSE: raw_input("Press Enter to continue...")
#*******************************************************#
# #
# Plot #
# #
#*******************************************************#
print "starting to plot"
c = TCanvas("c_" + category, category, 800, 800)
c.Divide(1, 2)
setTopPad(c.GetPad(1), RATIO)
setBotPad(c.GetPad(2), RATIO)
c.cd(1)
frame = X_mass.frame()
setPadStyle(frame, 1.25, True)
if VARBINS: frame.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin)
signal = getSignal(
category, stype,
2000) #replacing Alberto's getSignal by own dummy function
graphData = setData.plotOn(frame, RooFit.Binning(plot_binning),
RooFit.Scaling(False), RooFit.Invisible())
modelBkg.plotOn(frame, RooFit.VisualizeError(fitRes, 1, False),
RooFit.LineColor(602), RooFit.FillColor(590),
RooFit.FillStyle(1001), RooFit.DrawOption("FL"),
RooFit.Name("1sigma"))
modelBkg.plotOn(frame, RooFit.LineColor(602), RooFit.FillColor(590),
RooFit.FillStyle(1001), RooFit.DrawOption("L"),
RooFit.Name(modelBkg.GetName()))
modelAlt.plotOn(frame, RooFit.LineStyle(7), RooFit.LineColor(613),
RooFit.FillColor(609), RooFit.FillStyle(1001),
RooFit.DrawOption("L"), RooFit.Name(modelAlt.GetName()))
if not isSB and signal[0] is not None: # FIXME remove /(2./3.)
signal[0].plotOn(
frame,
RooFit.Normalization(signal[1] * signal[2], RooAbsReal.NumEvent),
RooFit.LineStyle(3), RooFit.LineWidth(6), RooFit.LineColor(629),
RooFit.DrawOption("L"), RooFit.Name("Signal"))
graphData = setData.plotOn(
frame, RooFit.Binning(plot_binning), RooFit.Scaling(False),
RooFit.XErrorSize(0 if not VARBINS else 1),
RooFit.DataError(RooAbsData.Poisson if isData else RooAbsData.SumW2),
RooFit.DrawOption("PE0"), RooFit.Name(setData.GetName()))
fixData(graphData.getHist(), True, True, not isData)
pulls = frame.pullHist(setData.GetName(), modelBkg.GetName(), True)
chi = frame.chiSquare(setData.GetName(), modelBkg.GetName(), True)
#setToys.plotOn(frame, RooFit.DataError(RooAbsData.Poisson), RooFit.DrawOption("PE0"), RooFit.MarkerColor(2))
frame.GetYaxis().SetTitle("Events / ( 100 GeV )")
frame.GetYaxis().SetTitleOffset(1.05)
frame.Draw()
#print "frame drawn"
# Get Chi2
# chi2[1] = frame.chiSquare(modelBkg1.GetName(), setData.GetName())
# chi2[2] = frame.chiSquare(modelBkg2.GetName(), setData.GetName())
# chi2[3] = frame.chiSquare(modelBkg3.GetName(), setData.GetName())
# chi2[4] = frame.chiSquare(modelBkg4.GetName(), setData.GetName())
frame.SetMaximum(frame.GetMaximum() * 10)
frame.SetMinimum(max(frame.GetMinimum(), 1.e-1))
c.GetPad(1).SetLogy()
drawAnalysis(category)
drawRegion(category, True)
#drawCMS(LUMI, "Simulation Preliminary")
drawCMS(LUMI, "Work in Progress", suppressCMS=True)
leg = TLegend(0.575, 0.6, 0.95, 0.9)
leg.SetBorderSize(0)
leg.SetFillStyle(0) #1001
leg.SetFillColor(0)
leg.AddEntry(setData.GetName(),
setData.GetTitle() + " (%d events)" % nevents, "PEL")
leg.AddEntry(modelBkg.GetName(), modelBkg.GetTitle(),
"FL") #.SetTextColor(629)
leg.AddEntry(modelAlt.GetName(), modelAlt.GetTitle(), "L")
if not isSB and signal[0] is not None:
leg.AddEntry("Signal", signal[0].GetTitle(), "L")
leg.SetY1(0.9 - leg.GetNRows() * 0.05)
leg.Draw()
latex = TLatex()
latex.SetNDC()
latex.SetTextSize(0.04)
latex.SetTextFont(42)
if not isSB:
latex.DrawLatex(leg.GetX1() * 1.16,
leg.GetY1() - 0.04, "HVT model B (g_{V}=3)")
# latex.DrawLatex(0.67, leg.GetY1()-0.045, "#sigma_{X} = 1.0 pb")
c.cd(2)
frame_res = X_mass.frame()
setPadStyle(frame_res, 1.25)
frame_res.addPlotable(pulls, "P")
setBotStyle(frame_res, RATIO, False)
if VARBINS: frame_res.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin)
frame_res.GetYaxis().SetRangeUser(-5, 5)
frame_res.GetYaxis().SetTitle("pulls(#sigma)")
frame_res.GetYaxis().SetTitleOffset(0.3)
frame_res.Draw()
fixData(pulls, False, True, False)
drawChi2(RSS[order]["chi2"], RSS[order]["nbins"] - (order + 1), True)
line = drawLine(X_mass.getMin(), 0, lastBin, 0)
if VARBINS:
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf")
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png")
else:
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf")
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png")
#*******************************************************#
# #
# Generate workspace #
# #
#*******************************************************#
if BIAS:
gSystem.Load("libHiggsAnalysisCombinedLimit.so")
from ROOT import RooMultiPdf
cat = RooCategory("pdf_index", "Index of Pdf which is active")
pdfs = RooArgList(modelBkg, modelAlt)
roomultipdf = RooMultiPdf("roomultipdf", "All Pdfs", cat, pdfs)
normulti = RooRealVar("roomultipdf_norm",
"Number of background events", nevents, 0., 1.e6)
normzBkg.setConstant(
False
) ## newly put here to ensure it's freely floating in the combine fit
# create workspace
w = RooWorkspace("Zprime_" + YEAR, "workspace")
# Dataset
if isData: getattr(w, "import")(setData, RooFit.Rename("data_obs"))
else: getattr(w, "import")(setToys, RooFit.Rename("data_obs"))
#getattr(w, "import")(setData, RooFit.Rename("data_obs"))
if BIAS:
getattr(w, "import")(cat, RooFit.Rename(cat.GetName()))
getattr(w, "import")(normulti, RooFit.Rename(normulti.GetName()))
getattr(w, "import")(roomultipdf, RooFit.Rename(roomultipdf.GetName()))
getattr(w, "import")(modelBkg, RooFit.Rename(modelBkg.GetName()))
getattr(w, "import")(modelAlt, RooFit.Rename(modelAlt.GetName()))
getattr(w, "import")(normzBkg, RooFit.Rename(normzBkg.GetName()))
w.writeToFile(WORKDIR + "%s_%s.root" % (DATA_TYPE + "_" + YEAR, category),
True)
print "Workspace", WORKDIR + "%s_%s.root" % (
DATA_TYPE + "_" + YEAR, category), "saved successfully"
if VERBOSE: raw_input("Press Enter to continue...")
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)
background_norm.Print()
# S+B model
model = RooAddPdf("model","s+b",RooArgList(background,signal),RooArgList(background_norm,signal_norm))
rooDataHist = RooDataHist('rooDatahist','rooDathist',RooArgList(mjj),hData)
rooDataHist.Print()
if args.runFit:
res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy))
if not args.decoBkg: res.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
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)
if args.fitBonly: signal_norm.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)))
background_norm2 = RooRealVar('background_norm2','background_norm2',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)))
background_norm3 = RooRealVar('background_norm3','background_norm3',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)))
background_norm4 = RooRealVar('background_norm4','background_norm4',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)))
background_norm5 = RooRealVar('background_norm5','background_norm5',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)
# S+B model
model = RooAddPdf("model","s+b",RooArgList(background,signal),RooArgList(background_norm,signal_norm))
model2 = RooAddPdf("model2","s+b2",RooArgList(background2,signal),RooArgList(background_norm2,signal_norm))
model3 = RooAddPdf("model3","s+b3",RooArgList(background3,signal),RooArgList(background_norm3,signal_norm))
model4 = RooAddPdf("model4","s+b4",RooArgList(background4,signal),RooArgList(background_norm4,signal_norm))
model5 = RooAddPdf("model5","s+b5",RooArgList(background5,signal),RooArgList(background_norm5,signal_norm))
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"), ROOT.RooFit.Invisible())
res = model.fitTo(rooDataHist, RooFit.Save(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.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.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.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.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"))
canvas = TCanvas("cdouble", "cdouble", 800, 1000)
gStyle.SetOptStat(0);
gStyle.SetOptTitle(0);
top = TPad("top", "top", 0., 0.5, 1., 1.)
top.SetBottomMargin(0.03)
top.Draw()
top.SetLogy()
bottom = TPad("bottom", "bottom", 0., 0., 1., 0.5)
bottom.SetTopMargin(0.02)
bottom.SetBottomMargin(0.2)
bottom.Draw()
top.cd()
frame_top = TH1D("frame_top", "frame_top", 100, 526, 1500)
frame_top.GetXaxis().SetTitleSize(0)
frame_top.GetXaxis().SetLabelSize(0)
frame_top.GetYaxis().SetLabelSize(0.04)
frame_top.GetYaxis().SetTitleSize(0.04)
frame_top.GetYaxis().SetTitle("Events")
frame_top.SetMaximum(1000.)
frame_top.SetMinimum(0.1)
frame_top.Draw("axis")
mframe.Draw("p e1 same")
bottom.cd()
frame_bottom = TH1D("frame_bottom", "frame_bottom", 100, 526, 1500)
frame_bottom.GetXaxis().SetTitle("m_{jj} [GeV]")
frame_bottom.GetYaxis().SetTitle("Pull")
frame_bottom.GetXaxis().SetLabelSize(0.04)
frame_bottom.GetXaxis().SetTitleSize(0.06)
frame_bottom.GetXaxis().SetLabelOffset(0.01)
frame_bottom.GetXaxis().SetTitleOffset(1.1)
frame_bottom.GetYaxis().SetLabelSize(0.04)
frame_bottom.GetYaxis().SetTitleSize(0.04)
frame_bottom.GetYaxis().SetTitleOffset(0.85)
frame_bottom.SetMaximum(4.)
frame_bottom.SetMinimum(-3.)
frame_bottom.Draw("axis")
zero = TLine(526., 0., 1500., 0.)
zero.SetLineColor(ROOT.EColor.kBlack)
zero.SetLineStyle(1)
zero.SetLineWidth(2)
zero.Draw("same")
# Ratio histogram with no errors (not so well defined, since this isn't a well-defined efficiency)
newHist = mframe.getHist("data")
curve = mframe.getObject(1)
hresid = newHist.makePullHist(curve,kTRUE)
resframe = mjj.frame()
mframe.SetAxisRange(526.,1500.)
resframe.addPlotable(hresid,"B X")
resframe.Draw("same")
canvas.cd()
canvas.SaveAs("testdouble.pdf")
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","model3")
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(525.,1200.)
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.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(525.,1200.)
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.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"))
#if use different fits for shape uncertainties
#getattr(w,'import')(,ROOT.RooCmdArg(),RooFit.Rename("background__bkgUp"))
#getattr(w,'import')(,ROOT.RooCmdArg(),RooFit.Rename("background__bkgDown"))
getattr(w,'import')(background_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) )
dataHist_data=RooDataHist("RooDataHist","RooDataHist",RooArgList(x),hDat)
if fitSig:
# define parameters for signal fit
m = RooRealVar('mean','mean',float(mass),float(mass)-200,float(mass)+200)
s = RooRealVar('sigma','sigma',0.1*float(mass),0,10000)
a = RooRealVar('alpha','alpha',1,-10,10)
n = RooRealVar('n','n',1,0,100)
sig = RooCBShape('sig','sig',x,m,s,a,n)
p = RooRealVar('p','p',1,0,5)
x0 = RooRealVar('x0','x0',1000,100,5000)
bkg = RooGenericPdf('bkg','1/(exp(pow(@0/@1,@2))+1)',RooArgList(x,x0,p))
fsig= RooRealVar('fsig','fsig',0.5,0.,1.)
signal = RooAddPdf('signal','signal',sig,bkg,fsig)
# -----------------------------------------
# fit signal
canSname = 'can_Mjj'+str(mass)
canS = TCanvas(canSname,canSname,900,600)
gPad.SetLogy()
roohistSig = RooDataHist('roohist','roohist',RooArgList(x),hSig)
roohistSig.Print()
res_sig = signal.fitTo(roohistSig, RooFit.Save(ROOT.kTRUE))
res_sig.Print()
fit_max = 1.04
#First Gaussian PDF
Mkk = RooRealVar("Mkk", "Mkk", fit_min, fit_max)
mean1 = RooRealVar("mean1", "Mean of Gaussian 1", 1.01944, 1.01, 1.03)
sigma1 = RooRealVar("sigma1", "Width of Gaussian 1", 0.00222, 0.0001, 0.01)
gauss1 = RooGaussian("gauss1", "gauss1(Mkk,mean1,sigma1)", Mkk, mean1, sigma1)
# Second Gaussian PDF
mean2 = RooRealVar("mean2", "Mean of Gaussian 2", 1.02052, 1.0, 1.1)
sigma2 = RooRealVar("sigma2", "Width of Gaussian 2", 0.0072, 0.001, 1)
gauss2 = RooGaussian("gauss2", "gauss1(Mkk,mean2,sigma2)", Mkk, mean2, sigma2)
r2 = RooRealVar("r2", "ratio of width of gaussian 2", 3.2, 0, 10)
customGaussR = RooGenericPdf(
"customGaussR", "custom PDF build",
"1/(sigma1*r2) * exp(- (Mkk - mean2)**2 / (2 * (sigma1*r2) ** 2))",
RooArgList(Mkk, mean2, sigma1, r2))
# faster method:
r_sigma2 = RooFormulaVar("r_sigma2", "sigma1 * r2", RooArgList(sigma1, r2))
gauss2R = RooGaussian("gauss2R", "gauss1(Mkk,mean2,sigma2)", Mkk, mean2,
r_sigma2)
toyDataCustom = customGaussR.generate(RooArgSet(Mkk), 100000)
toyData = gauss2.generate(RooArgSet(Mkk), 100000)
toyDataR = gauss2R.generate(RooArgSet(Mkk), 100000)
c = TCanvas("c", "c", 800, 800)
frame1 = Mkk.frame(RooFit.Bins(50), RooFit.Title("Comparison of PDFs"))
# Plot all data tagged as passed sample
##p2mod = 4.99989 +/- 3.9569 (limited)
##p3mod = 11.9997 +/- 0.529866 (limited)
##p4mod = 2.02636 +/- 0.360492 (limited)
##p5mod = 0.220746 +/- 0.0842075 (limited)
## dijet mass function
f_var = RooFormulaVar('f_var', 'f_var', '@0/13000.', RooArgList(J_Mass))
p1mod = RooRealVar('p1mod', 'p1mod', 0., 4000)
p2mod = RooRealVar('p2mod', 'p2mod', -2000., 2000.)
p3mod = RooRealVar('p3mod', 'p3mod', -1000, 1000.)
p4mod = RooRealVar('p4mod', 'p4mod', -100., 100.)
p5mod = RooRealVar('p5mod', 'p5mod', -200., 200.)
p6mod = RooRealVar('p6mod', 'p6mod', -10, 10.)
diJetMass = RooGenericPdf('diJetMass', "pow(1-@0,@2)/pow(@0, @1+@3*log(@0))",
RooArgList(f_var, p4mod, p2mod, p3mod))
diJetMass_2 = RooGenericPdf('diJetMass_2', "1.0/pow(@0,@1)",
RooArgList(f_var, p3mod))
diJetMass_3 = RooGenericPdf('diJetMass_3', "pow(1-@0,@1)/pow(@0,@2)",
RooArgList(f_var, p2mod, p3mod))
diJetMass_4 = RooGenericPdf('diJetMass_4',
"pow(1-@0,@1)/pow(@0, @2+@3*log(@0))",
RooArgList(f_var, p2mod, p3mod, p4mod))
diJetMass_5 = RooGenericPdf(
'diJetMass_5', "pow(1-@0,@1)/pow(@0, @2+@3*log(@0)+@4*pow(log(@0),2))",
RooArgList(J_Mass, p2mod, p3mod, p4mod, p5mod))
##polynomial of order 5
#diJetMass_5 = RooGenericPdf('diJetMass_5', "@1+@2*pow(@0,1)+@3*pow(@0,2)+@4*pow(@0,3)+@5*pow(@0,4)+@6*pow(@0,5)",RooArgList(J_Mass,p1mod,p2mod,p3mod,p4mod,p5mod,p6mod))
#diJetMass_5 = RooGenericPdf('diJetMass_5', "@1*pow(@0,1)+@2*pow(@0,2)+@3*pow(@0,3)+@4*pow(@0,4)+@5*pow(@0,5)",RooArgList(J_Mass,p2mod,p3mod,p4mod,p5mod,p6mod))
#x= RooRealVar("x","x", 500,1500)
# 3. How to get variable binning (wider bins for longer lifetimes)?
## Acceptance
# Note: Using a PDF to represent an acceptance is not rigorously
# correct, but it is acceptable in this context since we only want to
# determine the shape, which is to be later included in the PDF for
# the fit as a function.
if accfn == 'powerlaw':
# Condition to ensure acceptance function is always +ve definite.
# The first condition protects against the undefined nature of the
# function for times less than 0. Whereas the second condition
# ensures the 0.2 ps selection cut present in the sample is
# incorporated into the model.
acc_cond = '((@1-@2)<0 || @1<0.0002)'
expr = '(1.-1./(1.+(@0*(@1-@2))**3))'
PDF = RooGenericPdf('PDF', '%s ? 0 : %s' % (acc_cond, expr),
RooArgList(turnon, time, offset))
elif accfn == 'arctan':
acc_cond = '(@0<0.0002)'
expr = '(atan(@0*exp(@1*@0-@2)))'
PDF = RooGenericPdf('PDF', '%s ? 0 : %s' % (acc_cond, expr),
RooArgList(time, turnon, offset))
elif accfn == 'erf':
acc_cond = '(@1<0.0002)'
expr = '(0.5*(TMath::Erf((@1-@2)/@0)+1))'
PDF = RooGenericPdf('PDF', '%s ? 0 : %s' % (acc_cond, expr),
RooArgList(turnon, time, offset))
else:
print 'Unknown acceptance type. Aborting'
assert(False)
# Dataset to fit to
class fitFunc(object):
pass
fitParam = {}
mT = RooRealVar( "m_T", "m_{T}", 1500., 3900., "GeV")
fitBDT0_2016 = fitFunc()
fitBDT0_2016.p1 = RooRealVar("CMS2016_BDT0_p1", "p1", -18.0947, -1000., 1000.)
fitBDT0_2016.p2 = RooRealVar("CMS2016_BDT0_p2", "p2", 22.8504, -10., 10.)
fitBDT0_2016.p3 = RooRealVar("CMS2016_BDT0_p3", "p3", 3.72973, -10., 10.)
fitBDT0_2016.modelBkg = RooGenericPdf("Bkg", "Bkg. fit (3 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2, fitBDT0_2016.p3))
fitParam["BDT0_2016"] = fitBDT0_2016
fitBDT1_2016 = fitFunc()
fitBDT1_2016.p1 = RooRealVar("CMS2016_BDT1_p1", "p1",-13.1451, -1000., 1000.)
fitBDT1_2016.p2 = RooRealVar("CMS2016_BDT1_p2", "p2", 13.1451, -10., 10.)
fitBDT1_2016.p3 = RooRealVar("CMS2016_BDT1_p3", "p3", 2.91787, -10., 10.)
fitBDT1_2016.modelBkg = RooGenericPdf("Bkg", "Bkg. fit (3 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(mT, fitBDT1_2016.p1, fitBDT1_2016.p2, fitBDT1_2016.p3))
fitParam["BDT1_2016"] = fitBDT1_2016
fitBDT2_2016 = fitFunc()
fitBDT2_2016.p1 = RooRealVar("CMS2016_BDT2_p1", "p1", 12.5899, -1000., 1000.)
fitBDT2_2016.p2 = RooRealVar("CMS2016_BDT2_p2", "p2", 6.71091, -10., 10.)
fitBDT2_2016.p3 = RooRealVar("CMS2016_BDT2_p3", "p3", 0.265957, -10., 10.)
def fitChicSpectrum(dataset, binname):
""" Fit chic spectrum"""
x = RooRealVar('Qvalue', 'Q', 9.7, 10.1)
x.setBins(80)
mean_1 = RooRealVar("mean_1", "mean ChiB1", 9.892, 9, 10, "GeV")
sigma_1 = RooRealVar("sigma_1", "sigma ChiB1", 0.0058, 'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', 0.748)
n1_1 = RooRealVar('n1_1', 'n1_1', 2.8)
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1', 1.739)
n2_1 = RooRealVar('n2_1', 'n2_1', 3.0)
deltam = RooRealVar('deltam', 'deltam', 0.01943)
mean_2 = RooFormulaVar("mean_2", "@0+@1", RooArgList(mean_1, deltam))
sigma_2 = RooRealVar("sigma_2", "sigma ChiB2", 0.0059, 'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', 0.738)
n1_2 = RooRealVar('n1_2', 'n1_2', 2.8)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', 1.699)
n2_2 = RooRealVar('n2_2', 'n2_2', 3.0)
parameters = RooArgSet()
parameters.add(RooArgSet(sigma_1, sigma_2))
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
parameters.add(RooArgSet(a1_2, a2_2, n1_2, n2_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1,
a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2,
a2_2, n2_2)
#background
q01S_Start = 9.5
alpha = RooRealVar("#alpha", "#alpha", 1.5, -1, 3.5) #0.2 anziche' 1
beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.)
q0 = RooRealVar("q0", "q0", q01S_Start) #,9.5,9.7)
delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0))
b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0))
signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.",
RooArgList(x, q0))
background = RooGenericPdf("background", "Background",
"signum1*pow(delta,#alpha)*exp(b1)",
RooArgList(signum1, delta, alpha, b1))
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf, chib2_pdf, background)
n_chib = RooRealVar("n_chib", "n_chib", 2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21", "ratio_21", 0.5, 0, 1)
n_chib1 = RooFormulaVar("n_chib1", "@0/(1+@1)",
RooArgList(n_chib, ratio_21))
n_chib2 = RooFormulaVar("n_chib2", "@0/(1+1/@1)",
RooArgList(n_chib, ratio_21))
n_background = RooRealVar('n_background', 'n_background', 4550, 0, 50000)
ratio_list = RooArgList(n_chib1, n_chib2, n_background)
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
frame = x.frame(RooFit.Title('m'))
range = x.setRange('range', 9.7, 10.1)
result = modelPdf.fitTo(dataset, RooFit.Save(), RooFit.Range('range'))
dataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
#plotting
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
canvas.SaveAs('out-' + binname + '.png')
def dofit(roodataset, hname):
mass_chib = 10.5103 # from PES uncorrected mass measurement
deltaM = 0.0105 # MeV theoretical expectations
ratio21 = 0.45 # same as chic2/chic1 and chib2/chib1
# the following numbers are from an old 3P gun simulation
# that needs to be re-done
sigma1 = 0.003 #0.0031
sigma2 = 0.003 #0.0035
alpha1 = 0.95
alpha2 = 1.12
n = 2.5
mass1_v = RooRealVar('mchi1', 'm_{#chi1}', mass_chib)
deltaM_v = RooRealVar('deltaM', '#Delta_{m}', deltaM, 0.005, 0.015)
mass2_v = RooFormulaVar('mchi2', '@0+@1', RooArgList(mass1_v, deltaM_v))
sigma1_v = RooRealVar('sigma1', '#sigma_1', sigma1)
sigma2_v = RooRealVar('sigma2', '#sigma_2', sigma2)
alpha1_v = RooRealVar('alpha1', '#alpha_1', alpha1)
alpha2_v = RooRealVar('alpha2', '#alpha_2', alpha2)
n_v = RooRealVar('n', 'n', n)
ratio21_v = RooRealVar('ratio21', 'r_{21}', ratio21)
x = RooRealVar("invm3S", "#chi_{b} Data", 10.4, 10.7)
# choose here binning of mass plot
x.setBins(150)
#signal pdf
chib1 = RooCBShape('chib1', 'chib1', x, mass1_v, sigma1_v, alpha1_v, n_v)
chib2 = RooCBShape('chib2', 'chib2', x, mass2_v, sigma2_v, alpha2_v, n_v)
# define background
q01S_Start = 10.4
alpha = RooRealVar("#alpha", "#alpha", 1.5, 0.2, 3.5)
beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.)
#q0 = RooRealVar("q0","q0",q01S_Start,q01S_Start-0.05,q01S_Start+0.05)
q0 = RooRealVar("q0", "q0", q01S_Start)
delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0))
b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0))
signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.",
RooArgList(x, q0))
background = RooGenericPdf("background", "Background",
"signum1*pow(delta,#alpha)*exp(b1)",
RooArgList(signum1, delta, alpha, b1))
n_evts_1 = RooRealVar('N_{3P_{1}}', 'N_{3P_{1}}', 50, 30, 1000)
n_evts_2 = RooFormulaVar('N_{3P_{2}}', '@0*@1',
RooArgList(n_evts_1, ratio21_v))
n_bck = RooRealVar('nbkg', 'n_{bkg}', 500, 0, 100000)
#build final pdf
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf',
RooArgList(chib1, chib2, background),
RooArgList(n_evts_1, n_evts_2, n_bck))
# fit
low_cut = x.setRange("low_cut", 10.4, 10.7)
result = modelPdf.fitTo(roodataset, RooFit.Save(), RooFit.Range("low_cut"))
frame = x.frame(RooFit.Title("m(#chi_{b}(3P))"))
roodataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(1))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
frame.GetXaxis().SetTitle(
'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon(3S)} [GeV/c^{2}]'
)
#frame.GetYaxis().SetTitle( "Events/15.0 MeV " )
frame.GetXaxis().SetTitleSize(0.04)
frame.GetYaxis().SetTitleSize(0.04)
frame.GetXaxis().SetTitleOffset(1.1)
frame.GetXaxis().SetLabelSize(0.04)
frame.GetYaxis().SetLabelSize(0.04)
frame.SetLineWidth(1)
frame.SetName("fit_resonance")
chi2 = frame.chiSquare()
chi2 = round(chi2, 2)
leg = TLegend(0.50, 0.7, 0.60, 0.8)
leg.AddEntry(0, '#chi^{2} =' + str(chi2), '')
leg.SetBorderSize(0)
leg.SetFillColor(0)
leg.SetTextSize(0.06)
gROOT.SetStyle("Plain")
frame.SaveAs(str(hname) + '.root')
# param_set = RooArgSet(n_evts_Roo4, m_chib[1][3],alpha, beta, q0)
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
# modelPdf.paramOn(frame, RooFit.Layout(0.725,0.9875,0.9), RooFit.Parameters(param_set))
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
leg.Draw("same")
canvas.SaveAs(str(hname) + '.png')
# J/psi PDF mass for m0 taken as TDatabasePDG::Instance()->GetParticle( 443 )->Mass()
m0 = RooRealVar("m0", "mass", 3.09692, 3., 3.15)
n = RooRealVar("n", "n", 2, 0., 20.)
sig = RooRealVar("sig", "resolution", 0.1, 0.001, 0.2)
alpha = RooRealVar("alpha", "alpha", 0.3, 0.1, 4.1)
cb = RooCBShape("cb", "Crystal Ball PDF", m, m0, sig, alpha, n)
#_____________________________________________________________________________
#Background function
lam = RooRealVar("lambda", "Exponent", -0.6, -10., 0.)
c1 = RooRealVar("c1", "c1", 1.5, 0.5, 2.5)
c2 = RooRealVar("c2", "c2", 0.04, -1., 1.)
bkg_func = "TMath::Abs(jRecM-c1)*TMath::Exp(lambda*(jRecM-c1)*(jRecM-c1)+c2*(jRecM-c1)*(jRecM-c1)*(jRecM-c1))"
#bkg_func = "TMath::Abs(jRecM-c1)*TMath::Exp(lambda*(jRecM-c1)*(jRecM-c1)+c2*jRecM*jRecM*jRecM)"
#abs() is to prevent error messages about negative values below the fit range
bkgd = RooGenericPdf("Background", bkg_func, RooArgList(m, lam, c1, c2))
#version for plotting with fixed parameters
lamF = RooRealVar("lambdaF", "lambdaF", -2.422)
c1f = RooRealVar("c1f", "c1f", 1.227)
c2f = RooRealVar("c2f", "c2f", 0.240)
bkg_func_f = "TMath::Abs(jRecM-c1f)*TMath::Exp(lambdaF*(jRecM-c1f)*(jRecM-c1f)+c2f*(jRecM-c1f)*(jRecM-c1f)*(jRecM-c1f))"
#bkg_func_f = "TMath::Abs(jRecM-c1f)*TMath::Exp(lambdaF*(jRecM-c1f)*(jRecM-c1f)+c2f*jRecM*jRecM*jRecM)"
bkgd_f = RooGenericPdf("Background_f", bkg_func_f, RooArgList(m, lamF, c1f, c2f))
def shapeCards(datahistosFile, histosFile, signalFile, signalSample, hist,
signalMass, minMass, maxMass, outputName, outputFileTheta):
"""function to run Roofit and save workspace for RooStats"""
warnings.filterwarnings(
action='ignore',
category=RuntimeWarning,
message='.*class stack<RooAbsArg\*,deque<RooAbsArg\*> >')
############################################################# DATA
#hData = histosFile.Get('massAve_deltaEtaDijet_QCDPtAll')
#hData = datahistosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj')
dataFile = TFile(datahistosFile)
hData = dataFile.Get(hist + '_DATA')
hData.Rebin(args.reBin)
#hData = hData.Rebin( len( boostedMassAveBins )-1, hData.GetName(), boostedMassAveBins )
#hData = histosFile.Get(hist+'_QCDPtAll_A')
#hData.Add(htmpSignal)
#hData.Scale(1/hData.Integral())
#maxMass = boostedMassAveBins[ hData.FindLastBinAbove( 0, 1) ]
#minMass = signalMass-30
#maxMass = signalMass+30
massAve = RooRealVar('massAve', 'massAve', minMass, maxMass)
#massAveData = RooRealVar( 'massAveData', 'massAveData', minMass, maxMass )
rooDataHist = RooDataHist('rooDatahist', 'rooDatahist',
RooArgList(massAve),
hData) # if isData else hPseudo )
rooDataHist.Print()
############################################################################################
####################### Signal
if 'gaus' in args.job:
hSignal = TH1F('massAve_RPVStop', 'massAve_RPVStop',
maxMass / args.reBin, minMass, maxMass)
for q in range(hSignal.GetNbinsX() + 1):
gausEval = signalFile.Eval(hSignal.GetXaxis().GetBinCenter(q))
hSignal.SetBinContent(q, gausEval)
#meanSig = RooRealVar( 'meanSig', 'mean of signal', sigGaus.GetParameter( 1 ) )
#sigmaSig = RooRealVar( 'sigmaSig', 'sigma of signal', sigGaus.GetParameter( 2 ) )
#signalPdf = RooGaussian( 'signal', 'signal', massAve, meanSig, sigmaSig )
#signalPdf.Print()
else:
signalHistosFile = TFile(signalFile)
hSignal = signalHistosFile.Get(hist + '_' + signalSample)
hSignal.Rebin(args.reBin)
hSignal.Scale(twoProngSF)
signalXS = search(dictXS, 'RPVStopStopToJets_UDD312_M-' + str(signalMass))
rooSigHist = RooDataHist('rooSigHist', 'rooSigHist', RooArgList(massAve),
hSignal)
sigAcc = rooSigHist.sumEntries(
) #round(hSignal.Integral( hSignal.GetXaxis().FindBin( minMass ), hSignal.GetXaxis().FindBin( maxMass )), 2)
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()
#####################################################################
hSigSyst = signalUnc(hSignal, signalMass)
hSigSystDataHist = {}
if args.jesUnc:
hSigSystDataHist['JESUp'] = RooDataHist('hSignalJESUp', 'hSignalJESUp',
RooArgList(massAve),
hSigSyst['JESUp'])
hSigSystDataHist['JESDown'] = RooDataHist('hSignalJESDown',
'hSignalJESDown',
RooArgList(massAve),
hSigSyst['JESDown'])
if args.jerUnc:
hSigSystDataHist['JERUp'] = RooDataHist('hSignalJERUp', 'hSignalJERUp',
RooArgList(massAve),
hSigSyst['JERUp'])
hSigSystDataHist['JERDown'] = RooDataHist('hSignalJERDown',
'hSignalJERDown',
RooArgList(massAve),
hSigSyst['JERDown'])
#################################### Background
if args.altBkg:
newBkgHistoFile = datahistosFile.replace('DATA', 'DATA_ABCDBkg')
newBkgFile = TFile(newBkgHistoFile)
htmpBkg = newBkgFile.Get(
'massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj')
if (htmpBkg.GetBinWidth(1) != args.reBin):
print '|----- Bin size in DATA_C histogram is different than rest.'
sys.exit(0)
else:
htmpBkg = dataFile.Get(
'massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj')
htmpBkg.Rebin(args.reBin)
#hBkg = histosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_QCDPtAll_ABCDProj')
#hBkg = histosFile.Get(hist+'_QCDPtAll_BCD')
#htmpBkg = htmpBkg.Rebin( len( boostedMassAveBins )-1, htmpBkg.GetName(), boostedMassAveBins )
hBkg = htmpBkg.Clone()
hBkg.Reset()
for ibin in range(htmpBkg.GetNbinsX()):
binCont = htmpBkg.GetBinContent(ibin)
binErr = htmpBkg.GetBinError(ibin)
if binCont == 0:
hBkg.SetBinContent(ibin, 0)
hBkg.SetBinError(ibin, 1.8)
else:
hBkg.SetBinContent(ibin, binCont)
hBkg.SetBinError(ibin, binErr)
#hBkg.Scale(1/hBkg.Integral())
hPseudo = createPseudoExperiment(hBkg, bkgAcc)
###### Adding statistical uncertanty
hBkgStatUncUp = hBkg.Clone()
hBkgStatUncUp.Reset()
hBkgStatUncDown = hBkg.Clone()
hBkgStatUncDown.Reset()
for i in range(hBkg.GetNbinsX() + 1):
cont = hBkg.GetBinContent(i)
contErr = hBkg.GetBinError(i)
hBkgStatUncUp.SetBinContent(i, cont + (1 * contErr))
hBkgStatUncDown.SetBinContent(i, cont - (1 * contErr))
hBkgStatUncUpDataHist = RooDataHist('hBkgStatUncUp', 'hBkgStatUncUp',
RooArgList(massAve), hBkgStatUncUp)
hBkgStatUncDownDataHist = RooDataHist('hBkgStatUncDown', 'hBkgStatUncDown',
RooArgList(massAve), hBkgStatUncDown)
if 'template' in args.job:
rooBkgHist = RooDataHist('rooBkgHist', 'rooBkgHist',
RooArgList(massAve), hBkg)
bkgAcc = rooBkgHist.sumEntries()
rooBkgHist.Print()
background = RooHistPdf('background', 'background', RooArgSet(massAve),
rooBkgHist)
background.Print()
else:
massAveBkg = RooRealVar('massAveBkg', 'massAveBkg', minMass, maxMass)
p1 = RooRealVar('p1', 'p1', 1, 0., 100.)
p2 = RooRealVar('p2', 'p2', 1, 0., 60.)
p3 = RooRealVar('p3', 'p3', 1, -10., 10.)
bkgAcc = round(
hBkg.Integral(hBkg.GetXaxis().FindBin(minMass),
hBkg.GetXaxis().FindBin(maxMass)), 2)
background = RooGenericPdf(
'background',
'(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))' %
(1300, 1300, 1300), RooArgList(massAveBkg, p1, p2, p3))
background.Print()
hBkgSyst = {}
hBkgSystDataHist = {}
if args.bkgUnc:
print ' |---> Adding bkg unc'
hBkgSyst['BkgUncUp'] = hBkg.Clone()
hBkgSyst['BkgUncDown'] = hBkg.Clone()
for key in hBkgSyst:
hBkgSyst[key].Reset()
hBkgSyst[key].SetName(hBkgSyst[key].GetName() + '_' + key)
for q in range(0, hBkg.GetNbinsX()):
binCont = hBkg.GetBinContent(q)
bkgUncUp = 1. + (args.bkgUncValue / 100.)
hBkgSyst['BkgUncUp'].SetBinContent(q, binCont * bkgUncUp)
bkgUncDown = 1. - (args.bkgUncValue / 100.)
hBkgSyst['BkgUncDown'].SetBinContent(q, binCont * bkgUncDown)
hBkgSystDataHist['BkgUncUp'] = RooDataHist('hBkgBkgUncUp',
'hBkgBkgUncUp',
RooArgList(massAve),
hBkgSyst['BkgUncUp'])
hBkgSystDataHist['BkgUncDown'] = RooDataHist('hBkgBkgUncDown',
'hBkgBkgUncDown',
RooArgList(massAve),
hBkgSyst['BkgUncDown'])
############################################################################################
#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()
############################ Create Workspace
myWS = RooWorkspace("myWS")
getattr(myWS, 'import')(rooBkgHist, RooFit.Rename("background"))
#getattr(myWS,'import')(background,RooFit.Rename("background"))
#getattr(myWS,'import')(signal_norm)
#getattr(myWS,'import')(background_norm)
'''
if 'gaus' in args.job:
getattr(myWS,'import')(signalPdf,RooFit.Rename("signal"))
if args.jesUnc:
getattr(myWS,'import')(signalPdfJESUp,RooFit.Rename("signal__JESUp"))
getattr(myWS,'import')(signalPdfJESDown,RooFit.Rename("signal__JESDown"))
else:
'''
getattr(myWS, 'import')(rooSigHist, RooFit.Rename("signal"))
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"))
if args.bkgUnc:
getattr(myWS, 'import')(hBkgSystDataHist['BkgUncUp'],
RooFit.Rename("background__BkgUncUp"))
getattr(myWS, 'import')(hBkgSystDataHist['BkgUncDown'],
RooFit.Rename("background__BkgUncDown"))
getattr(myWS, 'import')(hBkgStatUncUpDataHist,
RooFit.Rename("background__BkgStatUncUp"))
getattr(myWS, 'import')(hBkgStatUncDownDataHist,
RooFit.Rename("background__BkgStatUncDown"))
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
'''
c1 = TCanvas('c1', 'c1', 10, 10, 750, 500 )
# c1.SetLogy()
xframe = myWS.var("massAve").frame()
signalPdf.plotOn( xframe )
xframe.Draw()
c1.SaveAs('test.png')
del c1
'''
############################################################################################
######################### 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.bkgUnc 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 ' + signalSample + '\n')
datacard.write('observation -1\n')
datacard.write('------------------------------\n')
datacard.write('bin ' + signalSample + ' ' +
signalSample + '\n')
datacard.write('process signal background\n')
datacard.write('process 0 1\n')
#datacard.write('rate -1 -1\n')
datacard.write('rate ' + str(sigAcc) + ' ' + str(bkgAcc) +
'\n')
datacard.write('------------------------------\n')
if args.lumiUnc:
datacard.write('lumi lnN %f -\n' % (lumiValue))
if args.puUnc: datacard.write('pu lnN %f -\n' % (puValue))
if args.jesUnc: datacard.write('JES shape 1 -\n')
if args.jerUnc: datacard.write('JER shape 1 -\n')
#flat parameters --- flat prior
#if args.bkgUnc: datacard.write('BkgUnc shape - '+str( round( 1/ (args.bkgUncValue/34.1), 2 ) )+'\n')
if args.bkgUnc: datacard.write('BkgUnc shape - 1 \n')
#NcombineUnc = ( 1 / TMath.Sqrt( args.bkgUncValue / 100. ) ) - 1
#datacard.write('background_norm gmN '+str(int(round(NcombineUnc)))+' - '+str( round(bkgAcc/NcombineUnc,2) )+'\n')
#datacard.write('p1 flatParam\n')
datacard.write('BkgStatUnc shape - 1 \n')
datacard.close()
print ' |----> Datacard created:\n', dataCardName
############################################################################################
########## Theta
if args.theta:
print ' |----> Creating Theta file\n', outputFileTheta
outFile = TFile(outputFileTheta, 'update')
tmpName = 'rpvstopjj' + str(signalMass)
hSignal.SetName('massAve__' + tmpName)
hSignal.Write()
hSigSyst['JESDown'].SetName('massAve__' + tmpName + '__jes__down')
hSigSyst['JESDown'].Write()
hSigSyst['JESUp'].SetName('massAve__' + tmpName + '__jes__up')
hSigSyst['JESUp'].Write()
hSigSyst['JERDown'].SetName('massAve__' + tmpName + '__jer__down')
hSigSyst['JERDown'].Write()
hSigSyst['JERUp'].SetName('massAve__' + tmpName + '__jer__up')
hSigSyst['JERUp'].Write()
if (signalMass == 100): #or (signalMass == 170):
hBkg.SetName('massAve__background')
hBkg.Write()
hBkgSyst['BkgUncDown'].SetName('massAve__background__unc__down')
hBkgSyst['BkgUncDown'].Write()
hBkgSyst['BkgUncUp'].SetName('massAve__background__unc__up')
hBkgSyst['BkgUncUp'].Write()
hData.SetName('massAve__DATA')
hData.Write()
outFile.Close()
setTDRStyle()
gROOT.ForceStyle()
gROOT.SetStyle('tdrStyle')
filename = 'dijetHisto_data_signal.root'
inf = TFile.Open(filename)
h = inf.Get('h_mjj')
x = RooRealVar('mjj','mjj',900,4500)
NBINS = 180
p1 = RooRealVar('p1','p1',5,0,20)
p2 = RooRealVar('p2','p2',5,0,20)
p3 = RooRealVar('p3','p3',0.1,0,1)
model = RooGenericPdf('model','pow(1-@0/8000,@1)/pow(@0/8000,@2+@3*log(@0/8000))',RooArgList(x,p1,p2,p3))
roohist = RooDataHist('roohist','roohist',RooArgList(x),h)
res = model.fitTo(roohist)
can = TCanvas('can_Mjj_Data','can_Mjj_Data',900,600)
gPad.SetLogy()
can.cd(1).SetBottomMargin(0.4);
frame1 = x.frame()
frame2 = x.frame();
roohist.plotOn(frame1,RooFit.Binning(NBINS))
model.plotOn(frame1)
hpull = frame1.pullHist();
frame2.addPlotable(hpull,'p');
bin_cut = "((Lb_M23*Lb_M23 > {}) && (Lb_M23*Lb_M23 < {}))".format(
qsq_bin_min, qsq_bin_max)
pt_cut = "((mum_PT > {}) && (mup_PT > {}) && (pplus_PT > {}) && (Kminus_PT > {}))".format(
cut_mum_PT, cut_mup_PT, cut_pplus_PT, cut_Kminus_PT)
tot_cut = "{} && {}".format(bin_cut, pt_cut)
data_selected = data_all.reduce(tot_cut)
data_all.Print()
data_selected.Print()
data_selected.get(49).Print("cosTheta_lepton")
# ----------------------------------------------
# define the PDFs
# ----------------------------------------------
Legendre_Lep = RooGenericPdf ("Legendre_Lep", Legendre_Lep_even,\
RooArgList (cosTheta_lepton, cLep2, cLep4,cLep6))
Legendre_Lambda = RooGenericPdf ("Legendre_Lambda", Legendre_Lambda_all, \
RooArgList (cosTheta_Lst,cLambda1, cLambda2,cLambda3, cLambda4, cLambda5))
# ----------------------------------------------
# Make the fit
# ----------------------------------------------
fit_results_RooFit_Lep = Legendre_Lep.fitTo(data_selected,
ROOT.RooFit.Save())
fit_results_RooFit_Lambda = Legendre_Lambda.fitTo(
data_selected, ROOT.RooFit.Save())
#write the the numbers that we need in a text file for the toys later
results.write("----\n")
results.write("----\n")
results.write(
# define observable
x = RooRealVar('mjj','mjj',900,4500)
if fitSig:
# define parameters for signal fit
m = RooRealVar('mean','mean',float(mass),float(mass)-200,float(mass)+200)
s = RooRealVar('sigma','sigma',0.1*float(mass),0,10000)
a = RooRealVar('alpha','alpha',1,-10,10)
n = RooRealVar('n','n',1,0,100)
sig = RooCBShape('sig','sig',x,m,s,a,n)
p = RooRealVar('p','p',1,0,5)
x0 = RooRealVar('x0','x0',1000,100,5000)
bkg = RooGenericPdf('bkg','1/(exp(pow(@0/@1,@2))+1)',RooArgList(x,x0,p))
fsig= RooRealVar('fsig','fsig',0.5,0.,1.)
signal = RooAddPdf('signal','signal',sig,bkg,fsig)
# -----------------------------------------
# fit signal
canSname = 'can_Mjj'+str(mass)
if useSub:
canSname = 'can_Sub_Mjj'+str(mass)
canS = TCanvas(canSname,canSname,900,600)
#gPad.SetLogy()
roohistSig = RooDataHist('roohist','roohist',RooArgList(x),hSig)
signal.fitTo(roohistSig)
def buildPdf(ws, p):
mass = RooRealVar("mass", "mass", p.minMass, p.maxMass)
# ws.import(mass)
getattr(ws,'import')(mass)
# Construct signal pdf
mean = RooRealVar("mean", "mean", 60, 0, 130)
width = RooRealVar("width", "width", 10, 1, 40)
# alpha = RooRealVar("alpha", "#alpha", -0.1, -10.0, -0.1)
# npow = RooRealVar("npow", "n_{CB}", 2.3, 0.1, 10.)
# width.setConstant(ROOT.kTRUE)
sigma = RooRealVar("sigma", "sigma", 1.2, 0.2, 40)
# minusMass = RooFormulaVar("minusMass", "@0*-1", RooArgList(mass))
# signalAll = RooCBShape("signalAll", "signalAll", mass, mean, width, alpha, npow);
signalAll = RooVoigtian("signalAll", "signalAll", mass, mean, width, sigma)
# Construct background pdf
# a0_all = RooRealVar("a0_all","a0_all",-0.1,-1,1)
# a1_all = RooRealVar("a1_all","a1_all",0.004,-1,1)
# backgroundAll = RooChebychev("backgroundAll","backgroundAll",mass,RooArgList(a0_all,a1_all))
turnOnAll = RooRealVar("turnOnAll","turnOnAll", 80., 40., 150.)
widthAll_bkg = RooRealVar("widthAll","widthAll", 2., 0., 50.)
decayAll_bkg = RooRealVar("decayAll","decayAll", 80., 20., 150.)
meanB = RooRealVar("meanB", "meanB", 90, 60, 130)
sigmaB = RooRealVar("sigmaB", "sigmaB", 10, 1, 20)
bkg_a1 = RooRealVar("bkg_a1", "bkg_a1", 0., -2., 2.)
bkg_a2 = RooRealVar("bkg_a2", "bkg_a2", 0., -2., 2.)
#backgroundAll = RooChebychev("backgroundAll", "backgroundAll", mass, RooArgList(bkg_a1, bkg_a2))
#backgroundAll = RooGenericPdf("backgroundAll","backgroundAll", "exp(-@0/@3)*(TMath::Erf((@0-@1)/@2)+1)", RooArgList(mass, turnOnAll, widthAll_bkg, decayAll_bkg))
backgroundAll = RooGenericPdf("backgroundAll","backgroundAll","exp(-@0/@1)",RooArgList(mass, decayAll_bkg))
#backgroundAll = RooGaussian("backgroundAll", "backgroundAll", mass, meanB, sigmaB)
# Construct composite pdf
sigAll = RooRealVar("sigAll", "sigAll", 2000, 0, 10000000)
bkgAll = RooRealVar("bkgAll", "bkgAll", 100, 0, 1000000)
modelAll = RooAddPdf("modelAll", "modelAll", RooArgList(signalAll, backgroundAll), RooArgList(sigAll, bkgAll))
if p.NoBkgd:
modelAll = RooAddPdf("modelAll", "modelAll", RooArgList(signalAll), RooArgList(sigAll))
# Define pdf for all probes
# Construct signal pdf.
# NOTE that sigma is shared with the signal sample model
signalPass = RooVoigtian("signalPass","signalPass",mass,mean,width,sigma)
# signalPass = RooCBShape("signalPass", "signalPass", mass, mean, width, alpha, npow);
# Construct the background pdf
# a0_pass = RooRealVar("a0_pass","a0_pass",-0.1,-1,1)
# a1_pass = RooRealVar("a1_pass","a1_pass",0.5,-0.1,1)
# backgroundPass = RooChebychev("backgroundPass","backgroundPass",mass,RooArgList(a0_pass,a1_pass))
# turnOnPass = RooRealVar("turnOnPass","turnOnPass", 80., 50., 150.)
# widthPass_bkg = RooRealVar("widthPass","widthPass", 2., 0., 50.)
decayPass_bkg = RooRealVar("decayPass","decayPass", 80., 20., 150.)
#backgroundPass = RooChebychev("backgroundPass", "backgroundPass", mass, RooArgList(bkg_a1, bkg_a2))
#backgroundPass = RooGenericPdf("backgroundPass","backgroundPass", "exp(-@0/@3)*(TMath::Erf((@0-@1)/@2)+1)", RooArgList(mass, turnOnPass, widthPass_bkg, decayPass_bkg));
#backgroundPass = RooGenericPdf("backgroundPass","backgroundPass", "exp(-@0/@3)*(TMath::Erf((@0-@1)/@2)+1)", RooArgList(mass, turnOnAll, widthAll_bkg, decayAll_bkg));
backgroundPass = RooGenericPdf("backgroundPass","backgroundPass","exp(-@0/@1)",RooArgList(mass, decayPass_bkg))
#backgroundPass = RooGaussian("backgroundPass", "backgroundPass", mass, meanB, sigmaB)
# Construct the composite model
efficiency = RooRealVar("efficiency","efficiency",0.9,0.1,1.)
# Use it only analyzing the data prescaling value set to be 20
sigPass = RooFormulaVar("sigPass", "@0*@1*"+str(p.scaleFactor), RooArgList(sigAll, efficiency))
bkgPass = RooRealVar("bkgPass", "bkgPass", 100, 0, 1000000)
# bkgPass = RooFormulaVar("bkgPass", "@0*@1", RooArgList(bkgAll, efficiency))
modelPass = RooAddPdf("modelPass", "modelPass", RooArgList(signalPass, backgroundPass), RooArgList(sigPass, bkgPass))
if p.NoBkgd:
modelPass = RooAddPdf("modelPass", "modelPass", RooArgList(signalPass), RooArgList(sigPass))
frac = RooRealVar("frac", "frac", 0.8, 0., 1.)
# Define combined pdf for simultaneous fit
# Define category to distinguish physics and control samples events
sample = RooCategory("sample","sample")
sample.defineType("all")
sample.defineType("pass")
simPdf = RooSimultaneous("simPdf","simultaneous pdf",sample)
# Associate model with the physics state and model_ctl with the control state
simPdf.addPdf(modelAll,"all")
simPdf.addPdf(modelPass,"pass")
# ws.import(simPdf)
getattr(ws,'import')(simPdf)
"resolution",
x,
mean,
sigma1
)
decay = RooDecay(
"exp",
"exp",
x,
tau,
r1,
RooDecay.DoubleSided)
p1 = decay
p2 = bw
p1 = RooGenericPdf("pdf","exp(-abs(x)/tau)",RooArgList(x,tau)) ;
p2 = RooGenericPdf("pdf","exp(-abs(x)/tau2)",RooArgList(x,tau2)) ;
#pdf = RooNumConvPdf("pdf", 'convolution', x, p1, p2)
#x.setBins(10000,"fft") ;
#pdf = RooFFTConvPdf("pdf", 'convolution', x, p1, p2)
#pdf.setBufferFraction(50.0)
#pdf = RooGenericPdf("pdf","abs(x)>m0?exp(-abs(x)/tau)+exp(-m0/tau2)-exp(-m0/tau):exp(-abs(x)/tau2)",RooArgList(x,m0,tau,tau2)) ;
#pdf = RooGenericPdf("pdf","abs(x)>m0?exp(-abs(x)/tau2):exp(-abs(x)/tau)+exp(-m0/tau2)-exp(-m0/tau)",RooArgList(x,m0,tau,tau2)) ;
pdf = RooGenericPdf("pdf","exp(-abs(x)/tau2)/tau2>exp(-abs(x)/tau)/tau?exp(-abs(x)/tau2)/tau2:exp(-abs(x)/tau)/tau",RooArgList(x,tau,tau2)) ;
#pdf = RooGenericPdf("pdf","exp(-abs(x)/tau)+1000",RooArgList(x,m0,tau,tau2)) ;
# Plot PDF
canvas = TCanvas("c1","",1200,480);
canvas.Divide(3,1);
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
#background parameters
q01S_Start = 9.62
alphabkg1S = RooRealVar("#alpha1S","#alpha1S",1.5,0.2,10)
beta = RooRealVar("#beta1S","#beta1S",-2.5,-7.,0.)
q01S = RooRealVar("q01S","q01S",q01S_Start)
delta1S = RooFormulaVar("delta1S","TMath::Abs(@0-@1)",RooArgList(x,q01S))
b11S = RooFormulaVar("b11S","@0*(@1-@2)",RooArgList(beta,x,q01S))
signum11S = RooFormulaVar( "signum11S","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q01S) )
background1S = RooGenericPdf("background","Background", "signum11S*pow(delta1S,#alpha1S)*exp(b11S)", RooArgList(signum11S,delta1S,alphabkg1S,b11S) )
q02S_Start = 10.0
alphabkg2S = RooRealVar("#alpha2S","#alpha2S",1.5,0.2,3.5)
beta2S = RooRealVar("#beta2S","#beta2S",-2.5,-7.,0.)
q02S = RooRealVar("q02S","q02S",q02S_Start,q02S_Start-0.05,q02S_Start+0.05)
delta2S = RooFormulaVar("delta2S","TMath::Abs(@0-@1)",RooArgList(x,q02S))
b12S = RooFormulaVar("b12S","@0*(@1-@2)",RooArgList(beta2S,x,q02S))
signum12S = RooFormulaVar( "signum12S","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q02S) )
background2S = RooGenericPdf("background","Background", "signum12S*pow(delta2S,#alpha2S)*exp(b12S)", RooArgList(signum12S,delta2S,alphabkg2S,b12S) )
# define background
class CouplingsFitter2(object):
def __init__(self):
self.poiLabels = []
self.BR = dict(b=0.577,
tau=0.063,
mu=2.2e-4,
c=2.91e-2,
g=8.57e-2,
gamma=3.82e-3,
W=0.215,
Z=0.0264,
t=0.0)
self.poi = dict()
self.poilabels = dict()
self.constraint = dict()
self.canvases = dict()
self._keep = []
def addPOI(self, poi, label='', minimum=-0.3, maximum=0.3):
'''Add a parameter of interest.
Example:
addPOI('Z','Z',-0.05,0.05)
->
Z[0,-0.05,0.05]
# adds variable Z with value 0,
# allow it to scale between -0.05 and 0.05
'''
self.poi[poi] = ROOT.RooRealVar(poi, poi, 0, minimum, maximum)
if label == '':
label = poi
self.poilabels[poi] = label
def createWidthDeviation(self):
'''Compute the width deviation (denoted \kappa_H^2 by M.Peskin in arxiv 1312.4974).
Note that we fit an additive modification of the coupling: (1 + dx)
is therefore equal to kappa_x
'''
expr = '0'
sumBR = sum(self.BR.values())
pwidths = []
for dcoupling, br in self.BR.iteritems():
pwidth = None
if dcoupling in self.poi:
pwidth = str(
br /
sumBR) + "*(1+" + dcoupling + ")*(1+" + dcoupling + ")"
else:
# using sm partial width
pwidth = str(br / sumBR)
pwidths.append(pwidth)
expr = '+'.join(pwidths)
if 'inv' in self.poi:
expr = '(' + expr + ')/(1.0-inv)'
else:
# setting invisible width to 0.
expr = '(' + expr + ')'
dependentlist = RooArgList()
for dep in self.poi.values():
dependentlist.add(dep)
self.width = RooGenericPdf('width', 'width', expr, dependentlist)
def addConstraint(self, name, expr, deplist, mean, sigma):
'''Add a constraint on one of the observables
For example, for ZH inclusive:
f.addConstraint('Zh','(1+Z)*(1+Z)','Z',1,0.004)
Z is an additive modification of the gZ coupling w/r to the standard model,
so 1+Z = \kappa_Z
Zh is the pdf of the ratio of the yield w/r to the one expected in the standard model.
This pdf depends on Z, as (1+Z)*(1+Z).
ZhObs is the measured value, here 1 so we assume that the SM yield is observed.
The fit varies the parameter of interest Z, thus modifying the pdf,
while ZhObs is fixed at 1. The likelihood of each value of Z is evaluated at ZhObs on the pdf.
'''
print 'constraint:', name
print expr
print deplist
print mean, '+/-', sigma
deps = self._getdeps(deplist)
self.constraint[name] = GaussianConstraint(name, expr, deps, mean,
sigma)
def _getdeps(self, deplist):
depnames = deplist
try:
depnames = deplist.split(',')
except:
pass
deps = []
for dep in depnames:
if dep == 'width':
deps.append(self.width)
else:
deps.append(self.poi[dep])
return deps
def addChannel(self, name, mean, sigma, prod, decay=None):
expr_prod = '(1+{prod})*(1+{prod})'.format(prod=prod)
expr = expr_prod
variables = [prod]
if decay:
if isinstance(decay, basestring):
expr_decay = '(1+{decay})*(1+{decay})'.format(decay=decay)
variables.append(decay)
else:
decay_exprs = []
for decay, fraction in decay:
n = mean * fraction
decay_expr = '{n}*(1+{decay})*(1+{decay})'.format(
n=n, decay=decay)
decay_exprs.append(decay_expr)
variables.append(decay)
expr_decay = ' + '.join(decay_exprs)
expr = '{expr_prod}*({expr_decay})/width'.format(
expr_prod=expr_prod,
expr_decay=expr_decay,
)
variables.append('width')
variables = list(set(variables))
deplist = ','.join(variables)
self.addConstraint(name, expr, deplist, mean, sigma)
def addUniformConstraint(self, name, expr):
'''Adds a uniform constraint with pdf name, and expression expr.
For example:
f.addPOI('inv','inv', 0, 0.01)
f.addUniformConstraint('Zhinv','inv') ####->Means free floating
inv (the invisible BR) is free to float between 0 and 1%
'''
deps = self._getdeps([expr])
self.constraint[name] = UniformConstraint(name, expr, deps)
def info(self):
for name, constraint in sorted(self.constraint.iteritems()):
constraint.info()
def fit(self):
pdfs = RooArgList()
obsvars = RooArgSet('set')
for constraint in self.constraint.values():
pdfs.add(constraint.pdf_constraint)
if hasattr(constraint, 'var_obs'):
obsvars.add(constraint.var_obs)
self.model = RooProdPdf('model', 'model', pdfs)
self.data = RooDataSet('data', 'data', obsvars)
self.data.add(obsvars)
self.data.Print()
self.fit_result = self.model.fitTo(self.data,
ROOT.RooFit.PrintLevel(3),
ROOT.RooFit.Optimize(1),
ROOT.RooFit.Hesse(1),
ROOT.RooFit.Minos(1),
ROOT.RooFit.Strategy(2),
ROOT.RooFit.Save(1))
def canvas(self, name, *args):
canvas = self.canvases.setdefault(name,
ROOT.TCanvas(name, name, *args))
canvas.cd()
return canvas
def keep(self, obj):
self._keep.append(obj)
return obj
def createSummary(self):
#sample the covariance matrix for the width
# ROOT.gStyle.SetOptTitle(0)
ROOT.gStyle.SetStatW(0.4)
ROOT.gStyle.SetStatH(0.4)
self.graph_couplings = ROOT.TGraphAsymmErrors(len(self.poi) + 2)
order_BR = ['Z', 'W', 'b', 'c', 'g', 'tau', 'mu', 'gamma', 'inv']
for br in order_BR:
if not self.poi.get(br, None):
order_BR.remove(br)
for i, poiname in enumerate(order_BR):
poi = self.poi.get(poiname)
self.graph_couplings.SetPoint(i, i + 0.5, poi.getVal())
self.graph_couplings.SetPointError(i, 0.0, 0.0,
-poi.getAsymErrorLo(),
poi.getAsymErrorHi())
print 'Sampling the covariance matrix to propagate error on width'
self.h_width = ROOT.TH1F('h_width', 'width', 1000, 0.5, 1.5)
ntoys = 10000
for i in range(ntoys):
randomizedPars = self.fit_result.randomizePars()
for j in range(0, randomizedPars.getSize()):
self.poi[randomizedPars.at(j).GetName()].setVal(
randomizedPars.at(j).getVal())
self.h_width.Fill(self.width.getVal())
for cstr in self.constraint.values():
cstr.fill_pull()
self.graph_couplings.SetMarkerStyle(20)
self.graph_couplings.SetLineWidth(3)
can_couplings = self.canvas('couplings')
self.graph_couplings.Draw("AP")
self.graph_couplings.GetYaxis().SetTitle("68% CL on d(A) ")
self.graph_couplings.GetXaxis().SetNdivisions(0)
l = self.keep(ROOT.TLine())
l.SetLineColor(ROOT.kRed)
l.SetLineWidth(3)
l.DrawLine(0.0, 0.0, len(self.poi) + 1.5, 0)
self.graph_couplings.SetPoint(len(self.poi), len(self.poi) + 0.5, 0.0)
self.graph_couplings.SetPointError(
len(self.poi), 0.0, 0.0,
self.h_width.GetRMS() / self.h_width.GetMean(),
self.h_width.GetRMS() / self.h_width.GetMean())
for i, poiname in enumerate(order_BR + ['#Gamma_{T}']):
label = self.poilabels.get(poiname, poiname)
tex = self.keep(
ROOT.TLatex(i + 0.5,
0.95 * self.graph_couplings.GetYaxis().GetXmin(),
label))
tex.Draw()
print """
###############################################################
###############################################################
###############################################################
RESULTS
###############################################################
###############################################################
###############################################################
"""
print 'RESULTS FOR THE CONFIDENCE INTERVALS------>'
for name in order_BR:
poi = self.poi[name]
poiLabel = self.poilabels.get(name, name)
mind = poi.getAsymErrorLo() * 100
maxd = poi.getAsymErrorHi() * 100
avd = abs(maxd - mind) / 2.
# print poiLabel+': ('+str(poi.getAsymErrorLo())+','+str(poi.getAsymErrorHi())+'), ' + str(avd)
print '{label:10}:\t{mind:5.3f}%\t{maxd:5.3f}%\t{avd:5.3f}%'.format(
label=poiLabel, mind=mind, maxd=maxd, avd=avd)
can_gamma = self.canvas('gamma')
self.h_width.GetXaxis().SetTitle("#Gamma_{T}")
self.h_width.GetYaxis().SetTitle("N toys")
self.h_width.Draw()
print 'Relative error on the total width ', self.h_width.GetRMS(
) / self.h_width.GetMean()
print 'Please check the histogram to see that the dist is Gaussian. If not the fit is biased'
print 'The fit can be biased when floating the width sometimes.'
can_pulls = self.canvas('pulls', 1000, 1000)
npulls = len(self.constraint)
nxy = int(math.ceil(math.sqrt(npulls)))
can_pulls.Divide(nxy, nxy)
for i, c in enumerate(self.constraint.values()):
can_pulls.cd(i + 1)
c.pulls.Draw()
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)
background_norm.Print()
# S+B model
model = RooAddPdf("model", "s+b", RooArgList(background, signal),
RooArgList(background_norm, signal_norm))
rooDataHist = RooDataHist('rooDatahist', 'rooDathist', RooArgList(mjj),
hData)
rooDataHist.Print()
def fit():
#fit to log_10(pT^2) with components and plot of plain pT^2
#range in log_10(pT^2)
ptbin = 0.12
ptmin = -5.
ptmax = 0.99 # 1.01
#range in pT^2
ptsq_bin = 0.03
ptsq_min = 1e-5
ptsq_max = 1
mmin = 2.8
mmax = 3.2
#range for incoherent fit
fitran = [-0.9, 0.1]
#number of gamma-gamma events
ngg = 131
#number of psi' events
npsiP = 20
#input data
pT = RooRealVar("jRecPt", "pT", 0, 10)
m = RooRealVar("jRecM", "mass", 0, 10)
data_all = RooDataSet("data", "data", tree, RooArgSet(pT, m))
#select for mass range
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
data = data_all.reduce(strsel)
#create log(pT^2) from pT
ptsq_draw = "jRecPt*jRecPt" # will be used for pT^2
logPtSq_draw = "TMath::Log10(" + ptsq_draw + ")"
logPtSq_form = RooFormulaVar("logPtSq", "logPtSq", logPtSq_draw,
RooArgList(pT))
logPtSq = data.addColumn(logPtSq_form)
logPtSq.setRange("fitran", fitran[0], fitran[1])
#bins and range for the plot
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
logPtSq.setMin(ptmin)
logPtSq.setMax(ptmax)
logPtSq.setRange("plotran", ptmin, ptmax)
#range for pT^2
ptsq_nbins, ptsq_max = ut.get_nbins(ptsq_bin, ptsq_min, ptsq_max)
#incoherent parametrization
bval = RooRealVar("bval", "bval", 3.3, 0, 10)
inc_form = "log(10.)*pow(10.,logPtSq)*exp(-bval*pow(10.,logPtSq))"
incpdf = RooGenericPdf("incpdf", inc_form, RooArgList(logPtSq, bval))
#make the incoherent fit
res = incpdf.fitTo(data, rf.Range("fitran"), rf.Save())
#get incoherent norm to the number of events
lset = RooArgSet(logPtSq)
iinc = incpdf.createIntegral(lset, rf.NormSet(lset), rf.Range("fitran"))
inc_nevt = data.sumEntries("logPtSq", "fitran")
incpdf.setNormRange("fitran")
aval = RooRealVar("aval", "aval", inc_nevt / incpdf.getNorm(lset))
#print "A =", aval.getVal()
#print "b =", bval.getVal()
#incoherent distribution from log_10(pT^2) function for the sum with gamma-gamma
hIncPdf = ut.prepare_TH1D_n("hGG", nbins, ptmin, ptmax)
func_incoh_logPt2 = TF1("func_incoh_logPt2",
"[0]*log(10.)*pow(10.,x)*exp(-[1]*pow(10.,x))",
-10., 10.)
func_incoh_logPt2.SetNpx(1000)
func_incoh_logPt2.SetLineColor(rt.kMagenta)
func_incoh_logPt2.SetParameters(
aval.getVal(),
bval.getVal()) # 4.9 from incoherent mc, 3.3 from data fit
ut.fill_h1_tf(hIncPdf, func_incoh_logPt2, rt.kMagenta)
#gamma-gamma contribution
hGG = ut.prepare_TH1D_n("hGG", nbins, ptmin, ptmax)
tree_gg.Draw(logPtSq_draw + " >> hGG", strsel)
ut.norm_to_num(hGG, ngg, rt.kGreen + 1)
#sum of incoherent distribution and gamma-gamma
hSumIncGG = ut.prepare_TH1D_n("hSumIncGG", nbins, ptmin, ptmax)
hSumIncGG.Add(hIncPdf)
hSumIncGG.Add(hGG)
ut.line_h1(hSumIncGG, rt.kMagenta)
#gamma-gamma in pT^2
hGG_ptsq = ut.prepare_TH1D_n("hGG_ptsq", ptsq_nbins, ptsq_min, ptsq_max)
tree_gg.Draw(ptsq_draw + " >> hGG_ptsq", strsel)
ut.norm_to_num(hGG_ptsq, ngg, rt.kGreen + 1)
#psi' contribution
psiP_file = TFile.Open(basedir_mc + "/ana_slight14e4x1_s6_sel5z.root")
psiP_tree = psiP_file.Get("jRecTree")
hPsiP = ut.prepare_TH1D_n("hPsiP", nbins, ptmin, ptmax)
psiP_tree.Draw(logPtSq_draw + " >> hPsiP", strsel)
ut.norm_to_num(hPsiP, npsiP, rt.kViolet)
#psi' in pT^2
hPsiP_ptsq = ut.prepare_TH1D_n("hPsiP_ptsq", ptsq_nbins, ptsq_min,
ptsq_max)
psiP_tree.Draw(ptsq_draw + " >> hPsiP_ptsq", strsel)
ut.norm_to_num(hPsiP_ptsq, npsiP, rt.kViolet)
#create canvas frame
gStyle.SetPadTickY(1)
can = ut.box_canvas(1086, 543) # square area is still 768^2
can.SetMargin(0, 0, 0, 0)
can.Divide(2, 1, 0, 0)
gStyle.SetLineWidth(1)
can.cd(1)
ut.set_margin_lbtr(gPad, 0.11, 0.1, 0.01, 0)
frame = logPtSq.frame(rf.Bins(nbins))
frame.SetTitle("")
frame.SetMaximum(80)
frame.SetYTitle("Events / ({0:.3f}".format(ptbin) + " GeV^{2})")
frame.SetXTitle("log_{10}( #it{p}_{T}^{2} ) (GeV^{2})")
frame.GetXaxis().SetTitleOffset(1.2)
frame.GetYaxis().SetTitleOffset(1.6)
#plot the data
data.plotOn(frame, rf.Name("data"), rf.LineWidth(2))
#incoherent parametrization
incpdf.plotOn(frame, rf.Range("fitran"), rf.LineColor(rt.kRed),
rf.Name("incpdf"), rf.LineWidth(2))
incpdf.plotOn(frame, rf.Range("plotran"), rf.LineColor(rt.kRed),
rf.Name("incpdf_full"), rf.LineStyle(rt.kDashed),
rf.LineWidth(2))
frame.Draw()
#add gamma-gamma contribution
hGG.Draw("same")
#sum of incoherent distribution and gamma-gamma
#hSumIncGG.Draw("same")
#add psi'
#hPsiP.Draw("same")
#legend for log_10(pT^2)
leg = ut.prepare_leg(0.15, 0.77, 0.28, 0.19, 0.035)
hxl = ut.prepare_TH1D("hxl", 1, 0, 1)
hxl.Draw("same")
ilin = ut.col_lin(rt.kRed, 2)
ilin2 = ut.col_lin(rt.kRed, 2)
ilin2.SetLineStyle(rt.kDashed)
leg.AddEntry(ilin, "Incoherent parametrization, fit region", "l")
leg.AddEntry(ilin2, "Incoherent parametrization, extrapolation region",
"l")
leg.AddEntry(hGG, "#gamma#gamma#rightarrow e^{+}e^{-}", "l")
#leg.AddEntry(hxl, "Data", "lp")
leg.AddEntry(hxl, "Data, log_{10}( #it{p}_{T}^{2} )", "lp")
leg.Draw("same")
#----- plot pT^2 on the right -----
#pT^2 variable from pT
ptsq_form = RooFormulaVar("ptsq", "ptsq", ptsq_draw, RooArgList(pT))
ptsq = data.addColumn(ptsq_form)
#range for pT^2 plot
ptsq.setMin(ptsq_min)
ptsq.setMax(ptsq_max)
#make the pT^2 plot
can.cd(2)
gPad.SetLogy()
#gPad.SetLineWidth(3)
#gPad.SetFrameLineWidth(1)
ut.set_margin_lbtr(gPad, 0, 0.1, 0.01, 0.15)
ptsq_frame = ptsq.frame(rf.Bins(ptsq_nbins), rf.Title(""))
#print type(ptsq_frame), type(ptsq)
ptsq_frame.SetTitle("")
ptsq_frame.SetXTitle("#it{p}_{T}^{2} (GeV^{2})")
ptsq_frame.GetXaxis().SetTitleOffset(1.2)
data.plotOn(ptsq_frame, rf.Name("data"), rf.LineWidth(2))
ptsq_frame.SetMaximum(9e2)
ptsq_frame.SetMinimum(0.8) # 0.101
ptsq_frame.Draw()
#incoherent parametrization in pT^2 over the fit region, scaled to the plot
inc_ptsq = TF1("inc_ptsq", "[0]*exp(-[1]*x)", 10**fitran[0], 10**fitran[1])
inc_ptsq.SetParameters(aval.getVal() * ptsq_bin, bval.getVal())
#incoherent parametrization in the extrapolation region, below and above the fit region
inc_ptsq_ext1 = TF1("inc_ptsq_ext1", "[0]*exp(-[1]*x)", 0., 10**fitran[0])
inc_ptsq_ext2 = TF1("inc_ptsq_ext2", "[0]*exp(-[1]*x)", 10**fitran[1], 10)
inc_ptsq_ext1.SetParameters(aval.getVal() * ptsq_bin, bval.getVal())
inc_ptsq_ext1.SetLineStyle(rt.kDashed)
inc_ptsq_ext2.SetParameters(aval.getVal() * ptsq_bin, bval.getVal())
inc_ptsq_ext2.SetLineStyle(rt.kDashed)
inc_ptsq.Draw("same")
inc_ptsq_ext1.Draw("same")
inc_ptsq_ext2.Draw("same")
#add gamma-gamma in pT^2
hGG_ptsq.Draw("same")
#add psi' in pT^2
#hPsiP_ptsq.Draw("same")
#redraw the frame
#ptsq_frame.Draw("same")
ptsq_frame.GetXaxis().SetLimits(-9e-3, ptsq_frame.GetXaxis().GetXmax())
#vertical axis for pT^2 plot
xpos = ptsq_frame.GetXaxis().GetXmax()
ypos = ptsq_frame.GetMaximum()
ymin = ptsq_frame.GetMinimum()
ptsq_axis = TGaxis(xpos, 0, xpos, ypos, ymin, ypos, 510, "+GL")
ut.set_axis(ptsq_axis)
ptsq_axis.SetMoreLogLabels()
ptsq_axis.SetTitle("Events / ({0:.3f}".format(ptsq_bin) + " GeV^{2})")
ptsq_axis.SetTitleOffset(2.2)
ptsq_axis.Draw()
#legend for input data
#dleg = ut.prepare_leg(0.4, 0.77, 0.14, 0.18, 0.035)
dleg = ut.prepare_leg(0.4, 0.71, 0.16, 0.24, 0.035)
dleg.AddEntry(None, "#bf{|#kern[0.3]{#it{y}}| < 1}", "")
ut.add_leg_mass(dleg, mmin, mmax)
dleg.AddEntry(None, "AuAu@200 GeV", "")
dleg.AddEntry(None, "UPC sample", "")
dleg.AddEntry(hxl, "Data, #it{p}_{T}^{2}", "lp")
dleg.Draw("same")
#ut.invert_col_can(can)
can.SaveAs("01fig.pdf")
def pdf_logPt2_prelim():
#PDF fit to log_10(pT^2) for preliminary figure
#tree_in = tree_incoh
tree_in = tree
#ptbin = 0.04
ptbin = 0.12
ptmin = -5.
ptmax = 1.
mmin = 2.8
mmax = 3.2
#fitran = [-5., 1.]
fitran = [-0.9, 0.1]
binned = False
#gamma-gamma 131 evt for pT<0.18
#input data
pT = RooRealVar("jRecPt", "pT", 0, 10)
m = RooRealVar("jRecM", "mass", 0, 10)
dataIN = RooDataSet("data", "data", tree_in, RooArgSet(pT, m))
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
data = dataIN.reduce(strsel)
#x is RooRealVar for log(Pt2)
draw = "TMath::Log10(jRecPt*jRecPt)"
draw_func = RooFormulaVar(
"x", "Dielectron log_{10}( #it{p}_{T}^{2} ) ((GeV/c)^{2})", draw,
RooArgList(pT))
x = data.addColumn(draw_func)
x.setRange("fitran", fitran[0], fitran[1])
#binned data
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
hPt = TH1D("hPt", "hPt", nbins, ptmin, ptmax)
hPtCoh = ut.prepare_TH1D("hPtCoh", ptbin, ptmin, ptmax)
hPtCoh.SetLineWidth(2)
#fill in binned data
tree_in.Draw(draw + " >> hPt", strsel)
tree_coh.Draw(draw + " >> hPtCoh", strsel)
dataH = RooDataHist("dataH", "dataH", RooArgList(x), hPt)
#range for plot
x.setMin(ptmin)
x.setMax(ptmax)
x.setRange("plotran", ptmin, ptmax)
#create the pdf
b = RooRealVar("b", "b", 5., 0., 10.)
pdf_func = "log(10.)*pow(10.,x)*exp(-b*pow(10.,x))"
pdf_logPt2 = RooGenericPdf("pdf_logPt2", pdf_func, RooArgList(x, b))
#make the fit
if binned == True:
r1 = pdf_logPt2.fitTo(dataH, rf.Range("fitran"), rf.Save())
else:
r1 = pdf_logPt2.fitTo(data, rf.Range("fitran"), rf.Save())
#calculate norm to number of events
xset = RooArgSet(x)
ipdf = pdf_logPt2.createIntegral(xset, rf.NormSet(xset),
rf.Range("fitran"))
print "PDF integral:", ipdf.getVal()
if binned == True:
nevt = tree_incoh.Draw(
"", strsel + " && " + draw + ">{0:.3f}".format(fitran[0]) +
" && " + draw + "<{1:.3f}".format(fitran[0], fitran[1]))
else:
nevt = data.sumEntries("x", "fitran")
print "nevt:", nevt
pdf_logPt2.setNormRange("fitran")
print "PDF norm:", pdf_logPt2.getNorm(RooArgSet(x))
#a = nevt/ipdf.getVal()
a = nevt / pdf_logPt2.getNorm(RooArgSet(x))
print "a =", a
#gamma-gamma contribution
hPtGG = ut.prepare_TH1D("hPtGG", ptbin, ptmin, ptmax)
tree_gg.Draw(draw + " >> hPtGG", strsel)
#ut.norm_to_data(hPtGG, hPt, rt.kGreen, -5., -2.9)
ut.norm_to_num(hPtGG, 131., rt.kGreen + 1)
print "Int GG:", hPtGG.Integral()
#sum of all contributions
hSum = ut.prepare_TH1D("hSum", ptbin, ptmin, ptmax)
hSum.SetLineWidth(3)
#add ggel to the sum
hSum.Add(hPtGG)
#add incoherent contribution
func_logPt2 = TF1("pdf_logPt2",
"[0]*log(10.)*pow(10.,x)*exp(-[1]*pow(10.,x))", -10.,
10.)
func_logPt2.SetParameters(a, b.getVal())
hInc = ut.prepare_TH1D("hInc", ptbin, ptmin, ptmax)
ut.fill_h1_tf(hInc, func_logPt2)
hSum.Add(hInc)
#add coherent contribution
ut.norm_to_data(hPtCoh, hPt, rt.kBlue, -5., -2.2) # norm for coh
hSum.Add(hPtCoh)
#set to draw as a lines
ut.line_h1(hSum, rt.kBlack)
#create canvas frame
can = ut.box_canvas()
ut.set_margin_lbtr(gPad, 0.11, 0.1, 0.01, 0.01)
frame = x.frame(rf.Bins(nbins), rf.Title(""))
frame.SetTitle("")
frame.SetYTitle("J/#psi candidates / ({0:.3f}".format(ptbin) +
" (GeV/c)^{2})")
frame.GetXaxis().SetTitleOffset(1.2)
frame.GetYaxis().SetTitleOffset(1.6)
print "Int data:", hPt.Integral()
#plot the data
if binned == True:
dataH.plotOn(frame, rf.Name("data"))
else:
data.plotOn(frame, rf.Name("data"))
pdf_logPt2.plotOn(frame, rf.Range("fitran"), rf.LineColor(rt.kRed),
rf.Name("pdf_logPt2"))
pdf_logPt2.plotOn(frame, rf.Range("plotran"), rf.LineColor(rt.kRed),
rf.Name("pdf_logPt2_full"), rf.LineStyle(rt.kDashed))
frame.Draw()
leg = ut.prepare_leg(0.61, 0.77, 0.16, 0.19, 0.03)
#ut.add_leg_mass(leg, mmin, mmax)
hx = ut.prepare_TH1D("hx", 1, 0, 1)
hx.Draw("same")
ln = ut.col_lin(rt.kRed, 2)
leg.AddEntry(hx, "Data", "p")
leg.AddEntry(hSum, "Sum", "l")
leg.AddEntry(hPtCoh, "Coherent J/#psi", "l")
leg.AddEntry(ln, "Incoherent parametrization", "l")
leg.AddEntry(hPtGG, "#gamma#gamma#rightarrow e^{+}e^{-}", "l")
#leg.AddEntry(ln, "ln(10)*#it{A}*10^{log_{10}#it{p}_{T}^{2}}exp(-#it{b}10^{log_{10}#it{p}_{T}^{2}})", "l")
leg.Draw("same")
l0 = ut.cut_line(fitran[0], 0.9, frame)
l1 = ut.cut_line(fitran[1], 0.9, frame)
#l0.Draw()
#l1.Draw()
pleg = ut.prepare_leg(0.12, 0.75, 0.14, 0.22, 0.03)
pleg.AddEntry(None, "#bf{|#kern[0.3]{#it{y}}| < 1}", "")
ut.add_leg_mass(pleg, mmin, mmax)
pleg.AddEntry(None, "STAR Preliminary", "")
pleg.AddEntry(None, "AuAu@200 GeV", "")
pleg.AddEntry(None, "UPC sample", "")
pleg.Draw("same")
desc = pdesc(frame, 0.14, 0.9, 0.057)
desc.set_text_size(0.03)
desc.itemD("#chi^{2}/ndf", frame.chiSquare("pdf_logPt2", "data", 2), -1,
rt.kRed)
desc.itemD("#it{A}", a, -1, rt.kRed)
desc.itemR("#it{b}", b, rt.kRed)
#desc.draw()
#put the sum
hSum.Draw("same")
frame.Draw("same")
#put gamma-gamma and coherent J/psi
hPtGG.Draw("same")
hPtCoh.Draw("same")
#ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
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))
if fitSig:
# define parameters for signal fit
m = RooRealVar('mean', 'mean', float(mass),
float(mass) - 200,
float(mass) + 200)
s = RooRealVar('sigma', 'sigma', 0.1 * float(mass), 0, 10000)
a = RooRealVar('alpha', 'alpha', 1, -10, 10)
n = RooRealVar('n', 'n', 1, 0, 100)
sig = RooCBShape('sig', 'sig', x, m, s, a, n)
p = RooRealVar('p', 'p', 1, 0, 5)
x0 = RooRealVar('x0', 'x0', 1000, 100, 5000)
bkg = RooGenericPdf('bkg', '1/(exp(pow(@0/@1,@2))+1)',
RooArgList(x, x0, p))
fsig = RooRealVar('fsig', 'fsig', 0.5, 0., 1.)
signal = RooAddPdf('signal', 'signal', sig, bkg, fsig)
# -----------------------------------------
# fit signal
canSname = 'can_Mjj' + str(mass)
canS = TCanvas(canSname, canSname, 900, 600)
gPad.SetLogy()
roohistSig = RooDataHist('roohist', 'roohist', RooArgList(x), hSig)
roohistSig.Print()
res_sig = signal.fitTo(roohistSig, RooFit.Save(ROOT.kTRUE))
res_sig.Print()
class fitFunc(object):
pass
fitParam = {}
mT = RooRealVar("m_T", "m_{T}", 1500., 3900., "GeV")
fitBDT0_2016 = fitFunc()
fitBDT0_2016.p1 = RooRealVar("CMS2016_BDT0_p1", "p1", -18.0947, -1000., 1000.)
fitBDT0_2016.p2 = RooRealVar("CMS2016_BDT0_p2", "p2", 22.8504, -10., 10.)
fitBDT0_2016.p3 = RooRealVar("CMS2016_BDT0_p3", "p3", 3.72973, -10., 10.)
fitBDT0_2016.p4 = RooRealVar("CMS2016_BDT0_p3", "p4", 0, -1000., 1000.)
fitBDT0_2016.modelBkg = RooGenericPdf(
"BkgOrg", "Bkg. fit (3 par.)",
"pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))",
RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2, fitBDT0_2016.p3))
fitBDT0_2016.modelBkg2 = RooGenericPdf(
"Bkg2", "Bkg. fit (2 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2)",
RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2))
fitBDT0_2016.modelBkg3 = RooGenericPdf(
"Bkg3", "Bkg. fit (3 par.)",
"pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))",
RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2, fitBDT0_2016.p3))
fitBDT0_2016.modelBkg4 = RooGenericPdf(
"Bkg", "Bkg. fit (4 par.)",
"pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000)+@4*pow(log(@0/13000),2))",
RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2, fitBDT0_2016.p3,
fitBDT0_2016.p4))
fitParam["BDT0_2016"] = fitBDT0_2016
aset[func].add(pars[func, ipar])
# DAS_EX_2.6
# Define RooGenericPdf for each "func" from function string in the fitFuncs dictionary
# and RooArgSet. Make sure PDF name, title are uniqe
# Get function string from fitFuncs dictionary
funcStr = fitFuncs[func, "str"]
# Make sure to use this name and title when defining the PDF
name = "bkgpdf_" + func
title = "bkgpdf_" + func
# Define pdf
# pdfs[func] =
pdfs[func] = RooGenericPdf(name, title, funcStr, RooArgList(aset[func]))
######################
# Do Fit
######################
roores = {}
for func in ["f2", "f1", "f3"]:
# DAS_EX_2.7
# Using the fitTo() method of the PDF, fit the data with each function
# Pass the option RooFit.Save(True) to the fitTo method, and save each result in the roores dictionary:
roores[func] = pdfs[func].fitTo(rdata, RooFit.Save(True))
#########################
# Make Plots
#########################
jpsik = RooRealVar("jpsik_m_ref","jpsik_m",0.0,1000.0)
theSet = RooArgSet(mass_ref_c_kkk,dimuonditrk_m_rf_c,dimuonditrk_charge,kkk,jpsik)
#RooArgSet(RooArgSet(mass_ref_c_kkk,dimuonditrk_m_rf_c,dimuonditrk_ctauPV,dimuonditrk_ctauErrPV,dimuon_pt),RooArgSet(ditrak_pt,mass_ref_c_kkk,dimuonditrk_charge,ditrak_m,dimuon_m))
DATA = RooDataSet("alldata","alldata",xTuple,theSet)
splotData = RooDataSet("alldata_sig","alldata_sig",DATA,theSet,"dimuonditrk_charge==0")
#splotBkgData = RooDataSet("alldata_bkg","alldata_bkg",DATA,theSet,"dimuonditrk_charge!=0 && dimuonditrk_m_rf_c<5.0 && dimuonditrk_m_rf_c>4.0")
print "Tree entries %d"%(splotData.numEntries())
print "PHSP fit"
BkgTotalMPdf = RooGenericPdf("BkgPdf","BkgPdf","sqrt( pow(dimuonditrk_m_rf_c,4) + pow(3.0967,4) + pow(1.01946,4) - 2*pow(dimuonditrk_m_rf_c,2)*pow(3.0967,2) - 2*pow(3.0967,2)*pow(1.01946,2) - 2*pow(dimuonditrk_m_rf_c,2)*pow(1.01946,2) ) * sqrt( pow(5.279,4) + pow(dimuonditrk_m_rf_c,4) + pow(0.493677,4) - 2*pow(5.279,2)*pow(dimuonditrk_m_rf_c,2) - 2*pow(5.279,2)*pow(0.493677,2) - 2*pow(dimuonditrk_m_rf_c,2)*pow(0.493677,2) ) / (dimuonditrk_m_rf_c)", RooArgList(dimuonditrk_m_rf_c));
dimuonditrk_m_rf_c.setBins(80)
dimuonditrk_m_rf_c.setRange("baserange",4.0,5.0)
s = BkgTotalMPdf.createIntegral(RooArgSet(dimuonditrk_m_rf_c),"baserange").getVal()
#bkgFit = BkgTotalMPdf.fitTo(splotBkgData,Range(4.0,5.0),RooFit.NumCPU(args.ncpu),RooFit.Verbose(False))
cb = TCanvas("canvas_b","canvas_b",1200,800)
print s
mumukkFrame = dimuonditrk_m_rf_c.frame(Title("Phase Space Fit"),Range(4.0,5.0),Normalization(1.0))
splotData.plotOn(mumukkFrame)
BkgTotalMPdf.plotOn(mumukkFrame,Normalization(1.65))
mumukkFrame.Draw()
