def plotMCSpectrum():
# load workspace
f = TFile("./data/fitWorkspace.root", "UPDATE")
fitWorkspace = f.Get("fitWorkspace")
fData = fitWorkspace.allData().front()
fitResult = fitWorkspace.allGenericObjects().front()
fEnergy = fitWorkspace.var("energy_keV")
model = fitWorkspace.pdf("model")
pdfList = fitWorkspace.allPdfs() # RooArgSet
# create a toy dataset with the same number of expected events as the best-fit model
# by sampling from the best-fit model PDF.
# makes it look like the real data points got slightly randomized.
print model.expectedEvents(pdfList)
fMCData = model.generate(ROOT.RooArgSet(fEnergy), RF.Name("Toy MC Data"),
RF.Extended())
# getattr(fitWorkspace,'import')(fMCData)
# fitWorkspace.Write("",TObject.kOverwrite)
# f.Close()
# -- plot the data vs. the toy data --
c = TCanvas("c", "c", 1100, 800)
binSize = 0.2
nBins = int((eHi - eLo) / binSize + 0.5)
fSpec = fEnergy.frame(RF.Range(eLo, eHi), RF.Bins(nBins))
fData.plotOn(fSpec)
fMCData.plotOn(fSpec, RF.MarkerColor(ROOT.kBlue))
model.plotOn(fSpec, RF.LineColor(ROOT.kRed), RF.Name("FullModel"))
fSpec.SetTitle(" ")
fSpec.Draw()
c.Print("./plots/toyMC.pdf")
def _plot_bin(self,
wsp,
full_data,
bin_name,
bin_borders,
n_bins,
publication=False):
"""Make the distribution plot for a given bin"""
leg = setup_legend(*self.plot_config['legpos'])
# In order to remove horizontal error bars from the plot the option
# XErrorSize(0) has to be used, but that breaks the calculation of the
# chi2 wrt a given curve since the x-errors are used to determine the
# bin and the corresponding mean value of the data points in the bin
# which is necessary to calculate the point at which the curve should be
# evaluated. So here I plot two curves, the one labeled 'data_hist_plot'
# is the visible one, whereas the one labeled 'data_hist' will be the
# with associated x uncertainties that can be used to calculate the chi2
# This will only be done in "publication mode"
if publication:
data_args = (rf.MarkerSize(0.5), rf.Name('data_hist_plot'),
rf.XErrorSize(0))
leg.SetTextSize(0.04)
else:
data_args = (rf.MarkerSize(0.7), rf.Name('data_hist'))
fit_var = get_var(wsp, self.fit_var)
frame = fit_var.frame(rf.Bins(n_bins))
cut = get_bin_cut(self.bin_cut_vars, bin_borders)
full_data.reduce(cut).plotOn(frame, *data_args)
if publication:
full_data.reduce(cut).plotOn(frame, rf.MarkerSize(0),
rf.Name('data_hist'), rf.LineColor(0),
rf.LineWidth(0))
leg.AddEntry(frame.getHist('data_hist_plot'), 'Data', 'PE')
full_pdf = wsp.pdf(self.full_model + '_' + bin_name)
full_pdf.plotOn(frame, rf.LineWidth(2), rf.Name('full_pdf_curve'))
leg.AddEntry(frame.getCurve('full_pdf_curve'), 'Fit result', 'l')
for name, settings in self.components:
full_pdf.plotOn(frame, rf.Components(name + '_' + bin_name),
rf.LineStyle(settings['line']),
rf.LineColor(settings['color']), rf.LineWidth(2),
rf.Name(name))
leg.AddEntry(frame.getCurve(name), settings['label'], 'l')
# calculate the bin width in MeV
bw_mev = lambda v, n: (v.getMax() - v.getMin()) / n * 1000
frame.GetYaxis().SetTitleOffset(1.3)
frame.GetYaxis().SetTitle('Events / {:.2f} MeV'.format(
bw_mev(fit_var, n_bins)))
frame.SetTitle("")
return frame, leg
def plot_ll(self,
poi,
nbins=100,
poi_min=-1,
poi_max=-1,
save=False,
save_folder='.',
save_prefix='pll'):
"""Plot the nominal and profiled likelihoods for the instance's data and model for the provided parameter of interest
Parameters
----------
poi: RooRealVar
parameter of interest for which the likelihoods will be plotted
nbins: int, optional (default=100)
number of bins for plotting
poi_min: float, optional (default=-1, set to be -5*poi_fit_error)
left range for plotting
poi_max: float, optional (default=-1, set to be +5*poi_fit_error)
right range for plotting
save: bool, optional (default=False)
whether save the plot or not
save_folder: str, optional (default='.')
path for saving
save_prefix: str, optional (default='pll')
prefix to the file name
Returns
-------
frame: RooPlot
frame containing the likelihood plots (requires further drawing on the canvas)
"""
poi_from_model = self.model.getVariables().find(poi.GetName())
if poi_min == -1:
poi_min = poi_from_model.getVal() - 5 * poi_from_model.getError()
if poi_max == -1:
poi_max = poi_from_model.getVal() + 5 * poi_from_model.getError()
assert (nbins % 1 == 0
and nbins >= 0), 'nbins must be a positive integer'
assert (poi_min <
poi_max), 'left range value must be lower than right range one'
nll = self.model.createNLL(self.data)
pll = nll.createProfile(ROOT.RooArgSet(poi))
frame_nll = poi.frame(RF.Bins(nbins), RF.Range(poi_min, poi_max))
frame_nll.SetTitle('')
nll.plotOn(frame_nll, RF.ShiftToZero(), RF.LineColor(ROOT.kGreen))
pll.plotOn(frame_nll, RF.LineColor(ROOT.kRed))
frame_nll.SetMaximum(25.)
frame_nll.SetMinimum(0.)
frame_nll.SetXTitle(poi.GetName())
if save:
c_ll = ROOT.TCanvas("c_ll", "c_ll", 800, 600)
frame_nll.Draw()
c_ll.SaveAs(f'{save_folder}/{save_prefix}.pdf')
return frame_nll
def compareData():
""" Make sure I can match the data points of a RooPlot """
from ROOT import TFile, TCanvas
# === matplotlib style
tf2 = TFile("./data/latDS%s.root" % ''.join([str(d) for d in dsList]))
tt = tf2.Get("skimTree")
tCut = "isEnr" if enr else "!isEnr"
tCut += " && trapENFCal >= %.1f && trapENFCal <= %.1f" % (eLo, eHi)
n = tt.Draw("trapENFCal", tCut, "goff")
hitE = tt.GetV1()
hitE = [hitE[i] for i in range(n)]
x, hData = wl.GetHisto(hitE, eLo, eHi, epb)
hErr = np.asarray([np.sqrt(h) for h in hData]) # statistical error
plt.figure(figsize=(7,5))
# plt.plot(x, hData, ls='steps', c='b') # normal histo
plt.errorbar(x, hData, yerr=hErr, c='k', ms=10, linewidth=0.8, fmt='.', capsize=2) # pretty convincing rooplot fake
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("Events / %.1f keV" % epb, ha='right', y=1)
plt.xlim(eLo, eHi)
plt.tight_layout()
# plt.show()
plt.savefig("./plots/sf-data-np.pdf")
# === roofit style
f = TFile("./data/fitWorkspace.root")
fitWorkspace = f.Get("fitWorkspace")
fData = fitWorkspace.allData().front()
fitResult = fitWorkspace.allGenericObjects().front()
nPars = fitResult.floatParsFinal().getSize()
fEnergy = fitWorkspace.var("trapENFCal")
modelPDF = fitWorkspace.pdf("model")
nBins = int((eHi-eLo)/epb + 0.5)
fSpec = fEnergy.frame(RF.Range(eLo,eHi), RF.Bins(nBins))
fData.plotOn(fSpec)
c = TCanvas()
fSpec.Draw()
c.Print("./plots/sf-data-rp.pdf")
def plotFit(plotRate=False):
from ROOT import TFile, TCanvas, TH1D, TLegend, gStyle
f = TFile("%s/data/fitWorkspace.root" % dsi.latSWDir)
fitWorkspace = f.Get("fitWorkspace")
fData = fitWorkspace.allData().front()
fitResult = fitWorkspace.allGenericObjects().front()
nPars = fitResult.floatParsFinal().getSize()
hitE = fitWorkspace.var("trapENFCal")
model = fitWorkspace.pdf("model")
nData = fData.numEntries()
fCov = fitResult.covQual()
# fitWorkspace.Print()
# === get fit results: {name : [nCts, err]} ===
fitVals = {}
for i in range(nPars):
fp = fitResult.floatParsFinal()
name = fp.at(i).GetName()
fitVal, fitErr = fp.at(i).getValV(), fp.at(i).getError()
if "amp" in name:
fitVals[name.split('-')[1]] = [fitVal, fitErr]
# for f in fitVals:
# print(f, fitVals[f])
# === make a rooplot of the fit ===
leg = TLegend(0.83, 0.5, 0.97, 0.9)
gStyle.SetPalette(ROOT.kRainBow)
nCol = float(gStyle.GetNumberOfColors())
fSpec = hitE.frame(RF.Range(eLo, eHi), RF.Bins(nB))
fData.plotOn(fSpec)
for i, name in enumerate(bkgModel):
pdfName = "ext-" + name
col = gStyle.GetColorPalette(int(nCol / len(bkgModel) * i))
model.plotOn(fSpec, RF.Components(pdfName), RF.LineColor(col),
RF.LineStyle(ROOT.kDashed), RF.Name(name))
leg.AddEntry(fSpec.findObject(name), name, "l")
chiSquare = fSpec.chiSquare(nPars)
model.plotOn(fSpec, RF.LineColor(ROOT.kRed), RF.Name("fmodel"))
leg.AddEntry(fSpec.findObject("fmodel"),
"Full Model, #chi^{2}/NDF = %.3f" % chiSquare, "l")
c = TCanvas("c", "c", 1400, 1000)
fSpec.SetTitle("")
fSpec.Draw()
leg.Draw("same")
c.Print("%s/plots/sf-after.pdf" % dsi.latSWDir)
c.Clear()
# === duplicate the rooplot in matplotlib ===
plt.close()
tf = TFile("%s/data/latDS%s.root" %
(dsi.latSWDir, ''.join([str(d) for d in dsList])))
tt = tf.Get("skimTree")
tCut = "isEnr==1" if enr is True else "isEnr==0"
tCut = "isEnr" if enr else "!isEnr"
tCut += " && trapENFCal >= %.1f && trapENFCal <= %.1f" % (eLo, eHi)
n = tt.Draw("trapENFCal", tCut, "goff")
trapE = tt.GetV1()
trapE = [trapE[i] for i in range(n)]
x, hData = wl.GetHisto(trapE, eLo, eHi, epb)
if plotRate:
hErr = np.asarray([np.sqrt(h) / detExp
for h in hData]) # statistical error
plt.errorbar(x,
hData / detExp,
yerr=hErr,
c='k',
ms=5,
linewidth=0.5,
fmt='.',
capsize=1,
zorder=1)
else:
hErr = np.asarray([np.sqrt(h) for h in hData]) # statistical error
plt.errorbar(x,
hData,
yerr=hErr,
c='k',
ms=5,
linewidth=0.5,
fmt='.',
capsize=1,
zorder=1)
# get the list of histograms and plot the components
hList = getHistList()
cmap = plt.cm.get_cmap('jet', len(hList) + 2)
pdfs, pdfsCorr, nTot, nTotC = [], [], 0, 0
for i, h in enumerate(hList):
name = h[1]
x, y, xpb = wl.npTH1D(h[0])
x, y = normPDF(x, y, eLo, eHi)
nCts, nErr = fitVals[name] # final result
yc = nCts * getEffCorr(x, y, inv=True)
if abs(nCts - np.sum(y * nCts)) > 2:
print("norm error, %s nCts %d y*nCts %d" %
(name, nCts, np.sum(y * nCts)))
# plt.step(x, y * nCts * (epb/xpb), c=cmap(i), lw=2, label="%s cts: %.2f±%.2f" % (name, nCts, nErr)) # plot the histo
xS = np.arange(eLo, eHi, 0.001) # plot a smoothed version
yS = spline(x - xpb / 2, y, xS)
if plotRate:
plt.plot(xS,
yS * nCts * (epb / xpb) / detExp,
"--",
c=cmap(i),
lw=2,
label="%s %.2f ± %.2f" %
(name, nCts / detExp, nErr / detExp))
else:
plt.plot(xS,
yS * nCts * (epb / xpb),
c=cmap(i),
lw=2,
label="%s cts: %d" % (name, nCts))
pdfs.append([x, y, xpb, nCts])
pdfsCorr.append([x, yc, xpb, nCts])
nTot += nCts
nTotC += np.sum(
yc
) # reverse the efficiency correction to get the "true" number of counts
# get the fit model, and the efficiency-corrected final model
xT, yT = getTotalModel(pdfs, eLo, eHi, epb, smooth=True)
xTc, yTc = getTotalModel(pdfsCorr, eLo, eHi, epb, smooth=True, amp=False)
if plotRate:
plt.plot(xT,
yT / detExp,
'r',
lw=2,
alpha=0.7,
label="Rate: %.2f" % (nTot / detExp))
plt.plot(xTc,
yTc / detExp,
c='m',
lw=3,
alpha=0.7,
label="Eff.corr: %.2f " % (nTotC / detExp))
plt.ylabel("Counts / keV / kg-d", ha='right', y=1)
else:
plt.plot(xT,
yT,
'r',
lw=2,
alpha=0.7,
label="Raw (no eff. corr): %d cts" % nTot)
plt.plot(xTc,
yTc,
c='m',
lw=3,
alpha=0.7,
label="Efficiency corrected: %d cts" % nTotC)
plt.ylabel("Counts / %.1f keV" % epb, ha='right', y=1)
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.legend(loc=1, fontsize=12)
plt.xticks(np.arange(int(eLo) - 1, eHi + 1, 5))
plt.xlim(eLo, eHi)
plt.ylim(ymin=0)
plt.tight_layout()
# plt.show()
plt.savefig("%s/plots/sf-after-mpl.pdf" % dsi.latSWDir)
def fitModel(makePlots=False):
from ROOT import TFile, TH1D, TCanvas, TLegend, gStyle
# === load data into workspace ===
tf = TFile("%s/data/latDS%s.root" %
(dsi.latSWDir, ''.join([str(d) for d in dsList])))
tt = tf.Get("skimTree")
tCut = "isEnr==1" if enr is True else "isEnr==0"
hitE = ROOT.RooRealVar("trapENFCal", "Energy", eLo, eHi, "keV")
hEnr = ROOT.RooRealVar("isEnr", "isEnr", 0, 1, "")
# hitW = ROOT.RooRealVar("weight", "weight", 1, 1000, "")
fData = ROOT.RooDataSet("data", "data", tt, ROOT.RooArgSet(hitE, hEnr),
tCut)
# fData = ROOT.RooDataSet("data", "data", tt, ROOT.RooArgSet(hitE, hEnr, hitW), "", "weight")
fitWorkspace = ROOT.RooWorkspace("fitWorkspace", "Fit Workspace")
getattr(fitWorkspace, 'import')(hitE)
getattr(fitWorkspace, 'import')(fData)
# getattr(fitWorkspace,'import')(fWeight)
tf2 = TFile("%s/data/specPDFs.root" % dsi.latSWDir)
pdfList = ROOT.RooArgList("shapes")
# === background model ===
hList = getHistList()
bkgList = []
for h in hList:
hB, name = h[0], h[1]
pars = bkgVals[name]
bkN = ROOT.RooRealVar("amp-" + name, "amp-" + name, pars[1], pars[2],
pars[3])
bkDH = ROOT.RooDataHist("dh-" + name, "dh-" + name,
ROOT.RooArgList(hitE), RF.Import(hB))
bkPDF = ROOT.RooHistPdf("pdf-" + name, "pdf-" + name,
ROOT.RooArgSet(hitE), bkDH, 2)
bkExt = ROOT.RooExtendPdf("ext-" + name, "ext-" + name, bkPDF, bkN)
hitE.setRange(eLo, eHi)
bkgList.append([bkExt, name, bkN, bkDH, bkPDF])
# this is separate b/c all the RooVars have to remain in memory
for bkg in bkgList:
pdfList.add(bkg[0])
model = ROOT.RooAddPdf("model", "total PDF", pdfList)
if makePlots:
# === make a rooplot of the initial guess parameters, don't let roofit normalize automatically
leg = TLegend(0.83, 0.5, 0.97, 0.9)
gStyle.SetPalette(ROOT.kRainBow)
nCol = float(gStyle.GetNumberOfColors())
fSpec = hitE.frame(RF.Range(eLo, eHi), RF.Bins(nB))
fData.plotOn(fSpec)
# wouter's note: DON'T DELETE
# "the default behavior is when you plot a p.d.f. on an empty frame it is
# plotted with unit normalization. When you plot it on a frame with data in
# it, it will normalize to the number of events in that dataset."
# (then after you do a fit, the pdf normalization changes again ...)
nData = fData.numEntries()
nTot = 0
for i, ext in enumerate(bkgList):
extPDF, name = ext[0], ext[1]
col = gStyle.GetColorPalette(int(nCol / len(bkgList) * i))
extPDF.plotOn(
fSpec, RF.LineColor(col),
RF.Normalization(bkgVals[name][1], ROOT.RooAbsReal.Raw),
RF.Name(name))
leg.AddEntry(fSpec.findObject(name), name, "l")
nTot += bkgVals[name][1]
model.plotOn(fSpec, RF.LineColor(ROOT.kRed), RF.Name("fmodel"),
RF.Normalization(nTot, ROOT.RooAbsReal.Raw))
leg.AddEntry(fSpec.findObject("fmodel"), "Full Model", "l")
c = TCanvas("c", "c", 1400, 1000)
fSpec.SetTitle("")
fSpec.Draw()
leg.Draw("same")
c.Print("%s/plots/sf-before.pdf" % dsi.latSWDir)
c.Clear()
# === make a pyplot of the same thing
tCut = "isEnr" if enr else "!isEnr"
tCut += " && trapENFCal >= %.1f && trapENFCal <= %.1f" % (eLo, eHi)
n = tt.Draw("trapENFCal", tCut, "goff")
trapE = tt.GetV1()
trapE = [trapE[i] for i in range(n)]
x, hData = wl.GetHisto(trapE, eLo, eHi, epb)
hErr = np.asarray([np.sqrt(h) for h in hData])
plt.errorbar(x,
hData,
yerr=hErr,
c='k',
ms=5,
linewidth=0.5,
fmt='.',
capsize=1,
zorder=1) # pretty convincing rooplot fake
cmap = plt.cm.get_cmap('jet', len(hList) + 2)
pdfs = []
for i, h in enumerate(hList):
name = h[1]
x, y, xpb = wl.npTH1D(h[0])
x, y = normPDF(x, y, eLo, eHi)
nCts = bkgVals[h[1]][1] # the initial guess
if abs(nCts - np.sum(y * nCts)) > 2:
print("norm error, %s nCts %d y*nCts %d" %
(name, nCts, np.sum(y * nCts)))
# plt.step(x, y * nCts / xpb, c=cmap(i), lw=2, label="%s init cts: %d" % (name, nCts)) # plot the histo
xS = np.arange(eLo, eHi, 0.001) # plot a smoothed version
yS = spline(x - xpb / 2, y, xS)
plt.plot(xS,
yS * nCts / xpb,
c=cmap(i),
lw=2,
label="%s init cts: %d" % (name, nCts))
pdfs.append([x, y, xpb, nCts])
xT, yT = getTotalModel(pdfs, eLo, eHi, epb, smooth=True)
plt.step(xT,
yT / epb,
c='r',
lw=2,
label="Raw (no eff. corr): %d cts" % nTot)
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("Counts / %.1f keV" % epb, ha='right', y=1)
plt.legend(loc=1, fontsize=12)
plt.xlim(eLo, eHi)
plt.ylim(ymin=0)
plt.tight_layout()
# plt.show()
plt.savefig("%s/plots/sf-before-mpl.pdf" % dsi.latSWDir)
# === alright, now run the fit and output to the workspace
minimizer = ROOT.RooMinimizer(
model.createNLL(fData, RF.NumCPU(2, 0), RF.Extended(True)))
minimizer.setPrintLevel(-1)
minimizer.setStrategy(2)
minimizer.migrad()
fitResult = minimizer.save()
# according to the internet, covQual==3 is a good indicator that it converged
print("Fitter is done. Fit Cov Qual:", fitResult.covQual())
# save workspace to a TFile
getattr(fitWorkspace, 'import')(fitResult)
getattr(fitWorkspace, 'import')(model)
tf3 = TFile("%s/data/fitWorkspace.root" % dsi.latSWDir, "RECREATE")
fitWorkspace.Write()
tf3.Close()
mean = r.RooRealVar("mu", "mu", 5350, 5300, 5400)
sigma = r.RooRealVar("sg", "sg", 25, 0, 100)
spdf = r.RooGaussian("sig", "sig", mass, mean, sigma)
# exponential
slope = r.RooRealVar("lb", "lb", -0.002, -0.01, 0)
bpdf = r.RooExponential("bkg", "bkg", mass, slope)
# total
sy = r.RooRealVar("sy", "sy", 1000, 0, 10000)
by = r.RooRealVar("by", "by", 2000, 0, 10000)
pdf = r.RooAddPdf("pdf", "pdf", r.RooArgList(spdf, bpdf), r.RooArgList(sy, by))
# plot RooFit style
c = r.TCanvas()
pl = mass.frame(rf.Bins(800))
pdf.plotOn(
pl,
rf.Normalization(1, r.RooAbsReal.NumEvent),
rf.Precision(-1),
rf.Components("bkg"),
rf.LineColor(r.kRed),
rf.LineStyle(r.kDashed),
)
pdf.plotOn(
pl,
rf.Normalization(1, r.RooAbsReal.NumEvent),
rf.Precision(-1),
rf.Components("sig"),
rf.LineColor(r.kGreen + 3),
)
def fit_mass(data,
column,
x,
sig_pdf=None,
bkg_pdf=None,
n_sig=None,
n_bkg=None,
blind=False,
nll_profile=False,
second_storage=None,
log_plot=False,
pulls=True,
sPlot=False,
bkg_in_region=False,
importance=3,
plot_importance=3):
"""Fit a given pdf to a variable distribution
Parameter
---------
data : |hepds_type|
The data containing the variable to fit to
column : str
The name of the column to fit the pdf to
sig_pdf : RooFit pdf
The signal Probability Density Function. The variable to fit to has
to be named 'x'.
bkg_pdf : RooFit pdf
The background Probability Density Function. The variable to fit to has
to be named 'x'.
n_sig : None or numeric
The number of signals in the data. If it should be fitted, use None.
n_bkg : None or numeric
The number of background events in the data.
If it should be fitted, use None.
blind : boolean or tuple(numberic, numberic)
If False, the data is fitted. If a tuple is provided, the values are
used as the lower (the first value) and the upper (the second value)
limit of a blinding region, which will be omitted in plots.
Additionally, no true number of signal will be returned but only fake.
nll_profile : boolean
If True, a Negative Log-Likelihood Profile will be generated. Does not
work with blind fits.
second_storage : |hepds_type|
A second data-storage that will be concatenated with the first one.
importance : |importance_type|
|importance_docstring|
plot_importance : |plot_importance_type|
|plot_importance_docstring|
Return
------
tuple(numerical, numerical)
Return the number of signals and the number of backgrounds in the
signal-region. If a blind fit is performed, the signal will be a fake
number. If no number of background events is required, -999 will be
returned.
"""
if not (isinstance(column, str) or len(column) == 1):
raise ValueError("Fitting to several columns " + str(column) +
" not supported.")
if type(sig_pdf) == type(bkg_pdf) == None:
raise ValueError("sig_pdf and bkg_pdf are both None-> no fit possible")
if blind is not False:
lower_blind, upper_blind = blind
blind = True
n_bkg_below_sig = -999
# create data
data_name = data.name
data_array, _t1, _t2 = data.make_dataset(second_storage, columns=column)
del _t1, _t2
# double crystalball variables
min_x, max_x = min(data_array[column]), max(data_array[column])
# x = RooRealVar("x", "x variable", min_x, max_x)
# create data
data_array = np.array([i[0] for i in data_array.as_matrix()])
data_array.dtype = [('x', np.float64)]
tree1 = array2tree(data_array, "x")
data = RooDataSet("data", "Data", RooArgSet(x), RooFit.Import(tree1))
# # TODO: export somewhere? does not need to be defined inside...
# mean = RooRealVar("mean", "Mean of Double CB PDF", 5280, 5100, 5600)#, 5300, 5500)
# sigma = RooRealVar("sigma", "Sigma of Double CB PDF", 40, 0.001, 200)
# alpha_0 = RooRealVar("alpha_0", "alpha_0 of one side", 5.715)#, 0, 150)
# alpha_1 = RooRealVar("alpha_1", "alpha_1 of other side", -4.019)#, -200, 0.)
# lambda_0 = RooRealVar("lambda_0", "Exponent of one side", 3.42)#, 0, 150)
# lambda_1 = RooRealVar("lambda_1", "Exponent of other side", 3.7914)#, 0, 500)
#
# # TODO: export somewhere? pdf construction
# frac = RooRealVar("frac", "Fraction of crystal ball pdfs", 0.479, 0.01, 0.99)
#
# crystalball1 = RooCBShape("crystallball1", "First CrystalBall PDF", x,
# mean, sigma, alpha_0, lambda_0)
# crystalball2 = RooCBShape("crystallball2", "Second CrystalBall PDF", x,
# mean, sigma, alpha_1, lambda_1)
# doubleCB = RooAddPdf("doubleCB", "Double CrystalBall PDF",
# crystalball1, crystalball2, frac)
# n_sig = RooRealVar("n_sig", "Number of signals events", 10000, 0, 1000000)
# test input
if n_sig == n_bkg == 0:
raise ValueError("n_sig as well as n_bkg is 0...")
if n_bkg is None:
n_bkg = RooRealVar("n_bkg", "Number of background events", 10000, 0,
500000)
elif n_bkg >= 0:
n_bkg = RooRealVar("n_bkg", "Number of background events", int(n_bkg))
else:
raise ValueError("n_bkg is not >= 0 or None")
if n_sig is None:
n_sig = RooRealVar("n_sig", "Number of signal events", 1050, 0, 200000)
# START BLINDING
blind_cat = RooCategory("blind_cat", "blind state category")
blind_cat.defineType("unblind", 0)
blind_cat.defineType("blind", 1)
if blind:
blind_cat.setLabel("blind")
blind_n_sig = RooUnblindPrecision("blind_n_sig",
"blind number of signals",
"wasistdas", n_sig.getVal(),
10000, n_sig, blind_cat)
else:
# blind_cat.setLabel("unblind")
blind_n_sig = n_sig
print "n_sig value " + str(n_sig.getVal())
# raw_input("blind value " + str(blind_n_sig.getVal()))
# n_sig = blind_n_sig
# END BLINDING
elif n_sig >= 0:
n_sig = RooRealVar("n_sig", "Number of signal events", int(n_sig))
else:
raise ValueError("n_sig is not >= 0")
# if not blind:
# blind_n_sig = n_sig
# # create bkg-pdf
# lambda_exp = RooRealVar("lambda_exp", "lambda exp pdf bkg", -0.00025, -1., 1.)
# bkg_pdf = RooExponential("bkg_pdf", "Background PDF exp", x, lambda_exp)
if blind:
comb_pdf = RooAddPdf("comb_pdf", "Combined DoubleCB and bkg PDF",
RooArgList(sig_pdf, bkg_pdf),
RooArgList(blind_n_sig, n_bkg))
else:
comb_pdf = RooAddPdf("comb_pdf", "Combined DoubleCB and bkg PDF",
RooArgList(sig_pdf, bkg_pdf),
RooArgList(n_sig, n_bkg))
# create test dataset
# mean_gauss = RooRealVar("mean_gauss", "Mean of Gaussian", 5553, -10000, 10000)
# sigma_gauss = RooRealVar("sigma_gauss", "Width of Gaussian", 20, 0.0001, 300)
# gauss1 = RooGaussian("gauss1", "Gaussian test dist", x, mean_gauss, sigma_gauss)
# lambda_data = RooRealVar("lambda_data", "lambda exp data", -.002)
# exp_data = RooExponential("exp_data", "data example exp", x, lambda_data)
# frac_data = RooRealVar("frac_data", "Fraction PDF of data", 0.15)
#
# data_pdf = RooAddPdf("data_pdf", "Data PDF", gauss1, exp_data, frac_data)
# data = data_pdf.generate(RooArgSet(x), 30000)
# data.printValue()
# xframe = x.frame()
# data_pdf.plotOn(xframe)
# print "n_cpu:", meta_config.get_n_cpu()
# input("test")
# comb_pdf.fitTo(data, RooFit.Extended(ROOT.kTRUE), RooFit.NumCPU(meta_config.get_n_cpu()))
# HACK to get 8 cores in testing
c5 = TCanvas("c5", "RooFit pdf not fit vs " + data_name)
c5.cd()
x_frame1 = x.frame()
# data.plotOn(x_frame1)
# comb_pdf.pdfList()[1].plotOn(x_frame1)
if __name__ == "__main__":
n_cpu = 8
else:
n_cpu = meta_config.get_n_cpu()
print "n_cpu = ", n_cpu
# HACK
# n_cpu = 8
result_fit = comb_pdf.fitTo(data, RooFit.Minos(ROOT.kTRUE),
RooFit.Extended(ROOT.kTRUE),
RooFit.NumCPU(n_cpu))
# HACK end
if bkg_in_region:
x.setRange("signal", bkg_in_region[0], bkg_in_region[1])
bkg_pdf_fitted = comb_pdf.pdfList()[1]
int_argset = RooArgSet(x)
# int_argset = x
# int_argset.setRange("signal", bkg_in_region[0], bkg_in_region[1])
integral = bkg_pdf_fitted.createIntegral(int_argset,
RooFit.NormSet(int_argset),
RooFit.Range("signal"))
bkg_cdf = bkg_pdf_fitted.createCdf(int_argset, RooFit.Range("signal"))
bkg_cdf.plotOn(x_frame1)
# integral.plotOn(x_frame1)
n_bkg_below_sig = integral.getVal(int_argset) * n_bkg.getVal()
x_frame1.Draw()
if plot_importance >= 3:
c2 = TCanvas("c2", "RooFit pdf fit vs " + data_name)
c2.cd()
x_frame = x.frame()
# if log_plot:
# c2.SetLogy()
# x_frame.SetTitle("RooFit pdf vs " + data_name)
x_frame.SetTitle(data_name)
if pulls:
pad_data = ROOT.TPad("pad_data", "Pad with data and fit", 0, 0.33,
1, 1)
pad_pulls = ROOT.TPad("pad_pulls", "Pad with data and fit", 0, 0,
1, 0.33)
pad_data.SetBottomMargin(0.00001)
pad_data.SetBorderMode(0)
if log_plot:
pad_data.SetLogy()
pad_pulls.SetTopMargin(0.00001)
pad_pulls.SetBottomMargin(0.2)
pad_pulls.SetBorderMode(0)
pad_data.Draw()
pad_pulls.Draw()
pad_data.cd()
else:
if log_plot:
c2.SetLogy()
if blind:
# HACK
column = 'x'
# END HACK
x.setRange("lower", min_x, lower_blind)
x.setRange("upper", upper_blind, max_x)
range_str = "lower,upper"
lower_cut_str = str(
min_x) + "<=" + column + "&&" + column + "<=" + str(lower_blind)
upper_cut_str = str(
upper_blind) + "<=" + column + "&&" + column + "<=" + str(max_x)
sideband_cut_str = "(" + lower_cut_str + ")" + "||" + "(" + upper_cut_str + ")"
n_entries = data.reduce(
sideband_cut_str).numEntries() / data.numEntries()
# raw_input("n_entries: " + str(n_entries))
if plot_importance >= 3:
data.plotOn(x_frame, RooFit.CutRange(range_str),
RooFit.NormRange(range_str))
comb_pdf.plotOn(
x_frame, RooFit.Range(range_str),
RooFit.Normalization(n_entries, RooAbsReal.Relative),
RooFit.NormRange(range_str))
if pulls:
# pull_hist(pull_frame=x_frame, pad_data=pad_data, pad_pulls=pad_pulls)
x_frame_pullhist = x_frame.pullHist()
else:
if plot_importance >= 3:
data.plotOn(x_frame)
comb_pdf.plotOn(x_frame)
if pulls:
pad_pulls.cd()
x_frame_pullhist = x_frame.pullHist()
pad_data.cd()
comb_pdf.plotOn(x_frame,
RooFit.Components(sig_pdf.namePtr().GetName()),
RooFit.LineStyle(ROOT.kDashed))
comb_pdf.plotOn(x_frame,
RooFit.Components(bkg_pdf.namePtr().GetName()),
RooFit.LineStyle(ROOT.kDotted))
# comb_pdf.plotPull(n_sig)
if plot_importance >= 3:
x_frame.Draw()
if pulls:
pad_pulls.cd()
x_frame.SetTitleSize(0.05, 'Y')
x_frame.SetTitleOffset(0.7, 'Y')
x_frame.SetLabelSize(0.04, 'Y')
# c11 = TCanvas("c11", "RooFit\ pulls" + data_name)
# c11.cd()
# frame_tmp = x_frame
frame_tmp = x.frame()
# frame_tmp.SetTitle("significance")
frame_tmp.SetTitle("Roofit\ pulls\ " + data_name)
frame_tmp.addObject(x_frame_pullhist)
frame_tmp.SetMinimum(-5)
frame_tmp.SetMaximum(5)
# frame_tmp.GetYaxis().SetTitle("significance")
frame_tmp.GetYaxis().SetNdivisions(5)
frame_tmp.SetTitleSize(0.1, 'X')
frame_tmp.SetTitleOffset(1, 'X')
frame_tmp.SetLabelSize(0.1, 'X')
frame_tmp.SetTitleSize(0.1, 'Y')
frame_tmp.SetTitleOffset(0.5, 'Y')
frame_tmp.SetLabelSize(0.1, 'Y')
frame_tmp.Draw()
# raw_input("")
if not blind and nll_profile:
# nll_range = RooRealVar("nll_range", "Signal for nLL", n_sig.getVal(),
# -10, 2 * n_sig.getVal())
sframe = n_sig.frame(RooFit.Bins(20), RooFit.Range(1, 1000))
# HACK for best n_cpu
lnL = comb_pdf.createNLL(data, RooFit.NumCPU(8))
# HACK end
lnProfileL = lnL.createProfile(ROOT.RooArgSet(n_sig))
lnProfileL.plotOn(sframe, RooFit.ShiftToZero())
c4 = TCanvas("c4", "NLL Profile")
c4.cd()
# input("press ENTER to show plot")
sframe.Draw()
if plot_importance >= 3:
pass
params = comb_pdf.getVariables()
params.Print("v")
# print bkg_cdf.getVal()
if sPlot:
sPlotData = ROOT.RooStats.SPlot(
"sPlotData",
"sPlotData",
data, # variable fitted to, RooDataSet
comb_pdf, # fitted pdf
ROOT.RooArgList(
n_sig,
n_bkg,
# NSigB0s
))
sweights = np.array([
sPlotData.GetSWeight(i, 'n_sig') for i in range(data.numEntries())
])
return n_sig.getVal(), n_bkg_below_sig, sweights
if blind:
return blind_n_sig.getVal(), n_bkg_below_sig, comb_pdf
else:
return n_sig.getVal(), n_bkg_below_sig, comb_pdf
def pdf_logPt2_incoh():
#PDF fit to log_10(pT^2)
#tree_in = tree_incoh
tree_in = tree
#ptbin = 0.04
ptbin = 0.12
ptmin = -5.
ptmax = 1.
mmin = 2.8
mmax = 3.2
#fitran = [-5., 1.]
fitran = [-0.9, 0.1]
binned = False
#gamma-gamma 131 evt for pT<0.18
#output log file
out = open("out.txt", "w")
ut.log_results(
out, "in " + infile + " in_coh " + infile_coh + " in_gg " + infile_gg)
loglist = [(x, eval(x)) for x in
["ptbin", "ptmin", "ptmax", "mmin", "mmax", "fitran", "binned"]]
strlog = ut.make_log_string(loglist)
ut.log_results(out, strlog + "\n")
#input data
pT = RooRealVar("jRecPt", "pT", 0, 10)
m = RooRealVar("jRecM", "mass", 0, 10)
dataIN = RooDataSet("data", "data", tree_in, RooArgSet(pT, m))
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
data = dataIN.reduce(strsel)
#x is RooRealVar for log(Pt2)
draw = "TMath::Log10(jRecPt*jRecPt)"
draw_func = RooFormulaVar("x", "log_{10}( #it{p}_{T}^{2} ) (GeV^{2})",
draw, RooArgList(pT))
x = data.addColumn(draw_func)
x.setRange("fitran", fitran[0], fitran[1])
#binned data
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
hPt = TH1D("hPt", "hPt", nbins, ptmin, ptmax)
tree_in.Draw(draw + " >> hPt", strsel)
dataH = RooDataHist("dataH", "dataH", RooArgList(x), hPt)
#range for plot
x.setMin(ptmin)
x.setMax(ptmax)
x.setRange("plotran", ptmin, ptmax)
#create the pdf
b = RooRealVar("b", "b", 5., 0., 10.)
pdf_func = "log(10.)*pow(10.,x)*exp(-b*pow(10.,x))"
pdf_logPt2 = RooGenericPdf("pdf_logPt2", pdf_func, RooArgList(x, b))
#make the fit
if binned == True:
r1 = pdf_logPt2.fitTo(dataH, rf.Range("fitran"), rf.Save())
else:
r1 = pdf_logPt2.fitTo(data, rf.Range("fitran"), rf.Save())
ut.log_results(out, ut.log_fit_result(r1))
#calculate norm to number of events
xset = RooArgSet(x)
ipdf = pdf_logPt2.createIntegral(xset, rf.NormSet(xset),
rf.Range("fitran"))
print "PDF integral:", ipdf.getVal()
if binned == True:
nevt = tree_incoh.Draw(
"", strsel + " && " + draw + ">{0:.3f}".format(fitran[0]) +
" && " + draw + "<{1:.3f}".format(fitran[0], fitran[1]))
else:
nevt = data.sumEntries("x", "fitran")
print "nevt:", nevt
pdf_logPt2.setNormRange("fitran")
print "PDF norm:", pdf_logPt2.getNorm(RooArgSet(x))
#a = nevt/ipdf.getVal()
a = nevt / pdf_logPt2.getNorm(RooArgSet(x))
ut.log_results(out, "log_10(pT^2) parametrization:")
ut.log_results(out, "A = {0:.2f}".format(a))
ut.log_results(out, ut.log_fit_parameters(r1, 0, 2))
print "a =", a
#Coherent contribution
hPtCoh = ut.prepare_TH1D("hPtCoh", ptbin, ptmin, ptmax)
hPtCoh.Sumw2()
#tree_coh.Draw(draw + " >> hPtCoh", strsel)
tree_coh.Draw("TMath::Log10(jGenPt*jGenPt) >> hPtCoh", strsel)
ut.norm_to_data(hPtCoh, hPt, rt.kBlue, -5., -2.2) # norm for coh
#ut.norm_to_data(hPtCoh, hPt, rt.kBlue, -5, -2.1)
#ut.norm_to_num(hPtCoh, 405, rt.kBlue)
print "Coherent integral:", hPtCoh.Integral()
#TMath::Log10(jRecPt*jRecPt)
#Sartre generated coherent shape
sartre = TFile.Open(
"/home/jaroslav/sim/sartre_tx/sartre_AuAu_200GeV_Jpsi_coh_2p7Mevt.root"
)
sartre_tree = sartre.Get("sartre_tree")
hSartre = ut.prepare_TH1D("hSartre", ptbin, ptmin, ptmax)
sartre_tree.Draw("TMath::Log10(pT*pT) >> hSartre",
"rapidity>-1 && rapidity<1")
ut.norm_to_data(hSartre, hPt, rt.kViolet, -5, -2) # norm for Sartre
#gamma-gamma contribution
hPtGG = ut.prepare_TH1D("hPtGG", ptbin, ptmin, ptmax)
tree_gg.Draw(draw + " >> hPtGG", strsel)
#ut.norm_to_data(hPtGG, hPt, rt.kGreen, -5., -2.9)
ut.norm_to_num(hPtGG, 131., rt.kGreen)
print "Int GG:", hPtGG.Integral()
#psi' contribution
psiP = TFile.Open(basedir_mc + "/ana_slight14e4x1_s6_sel5z.root")
psiP_tree = psiP.Get("jRecTree")
hPtPsiP = ut.prepare_TH1D("hPtPsiP", ptbin, ptmin, ptmax)
psiP_tree.Draw(draw + " >> hPtPsiP", strsel)
ut.norm_to_num(hPtPsiP, 12, rt.kViolet)
#sum of all contributions
hSum = ut.prepare_TH1D("hSum", ptbin, ptmin, ptmax)
hSum.SetLineWidth(3)
#add ggel to the sum
hSum.Add(hPtGG)
#add incoherent contribution
func_logPt2 = TF1("pdf_logPt2",
"[0]*log(10.)*pow(10.,x)*exp(-[1]*pow(10.,x))", -10.,
10.)
func_logPt2.SetParameters(a, b.getVal())
hInc = ut.prepare_TH1D("hInc", ptbin, ptmin, ptmax)
ut.fill_h1_tf(hInc, func_logPt2)
hSum.Add(hInc)
#add coherent contribution
hSum.Add(hPtCoh)
#add psi(2S) contribution
#hSum.Add(hPtPsiP)
#set to draw as a lines
ut.line_h1(hSum, rt.kBlack)
#create canvas frame
can = ut.box_canvas()
ut.set_margin_lbtr(gPad, 0.11, 0.09, 0.01, 0.01)
frame = x.frame(rf.Bins(nbins), rf.Title(""))
frame.SetTitle("")
frame.SetMaximum(75)
frame.SetYTitle("Events / ({0:.3f}".format(ptbin) + " GeV^{2})")
print "Int data:", hPt.Integral()
#plot the data
if binned == True:
dataH.plotOn(frame, rf.Name("data"))
else:
data.plotOn(frame, rf.Name("data"))
pdf_logPt2.plotOn(frame, rf.Range("fitran"), rf.LineColor(rt.kRed),
rf.Name("pdf_logPt2"))
pdf_logPt2.plotOn(frame, rf.Range("plotran"), rf.LineColor(rt.kRed),
rf.Name("pdf_logPt2_full"), rf.LineStyle(rt.kDashed))
frame.Draw()
amin = TMath.Power(10, ptmin)
amax = TMath.Power(10, ptmax) - 1
print amin, amax
pt2func = TF1("f1", "TMath::Power(10, x)", amin,
amax) #TMath::Power(x, 10)
aPt2 = TGaxis(-5, 75, 1, 75, "f1", 510, "-")
ut.set_axis(aPt2)
aPt2.SetTitle("pt2")
#aPt2.Draw();
leg = ut.prepare_leg(0.57, 0.78, 0.14, 0.19, 0.03)
ut.add_leg_mass(leg, mmin, mmax)
hx = ut.prepare_TH1D("hx", 1, 0, 1)
hx.Draw("same")
ln = ut.col_lin(rt.kRed)
leg.AddEntry(hx, "Data")
leg.AddEntry(hPtCoh, "Sartre MC", "l")
leg.AddEntry(hPtGG, "#gamma#gamma#rightarrow e^{+}e^{-} MC", "l")
#leg.AddEntry(ln, "ln(10)*#it{A}*10^{log_{10}#it{p}_{T}^{2}}exp(-#it{b}10^{log_{10}#it{p}_{T}^{2}})", "l")
#leg.AddEntry(ln, "Incoherent fit", "l")
leg.Draw("same")
l0 = ut.cut_line(fitran[0], 0.9, frame)
l1 = ut.cut_line(fitran[1], 0.9, frame)
#l0.Draw()
#l1.Draw()
desc = pdesc(frame, 0.14, 0.8, 0.054)
desc.set_text_size(0.03)
desc.itemD("#chi^{2}/ndf", frame.chiSquare("pdf_logPt2", "data", 2), -1,
rt.kRed)
desc.itemD("#it{A}", a, -1, rt.kRed)
desc.itemR("#it{b}", b, rt.kRed)
desc.draw()
#put the sum
#hSum.Draw("same")
#gPad.SetLogy()
frame.Draw("same")
#put gamma-gamma
hPtGG.Draw("same")
#put coherent J/psi
hPtCoh.Draw("same")
#put Sartre generated coherent shape
#hSartre.Draw("same")
#put psi(2S) contribution
#hPtPsiP.Draw("same")
leg2 = ut.prepare_leg(0.14, 0.9, 0.14, 0.08, 0.03)
leg2.AddEntry(
ln,
"ln(10)*#it{A}*10^{log_{10}#it{p}_{T}^{2}}exp(-#it{b}10^{log_{10}#it{p}_{T}^{2}})",
"l")
#leg2.AddEntry(hPtCoh, "Sartre MC reconstructed", "l")
#leg2.AddEntry(hSartre, "Sartre MC generated", "l")
leg2.Draw("same")
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def 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 plotSpectrum():
useMalbek = False
eName = "energy_keV"
eName = "trapENFCal"
# load workspace
f = TFile("./data/fitWorkspace.root")
fitWorkspace = f.Get("fitWorkspace")
fData = fitWorkspace.allData().front()
fitResult = fitWorkspace.allGenericObjects().front()
nPars = fitResult.floatParsFinal().getSize()
fEnergy = fitWorkspace.var(eName)
modelPDF = fitWorkspace.pdf("model")
# fitWorkspace.Print()
# get a list of pdf names
pdfNames = []
pdfList = fitWorkspace.allPdfs() # goddamn RooArgSet
itr = pdfList.createIterator()
var = itr.Next()
while var:
name = var.GetName()
if "ext" in name:
pdfNames.append(name)
var = itr.Next()
pdfNames = sorted(pdfNames)
# -- create spectrum rooplot --
nCol = float(gStyle.GetNumberOfColors())
binSize = 0.2
nBins = int((eHi - eLo) / binSize + 0.5)
fSpec = fEnergy.frame(RF.Range(eLo, eHi), RF.Bins(nBins))
fData.plotOn(fSpec)
modelPDF.plotOn(fSpec, RF.LineColor(ROOT.kRed), RF.Name("FullModel"))
chiSquare = fSpec.chiSquare(nPars)
# draw components
leg = TLegend(0.83, 0.1, 0.97, 0.9)
leg.AddEntry(fSpec.findObject("FullModel"),
"model #chi^{2}=%.3f" % chiSquare, "l")
for idx in range(len(pdfNames)):
name = pdfNames[idx]
lineCol = gStyle.GetColorPalette(int(nCol / len(pdfNames) * idx))
modelPDF.plotOn(fSpec, RF.Components(name), RF.LineColor(lineCol),
RF.Name(name))
plotName = name
if "ext-" in name:
plotName = plotName[4:]
leg.AddEntry(fSpec.findObject(name), plotName, "l")
# create normalized residual ("pull") rooplot
# (draw full model again so residuals are calculated against it)
modelPDF.plotOn(fSpec, RF.LineColor(ROOT.kRed), RF.Name("FullModel"))
res = fSpec.pullHist()
fRes = fEnergy.frame(RF.Title(" "))
fRes.addPlotable(res, "P")
# -- print fit results --
print "-- SPECFIT RESULTS -- "
print "%-10s = %.3f" % ("chiSq", chiSquare)
fitValsFinal = getRooArgDict(fitResult.floatParsFinal())
for name in sorted(fitValsFinal):
fitVal = fitValsFinal[name]
if "amp-" in name:
error = fitWorkspace.var(name).getError()
print "%-10s = best %-7.3f error %.3f (w/o profile)" % (
name, fitVal, error)
elif "mu-" in name:
# compare the energy offset
pkName = name[3:]
pct = 100 * (1 - fitVal / pkList[pkName])
print "%-10s : fit %-6.3f lit %-6.3f (%.3f%%)" % (
name, fitVal, pkList[pkName], pct)
elif "sig-" in name:
# compare the sigma difference
pkName = name[4:]
pct = 100 * (1 - fitVal / getSigma(pkList[pkName]))
print "%-10s : fit %-6.3f func %-6.3f (%.3f%%)" % (
name, fitVal, getSigma(pkList[pkName]), pct)
else:
print "%s = %.4f" % (name, fitVal)
continue
# -- make spectrum plot w/ residual, w/ all the formatting crap --
gStyle.SetOptStat(0)
gStyle.SetPalette(
ROOT.kRainBow) # https://root.cern.ch/doc/master/classTColor.html#C06
c = TCanvas("c", "Bob Ross's Canvas", 1400, 1000)
p1 = TPad("p1", "spectrum", 0., 0.3, 1., 1.)
p2 = TPad("p2", "residual", 0., 0., 1., 0.3)
p1.Draw()
p2.Draw()
p1.SetRightMargin(0.2)
p1.SetBottomMargin(0.)
p2.SetRightMargin(0.2)
p2.SetTopMargin(0.)
p2.SetBottomMargin(0.4)
p1.cd()
# p1.SetGrid()
fSpec.SetTitle("")
fSpec.GetXaxis().SetLabelSize(0.)
fSpec.GetYaxis().SetLabelSize(0.05)
fSpec.GetYaxis().SetTitleSize(0.06)
fSpec.GetYaxis().SetTitleOffset(0.6)
fSpec.GetYaxis().SetTitle("Events / (%.1f keV)" % binSize)
fSpec.Draw()
leg.Draw("same")
p2.cd()
fRes.GetXaxis().SetLabelSize(0.1)
fRes.GetYaxis().SetLabelSize(0.1)
fRes.GetXaxis().SetTitleSize(0.15)
fRes.GetYaxis().SetTitle("Normalized Resid.")
fRes.GetYaxis().SetTitleOffset(0.3)
fRes.GetYaxis().SetTitleSize(0.1)
fRes.Draw()
zeroLine = ROOT.TLine(eLo, 0., eHi, 0.)
zeroLine.SetLineColor(ROOT.kBlack)
zeroLine.Draw("same")
c.Print("./plots/spectrum.pdf")
# -- correlation matrix --
c2 = TCanvas("c2", "Bob Ross's Canvas", 1100, 800)
c2.SetLeftMargin(0.15)
c2.SetRightMargin(0.12)
gStyle.SetPalette(ROOT.kDarkBodyRadiator)
corrMat = fitResult.correlationHist("Correlation Matrix")
corrMat.SetTitle("")
corrMat.GetXaxis().SetLabelSize(0.02)
corrMat.Draw("colz")
c2.Print("./plots/corrMatrix.pdf")
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., 10000)
nbkg = RooRealVar("nbkg", "#background events", 800, 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()
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 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")
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")
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")
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 runMCStudy():
# load workspace
f = TFile("./data/fitWorkspace.root")
fitWorkspace = f.Get("fitWorkspace")
fEnergy = fitWorkspace.var("energy_keV")
model = fitWorkspace.pdf("model")
fitResult = fitWorkspace.allGenericObjects().front()
fitValsFinal = getRooArgDict(fitResult.floatParsFinal())
pdfList = fitWorkspace.allPdfs() # RooArgSet
nExpected = int(model.expectedEvents(pdfList))
# thank you, lindsey gray. http://www.hep.wisc.edu/~lgray/toyMC.py
nSamples = 10
args = [
# RF.Binned(True),
RF.Silence(),
RF.FitOptions(RF.PrintEvalErrors(0),
RF.NumCPU(2)) # not sure numCPU is doing anything
]
mcStudy = ROOT.RooMCStudy(model, ROOT.RooArgSet(fEnergy), *args)
start = time.time()
mcStudy.generateAndFit(
nSamples, nExpected) # nSamples (nToys), nEvtPerSample (nEvents)
print "MC Study Complete. %i samples, %.2f seconds." % (
nSamples, time.time() - start)
parName = "amp-36Cl"
parVal = fitResult.floatParsFinal().find(parName).getValV()
parErr = fitResult.floatParsFinal().find(parName).getError()
parVar = fitWorkspace.var(parName)
# make 4 rooplot frames
fParam = mcStudy.plotParam(parVar, RF.Bins(50))
fError = mcStudy.plotError(
parVar, RF.FrameRange(parErr - 0.5 * parErr, parErr + 0.5 * parErr),
RF.Bins(50))
fPull = mcStudy.plotPull(parVar, RF.FrameRange(-5, 5), RF.Bins(50))
fNLL = mcStudy.plotNLL(RF.Bins(50))
line = TLine()
line.SetLineColor(ROOT.kBlue)
line.SetLineWidth(2)
line.SetLineStyle(3)
c = TCanvas("c", "c", 1100, 800)
c.Divide(2, 2)
c.cd(1)
fParam.SetTitle(parName)
fParam.Draw()
line.DrawLine(parVal, fParam.GetMinimum(), parVal,
fParam.GetMaximum()) # best fit
c.cd(2)
fError.SetTitle(parName + " Error")
fError.Draw()
line.DrawLine(parErr, fError.GetMinimum(), parErr, fError.GetMaximum())
c.cd(3)
fPull.SetTitle(parName + " Pull")
fPull.Draw()
c.cd(4)
fNLL.SetTitle("-log(likelihood)")
fNLL.Draw()
line.DrawLine(fitResult.minNll(), fNLL.GetMinimum(), fitResult.minNll(),
fNLL.GetMaximum())
c.Print("plots/mcStudy.pdf")
"""
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", -8, 8 )
# Construct signal pdf
mean = RooRealVar( "mean", "mean", 0, -8, 8 )
sigma = RooRealVar( "sigma", "sigma", 0.3, 0.1, 10 )
gx = RooGaussian( "gx", "gx", x, mean, sigma )
# Construct background pdf
a0 = RooRealVar( "a0", "a0", -0.1, -1, 1 )
a1 = RooRealVar( "a1", "a1", 0.004, -1, 1 )
px = RooChebychev( "px", "px", x, RooArgList( a0, a1 ) )
# Construct composite pdf
f = RooRealVar( "f", "f", 0.2, 0., 1. )
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", -3, -8, 8 )
gx_ctl = RooGaussian( "gx_ctl", "gx_ctl", x, mean_ctl, sigma )
# Construct the background pdf
a0_ctl = RooRealVar( "a0_ctl", "a0_ctl", -0.1, -1, 1 )
a1_ctl = RooRealVar( "a1_ctl", "a1_ctl", 0.5, -0.1, 1 )
px_ctl = RooChebychev( "px_ctl", "px_ctl", x, RooArgList( a0_ctl, a1_ctl ) )
# Construct the composite model
f_ctl = RooRealVar( "f_ctl", "f_ctl", 0.5, 0., 1. )
model_ctl = RooAddPdf( "model_ctl", "model_ctl", RooArgList( gx_ctl, px_ctl ),
RooArgList( f_ctl ) )
# G e n e r a t e e v e n t s f o r b o t h s a m p l e s
# ---------------------------------------------------------------
# Generate 1000 events in x and y from model
data = model.generate( RooArgSet( x ), 100 )
data_ctl = model_ctl.generate( RooArgSet( x ), 2000 )
# 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 = RooDataSet( "combData", "combined data", RooArgSet(x), RooFit.Index( sample ),
RooFit.Import( "physics", data ),
RooFit.Import( "control", data_ctl ) )
# 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()
# Second Gaussian PDF
mean2 = RooRealVar("mean2", "Mean of Gaussian 2", 1.02052, 1.0, 1.1)
sigma2 = RooRealVar("sigma2", "Width of Gaussian 2", 0.0072, 0.001, 1)
gauss2 = RooGaussian("gauss2", "gauss1(Mkk,mean2,sigma2)", Mkk, mean2, sigma2)
r2 = RooRealVar("r2", "ratio of width of gaussian 2", 3.2, 0, 10)
customGaussR = RooGenericPdf(
"customGaussR", "custom PDF build",
"1/(sigma1*r2) * exp(- (Mkk - mean2)**2 / (2 * (sigma1*r2) ** 2))",
RooArgList(Mkk, mean2, sigma1, r2))
# faster method:
r_sigma2 = RooFormulaVar("r_sigma2", "sigma1 * r2", RooArgList(sigma1, r2))
gauss2R = RooGaussian("gauss2R", "gauss1(Mkk,mean2,sigma2)", Mkk, mean2,
r_sigma2)
toyDataCustom = customGaussR.generate(RooArgSet(Mkk), 100000)
toyData = gauss2.generate(RooArgSet(Mkk), 100000)
toyDataR = gauss2R.generate(RooArgSet(Mkk), 100000)
c = TCanvas("c", "c", 800, 800)
frame1 = Mkk.frame(RooFit.Bins(50), RooFit.Title("Comparison of PDFs"))
# Plot all data tagged as passed sample
toyData.plotOn(frame1)
toyDataR.plotOn(frame1)
toyDataCustom.plotOn(frame1)
#totalPdf.paramOn(frame1, RooFit.Layout(0.55, 0.9, 0.9), RooFit.Format("NEU", RooFit.AutoPrecision(1)))
frame1.Draw()
def fit():
#fit to log_10(pT^2) with components and plot of plain pT^2
#range in log_10(pT^2)
ptbin = 0.12
ptmin = -5.
ptmax = 0.99 # 1.01
#range in pT^2
ptsq_bin = 0.03
ptsq_min = 1e-5
ptsq_max = 1
mmin = 2.8
mmax = 3.2
#range for incoherent fit
fitran = [-0.9, 0.1]
#number of gamma-gamma events
ngg = 131
#number of psi' events
npsiP = 20
#input data
pT = RooRealVar("jRecPt", "pT", 0, 10)
m = RooRealVar("jRecM", "mass", 0, 10)
data_all = RooDataSet("data", "data", tree, RooArgSet(pT, m))
#select for mass range
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
data = data_all.reduce(strsel)
#create log(pT^2) from pT
ptsq_draw = "jRecPt*jRecPt" # will be used for pT^2
logPtSq_draw = "TMath::Log10(" + ptsq_draw + ")"
logPtSq_form = RooFormulaVar("logPtSq", "logPtSq", logPtSq_draw,
RooArgList(pT))
logPtSq = data.addColumn(logPtSq_form)
logPtSq.setRange("fitran", fitran[0], fitran[1])
#bins and range for the plot
nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax)
logPtSq.setMin(ptmin)
logPtSq.setMax(ptmax)
logPtSq.setRange("plotran", ptmin, ptmax)
#range for pT^2
ptsq_nbins, ptsq_max = ut.get_nbins(ptsq_bin, ptsq_min, ptsq_max)
#incoherent parametrization
bval = RooRealVar("bval", "bval", 3.3, 0, 10)
inc_form = "log(10.)*pow(10.,logPtSq)*exp(-bval*pow(10.,logPtSq))"
incpdf = RooGenericPdf("incpdf", inc_form, RooArgList(logPtSq, bval))
#make the incoherent fit
res = incpdf.fitTo(data, rf.Range("fitran"), rf.Save())
#get incoherent norm to the number of events
lset = RooArgSet(logPtSq)
iinc = incpdf.createIntegral(lset, rf.NormSet(lset), rf.Range("fitran"))
inc_nevt = data.sumEntries("logPtSq", "fitran")
incpdf.setNormRange("fitran")
aval = RooRealVar("aval", "aval", inc_nevt / incpdf.getNorm(lset))
#print "A =", aval.getVal()
#print "b =", bval.getVal()
#incoherent distribution from log_10(pT^2) function for the sum with gamma-gamma
hIncPdf = ut.prepare_TH1D_n("hGG", nbins, ptmin, ptmax)
func_incoh_logPt2 = TF1("func_incoh_logPt2",
"[0]*log(10.)*pow(10.,x)*exp(-[1]*pow(10.,x))",
-10., 10.)
func_incoh_logPt2.SetNpx(1000)
func_incoh_logPt2.SetLineColor(rt.kMagenta)
func_incoh_logPt2.SetParameters(
aval.getVal(),
bval.getVal()) # 4.9 from incoherent mc, 3.3 from data fit
ut.fill_h1_tf(hIncPdf, func_incoh_logPt2, rt.kMagenta)
#gamma-gamma contribution
hGG = ut.prepare_TH1D_n("hGG", nbins, ptmin, ptmax)
tree_gg.Draw(logPtSq_draw + " >> hGG", strsel)
ut.norm_to_num(hGG, ngg, rt.kGreen + 1)
#sum of incoherent distribution and gamma-gamma
hSumIncGG = ut.prepare_TH1D_n("hSumIncGG", nbins, ptmin, ptmax)
hSumIncGG.Add(hIncPdf)
hSumIncGG.Add(hGG)
ut.line_h1(hSumIncGG, rt.kMagenta)
#gamma-gamma in pT^2
hGG_ptsq = ut.prepare_TH1D_n("hGG_ptsq", ptsq_nbins, ptsq_min, ptsq_max)
tree_gg.Draw(ptsq_draw + " >> hGG_ptsq", strsel)
ut.norm_to_num(hGG_ptsq, ngg, rt.kGreen + 1)
#psi' contribution
psiP_file = TFile.Open(basedir_mc + "/ana_slight14e4x1_s6_sel5z.root")
psiP_tree = psiP_file.Get("jRecTree")
hPsiP = ut.prepare_TH1D_n("hPsiP", nbins, ptmin, ptmax)
psiP_tree.Draw(logPtSq_draw + " >> hPsiP", strsel)
ut.norm_to_num(hPsiP, npsiP, rt.kViolet)
#psi' in pT^2
hPsiP_ptsq = ut.prepare_TH1D_n("hPsiP_ptsq", ptsq_nbins, ptsq_min,
ptsq_max)
psiP_tree.Draw(ptsq_draw + " >> hPsiP_ptsq", strsel)
ut.norm_to_num(hPsiP_ptsq, npsiP, rt.kViolet)
#create canvas frame
gStyle.SetPadTickY(1)
can = ut.box_canvas(1086, 543) # square area is still 768^2
can.SetMargin(0, 0, 0, 0)
can.Divide(2, 1, 0, 0)
gStyle.SetLineWidth(1)
can.cd(1)
ut.set_margin_lbtr(gPad, 0.11, 0.1, 0.01, 0)
frame = logPtSq.frame(rf.Bins(nbins))
frame.SetTitle("")
frame.SetMaximum(80)
frame.SetYTitle("Events / ({0:.3f}".format(ptbin) + " GeV^{2})")
frame.SetXTitle("log_{10}( #it{p}_{T}^{2} ) (GeV^{2})")
frame.GetXaxis().SetTitleOffset(1.2)
frame.GetYaxis().SetTitleOffset(1.6)
#plot the data
data.plotOn(frame, rf.Name("data"), rf.LineWidth(2))
#incoherent parametrization
incpdf.plotOn(frame, rf.Range("fitran"), rf.LineColor(rt.kRed),
rf.Name("incpdf"), rf.LineWidth(2))
incpdf.plotOn(frame, rf.Range("plotran"), rf.LineColor(rt.kRed),
rf.Name("incpdf_full"), rf.LineStyle(rt.kDashed),
rf.LineWidth(2))
frame.Draw()
#add gamma-gamma contribution
hGG.Draw("same")
#sum of incoherent distribution and gamma-gamma
#hSumIncGG.Draw("same")
#add psi'
#hPsiP.Draw("same")
#legend for log_10(pT^2)
leg = ut.prepare_leg(0.15, 0.77, 0.28, 0.19, 0.035)
hxl = ut.prepare_TH1D("hxl", 1, 0, 1)
hxl.Draw("same")
ilin = ut.col_lin(rt.kRed, 2)
ilin2 = ut.col_lin(rt.kRed, 2)
ilin2.SetLineStyle(rt.kDashed)
leg.AddEntry(ilin, "Incoherent parametrization, fit region", "l")
leg.AddEntry(ilin2, "Incoherent parametrization, extrapolation region",
"l")
leg.AddEntry(hGG, "#gamma#gamma#rightarrow e^{+}e^{-}", "l")
#leg.AddEntry(hxl, "Data", "lp")
leg.AddEntry(hxl, "Data, log_{10}( #it{p}_{T}^{2} )", "lp")
leg.Draw("same")
#----- plot pT^2 on the right -----
#pT^2 variable from pT
ptsq_form = RooFormulaVar("ptsq", "ptsq", ptsq_draw, RooArgList(pT))
ptsq = data.addColumn(ptsq_form)
#range for pT^2 plot
ptsq.setMin(ptsq_min)
ptsq.setMax(ptsq_max)
#make the pT^2 plot
can.cd(2)
gPad.SetLogy()
#gPad.SetLineWidth(3)
#gPad.SetFrameLineWidth(1)
ut.set_margin_lbtr(gPad, 0, 0.1, 0.01, 0.15)
ptsq_frame = ptsq.frame(rf.Bins(ptsq_nbins), rf.Title(""))
#print type(ptsq_frame), type(ptsq)
ptsq_frame.SetTitle("")
ptsq_frame.SetXTitle("#it{p}_{T}^{2} (GeV^{2})")
ptsq_frame.GetXaxis().SetTitleOffset(1.2)
data.plotOn(ptsq_frame, rf.Name("data"), rf.LineWidth(2))
ptsq_frame.SetMaximum(9e2)
ptsq_frame.SetMinimum(0.8) # 0.101
ptsq_frame.Draw()
#incoherent parametrization in pT^2 over the fit region, scaled to the plot
inc_ptsq = TF1("inc_ptsq", "[0]*exp(-[1]*x)", 10**fitran[0], 10**fitran[1])
inc_ptsq.SetParameters(aval.getVal() * ptsq_bin, bval.getVal())
#incoherent parametrization in the extrapolation region, below and above the fit region
inc_ptsq_ext1 = TF1("inc_ptsq_ext1", "[0]*exp(-[1]*x)", 0., 10**fitran[0])
inc_ptsq_ext2 = TF1("inc_ptsq_ext2", "[0]*exp(-[1]*x)", 10**fitran[1], 10)
inc_ptsq_ext1.SetParameters(aval.getVal() * ptsq_bin, bval.getVal())
inc_ptsq_ext1.SetLineStyle(rt.kDashed)
inc_ptsq_ext2.SetParameters(aval.getVal() * ptsq_bin, bval.getVal())
inc_ptsq_ext2.SetLineStyle(rt.kDashed)
inc_ptsq.Draw("same")
inc_ptsq_ext1.Draw("same")
inc_ptsq_ext2.Draw("same")
#add gamma-gamma in pT^2
hGG_ptsq.Draw("same")
#add psi' in pT^2
#hPsiP_ptsq.Draw("same")
#redraw the frame
#ptsq_frame.Draw("same")
ptsq_frame.GetXaxis().SetLimits(-9e-3, ptsq_frame.GetXaxis().GetXmax())
#vertical axis for pT^2 plot
xpos = ptsq_frame.GetXaxis().GetXmax()
ypos = ptsq_frame.GetMaximum()
ymin = ptsq_frame.GetMinimum()
ptsq_axis = TGaxis(xpos, 0, xpos, ypos, ymin, ypos, 510, "+GL")
ut.set_axis(ptsq_axis)
ptsq_axis.SetMoreLogLabels()
ptsq_axis.SetTitle("Events / ({0:.3f}".format(ptsq_bin) + " GeV^{2})")
ptsq_axis.SetTitleOffset(2.2)
ptsq_axis.Draw()
#legend for input data
#dleg = ut.prepare_leg(0.4, 0.77, 0.14, 0.18, 0.035)
dleg = ut.prepare_leg(0.4, 0.71, 0.16, 0.24, 0.035)
dleg.AddEntry(None, "#bf{|#kern[0.3]{#it{y}}| < 1}", "")
ut.add_leg_mass(dleg, mmin, mmax)
dleg.AddEntry(None, "AuAu@200 GeV", "")
dleg.AddEntry(None, "UPC sample", "")
dleg.AddEntry(hxl, "Data, #it{p}_{T}^{2}", "lp")
dleg.Draw("same")
#ut.invert_col_can(can)
can.SaveAs("01fig.pdf")
def plotFit():
axPeak = 2.464
# load workspace
f = TFile("./data/splitWorkspace.root")
fitWorkspace = f.Get("fitWorkspace")
fData = fitWorkspace.allData().front()
fitResult = fitWorkspace.allGenericObjects().front()
nPars = fitResult.floatParsFinal().getSize()
fEnergy = fitWorkspace.var("energy_keV")
modelPDF = fitWorkspace.pdf("model")
# fitWorkspace.Print()
pdfNames = ["ext-axion"]
# -- create spectrum rooplot --
nCol = float(gStyle.GetNumberOfColors())
binSize = 0.04
nBins = int((eHi - eLo) / binSize + 0.5)
fSpec = fEnergy.frame(RF.Range(eLo, eHi), RF.Bins(nBins))
fData.plotOn(fSpec)
modelPDF.plotOn(fSpec, RF.LineColor(ROOT.kRed), RF.Name("FullModel"))
chiSquare = fSpec.chiSquare(nPars)
modelPDF.plotOn(fSpec, RF.Components(pdfNames[0]),
RF.LineColor(ROOT.kBlue), RF.Name(pdfNames[0]))
# -- make a fake Gaussian --
# gaus = ROOT.TF1("g","gaus",-3, eHi)
# gaus.SetParameters(10., axPeak, getSigma(axPeak))
# gaus.SetParameter(0,10.)
# gaus.SetParameter(1, axPeak)
# gaus.SetParameter(2, getSigma(axPeak))
# erf
# rrvGaus = ROOT.RooRealVar("ax","ax",-3.,3.)
# rarGaus = RF.bindFunction("gaus", ROOT.TMath.Erf, rrvGaus)
# rarGaus.Print()
# frame2 = rrvGaus.frame(RF.Title("mygaus"))
# rarGaus.plotOn(frame2, RF.LineColor(ROOT.kGreen), RF.LineStyle(ROOT.kDashed), RF.Name("axGaus"))
# c0 = TCanvas("c0","",800,600)
# frame2.Draw()
# c0.Print("./plots/testGaus.pdf")
# -- print fit results --
print "-- SHIFTFIT RESULTS -- "
print "%-10s = %.3f" % ("chiSq", chiSquare)
fitValsFinal = getRooArgDict(fitResult.floatParsFinal())
bkgVal = 0.
for name in sorted(fitValsFinal):
fitVal = fitValsFinal[name]
if "amp-" in name:
error = fitWorkspace.var(name).getError()
print "%-10s = best %-7.3f error %.3f (w/o profile)" % (
name, fitVal, error)
elif "mu-" in name:
# compare the energy offset
pkName = name[3:]
pct = 100 * (1 - fitVal / axPeak)
print "%-10s : fit %-6.3f lit %-6.3f (%.3f%%)" % (name, fitVal,
axPeak, pct)
elif "sig-" in name:
# compare the sigma difference
pkName = name[4:]
pct = 100 * (1 - fitVal / getSigma(axPeak))
print "%-10s : fit %-6.3f func %-6.3f (%.3f%%)" % (
name, fitVal, getSigma(axPeak), pct)
else:
print "%s = %.4f (%.4f)" % (name, fitVal, fitVal / nBins)
bkgVal = fitVal / nBins
continue
# -- make spectrum plot --
c = TCanvas("c", "Bob Ross's Canvas", 1400, 1000)
c.SetRightMargin(0.2)
fSpec.SetTitle(" ")
fSpec.Draw()
ymax = fSpec.GetMaximum()
l1 = ROOT.TLine(axPeak, 0., axPeak, ymax)
l1.SetLineColor(ROOT.kBlue)
l1.SetLineWidth(2)
l1.Draw("same")
leg = TLegend(0.83, 0.6, 0.97, 0.9)
leg.AddEntry(fSpec.findObject("FullModel"),
"model #chi^{2}=%.3f" % chiSquare, "l")
leg.AddEntry(fSpec.findObject("FullModel"), "cts/bin=%.2f" % bkgVal, "")
leg.AddEntry(fSpec.findObject(pdfNames[0]), "axion gaussian", "l")
leg.AddEntry(l1, "axion-%.2f" % axPeak, "l")
leg.Draw("same")
c.Print("./plots/shiftFit.pdf")
# -- get FC Limit --
# Calculate the confidence interval for the axion peak, which is too low to use profile likelihood.
# TFeldmanCousins version:
# https://root.cern.ch/root/html/tutorials/math/FeldmanCousins.C.html
# RooStats version:
# https://root.cern.ch/root/html/tutorials/roostats/StandardFeldmanCousinsDemo.C.html
# FC Paper: https://arxiv.org/pdf/physics/9711021.pdf
f = TFeldmanCousins(0.95)
N_obs = 1.
N_bkg = bkgVal / 3.
ul = f.CalculateUpperLimit(N_obs, N_bkg)
ll = f.GetLowerLimit()
print "For %.2f events observed, and %.2f background events," % (N_obs,
N_bkg)
print "F-C method gives UL: %.2f and LL %.2f (90%% CL)" % (ul, ll)
50.,
'fC')
lnd = RooLandau('lnd', 'lnd', x, mpv, width)
sigma = RooRealVar(
'sigma',
'#sigma', #fpar[3],
sig_hist.GetRMS() / 5.,
0.,
50.,
'fC')
mean = RooConstVar('mean', 'mean', 0.)
res = RooGaussian('res', 'res', x, mean, sigma)
lxg = RooFFTConvPdf('lxg', 'lxg', x, lnd, res)
xf = x.frame(RooFit.Bins(Nbins))
sigDS.plotOn(xf)
fmip = RooRealVar('fmip', 'f_{mip}', 0.95, 0., 1.)
if havePeds:
if opts.sipm:
lxgplus = RooAddPdf('lxgplus', 'lxgplus', lxg,
ws.pdf('pedPlusOne'), fmip)
else:
lxgplus = RooAddPdf('lxgplus', 'lxgplus', lxg, ws.pdf('ped'), fmip)
ws.pdf('ped').plotOn(
xf, RooFit.LineColor(kRed), RooFit.LineStyle(kDashed),
RooFit.Normalization(sig_hist.GetEntries() / 3, RooAbsReal.Raw))
fitter = lxgplus
else:
fitter = lxg
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")
alpha.getError()))
ut.log_results(
out, "{0:6} {1:.3f} +/- {2:.3f}".format("n:", n.getVal(),
n.getError()))
#create the plot
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))
nSelJet_avg_bWsW - 1
) # N bkg for bWsW 1 : when rec s jet exist, avg of number of bkg is nSelJet_avg - 1
+ N_ttbar_reco_dilep * (vts_term_bWsW) * (ep_ns_sb) *
nSelJet_avg_bWsW # N bkg for bWsW 2 : when rec s jet does not exist, avg of number of bkg is nSelJet_avg
)
w.factory("expr::nbkg('nu*expected_bkg', {expected_bkg, nu})")
w.factory("SUM::model(nsig*sig, nbkg*bkg)")
w.factory("prod::sig_only(nsig,sig)")
w.factory("prod::bkg_only(nbkg,bkg)")
#w.factory("expr::sig_only('nsig*sig', {nsig, sig})")
#w.factory("expr::bkg_only('nbkg*bkg', {nbkg, bkg})")
c.cd(2)
data = w.pdf("model").generate(ROOT.RooArgSet(w.var("bdt")))
f = w.var("bdt").frame(RooFit.Bins(40))
data.plotOn(f, RooFit.MarkerColor(1))
w.pdf("model").plotOn(f, RooFit.LineColor(1))
w.obj("sig_only").plotOn(f, RooFit.LineColor(2))
w.obj("bkg_only").plotOn(f, RooFit.LineColor(4))
f.SetTitle("Generated Dataset")
f.Draw()
mc = RooStats.ModelConfig("mc", w)
mc.SetPdf(w.pdf("model"))
mc.SetParametersOfInterest("mu")
mc.SetObservables("bdt")
mc.SetNuisanceParameters("nbkg")
#getattr(w, 'import')(mc)
c.cd(3)
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")
ROOT.RooMinuit(sumNLL).migrad()
ROOT.RooMinuit(sumNLL).hesse()
ROOT.RooMinuit(sumNLL).minos()#optional
print "## Post-fit ##"
print "yield_WJets_pos:" , yield_WJets_pos.getVal()
print "yield_WJets_neg:" , yield_WJets_neg.getVal()
print "yield_TTJets:" , yield_TTJets.getVal()
yield_WJets_0b_postFit = yield_WJets_pos.getVal()*WJetsTemp_pos_.GetBinContent(1)+yield_WJets_neg.getVal()*WJetsTemp_neg_.GetBinContent(1)
yield_WJets_0b_preFit = WJetsHist_pos.GetBinContent(1)+WJetsHist_neg.GetBinContent(1)
yields_WJets_0b_postFit.append(yield_WJets_0b_postFit)
print "W+Jets scaled by: ", yield_WJets_0b_postFit/yield_WJets_0b_preFit
fitFrame_PosPdg=x.frame(rf.Bins(50),rf.Title("FitModel"))
model_total_pos.paramOn(fitFrame_PosPdg,rf.Layout(0.42,0.9,0.9))
data_hist_pos.plotOn(fitFrame_PosPdg,rf.LineColor(ROOT.kRed))
model_total_pos.plotOn(fitFrame_PosPdg,rf.LineStyle(ROOT.kDashed))
model_total_pos.plotOn(fitFrame_PosPdg,rf.Components("model_WJets_pos"),rf.LineColor(ROOT.kGreen))
model_total_pos.plotOn(fitFrame_PosPdg,rf.Components("model_TTJets"),rf.LineColor(ROOT.kBlue))
#model_total_pos.plotOn(fitFrame_PosPdg,rf.Components("model_Diboson_pos"),rf.LineColor(ROOT.kOrange+7))
fitFrame_NegPdg=x.frame(rf.Bins(50),rf.Title("FitModel"))
model_total_neg.paramOn(fitFrame_NegPdg,rf.Layout(0.42,0.9,0.9))
data_hist_neg.plotOn(fitFrame_NegPdg,rf.LineColor(ROOT.kRed))
model_total_neg.plotOn(fitFrame_NegPdg,rf.LineStyle(ROOT.kDashed))
model_total_neg.plotOn(fitFrame_NegPdg,rf.Components("model_WJets_neg"),rf.LineColor(ROOT.kGreen))
model_total_neg.plotOn(fitFrame_NegPdg,rf.Components("model_TTJets"),rf.LineColor(ROOT.kBlue))
#model_total_neg.plotOn(fitFrame_NegPdg,rf.Components("model_Diboson_neg"),rf.LineColor(ROOT.kOrange+7))
def make_fit():
adc_bin = 12 #18 for low-m gg, 24 for jpsi
adc_min = 0. #10.
adc_max = 400.
#adc_max = 1200
ptmax = 0.18
#mmin = 1.6
#mmin = 2.1
#mmax = 2.6
#mmin = 1.5
#mmax = 5.
mmin = 2.9
mmax = 3.2
#mmin = 3.4
#mmax = 4.6
#east/west projections and 2D plot
ew = 1
p2d = 2 # 0: single projection by 'ew', 1: 2D plot, 2: both projections
#plot colors
model_col = rt.kMagenta
model_col = rt.kBlue
out = open("out.txt", "w")
lmg = 6
ut.log_results(out, "in " + infile, lmg)
strlog = "adc_bin " + str(adc_bin) + " adc_min " + str(
adc_min) + " adc_max " + str(adc_max)
strlog += " ptmax " + str(ptmax) + " mmin " + str(mmin) + " mmax " + str(
mmax)
ut.log_results(out, strlog, lmg)
#adc distributions
adc_east = RooRealVar("jZDCUnAttEast", "ZDC ADC east", adc_min, adc_max)
adc_west = RooRealVar("jZDCUnAttWest", "ZDC ADC west", adc_min, adc_max)
#kinematics variables
m = RooRealVar("jRecM", "e^{+}e^{-} mass (GeV)", 0., 10.)
y = RooRealVar("jRecY", "rapidity", -1., 1.)
pT = RooRealVar("jRecPt", "pT", 0., 10.)
#adc distributions
#adc_east = RooRealVar("zdce", "ZDC ADC east", adc_min, adc_max)
#adc_west = RooRealVar("zdcw", "ZDC ADC west", adc_min, adc_max)
#kinematics variables
#m = RooRealVar("mee", "e^{+}e^{-} mass (GeV)", 0., 10.)
#y = RooRealVar("rapee", "rapidity", -1., 1.)
#pT = RooRealVar("ptpair", "pT", 0., 10.)
strsel = "jRecPt<{0:.3f} && jRecM>{1:.3f} && jRecM<{2:.3f}".format(
ptmax, mmin, mmax)
#strsel = "ptpair<{0:.3f} && mee>{1:.3f} && mee<{2:.3f}".format(ptmax, mmin, mmax)
data_all = RooDataSet("data", "data", tree,
RooArgSet(adc_east, adc_west, m, y, pT))
print "All input:", data_all.numEntries()
data = data_all.reduce(strsel)
print "Sel input:", data.numEntries()
model = Model2D(adc_east, adc_west)
r1 = model.model.fitTo(data, rf.Save())
ut.log_results(out, ut.log_fit_result(r1), lmg)
ut.log_results(out, "Fit parameters:\n", lmg)
out.write(ut.log_fit_parameters(r1, lmg + 2) + "\n")
#out.write(ut.table_fit_parameters(r1))
#print ut.table_fit_parameters(r1)
#create the plot
if p2d != 2: can = ut.box_canvas()
nbins, adc_max = ut.get_nbins(adc_bin, adc_min, adc_max)
adc_east.setMax(adc_max)
adc_west.setMax(adc_max)
frame_east = adc_east.frame(rf.Bins(nbins), rf.Title(""))
frame_west = adc_west.frame(rf.Bins(nbins), rf.Title(""))
data.plotOn(frame_east, rf.Name("data"))
model.model.plotOn(frame_east, rf.Precision(1e-6), rf.Name("model"),
rf.LineColor(model_col))
data.plotOn(frame_west, rf.Name("data"))
model.model.plotOn(frame_west, rf.Precision(1e-6), rf.Name("model"),
rf.LineColor(model_col))
#reduced chi^2 in east and west projections
ut.log_results(out, "chi2/ndf:\n", lmg)
ut.log_results(
out,
" East chi2/ndf: " + str(frame_east.chiSquare("model", "data", 16)),
lmg)
ut.log_results(
out,
" West chi2/ndf: " + str(frame_west.chiSquare("model", "data", 16)),
lmg)
ut.log_results(out, "", 0)
ytit = "Events / ({0:.0f} ADC units)".format(adc_bin)
frame_east.SetYTitle(ytit)
frame_west.SetYTitle(ytit)
frame_east.SetTitle("")
frame_west.SetTitle("")
frame = [frame_east, frame_west]
if p2d == 0: plot_projection(frame[ew], ew)
plot_pdf = PlotPdf(model, adc_east, adc_west)
if p2d == 1: plot_2d(plot_pdf)
if p2d == 2:
frame2 = ut.prepare_TH1D("frame2", adc_bin, adc_min,
2. * adc_max + 4.1 * adc_bin)
plot_proj_both(frame2, frame_east, frame_west, adc_bin, adc_min,
adc_max, ptmax, mmin, mmax)
lhead = ["east ZDC", "west ZDC"]
if p2d == 1:
leg = ut.prepare_leg(0.003, 0.9, 0.3, 0.1, 0.035)
else:
leg = ut.prepare_leg(0.66, 0.8, 0.32, 0.13, 0.03)
if p2d == 0: leg.AddEntry(None, "#bf{Projection to " + lhead[ew] + "}", "")
leg.SetMargin(0.05)
leg.AddEntry(None,
"#bf{#it{p}_{T} < " + "{0:.2f}".format(ptmax) + " GeV/c}", "")
mmin_fmt = "{0:.1f}".format(mmin)
mmax_fmt = "{0:.1f}".format(mmax)
leg.AddEntry(
None, "#bf{" + mmin_fmt + " < #it{m}_{e^{+}e^{-}} < " + mmax_fmt +
" GeV/c^{2}}", "")
leg.Draw("same")
pleg = ut.prepare_leg(0.99, 0.87, -0.4, 0.11, 0.035)
pleg.SetFillStyle(1001)
#pleg.AddEntry(None, "STAR Preliminary", "")
pleg.AddEntry(None, "AuAu@200 GeV", "")
pleg.AddEntry(None, "UPC sample", "")
#pleg.Draw("same")
#ut.print_pad(gPad)
#b3d = TBuffer3D(0)
#b3d = None
#gPad.GetViewer3D().OpenComposite(b3d)
#print b3d
#print "All input: ", data.numEntries()
#print "All input: 858"
#all input data
nall = float(tree.Draw("", strsel))
print "All input: ", nall
n_1n1n = float(model.num_1n1n.getVal())
print "1n1n events: ", n_1n1n
ratio_1n1n = n_1n1n / nall
sigma_ratio_1n1n = ratio_1n1n * TMath.Sqrt(
(nall - n_1n1n) / (nall * n_1n1n))
print "Ratio 1n1n / all: ", ratio_1n1n, "+/-", sigma_ratio_1n1n
ut.log_results(out, "Fraction of 1n1n events:\n", lmg)
ut.log_results(out, "All input: " + str(nall), lmg)
ut.log_results(out, "1n1n events: " + str(model.num_1n1n.getVal()), lmg)
ratio_str = "Ratio 1n1n / all: " + str(ratio_1n1n) + " +/- " + str(
sigma_ratio_1n1n)
ut.log_results(out, ratio_str, lmg)
if p2d != 2:
#ut.print_pad(gPad)
ut.invert_col(gPad)
can.SaveAs("01fig.pdf")
if interactive == True: start_interactive()
def plotFit():
from ROOT import TFile, TCanvas, TH1D
f = TFile("%s/data/fitWorkspace.root" % dsi.latSWDir)
fitWorkspace = f.Get("fitWorkspace")
fData = fitWorkspace.allData().front()
fitResult = fitWorkspace.allGenericObjects().front()
nPars = fitResult.floatParsFinal().getSize()
hitE = fitWorkspace.var("trapENFCal")
model = fitWorkspace.pdf("model")
# fitWorkspace.Print()
# plot data
fSpec = hitE.frame(RF.Range(eLo,eHi), RF.Bins(nB))
fData.plotOn(fSpec)
# plot model and components
model.plotOn(fSpec, RF.LineColor(ROOT.kRed), RF.Name("FullModel"))
c = TCanvas("c","c", 1400, 1000)
fSpec.SetTitle("")
fSpec.Draw()
c.Print("%s/plots/spectrum-after.pdf" % dsi.latSWDir)
c.Clear()
# get fit results
fitVals = {}
for i in range(nPars):
fp = fitResult.floatParsFinal()
name = fp.at(i).GetName()
fitVal = fp.at(i).getValV()
fitErr = fp.at(i).getError()
print("%s fitVal %.2f error %.2f" % (name, fitVal, fitErr))
if name == "amp-68GeK": nPk = fitVal
if name == "amp-bkg": nBk = fitVal
if name == "amp-trit": nTr = fitVal
# === duplicate the rooplot in matplotlib ===
plt.close()
tf = TFile("%s/data/latDS%s.root" % (dsi.latSWDir,''.join([str(d) for d in dsList])))
tt = tf.Get("skimTree")
tCut = "isEnr==1" if enr is True else "isEnr==0"
tCut = "isEnr" if enr else "!isEnr"
tCut += " && trapENFCal >= %.1f && trapENFCal <= %.1f" % (eLo, eHi)
n = tt.Draw("trapENFCal", tCut, "goff")
trapE = tt.GetV1()
trapE = [trapE[i] for i in range(n)]
x, hData = wl.GetHisto(trapE, eLo, eHi, epb)
# plt.plot(x, hData, ls='steps', c='b') # normal histo
hErr = np.asarray([np.sqrt(h) for h in hData]) # statistical error
plt.errorbar(x, hData, yerr=hErr, c='k', ms=5, linewidth=0.5, fmt='.', capsize=1, zorder=1) # pretty convincing rooplot fake
# plot the model components and total
tf2 = TFile("%s/data/specPDFs.root" % dsi.latSWDir)
# get (eff-corrected) histos and normalize to 1 in the global energy range
hTr = tf2.Get("h5")
if eff: hTr = getEffCorrTH1D(hTr, pLo, pHi, nBP)
hBkg = getBkgPDF(eff)
hPk = peakPDF(10.37, getSigma(10.37), "68GeK", eff)
x1, y1, xpb1 = wl.npTH1D(hTr)
x2, y2, xpb2 = wl.npTH1D(hBkg)
x3, y3, xpb3 = wl.npTH1D(hPk)
x1, y1 = normPDF(x1, y1, eLo, eHi)
x2, y2 = normPDF(x2, y2, eLo, eHi)
x3, y3 = normPDF(x3, y3, eLo, eHi)
nTot = nTr + nBk + nPk
if abs(nTr - np.sum(y1 * nTr)) > 3: print("Error in trit: nTr %d cts in curve %d" % (nTr, np.sum(y1*nTr)))
if abs(nTr - np.sum(y2 * nTr)) > 3: print("Error in bkg: nTr %d cts in curve %d" % (nTr, np.sum(y2*nTr)))
if abs(nTr - np.sum(y3 * nTr)) > 3: print("Error in peak: nTr %d cts in curve %d" % (nTr, np.sum(y3*nTr)))
# === reverse the efficiency correction to get the "true" number of counts
y1c = nTr * getEffCorr(x1, y1, inv=True)
y2c = nBk * getEffCorr(x2, y2, inv=True)
y3c = nPk * getEffCorr(x3, y3, inv=True)
nTotC = np.sum(y1c) + np.sum(y2c) + np.sum(y3c)
# === plot total model
pdfs = [[x1,y1,xpb1,nTr],[x2,y2,xpb2,nBk],[x3,y3,xpb3,nPk]]
xT, yT = getTotalModel(pdfs, eLo, eHi, epb, smooth=True)
plt.step(xT, yT, c='b', lw=2, label="Raw (no eff. corr): %d cts" % nTot)
# === plot components of the (uncorrected) model
# *** NOTE: to plot after the fit, multiply by (global bin width / bin width when generated). to integrate, don't. ***
plt.step(x1, y1 * nTr * (epb/ppb), c='m', lw=2, alpha=0.7, label="Tritium: %d cts" % nTr)
plt.step(x2, y2 * nBk * (epb/epb), c='g', lw=2, alpha=0.7, label="Bkg: %d cts" % nBk)
plt.step(x3, y3 * nPk * (epb/ppb), c='c', lw=2, alpha=0.7, label="68GeK %d cts" % nPk)
# === plot efficiency corrected final model
pdfs = [[x1,y1c,xpb1,nTr],[x2,y2c,xpb2,nBk],[x3,y3c,xpb3,nPk]]
xTc, yTc = getTotalModel(pdfs, eLo, eHi, epb, smooth=True, amp=False)
plt.step(xTc, yTc, c='r', lw=3, label="Efficiency corrected: %d cts" % nTotC)
# === plot components of the corrected model
# plt.step(x1, y1c * (epb/ppb), c='orange', lw=2, alpha=0.7, label="trit fit: %d corr: %d" % (nTr, np.sum(y1c)))
# plt.step(x2, y2c * (epb/epb), c='orange', lw=2, alpha=0.7, label="bkg fit: %d corr: %d" % (nBk, np.sum(y2c)))
# plt.step(x3, y3c * (epb/ppb), c='orange', lw=2, alpha=0.7, label="peak fit: %d corr: %d" % (nPk, np.sum(y3c)))
plt.xlabel("Energy (keV)", ha='right', x=1)
plt.ylabel("Counts / %.1f keV" % epb, ha='right', y=1)
plt.legend(loc=1, fontsize=12)
plt.xlim(eLo, eHi)
plt.ylim(ymin=0)
plt.tight_layout()
# plt.show()
plt.savefig("%s/plots/sf4-mplafter.pdf" % dsi.latSWDir)