def makePlot(s):
if (type(s) == TH1D):
s.SetStats(0)
x = RooRealVar("x", "x", 0, 3)
l = RooArgList(x)
dh = RooDataHist("dh", "dh", l, s)
frame = x.frame()
dh.plotOn(frame)
#frame.SetTitle(name)
#frame.GetXaxis().SetTitle(s.GetXaxis().GetTitle())
frame.GetYaxis().SetTitle(s.GetYaxis().GetTitle())
# frame.GetYaxis().SetTopMargin(0.15)
#frame.Draw(draw)
return frame
elif (type(s) == TH2D):
s.SetStats(0)
x = RooRealVar("x", "x", 0, 3)
y = RooRealVar("y", "y", 0, 3)
l = RooArgList(x, y)
dh = RooDataHist("dh", "dh", l, s)
t = TGraph2D(s)
s.SetMarkerSize(1.0)
s.SetMarkerStyle(1)
#t.GetXaxis().SetTitle(s.GetXaxis().GetTitle())
return s
elif (type(s) == TGraph2D):
s.SetMarkerSize(1.0)
s.SetMarkerStyle(1)
return s
def DoRooFit(histo, title):
can = makeCMSCanvas(str(random.random()),"Fit result ",900,700)
#Varible
if "ele" in title:
x1 = RooRealVar("x1","m_{e^{+}e^{-}}",80,100)
if "mu" in title:
x1 = RooRealVar("x1","m_{#mu^{+}#mu^{-}}",80,100)
#Define CB function
m = RooRealVar("mean_{CB}","mean of gaussian",60,120)
s = RooRealVar("#sigma_{CB}","width of gaussian",0,3)
a = RooRealVar("#alpha_{CB}","mean of gaussian",0,100)
n = RooRealVar("n_{CB}","width of gaussian",0,5)
CB = RooCBShape("CB","CB PDF",x1, m, s, a, n)
m.setConstant(kFALSE)
s.setConstant(kFALSE)
a.setConstant(kFALSE)
n.setConstant(kFALSE)
#Define Gaussian function
mean1 = RooRealVar("mean_{G}","mean of gaussian",-60,60)
sigma1 = RooRealVar("#sigma_{G}","width of gaussian",0,10)
gauss1 = RooGaussian("gauss1","gaussian PDF",x1,mean1,sigma1)
mean1.setConstant(kFALSE)
sigma1.setConstant(kFALSE)
#Starting values of the parameters
mean1.setVal(1.0)
sigma1.setVal(1.0)
m.setVal(90.0)
s.setVal(1.0)
a.setVal(10.0)
n.setVal(2.0)
# Construct CB (x) gauss
x1.setBins(10000, "cache")
CBxG = RooFFTConvPdf("CBxG", "CB (X) gauss", x1, CB, gauss1)
can.cd()
d = RooDataHist("d","d",RooArgList(x1),RooFit.Import(histo))
CBxG.fitTo(d, RooLinkedList())
# Plot PDF and toy data overlaid
xframe2 = x1.frame(RooFit.Name("xframe"),RooFit.Title("")) # RooPlot
d.plotOn(xframe2, RooLinkedList() )
CBxG.paramOn(xframe2, RooFit.Layout(0.65,0.99,0.9))
xframe2.getAttText().SetTextSize(0.03)
CBxG.plotOn(xframe2)
xframe2.Draw()
can.SaveAs("DataVsMC/FitResults/"+title+"_Roofit.pdf")
can.SaveAs("DataVsMC/FitResults/"+title+"_Roofit.png")
return;
def saveLandauHistoAmplitude(histo,
outfile,
canvas,
XaxisTitle="",
YaxisTitle="",
plotTitle="",
stats=0):
ex = "Null Fit"
amplitude = RooRealVar("amplitude", "Cluster Amplitude", 0, 5000)
landau_data = RooDataHist("landau_data", "landau_data",
RooArgList(amplitude), histo)
ml = RooRealVar("ml", "mean landau", 1500., 1000, 2000)
sl = RooRealVar("sl", "sigma landau", 250, 100, 1000)
landau = RooLandau("lx", "lx", amplitude, ml, sl)
mg = RooRealVar("mg", "mg", 0)
sg = RooRealVar("sg", "sg", 100, 20, 500)
gauss = RooGaussian("gauss", "gauss", amplitude, mg, sg)
lxg = RooNumConvPdf("lxg", "lxg", amplitude, landau, gauss)
result = lxg.fitTo(landau_data)
frame = amplitude.frame()
landau_data.plotOn(frame)
lxg.plotOn(frame)
frame.Draw("")
frame.SetTitle(plotTitle)
frame.GetXaxis().SetTitle(XaxisTitle)
frame.GetYaxis().SetTitle(YaxisTitle)
frame.SetStats(stats)
frame.Write(plotTitle)
canvas.Print(outfile + ".pdf")
peak = []
try:
mean = RooRealVar(result.floatParsFinal().find("landau_mean"))
err = RooRealVar(mean.errorVar())
peak.append(mean.GetVal())
peak.append(err.GetVal())
except Exception as ex:
print(ex)
peak.append(0)
peak.append(0)
return peak
def saveLandauHistoSignalToNoise(histo,outfile,canvas,XaxisTitle="",YaxisTitle="",plotTitle="",stats=0):
ex = "Null Fit"
signal_to_noise = RooRealVar("signal_to_noise", "Signal to Noise", 0, 50)
landau_data = RooDataHist("landau_data", "landau_data", RooArgList(signal_to_noise), histo)
ml = RooRealVar("ml","mean landau",25, 20, 26)
sl = RooRealVar("sl","sigma landau", 5, 2, 10)
landau = RooLandau("lx","lx",signal_to_noise,ml,sl)
mg = RooRealVar("mg","mg",0) ;
sg = RooRealVar("sg","sg", 2, 1, 8)
gauss = RooGaussian("gauss","gauss",signal_to_noise,mg,sg)
lxg = RooNumConvPdf("lxg", "lxg", signal_to_noise, landau, gauss)
result = lxg.fitTo(landau_data)
frame = signal_to_noise.frame()
landau_data.plotOn(frame)
lxg.plotOn(frame)
frame.Draw("")
frame.SetTitle(plotTitle)
frame.GetXaxis().SetTitle(XaxisTitle)
frame.GetYaxis().SetTitle(YaxisTitle)
frame.SetStats(stats)
frame.Write(plotTitle)
canvas.Print(outfile+".pdf")
peak = []
try:
mean = RooRealVar(result.floatParsFinal().find("landau_mean"))
err = RooRealVar(mean.errorVar())
peak.append(mean.GetVal())
peak.append(err.GetVal())
except Exception as ex:
print(ex)
peak.append(0)
peak.append(0)
return peak
def main(options, args):
from ROOT import gSystem, gROOT, gStyle
gROOT.SetBatch()
gSystem.Load("libRooFitCore")
if options.doWebPage:
from lip.Tools.rootutils import loadToolsLib, apply_modifs
loadToolsLib()
from ROOT import TFile, RooFit, RooArgSet, RooDataHist, RooKeysPdf, RooHistPdf, TCanvas, TLegend, TLatex, TArrow, TPaveText, RooAddPdf, RooArgList
from ROOT import kWhite, kBlue, kOpenSquare
if options.doWebPage:
from ROOT import HtmlHelper, HtmlTag, HtmlTable, HtmlPlot
rootglobestyle.setTDRStyle()
gStyle.SetMarkerSize(1.5)
gStyle.SetTitleYOffset(1.5)
gStyle.SetPadLeftMargin(0.16)
gStyle.SetPadRightMargin(0.05)
gStyle.SetPadTopMargin(0.05)
gStyle.SetPadBottomMargin(0.13)
gStyle.SetLabelFont(42, "XYZ")
gStyle.SetLabelOffset(0.007, "XYZ")
gStyle.SetLabelSize(0.05, "XYZ")
gStyle.SetTitleSize(0.06, "XYZ")
gStyle.SetTitleXOffset(0.9)
gStyle.SetTitleYOffset(1.24)
gStyle.SetTitleFont(42, "XYZ")
##
## Read files
##
options.outdir = "%s_m%1.0f" % (options.outdir, options.mH)
if options.fp:
options.outdir += "_fp"
ncat = options.ncat
cats = options.cats
if cats is "":
categories = ["_cat%d" % i for i in range(0, ncat)]
else:
categories = ["_cat%s" % i for i in cats.split(",")]
if options.mva:
clables = {
"_cat0": ("MVA > 0.89", ""),
"_cat1": ("0.74 #leq MVA", "MVA < 0.89"),
"_cat2": ("0.545 #leq MVA", "MVA < 0.74"),
"_cat3": ("0.05 #leq MVA", "MVA < 0.545"),
"_cat4": ("Di-jet", "Tagged"),
"_cat5": ("Di-jet", "Tagged"),
"_combcat": ("All Classes", "Combined")
}
else:
clables = {
"_cat0": ("max(|#eta|<1.5", "min(R_{9})>0.94"),
"_cat1": ("max(|#eta|<1.5", "min(R_{9})<0.94"),
"_cat2": ("max(|#eta|>1.5", "min(R_{9})>0.94"),
"_cat3": ("max(|#eta|>1.5", "min(R_{9})<0.94"),
"_cat4": ("Di-jet", "Tagged"),
"_cat5": ("Di-jet", "Tagged"),
"_combcat": ("All Classes", "Combined")
}
helper = Helper()
fin = TFile.Open(options.infile)
helper.files.append(fin)
ws = fin.Get("cms_hgg_workspace")
mass = ws.var("CMS_hgg_mass")
mass.SetTitle("m_{#gamma#gamma}")
mass.setUnit("GeV")
mass.setRange(100., 150.)
mass.setBins(100, "plot")
mass.setBins(5000)
print ws
aset = RooArgSet(mass)
helper.objs.append(mass)
helper.objs.append(aset)
fitopt = (RooFit.Minimizer("Minuit2", ""), RooFit.Minos(False),
RooFit.SumW2Error(False), RooFit.NumCPU(8))
if not options.binned and not options.refit:
finpdf = TFile.Open(options.infilepdf)
helper.files.append(finpdf)
wspdf = finpdf.Get("wsig")
else:
wspdf = ws
for c in categories:
processes = ["ggh", "vbf", "wzh"]
if options.fp:
processes = ["vbf", "wzh"]
### elif clables[c][0] == "Di-jet":
### processes = [ "vbf", "ggh" ]
dsname = "sig_mass_m%1.0f%s" % (options.mH, c)
print dsname
print ws
ds = ws.data("sig_%s_mass_m%1.0f%s" %
(processes[0], options.mH, c)).Clone(dsname)
for proc in processes[1:]:
ds.append(ws.data("sig_%s_mass_m%1.0f%s" % (proc, options.mH, c)))
helper.dsets.append(ds)
if options.binned:
binned_ds = RooDataHist("binned_%s" % dsname, "binned_%s" % dsname,
aset, ds)
pdf = RooKeysPdf("pdf_%s_%s" % (dsname, f), "pdf_%s" % dsname,
mass, ds)
plot_pdf = RooHistPdf("pdf_%s" % dsname, "pdf_%s" % dsname, aset,
plot_ds)
helper.add(binned_ds, binned_ds.GetName())
else:
if options.refit:
if options.refitall and clables[c][0] != "Di-jet":
rpdfs = []
for proc in processes:
for ngaus in range(1, 4):
pp = build_pdf(ws, "%s_%s" % (c, proc), ngaus,
ngaus == 3)
pp.fitTo(
ws.data("sig_%s_mass_m%1.0f%s" %
(proc, options.mH, c)),
RooFit.Strategy(0), *fitopt)
rpdfs.append(pp)
pdf = RooAddPdf("hggpdfrel%s" % c, "hggpdfrel%s" % c,
RooArgList(*tuple(rpdfs)))
else:
if options.refitall and clables[c][0] == "Di-jet":
for ngaus in range(1, 5):
pdf = build_pdf(ws, c, ngaus, ngaus == 5)
pdf.fitTo(ds, RooFit.Strategy(0), *fitopt)
else:
for ngaus in range(1, 4):
pdf = build_pdf(ws, c, ngaus, ngaus == 3)
pdf.fitTo(ds, RooFit.Strategy(0), *fitopt)
else:
pdfs = (wspdf.pdf("hggpdfrel%s_%s" % (c, p))
for p in processes)
pdf = RooAddPdf("hggpdfrel%s" % c, "hggpdfrel%s" % c,
RooArgList(*pdfs))
helper.add(pdf, pdf.GetName())
plot_pdf = pdf.Clone("pdf_%s" % dsname)
plot_ds = RooDataHist("plot_%s" % dsname, "plot_%s" % dsname, aset,
"plot")
plot_ds.add(ds)
cdf = pdf.createCdf(aset)
hmin, hmax, hm = get_FWHM(mass, pdf, cdf, options.mH - 10.,
options.mH + 10.)
wmin, wmax = get_eff_sigma(mass, pdf, cdf, options.mH - 10.,
options.mH + 10.)
### hmin, hmax, hm = get_FWHM( points )
helper.add(plot_ds, plot_ds.GetName())
helper.add(plot_pdf, plot_pdf.GetName())
helper.add((wmin, wmax), "eff_sigma%s" % c)
helper.add((hmin, hmax, hm), "FWHM%s" % c)
helper.add(ds.sumEntries(),
"sumEntries%s" % c) # signal model integral
# data integral for PAS tables
data = ws.data("data_mass%s" % c)
helper.add(
data.sumEntries("CMS_hgg_mass>=%1.4f && CMS_hgg_mass<=%1.4f" %
(options.mH - 10., options.mH + 10.)),
"data_sumEntries%s" % c)
del cdf
del pdf
dsname = "sig_mass_m%1.0f_combcat" % options.mH
print dsname
combined_ds = helper.dsets[0].Clone(dsname)
for d in helper.dsets[1:]:
combined_ds.append(d)
if options.binned:
binned_ds = RooDataHist("binned_%s" % dsname, "binned_%s" % dsname,
aset, combined_ds)
pdf = RooKeysPdf("pdf_%s" % (dsname), "pdf_%s" % dsname, mass,
combined_ds)
plot_pdf = RooHistPdf("pdf_%s" % dsname, "pdf_%s" % dsname, aset,
plot_ds)
helper.add(binned_ds, binned_ds.GetName())
else:
#### pdf = build_pdf(ws,"_combcat")
#### pdf.fitTo(combined_ds, RooFit.Strategy(0), *fitopt )
#### plot_pdf = pdf.Clone( "pdf_%s" % dsname )
pdf = RooAddPdf(
"pdf_%s" % dsname, "pdf_%s" % dsname,
RooArgList(*(helper.histos["hggpdfrel%s" % c]
for c in categories)))
plot_pdf = pdf
cdf = pdf.createCdf(aset)
plot_ds = RooDataHist("plot_%s" % dsname, "plot_%s" % dsname, aset, "plot")
plot_ds.add(combined_ds)
wmin, wmax = get_eff_sigma(mass, pdf, cdf, options.mH - 10.,
options.mH + 10.)
hmin, hmax, hm = get_FWHM(mass, pdf, cdf, options.mH - 10.,
options.mH + 10.)
helper.add(plot_ds, plot_ds.GetName())
helper.add(plot_pdf, plot_pdf.GetName())
helper.add((wmin, wmax), "eff_sigma_combcat")
helper.add((hmin, hmax, hm), "FWHM_combcat")
helper.add(plot_ds.sumEntries(), "sumEntries_combcat")
mass.setRange("higgsrange", options.mH - 25., options.mH + 15.)
del cdf
del pdf
del helper.dsets
### label = TLatex(0.1812081,0.8618881,"#scale[0.8]{#splitline{CMS preliminary}{Simulation}}")
label = TLatex(0.7, 0.86,
"#scale[0.65]{#splitline{CMS preliminary}{Simulation}}")
label.SetNDC(1)
##
## Make web page with plots
##
if options.doWebPage:
hth = HtmlHelper(options.outdir)
hth.navbar().cell(HtmlTag("a")).firstChild().txt("..").set(
"href", "../?C=M;O=D")
hth.navbar().cell(HtmlTag("a")).firstChild().txt("home").set(
"href", "./")
tab = hth.body().add(HtmlTable())
ip = 0
for c in ["_combcat"] + categories:
### for c in categories:
if options.doWebPage and ip % 4 == 0:
row = tab.row()
ip = ip + 1
dsname = "sig_mass_m%1.0f%s" % (options.mH, c)
canv = TCanvas(dsname, dsname, 600, 600)
helper.objs.append(canv)
### leg = TLegend(0.4345638,0.6835664,0.9362416,0.9178322)
leg = TLegend(0.2, 0.96, 0.5, 0.55)
#apply_modifs( leg, [("SetLineColor",kWhite),("SetFillColor",kWhite),("SetFillStyle",0),("SetLineStyle",0)] )
hplotcompint = mass.frame(RooFit.Bins(250), RooFit.Range("higgsrange"))
helper.objs.append(hplotcompint)
helper.objs.append(leg)
plot_ds = helper.histos["plot_%s" % dsname]
plot_pdf = helper.histos["pdf_%s" % dsname]
wmin, wmax = helper.histos["eff_sigma%s" % c]
hmin, hmax, hm = helper.histos["FWHM%s" % c]
print hmin, hmax, hm
style = (RooFit.LineColor(kBlue), RooFit.LineWidth(2),
RooFit.FillStyle(0))
style_seff = (
RooFit.LineWidth(2),
RooFit.FillStyle(1001),
RooFit.VLines(),
RooFit.LineColor(15),
)
style_ds = (RooFit.MarkerStyle(kOpenSquare), )
plot_ds.plotOn(hplotcompint, RooFit.Invisible())
plot_pdf.plotOn(hplotcompint, RooFit.NormRange("higgsrange"),
RooFit.Range(wmin, wmax), RooFit.FillColor(19),
RooFit.DrawOption("F"), *style_seff)
seffleg = hplotcompint.getObject(int(hplotcompint.numItems() - 1))
plot_pdf.plotOn(hplotcompint, RooFit.NormRange("higgsrange"),
RooFit.Range(wmin, wmax), RooFit.LineColor(15),
*style_seff)
plot_pdf.plotOn(hplotcompint, RooFit.NormRange("higgsrange"),
RooFit.Range("higgsrange"), *style)
pdfleg = hplotcompint.getObject(int(hplotcompint.numItems() - 1))
plot_ds.plotOn(hplotcompint, *style_ds)
pointsleg = hplotcompint.getObject(int(hplotcompint.numItems() - 1))
iob = int(hplotcompint.numItems() - 1)
leg.AddEntry(pointsleg, "Simulation", "pe")
leg.AddEntry(pdfleg, "Parametric model", "l")
leg.AddEntry(seffleg,
"#sigma_{eff} = %1.2f GeV " % (0.5 * (wmax - wmin)), "fl")
clabel = TLatex(0.74, 0.65,
"#scale[0.65]{#splitline{%s}{%s}}" % clables[c])
clabel.SetNDC(1)
helper.objs.append(clabel)
hm = hplotcompint.GetMaximum() * 0.5 * 0.9
### hm = pdfleg.GetMaximum()*0.5
fwhmarrow = TArrow(hmin, hm, hmax, hm)
fwhmarrow.SetArrowSize(0.03)
helper.objs.append(fwhmarrow)
fwhmlabel = TPaveText(0.20, 0.58, 0.56, 0.48, "brNDC")
fwhmlabel.SetFillStyle(0)
fwhmlabel.SetLineColor(kWhite)
reducedFWHM = (hmax - hmin) / 2.3548200
fwhmlabel.AddText("FWHM/2.35 = %1.2f GeV" % reducedFWHM)
helper.objs.append(fwhmlabel)
hplotcompint.SetTitle("")
hplotcompint.GetXaxis().SetNoExponent(True)
hplotcompint.GetXaxis().SetTitle("m_{#gamma#gamma} (GeV)")
hplotcompint.GetXaxis().SetNdivisions(509)
## hplotcompint.GetYaxis().SetTitle("A.U.");
## hplotcompint.GetYaxis().SetRangeUser(0.,hplotcompint.GetMaximum()*1.4);
hplotcompint.Draw()
leg.Draw("same")
label.Draw("same")
clabel.Draw("same")
fwhmarrow.Draw("<>")
fwhmlabel.Draw("same")
plot_ds.sumEntries()
if options.doWebPage:
hpl = HtmlPlot(canv, False, "", True, True, True)
hpl.caption("<i>%s</i>" % canv.GetTitle())
row.cell(hpl)
else:
if os.path.isdir(options.outdir) is False:
os.mkdir(options.outdir)
for ext in "C", "png", "pdf":
canv.SaveAs(
os.path.join(options.outdir,
"%s.%s" % (canv.GetName(), ext)))
if "comb" in c:
ip = 0
if options.doWebPage:
print "Creating pages..."
hth.dump()
for f in helper.files:
f.Close()
gROOT.Reset()
from pprint import pprint
pprint(helper)
print 'Summary statistics per event class'
print 'Cat\tSignal\t\tData/GeV (in %3.1f+/-10)\tsigEff\tFWHM/2.35' % options.mH
sigTotal = 0.
dataTotal = 0.
for c in categories:
sigVal = helper.histos["sumEntries%s" % c]
datVal = helper.histos["data_sumEntries%s" % c]
sigTotal += sigVal
dataTotal += datVal
for c in categories:
sigVal = helper.histos["sumEntries%s" % c]
datVal = helper.histos["data_sumEntries%s" % c]
effSig = 0.5 * (helper.histos["eff_sigma%s" % c][1] -
helper.histos["eff_sigma%s" % c][0])
fwhm = (helper.histos["FWHM%s" % c][1] -
helper.histos["FWHM%s" % c][0]) / 2.3548200
print c, '\t%3.1f (%3.1f%%)\t%3.1f (%3.1f%%)\t\t\t%2.2f\t%2.2f' % (
sigVal, 100. * sigVal / sigTotal, datVal /
(10. + 10.), 100. * datVal / dataTotal, effSig, fwhm)
print "Done."
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) )
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)
frame = x.frame()
roohistSig.plotOn(frame)
signal.plotOn(frame)
signal.plotOn(frame,RooFit.Components('bkg'),RooFit.LineColor(ROOT.kRed),RooFit.LineWidth(2),RooFit.LineStyle(ROOT.kDashed))
frame.GetXaxis().SetRangeUser(900,4500)
frame.GetXaxis().SetTitle('m_{jj} (GeV)')
frame.Draw()
parsSig = signal.getParameters(roohistSig)
parsSig.setAttribAll('Constant', True)
if fitDat:
# -----------------------------------------
# define parameters for background
NBINS = 180
p1 = RooRealVar('p1','p1',7,1,10)
canvas.Print("track_parameters.pdf[")
#--- Fit the D0 plots ---#
#------------------------#
track_d0 = RooRealVar("track_d0", "D0 (mm)", -1.5, 1.5)
track_d0_mean = RooRealVar("track_d0_mean", "Track D0 Mean", 0, -1.5, 1.5)
track_d0_sigma = RooRealVar("track_d0_sigma", "Track D0 Sigma", .5, 0, 2)
track_d0_gaussian = RooGaussModel("track_d0_gaussian", "Track D0 Gaussian", track_d0, track_d0_mean, track_d0_sigma)
track_d0_data = RooDataHist("track_d0_data", "Track D0 Data", RooArgList(track_d0), h_track_d0)
track_d0_plot = track_d0.frame()
track_d0_plot.SetTitle("")
track_d0_data.plotOn(track_d0_plot, RooFit.MarkerColor(kAzure+2), RooFit.LineColor(kAzure+2))
track_d0_gaussian.fitTo(track_d0_data)
track_d0_gaussian.plotOn(track_d0_plot, RooFit.LineColor(kAzure+2))
gbl_track_d0 = RooRealVar("gbl_track_d0", "D0 (mm)", -1.5, 1.5)
gbl_track_d0_mean = RooRealVar("gbl_track_d0_mean", "Track D0 Mean", 0, -1.5, 1.5)
gbl_track_d0_sigma = RooRealVar("gbl_track_d0_sigma", "Track D0 Sigma", .5, 0, 2)
gbl_track_d0_gaussian = RooGaussModel("gbl_track_d0_gaussian", "Track D0 Gaussian", gbl_track_d0, gbl_track_d0_mean, gbl_track_d0_sigma)
gbl_track_d0_data = RooDataHist("track_d0_data", "Track D0 Data", RooArgList(gbl_track_d0), h_gbl_track_d0)
gbl_track_d0_plot = gbl_track_d0.frame()
gbl_track_d0_plot.SetTitle("")
gbl_track_d0_data.plotOn(gbl_track_d0_plot, RooFit.MarkerColor(kRed+1), RooFit.LineColor(kRed+1))
gbl_track_d0_gaussian.fitTo(gbl_track_d0_data)
chi2=RooChi2Var("chi2","chi2",sigmodel,signal,RooFit.DataError(RooAbsData.SumW2))
nbins=data.numEntries()
nfree=sigmodel.getParameters(data).selectByAttrib("Constant",False).getSize()
s0.setConstant(True)
s1.setConstant(True)
if cut>=1:
fullintegral=sumsighist.Integral()
else:
fullintegral=sighist.Integral()
print "SIGNAL FRACTION",nsigref.getValV()/(nsigref.getValV()+nbkg.getValV())
if nsigref.getValV()==0: continue
if fit=="data":
xframe=mass.frame(RooFit.Title("signal fraction in peak ="+str(int(nsigref.getValV()/(nsigref.getValV()+nbkg.getValV())*1000.)/1000.)+"+-"+str(int(nsigref.getError()/(nsigref.getValV()+nbkg.getValV())*1000.)/1000.)+", #chi^{2}/DOF = "+str(int((chi2.getVal()/(nbins-nfree))*10.)/10.)))
signal.plotOn(xframe,RooFit.DataError(RooAbsData.SumW2))
sigmodel.plotOn(xframe,RooFit.Normalization(1.0,RooAbsReal.RelativeExpected))
sigmodel.plotOn(xframe,RooFit.Components("sigbkg"+str(cut)),RooFit.LineStyle(kDashed),RooFit.Normalization(1.0,RooAbsReal.RelativeExpected))
sigmodel.plotOn(xframe,RooFit.Components("sig"),RooFit.LineStyle(kDotted),RooFit.Normalization(1.0,RooAbsReal.RelativeExpected))
canvas=TCanvas("c3","c3",0,0,600,600)
xframe.Draw()
canvas.SaveAs(prefix+"_"+plot[0]+str(cut)+"_sigfit.pdf")
a0=RooRealVar("a0"+str(cut),"a0",100.,0.,1000.)
a1=RooRealVar("a1"+str(cut),"a1",100.,0.,1000.)
a2=RooRealVar("a2"+str(cut),"a2",50.,0.,1000.)
a3=RooRealVar("a3"+str(cut),"a3",0.1,0.,1000.)
b0=RooRealVar("b0"+str(cut),"b0",120.,0.,100.)
b1=RooRealVar("b1"+str(cut),"b1",50.,0.,100.)
b2=RooRealVar("b2"+str(cut),"b2",50.,0.,100.)
c0=RooRealVar("c0"+str(cut),"c0",100.,-1000.,1000.)
RooArgList(turnon, time, offset))
else:
print 'Unknown acceptance type. Aborting'
assert(False)
# Dataset to fit to
datahist = RooDataHist('datahist', 'Dataset from a histogram',
RooArgList(time), RooFit.Import(timehist2, False))
# Debug
datahist.Print('v')
# Fit
PDF.fitTo(datahist, RooFit.SumW2Error(True), RooFit.NumCPU(1),
RooFit.Range(epsilon, 0.005),
RooFit.Optimize(False), RooFit.Verbose(True), RooFit.Strategy(2))
# Plot
tframe1 = time.frame(RooFit.Name('ptime'),
RooFit.Title('Lifetime acceptance fitted to %s' % accfn))
datahist.plotOn(tframe1, RooFit.MarkerStyle(kFullTriangleUp))
PDF.plotOn(tframe1, RooFit.LineColor(kGreen))
# canvas2 = TCanvas('canvas2', 'Acceptance', 800, 600)
tframe1.Draw()
canvas1.Print(fname)
canvas1.Print(fname + ']')
# timestamp = get_timestamp()
# canvas1.Print('plots/simple-distrib-%s.pdf' % timestamp)
# canvas2.Print('plots/simple-fit-%s-%s.pdf' % (accfn, timestamp))
def makePlots():
histoFile = TFile('histos_'+sample+'.root')
histos = {}
for key in histoFile.GetListOfKeys():
histos[key.GetName()] = histoFile.Get(key.GetName())
outFile_name = 'plots_'+sample+'.pdf'
c1 = TCanvas('c1', 'c1')
c1.Print(outFile_name+'[')
# Plot comparing m_Phi various method
drawMultiPlot(outFile_name,';m_{KK [MeV]};', 'm_phi',
**{'m_{KK}' : histos['m_KK'],
'm_{#Phi}' : histos['m_Phi'],
'm_{#Phi} DTF #tau' : histos['m_DTFTau_Phi'],
'm_{#Phi} DTF #Phi' : histos['m_DTF_Phi']})
# Plot comparing m_Tau various method
drawMultiPlot(outFile_name, ';m_{KK#mu [MeV]};', 'm_tau',
**{'m_{KK#mu}' : histos['m_KKMu'],
'm_{#Phi#mu}' : histos['m_PhiMu'],
'm_{#tau} DTF #Phi' : histos['m_DTF_Tau']})
# m_KPi and m_PiK
drawMultiPlot(outFile_name, ';m_{K#pi} [MeV];', 'm_KPi',
**{'m_{K#pi}' : histos['m_KPi'],
'm_{#piK}' : histos['m_PiK']})
# m_KKpi and m_PhiPi
drawMultiPlot(outFile_name, ';m_{KK#pi} [MeV];', 'm_KKPi',
**{'m_{KK#pi}' : histos['m_KKPi'],
'm_{#Phi#pi}' : histos['m_PhiPi']})
# m_KPiPi_SS and KPiPi_OS
drawMultiPlot(outFile_name, ';m_{K#pi#pi} [MeV];', 'm_KPiPi',
**{'m_{K^{+}#pi^{-}#pi^{-}}' : histos['m_KPiPi_SS'],
'm_{K^{-}#pi^{+}#pi^{-}}' : histos['m_KPiPi_OS']})
drawMultiPlot(outFile_name, 'not in D peak;m_{K#pi#pi} [MeV];', 'm_KPiPi_noD',
**{'m_{K^{+}#pi^{-}#pi^{-}}' : histos['m_KPiPi_SS_noD'],
'm_{K^{-}#pi^{+}#pi^{-}}' : histos['m_KPiPi_OS_noD']})
#Plot various histos
for key in ('m_PiPi', 'm_PiPi_noD', 'm_KPi_fromMu','m_KPi_fromMu_noD' , 'm_KKPi_D' ,'Tau_DTF_PROB', 'Tau_DTFTau_PROB'):
histos[key].Draw()
c1.Update()
c1.Print(outFile_name)
c1.Print('plots/'+sample+'/'+key+'.pdf')
from ROOT import RooFit, RooRealVar, RooDataHist, RooArgList
# Fit m_DTF_Phi
gStyle.SetOptFit(1111)
histo = histos['m_DTF_Phi']
x = RooRealVar('x', 'm_{#Phi}', 1008,1032,'MeV')
ral = RooArgList(x)
dh = RooDataHist ("dh","dh",ral,RooFit.Import(histo))
frame = x.frame(RooFit.Title('Mass Decay Tree Fitter m_{#Phi} constrained'))
dh.plotOn(frame)
mean = RooRealVar("mean","mean",1020,1010,1025)
sigma = RooRealVar("sigma","sigma",3,0.1,10)
alpha = RooRealVar('alpha', 'alpha', 1, 0.1, 10)
param_n = RooRealVar('param_n','param_n', 2, 0.1, 10)
#pdf = ROOT.RooGaussian("gauss","gauss",x,mean,sigma)
pdf = ROOT.RooBreitWigner('BW','BW',x,mean, sigma)
#pdf = ROOT.RooVoigtian('voit','voit', x, mean, sigma)
#pdf = ROOT.RooCBShape('CB','CB', x, mean, sigma, alpha, param_n)
fit_region = x.setRange("fit_region",1015,1025)
pdf.fitTo(dh, RooFit.Range("fit_region"))
pdf.paramOn(frame, RooFit.Layout(0.1,0.44,0.9))
pdf.plotOn(frame)
chi2 = round(frame.chiSquare(),2)
leg = TLegend(0.3,0,.10,.10)
leg.SetBorderSize(0)
leg.SetFillStyle(0)
leg.AddEntry(0,'#chi^{2} ='+str(chi2),'')
frame.addObject(leg)
frame.Draw()
c1.Update()
c1.Print(outFile_name)
# Fit m_Kpipi
histo = histos['m_KPiPi_SS_noD']
x = RooRealVar('x', 'm_{K#pi#pi}', 1100,1900,'MeV')
ral = RooArgList(x)
dh = RooDataHist ("dh","dh",ral,RooFit.Import(histo))
frame = x.frame(RooFit.Title('Combinatorial mass not in D- region'))
dh.plotOn(frame)
mean = RooRealVar("mean","mean",1510,1100,1900)
sigma = RooRealVar("sigma","sigma",107,0.1,300)
alpha = RooRealVar('alpha', 'alpha', 1, 0.1, 10)
param_n = RooRealVar('param_n','param_n', 2, 0.1, 10)
#pdf = ROOT.RooGaussian("gauss","gauss",x,mean,sigma)
pdf = ROOT.RooCBShape('CB','CB', x, mean, sigma, alpha, param_n)
fit_region = x.setRange("fit_region",1100,1900)
pdf.fitTo(dh, RooFit.Range("fit_region"))
pdf.paramOn(frame, RooFit.Layout(0.1,0.44,0.9))
pdf.plotOn(frame)
chi2 = round(frame.chiSquare(),2)
leg = TLegend(0.3,0,.10,.10)
leg.SetBorderSize(0)
leg.SetFillStyle(0)
leg.AddEntry(0,'#chi^{2} ='+str(chi2),'')
frame.addObject(leg)
frame.Draw()
c1.Update()
c1.Print(outFile_name)
histo.Fit('gaus')
histo.Draw()
c1.Update()
c1.Print(outFile_name)
# # Traditional Root way to fit
# func = TF1('myBW', '[0]*TMath::BreitWigner(x,[1],[2])', 1010,1025)
# # func = TF1('myfunc', '[0]*TMath::Gaus(x,[1],[2])', 1010,1025)
# func = TF1('myfunc', '[0]*TMath::Voigt(x-[1],[2],[3])', 1010,1025)
# func.SetParameter(0,1048)
# func.SetParName(0,'Norm')
# func.SetParameter(1,1020)
# func.SetParName(1,'mean')
# func.SetParameter(2,4)
# func.SetParName(2,'gamma')
# func = TF1('myfunc', '[0]*TMath::Voigt(x-[1],[2],[3])', 1010,1025)
# func.SetParameter(0,1048)
# func.SetParName(0,'Norm')
# func.SetParameter(1,1020)
# func.SetParName(1,'mean')
# func.SetParameter(2,4)
# func.SetParName(2,'sigma')
# func.SetParameter(3,4)
# func.SetParName(2,'gamma')
# histo.Fit('myfunc')
# #histo.Fit('gaus')
# histo.Draw()
# c1.Update()
# c1.Print(outFile_name)
c1.Print(outFile_name+']')
def main(options,args):
from ROOT import gSystem, gROOT, gStyle
gROOT.SetBatch()
gSystem.Load("libRooFitCore")
if options.doWebPage:
from lip.Tools.rootutils import loadToolsLib, apply_modifs
loadToolsLib()
from ROOT import TFile, RooFit, RooArgSet, RooDataHist, RooKeysPdf, RooHistPdf, TCanvas, TLegend, TLatex, TArrow, TPaveText, RooAddPdf, RooArgList
from ROOT import kWhite, kBlue, kOpenSquare
if options.doWebPage:
from ROOT import HtmlHelper, HtmlTag, HtmlTable, HtmlPlot
rootglobestyle.setTDRStyle()
gStyle.SetMarkerSize(1.5)
gStyle.SetTitleYOffset(1.5)
gStyle.SetPadLeftMargin(0.16)
gStyle.SetPadRightMargin(0.05)
gStyle.SetPadTopMargin(0.05)
gStyle.SetPadBottomMargin(0.13)
gStyle.SetLabelFont(42,"XYZ")
gStyle.SetLabelOffset(0.007, "XYZ")
gStyle.SetLabelSize(0.05,"XYZ")
gStyle.SetTitleSize(0.06,"XYZ")
gStyle.SetTitleXOffset(0.9)
gStyle.SetTitleYOffset(1.24)
gStyle.SetTitleFont(42,"XYZ")
##
## Read files
##
options.outdir = "%s_m%1.0f" % ( options.outdir, options.mH )
if options.fp:
options.outdir += "_fp"
ncat=options.ncat
cats=options.cats
if cats is "":
categories =[ "_cat%d" % i for i in range(0,ncat) ]
else:
categories =[ "_cat%s" % i for i in cats.split(",") ]
if options.mva:
clables = { "_cat0" : ("MVA > 0.89",""),
"_cat1" : ("0.74 #leq MVA","MVA < 0.89"),
"_cat2" : ("0.545 #leq MVA","MVA < 0.74"),
"_cat3" : ("0.05 #leq MVA","MVA < 0.545"),
"_cat4" : ("Di-jet","Tagged"),
"_cat5" : ("Di-jet","Tagged"),
"_combcat" : ("All Classes","Combined")
}
else:
clables = { "_cat0" : ("max(|#eta|<1.5","min(R_{9})>0.94"),
"_cat1" : ("max(|#eta|<1.5","min(R_{9})<0.94"),
"_cat2" : ("max(|#eta|>1.5","min(R_{9})>0.94"),
"_cat3" : ("max(|#eta|>1.5","min(R_{9})<0.94"),
"_cat4" : ("Di-jet","Tagged"),
"_cat5" : ("Di-jet","Tagged"),
"_combcat" : ("All Classes","Combined")
}
helper = Helper()
fin = TFile.Open(options.infile)
helper.files.append(fin)
ws = fin.Get("cms_hgg_workspace")
mass = ws.var("CMS_hgg_mass")
mass.SetTitle("m_{#gamma#gamma}");
mass.setUnit("GeV");
mass.setRange(100.,150.)
mass.setBins(100,"plot")
mass.setBins(5000)
print ws
aset = RooArgSet(mass)
helper.objs.append( mass )
helper.objs.append( aset )
fitopt = ( RooFit.Minimizer("Minuit2", ""), RooFit.Minos(False), RooFit.SumW2Error(False), RooFit.NumCPU(8) )
if not options.binned and not options.refit:
finpdf = TFile.Open(options.infilepdf)
helper.files.append(finpdf)
wspdf = finpdf.Get("wsig")
else:
wspdf = ws
for c in categories:
processes = [ "ggh", "vbf", "wzh" ]
if options.fp:
processes = [ "vbf", "wzh" ]
### elif clables[c][0] == "Di-jet":
### processes = [ "vbf", "ggh" ]
dsname = "sig_mass_m%1.0f%s" % (options.mH,c)
print dsname
print ws
ds = ws.data( "sig_%s_mass_m%1.0f%s" % (processes[0],options.mH,c) ).Clone(dsname)
for proc in processes[1:]:
ds.append( ws.data( "sig_%s_mass_m%1.0f%s" % (proc,options.mH,c) ) )
helper.dsets.append( ds )
if options.binned:
binned_ds = RooDataHist( "binned_%s" % dsname,"binned_%s" % dsname,aset, ds)
pdf = RooKeysPdf( "pdf_%s_%s" % (dsname, f), "pdf_%s" % dsname, mass, ds )
plot_pdf = RooHistPdf( "pdf_%s" % dsname, "pdf_%s" % dsname, aset, plot_ds )
helper.add( binned_ds, binned_ds.GetName() )
else:
if options.refit:
if options.refitall and clables[c][0] != "Di-jet":
rpdfs = []
for proc in processes:
for ngaus in range(1,4):
pp = build_pdf(ws,"%s_%s" % (c,proc),ngaus,ngaus==3 )
pp.fitTo( ws.data( "sig_%s_mass_m%1.0f%s" % (proc,options.mH,c)), RooFit.Strategy(0), *fitopt )
rpdfs.append(pp)
pdf = RooAddPdf("hggpdfrel%s" % c, "hggpdfrel%s" % c, RooArgList(*tuple(rpdfs) ))
else:
if options.refitall and clables[c][0] == "Di-jet":
for ngaus in range(1,5):
pdf = build_pdf(ws,c,ngaus,ngaus==5)
pdf.fitTo(ds, RooFit.Strategy(0), *fitopt )
else:
for ngaus in range(1,4):
pdf = build_pdf(ws,c,ngaus,ngaus==3)
pdf.fitTo(ds, RooFit.Strategy(0), *fitopt )
else:
pdfs = (wspdf.pdf( "hggpdfrel%s_%s" % (c, p)) for p in processes )
pdf = RooAddPdf("hggpdfrel%s" % c, "hggpdfrel%s" % c, RooArgList(*pdfs ))
helper.add(pdf,pdf.GetName())
plot_pdf = pdf.Clone("pdf_%s" % dsname)
plot_ds = RooDataHist( "plot_%s" % dsname,"plot_%s" % dsname, aset, "plot")
plot_ds.add( ds )
cdf = pdf.createCdf(aset)
hmin, hmax, hm = get_FWHM( mass, pdf, cdf, options.mH-10., options.mH+10. )
wmin, wmax = get_eff_sigma( mass, pdf, cdf, options.mH-10., options.mH+10. )
### hmin, hmax, hm = get_FWHM( points )
helper.add( plot_ds, plot_ds.GetName() )
helper.add( plot_pdf, plot_pdf.GetName() )
helper.add( (wmin,wmax), "eff_sigma%s" % c )
helper.add( (hmin, hmax, hm), "FWHM%s" % c )
helper.add( ds.sumEntries(), "sumEntries%s" %c ) # signal model integral
# data integral for PAS tables
data = ws.data( "data_mass%s"%c)
helper.add( data.sumEntries("CMS_hgg_mass>=%1.4f && CMS_hgg_mass<=%1.4f"%(options.mH-10.,options.mH+10.)),"data_sumEntries%s"%c)
del cdf
del pdf
dsname = "sig_mass_m%1.0f_combcat" % options.mH
print dsname
combined_ds = helper.dsets[0].Clone(dsname)
for d in helper.dsets[1:]:
combined_ds.append(d)
if options.binned:
binned_ds = RooDataHist( "binned_%s" % dsname,"binned_%s" % dsname,aset, combined_ds)
pdf = RooKeysPdf( "pdf_%s" % (dsname), "pdf_%s" % dsname, mass, combined_ds )
plot_pdf = RooHistPdf( "pdf_%s" % dsname, "pdf_%s" % dsname, aset, plot_ds )
helper.add( binned_ds, binned_ds.GetName() )
else:
#### pdf = build_pdf(ws,"_combcat")
#### pdf.fitTo(combined_ds, RooFit.Strategy(0), *fitopt )
#### plot_pdf = pdf.Clone( "pdf_%s" % dsname )
pdf = RooAddPdf( "pdf_%s" % dsname, "pdf_%s" % dsname, RooArgList( *(helper.histos["hggpdfrel%s" % c] for c in categories) ) )
plot_pdf = pdf
cdf = pdf.createCdf(aset)
plot_ds = RooDataHist( "plot_%s" % dsname,"plot_%s" % dsname, aset, "plot")
plot_ds.add( combined_ds )
wmin, wmax = get_eff_sigma( mass, pdf, cdf, options.mH-10., options.mH+10. )
hmin, hmax, hm = get_FWHM( mass, pdf, cdf, options.mH-10., options.mH+10. )
helper.add( plot_ds, plot_ds.GetName() )
helper.add( plot_pdf, plot_pdf.GetName() )
helper.add( (wmin,wmax), "eff_sigma_combcat" )
helper.add( (hmin, hmax, hm), "FWHM_combcat" )
helper.add( plot_ds.sumEntries(), "sumEntries_combcat" )
mass.setRange("higgsrange",options.mH-25.,options.mH+15.);
del cdf
del pdf
del helper.dsets
### label = TLatex(0.1812081,0.8618881,"#scale[0.8]{#splitline{CMS preliminary}{Simulation}}")
label = TLatex(0.7,0.86,"#scale[0.65]{#splitline{CMS preliminary}{Simulation}}")
label.SetNDC(1)
##
## Make web page with plots
##
if options.doWebPage:
hth = HtmlHelper(options.outdir)
hth.navbar().cell( HtmlTag("a") ).firstChild().txt("..").set("href","../?C=M;O=D")
hth.navbar().cell( HtmlTag("a") ).firstChild().txt("home").set("href","./")
tab = hth.body().add( HtmlTable() )
ip = 0
for c in ["_combcat"]+categories:
### for c in categories:
if options.doWebPage and ip % 4 == 0:
row = tab.row()
ip = ip + 1
dsname = "sig_mass_m%1.0f%s" % (options.mH,c)
canv = TCanvas(dsname,dsname,600,600)
helper.objs.append(canv)
### leg = TLegend(0.4345638,0.6835664,0.9362416,0.9178322)
leg = TLegend(0.2,0.96,0.5,0.55)
#apply_modifs( leg, [("SetLineColor",kWhite),("SetFillColor",kWhite),("SetFillStyle",0),("SetLineStyle",0)] )
hplotcompint = mass.frame(RooFit.Bins(250),RooFit.Range("higgsrange"))
helper.objs.append(hplotcompint)
helper.objs.append(leg)
plot_ds =helper.histos["plot_%s" % dsname ]
plot_pdf =helper.histos["pdf_%s" % dsname ]
wmin,wmax = helper.histos["eff_sigma%s" % c ]
hmin, hmax, hm = helper.histos["FWHM%s" % c ]
print hmin, hmax, hm
style = ( RooFit.LineColor(kBlue), RooFit.LineWidth(2), RooFit.FillStyle(0) )
style_seff = ( RooFit.LineWidth(2), RooFit.FillStyle(1001), RooFit.VLines(), RooFit.LineColor(15), )
style_ds = ( RooFit.MarkerStyle(kOpenSquare), )
plot_ds.plotOn(hplotcompint,RooFit.Invisible())
plot_pdf.plotOn(hplotcompint,RooFit.NormRange("higgsrange"),RooFit.Range(wmin,wmax), RooFit.FillColor(19),
RooFit.DrawOption("F"), *style_seff)
seffleg = hplotcompint.getObject(int(hplotcompint.numItems()-1))
plot_pdf.plotOn(hplotcompint,RooFit.NormRange("higgsrange"),RooFit.Range(wmin,wmax), RooFit.LineColor(15), *style_seff)
plot_pdf.plotOn(hplotcompint,RooFit.NormRange("higgsrange"),RooFit.Range("higgsrange"),*style)
pdfleg = hplotcompint.getObject(int(hplotcompint.numItems()-1))
plot_ds.plotOn(hplotcompint,*style_ds)
pointsleg = hplotcompint.getObject(int(hplotcompint.numItems()-1))
iob = int( hplotcompint.numItems() - 1 )
leg.AddEntry( pointsleg, "Simulation", "pe" )
leg.AddEntry( pdfleg, "Parametric model", "l" )
leg.AddEntry( seffleg, "#sigma_{eff} = %1.2f GeV " % ( 0.5*(wmax-wmin) ), "fl" )
clabel = TLatex(0.74,0.65,"#scale[0.65]{#splitline{%s}{%s}}" % clables[c])
clabel.SetNDC(1)
helper.objs.append(clabel)
hm = hplotcompint.GetMaximum()*0.5*0.9
### hm = pdfleg.GetMaximum()*0.5
fwhmarrow = TArrow(hmin,hm,hmax,hm)
fwhmarrow.SetArrowSize(0.03)
helper.objs.append(fwhmarrow)
fwhmlabel = TPaveText(0.20,0.58,0.56,0.48,"brNDC")
fwhmlabel.SetFillStyle(0)
fwhmlabel.SetLineColor(kWhite)
reducedFWHM = (hmax-hmin)/2.3548200
fwhmlabel.AddText("FWHM/2.35 = %1.2f GeV" % reducedFWHM)
helper.objs.append(fwhmlabel)
hplotcompint.SetTitle("");
hplotcompint.GetXaxis().SetNoExponent(True);
hplotcompint.GetXaxis().SetTitle("m_{#gamma#gamma} (GeV)");
hplotcompint.GetXaxis().SetNdivisions(509);
## hplotcompint.GetYaxis().SetTitle("A.U.");
## hplotcompint.GetYaxis().SetRangeUser(0.,hplotcompint.GetMaximum()*1.4);
hplotcompint.Draw();
leg.Draw("same")
label.Draw("same")
clabel.Draw("same")
fwhmarrow.Draw("<>")
fwhmlabel.Draw("same")
plot_ds.sumEntries()
if options.doWebPage:
hpl = HtmlPlot(canv,False,"",True,True,True)
hpl.caption("<i>%s</i>" % canv.GetTitle())
row.cell( hpl )
else:
if os.path.isdir(options.outdir) is False:
os.mkdir(options.outdir)
for ext in "C","png","pdf":
canv.SaveAs( os.path.join(options.outdir,"%s.%s" % (canv.GetName(), ext)) )
if "comb" in c:
ip = 0
if options.doWebPage:
print "Creating pages..."
hth.dump()
for f in helper.files:
f.Close()
gROOT.Reset()
from pprint import pprint
pprint(helper)
print 'Summary statistics per event class'
print 'Cat\tSignal\t\tData/GeV (in %3.1f+/-10)\tsigEff\tFWHM/2.35'%options.mH
sigTotal=0.
dataTotal=0.
for c in categories:
sigVal = helper.histos["sumEntries%s"%c]
datVal = helper.histos["data_sumEntries%s"%c]
sigTotal+=sigVal
dataTotal+=datVal
for c in categories:
sigVal = helper.histos["sumEntries%s"%c]
datVal = helper.histos["data_sumEntries%s"%c]
effSig = 0.5*(helper.histos["eff_sigma%s"%c][1]-helper.histos["eff_sigma%s"%c][0])
fwhm = (helper.histos["FWHM%s"%c][1]-helper.histos["FWHM%s"%c][0]) / 2.3548200
print c, '\t%3.1f (%3.1f%%)\t%3.1f (%3.1f%%)\t\t\t%2.2f\t%2.2f'%(sigVal,100.*sigVal/sigTotal,datVal/(10.+10.),100.*datVal/dataTotal,effSig,fwhm)
print "Done."
# In[9]:
masslist = RooArgList(mass)
dh = RooDataHist("dh", "dh", masslist, hist)
numEvts = dh.sum(False)
print numEvts
# In[10]:
tot.fitTo(dh)
# In[11]:
massFrame = mass.frame()
massFrame.SetTitle("Phi signal")
dh.plotOn(massFrame)
tot.plotOn(massFrame)
gauss.plotOn(massFrame, LineColor(kGreen), LineStyle(kDashed),
Normalization((sFrac.getValV() * numEvts) / (numEvts)))
cheb.plotOn(massFrame, LineColor(kMagenta), LineStyle(kDotted),
Normalization(((1.0 - sFrac.getValV()) * numEvts) / (numEvts)))
tot.paramOn(massFrame, Layout(0.60, 0.99, 0.75))
massFrame.Draw()
# In[12]:
plotmax = hist.GetMaximum() * 1.05
sidesigma = sigma.getValV()
leftlowside = -7. * sidesigma + mean.getValV()
leftupside = -5. * sidesigma + mean.getValV()
rightlowside = +5. * sidesigma + mean.getValV()
numEvts = dh.sum(False)
print numEvts
# In[10]:
tot.fitTo(dh)
# In[11]:
massFrame = mass.frame()
massFrame.SetTitle("Phi signal")
dh.plotOn(massFrame)
tot.plotOn(massFrame)
gauss.plotOn(massFrame,LineColor(kGreen),LineStyle(kDashed),Normalization((sFrac.getValV()*numEvts)/(numEvts)))
cheb.plotOn(massFrame,LineColor(kMagenta),LineStyle(kDotted),Normalization(((1.0-sFrac.getValV())*numEvts)/(numEvts)))
tot.paramOn(massFrame,Layout(0.60,0.99,0.75));
massFrame.Draw()
# In[12]:
plotmax = hist.GetMaximum()*1.05
sidesigma = sigma.getValV()
leftlowside = -7.*sidesigma + mean.getValV()
leftupside = -5.*sidesigma + mean.getValV()
rightlowside = +5.*sidesigma + mean.getValV()
def fitHistogram( histToFit, channel, variable='', bin='', treeSuffix ='' ) :
# Declare variables x,mean,sigma with associated name, title, initial value and allowed range
x = RooRealVar("M(jj)","M(jj)",40,500)
title = channel
if variable != '' and bin != '' :
title = '%s_%s_%s' % (channel, variable, bin)
histToFit = RooDataHist('histToFit', 'histToFit', RooArgList( x ), RooFit.Import( histToFit ) )
frame = x.frame(RooFit.Title( title ))
histToFit.plotOn( frame )
# Setup fit function
fitFunction = None
# Stuff for gauss
mg = RooRealVar("mean","mean of gaussian",86,50,120)
sg = RooRealVar("sigma","width of gaussian",10,2,50)
gauss = RooGaussian("gauss","gaussian PDF",x,mg,sg)
CBmean = RooRealVar("CBmean", "CBmean",110, 5, 500)
CBsigma = RooRealVar("CBsigma", "CBsigma",40, 20, 150)
CBalpha = RooRealVar("CBalpha", "CBalpha", -0.5, -20., 0.)
# CBalpha = RooRealVar("CBalpha", "CBalpha", 10, 0., 20.)
CBn = RooRealVar("CBn", "CBn", 1., 0., 20.)
crystalBall = RooCBShape("crystalBall","Crystal Ball resolution model", x, CBmean, CBsigma, CBalpha, CBn)
fracGauss = RooRealVar("fracGauss", "fracGauss", 0.4, 0, 1)
gaussPlusCrystalBall = RooAddPdf("gaussPlusCrystalBall", "Gauss plus Crystal Ball", RooArgList(gauss, crystalBall), RooArgList( fracGauss ) )
fitFunction = gaussPlusCrystalBall
# # Fit pdf to data
fitFunction.fitTo(histToFit, RooFit.PrintLevel(-1))
# Plot histogram being fitted
histToFit.plotOn(frame)
# Plot fit functions and components
fitFunction.plotOn(frame, RooFit.LineColor(kRed))
toPlot = RooArgSet(crystalBall)
fitFunction.plotOn(frame, RooFit.Components(toPlot), RooFit.LineStyle(kDashed), RooFit.LineColor(kRed))
toPlot = RooArgSet(gauss)
fitFunction.plotOn(frame, RooFit.Components(toPlot), RooFit.LineStyle(kDashed), RooFit.LineColor(kBlue))
fitFunction.paramOn(frame,RooFit.Layout(0.55, 0.9, 0.9)) ;
# # Draw frame on a canvas
c = TCanvas("WMass","WMass",800,400)
gPad.SetLeftMargin(0.15)
frame.GetYaxis().SetTitleOffset(1.6)
frame.Draw()
gPad.Update()
if variable == '' and bin == '':
c.Print( 'plots/WStudies/%s%s.pdf' % ( channel, treeSuffix ) )
elif variable != '' and bin != '':
outputDir = 'plots/WStudies/%s%s/%s' % (channel, treeSuffix, variable)
if not os.path.exists( outputDir ):
os.makedirs( outputDir )
c.Print( '%s/%s.pdf' % (outputDir, bin) )
# raw_input('Carry on')
# mg.Print()
return mg
def rf501_simultaneouspdf():
# C r e a t e m o d e l f o r p h y s i c s s a m p l e
# -------------------------------------------------------------
# Create observables
x = RooRealVar("x", "x", 40, 200)
nsig = RooRealVar("nsig", "#signal events", 200, 0.0, 10000)
nbkg = RooRealVar("nbkg", "#background events", 800, 0.0, 200000)
# Construct signal pdf
mean = RooRealVar("mean", "mean", mu4, 40, 200)
sigma = RooRealVar("sigma", "sigma", sigma4, 0.1, 20)
gx = RooGaussian("gx", "gx", x, mean, sigma)
# Construct background pdf
mean_bkg = RooRealVar("mean_bkg", "mean_bkg", mu3, 40, 200)
sigma_bkg = RooRealVar("sigma_bkg", "sigma_bkg", sigma3, 0.1, 20)
px = RooGaussian("px", "px", x, mean_bkg, sigma_bkg)
# Construct composite pdf
model = RooAddPdf("model", "model", RooArgList(gx, px), RooArgList(nsig, nbkg))
# C r e a t e m o d e l f o r c o n t r o l s a m p l e
# --------------------------------------------------------------
# Construct signal pdf.
# NOTE that sigma is shared with the signal sample model
y = RooRealVar("y", "y", 40, 200)
mean_ctl = RooRealVar("mean_ctl", "mean_ctl", mu2, 40, 200)
sigma_ctl = RooRealVar("sigma", "sigma", sigma2, 0.1, 10)
gx_ctl = RooGaussian("gx_ctl", "gx_ctl", y, mean_ctl, sigma_ctl)
# Construct the background pdf
mean_bkg_ctl = RooRealVar("mean_bkg_ctl", "mean_bkg_ctl", mu1, 40, 200)
sigma_bkg_ctl = RooRealVar("sigma_bkg_ctl", "sigma_bkg_ctl", sigma1, 0.1, 20)
px_ctl = RooGaussian("px_ctl", "px_ctl", y, mean_bkg_ctl, sigma_bkg_ctl)
# Construct the composite model
# f_ctl = RooRealVar( "f_ctl", "f_ctl", 0.5, 0., 20. )
model_ctl = RooAddPdf("model_ctl", "model_ctl", RooArgList(gx_ctl, px_ctl), RooArgList(nsig, nbkg))
# G e t e v e n t s f o r b o t h s a m p l e s
# ---------------------------------------------------------------
real_data, real_data_ctl = get_data()
real_data_hist = RooDataHist("real_data_hist", "real_data_hist", RooArgList(x), real_data)
real_data_ctl_hist = RooDataHist("real_data_ctl_hist", "real_data_ctl_hist", RooArgList(y), real_data_ctl)
input_hists = MapStrRootPtr()
input_hists.insert(StrHist("physics", real_data))
input_hists.insert(StrHist("control", real_data_ctl))
# C r e a t e i n d e x c a t e g o r y a n d j o i n s a m p l e s
# ---------------------------------------------------------------------------
# Define category to distinguish physics and control samples events
sample = RooCategory("sample", "sample")
sample.defineType("physics")
sample.defineType("control")
# Construct combined dataset in (x,sample)
combData = RooDataHist("combData", "combined data", RooArgList(x), sample, input_hists)
# C o n s t r u c t a s i m u l t a n e o u s p d f i n ( x , s a m p l e )
# -----------------------------------------------------------------------------------
# Construct a simultaneous pdf using category sample as index
simPdf = RooSimultaneous("simPdf", "simultaneous pdf", sample)
# Associate model with the physics state and model_ctl with the control state
simPdf.addPdf(model, "physics")
simPdf.addPdf(model_ctl, "control")
# P e r f o r m a s i m u l t a n e o u s f i t
# ---------------------------------------------------
model.fitTo(real_data_hist)
summary = "fit in signal region\n"
summary += "nsig: " + str(nsig.getValV()) + " +- " + str(nsig.getError()) + "\n"
summary += "nbkg: " + str(nbkg.getValV()) + " +- " + str(nbkg.getError()) + "\n"
model_ctl.fitTo(real_data_ctl_hist)
summary += "fit in control region\n"
summary += "nsig: " + str(nsig.getValV()) + " +- " + str(nsig.getError()) + "\n"
summary += "nbkg: " + str(nbkg.getValV()) + " +- " + str(nbkg.getError()) + "\n"
# Perform simultaneous fit of model to data and model_ctl to data_ctl
simPdf.fitTo(combData)
summary += "Combined fit\n"
summary += "nsig: " + str(nsig.getValV()) + " +- " + str(nsig.getError()) + "\n"
summary += "nbkg: " + str(nbkg.getValV()) + " +- " + str(nbkg.getError()) + "\n"
# P l o t m o d e l s l i c e s o n d a t a s l i c e s
# ----------------------------------------------------------------
# Make a frame for the physics sample
frame1 = x.frame(RooFit.Bins(30), RooFit.Title("Physics sample"))
# Plot all data tagged as physics sample
combData.plotOn(frame1, RooFit.Cut("sample==sample::physics"))
# Plot "physics" slice of simultaneous pdf.
# NBL You _must_ project the sample index category with data using ProjWData
# as a RooSimultaneous makes no prediction on the shape in the index category
# and can thus not be integrated
simPdf.plotOn(frame1, RooFit.Slice(sample, "physics"), RooFit.ProjWData(RooArgSet(sample), combData))
simPdf.plotOn(
frame1,
RooFit.Slice(sample, "physics"),
RooFit.Components("px"),
RooFit.ProjWData(RooArgSet(sample), combData),
RooFit.LineStyle(kDashed),
)
# The same plot for the control sample slice
frame2 = y.frame(RooFit.Bins(30), RooFit.Title("Control sample"))
combData.plotOn(frame2, RooFit.Cut("sample==sample::control"))
simPdf.plotOn(frame2, RooFit.Slice(sample, "control"), RooFit.ProjWData(RooArgSet(sample), combData))
simPdf.plotOn(
frame2,
RooFit.Slice(sample, "control"),
RooFit.Components("px_ctl"),
RooFit.ProjWData(RooArgSet(sample), combData),
RooFit.LineStyle(kDashed),
)
simPdf.plotOn(
frame2,
RooFit.Slice(sample, "control"),
RooFit.Components("gx_ctl"),
RooFit.ProjWData(RooArgSet(sample), combData),
RooFit.LineStyle(kDashed),
)
c = TCanvas("rf501_simultaneouspdf", "rf403_simultaneouspdf", 800, 400)
c.Divide(2)
c.cd(1)
gPad.SetLeftMargin(0.15)
frame1.GetYaxis().SetTitleOffset(1.4)
frame1.Draw()
c.cd(2)
gPad.SetLeftMargin(0.15)
frame2.GetYaxis().SetTitleOffset(1.4)
frame2.Draw()
print summary
raw_input()
fintegral = ratio.createIntegral(RooArgSet(time), 'fullrange').getVal()
hintegral = ratiohist.Integral('width') # has weights, use width
norm = fintegral / hintegral
print '=' * 5, ' Integrals ', '=' * 5
print 'Function integral / histogram integral = %g / %g = %g' % (
fintegral, hintegral, norm)
ratiohist.Scale(norm)
# make dataset from histogram
ratiodset = RooDataHist('ratiodset', '', RooArgList(time), ratiohist)
ratiodset.Print('v')
## Plot
tframe = time.frame(RooFit.Title('Time acceptance ratio'))
paramset = RooArgSet(rturnon, roffset, rbeta)
ratio.plotOn(tframe, RooFit.VisualizeError(fitresult, paramset, 1, False))
ratio.plotOn(tframe)
ratiodset.plotOn(tframe, RooFit.MarkerStyle(kFullDotMedium))
tframe.Draw()
# Print
if doPrint:
print 'Plotting to file: plots/DsK_ratio_%s.{png,pdf}' % timestamp
gPad.Print('plots/DsK_ratio_%s.png' % timestamp)
gPad.Print('plots/DsK_ratio_%s.pdf' % timestamp)
# NB: Do not close file, otherwise plot disappears
# ffile.Close()
def fitLandauGaus(hist, full = False):
## c1 = ROOT.TCanvas()
## c1.Divide(2)
## c1.cd(1)
## hist.Draw()
neg_landau = False
if hist.GetMean() < 0.:
neg_landau = True
if neg_landau:
hist = turnHisto(hist)
hist.Rebin(2)
hist.SetTitle('')
hist.SetName('hSignal')
## c1.cd(2)
## hist.Draw('hist')
## c1.SaveAs('foobar.pdf')
### #if neg_landau:
### # func = ROOT.TF1('my_landau','[0] * TMath::Landau(-x,[1],[2])', hist.GetXaxis().GetXmin(), hist.GetXaxis().GetXmax())
### # func.SetParameters(1, hist.GetMean(), hist.GetRMS() )
### #else:
### func = ROOT.TF1('my_landau','[0] * TMath::Landau(x,[1],[2])', hist.GetXaxis().GetXmin(), hist.GetXaxis().GetXmax())
### func.SetParameters(1, hist.GetMean(), hist.GetRMS() )
### hist.Fit('my_landau','q')
### fit_res = []
### fit_res.append(func.GetParameter(0) if not neg_landau else func.GetParameter(0))
### fit_res.append(func.GetParameter(1) if not neg_landau else -1.*func.GetParameter(1))
### fit_res.append(func.GetParameter(2) if not neg_landau else func.GetParameter(2))
### return hist, fit_res
## ROOFIT VERSION
xmin = hist.GetXaxis().GetXmin()
xmax = hist.GetXaxis().GetXmax()
mean = hist.GetMean()
mp = hist.GetXaxis().GetBinCenter(hist.GetMaximumBin())
rms = hist.GetRMS()
flandau = ROOT.TF1('flandau','landau',mp-20,mp+40)
flandau.SetLineWidth(1)
flandau.SetLineColor(ROOT.kBlue)
hist2 = hist.Clone(hist.GetName()+'_2')
hist2.Scale(1./hist2.GetBinContent(hist2.GetMaximumBin()))
hist2.Fit(flandau,'Q','',mp-20,mp+40)
flandau2 = flandau.Clone('flandau2')
flandau2.SetRange(0,500)
flandau2.SetLineStyle(2)
for i in range(flandau.GetNpar()):
flandau2.SetParLimits(i,flandau.GetParameter(i),flandau.GetParameter(i))
hist2.Fit(flandau2,'Q+')#,'same',mp-20,mp+40)
for i in range(flandau.GetNpar()):
hist2.GetFunction('flandau2').SetParameter(i,flandau.GetParameter(i))
for i in range(flandau.GetNpar()):
print flandau.GetParameter(i),flandau2.GetParameter(i)
x = RooRealVar('x', 'signal / adc', 0,500)
x.setRange("signal",mp - 40, mp+90)
x.setRange("draw",0,500)
ral = RooArgList(x)
dh = RooDataHist('dh', 'dh', ral, RooFit.Import(hist))
if full:
ml = RooRealVar('ml', 'mean landau' , mp, mp-20., mp+30)
sl = RooRealVar('sl', 'sigma landau', 10, 1., 25.)
else:
ml = RooRealVar('ml', 'mean landau' , mean, mean-40., mean)
sl = RooRealVar('sl', 'sigma landau', 10., 6., 14.)
landau = RooLandau ('lx', 'lx', x, ml, sl)
mean = 0
if full:
mg = RooRealVar ('mg', 'mean gaus' , 0,0,0)
sg = RooRealVar ('sg', 'sigma gaus', flandau.GetParameter(2), 0.1, 30.)
else:
mg = RooRealVar ('mg', 'mean gaus' , 0,0,0) #mean, mean-30., mean+30.)
sg = RooRealVar ('sg', 'sigma gaus', 2., 0.1, 20.)
gaus = RooGaussian('gx', 'gx', x, mg, sg)
x.setBins(1000,'cache')
## Construct landau (x) gauss
lxg = RooFFTConvPdf('lxg','landau (x) gaus', x, landau, gaus)
lxg.fitTo(dh,RooFit.Range("signal"))
#,RooFit.Normalization(ROOT.RooAbsReal.NumEvent,1))
a = lxg.getParameters(dh)
print 'fit par0 %+6.1f'%flandau.GetParameter(0)
print 'fit par1 %+6.1f'%flandau.GetParameter(1)
print 'fit par2 %+6.1f'%flandau.GetParameter(2)
print 'mp %+6.1f'%mp
print 'rms %+6.1f'%rms
print 'lxg.getParameters(dh).getRealValue(\'ml\'): %+6.1f'% a.getRealValue('ml')
print 'lxg.getParameters(dh).getRealValue(\'sl\'): %+6.1f'% a.getRealValue('sl')
print 'lxg.getParameters(dh).getRealValue(\'sg\'): %+6.1f'% a.getRealValue('sg')
frame = x.frame(RooFit.Title('landau (x) gauss convolution'),RooFit.Range("draw"))
#,RooFit.Normalization(ROOT.RooAbsReal.NumEvent,1))
dh.plotOn(frame,RooFit.Range("draw"))
#,RooFit.Normalization(1./dh.numEntries(),ROOT.RooAbsReal.Raw))
lxg.plotOn(frame,RooFit.LineColor(ROOT.kRed),RooFit.Range("draw"))
#,RooFit.Normalization(1,ROOT.RooAbsReal.Raw))
#lxg.plotOn(frame,RooFit.LineColor(ROOT.kBlue),RooFit.Range("signal"),RooFit.Components('lx,gx'))
# c = ROOT.TCanvas('lg_convolution','landau (x) gaus', 600, 600)
# c.Divide(2)
# c.cd(1)
# hist.Draw()
# c.cd(2)
# ROOT.gPad.SetLeftMargin(0.15)
# frame.GetYaxis().SetTitleOffset(1.4)
# frame.Draw()
# c.SaveAs('histograms/outputhisto'+hist.GetName().split('pz')[1]+'.pdf')
return dh, copy.deepcopy(a), copy.deepcopy(frame),copy.deepcopy(hist2)
def Subtract_Distribution(dataset, DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV, bin = "undefined", silent = False):
dataset_sig = RooDataSet("dataset_sig", "Signal region",dataset, RooArgSet(DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV) ," ( DTF_D0sPi_M < 2015 ) ")
dataset_bckg = RooDataSet("dataset_bckg", "Background region",dataset, RooArgSet(DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV) ," ( DTF_D0sPi_M > 2015 ) && ( DTF_D0sPi_M < 2020 ) ")
#Introduce fit variables
## Johnson parameters
J_mu = RooRealVar("J_mu","J_mu", 2011, 2000, 2020)
J_sigma = RooRealVar("J_sigma","J_sigma", 0.045, 0.01, 0.1)
J_delta = RooRealVar("J_delta","J_delta", 0., -1, 1)
J_gamma = RooRealVar("J_gamma","J_gamma", 0., -1, 1)
## Gaussian parameters
G1_mu = RooRealVar("G1_mu","G1_mu", 2010, 2008, 2012)
G1_sigma = RooRealVar("G1_sigma","G1_sigma", 1.0, 0.01, 5)
G2_mu = RooRealVar("G2_mu","G2_mu", 2010, 2008, 2012)
G2_sigma = RooRealVar("G2_sigma","G2_sigma", 0.4, 0.01, 5)
G3_mu = RooRealVar("G3_mu","G3_mu", 2010, 2008, 2012)
G3_sigma = RooRealVar("G3_sigma","G3_sigma", 0.2, 0.01, 5)
## Signal yields ratios
fJ = RooRealVar("fJ","fJ", 0.5, 0., 1)
fG1 = RooRealVar("fG1","fG1", 0.5, 0., 1)
fG2 = RooRealVar("fG2","fG2", 0.5, 0., 1)
##Background parameters
B_b = RooRealVar("B_b","B_b", 1.09, 0.9, 1.5)
B_c = RooRealVar("B_c","B_c", 0.0837, 0.01, 0.2)
##Total yield
N_S = RooRealVar("N_S","N_S", 0.6*dataset.numEntries(), 0, 1.1*dataset.numEntries())
N_B = RooRealVar("N_B","N_B", 0.3*dataset.numEntries(), 0, 1.1*dataset.numEntries())
#Define shapes
s_Johnson = ROOT.Johnson("s_Johnson", "s_Johnson", DTF_D0sPi_M, J_mu, J_sigma, J_delta, J_gamma)
s_Gauss1 = ROOT.RooGaussian("s_Gauss1","s_Gauss1", DTF_D0sPi_M, G1_mu, G1_sigma)
s_Gauss2 = ROOT.RooGaussian("s_Gauss2","s_Gauss2", DTF_D0sPi_M, G2_mu, G2_sigma)
s_Gauss3 = ROOT.RooGaussian("s_Gauss3","s_Gauss3", DTF_D0sPi_M, G3_mu, G3_sigma)
s_Background = ROOT.Background("s_Background", "s_Background", DTF_D0sPi_M, B_b, B_c)
s_Signal = RooAddPdf("s_Signal", "s_Signal", RooArgList(s_Gauss1, s_Gauss2, s_Gauss3), RooArgList(fG1, fG2), True)
s_Total = RooAddPdf("s_Total", "s_Total", RooArgList(s_Signal, s_Background), RooArgList(N_S, N_B))
dataset_binned = RooDataHist("dataset_binned","Binned data", RooArgSet(DTF_D0sPi_M), dataset)
#Fit shapes
fit_hists = s_Total.fitTo(dataset_binned,RooFit.SumW2Error(True),RooFit.Save())
if not silent:
ipframe_1 = DTF_D0sPi_M.frame(RooFit.Title("Fit example"))
dataset_binned.plotOn(ipframe_1)
s_Total.plotOn(ipframe_1, RooFit.Components("s_Signal"), RooFit.LineColor(2),RooFit.LineWidth(4))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Johnson"), RooFit.LineColor(5),RooFit.LineWidth(2), RooFit.LineStyle(3))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Gauss1"), RooFit.LineColor(6),RooFit.LineWidth(2), RooFit.LineStyle(3))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Gauss2"), RooFit.LineColor(7),RooFit.LineWidth(2), RooFit.LineStyle(3))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Gauss3"), RooFit.LineColor(8),RooFit.LineWidth(2), RooFit.LineStyle(3))
s_Total.plotOn(ipframe_1, RooFit.Components("s_Background"), RooFit.LineColor(4),RooFit.LineWidth(4))
s_Total.plotOn(ipframe_1, RooFit.LineColor(1), RooFit.LineWidth(4))
DTF_D0sPi_M.setRange("Background_region", 2015, 2020)
DTF_D0sPi_M.setRange("Signal_region", 2002, 2015)
Bckg_int = s_Background.createIntegral(RooArgSet(DTF_D0sPi_M), RooArgSet(DTF_D0sPi_M), "Background_region")
Sig_int = s_Background.createIntegral(RooArgSet(DTF_D0sPi_M), RooArgSet(DTF_D0sPi_M), "Signal_region")
w = RooRealVar("w","w",-1,1)
w.setVal(1)
dataset_sig.addColumn(w, False)
w.setVal(-float(Sig_int.getVal())/float(Bckg_int.getVal()))
dataset_bckg.addColumn(w, False)
dataset_all = RooDataSet("dataset_all", "dataset_all",dataset_bckg, RooArgSet(DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV, w), "1>0", "w")
dataset_all.append(dataset_sig)
if not silent:
ipframe_2 = LOG_D0_IPCHI2_OWNPV.frame(RooFit.Title("IPChi2 distribution"))
dataset_bckg.plotOn(ipframe_2, RooFit.LineColor(4), RooFit.MarkerColor(4))
dataset_all.plotOn(ipframe_2, RooFit.LineColor(3), RooFit.MarkerColor(3))
dataset_sig.plotOn(ipframe_2, RooFit.LineColor(2), RooFit.MarkerColor(2))
c1 = TCanvas("c1","c1",900,900)
ipframe_1.Draw()
c1.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_frame1.pdf")
c1.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_frame1_C.C")
c2 = TCanvas("c2","c2",900,900)
ipframe_2.Draw()
c2.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_frame2.pdf")
c2.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_frame2_C.C")
ipframe_1.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_ipframe1.C")
ipframe_2.SaveAs("plots/Subtraction_Control/Bin_"+str(bin)+"_ipframe2.C")
return dataset_all
from ROOT import TH1F, RooRealVar, TCanvas, RooDataHist, RooFit, RooGaussian, kTRUE, RooArgList, RooAddPdf, TLatex
hh = TH1F("hh", "The hist", 100, -5, 5)
hh.FillRandom("gaus", 10000)
c = TCanvas("c", "c", 600, 600)
hh.Draw()
#Save data in RooDataHist
x = RooRealVar("x", "x", -5, 5)
data = RooDataHist("data", "dataset with x", RooArgList(x), hh)
xframe = x.frame()
data.plotOn(xframe)
c1 = TCanvas("c1", "c1", 1200, 600)
c1.Divide(2, 1)
c1.cd(1)
xframe.Draw()
#Create PDF
mean = RooRealVar("mean", "MeanofGaussian", 0, -10, 10)
sigma = RooRealVar("sigma", "WidthofGaussian", 3, -10, 10)
gauss = RooGaussian("gauss", "gauss(x,mean,sigma)", x, mean, sigma)
g1sig = RooRealVar("g1sig", "fraction of gauss1", 10, 0, 100000.0)
# Build signal PDF: f1
signalPDF = RooAddPdf("signalPDF", "g1sig * g1", RooArgList(gauss),
RooArgList(g1sig))
#mean.setConstant(kTRUE); #fix mean
sigma.setRange(0.1, 3)
class CBfunction:
doubleSidedCB = False
gaussian = False
nbins = 600
xmin = 0
xmax = 12000
xaxis_scale = 0.2
a_initial = 0.5
n_initial = 7
a2_initial = 0.5
n2_initial = 7
s_initial = 60
def __init__(self,data):
self.data = data ## data should be TChain already
def set_crystal(self,crystal):
self.crystal = crystal
def set_energy(self,energy):
self.energy = energy
def set_position(self,x=0,y=0,window=20):
self.xcenter = x
self.ycenter = y
self.window = window
def set_selection(self):
self.selection = "n_tracks==1 && fabs(X-(%.2f))<%.2f && fabs(Y-(%.2f))<%.2f"%(self.xcenter,self.window,self.ycenter,self.window)
def prepare_sumhistogram(self,dict_crystals_calibration,matrix):
self.set_selection()
self.hist = ROOT.TH1F("ampl_%s_%s"%(self.crystal,self.energy),"ampl_%s_%s"%(self.crystal,self.energy),self.nbins,self.xmin,self.xmax)
draw_function = '('
for enum,cryst in enumerate(matrix):
#draw_function +='fit_ampl[%s]*%.4f'%(cryst,dict_crystals_calibration[cryst])
draw_function +='((fit_ampl[%s] > 0) ? fit_ampl[%s] : amp_max[%s])*%.4f'%(cryst,cryst,cryst,dict_crystals_calibration[cryst])
if enum!=len(matrix)-1 : draw_function+='+'
# else : draw_function+=")*%.4f>>ampl_%s_%s"%(dict_crystals_calibration['conversion_factor'],self.crystal,self.energy)
else : draw_function+=")>>ampl_%s_%s"%(self.crystal,self.energy)
self.data.Draw(draw_function,self.selection,"goff")
self.peak_position = self.hist.GetXaxis().GetBinCenter(self.hist.GetMaximumBin())
self.ymax_value = self.hist.GetMaximum()
def prepare_histogram(self):
self.set_selection()
self.hist = ROOT.TH1F("ampl_%s_%s"%(self.crystal,self.energy),"ampl_%s_%s"%(self.crystal,self.energy),self.nbins,self.xmin,self.xmax)
self.data.Draw("fit_ampl[%s]>>ampl_%s_%s"%(self.crystal,self.crystal,self.energy),self.selection,"goff")
self.peak_position = self.hist.GetXaxis().GetBinCenter(self.hist.GetMaximumBin())
self.ymax_value = self.hist.GetMaximum()
def prepare_histogram_time(self):
self.set_selection()
self.hist = ROOT.TH1F("ampl_%s_%s"%(self.crystal,self.energy),"ampl_%s_%s"%(self.crystal,self.energy),self.nbins,self.xmin,self.xmax)
self.data.Draw("((fit_time[%s]-fit_time[MCP2]+fit_time[VFE_CLK])-int((fit_time[%s]-fit_time[MCP2]+fit_time[VFE_CLK])/6.238)*6.238)>>ampl_%s_%s"%(self.crystal,self.crystal,self.crystal,self.energy),self.selection,"goff")
self.peak_position = self.hist.GetXaxis().GetBinCenter(self.hist.GetMaximumBin())
self.ymax_value = self.hist.GetMaximum()
def plot_histogram_time(self):
self.hist.Draw("HISTsame")
def CBintialization(self):
round_energy = round(float(self.energy),-1)
if round_energy ==240 : round_energy = 250
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,0.001,1.) #500.
self.a = RooRealVar("alpha_%s_%s"%(self.crystal,self.energy),"alpha_%s_%s"%(self.crystal,self.energy),self.a_initial,-10.,10)
self.n = RooRealVar("exp_%s_%s"%(self.crystal,self.energy),"exp_%s_%s"%(self.crystal,self.energy),self.n_initial,0.,30)
self.sig = RooCBShape("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s,self.a,self.n)
def Gausintialization(self):
round_energy = round(float(self.energy),-1)
if round_energy ==240 : round_energy = 250
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,0.001,1.)
self.sig = RooGaussian("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s)
def CB2intialization(self):
round_energy = round(float(self.energy),-1)
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,10,500)
self.a = RooRealVar("alpha_%s_%s"%(self.crystal,self.energy),"alpha_%s_%s"%(self.crystal,self.energy),self.a_initial,-10.,10)
self.a2 = RooRealVar("alpha2_%s_%s"%(self.crystal,self.energy),"alpha2_%s_%s"%(self.crystal,self.energy),self.a2_initial,-10.,10)
self.n = RooRealVar("exp_%s_%s"%(self.crystal,self.energy),"exp_%s_%s"%(self.crystal,self.energy),self.n_initial,0.,30)
self.n2 = RooRealVar("exp2_%s_%s"%(self.crystal,self.energy),"exp2_%s_%s"%(self.crystal,self.energy),self.n2_initial,0.,30)
self.sig = ROOT.My_double_CB("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s,self.a,self.n,self.a2,self.n2)
def fitToData(self):
self.res = self.sig.fitTo(self.roohist)
def fitResults(self):
self.dict_fit_results = {}
self.dict_fit_results['CBmean'] = [self.m.getVal(),self.m.getError()]
self.dict_fit_results['CBsigma'] = [self.s.getVal(),self.s.getError()]
if (self.gaussian==False) :
self.dict_fit_results['CBalpha'] = [self.a.getVal(),self.a.getError()]
self.dict_fit_results['CBexp'] = [self.n.getVal(),self.n.getError()]
if (self.doubleSidedCB==True) :
self.dict_fit_results['CBalpha2'] = [self.a2.getVal(),self.a2.getError()]
self.dict_fit_results['CBexp2'] = [self.n2.getVal(),self.n2.getError()]
self.dict_fit_results['chi2'] = self.chi2
return self.dict_fit_results
def plot(self):
self.frame = self.x.frame()
self.roohist.plotOn(self.frame,RooFit.Name("roohist_chi2_%s_%s"%(self.crystal,self.energy)))
self.sig.plotOn(self.frame,RooFit.Name("signal_chi2_%s_%s"%(self.crystal,self.energy)))
ndf = 4
self.chi2 = self.frame.chiSquare("signal_chi2_%s_%s"%(self.crystal,self.energy),"roohist_chi2_%s_%s"%(self.crystal,self.energy),ndf) # 4 = nFitParameters from CB
self.sig.paramOn(self.frame,RooFit.Layout(0.65,0.99,0.8))
self.frame.getAttText().SetTextSize(0.02)
txt_chi2 = ROOT.TText(self.peak_position*(1.01-self.xaxis_scale),self.ymax_value*0.95,"Chi2 = %.1f"%self.chi2)
txt_chi2.SetTextSize(0.04)
txt_chi2.SetTextColor(ROOT.kRed)
self.frame.addObject(txt_chi2)
self.frame.Draw()
def plot_time(self):
self.frame = self.x.frame()
self.roohist.plotOn(self.frame,RooFit.Name("roohist_chi2_%s_%s"%(self.crystal,self.energy)))
self.frame.Draw()
def fit2GausPol1(Elo, Ehi, Emid, hist, name_prefix = None,
area1_lo = None, area1_hi = None,
area2_lo = None, area2_hi = None,
offset_lo = None, offset_hi = None,
slope_lo = None, slope_hi = None,
nbkg_lo = None, nbkg_hi = None,
verbose = None):
""" Fitting two gaussian peaks on top of a first order polynomial
background. Some parameters are hardcoded.
A name can be provided to make the fit parameters unique.
"""
if area1_lo is None:
area1_lo = 1.
if area1_hi is None:
area1_hi = 1.E4
if area2_lo is None:
area2_lo = 1.
if area2_hi is None:
area2_hi = 1.E4
if nbkg_lo is None:
nbkg_lo = 0.
if nbkg_hi is None:
nbkg_hi = 1.E4
if offset_lo is None:
offset_lo = -10.
if offset_hi is None:
offset_hi = 100.
if slope_lo is None:
slope_lo = -0.1
if slope_hi is None:
slope_hi = 0.1
if verbose is not None:
print "Fitting two Gaussian peaks on top of a 1st order polynomial\
background to the", hist.GetName(), "in range:", Elo, "--", Ehi, "keV"
ws = ROOT.RooWorkspace()
bookstr = "Polynomial::pol1_bkg(" +\
"edep[" + Elo.__str__() + ", " + Ehi.__str__() +"]" +\
", {bkg_offset[" + offset_lo.__str__() + "," +offset_hi.__str__()+ "]" +\
", bkg_slope[" + slope_lo.__str__() +"," + slope_hi.__str__() +"]"+\
"} )"
if verbose is not None:
print bookstr
ws.factory(bookstr)
bookstr = "Gaussian::peak1_pdf(" +\
"edep[" + Elo.__str__() + ", " + Ehi.__str__() +"]" +\
", centroid1[" + Elo.__str__() + ", " + (Emid+2).__str__() +"]" +\
", sigma1[0.3, 10.])"
if verbose is not None:
print bookstr
ws.factory(bookstr)
bookstr = "Gaussian::peak2_pdf(" +\
"edep[" + Elo.__str__() + ", " + Ehi.__str__() +"]" +\
", centroid2[" + (Emid-2).__str__() + ", " + Ehi.__str__() +"]" +\
", sigma2[0.3, 10.])"
if verbose is not None:
print bookstr
ws.factory(bookstr)
bookstr = "SUM:sum_pdf(area1[" + area1_lo.__str__() + "," + area1_hi.__str__() + "]*peak1_pdf"+\
", area2[" + area2_lo.__str__() + "," + area2_hi.__str__() + "]*peak2_pdf"+\
", nbkg[" + nbkg_lo.__str__()+ "," + nbkg_hi.__str__() + "]*pol1_bkg)"
if verbose is not None:
print bookstr
ws.factory(bookstr)
#ws.factory("SUM:sum_pdf(area1[0,10000]*peak1_pdf, area2[0,1E5]*peak2_pdf, nbkg[0,100000]*pol1_bkg)")
edep = ws.var("edep")
pdf = ws.pdf("sum_pdf")
centroid1 = ws.var("centroid1")
centroid2 = ws.var("centroid2")
datahist = RooDataHist("tmp_datahist","tmp_datahist", RooArgList(edep), hist)
model_config = RooStats.ModelConfig("model_config", ws)
model_config.SetPdf(pdf)
model_config.SetParametersOfInterest(RooArgSet(ws.var("area1"),
ws.var("area2")))
model_config.SetObservables(RooArgSet(ws.var("edep")))
model_config.SetNuisanceParameters(RooArgSet(ws.var("nbkg")))
pllCal = RooStats.ProfileLikelihoodCalculator(datahist, model_config)
fit_result = pllCal.fFitResult
pllCal.SetConfidenceLevel(0.683)
interval = pllCal.GetInterval()
POIs = model_config.GetParametersOfInterest()
#lowerlimit = interval.LowerLimit(firstPOI)
#upperlimit = interval.UpperLimit(firstPOI)
if verbose is not None:
print "Fit status:",fit_result.status()
frame = edep.frame()
datahist.plotOn(frame,
RooFit.MarkerSize(0.3),
RooFit.MarkerColor(ROOT.kAzure))
pdf.plotOn(frame,
RooFit.Components("peak1_pdf"),
RooFit.LineColor(ROOT.kOrange))
pdf.plotOn(frame,
RooFit.Components("peak2_pdf"),
RooFit.LineColor(ROOT.kOrange+2))
pdf.plotOn(frame,
RooFit.Components("pol1_bkg"),
RooFit.LineStyle(ROOT.kDotted),
RooFit.LineColor(ROOT.kMagenta))
pdf.plotOn(frame,
RooFit.LineColor(ROOT.kRed))
c = TCanvas()
c.SetWindowSize(400,250)
frame.Draw()
output = {}
output["fit_status"] = fit_result.status()
output["area1"] = POIs["area1"]
output["area2"] = POIs["area2"]
output["nbkg"] = ws.var("nbkg")
output["centroid1"] = ws.var("centroid1")
output["centroid2"] = ws.var("centroid2")
output["sigma1"] = ws.var("sigma1")
output["sigma2"] = ws.var("sigma2")
output["bkg_slope"] = ws.var("bkg_slope")
output["bkg_offset"] = ws.var("bkg_offset")
output["canvas"] = c
for param in output:
if hasattr(output[param], 'GetName'):
oldname = output[param].GetName()
if name_prefix is None:
newname = hist.GetName() + "_" + Elo.__str__()\
+ "_" + Ehi.__str__() + "_" + oldname
else:
newname = oldname
output[param].SetName(newname)
del ws
return output
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")
bkg = RooGenericPdf('bkg','1/(exp(pow(@0/@1,@2))+1)',RooArgList(x,x0,p))
fsig= RooRealVar('fsig','fsig',0.5,0.,1.)
model = RooAddPdf('model','model',sig,bkg,fsig)
can = TCanvas('can_Mjj'+str(mass),'can_Mjj'+str(mass),900,600)
h.Draw()
gPad.SetLogy()
roohist = RooDataHist('roohist','roohist',RooArgList(x),h)
model.fitTo(roohist)
frame = x.frame()
roohist.plotOn(frame)
model.plotOn(frame)
model.plotOn(frame,RooFit.Components('bkg'),RooFit.LineColor(ROOT.kRed),RooFit.LineWidth(2),RooFit.LineStyle(ROOT.kDashed))
frame.Draw('same')
w = RooWorkspace('w','workspace')
getattr(w,'import')(model)
getattr(w,'import')(roohist)
w.Print()
w.writeToFile('RS'+str(mass)+'_workspace.root')
#----- keep the GUI alive ------------
if __name__ == '__main__':
rep = ''
while not rep in ['q','Q']:
rep = raw_input('enter "q" to quit: ')
sig = RooAddPdf("sig", "g+g", sig_1, sig_2, gFrac)
#sig_1 = RooGaussian("sig_1","sig_1",mass,mean,sigma)
nSig = RooRealVar("nSig", "nSig", 100, 100, len(data["mass"].values))
nBkg = RooRealVar("nBkg", "nBkg", 1000, 100, len(data["mass"].values))
#tot = RooAddPdf("tot","g+cheb",RooArgList(sig,sig_3,bkg),RooArgList(sFrac,bumpFrac))
tot = RooAddPdf("tot", "g+cheb", RooArgList(sig_1, bkg),
RooArgList(nSig, nBkg))
h1 = TH1F("hist", "hist", 200, 4.05, 5.75)
map(h1.Fill, data["mass"].values)
masslist = RooArgList(mass)
dh = RooDataHist("dh", "dh", masslist, h1)
tot.fitTo(dh)
canvas = TCanvas("c", "c", 1200, 1000)
kkFrame = mass.frame()
dh.plotOn(kkFrame)
tot.plotOn(kkFrame) #,RooFit.Normalization(1.0/float(nfit)))
dh.plotOn(kkFrame)
#tot.paramOn(kkFrame,RooFit.Layout(0.57,0.99,0.65))
kkFrame.Draw()
canvas.Draw()
canvas.SaveAs("test.png")
def plot_rec_gen_track_phi():
#track azimuthal angle phi resolution as ( phi_track_rec - phi_track_gen )/phi_track_gen
phibin = 0.0001
phimin = -0.02
phimax = 0.02
#ptlo = 0.
#pthi = 0.9
fitran = [-0.01, 0.01]
mmin = 2.8
mmax = 3.2
cbw = rt.kBlue
#output log file
out = open("out.txt", "w")
#log fit parameters
loglist1 = [(x, eval(x))
for x in ["infile_mc", "phibin", "phimin", "phimax"]]
loglist2 = [(x, eval(x)) for x in ["fitran", "mmin", "mmax"]]
strlog = ut.make_log_string(loglist1, loglist2)
ut.log_results(out, strlog + "\n")
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
#strsel += " && jGenPt>{0:.3f}".format(ptlo)
#strsel += " && jGenPt<{0:.3f}".format(pthi)
nbins, phimax = ut.get_nbins(phibin, phimin, phimax)
hPhiRel = ut.prepare_TH1D_n("hPhiRel", nbins, phimin, phimax)
ytit = "Events / ({0:.4f})".format(phibin)
xtit = "(#phi_{rec} - #phi_{gen})/#phi_{gen}"
mctree.Draw("(jT0phi-jGenP0phi)/jGenP0phi >> hPhiRel",
strsel) # positive charge
mctree.Draw("(jT1phi-jGenP1phi)/jGenP1phi >>+hPhiRel",
strsel) # add negative charge
x = RooRealVar("x", "x", phimin, phimax)
x.setRange("fitran", fitran[0], fitran[1])
rfPhiRel = RooDataHist("rfPhiRel", "rfPhiRel", RooArgList(x), hPhiRel)
#Breit-Wigner pdf
mean = RooRealVar("mean", "mean", 0., -0.1, 0.1)
sigma = RooRealVar("sigma", "sigma", 0.01, 0., 0.9)
bwpdf = RooBreitWigner("bwpdf", "bwpdf", x, mean, sigma)
res = bwpdf.fitTo(rfPhiRel, rf.Range("fitran"), rf.Save())
#log fit results
ut.log_results(out, ut.log_fit_result(res))
can = ut.box_canvas()
ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.05, 0.03)
frame = x.frame(rf.Bins(nbins), rf.Title(""))
ut.put_frame_yx_tit(frame, ytit, xtit)
rfPhiRel.plotOn(frame, rf.Name("data"))
bwpdf.plotOn(frame, rf.Precision(1e-6), rf.Name("bwpdf"))
frame.Draw()
desc = pdesc(frame, 0.12, 0.93, 0.057)
#x, y, sep
desc.set_text_size(0.03)
desc.itemD("#chi^{2}/ndf", frame.chiSquare("bwpdf", "data", 2), -1, cbw)
desc.prec = 2
desc.fmt = "e"
desc.itemR("mean", mean, cbw)
desc.itemR("#sigma", sigma, cbw)
desc.draw()
leg = ut.make_uo_leg(hPhiRel, 0.5, 0.8, 0.2, 0.2)
#leg.Draw("same")
#print "Entries: ", hPhiRel.GetEntries()
#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))
def plot_rec_gen_track_pt():
#track pT resolution as ( pT_track_rec - pT_track_gen )/pT_track_gen
ptbin = 0.001
ptmin = -0.3
ptmax = 0.1
#generated dielectron pT selection to input data
ptlo = 0.2
pthi = 1
fitran = [-0.15, 0.018]
mmin = 2.8
mmax = 3.2
ccb = rt.kBlue
#output log file
out = open("out.txt", "w")
#log fit parameters
loglist1 = [(x, eval(x)) for x in ["infile_mc", "ptbin", "ptmin", "ptmax"]]
loglist2 = [(x, eval(x))
for x in ["ptlo", "pthi", "fitran", "mmin", "mmax"]]
strlog = ut.make_log_string(loglist1, loglist2)
ut.log_results(out, strlog + "\n")
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
strsel += " && jGenPt>{0:.3f}".format(ptlo)
strsel += " && jGenPt<{0:.3f}".format(pthi)
#strsel = ""
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
hPtTrackRel = ut.prepare_TH1D_n("hPtTrackRel", nbins, ptmin, ptmax)
ytit = "Events / ({0:.3f})".format(ptbin)
xtit = "(#it{p}_{T, rec}^{track} - #it{p}_{T, gen}^{track})/#it{p}_{T, gen}^{track}"
mctree.Draw("(jT0pT-jGenP0pT)/jGenP0pT >> hPtTrackRel",
strsel) # positive charge
mctree.Draw("(jT1pT-jGenP1pT)/jGenP1pT >>+hPtTrackRel",
strsel) # add negative charge
x = RooRealVar("x", "x", ptmin, ptmax)
x.setRange("fitran", fitran[0], fitran[1])
rfPtTrackRel = RooDataHist("rfPtTrackRel", "rfPtTrackRel", RooArgList(x),
hPtTrackRel)
#standard Crystal Ball
mean = RooRealVar("mean", "mean", -0.003, -0.1, 0.1)
sigma = RooRealVar("sigma", "sigma", 0.01, 0., 0.9)
alpha = RooRealVar("alpha", "alpha", 1.2, 0., 10.)
n = RooRealVar("n", "n", 1.3, 0., 20.)
cbpdf = RooCBShape("cbpdf", "cbpdf", x, mean, sigma, alpha, n)
res = cbpdf.fitTo(rfPtTrackRel, rf.Range("fitran"), rf.Save())
#log fit results
ut.log_results(out, ut.log_fit_result(res))
#generate new distribution according to the fit
gROOT.LoadMacro("cb_gen.h")
#Crystal Ball generator, min, max, mean, sigma, alpha, n
#cbgen = rt.cb_gen(-0.18, 0.05, -0.00226, 0.00908, 1.40165, 1.114) # -0.18, 0.05 ptmin, ptmax
cbgen = rt.cb_gen(-0.5, 0.05, -0.00226, 0.00908, 0.2,
2.) # -0.18, 0.05 ptmin, ptmax
hRelGen = ut.prepare_TH1D_n("hRelGen", nbins, ptmin, ptmax)
ut.set_H1D_col(hRelGen, rt.kBlue)
#rt.cb_generate_n(cbgen, hRelGen, int(hPtTrackRel.GetEntries()))
rfRelGen = RooDataHist("rfRelGen", "rfRelGen", RooArgList(x), hRelGen)
#generate distribution with additional smearing applied
hRelSmear = ut.prepare_TH1D_n("hRelSmear", nbins, ptmin, ptmax)
ut.set_H1D_col(hRelSmear, rt.kOrange)
#tcopy = mctree.CopyTree(strsel)
#rt.cb_apply_smear(cbgen, mctree, hRelSmear)
can = ut.box_canvas()
ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.05, 0.03)
frame = x.frame(rf.Bins(nbins), rf.Title(""))
ut.put_frame_yx_tit(frame, ytit, xtit)
rfPtTrackRel.plotOn(frame, rf.Name("data"))
#rfRelGen.plotOn(frame, rf.Name("data"))
cbpdf.plotOn(frame, rf.Precision(1e-6), rf.Name("cbpdf"),
rf.LineColor(ccb))
frame.Draw()
#hRelGen.Draw("e1same")
#hRelSmear.Draw("e1same")
desc = pdesc(frame, 0.2, 0.8, 0.057)
#x, y, sep
desc.set_text_size(0.03)
desc.itemD("#chi^{2}/ndf", frame.chiSquare("cbpdf", "data", 4), -1, ccb)
desc.prec = 5
desc.itemR("mean", mean, ccb)
desc.itemR("#sigma", sigma, ccb)
desc.itemR("#alpha", alpha, ccb)
desc.prec = 3
desc.itemR("#it{n}", n, ccb)
desc.draw()
leg = ut.prepare_leg(0.2, 0.82, 0.21, 0.12, 0.03) # x, y, dx, dy, tsiz
leg.SetMargin(0.05)
leg.AddEntry(0, "#bf{%.1f < #it{p}_{T}^{pair} < %.1f GeV}" % (ptlo, pthi),
"")
leg.Draw("same")
#ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
#nk1 = model3.createNLL(data)
#RooMinuit(nk1).migrad()
#Rk1 = k2.frame()
#nk1.plotOn(Rk1,RooFit.ShiftToZero())
#cRcc = TCanvas("Rcc", "Rcc", 500, 500)
#Rk1.SetMaximum(4.);Rk1.SetMinimum(0)
#Rk1.GetXaxis().SetTitle("nttbar/nmc")
#Rk1.SetTitle("")
#Rk1.Draw()
cR11 = TCanvas("R11", "R", 500, 500)
xframe = x.frame()
data.plotOn(xframe, RooFit.DataError(RooAbsData.SumW2))
model3.paramOn(xframe, RooFit.Layout(0.65, 0.9, 0.9))
model3.plotOn(xframe)
chi2 = xframe.chiSquare(2)
ndof = xframe.GetNbinsX()
print "chi2 = " + str(chi2)
print "ndof = " + str(ndof)
xframe.Draw()
print "k1:" + str(k1.getVal()) + ", err:" + str(
k1.getError()) + ", init:" + str(rttbar)
print "k2:" + str(k2.getVal()) + ", err:" + str(k2.getError())
n_mctotal = n_ttbar + n_background
print "####################"
print "ttbar = " + str(n_ttbar)
def plot_rec_gen_pt_relative():
# relative dielectron pT resolution as ( pT_rec - pT_gen )/pT_gen
ptbin = 0.01
ptmin = -1.2
ptmax = 4
#generated pT selection to input data
ptlo = 0.2
pthi = 1.
fitran = [-0.1, 3]
mmin = 2.8
mmax = 3.2
#output log file
out = open("out.txt", "w")
#log fit parameters
loglist1 = [(x, eval(x)) for x in ["infile_mc", "ptbin", "ptmin", "ptmax"]]
loglist2 = [(x, eval(x))
for x in ["ptlo", "pthi", "fitran", "mmin", "mmax"]]
strlog = ut.make_log_string(loglist1, loglist2)
ut.log_results(out, strlog + "\n")
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
strsel += " && jGenPt>{0:.3f}".format(ptlo)
strsel += " && jGenPt<{0:.3f}".format(pthi)
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
hPtRel = ut.prepare_TH1D("hPtRel", ptbin, ptmin, ptmax)
ytit = "Events / ({0:.3f})".format(ptbin)
xtit = "(#it{p}_{T, rec} - #it{p}_{T, gen})/#it{p}_{T, gen}"
mctree.Draw("(jRecPt-jGenPt)/jGenPt >> hPtRel", strsel)
x = RooRealVar("x", "x", ptmin, ptmax)
x.setRange("fitran", fitran[0], fitran[1])
rfPtRel = RooDataHist("rfPtRel", "rfPtRel", RooArgList(x), hPtRel)
#reversed Crystal Ball
mean = RooRealVar("mean", "mean", 0., -0.1, 0.1)
sigma = RooRealVar("sigma", "sigma", 0.2, 0., 0.9)
alpha = RooRealVar("alpha", "alpha", -1.2, -10., 0.)
n = RooRealVar("n", "n", 1.3, 0., 20.)
cbpdf = RooCBShape("cbpdf", "cbpdf", x, mean, sigma, alpha, n)
res = cbpdf.fitTo(rfPtRel, rf.Range("fitran"), rf.Save())
#log fit results
ut.log_results(out, ut.log_fit_result(res))
can = ut.box_canvas()
ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.05, 0.03)
frame = x.frame(rf.Bins(nbins), rf.Title(""))
ut.put_frame_yx_tit(frame, ytit, xtit)
rfPtRel.plotOn(frame, rf.Name("data"))
cbpdf.plotOn(frame, rf.Precision(1e-6), rf.Name("cbpdf"))
frame.Draw()
desc = pdesc(frame, 0.65, 0.8, 0.057)
#x, y, sep
desc.set_text_size(0.03)
desc.itemD("#chi^{2}/ndf", frame.chiSquare("cbpdf", "data", 4), -1,
rt.kBlue)
desc.prec = 5
desc.itemR("mean", mean, rt.kBlue)
desc.prec = 4
desc.itemR("#sigma", sigma, rt.kBlue)
desc.itemR("#alpha", alpha, rt.kBlue)
desc.prec = 3
desc.itemR("#it{n}", n, rt.kBlue)
desc.draw()
leg = ut.prepare_leg(0.6, 0.82, 0.21, 0.12, 0.03) # x, y, dx, dy, tsiz
leg.SetMargin(0.05)
leg.AddEntry(0, "#bf{%.1f < #it{p}_{T}^{pair} < %.1f GeV}" % (ptlo, pthi),
"")
leg.Draw("same")
#ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
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');
frame1.SetMinimum(0.5)
frame1.GetXaxis().SetTitle('')
frame1.GetXaxis().SetLabelSize(0.0)
frame1.GetYaxis().SetTickLength(0.06)
frame1.Draw()
pad = TPad('pad','pad',0.,0.,1.,1.);
pad.SetTopMargin(0.6);
pad.SetFillColor(0);
pad.SetFillStyle(0);
pad.Draw();
def plot_rec_minus_gen_pt():
#reconstructed pT vs. generated pT for resolution
#distribution range
ptbin = 0.005
ptmin = -0.2
ptmax = 0.4
#generated pT selection to input data
ptlo = 0
pthi = 0.1
#mass selection
mmin = 2.8
mmax = 3.2
#range for the fit
fitran = [-0.02, 0.2]
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
strsel += " && jGenPt>{0:.3f}".format(ptlo)
strsel += " && jGenPt<{0:.3f}".format(pthi)
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
hPtDiff = ut.prepare_TH1D("hPtDiff", ptbin, ptmin, ptmax)
ytit = "Events / ({0:.3f}".format(ptbin) + " GeV)"
xtit = "#it{p}_{T, reconstructed} - #it{p}_{T, generated} (GeV)"
mctree.Draw("jRecPt-jGenPt >> hPtDiff", strsel)
#roofit binned data
x = RooRealVar("x", "x", -1, 1)
x.setRange("fitran", fitran[0], fitran[1])
rfPt = RooDataHist("rfPt", "rfPt", RooArgList(x), hPtDiff)
#reversed Crystal Ball
mean = RooRealVar("mean", "mean", 0., -0.1, 0.1)
sigma = RooRealVar("sigma", "sigma", 0.01, 0., 0.1)
alpha = RooRealVar("alpha", "alpha", -1.046, -10., 0.)
n = RooRealVar("n", "n", 1.403, 0., 20.)
pdf = RooCBShape("pdf", "pdf", x, mean, sigma, alpha, n)
#make the fit
res = pdf.fitTo(rfPt, rf.Range("fitran"), rf.Save())
can = ut.box_canvas()
ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.05, 0.03)
frame = x.frame(rf.Bins(nbins), rf.Title(""))
ut.put_frame_yx_tit(frame, ytit, xtit)
rfPt.plotOn(frame, rf.Name("data"))
pdf.plotOn(frame, rf.Precision(1e-6), rf.Name("pdf"))
frame.Draw()
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
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)
signal.fitTo(roohistSig)
frame = x.frame()
roohistSig.plotOn(frame)
signal.plotOn(frame)
signal.plotOn(frame,RooFit.Components('bkg'),RooFit.LineColor(ROOT.kRed),RooFit.LineWidth(2),RooFit.LineStyle(ROOT.kDashed))
frame.GetXaxis().SetRangeUser(900,4500)
frame.GetXaxis().SetTitle('m_{jj} (GeV)')
frame.Draw()
parsSig = signal.getParameters(roohistSig)
parsSig.setAttribAll('Constant', True)
if fitDat:
# -----------------------------------------
# define parameters for background
NBINS = 180
p1 = RooRealVar('p1','p1',7,1,10)
data_hist1 = RooDataHist('dhist1', 'dhist1', RooArgList(x), hist1)
pdf1 = RooHistPdf('phist1', 'phist1', RooArgSet(x), data_hist1)
pdf1.plotOn(frame, RooFit.LineColor(R.kGreen),
RooFit.Normalization(hist1_events))
# Z = 175 GeV
data_hist2 = RooDataHist('dhist2', 'dhist2', RooArgList(x), hist2)
pdf2 = RooHistPdf('phist2', 'phist2', RooArgSet(x), data_hist2)
pdf2.plotOn(frame, RooFit.LineColor(R.kGreen),
RooFit.Normalization(hist2_events))
# Not to be included in the Moment Morphing (just a check)
data_hist3 = RooDataHist('dhist3', 'dhist3', RooArgList(x), hist3)
pdf3 = RooHistPdf('phist3', 'phist3', RooArgSet(x), data_hist3)
pdf3.plotOn(frame, RooFit.LineColor(R.kBlue),
RooFit.Normalization(hist3_events))
data_hist3.plotOn(frame)
# Create a RooArgList to store pdfs and fill it
pdfs = RooArgList()
pdfs.add(pdf1)
pdfs.add(pdf2)
# Create a TVector and store model mass values in it
masses = [125, 175]
paramVec = R.TVectorD(len(masses))
paramVec[0] = masses[0]
paramVec[1] = masses[1]
# Set up morphing
m = w.factory('m[70,230]')
setting = R.RooMomentMorph.Linear
morph = R.RooMomentMorph('morph', 'morph', m, RooArgList(x), pdfs, paramVec,
def main():
parser = OptionParser()
parser.add_option("-d", "--dir", type="string", dest="outDir", metavar="DIR", default="./",
help="output directory for .png")
(options, args) = parser.parse_args()
if os.path.exists(options.outDir) and options.outDir!="./":
print "Sorry, file ",options.outDir," already exist, choose another name\n"
exit(1)
else:
os.system("mkdir -p "+options.outDir)
"""
Set the style ...
"""
myNewStyle = TStyle("myNewStyle","A better style for my plots")
setStyle(myNewStyle)
TH1F.SetDefaultSumw2(True)
# Histogram range
xlow = 70.
xup = 110.
# Mass range for fit
minM_fit = 75.
maxM_fit = 105.
# Ratio plot range
minR = 0.8
maxR = 1.2
# TLines for ratio plot
line = TLine(minM_fit,1,maxM_fit,1)
line.SetLineWidth(2)
line.SetLineColor(2)
# Canvas
spectrum_height = 0.75
ratio_correction = 1.4
ratio_height = (1-spectrum_height)*ratio_correction
xOffset = 0.08
yOffset = 0.04
cTest = TCanvas("cTest","cTest")
c2 = TCanvas("c2","c2")
c2.SetFillColor(0)
c2.Divide(1,2)
c3 = TCanvas("c3","c3")
c3.SetFillColor(0)
c3.Divide(1,2)
# Files MuScleFit
fDataBefore = TFile("h3_Z_data_beforeCorrection.root")
fDataAfter = TFile("h3_Z_data_afterCorrection.root")
fMcBefore = TFile("h3_Z_mc_beforeCorrection.root")
fMcAfter = TFile("h3_Z_mc_afterCorrection.root")
# Retrieve histograms and fit
hDataBefore = fDataBefore.Get("h1_Z_data")
hDataAfter = fDataAfter.Get("h1_Z_data")
hMcBefore = fMcBefore.Get("h1_Z_mc")
hMcAfter = fMcAfter.Get("h1_Z_mc")
# Identifiers
ids = ["data_before","data_after","mc_before","mc_after"]
# Create histograms dictionary
histos = {}
histos["data_before"] = hDataBefore
histos["data_after"] = hDataAfter
histos["mc_before"] = hMcBefore
histos["mc_after"] = hMcAfter
histosSubtr = {}
# Create parameters dictionary
expPars = {}
signalPars = {}
for i in ids:
# RooFit definitions
## RooRealVars
x = RooRealVar("x","M_{#mu#mu} (GeV)",minM_fit,maxM_fit)
mean = RooRealVar("mean","mean",91.19,87.,94.)
meanCB = RooRealVar("meanCB","meanCB",0.,-10.,10.)
meanCB.setConstant(True)
width = RooRealVar("width","width",2.4952,2.3,2.6)
width.setConstant(True)
sigma = RooRealVar("sigma","sigma",1.3,0.001,3.)
# sigma.setConstant(True)
slope = RooRealVar("slope","slope",-0.1,-1.0,0.)
# slope.setConstant(True)
alpha = RooRealVar("alpha","alpha",1.,0.,30.)
# alpha.setConstant(True)
N = RooRealVar("N","N",2.,0.,100.)
# N.setConstant(True)
fsig = RooRealVar("fsig","fsig",0.9,0.,1.0)
## PDFs
relBW = RooGenericPdf("relBW","relBW","@0/(pow(@0*@0-@1*@1,2) + @2*@2*@0*@0*@0*@0/(@1*@1))",RooArgList(x,mean,width))
CB = RooCBShape("CB","CB",x,meanCB,sigma,alpha,N)
expo = RooExponential("expo","expo",x,slope)
relBWTimesCB = RooFFTConvPdf("relBWTimesCB","relBWTimesCB",x,relBW,CB)
relBWTimesCBPlusExp = RooAddPdf("relBWTimesCBPlusExp","relBWTimesCBPlusExp",relBWTimesCB,expo,fsig)
# Fit
frame = x.frame()
h = histos[i]
# h.Rebin(10)
h.Sumw2()
nbin = h.GetNbinsX()
dh = RooDataHist("dh","dh",RooArgList(x),h)
dh.plotOn(frame)
relBWTimesCBPlusExp.fitTo(dh)
relBWTimesCBPlusExp.plotOn(frame)
relBWTimesCBPlusExp.paramOn(frame)
# Plot
c = TCanvas("c_"+i,"c_"+i)
c.SetFillColor(0)
c.cd()
frame.Draw()
c.SaveAs(options.outDir+"/DimuonWithFit_"+i+".png")
# Extract the result of the fit
expParams = []
expCoef = slope.getValV()
fSig = fsig.getValV()
binLow = h.GetXaxis().FindBin(minM_fit)
binHigh = h.GetXaxis().FindBin(maxM_fit)
nEntries = h.Integral(binLow,binHigh)
expParams = [expCoef,fSig,nEntries,binLow,binHigh]
expPars[i] = expParams
signalParams = [mean.getVal(),width.getVal(),meanCB.getVal(),sigma.getVal(),alpha.getVal(),N.getVal()]
signalPars[i] = signalParams
# Subtract the bkg from the histograms
h_woBkg = h.Clone()
h_bkg = TH1F("h_bkg_"+i,"Histogram of bkg events",nbin,xlow,xup)
h_bkg.Sumw2()
expNorm = (math.fabs(expCoef)*(1-fSig)*nEntries)/(math.exp(expCoef*minM_fit)-math.exp(expCoef*maxM_fit))
for ibin in range(binLow,binHigh):
w = integrateExp(expNorm,expCoef,h_bkg.GetBinLowEdge(ibin),h_bkg.GetBinLowEdge(ibin+1))
h_bkg.SetBinContent(ibin,w)
h_woBkg.Add(h_bkg,-1)
nEvts_woBkg = h_woBkg.Integral(binLow,binHigh)
h_woBkg.Scale(1/nEvts_woBkg)
histosSubtr[i] = h_woBkg
del expParams, c
del relBWTimesCBPlusExp, relBW, CB, relBWTimesCB, expo
del x, mean, width, sigma, fsig, N, alpha, slope, meanCB
del frame, dh, h, h_woBkg, h_bkg
# BEFORE CORRECTIONS
# # RooFit definitions (again, sorry)
# ## RooRealVars
# x = RooRealVar("x","M_{#mu#mu} (GeV)",minM_fit,maxM_fit)
# mean = RooRealVar("mean","mean",91.19)
# meanCB = RooRealVar("meanCB","meanCB",0.)
# width = RooRealVar("width","width",2.4952)
# sigma = RooRealVar("sigma","sigma",1.3)
# alpha = RooRealVar("alpha","alpha",1.)
# N = RooRealVar("N","N",2.)
# ## PDFs (again, sorry)
# relBW = RooGenericPdf("relBW","relBW","@0/(pow(@0*@0-@1*@1,2) + @2*@2*@0*@0*@0*@0/(@1*@1))",RooArgList(x,mean,width))
# CB = RooCBShape("CB","CB",x,meanCB,sigma,alpha,N)
# relBWTimesCB = RooFFTConvPdf("relBWTimesCB","relBWTimesCB",x,relBW,CB)
# Ratio plot after background subtraction
histosSubtr["data_before"].GetXaxis().SetRangeUser(minM_fit,maxM_fit)
histosSubtr["data_before"].GetYaxis().SetRangeUser(0.,histosSubtr["data_before"].GetMaximum()+0.1*histosSubtr["data_before"].GetMaximum())
histosSubtr["data_before"].SetLineColor(1)
histosSubtr["mc_before"].GetXaxis().SetRangeUser(minM_fit,maxM_fit)
if histosSubtr["mc_before"].GetMaximum()>histosSubtr["data_before"].GetMaximum():
histosSubtr["data_before"].GetYaxis().SetRangeUser(0.,histosSubtr["mc_before"].GetMaximum()+0.1*histosSubtr["mc_before"].GetMaximum())
histosSubtr["mc_before"].SetLineColor(2)
## This is the simple overlay of the normalized spectra
# c2.cd(1)
r.SetOwnership(c2, False)
c2_spectrum = c2.GetListOfPrimitives().FindObject("c2_1")
c2_ratio = c2.GetListOfPrimitives().FindObject("c2_2")
c2_spectrum.SetPad(0.+xOffset, (1 - spectrum_height)+yOffset, 1.+xOffset, 1.+yOffset)
c2_ratio.SetPad(0.+xOffset, 0.+yOffset, 1.+xOffset, ratio_height+yOffset)
c2_ratio.SetTopMargin(0)
c2_ratio.SetBottomMargin(0.2)
c2_spectrum.SetLeftMargin(0.12)
c2_spectrum.SetRightMargin(0.15)
c2_ratio.SetLeftMargin(0.12)
c2_ratio.SetRightMargin(0.15)
leg=0
leg = TLegend(0.10,0.75,0.40,0.90)
leg.SetHeader("Before corrections")
leg.SetFillColor(0)
leg.SetTextSize(0.06)
leg.AddEntry(histosSubtr["data_before"],"DATA")
leg.AddEntry(histosSubtr["mc_before"],"MC")
setHistoStyle(histosSubtr["data_before"])
setHistoStyle(histosSubtr["mc_before"])
histosSubtr["data_before"].SetTitle("Dimuon mass spectrum (after background subtraction) data vs. MC")
histosSubtr["data_before"].GetXaxis().SetTitle("M_{#mu#mu} (GeV)")
histosSubtr["data_before"].GetYaxis().SetTitle("Arbitrary units")
histosSubtr["mc_before"].GetXaxis().SetTitle("M_{#mu#mu} (GeV)")
histosSubtr["mc_before"].GetYaxis().SetTitle("Arbitrary units")
c2_spectrum.cd()
# c2_spectrum.SetLogy()
histosSubtr["data_before"].Draw("HIST")
histosSubtr["mc_before"].Draw("HISTsame")
tpt_pars_data = TPaveText(0.13, 0.45, 0.4, 0.59, "NDC")
tpt_pars_data.SetTextSize(0.045)
tpt_pars_data.SetTextFont(42)
tpt_pars_data.SetFillColor(0)
tpt_pars_data.SetBorderSize(0)
tpt_pars_data.SetMargin(0.01)
tpt_pars_data.SetTextAlign(12)
tpt_pars_data.AddText(0.0,0.9,"M^{fit}_{Z,data} = "+str(round(signalPars["data_before"][0],2))+" GeV")
tpt_pars_data.AddText(0.0,0.4,"#sigma_{CB,data} = "+str(round(signalPars["data_before"][3],2))+" GeV")
tpt_pars_data.Draw("same")
tpt_pars_mc = TPaveText(0.13, 0.30, 0.4, 0.44, "NDC")
tpt_pars_mc.SetTextSize(0.045)
tpt_pars_mc.SetTextFont(42)
tpt_pars_mc.SetFillColor(0)
tpt_pars_mc.SetBorderSize(0)
tpt_pars_mc.SetMargin(0.01)
tpt_pars_mc.SetTextAlign(12)
tpt_pars_mc.SetTextColor(2)
tpt_pars_mc.AddText(0.0,0.9,"M^{fit}_{Z,MC} = "+str(round(signalPars["mc_before"][0],2))+" GeV")
tpt_pars_mc.AddText(0.0,0.4,"#sigma_{CB,MC} = "+str(round(signalPars["mc_before"][3],2))+" GeV")
tpt_pars_mc.Draw("same")
leg.Draw("same")
# mean.setVal(signalPars["data_before"][0])
# sigma.setVal(signalPars["data_before"][3])
# alpha.setVal(signalPars["data_before"][4])
# N.setVal(signalPars["data_before"][5])
# dh_data = RooDataHist("dh_data","dh_data",RooArgList(x),histosSubtr["data_before"])
# frame_data = x.frame()
# dh_data.plotOn(frame_data,RooFit.LineColor(1),RooFit.DrawOption("B"))
# # relBWTimesCB.plotOn(frame_data,RooFit.LineColor(1))
# frame_data.Draw()
# mean.setVal(signalPars["mc_before"][0])
# # mean.setVal(97)
# sigma.setVal(signalPars["mc_before"][3])
# alpha.setVal(signalPars["mc_before"][4])
# N.setVal(signalPars["mc_before"][5])
# dh_mc = RooDataHist("dh_mc","dh_mc",RooArgList(x),histosSubtr["mc_before"])
# frame_mc = x.frame()
# # dh_mc.plotOn(frame_mc,RooFit.LineColor(2),RooFit.MarkerColor(2),RooFit.MarkerSize(0.4),RooFit.DrawOption("HIST"))
# # relBWTimesCB.plotOn(frame_mc,RooFit.LineColor(2))
# # frame_mc.Draw("same")
## Ratio histogram
h_Num_woBkg = histosSubtr["data_before"].Clone()
h_Den_woBkg = histosSubtr["mc_before"].Clone()
# h_Num_woBkg.Rebin(10)
# h_Den_woBkg.Rebin(10)
h_Num_woBkg.Divide(h_Den_woBkg)
h_Num_woBkg.GetXaxis().SetRangeUser(minM_fit,maxM_fit)
h_Num_woBkg.GetYaxis().SetRangeUser(minR,maxR)
h_Num_woBkg.GetXaxis().SetTitleSize(0.09)
h_Num_woBkg.GetYaxis().SetTitleSize(0.09)
h_Num_woBkg.GetXaxis().SetLabelSize(0.08)
h_Num_woBkg.GetYaxis().SetLabelSize(0.08)
h_Num_woBkg.GetYaxis().SetTitleOffset(0.45)
## This is the DATA/MC ratio
c2_ratio.cd()
h_Num_woBkg.GetYaxis().SetTitle("DATA/MC Ratio")
h_Num_woBkg.SetTitle("")
# setHistoStyle(h_Num_woBkg)
h_Num_woBkg.SetMarkerStyle(20)
h_Num_woBkg.SetMarkerSize(0.85)
h_Num_woBkg.Draw("E")
line.Draw("same")
c2.SaveAs(options.outDir+"/DimuonAfterBkgSub_beforeCorrections.png")
c2.SaveAs(options.outDir+"/DimuonAfterBkgSub_beforeCorrections.pdf")
c2.SaveAs(options.outDir+"/DimuonAfterBkgSub_beforeCorrections.eps")
del tpt_pars_data, tpt_pars_mc, h_Num_woBkg
# AFTER CORRECTIONS
# # RooFit definitions (again, sorry)
# ## RooRealVars
# x = RooRealVar("x","M_{#mu#mu} (GeV)",minM_fit,maxM_fit)
# mean = RooRealVar("mean","mean",91.19)
# meanCB = RooRealVar("meanCB","meanCB",0.)
# width = RooRealVar("width","width",2.4952)
# sigma = RooRealVar("sigma","sigma",1.3)
# alpha = RooRealVar("alpha","alpha",1.)
# N = RooRealVar("N","N",2.)
# ## PDFs (again, sorry)
# relBW = RooGenericPdf("relBW","relBW","@0/(pow(@0*@0-@1*@1,2) + @2*@2*@0*@0*@0*@0/(@1*@1))",RooArgList(x,mean,width))
# CB = RooCBShape("CB","CB",x,meanCB,sigma,alpha,N)
# relBWTimesCB = RooFFTConvPdf("relBWTimesCB","relBWTimesCB",x,relBW,CB)
# Ratio plot after background subtraction
histosSubtr["data_after"].GetXaxis().SetRangeUser(minM_fit,maxM_fit)
histosSubtr["data_after"].GetYaxis().SetRangeUser(0.,histosSubtr["data_after"].GetMaximum()+0.1*histosSubtr["data_after"].GetMaximum())
histosSubtr["data_after"].SetLineColor(1)
histosSubtr["mc_after"].GetXaxis().SetRangeUser(minM_fit,maxM_fit)
if histosSubtr["mc_after"].GetMaximum()>histosSubtr["data_after"].GetMaximum():
histosSubtr["data_after"].GetYaxis().SetRangeUser(0.,histosSubtr["mc_after"].GetMaximum()+0.1*histosSubtr["mc_after"].GetMaximum())
histosSubtr["mc_after"].SetLineColor(2)
## This is the simple overlay of the normalized spectra
# c3.cd(1)
r.SetOwnership(c3, False)
c3_spectrum = c3.GetListOfPrimitives().FindObject("c3_1")
c3_ratio = c3.GetListOfPrimitives().FindObject("c3_2")
c3_spectrum.SetPad(0.+xOffset, (1 - spectrum_height)+yOffset, 1.+xOffset, 1.+yOffset)
c3_ratio.SetPad(0.+xOffset, 0.+yOffset, 1.+xOffset, ratio_height+yOffset)
c3_ratio.SetTopMargin(0)
c3_ratio.SetBottomMargin(0.2)
c3_spectrum.SetLeftMargin(0.12)
c3_spectrum.SetRightMargin(0.15)
c3_ratio.SetLeftMargin(0.12)
c3_ratio.SetRightMargin(0.15)
leg=0
leg = TLegend(0.10,0.75,0.40,0.90)
leg.SetHeader("After corrections")
leg.SetFillColor(0)
leg.SetTextSize(0.06)
leg.AddEntry(histosSubtr["data_after"],"DATA")
leg.AddEntry(histosSubtr["mc_after"],"MC")
setHistoStyle(histosSubtr["data_after"])
setHistoStyle(histosSubtr["mc_after"])
histosSubtr["data_after"].SetTitle("Dimuon mass spectrum (after background subtraction) data vs. MC")
histosSubtr["data_after"].GetXaxis().SetTitle("M_{#mu#mu} (GeV)")
histosSubtr["data_after"].GetYaxis().SetTitle("Arbitrary units")
histosSubtr["mc_after"].GetXaxis().SetTitle("M_{#mu#mu} (GeV)")
histosSubtr["mc_after"].GetYaxis().SetTitle("Arbitrary units")
c3_spectrum.cd()
# c3_spectrum.SetLogy()
histosSubtr["data_after"].Draw("HIST")
histosSubtr["mc_after"].Draw("HISTsame")
tpt_pars_data = 0
tpt_pars_data = TPaveText(0.13, 0.45, 0.4, 0.59, "NDC")
tpt_pars_data.SetTextSize(0.045)
tpt_pars_data.SetTextFont(42)
tpt_pars_data.SetFillColor(0)
tpt_pars_data.SetBorderSize(0)
tpt_pars_data.SetMargin(0.01)
tpt_pars_data.SetTextAlign(12)
tpt_pars_data.AddText(0.0,0.9,"M^{fit}_{Z,data} = "+str(round(signalPars["data_after"][0],2))+" GeV")
tpt_pars_data.AddText(0.0,0.4,"#sigma_{CB,data} = "+str(round(signalPars["data_after"][3],2))+" GeV")
tpt_pars_data.Draw("same")
tpt_pars_mc = 0
tpt_pars_mc = TPaveText(0.13, 0.30, 0.4, 0.44, "NDC")
tpt_pars_mc.SetTextSize(0.045)
tpt_pars_mc.SetTextFont(42)
tpt_pars_mc.SetFillColor(0)
tpt_pars_mc.SetBorderSize(0)
tpt_pars_mc.SetMargin(0.01)
tpt_pars_mc.SetTextAlign(12)
tpt_pars_mc.SetTextColor(2)
tpt_pars_mc.AddText(0.0,0.9,"M^{fit}_{Z,MC} = "+str(round(signalPars["mc_after"][0],2))+" GeV")
tpt_pars_mc.AddText(0.0,0.4,"#sigma_{CB,MC} = "+str(round(signalPars["mc_after"][3],2))+" GeV")
tpt_pars_mc.Draw("same")
leg.Draw("same")
# mean.setVal(signalPars["data_after"][0])
# sigma.setVal(signalPars["data_after"][3])
# alpha.setVal(signalPars["data_after"][4])
# N.setVal(signalPars["data_after"][5])
# dh_data = RooDataHist("dh_data","dh_data",RooArgList(x),histosSubtr["data_after"])
# frame_data = x.frame()
# dh_data.plotOn(frame_data,RooFit.LineColor(1),RooFit.DrawOption("B"))
# # relBWTimesCB.plotOn(frame_data,RooFit.LineColor(1))
# frame_data.Draw()
# mean.setVal(signalPars["mc_after"][0])
# # mean.setVal(97)
# sigma.setVal(signalPars["mc_after"][3])
# alpha.setVal(signalPars["mc_after"][4])
# N.setVal(signalPars["mc_after"][5])
# dh_mc = RooDataHist("dh_mc","dh_mc",RooArgList(x),histosSubtr["mc_after"])
# frame_mc = x.frame()
# # dh_mc.plotOn(frame_mc,RooFit.LineColor(2),RooFit.MarkerColor(2),RooFit.MarkerSize(0.4),RooFit.DrawOption("HIST"))
# # relBWTimesCB.plotOn(frame_mc,RooFit.LineColor(2))
# # frame_mc.Draw("same")
## Ratio histogram
h_Num_woBkg = histosSubtr["data_after"].Clone()
h_Den_woBkg = histosSubtr["mc_after"].Clone()
# h_Num_woBkg.Rebin(10)
# h_Den_woBkg.Rebin(10)
h_Num_woBkg.Divide(h_Den_woBkg)
h_Num_woBkg.GetXaxis().SetRangeUser(minM_fit,maxM_fit)
h_Num_woBkg.GetYaxis().SetRangeUser(minR,maxR)
h_Num_woBkg.GetXaxis().SetTitleSize(0.09)
h_Num_woBkg.GetYaxis().SetTitleSize(0.09)
h_Num_woBkg.GetXaxis().SetLabelSize(0.08)
h_Num_woBkg.GetYaxis().SetLabelSize(0.08)
h_Num_woBkg.GetYaxis().SetTitleOffset(0.45)
## This is the DATA/MC ratio
c3_ratio.cd()
h_Num_woBkg.GetYaxis().SetTitle("DATA/MC Ratio")
h_Num_woBkg.SetTitle("")
# setHistoStyle(h_Num_woBkg)
h_Num_woBkg.SetMarkerStyle(20)
h_Num_woBkg.SetMarkerSize(0.85)
h_Num_woBkg.Draw("E")
line.Draw("same")
c3.SaveAs(options.outDir+"/DimuonAfterBkgSub_afterCorrections.png")
c3.SaveAs(options.outDir+"/DimuonAfterBkgSub_afterCorrections.pdf")
c3.SaveAs(options.outDir+"/DimuonAfterBkgSub_afterCorrections.eps")
canvas.Print("track_parameters.pdf[")
#--- Fit the D0 plots ---#
#------------------------#
track_d0 = RooRealVar("track_d0", "D0 (mm)", -1.5, 1.5)
track_d0_mean = RooRealVar("track_d0_mean", "Track D0 Mean", 0, -1.5, 1.5)
track_d0_sigma = RooRealVar("track_d0_sigma", "Track D0 Sigma", .5, 0, 2)
track_d0_gaussian = RooGaussModel("track_d0_gaussian", "Track D0 Gaussian",
track_d0, track_d0_mean, track_d0_sigma)
track_d0_data = RooDataHist("track_d0_data", "Track D0 Data",
RooArgList(track_d0), h_track_d0)
track_d0_plot = track_d0.frame()
track_d0_plot.SetTitle("")
track_d0_data.plotOn(track_d0_plot, RooFit.MarkerColor(kAzure + 2),
RooFit.LineColor(kAzure + 2))
track_d0_gaussian.fitTo(track_d0_data)
track_d0_gaussian.plotOn(track_d0_plot, RooFit.LineColor(kAzure + 2))
gbl_track_d0 = RooRealVar("gbl_track_d0", "D0 (mm)", -1.5, 1.5)
gbl_track_d0_mean = RooRealVar("gbl_track_d0_mean", "Track D0 Mean", 0, -1.5,
1.5)
gbl_track_d0_sigma = RooRealVar("gbl_track_d0_sigma", "Track D0 Sigma", .5, 0,
2)
gbl_track_d0_gaussian = RooGaussModel("gbl_track_d0_gaussian",
"Track D0 Gaussian", gbl_track_d0,
gbl_track_d0_mean, gbl_track_d0_sigma)
gbl_track_d0_data = RooDataHist("track_d0_data", "Track D0 Data",
RooArgList(gbl_track_d0), h_gbl_track_d0)
def bw_fit(ecm, infile, outdir, reconstruction):
"""Breit-Wigner fit of the Mw distribution"""
file_ = TFile(infile, "r")
file_.cd()
mass_ = 'h_mW2'
h_mass = gDirectory.Get(mass_)
scale = h_mass.GetXaxis().GetBinWidth(1) / (h_mass.Integral("width"))
h_mass.Scale(scale)
mass_min = 40
mass_max = 120
mass = RooRealVar("Dijet mass", "Dijet mass", mass_min, mass_max, "GeV")
# parameters for gaussian function
gaus_sig = RooRealVar("#sigma_{G}", "Core Width", 1., 0.5, 10., "GeV")
# gaus_sig.setConstant()
# parameters for Crystall Ball distribution
m_ = RooRealVar("#Delta m", "Bias", 0., -3., 3., "GeV")
sigma = RooRealVar("#sigma", "Width", 1.7, 0., 10., "GeV")
alpha = RooRealVar("#alpha", "Cut", -0.15, -5., 0.)
n = RooRealVar("n", "Power", 2.4, 0.5, 10.)
alpha.setConstant()
n.setConstant()
# Parameters for Breit-Wigner distribution
m_res = RooRealVar("M_{W}", "W boson mass", 80.385, 80.0, 81.0, "GeV")
width = RooRealVar("#Gamma", "W width", 2.085, 1.5, 2.5, "GeV")
m_res.setConstant()
width.setConstant()
# Cristall-Ball lineshape
resG = RooGaussian("resG", "Gaussian distribution", mass, m_, gaus_sig)
resCB = RooCBShape("resCB", "Crystal Ball distribution", mass, m_, sigma,
alpha, n)
fracG = RooRealVar("f_{G}", "Gaussian Fraction", 0., 0., 1.)
res = RooAddPdf("res", "Resolution Model", resG, resCB, fracG)
# Breit-wigner lineshape
bw = RooBreitWigner("bw", "Breit-Wigner distribution", mass, m_res, width)
# Convolution
bw_CB_conv = RooFFTConvPdf("bw_CB_conv", "Convolution", mass, bw, res)
# Background p.d.f
bgtau = RooRealVar("a_{BG}", "Backgroung Shape", -0.15, -1.0, 0.0,
"1/GeV/c^{2}")
bg = RooExponential("bg", "Background distribution", mass, bgtau)
# Fit model
nentries = h_mass.GetEntries()
nsigmin = 0.5 * nentries
nsigmean = 1.0 * nentries
nsigmax = 1.05 * nentries
nbkgmean = 0.01 * nentries
nbkgmax = 0.1 * nentries
nsig = RooRealVar("N_S", "#signal events", nsigmean, nsigmin, nsigmax)
nbkg = RooRealVar("N_B", "#background events", nbkgmean, 0, nbkgmax)
model = RooAddPdf("model", "W mass fit", RooArgList(bw_CB_conv, bg),
RooArgList(nsig, nbkg))
###### FIT
c_name = "c_ " + mass_ + "_" + str(ecm) + "_" + reconstruction + "_fit"
c_mass_fit = TCanvas(
c_name,
'Fit of the reconstructed mass distribution with a convolution of Breit-Wigner and Crystal-Ball',
700, 500)
c_mass_fit.cd()
data = RooDataHist("data", "data", RooArgList(mass), h_mass)
frame = mass.frame()
data.plotOn(frame)
model.fitTo(data, RooFit.Optimize(0))
model.plotOn(frame)
model.paramOn(frame, RooFit.Layout(0.6, 0.90, 0.85))
frame.Draw()
# norm = h_mass.Integral()/bw_CB_conv.createIntegral(RooArgSet(mass)).getValV()
# m = m_.getValV()*norm
# s = sigma.getValV()*norm
m = m_.getVal()
s = sigma.getVal()
print("\n\n----------------------------------------------")
print(" Fit results :")
print(" Bias to apply on mW : {} GeV".format(m))
print(" Mw = {} +/- {} GeV".format((m + 80.385), s))
print("--------------------------------------------------")
raw_input("")
c_mass_fit.Print("{}fit/fit_{}_{}_{}.pdf".format(outdir, mass_, ecm,
reconstruction))
# write into an output file and close the file
outfilename = "{}fit/fit_{}_{}.root".format(outdir, mass_, ecm)
outfile = TFile(outfilename, "UPDATE")
c_mass_fit.Write("", TObject.kOverwrite)
outfile.Write()
outfile.Close()
gStyle.SetPadTickX(1)
gStyle.SetFrameLineWidth(2)
can = ut.box_canvas()
gPad.SetRightMargin(0.02)
gPad.SetTopMargin(0.04)
gPad.SetBottomMargin(0.09)
gPad.SetLeftMargin(0.11)
frame = m.frame(rf.Bins(nbins), rf.Title(""))
frame.SetTitle("")
frame.GetXaxis().SetTitleOffset(1.2)
frame.GetYaxis().SetTitleOffset(1.6)
if binned == True:
dataH.plotOn(frame, rf.Name("data"))
else:
data.plotOn(frame, rf.Name("data"))
cb.plotOn(frame, rf.Precision(1e-6), rf.Name("CrystalBall"),
rf.LineColor(ccb))
frame.Draw()
frame.SetXTitle("#it{m}_{e^{+}e^{-}} (GeV)")
frame.SetYTitle("Dielectron counts / ({0:.0f} MeV)".format(1000. * mbin))
#fit parameters on the plot
desc = pdesc(frame, 0.18, 0.8, 0.057)
#x, y, sep
desc.set_text_size(0.03)
def plot_rec_minus_gen_pt2():
#reconstructed pT^2 vs. generated pT^2 for resolution
#distribution range
ptbin = 0.001
ptmin = -0.1
ptmax = 0.15
#generated pT^2 selection to input data
ptlo = 0.04
pthi = 0.1
#mass selection
mmin = 2.8
mmax = 3.2
fitran = [-0.003, 0.05]
#fitran = [-0.003, 0.003]
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
strsel += " && (jGenPt*jGenPt)>{0:.3f}".format(ptlo)
strsel += " && (jGenPt*jGenPt)<{0:.3f}".format(pthi)
print strsel
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
hPt2 = ut.prepare_TH1D("hPt2", ptbin, ptmin, ptmax)
ytit = "Events / ({0:.3f}".format(ptbin) + " GeV^{2})"
xtit = "#it{p}_{T, reconstructed}^{2} - #it{p}_{T, generated}^{2} (GeV^{2})"
ut.put_yx_tit(hPt2, ytit, xtit)
draw = "(jRecPt*jRecPt)-(jGenPt*jGenPt)"
mctree.Draw(draw + " >> hPt2", strsel)
#roofit binned data
x = RooRealVar("x", "x", -1, 1)
dataH = RooDataHist("dataH", "dataH", RooArgList(x), hPt2)
x.setRange("fitran", fitran[0], fitran[1])
#reversed Crystal Ball
mean = RooRealVar("mean", "mean", 0., -0.1, 0.1)
sigma = RooRealVar("sigma", "sigma", 0.0011, 0., 0.1)
alpha = RooRealVar("alpha", "alpha", -1.046, -10., 0.)
n = RooRealVar("n", "n", 1.403, 0., 20.)
pdf = RooCBShape("pdf", "pdf", x, mean, sigma, alpha, n)
#gaus = RooGaussian("gaus", "gaus", x, mean, sigma)
#make the fit
#res = pdf.fitTo(dataH, rf.Range("fitran"), rf.Save())
#res = gaus.fitTo(dataH, rf.Range("fitran"), rf.Save())
can = ut.box_canvas()
ut.set_margin_lbtr(gPad, 0.12, 0.1, 0.015, 0.03)
frame = x.frame(rf.Bins(nbins), rf.Title(""))
frame.SetTitle("")
frame.SetYTitle(ytit)
frame.SetXTitle(xtit)
frame.GetXaxis().SetTitleOffset(1.2)
frame.GetYaxis().SetTitleOffset(1.7)
dataH.plotOn(frame, rf.Name("data"))
pdf.plotOn(frame, rf.Precision(1e-6), rf.Name("pdf"))
#gaus.plotOn(frame, rf.Precision(1e-6), rf.Name("gaus"))
frame.Draw()
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def fitWPeak():
# Get histograms from file
mcHist = 0
with root_open( inputFile, 'read' ) as file:
gROOT.cd()
mcHist = file.Get(inputHistogram).Clone('histToFit')
# mcHist = file.Get(inputHistogram).GetStack().Last().Clone('histToFit')
# Data hist gone out of scope?
print mcHist
# Import the data to fit
# Declare variables x,mean,sigma with associated name, title, initial value and allowed range
x = RooRealVar("M(jj)","M(jj)",40,180)
histToFit = RooDataHist('histToFit', 'histToFit', RooArgList( x ), RooFit.Import( mcHist ) )
frame = x.frame(RooFit.Title("E Plus Jets"))
histToFit.plotOn( frame )
# Setup fit function
fitFunction = None
print fitFunction
if whatToFit == 'realLife':
# Stuff for gauss
mg = RooRealVar("mean","mean of gaussian",86,50,120)
sg = RooRealVar("sigma","width of gaussian",10,0,50)
gauss = RooGaussian("gauss","gaussian PDF",x,mg,sg)
CBmean = RooRealVar("CBmean", "CBmean",110, 60, 200)
CBsigma = RooRealVar("CBsigma", "CBsigma",40, 20, 100)
CBalpha = RooRealVar("CBalpha", "CBalpha", -0.5, -20., 0.)
# CBalpha = RooRealVar("CBalpha", "CBalpha", 10, 0., 20.)
CBn = RooRealVar("CBn", "CBn", 1., 0., 20.)
crystalBall = RooCBShape("crystalBall","Crystal Ball resolution model", x, CBmean, CBsigma, CBalpha, CBn)
fracGauss = RooRealVar("fracGauss", "fracGauss", 0.4, 0, 1)
gaussPlusCrystalBall = RooAddPdf("gaussPlusCrystalBall", "Gauss plus Crystal Ball", RooArgList(gauss, crystalBall), RooArgList( fracGauss ) )
fitFunction = gaussPlusCrystalBall
elif whatToFit == 'partons':
mg = RooRealVar("mean","mean of gaussian",86,50,120)
sg = RooRealVar("sigma","width of gaussian",10,0,50)
breitWigner = RooBreitWigner('bw', 'bw', x, mg, sg)
fitFunction = breitWigner
elif whatToFit == 'genJetsFromPartons':
# mg = RooRealVar("mean","mean of gaussian",86,50,120)
# sg = RooRealVar("sigma","width of gaussian",10,0,50)
# breitWigner = RooBreitWigner('bw', 'bw', x, mg, sg)
# fitFunction = breitWigner
# mg = RooRealVar("mean","mean of gaussian",86,50,120)
# sg = RooRealVar("sigma","width of gaussian",1,0,20)
# width = RooRealVar("width","width of gaussian",5,0,50)
# voigtian = RooVoigtian("voigt","voigt",x,mg,sg,width);
# fitFunction = voigtian
mg = RooRealVar("mean","mean of gaussian",86,50,120)
sg = RooRealVar("sigma","width of gaussian",10,0,50)
gauss = RooGaussian("gauss","gaussian PDF",x,mg,sg)
fitFunction = gauss
print fitFunction
# # Fit pdf to data
fitFunction.fitTo(histToFit)
# Plot histogram being fitted
histToFit.plotOn(frame)
# Plot fit functions and components
fitFunction.plotOn(frame, RooFit.LineColor(kRed))
print 'Chi square with 7 : ',frame.chiSquare(7)
print frame.chiSquare()
print fitFunction.getParameters(histToFit).selectByAttrib('Constant', kFALSE).getSize()
toPlot = RooArgSet(crystalBall)
fitFunction.plotOn(frame, RooFit.Components(toPlot), RooFit.LineStyle(kDashed), RooFit.LineColor(kRed))
toPlot = RooArgSet(gauss)
fitFunction.plotOn(frame, RooFit.Components(toPlot), RooFit.LineStyle(kDashed), RooFit.LineColor(kBlue))
fitFunction.paramOn(frame,RooFit.Layout(0.55, 0.9, 0.9)) ;
# Print values of mean and sigma (that now reflect fitted values and errors)
mg.Print()
sg.Print()
# CBmean.Print()
# CBsigma.Print()
# CBalpha.Print()
# CBn.Print()
# fracGauss.Print()
# # Draw frame on a canvas
c = TCanvas("WMass","WMass",800,400)
gPad.SetLeftMargin(0.15)
frame.GetYaxis().SetTitleOffset(1.6)
frame.Draw()
gPad.Update()
c.Print('EPlusJets_mjj_fit.pdf')
raw_input()
inH = inF.Get('lbtkCombBKG')
datahist = RooDataHist('histogram', 'histogram', RooArgList(mass), inH)
# create target PDF.
#space.factory('EXPR::cPDF( "( exp(-1.*(mass-mShift)/(cPar1+cPar2)) - exp(-1.*(mass-mShift)/cPar1) )", mass, mShift[4.8,0.1,10.0], cPar1[0.44,0.001,100.],cPar2[0.0025,0.0000001,10.] )')
space.factory(
'EXPR::cPDF( "( exp(-1.*(mass-mShift)/(cPar1+cPar2)) - exp(-1.*(mass-mShift)/cPar1) )", mass, mShift[4.8,0.1,10.0], cPar1[0.44,0.001,100.],cPar2[0.0025,0.0000001,10.] )'
)
myPDF = space.pdf('cPDF')
myPDF.fitTo(datahist)
myPDF.fitTo(datahist)
myPDF.fitTo(datahist)
myFrame = mass.frame()
datahist.plotOn(myFrame)
myPDF.plotOn(myFrame)
canv = TCanvas('c1', 'c1', 1600, 1000)
myFrame.Draw()
canv.SaveAs('store_fig/hout_simpleFit_lbDist_from2016Data.png')
canv.SaveAs('store_fig/C_hout_simpleFit_lbDist_from2016Data.C')
# fit lbtkMass in 2016Data end }}}
## fit lbtkMass in Lb MC {{{
##space.factory('lbtkMass[5.1,7.]')
#space.factory('lbtkMass[5.5,5.7]')
#mass=space.var('lbtkMass')
#
#inN=inF.Get('LbTk')
#dataset=RooDataSet('dataset','dataset',inN,RooArgSet(mass))
#
def RooFitHist(inputhist,title='title',path='.'):
# RooFit.gErrorIgnoreLevel = RooFit.kInfo # <6.02
# RooFit.SetSilentMode()# >6.02
# RooMsgService().instance().SetSilentMode(kTRUE)
fitbinning=array('d')
binwidth=200
#NBins=(14000/binwidth) - ( (1040/binwidth) + 1 ) Mjj
NBins=(8000/binwidth) - ( (200/binwidth)+1 )#pT
for i in range(NBins+1):
fitbinning.append(210+i*binwidth)# Mjj 1050
# print(fitbinning)
#import numpy as np
#fitbinning=np.linspace(0,8000,81)
hist=inputhist.Rebin(NBins,"fit parameter",fitbinning)
#hist=inputhist.Rebin(80,"fit parameter", fitbinning)
#meanstart=hist.GetBinCenter(2000)
meanstart=hist.GetBinCenter(hist.GetMaximumBin())#maximum
sigmastart=hist.GetRMS()
#sigmastart=3000
print('meanstart:',meanstart,'sigmastart:',sigmastart)
# inputhist.Draw()
# hist.Draw()
# hold=raw_input('press enter to exit.')
gStyle.SetOptFit(1111)
gStyle.SetOptTitle(0)
RooFit.SumW2Error(kTRUE)
RooFit.Extended(kTRUE)
# RooDataHist::adjustBinning(dh): fit range of variable mjj expanded to nearest bin boundaries: [1050,13850] --> [1050,13850]
mjj=RooRealVar('mjj','P_{T-AK8}',fitbinning[0],fitbinning[len(fitbinning)-1],'GeV')
mjjral=RooArgList(mjj)
dh=RooDataHist('dh','dh',mjjral,RooFit.Import(hist))
#shape.fitTo(dh,RooFit.Range("FitRange"),RooFit.Extended(True),RooFit.SumW2Error(False))
shapes={}
#Gaussian not really
# 3rd, 4th and 5th arguments are: (starting value, minimum possible value, maximum possible value) -- not goot
gaussmean = RooRealVar('#mu_{gauss}','mass mean value',meanstart,0,2*meanstart)
gausssigma= RooRealVar('#sigma_{gauss}','mass resolution',sigmastart,0,2*meanstart)
gauss=RooGaussian('gauss','gauss',mjj,gaussmean,gausssigma)
shapes.update({'Gauss':gauss})
#poisson
poissonmean = RooRealVar('#mu_{poisson}', 'pT mean value', meanstart,0,2*meanstart)
poissonsigma = RooRealVar('#sigma_{poisson]', 'pT resolution', sigmastart, 0, 2*sigmastart)
poisson = RooPoisson('poisson', 'poisson', mjj, poissonmean, False)
shapes.update({'Poisson': poisson})
#Landau -- not good
landaumean=RooRealVar('#mu_{landau}','mean landau',meanstart,0,2*meanstart)
landausigma= RooRealVar('#sigma_{landau}','mass resolution',sigmastart,0,2*sigmastart)#bzw8
landau=RooLandau('landau','landau',mjj,landaumean,landausigma)
shapes.update({'Landau':landau})
#CrystalBall -> this is close to be good but matrix error :(
mean = RooRealVar('#mu','mean',meanstart,0,2*meanstart)
sigma= RooRealVar('#sigma','sigma',sigmastart,0,2*sigmastart)
alpha=RooRealVar('#alpha','Gaussian tail',-1000,0)
n=RooRealVar('n','Normalization',-1000,1000)
cbshape=RooCBShape('cbshape','crystalball PDF',mjj,mean,sigma,alpha,n)
shapes.update({'CrystalBall':cbshape})
#Voigt ---pff
voigtmean = RooRealVar('#mu','mass mean value',meanstart,0,2*meanstart)
voigtwidth = RooRealVar('#gamma','width of voigt',0,100)
voigtsigma= RooRealVar('#sigma','mass resolution',sigmastart,0,150)
voigt=RooVoigtian('voigt','voigt',mjj,voigtmean,voigtwidth,voigtsigma)
shapes.update({'Voigt':voigt})
#BreitWigner--worst
bwmean = RooRealVar('#mu','mass mean value',meanstart,0,2*meanstart)
bwwidth = RooRealVar('#sigma','width of bw',sigmastart,100, 150)
bw=RooBreitWigner('bw','bw',mjj,bwmean,bwwidth)
shapes.update({'BreitWigner':bw})
#Logistics
#logisticsmean=RooRealVar('#mu_{logistics}','mean logistics',meanstart,0,2*meanstart)
#logisticssigma= RooRealVar('#sigma_{logistics}','mass resolution',sigmastart,0,2*sigmastart)
#logistics=RooLogistics('logistics','logistics',mjj,logisticsmean,logisticssigma)
#shapes.update({'Logistics':logistics})
#ExpAndGauss
expgaussmean=RooRealVar('#mu_{expgauss}','mean expgauss',meanstart,490,900)
expgausssigma= RooRealVar('#sigma_{expgauss}','mass resolution',sigmastart,20,3*sigmastart)
expgausstrans= RooRealVar('trans','trans',0,1000)
ExpAndGauss=RooExpAndGauss('expgauss','expgauss',mjj,expgaussmean,expgausssigma,expgausstrans)
shapes.update({'ExpAndGauss':ExpAndGauss})
#Exp
#expmean=RooRealVar('')
#BifurGauss -bad
BifurGaussmean=RooRealVar('#mu_{BifurGauss}','mean BifurGauss',meanstart,0,2*meanstart)
BifurGausslsigma= RooRealVar('#sigma_{left}','mass resolution',sigmastart,200,2*sigmastart)#2*sigmastart
BifurGaussrsigma= RooRealVar('#sigma_{right}','mass resolution',sigmastart,200,2*sigmastart)
BifurGauss=RooBifurGauss('BifurGauss','BifurGauss',mjj,BifurGaussmean,BifurGausslsigma,BifurGaussrsigma)
shapes.update({'BifurGauss':BifurGauss})
#Chebychev -nope
Chebychev1=RooRealVar('c0','Chebychev0',-1000,1000)
Chebychev2= RooRealVar('c1','Chebychev1',-1000,1000)
Chebychev3= RooRealVar('c2','Chebychev2',2,-1000,1000)
Chebychev=RooChebychev('Chebychev','Chebychev',mjj,RooArgList(Chebychev1,Chebychev2,Chebychev3))
shapes.update({'Chebychev':Chebychev})
#Polynomial -nope
Polynomial1=RooRealVar('Polynomial1','Polynomial1',100,0,1000)
Polynomial2= RooRealVar('Polynomial2','Polynomial2',100,0,1000)
Polynomial=RooPolynomial('Polynomial','Polynomial',mjj,RooArgList(Polynomial1,Polynomial2))
shapes.update({'Polynomial':Polynomial})
#pareto
#___________________________________________________________We will see
#Convolutions
#-> use bin > 1000 for better accuracy -----cyclic trouble
#-> Convolution depends on order!!! RooFFTConvPdf the first p.d.f. is the theory model and that the second p.d.f. is the resolution model
#
#LandauGauss Convolution - really bad
landaugauss=RooFFTConvPdf('landaugauss','landau x gauss',mjj,landau, gauss)
#landaugauss.setBufferFraction(126)
shapes.update({'LandauGauss':landaugauss})
#GaussLandau Convolution -> Better but NOT posdef. ...but for 100 it is
gausslandau=RooFFTConvPdf('gausslandau','gauss x landau ',mjj,gauss,landau)
#gausslandau.setBufferFraction(126)
shapes.update({'GaussLandau':gausslandau})
#CrystalBallLandau Convolution cbshape x landau looks better -> status failed
crystlandau=RooFFTConvPdf('crystallandau','cbshape x landau', mjj, landau, cbshape)
crystlandau.setBufferFraction(39)
shapes.update({'CrystLandau': crystlandau})
#BifurGaussLandau Convolution -> Better in look, NO matrix error for Binwidth 200
BifurGaussLandau=RooFFTConvPdf('bifurgausslandau','landau x bifurgauss',mjj,landau, BifurGauss)
BifurGaussLandau.setBufferFraction(39) #against over cycling
shapes.update({'BifurGaussLandau':BifurGaussLandau})
#CrystalGauss Convolution looks better -> status failed
crystgauss=RooFFTConvPdf('crystalgauss','cbshape x gauss', mjj, cbshape, gauss)
#crystgauss.setBufferFraction(39)
shapes.update({'CrystGauss': crystgauss})
#BreitWignerLandau Convolution (Breitwigner = Lorentz)-> status OK....
BreitWignerLandau=RooFFTConvPdf('breitwignerlandau','breitwigner x landau',mjj,landau,bw,3)
#BreitWignerLandau.setBufferFraction(48) #setBufferFraction(fraction of the sampling array size) ->cyclic behaviour fix
#crystgauss.setShift(0,0)
#s1 and s2 are the amounts by which the sampling ranges for pdf's are shifted respectively
#(0,-(xmin+xmax)/2) replicates the default behavior
#(0,0) disables the shifting feature altogether
shapes.update({'BreitWignerLandau':BreitWignerLandau})
for fname in ['ExpAndGauss']:
plottitle='%s Fit of %s'%(fname,title)
shape=shapes[fname]
# shape.fitTo(dh,RooFit.Range("FitRange"),RooFit.SumW2Error(True))
#shape.fitTo(dh,RooFit.Extended(True),RooFit.SumW2Error(True))
mjj.setRange("FitRange",500,4000)#tried
shape.fitTo(dh,RooFit.Range("FitRange"),RooFit.Extended(False),RooFit.SumW2Error(True))
frame=mjj.frame(RooFit.Title(plottitle))
#frame.GetYaxis().SetTitleOffset(2)
dh.plotOn(frame,RooFit.MarkerStyle(4))
shape.plotOn(frame,RooFit.LineColor(2))
ndof=dh.numEntries()-3
print ('ndof', ndof)
#chiSquare legend
chi2 = frame.chiSquare()#there are 2 chiSquare. the 2cond returns chi2/ndf /// \return \f$ \chi^2 / \mathrm{ndf} \f$
print ('chi2', chi2)
probChi2 = TMath.Prob(chi2*ndof, ndof)# why chi2*ndof ?! makes no sense to me
#Double_t Prob(Double_t chi2, Int_t ndf)
#Computation of the probability for a certain Chi-squared (chi2)
#and number of degrees of freedom (ndf).
#P(a,x) represents the probability that the observed Chi-squared
#for a correct model should be less than the value chi2.
#The returned probability corresponds to 1-P(a,x), !!!!
#which denotes the probability that an observed Chi-squared exceeds
#the value chi2 by chance, even for a correct model.
#--- NvE 14-nov-1998 UU-SAP Utrecht
#probChi2=TMath.Prob(chi2, ndof)
chi2 = round(chi2,2)
#probChi2 = round(probChi2,2)
leg = TLegend(0.5,0.5,0.5,0.65)#0.9
leg.SetBorderSize(0)
leg.SetFillStyle(0)
shape.paramOn(frame, RooFit.Layout(0.5,0.9,0.9))
leg.AddEntry(0,'#chi^{2} ='+str(chi2),'')
leg.AddEntry(0,'Prob #chi^{2} = '+str(probChi2),'')
leg.SetTextSize(0.04)
frame.addObject(leg)
canv=TCanvas(plottitle,plottitle,700,700)
canv.SetLogy()
canv.SetLeftMargin(0.20)
canv.cd()
frame.SetMaximum(10**(1))
frame.SetMinimum(10**(-11))#from -3 -> -6
frame.Draw()
#canv.Print(path+'/%s__%sS2MoreLessY.pdf'%(title,fname))
raw_input('press enter to continue')
return chi2
model.SetParameter(2, 0.01)
hist.Fit(model)
"""
x = RooRealVar("x", "x", -1000.0, 1000.0)
roodata = RooDataHist("roodata", "equity dataset", RooArgList(x), hist)
frame = x.frame()
mass = RooRealVar("mass", "mass", 0.0, -10.0, 10.0)
width = RooRealVar("width", "width", 0.01, -10.0, 10.0)
s = RooRealVar("s", "s", 0.005, -10.0, 10.0)
#model = RooGaussian("gaus", "gaus", x, mass, width)
#model = RooBreitWigner("bw", "bw", x, mass, width)
model = RooVoigtian("voigt", "voigt", x, mass, width, s)
fit_result = model.fitTo(roodata, RooFit.Save())
roodata.plotOn(frame)
#roodata.statOn(frame)
model.plotOn(frame)
model.paramOn(frame, roodata)
frame.Draw()
chisq = frame.chiSquare()
ndf = n_bins
print "------> Fit Quality:", TMath.Prob(chisq, ndf)
canv.Update()
canv.SaveAs("%s.png" % name[i])
del hist
def rf501_simultaneouspdf():
signal_1, bkg_1, signal_2, bkg_2 = get_templates()
# C r e a t e m o d e l f o r p h y s i c s s a m p l e
# -------------------------------------------------------------
# Create observables
x = RooRealVar( "x", "x", 0, 200 )
x.setBins(n_bins)
nsig = RooRealVar( "nsig", "#signal events", N_signal_obs, 0., 2*N_data )
nbkg = RooRealVar( "nbkg", "#background events", N_bkg1_obs, 0., 2*N_data )
# Construct signal pdf
# mean = RooRealVar( "mean", "mean", mu4, 40, 200 )
# sigma = RooRealVar( "sigma", "sigma", sigma4, 0.1, 20 )
# gx = RooGaussian( "gx", "gx", x, mean, sigma )
roofit_signal_1 = RooDataHist( 'signal_1', 'signal_1', RooArgList(x), signal_1 )
signal_1_pdf = RooHistPdf ( 'signal_1_pdf' , 'signal_1_pdf', RooArgSet(x), roofit_signal_1)
# Construct background pdf
# mean_bkg = RooRealVar( "mean_bkg", "mean_bkg", mu3, 40, 200 )
# sigma_bkg = RooRealVar( "sigma_bkg", "sigma_bkg", sigma3, 0.1, 20 )
# px = RooGaussian( "px", "px", x, mean_bkg, sigma_bkg )
roofit_bkg_1 = RooDataHist( 'bkg_1', 'bkg_1', RooArgList(x), bkg_1 )
bkg_1_pdf = RooHistPdf ( 'bkg_1_pdf' , 'bkg_1_pdf', RooArgSet(x), roofit_bkg_1)
# Construct composite pdf
model = RooAddPdf( "model", "model", RooArgList( signal_1_pdf, bkg_1_pdf ), RooArgList( nsig, nbkg ) )
# C r e a t e m o d e l f o r c o n t r o l s a m p l e
# --------------------------------------------------------------
# Construct signal pdf.
# NOTE that sigma is shared with the signal sample model
y = RooRealVar( "y", "y", 0, 200 )
y.setBins(n_bins)
mean_ctl = RooRealVar( "mean_ctl", "mean_ctl", mu2, 0, 200 )
sigma_ctl = RooRealVar( "sigma", "sigma", sigma2, 0.1, 10 )
gx_ctl = RooGaussian( "gx_ctl", "gx_ctl", y, mean_ctl, sigma_ctl )
# Construct the background pdf
mean_bkg_ctl = RooRealVar( "mean_bkg_ctl", "mean_bkg_ctl", mu1, 0, 200 )
sigma_bkg_ctl = RooRealVar( "sigma_bkg_ctl", "sigma_bkg_ctl", sigma1, 0.1, 20 )
px_ctl = RooGaussian( "px_ctl", "px_ctl", y, mean_bkg_ctl, sigma_bkg_ctl )
# Construct the composite model
# f_ctl = RooRealVar( "f_ctl", "f_ctl", 0.5, 0., 20. )
model_ctl = RooAddPdf( "model_ctl", "model_ctl", RooArgList( gx_ctl, px_ctl ),
RooArgList( nsig, nbkg ) )
# G e t e v e n t s f o r b o t h s a m p l e s
# ---------------------------------------------------------------
real_data, real_data_ctl = get_data()
real_data_hist = RooDataHist( 'real_data_hist',
'real_data_hist',
RooArgList( x ),
real_data )
real_data_ctl_hist = RooDataHist( 'real_data_ctl_hist',
'real_data_ctl_hist',
RooArgList( y ),
real_data_ctl )
input_hists = MapStrRootPtr()
input_hists.insert( StrHist( "physics", real_data ) )
input_hists.insert( StrHist( "control", real_data_ctl ) )
# C r e a t e i n d e x c a t e g o r y a n d j o i n s a m p l e s
# ---------------------------------------------------------------------------
# Define category to distinguish physics and control samples events
sample = RooCategory( "sample", "sample" )
sample.defineType( "physics" )
sample.defineType( "control" )
# Construct combined dataset in (x,sample)
combData = RooDataHist( "combData", "combined data", RooArgList( x), sample ,
input_hists )
# C o n s t r u c t a s i m u l t a n e o u s p d f i n ( x , s a m p l e )
# -----------------------------------------------------------------------------------
# Construct a simultaneous pdf using category sample as index
simPdf = RooSimultaneous( "simPdf", "simultaneous pdf", sample )
# Associate model with the physics state and model_ctl with the control state
simPdf.addPdf( model, "physics" )
simPdf.addPdf( model_ctl, "control" )
#60093.048127 173.205689173 44.7112503776
# P e r f o r m a s i m u l t a n e o u s f i t
# ---------------------------------------------------
model.fitTo( real_data_hist,
RooFit.Minimizer( "Minuit2", "Migrad" ),
RooFit.NumCPU( 1 ),
# RooFit.Extended(),
# RooFit.Save(),
)
summary = 'fit in signal region\n'
summary += 'nsig: ' + str( nsig.getValV() ) + ' +- ' + str( nsig.getError() ) + '\n'
summary += 'nbkg: ' + str( nbkg.getValV() ) + ' +- ' + str( nbkg.getError() ) + '\n'
#
# model_ctl.fitTo( real_data_ctl_hist )
# summary += 'fit in control region\n'
# summary += 'nsig: ' + str( nsig.getValV() ) + ' +- ' + str( nsig.getError() ) + '\n'
# summary += 'nbkg: ' + str( nbkg.getValV() ) + ' +- ' + str( nbkg.getError() ) + '\n'
#
# # Perform simultaneous fit of model to data and model_ctl to data_ctl
# simPdf.fitTo( combData )
# summary += 'Combined fit\n'
# summary += 'nsig: ' + str( nsig.getValV() ) + ' +- ' + str( nsig.getError() ) + '\n'
# summary += 'nbkg: ' + str( nbkg.getValV() ) + ' +- ' + str( nbkg.getError() ) + '\n'
# P l o t m o d e l s l i c e s o n d a t a s l i c e s
# ----------------------------------------------------------------
# Make a frame for the physics sample
frame1 = x.frame( RooFit.Bins( 30 ), RooFit.Title( "Physics sample" ) )
# Plot all data tagged as physics sample
combData.plotOn( frame1, RooFit.Cut( "sample==sample::physics" ) )
# Plot "physics" slice of simultaneous pdf.
# NBL You _must_ project the sample index category with data using ProjWData
# as a RooSimultaneous makes no prediction on the shape in the index category
# and can thus not be integrated
simPdf.plotOn( frame1, RooFit.Slice( sample, "physics" ),
RooFit.ProjWData( RooArgSet( sample ), combData ), )
simPdf.plotOn( frame1, RooFit.Slice( sample, "physics" ),
RooFit.Components( "signal_1_pdf" ),
RooFit.ProjWData( RooArgSet( sample ), combData ),
RooFit.LineStyle( kDashed ),
)
simPdf.plotOn( frame1, RooFit.Slice( sample, "physics" ),
RooFit.Components( "bkg_1_pdf" ),
RooFit.ProjWData( RooArgSet( sample ), combData ),
RooFit.LineStyle( kDashed ),
RooFit.LineColor( kRed ) )
# The same plot for the control sample slice
frame2 = y.frame( RooFit.Bins( 30 ), RooFit.Title( "Control sample" ) )
combData.plotOn( frame2, RooFit.Cut( "sample==sample::control" ) )
simPdf.plotOn( frame2, RooFit.Slice( sample, "control" ),
RooFit.ProjWData( RooArgSet( sample ), combData ) )
simPdf.plotOn( frame2, RooFit.Slice( sample, "control" ),
RooFit.Components( "px_ctl" ),
RooFit.ProjWData( RooArgSet( sample ), combData ),
RooFit.LineStyle( kDashed ) )
c = TCanvas( "rf501_simultaneouspdf", "rf403_simultaneouspdf", 800, 400 )
c.Divide( 2 )
c.cd( 1 )
gPad.SetLeftMargin( 0.15 )
frame1.GetYaxis().SetTitleOffset( 1.4 )
frame1.Draw()
c.cd( 2 )
gPad.SetLeftMargin( 0.15 )
frame2.GetYaxis().SetTitleOffset( 1.4 )
frame2.Draw()
print summary
print real_data.Integral()
raw_input()
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")
# param = ROOT.RooRealVar( p_name, "", p_min, p_max)
# gcs.append(param)
# coeff.add(param)
# print 'her'
print formula
#coeff.add(x)
#coeff.Print()
pdf = ROOT.RooGenericPdf( ("%s" % (pdf_name)), "", "TMath::Exp(-@0*TMath::Log(@2/13000)-@0*@1*TMath::Log(@2/13000)*TMath::Log(@2/13000))*(1+@3*(@2/13000))", RooArgList(c,c2,x,c3) )
#pdf = ROOT.RooGenericPdf( ("%s" % (pdf_name)), "", "TMath::Exp(-@0*TMath::Log(@2)-@0*@1*TMath::Log(@2)*TMath::Log(@2))", RooArgList(c,c2,x) )
res = pdf.fitTo(roo_mbb_hist, RooFit.SumW2Error(ROOT.kFALSE),
RooFit.Warnings(ROOT.kFALSE))
frame = x.frame()
roo_mbb_hist.plotOn(frame,RooFit.DrawOption("Psame"), RooFit.LineWidth(2))
pdf.plotOn(frame,RooFit.LineColor(2))
frame.GetYaxis().SetRangeUser(0.,data_hist.GetMaximum()*1.1)
frame.GetXaxis().SetNdivisions(5,False)
frame.GetYaxis().SetTitleOffset(1.5)
frame.GetYaxis().SetTitle("Events")
frame.GetXaxis().SetTitle(data_hist.GetTitle())
chi2 = frame.chiSquare( )
print chi2
frame.Draw()
print 'res minNll = ', res.minNll()
pCMS1.Draw()
pCMS12.Draw()
ws.factory("Gaussian::gaus1(x,gm1[0.85,%.2f,%.2f],gs1[0.1,%.2f,%.2f])" % (0.8,1.05, 0.01,0.25))
#gmlow, gmup = 1.00, 1.15
gmlow, gmup = 0.90, 1.15
else:
ws.factory("Gaussian::gaus1(x,gm1[1.0,%.2f,%.2f],gs1[0.1,%.2f,%.2f])" % (0.95,1.10, 0.01,0.16))
ws.factory("expr::gs2('gs1*gssf1',gs1,gssf1[1.05,1,6])")
ws.factory("Gaussian::gaus2(x,gm2[1.0,%.2f,%.2f],gs2)" % (gmlow,gmup))
#ws.factory("Gaussian::gaus2(x,gm2[1.0,%.2f,%.2f],gs2)" % (gmlow,gmup))
ws.factory("SUM::double_gaussian(gaus1,f[0.5,0,1]*gaus2)")
model = ws.pdf("double_gaussian")
#result = model.fitTo(data, RooFit.Save())
result = model.fitTo(data, RooFit.Range(fxlow,fxup), RooFit.Save())
data.plotOn(frame,RooFit.Name("data"),RooFit.DataError(RooAbsData.SumW2))
model.plotOn(frame,RooFit.Name("model_1"),RooFit.Components("gaus1"),RooFit.LineStyle(kDashed),RooFit.LineColor(kBlue-7))
model.plotOn(frame,RooFit.Name("model_2"),RooFit.Components("gaus2"),RooFit.LineStyle(kDashed),RooFit.LineColor(kBlue-7))
model.plotOn(frame,RooFit.Name("model"))
frame.SetMaximum(h.GetMaximum() if logy else 6000)
frame.SetMinimum(0.5 if logy else 0)
frame.Draw()
chi2 = frame.chiSquare("model", "data", 5)
p1 = ws.var("gm1")
p2 = ws.var("gs1")
p3 = ws.var("gm2")
p4 = ws.var("gssf1")
#p4 = ws.var("gs2")
p5 = ws.var("f")
parvalues = [p1.getVal(), p2.getVal(), p3.getVal(), p4.getVal(), p5.getVal()]
def rf501_simultaneouspdf():
# C r e a t e m o d e l f o r p h y s i c s s a m p l e
# -------------------------------------------------------------
# Create observables
x = RooRealVar("x", "x", 40, 200)
# Construct signal pdf
mean = RooRealVar("mean", "mean", 140, 40, 200)
sigma = RooRealVar("sigma", "sigma", 5, 0.1, 10)
gx = RooGaussian("gx", "gx", x, mean, sigma)
# Construct background pdf
mean_bkg = RooRealVar("mean_bkg", "mean_bkg", 100, 40, 200)
sigma_bkg = RooRealVar("sigma_bkg", "sigma_bkg", 15, 0.1, 20)
px = RooGaussian("px", "px", x, mean_bkg, sigma_bkg)
# Construct composite pdf
f = RooRealVar("f", "f", 0.2, 0., 20.)
model = RooAddPdf("model", "model", RooArgList(gx, px), RooArgList(f))
# C r e a t e m o d e l f o r c o n t r o l s a m p l e
# --------------------------------------------------------------
# Construct signal pdf.
# NOTE that sigma is shared with the signal sample model
mean_ctl = RooRealVar("mean_ctl", "mean_ctl", 140, 40, 200)
gx_ctl = RooGaussian("gx_ctl", "gx_ctl", x, mean_ctl, sigma)
# Construct the background pdf
mean_bkg_ctl = RooRealVar("mean_bkg_ctl", "mean_bkg_ctl", 100, 40, 200)
sigma_bkg_ctl = RooRealVar("sigma_bkg_ctl", "sigma_bkg_ctl", 15, 0.1, 20)
px_ctl = RooGaussian("px_ctl", "px_ctl", x, mean_bkg_ctl, sigma_bkg_ctl)
# Construct the composite model
f_ctl = RooRealVar("f_ctl", "f_ctl", 0.5, 0., 20.)
model_ctl = RooAddPdf("model_ctl", "model_ctl", RooArgList(gx_ctl, px_ctl),
RooArgList(f_ctl))
# G e t e v e n t s f o r b o t h s a m p l e s
# ---------------------------------------------------------------
real_data, real_data_ctl = get_data()
input_hists = MapStrRootPtr()
input_hists.insert(StrHist("physics", real_data))
input_hists.insert(StrHist("control", real_data_ctl))
# C r e a t e i n d e x c a t e g o r y a n d j o i n s a m p l e s
# ---------------------------------------------------------------------------
# Define category to distinguish physics and control samples events
sample = RooCategory("sample", "sample")
sample.defineType("physics")
sample.defineType("control")
# Construct combined dataset in (x,sample)
combData = RooDataHist("combData", "combined data", RooArgList(x), sample,
input_hists)
# C o n s t r u c t a s i m u l t a n e o u s p d f i n ( x , s a m p l e )
# -----------------------------------------------------------------------------------
# Construct a simultaneous pdf using category sample as index
simPdf = RooSimultaneous("simPdf", "simultaneous pdf", sample)
# Associate model with the physics state and model_ctl with the control state
simPdf.addPdf(model, "physics")
simPdf.addPdf(model_ctl, "control")
# P e r f o r m a s i m u l t a n e o u s f i t
# ---------------------------------------------------
# Perform simultaneous fit of model to data and model_ctl to data_ctl
simPdf.fitTo(combData)
# P l o t m o d e l s l i c e s o n d a t a s l i c e s
# ----------------------------------------------------------------
# Make a frame for the physics sample
frame1 = x.frame(RooFit.Bins(30), RooFit.Title("Physics sample"))
# Plot all data tagged as physics sample
combData.plotOn(frame1, RooFit.Cut("sample==sample::physics"))
# Plot "physics" slice of simultaneous pdf.
# NBL You _must_ project the sample index category with data using ProjWData
# as a RooSimultaneous makes no prediction on the shape in the index category
# and can thus not be integrated
simPdf.plotOn(frame1, RooFit.Slice(sample, "physics"),
RooFit.ProjWData(RooArgSet(sample), combData))
simPdf.plotOn(frame1, RooFit.Slice(sample, "physics"),
RooFit.Components("px"),
RooFit.ProjWData(RooArgSet(sample), combData),
RooFit.LineStyle(kDashed))
# The same plot for the control sample slice
frame2 = x.frame(RooFit.Bins(30), RooFit.Title("Control sample"))
combData.plotOn(frame2, RooFit.Cut("sample==sample::control"))
simPdf.plotOn(frame2, RooFit.Slice(sample, "control"),
RooFit.ProjWData(RooArgSet(sample), combData))
simPdf.plotOn(frame2, RooFit.Slice(sample, "control"),
RooFit.Components("px_ctl"),
RooFit.ProjWData(RooArgSet(sample), combData),
RooFit.LineStyle(kDashed))
c = TCanvas("rf501_simultaneouspdf", "rf403_simultaneouspdf", 800, 400)
c.Divide(2)
c.cd(1)
gPad.SetLeftMargin(0.15)
frame1.GetYaxis().SetTitleOffset(1.4)
frame1.Draw()
c.cd(2)
gPad.SetLeftMargin(0.15)
frame2.GetYaxis().SetTitleOffset(1.4)
frame2.Draw()
raw_input()
def RooFitHist(inputhist, title='title', path='.'):
# RooFit.gErrorIgnoreLevel = RooFit.kInfo # <6.02
# RooFit.SetSilentMode()# >6.02
# RooMsgService().instance().SetSilentMode(kTRUE)
fitbinning = array('d')
binwidth = 200
#NBins=(14000/binwidth) - ( (1040/binwidth) + 1 )
NBins = (14000 / binwidth) - ((1040 / binwidth) + 1)
for i in range(NBins + 1):
fitbinning.append(1050 + i * binwidth)
# print(fitbinning)
hist = inputhist.Rebin(NBins, "fit parameter", fitbinning)
meanstart = hist.GetBinCenter(hist.GetMaximumBin())
sigmastart = hist.GetRMS()
print('meanstart:', meanstart, 'sigmastart:', sigmastart)
# inputhist.Draw()
# hist.Draw()
# hold=raw_input('press enter to exit.')
gStyle.SetOptFit(1100)
gStyle.SetOptTitle(0)
RooFit.SumW2Error(kTRUE)
mjj = RooRealVar('mjj', 'M_{jj-AK8}', fitbinning[0],
fitbinning[len(fitbinning) - 1], 'GeV')
mjjral = RooArgList(mjj)
dh = RooDataHist('dh', 'dh', mjjral, RooFit.Import(hist))
shapes = {}
#Gaussian
gaussmean = RooRealVar('#mu_{gauss}', 'mass mean value', meanstart, 0,
2 * meanstart)
gausssigma = RooRealVar('#sigma_{gauss}', 'mass resolution', sigmastart, 0,
2 * sigmastart)
gauss = RooGaussian('gauss', 'gauss', mjj, gaussmean, gausssigma)
shapes.update({'Gauss': gauss})
#CrystalBall
mean = RooRealVar('#mu', 'mean', meanstart, 0, 2 * meanstart)
sigma = RooRealVar('#sigma', 'sigma', sigmastart, 0, 2 * sigmastart)
alpha = RooRealVar('#alpha', 'Gaussian tail', -1000, 0)
n = RooRealVar('n', 'Normalization', -1000, 1000)
cbshape = RooCBShape('cbshape', 'crystalball PDF', mjj, mean, sigma, alpha,
n)
shapes.update({'CrystalBall': cbshape})
#Voigt
voigtmean = RooRealVar('#mu', 'mass mean value', meanstart, 0,
2 * meanstart)
voigtwidth = RooRealVar('#gamma', 'width of voigt', 0, 5000)
voigtsigma = RooRealVar('#sigma', 'mass resolution', sigmastart, 0,
2 * sigmastart)
voigt = RooVoigtian('voigt', 'voigt', mjj, voigtmean, voigtwidth,
voigtsigma)
shapes.update({'Voigt': voigt})
#BreitWigner
bwmean = RooRealVar('#mu', 'mass mean value', meanstart, 0, 2 * meanstart)
bwwidth = RooRealVar('#sigma', 'width of bw', sigmastart, 0,
2 * sigmastart)
bw = RooBreitWigner('bw', 'bw', mjj, bwmean, bwwidth)
shapes.update({'BreitWigner': bw})
#Landau
landaumean = RooRealVar('#mu_{landau}', 'mean landau', meanstart, 0,
2 * meanstart)
landausigma = RooRealVar('#sigma_{landau}', 'mass resolution', sigmastart,
0, 2 * sigmastart)
landau = RooLandau('landau', 'landau', mjj, landaumean, landausigma)
shapes.update({'Landau': landau})
#LandauGauss Convolution
landaugauss = RooFFTConvPdf('landaugauss', 'landau x gauss', mjj, landau,
gauss)
shapes.update({'LandauGauss': landaugauss})
#Logistics
# logisticsmean=RooRealVar('#mu_{logistics}','mean logistics',meanstart,0,2*meanstart)
# logisticssigma= RooRealVar('#sigma_{logistics}','mass resolution',sigmastart,0,2*sigmastart)
# logistics=RooLogistics('logistics','logistics',mjj,logisticsmean,logisticssigma)
# shapes.update({'Logistics':logistics})
#ExpAndGauss
# expgaussmean=RooRealVar('#mu_{expgauss}','mean expgauss',meanstart,0,2*meanstart)
# expgausssigma= RooRealVar('#sigma_{expgauss}','mass resolution',sigmastart,0,2*sigmastart)
# expgausstrans= RooRealVar('trans','trans',0,100)
# expgauss=RooExpAndGauss('expgauss','expgauss',mjj,expgaussmean,expgausssigma,expgausstrans)
# shapes.update({'ExpAndGauss':expgauss})
#BifurGauss
BifurGaussmean = RooRealVar('#mu_{BifurGauss}', 'mean BifurGauss',
meanstart, 0, 2 * meanstart)
BifurGausslsigma = RooRealVar('#sigma_{left}', 'mass resolution',
sigmastart, 0, 2 * sigmastart)
BifurGaussrsigma = RooRealVar('#sigma_{right}', 'mass resolution',
sigmastart, 0, 2 * sigmastart)
BifurGauss = RooBifurGauss('BifurGauss', 'BifurGauss', mjj, BifurGaussmean,
BifurGausslsigma, BifurGaussrsigma)
shapes.update({'BifurGauss': BifurGauss})
#Chebychev
Chebychev1 = RooRealVar('c0', 'Chebychev0', -1000, 1000)
Chebychev2 = RooRealVar('c1', 'Chebychev1', -1000, 1000)
Chebychev3 = RooRealVar('c2', 'Chebychev2', 2, -1000, 1000)
Chebychev = RooChebychev('Chebychev', 'Chebychev', mjj,
RooArgList(Chebychev1, Chebychev2, Chebychev3))
shapes.update({'Chebychev': Chebychev})
#Polynomial
Polynomial1 = RooRealVar('Polynomial1', 'Polynomial1', 100, 0, 1000)
Polynomial2 = RooRealVar('Polynomial2', 'Polynomial2', 100, 0, 1000)
Polynomial = RooPolynomial('Polynomial', 'Polynomial', mjj,
RooArgList(Polynomial1, Polynomial2))
shapes.update({'Polynomial': Polynomial})
# mjj.setRange("FitRange",1050.,14000.)
# for fname in ['Gauss','Logistics','BifurGauss']:
for fname in ['BifurGauss']:
plottitle = '%s Fit of %s' % (fname, title)
shape = shapes[fname]
# shape.fitTo(dh,RooFit.Range("FitRange"),RooFit.SumW2Error(True))
shape.fitTo(dh, RooFit.SumW2Error(True))
frame = mjj.frame(RooFit.Title(plottitle))
frame.GetYaxis().SetTitleOffset(2)
dh.plotOn(frame, RooFit.MarkerStyle(4))
shape.plotOn(frame, RooFit.LineColor(2))
ndof = dh.numEntries() - 3
#chiSquare legend
chi2 = frame.chiSquare()
probChi2 = TMath.Prob(chi2 * ndof, ndof)
chi2 = round(chi2, 2)
probChi2 = round(probChi2, 2)
leg = TLegend(0.5, 0.5, 0.9, 0.65)
leg.SetBorderSize(0)
leg.SetFillStyle(0)
shape.paramOn(frame, RooFit.Layout(0.5, 0.9, 0.9))
leg.AddEntry(0, '#chi^{2} =' + str(chi2), '')
leg.AddEntry(0, 'Prob #chi^{2} = ' + str(probChi2), '')
leg.SetTextSize(0.04)
frame.addObject(leg)
canv = TCanvas(plottitle, plottitle, 700, 700)
canv.SetLogy()
canv.SetLeftMargin(0.20)
canv.cd()
frame.SetMinimum(10**(-3))
frame.Draw()
canv.Print(path + '/%s__%s.eps' % (title, fname))
return chi2
def resolution():
#relative energy resolution
#ALICE PHOS has 3% in 0.2 - 10 GeV, PHOS TDR page 113 (127)
emin = -0.4
emax = 0.4
ebin = 0.01
#reconstruct the energy from detected optical photons
gRec = rec(False)
#construct the relative energy resolution
nbins, emax = ut.get_nbins(ebin, emin, emax)
hRes = ut.prepare_TH1D_n("hRes", nbins, emin, emax)
egen = rt.Double()
erec = rt.Double()
for i in xrange(gRec.GetN()):
gRec.GetPoint(i, egen, erec)
hRes.Fill( (erec-egen)/egen )
#fit the resolution with Breit-Wigner pdf
x = RooRealVar("x", "x", -0.5, 0.5)
x.setRange("fitran", -0.21, 0.21)
rfRes = RooDataHist("rfRes", "rfRes", RooArgList(x), hRes)
#Breit-Wigner pdf
mean = RooRealVar("mean", "mean", 0., -0.1, 0.1)
sigma = RooRealVar("sigma", "sigma", 0.01, 0., 0.9)
bwpdf = RooBreitWigner("bwpdf", "bwpdf", x, mean, sigma)
rfres = bwpdf.fitTo(rfRes, rf.Range("fitran"), rf.Save())
#log the results to a file
out = open("out.txt", "w")
out.write(ut.log_fit_result(rfres))
#plot the resolution
can = ut.box_canvas()
frame = x.frame(rf.Bins(nbins), rf.Title(""))
frame.SetTitle("")
frame.SetXTitle("Relative energy resolution (#it{E}_{rec}-#it{E}_{gen})/#it{E}_{gen}")
frame.GetXaxis().SetTitleOffset(1.4)
frame.GetYaxis().SetTitleOffset(1.6)
ut.set_margin_lbtr(gPad, 0.11, 0.1, 0.01, 0.03)
rfRes.plotOn(frame, rf.Name("data"))
bwpdf.plotOn(frame, rf.Precision(1e-6), rf.Name("bwpdf"))
frame.Draw()
leg = ut.prepare_leg(0.65, 0.78, 0.28, 0.15, 0.035)
leg.SetMargin(0.17)
hx = ut.prepare_TH1D("hx", 1, 0, 1)
hx.Draw("same")
leg.AddEntry(hx, "#frac{#it{E}_{rec} - #it{E}_{gen}}{#it{E}_{gen}}")
lx = ut.col_lin(rt.kBlue)
leg.AddEntry(lx, "Breit-Wigner fit", "l")
leg.Draw("same")
#fit parameters on the plot
desc = pdesc(frame, 0.67, 0.7, 0.05); #x, y, sep
#desc.set_text_size(0.03)
desc.itemD("#chi^{2}/ndf", frame.chiSquare("bwpdf", "data", 2), -1, rt.kBlue)
desc.prec = 4
desc.itemR("mean", mean, rt.kBlue)
desc.itemR("#sigma", sigma, rt.kBlue)
desc.draw()
#ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
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()
frame = x.frame()
roohistSig.plotOn(frame, RooFit.Binning(166))
signal.plotOn(frame)
signal.plotOn(frame, RooFit.Components('bkg'), RooFit.LineColor(ROOT.kRed),
RooFit.LineWidth(2), RooFit.LineStyle(ROOT.kDashed))
#frame.GetXaxis().SetRangeUser(1118,6099)
frame.GetXaxis().SetRangeUser(minX_mass, maxX_mass)
frame.GetXaxis().SetTitle('m_{jj} (GeV)')
frame.Draw()
parsSig = signal.getParameters(roohistSig)
parsSig.setAttribAll('Constant', True)
if histpdfSig:
# -----------------------------------------
# hist pdf signal
nsigrefW=RooRealVar("nsigrefW"+name,"number of signal W events",sigWhist.Integral(),0,10*sigWhist.Integral())
nsigrefZ=RooRealVar("nsigrefZ"+name,"number of signal Z events",sigZhist.Integral(),0,10*sigZhist.Integral())
sigWfrac=RooRealVar("sigWfrac"+name,"fraction of W in signal",0.5,0,1.0)
sig=RooAddPdf("sig"+name,"sig"+name,sigW,sigZ,sigWfrac) ;
sigmodel=RooAddPdf("sigmodel"+name,"sig+sigbkg",RooArgList(sigbkg,sig),RooArgList(nsigbkg,nsigref))
meanW.setConstant(False)
meanWZ.setConstant(False)
widthWZ.setConstant(False)
sigWfrac.setConstant(False)
sigmodelW=RooAddPdf("sigmodelW"+name,"sigW",RooArgList(sigbkg,sigW),RooArgList(nsigbkg,nsigrefW))
sigmodelW.fitTo(signalW,RooFit.SumW2Error(True))
sigmodelW.fitTo(signalW,RooFit.SumW2Error(True))
sigmodelW.fitTo(signalW,RooFit.SumW2Error(True))
xframe=mass.frame(RooFit.Title(" m="+str(int((meanW.getValV())*1000.)/1000.)+"#pm"+str(int(meanW.getError()*1000.)/1000.)+" GeV"))
signalW.plotOn(xframe,RooFit.DataError(RooAbsData.SumW2))
sigmodelW.plotOn(xframe,RooFit.Normalization(1.0,RooAbsReal.RelativeExpected))
canvas=TCanvas("c3","c3",0,0,600,600)
xframe.GetYaxis().SetTitle("Events")
xframe.Draw()
canvas.SaveAs(prefix+"_"+plot[0]+name+"_sigWfit.pdf")
meanW.setConstant(True)
widthWZ.setConstant(True)
sigmodelZ=RooAddPdf("sigmodelZ"+name,"sigZ",RooArgList(sigbkg,sigZ),RooArgList(nsigbkg,nsigrefZ))
sigmodelZ.fitTo(signalZ,RooFit.SumW2Error(True))
sigmodelZ.fitTo(signalZ,RooFit.SumW2Error(True))
sigmodelZ.fitTo(signalZ,RooFit.SumW2Error(True))
xframe=mass.frame(RooFit.Title(" #Delta m="+str(int((meanWZ.getValV())*1000.)/1000.)+"#pm"+str(int(meanWZ.getError()*1000.)/1000.)+" GeV"))
signalZ.plotOn(xframe,RooFit.DataError(RooAbsData.SumW2))
sigmodelZ.plotOn(xframe,RooFit.Normalization(1.0,RooAbsReal.RelativeExpected))
canvas=TCanvas("c3","c3",0,0,600,600)
