def GetPLRInterval(filename="workspace.root",
wsname='myWS',
interactive=False):
# this function loads a workspace and computes
# a Bayesian upper limit
pInFile = ROOT.TFile(filename, "read")
# load workspace
pWs = pInFile.Get(wsname)
if not pWs:
print "workspace ", wsname, " not found"
return -1
# printout workspace content
pWs.Print()
# load and print data from workspace
data = pWs.data("data")
data.Print()
# load and print S+B Model Config
pSbHypo = pWs.obj("SbHypo")
pSbHypo.Print()
# create RooStats Profiled Likelihood ratio calculator and set parameters
bCalc = RooStats.ProfileLikelihoodCalculator(data, pSbHypo)
bCalc.SetConfidenceLevel(0.95)
# estimate credible interval
# NOTE: unfortunate notation: the UpperLimit() name refers
# to the upper boundary of an interval,
# NOT to the upper limit on the parameter of interest
# (it just happens to be the same for the one-sided
# interval starting at 0)
pSInt = bCalc.GetInterval()
upper_bound = pSInt.UpperLimit(pWs.var('xsec'))
lower_bound = pSInt.LowerLimit(pWs.var('xsec'))
print "one-sided 95%.C.L. interval for xsec: ", "[", lower_bound, ", ", upper_bound, "]"
# make posterior PDF plot for POI
c1 = ROOT.TCanvas("plr", "likelihood furnction")
pPlot = RooStats.LikelihoodIntervalPlot(pSInt)
pPlot.SetRange(0., 0.006)
pPlot.SetMaximum(5.)
pPlot.SetNPoints(50)
pPlot.Draw()
ROOT.gPad.Update()
c1.SaveAs("plr_plot.pdf")
if interactive:
raw_input("\npress <enter> to continue")
def execute(self, ws, debug = 0):
print self.legend, 'Profile Likelihood calculation started...'
# time the action
t = TStopwatch()
t.Start()
# model config is guaranteed to be here
# the action won't configure without it
# and this code will never run unless valid model config is found
mconf = ws.obj(self._model_config_name)
_poi = mconf.GetParametersOfInterest()
plcInt = self._plc.GetInterval()
# stop watch and print how long it took to get the interval
t.Print()
# iterate over all parameters of interest and print out the intervals
# (could there be more than one?)
_iter = _poi.createIterator()
while True:
_poi_name = _iter().GetTitle()
lower_limit = plcInt.LowerLimit( _poi[_poi_name] )
upper_limit = plcInt.UpperLimit( _poi[_poi_name] )
print self.legend, 'Profile Likelihood interval for', _poi_name, 'is ['+ \
str(lower_limit) + ', ' + \
str(upper_limit) + ']'
if _iter.Next() == None:
break
if self._scan_plot:
# draw scan plot
print self.legend, 'making the likelihood scan plot'
_plot_name = _poi_name+'_plc_scan_exost.'+self._plot_format
c1 = TCanvas("c1", "c1", 600, 600)
plcPlot = RooStats.LikelihoodIntervalPlot(plcInt)
gROOT.SetStyle("Plain")
plcPlot.Draw()
c1.SaveAs(_plot_name)
return (lower_limit, upper_limit)
def plotProfiles():
f = TFile("./data/fitWorkspace.root")
fitWorkspace = f.Get("fitWorkspace")
fData = fitWorkspace.allData().front()
fEnergy = fitWorkspace.var("energy_keV")
model = fitWorkspace.pdf("model")
fitResult = fitWorkspace.allGenericObjects().front()
fitValsFinal = getRooArgDict(fitResult.floatParsFinal())
print "Fit Cov Qual:", fitResult.covQual()
nameList = ["amp-axion"]
# nameList = []
# for key in sorted(fitValsFinal):
# if "amp-" in key:
# nameList.append(key)
print "Generating profiles ..."
c = TCanvas("c", "c", 800, 600)
for name in nameList:
fitVal = fitValsFinal[name]
thisVar = fitWorkspace.var(name)
# Brian & Clint method
plc = RS.ProfileLikelihoodCalculator(fData, model,
ROOT.RooArgSet(thisVar))
plc.SetConfidenceLevel(0.90)
interval = plc.GetInterval()
lower = interval.LowerLimit(thisVar)
upper = interval.UpperLimit(thisVar)
print "%-10s = lo %-7.3f best %-7.3f hi %.3f" % (name, lower, fitVal,
upper)
plot = RS.LikelihoodIntervalPlot(interval)
# p1, pltHi = fitVal - 1.5*(fitVal - lower), fitVal + 1.5*(upper - fitVal)
# plot.SetRange(pltLo,pltHi)
plot.SetTitle("%s: lo %.3f fit %.3f hi %.3f" %
(name, lower, fitVal, upper))
plot.SetNPoints(50)
plot.Draw("tf1")
"""
# Lukas method
# note: lukas uses ModelConfig, to explicitly set observables, constraints, and nuisance parameters
# https://root-forum.cern.ch/t/access-toy-datasets-generated-by-roostat-frequentistcalculator/24465/8
mc = RS.ModelConfig('mc', fitWorkspace)
mc.SetPdf( model )
mc.SetParametersOfInterest( ROOT.RooArgSet(thisVar) )
mc.SetObservables( ROOT.RooArgSet(fEnergy) )
# lukas example
# mc.SetConstraintParameters( ROOT.RooArgSet(mean, sigma) )
# mc.SetNuisanceParameters( ROOT.RooArgSet(mean, sigma, n_bkg) )
# mc.SetGlobalObservables( ROOT.RooArgSet(mean_obs, sigma_obs) )
# need to make some RooArgSets from RooRealVars
# constraints, nuisances, globalobs = ROOT.RooArgSet(), ROOT.RooArgSet(), ROOT.RooArgSet()
# for parName in sorted(fitValsFinal):
# rrv = fitWorkspace.var(parName)
# if parName != name:
# constraints.add(rrv)
# # .. etc.
# pl = RS.ProfileLikelihoodCalculator(fData, mc)
# pl.SetConfidenceLevel(0.683) # lukas used 0.90
# interval = pl.GetInterval()
# plot = RS.LikelihoodIntervalPlot(interval)
# plot.SetNPoints(50)
# plot.Draw("")
"""
c.Print("./plots/profile_%s.pdf" % name)
def getProfile(idx=None, update=False):
from ROOT import TFile, TCanvas
from ROOT import RooStats as RS
f = TFile("%s/data/fitWorkspace.root" % dsi.latSWDir)
fitWorkspace = f.Get("fitWorkspace")
fData = fitWorkspace.allData().front()
hitE = fitWorkspace.var("trapENFCal")
model = fitWorkspace.pdf("model")
fitResult = fitWorkspace.allGenericObjects().front()
fPars = fitResult.floatParsFinal()
nPars = fPars.getSize()
# === 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]
fitVals[name] = [fitVal, fitErr, name.split('-')[1]]
# for f in fitVals:
# print(f, fitVals[f])
# === get "true" counts (reverse efficiency correction based on fit value) ===
hAx = getHistList("axion")
x, y, xpb = wl.npTH1D(hAx)
x, y = normPDF(x, y, eLo, eHi)
nCts, nErr, _ = fitVals["amp-axion"] # fit result
yc = nCts * getEffCorr(x, y, inv=True)
nCorr = np.sum(yc)
effCorr = nCorr / nCts
print("nCts %d nCorr %.2f effCorr %.2f" % (nCts, nCorr, effCorr))
# thesis plot, don't delete
# plt.step(x, y * nCts * (epb/xpb), c='r', lw=2, label="Eff-weighted: %.1f" % (nCts))
# plt.step(x, yc * (epb/xpb), c='b', lw=2, label="True counts: %.1f" % (nCorr))
# plt.xlabel("Energy (keV)", ha='right', x=1)
# plt.ylabel("Counts / keV", ha='right', y=1)
# plt.legend(loc=1)
# plt.tight_layout()
# plt.show()
tMode = "UPDATE" if update else "RECREATE"
tOut = TFile("%s/data/rs-plc.root" % dsi.latSWDir, "UPDATE")
start = time.clock()
name = "amp-axion"
fitVal = fitVals[name][0]
thisVar = fitWorkspace.var(name)
pCL = 0.9
plc = RS.ProfileLikelihoodCalculator(fData, model, ROOT.RooArgSet(thisVar))
plc.SetConfidenceLevel(0.90)
interval = plc.GetInterval()
lower = interval.LowerLimit(thisVar)
upper = interval.UpperLimit(thisVar)
plot = RS.LikelihoodIntervalPlot(interval)
plot.SetNPoints(50)
plot.Draw("tf1")
pName = "hP_%d" if idx is not None else "hP"
hProfile = plot.GetPlottedObject()
hProfile.SetName(pName)
hProfile.SetTitle("PL %.2f %s lo %.3f mid %.3f hi %.3f eC %.3f" %
(pCL, name, lower, fitVal, upper, effCorr))
hProfile.Write()
print(hProfile.GetTitle())
tOut.Close()
print("elapsed:", time.clock() - start)
#bplot . Draw()
#c1 . SaveAs("posterior_pdf.png")
# query interval
#print "Bayesian interval on s = [",
#print bInt.LowerLimit( ), ",",
#print bInt.UpperLimit( ), "]"
# Profile Likelihood Calculator
plc = RooStats.ProfileLikelihoodCalculator(data, modelConfig)
# run Profile Likelihood Calculator
plc.SetConfidenceLevel(0.95)
plInt = plc.GetInterval();
# make plots
c1 = TCanvas("c1")
lrplot = RooStats.LikelihoodIntervalPlot(plInt)
lrplot.Draw()
c1 . SaveAs("likelihood_interval.png")
# query interval
plc_lower = plInt.LowerLimit( wspace.var("s") )
plc_upper = plInt.UpperLimit( wspace.var("s") )
print "Profile Likelihood interval on s = [",
print plc_lower, ",",
print plc_upper, "]"
def main():
# ROOT settings
ROOT.Math.MinimizerOptions.SetDefaultMinimizer('Minuit')
# Workspace
w = ROOT.RooWorkspace('w')
# Observable
E = w.factory('E[0.,100.]')
# Constrained parameters and constraint PDF
mean = w.factory('mean[50.,49.,51.]')
mean_obs = w.factory('mean_obs[50.,49.,51.]')
mean_obs.setConstant(True)
mean_err = w.factory('mean_err[0.2]')
cpdf_mean = w.factory('Gaussian::cpdf_mean(mean,mean_obs,mean_err)')
print type(mean), type(mean_obs), type(mean_err), type(cpdf_mean)
return
sigma = w.factory('sigma[1.,0.5,1.5]')
sigma_obs = w.factory('sigma_obs[1.,0.5,1.5]')
sigma_obs.setConstant(True)
sigma_err = w.factory('sigma_err[0.1]')
cpdf_sigma = w.factory('Gaussian::cpdf_sigma(sigma,sigma_obs,sigma_err)')
# Signal
n_sig = w.factory('n_sig[0.,0.,10.]')
pdf_sig = w.factory('Gaussian::pdf_sig(E,mean,sigma)')
# Background
n_bkg = w.factory('n_bkg[10.,0.,50.]')
pdf_bkg = w.factory('Polynomial::pdf_bkg(E,{})')
# PDF
pdf_sum = w.factory('SUM::pdf_sum(n_sig*pdf_sig,n_bkg*pdf_bkg)')
pdf_const = w.factory('PROD::pdf_const({pdf_sum,cpdf_mean,cpdf_sigma})')
# ModelConfig
mc = RS.ModelConfig('mc', w)
mc.SetPdf(pdf_const)
mc.SetParametersOfInterest(ROOT.RooArgSet(n_sig))
mc.SetObservables(ROOT.RooArgSet(E))
mc.SetConstraintParameters(ROOT.RooArgSet(mean, sigma))
mc.SetNuisanceParameters(ROOT.RooArgSet(mean, sigma, n_bkg))
mc.SetGlobalObservables(ROOT.RooArgSet(mean_obs, sigma_obs))
# Create empty dataset
data = ROOT.RooDataSet('data', 'data', ROOT.RooArgSet(E))
# Profile Likelihood
pl = RS.ProfileLikelihoodCalculator(data, mc)
pl.SetConfidenceLevel(0.90)
interval = pl.GetInterval()
print(interval.LowerLimit(n_sig), interval.UpperLimit(n_sig))
plot = RS.LikelihoodIntervalPlot(interval)
plot.SetNPoints(50)
c = ROOT.TCanvas("c", "c", 800, 1100)
plot.Draw("")
c.Print("plotLukasPLC.pdf")
