def get_roofit_model( histograms, fit_boundaries, name = 'model' ):
data_label = 'data'
samples = sorted( histograms.keys() )
samples.remove( data_label )
roofit_histograms = {}
roofit_pdfs = {}
roofit_variables = {}
variables = RooArgList()
variable_set = RooArgSet()
fit_variable = RooRealVar( name , name, fit_boundaries[0], fit_boundaries[1] )
variables.add( fit_variable )
variable_set.add( fit_variable )
roofit_histograms[data_label] = RooDataHist( data_label,
data_label,
variables,
histograms[data_label] )
pdf_arglist = RooArgList()
variable_arglist = RooArgList()
N_total = histograms[data_label].Integral() * 2
N_min = 0
for sample in samples:
roofit_histogram = RooDataHist( sample, sample, variables, histograms[sample] )
roofit_histograms[sample] = roofit_histogram
roofit_pdf = RooHistPdf ( 'pdf' + sample, 'pdf' + sample, variable_set, roofit_histogram, 0 )
roofit_pdfs[sample] = roofit_pdf
roofit_variable = RooRealVar( sample, "number of " + sample + " events", histograms[sample].Integral(), N_min, N_total, "event" )
roofit_variables[sample] = roofit_variable
pdf_arglist.add( roofit_pdf )
variable_arglist.add( roofit_variable )
model = RooAddPdf( name, name, pdf_arglist, variable_arglist )
return model, roofit_histograms, fit_variable
def _make_underlying_model(self):
self.pdfs = {}
self.yields = {} # yields are plain floats
self.ryields = {} # keep track of roofit objects for memory management
nbins, xmin, xmax = self.plot.histos[0].GetBinning()
self.xvar = RooRealVar("x", "x", xmin, xmax)
self.xvar.setBins(nbins)
self.pdfs = {}
self.hists = []
pdfs = RooArgList()
yields = RooArgList()
for compname, comp in self.plot.histosDict.iteritems():
if comp.weighted.Integral() == 0:
continue
assert (isinstance(comp, Histogram))
hist = RooDataHist(compname, compname, RooArgList(self.xvar),
comp.weighted)
SetOwnership(hist, False)
# self.hists.append(hist)
pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist)
self.pdfs[compname] = pdf
# self.pdfs[compname].Print()
pdfs.add(pdf)
nevts = comp.Integral(xmin=xmin, xmax=xmax)
nmin = min(0, nevts * (1 - comp.uncertainty))
nmax = nevts * (1 + comp.uncertainty)
theyield = RooRealVar('n{}'.format(compname),
'n{}'.format(compname), nevts, nmin, nmax)
self.ryields[compname] = theyield
self.yields[compname] = nevts
yields.add(theyield)
self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def makeTTbarModel(workspace,label, model,channel, wtagger, constraint=[],peak="W", spectrum="_mj"):
info =""
if label.find("_ttbar_data")!=-1 and label.find("fail")==-1:
rrv_number_total = RooRealVar("rrv_number_total_ttbar_data"+info+"_"+channel,"rrv_number_total_ttbar_data"+info+"_"+channel,500,0.,1e10)
eff_ttbar = RooRealVar("eff_ttbar_data"+info+"_"+channel,"eff_ttbar_data"+info+"_"+channel,0.7,0.2,1.0)
if peak == "Wt":eff_ttbar = RooRealVar("eff_ttbar_data"+info+"_"+channel,"eff_ttbar_data"+info+"_"+channel,0.7,0.0,1.0)
rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "@0*@1", RooArgList(eff_ttbar,rrv_number_total))
elif label.find("_ttbar_data")!=-1 and label.find("fail")!=-1:
rrv_number_total = workspace.var("rrv_number_total_ttbar_data"+info+"_"+channel)
eff_ttbar = workspace.var("eff_ttbar_data"+info+"_"+channel)
rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "(1-@0)*@1", RooArgList(eff_ttbar,rrv_number_total))
elif label.find("_ttbar_TotalMC")!=-1 and label.find("fail")==-1:
rrv_number_total = RooRealVar("rrv_number_total_ttbar_TotalMC"+info+"_"+channel,"rrv_number_total_ttbar_TotalMC"+info+"_"+channel,500,0.,1e10)
eff_ttbar = RooRealVar("eff_ttbar_TotalMC"+info+"_"+channel,"eff_ttbar_TotalMC"+info+"_"+channel,0.7,0.2,1.0)
if peak == "Wt": eff_ttbar = RooRealVar("eff_ttbar_TotalMC"+info+"_"+channel,"eff_ttbar_TotalMC"+info+"_"+channel,0.7,0.0,1.0)
rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "@0*@1", RooArgList(eff_ttbar,rrv_number_total))
elif label.find("_ttbar_TotalMC")!=-1 and label.find("fail")!=-1:
rrv_number_total = workspace.var("rrv_number_total_ttbar_TotalMC"+info+"_"+channel)
eff_ttbar = workspace.var("eff_ttbar_TotalMC"+info+"_"+channel)
rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "(1-@0)*@1", RooArgList(eff_ttbar,rrv_number_total))
model_pdf = MakeGeneralPdf(workspace,label,model,spectrum,wtagger,channel,constraint,peak)
model = RooExtendPdf("model"+label+"_"+channel+spectrum,"model"+label+"_"+channel+spectrum, model_pdf, rrv_number)
getattr(workspace,"import")(model)
return workspace.pdf("model"+label+"_"+channel+spectrum)
def __init__(self, super=False):
DoubleGauss.__init__(self, super=super)
sXY = ('x', 'y')
s12 = ('1', '2')
diffW = {name: RooRealVar(name, name, 0.01, 1.7) for name in \
[c+'WidthW'+i+'Diff' for c in sXY for i in s12]}
widthW = {c+'WidthW'+i: RooFormulaVar(c+'WidthW'+i, c+'WidthN'+i+'+'+ \
c+'WidthM'+i+'Diff'+'+'+c+'WidthW'+i+'Diff', \
RooArgList(diffW[c+'WidthW'+i+'Diff'], \
self.Parameter[c+'WidthM'+i+'Diff'],
self.Parameter[c+'WidthN'+i])) for c in sXY for i in s12}
rhoW = {name: RooRealVar(name, name, -0.48, 0.48) for name in \
['rhoW'+i for i in s12]}
if super:
self.super = True
extra = {name: RooRealVar(name, name, 0.0, 1.0) for name in \
['w'+i+'MFraction' for i in s12]}
nf = [('M', lambda i: 'w'+i+'MFraction*(1.0-w'+i+'N)'), \
('W', lambda i: '(1.0-w'+i+'MFraction)*(1.0-w'+i+'N)')]
w = {'w'+i+n: RooFormulaVar('w'+i+n, f(i), \
RooArgList(extra['w'+i+'MFraction'], self.Parameter['w'+i+'N'])) \
for i in s12 for (n, f) in nf}
else:
extra = {name: RooRealVar(name, name, 0.0, 0.5*pi) for name in \
[a+i for a in ('theta', 'phi') for i in s12]}
nf = [('N', lambda i: 'sin(theta'+i+')**2*cos(phi'+i+')**2'), \
('M', lambda i: 'sin(theta'+i+')**2*sin(phi'+i+')**2'), \
('W', lambda i: 'cos(theta'+i+')**2')]
w = {'w'+i+n: RooFormulaVar('w'+i+n, f(i), \
RooArgList(extra['theta'+i], extra['phi'+i])) for i in s12 \
for (n, f) in nf}
for d in (diffW, widthW, rhoW, extra, w):
self.Parameter.update(d)
def predict(self, x, theta_true):
"""
Run the unbinned ML fit
"""
# Data
roodata = RooDataSet('data', 'data', RooArgSet(self.phistar))
for xval in x:
self.phistar.setVal(xval)
roodata.add(RooArgSet(self.phistar))
theta = RooRealVar('theta', 'theta', 0.5, self.theta_min, self.theta_max)
# The combined pdf
model = RooAddPdf('model', 'model',
RooArgList(self.pdfs['A'], self.pdfs['H']),
RooArgList(theta))
with stdout_redirected_to('%s/minuit_output.log' % self.outdir):
res = model.fitTo(roodata, Save(True))
nll = res.minNll()
fitted_theta = theta.getValV()
# Get Lambda(theta_true | theta_best)
with stdout_redirected_to():
logl = model.createNLL(roodata)
theta.setVal(theta_true)
nll_theta_true = logl.getValV()
nll_ratio = nll_theta_true - nll
return fitted_theta, nll, nll_ratio
def fit(model, hists, fitmethod, eps=1.0e-7):
"""Fit beam shapes to Beam Imaging data.
model: Beam shape model (derived from BeamShapeCore).
hists: List of four TH2F with BI data.
fitmethod: Function(pdf, data) that fits pdf to data.
eps: Value of convergence criteria.
"""
RooAbsReal.defaultIntegratorConfig().setEpsAbs(eps)
RooAbsReal.defaultIntegratorConfig().setEpsRel(eps)
modfuncs = model.model_functions()
datahist = [
RooDataHist('scan{0}Beam{1}RestDataHist'.format(c, i),
'scan{0}Beam{1}RestDataHist'.format(c, i),
RooArgList(model.xvar(), model.yvar()), hists[j])
for j, (i, c) in enumerate(ic)
]
sample = RooCategory('sample', 'sample')
for (i, c) in ic:
sample.defineType('{0}_ScanData_Beam{1}Rest'.format(c, i))
combdata = RooDataHist('combdata', 'combined data',
RooArgList(model.xvar(), model.yvar()),
RooFit.Index(sample),
RooFit.Import('X_ScanData_Beam1Rest', datahist[0]),
RooFit.Import('Y_ScanData_Beam1Rest', datahist[1]),
RooFit.Import('X_ScanData_Beam2Rest', datahist[2]),
RooFit.Import('Y_ScanData_Beam2Rest', datahist[3]))
simpdf = RooSimultaneous('simpdf', 'simultaneous pdf', sample)
for j, (i, c) in enumerate(ic):
simpdf.addPdf(modfuncs[j], '{0}_ScanData_Beam{1}Rest'.format(c, i))
result = fitmethod(simpdf, combdata)
return result, modfuncs, datahist
def makePlot(s):
if (type(s) == TH1D):
s.SetStats(0)
x = RooRealVar("x", "x", 0, 3)
l = RooArgList(x)
dh = RooDataHist("dh", "dh", l, s)
frame = x.frame()
dh.plotOn(frame)
#frame.SetTitle(name)
#frame.GetXaxis().SetTitle(s.GetXaxis().GetTitle())
frame.GetYaxis().SetTitle(s.GetYaxis().GetTitle())
# frame.GetYaxis().SetTopMargin(0.15)
#frame.Draw(draw)
return frame
elif (type(s) == TH2D):
s.SetStats(0)
x = RooRealVar("x", "x", 0, 3)
y = RooRealVar("y", "y", 0, 3)
l = RooArgList(x, y)
dh = RooDataHist("dh", "dh", l, s)
t = TGraph2D(s)
s.SetMarkerSize(1.0)
s.SetMarkerStyle(1)
#t.GetXaxis().SetTitle(s.GetXaxis().GetTitle())
return s
elif (type(s) == TGraph2D):
s.SetMarkerSize(1.0)
s.SetMarkerStyle(1)
return s
def RooFitSig(mbbarray, bdtarray, weightarray, TC_mass, binstart, binend):
fitstart = 40
fitend = 150
mbbarray = range(200)
bdtarray = range(200)
weightarray = range(200)
mass = RooRealVar("X", "m(bb)[GeV]", fitstart, fitend)
BDT = RooRealVar("BDT", "BDT", -1, 100)
weight = RooRealVar("weight", "weight", -100, 200)
branchnames = ["X", "BDT", "weight"]
dtype = np.dtype([(branchnames[idx], np.float64)
for idx in range(len(branchnames))])
treearray = np.array([(mbbarray[idx], bdtarray[idx], weightarray[idx])
for idx in range(len(mbbarray))], dtype)
tree = rnp.array2tree(treearray)
m0 = RooRealVar("m0", "m0", TC_mass * 1., TC_mass * 1. - 60.,
TC_mass * 1. + 60.)
m02 = RooRealVar("m02", "m02", TC_mass * 1., TC_mass * 1. - 60.,
TC_mass * 1. + 60.)
alpha = RooRealVar("alpha", "alpha", 1.295, 1.0, 1.6)
sigma2 = RooRealVar("sigma2", "sigma2", 35, 8., 100)
n = RooRealVar("n", "n", 5, 1, 35)
mean = RooRealVar("mean", "mean of gaussian", 750, 0, 6000)
sigma = RooRealVar("sigma", "width of gaussian", 90, 38, 300)
gauss = RooGaussian("gauss", "gaussian PDF", mass, m0, sigma)
gauss2 = RooGaussian("gauss2", "gaussian PDF", mass, m02, sigma2)
CBshape = RooCBShape("CBshape", "Crystal Ball PDF", mass, m0, sigma2,
alpha, n)
##PDF normalization
num1 = RooRealVar("num1", "number of events", 400, 0, 5000)
##relative weight of 2 PDFs
f = RooRealVar("f", "f", 0.95, 0.6, 1)
sigPdf = RooAddPdf("sigPdf", "Signal PDF", RooArgList(CBshape, gauss),
RooArgList(f))
extPdf = RooExtendPdf("extPdf", "extPdf", sigPdf, num1)
data = RooDataSet("data", "data", tree, RooArgSet(mass, BDT, weight),
"BDT>0", "weight")
xframe = mass.frame()
mass.setBins(20)
data.plotOn(xframe)
extPdf.plotOn(
xframe) #,Normalization(1.0,RooAbsReal.RelativeExpected),LineColor(1))
hist = extPdf.createHistogram("X", fitend - fitstart)
hist.SetAxisRange(binstart, binend)
return deepcopy(hist)
def rooFit203():
print ">>> setup model..."
x = RooRealVar("x", "x", -10, 10)
mean = RooRealVar("mean", "mean of gaussian", 0, -10, 10)
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, RooConst(1))
# Construct px = 1 (flat in x)
px = RooPolynomial("px", "px", x)
# Construct model = f*gx + (1-f)px
f = RooRealVar("f", "f", 0., 1.)
model = RooAddPdf("model", "model", RooArgList(gauss, px), RooArgList(f))
data = model.generate(RooArgSet(x), 10000) # RooDataSet
print ">>> fit to full data range..."
result_full = model.fitTo(data, Save(kTRUE)) # RooFitResult
print "\n>>> fit \"signal\" range..."
# Define "signal" range in x as [-3,3]
x.setRange("signal", -3, 3)
result_sig = model.fitTo(data, Save(kTRUE),
Range("signal")) # RooFitResult
print "\n>>> plot and print results..."
# Make plot frame in x and add data and fitted model
frame1 = x.frame(Title("Fitting a sub range")) # RooPlot
data.plotOn(frame1, Name("data"))
model.plotOn(frame1, Range("Full"), LineColor(kBlue),
Name("model")) # Add shape in full ranged dashed
model.plotOn(frame1, LineStyle(kDashed), LineColor(kRed),
Name("model2")) # By default only fitted range is shown
print "\n>>> result of fit on all data:"
result_full.Print()
print "\n>>> result of fit in in signal region (note increased error on signal fraction):"
result_sig.Print()
print ">>> draw on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
legend = TLegend(0.2, 0.85, 0.4, 0.65)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
gPad.SetLeftMargin(0.14)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.4)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend.AddEntry("data", "data", 'LEP')
legend.AddEntry("model", "fit (full range)", 'L')
legend.AddEntry("model2", "fit (signal range)", 'L')
legend.Draw()
canvas.SaveAs("rooFit203.png")
def fitNSig(ibdt, fulldata, isample):
mean = RooRealVar("mass", "mean", B0Mass_, 3, 7, "GeV")
sigma = RooRealVar("#sigma_{1}", "sigma", 0.028, 0, 10, "GeV")
signalGauss = RooGaussian("signalGauss", "signal gauss", theBMass, mean,
sigma)
sigma2 = RooRealVar("#sigma_{2}", "sigma2", 0.048, 0, 0.09, "GeV")
signalGauss2 = RooGaussian("signalGauss2", "signal gauss2", theBMass, mean,
sigma2)
f1 = RooRealVar("f1", "f1", 0.8, 0., 1.)
gaus = RooAddPdf("gaus", "gaus1+gaus2",
RooArgList(signalGauss, signalGauss2), RooArgList(f1))
pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10)
pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10)
# pol_c3 = RooRealVar ("p3" , "coeff x^2 term", 0.5, -10, 10);
# slope = RooRealVar ("slope" , "slope" , 0.5, -10, 10);
# bkg_exp = RooExponential("bkg_exp" , "exponential" , slope, theBMass );
bkg_pol = RooChebychev("bkg_pol", "2nd order pol", theBMass,
RooArgList(pol_c1))
nsig = RooRealVar("Yield", "signal frac", 40000, 0, 1000000)
nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000)
cut = cut_base + '&& bdt_prob > %s' % (ibdt)
data = fulldata.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut)
fitFunction = RooAddPdf("fitfunction", "fit function",
RooArgList(gaus, bkg_pol), RooArgList(nsig, nbkg))
r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(),
RooFit.Range(4.9, 5.6), RooFit.PrintLevel(-1))
frame = theBMass.frame()
data.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7))
fitFunction.plotOn(frame, )
fitFunction.plotOn(frame, RooFit.Components("bkg_pol"),
RooFit.LineStyle(ROOT.kDashed))
fitFunction.plotOn(frame, RooFit.Components("signalGauss"),
RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kGreen + 1))
fitFunction.plotOn(frame, RooFit.Components("signalGauss2"),
RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kOrange + 1))
parList = RooArgSet(nsig, sigma, sigma2, mean)
###### fitFunction.plotOn(frame, RooFit.Components("signalGauss2"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen+2));
fitFunction.paramOn(frame, RooFit.Parameters(parList),
RooFit.Layout(0.62, 0.86, 0.88))
canv = ROOT.TCanvas()
frame.Draw()
# canv.SaveAs('sig_fit_bdt%f_sample%i.pdf'%(ibdt,isample))
dict_s_v1[ibdt] = [nsig.getVal(), nsig.getError()]
dict_sigma[ibdt] = math.sqrt(f1.getVal() * (sigma.getVal()**2) +
(1 - f1.getVal()) * (sigma2.getVal()**2))
def rooFit103():
print ">>> construct generic pdf from interpreted expression..."
# To construct a proper p.d.f, the formula expression is explicitly normalized internally
# by dividing it by a numeric integral of the expresssion over x in the range [-20,20]
x = RooRealVar("x", "x", -20, 20)
alpha = RooRealVar("alpha", "alpha", 5, 0.1, 10)
genpdf = RooGenericPdf("genpdf", "genpdf",
"(1+0.1*abs(x)+sin(sqrt(abs(x*alpha+0.1))))",
RooArgList(x, alpha))
print ">>> generate and fit toy data...\n"
data = genpdf.generate(RooArgSet(x), 10000) # RooDataSet
genpdf.fitTo(data)
frame1 = x.frame(Title("Interpreted expression pdf")) # RooPlot
data.plotOn(frame1, Binning(40))
genpdf.plotOn(frame1)
print "\n>>> construct standard pdf with formula replacing parameter..."
mean2 = RooRealVar("mean2", "mean^2", 10, 0, 200)
sigma = RooRealVar("sigma", "sigma", 3, 0.1, 10)
mean = RooFormulaVar("mean", "mean", "sqrt(mean2)", RooArgList(mean2))
gaus2 = RooGaussian("gaus2", "gaus2", x, mean, sigma)
print ">>> generate and fit toy data...\n"
gaus1 = RooGaussian("gaus1", "gaus1", x, RooConst(10), RooConst(3))
data2 = gaus1.generate(RooArgSet(x), 1000) # RooDataSet
result = gaus2.fitTo(data2, Save()) # RooFitResult
result.Print()
frame2 = x.frame(Title("Tailored Gaussian pdf")) # RooPlot
data2.plotOn(frame2, Binning(40))
gaus2.plotOn(frame2)
print "\n>>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600)
canvas.Divide(2)
canvas.cd(1)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
canvas.cd(2)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame2.GetYaxis().SetLabelOffset(0.008)
frame2.GetYaxis().SetTitleOffset(1.6)
frame2.GetYaxis().SetTitleSize(0.045)
frame2.GetXaxis().SetTitleSize(0.045)
frame2.Draw()
canvas.SaveAs("rooFit103.png")
def test_correlated_values():
try:
import uncertainties
except ImportError:
raise SkipTest("uncertainties package is not installed")
from rootpy.stats.correlated_values import correlated_values
# construct pdf and toy data following example at
# http://root.cern.ch/drupal/content/roofit
# --- Observable ---
mes = RooRealVar("mes", "m_{ES} (GeV)", 5.20, 5.30)
# --- Parameters ---
sigmean = RooRealVar("sigmean", "B^{#pm} mass", 5.28, 5.20, 5.30)
sigwidth = RooRealVar("sigwidth", "B^{#pm} width", 0.0027, 0.001, 1.)
# --- Build Gaussian PDF ---
signal = RooGaussian("signal", "signal PDF", mes, sigmean, sigwidth)
# --- Build Argus background PDF ---
argpar = RooRealVar("argpar", "argus shape parameter", -20.0, -100., -1.)
background = RooArgusBG("background", "Argus PDF",
mes, RooFit.RooConst(5.291), argpar)
# --- Construct signal+background PDF ---
nsig = RooRealVar("nsig", "#signal events", 200, 0., 10000)
nbkg = RooRealVar("nbkg", "#background events", 800, 0., 10000)
model = RooAddPdf("model", "g+a",
RooArgList(signal,background),
RooArgList(nsig,nbkg))
# --- Generate a toyMC sample from composite PDF ---
data = model.generate(RooArgSet(mes), 2000)
# --- Perform extended ML fit of composite PDF to toy data ---
fitresult = model.fitTo(data, RooFit.Save(), RooFit.PrintLevel(-1))
nsig, nbkg = correlated_values(["nsig", "nbkg"], fitresult)
# Arbitrary math expression according to what the `uncertainties`
# package supports, automatically computes correct error propagation
sum_value = nsig + nbkg
value, error = sum_value.nominal_value, sum_value.std_dev
workspace = Workspace(name='workspace')
# import the data
assert_false(workspace(data))
with TemporaryFile():
workspace.Write()
def toy_run(nevents):
lower = -1
upper = 1
# create observables
obs = RooRealVar("obs", "obs1", lower, upper)
# create parameters
mean1 = RooRealVar("mean1", "mean of gaussian", 0, -1, 1)
sigma1 = RooRealVar("sigma1", "sigma of gaussian", 0.1, -1, 1)
gauss1 = RooGaussian("gauss1", "gaussian PDF", obs, mean1, sigma1)
mean2 = RooRealVar("mean2", "mean of gaussian", 0.5, -1, 1)
sigma2 = RooRealVar("sigma2", "sigma of gaussian", 0.2, -1, 1)
gauss2 = RooGaussian("gauss2", "gaussian PDF", obs, mean2, sigma2)
frac = RooRealVar("frac", "Fraction of a gauss", 0.5, 0, 1)
arg_list = RooArgList(
gauss1,
gauss2,
gauss2,
gauss2,
gauss2,
# gauss2,
gauss2,
gauss2,
gauss1)
arg_list.addOwned(gauss2)
pdf = RooAddPdf(
"sum_pdf",
"sum of pdfs",
arg_list,
RooArgList(
frac,
frac,
frac,
# frac,
# frac,
frac,
frac,
frac,
frac,
frac))
# obs, pdf = build_pdf()
timer = zfit_benchmark.timer.Timer(f"Toys {nevents}")
with timer:
data = pdf.generate(RooArgSet(obs), nevents)
pdf.fitTo(data)
# mgr.generateAndFit(n_toys, nevents)
return float(timer.elapsed)
def addAsciiData(self,
ws,
ds_name,
item_title,
var_set_name,
var_set_type,
ds_file_name,
weight_var_name=None,
debug=0,
sets=None):
legend = '[exostConfig::addAsciiData]:'
arg_set = RooArgSet()
if (var_set_type == 'set'):
#_var_set = ws.set(var_set_name)
_var_set = sets[var_set_name]
arg_set.add(_var_set)
if _var_set.getSize() != 1:
print legend, 'Error: too many or too few columns in the input ASCII file'
print legend, 'Error: Smart program as I am, I can only handle ASCII files'
print legend, 'Error: with exactly one column at the moment.'
print legend, 'Error: Support for multiple columns will be implemented'
print legend, 'Error: eventually, contact the developers.'
print legend, 'Error: Better yet, switch to ROOT input files,'
print legend, 'Error: all the cool kids are doing that!'
return -1
elif (var_set_type == 'var'):
arg_set.add(ws.var(var_set_name))
else:
print legend, 'error: unknown var_set_type, cannot create dataset', ds_name
return -1
#create the dataset
if weight_var_name == None: #no weight
if (debug > 0):
print legend, 'no weight variable given'
_arglist = RooArgList(arg_set)
#ds = RooDataSet()ds_name, item_title)
ds = RooDataSet.read(ds_file_name, _arglist)
ds.SetName(ds_name)
ds.SetTitle(item_title)
else:
if (debug > 0):
print legend, 'using variable', weight_var_name, 'as weight'
print legend, 'Error: Smart program as I am, I cannot handle'
print legend, 'Error: weights when loading from ASCII files yet.'
print legend, 'Error: Support for weights from ASCII files will'
print legend, 'Error: be implemented eventually, contact the developers.'
print legend, 'Error: Better yet, switch to ROOT input files,'
print legend, 'Error: all the cool kids are doing that!'
return -1
# import the datahist. Note workaround 'import' being a reserved word
getattr(ws, 'import')(ds)
def get_dataset(varargset, ftree, cut='', wt='', scale=1):
"""Return a dataset.
Return a dataset from the ntuple `ftree'. Apply a selection cut
using the `cutVar' variable and the selection `cut'.
"""
from rplot.fixes import ROOT
from rplot.tselect import Tsplice
splice = Tsplice(ftree)
splice.make_splice('sel', cut)
from ROOT import RooDataSet, RooFit, RooFormulaVar, RooArgList
tmpdst = RooDataSet('tmpdataset', '', varargset, RooFit.Import(ftree))
if wt:
wtvar = RooFormulaVar('wt', '{}*@0'.format(scale),
RooArgList(varargset[wt]))
wtvar = tmpdst.addColumn(wtvar)
varargset.remove(varargset[wt])
varargset.add(wtvar)
dst = RooDataSet('dataset', 'Dataset', varargset,
RooFit.Import(tmpdst), RooFit.WeightVar(wtvar))
varargset.remove(wtvar)
dst = dst.reduce(varargset)
return dst
def makeHistPdf(hist, ws, x):
theVars = RooArgList(x)
v = RooArgSet(x)
dataHist = RooDataHist(hist.GetName() + '_dh', 'dataHist', theVars, hist)
hpdf = RooHistPdf(hist.GetName() + '_pdf', 'hist pdf', v, dataHist)
getattr(ws, 'import')(hpdf)
return hpdf
def RooParametricHist(self,name=''):
'''Produce a RooParametricHist2D filled with this object's binVars.
Returns:
RooParametricHist2D: Output RooFit object to pass to Combine.
'''
out_rph = {}
out_add = {}
for cat in _subspace:
cat_name = self.name+'_'+cat
cat_hist = self.binning.CreateHist(cat_name+'_temp',cat)
obj_name = '%s_%s'%(name if name != '' else self.name, cat)
self.binArgLists[cat] = RooArgList()
for ybin in range(1,len(self.binning.ybinList)):
for xbin in range(1,len(self.binning.xbinByCat[cat])):
bin_name = '%s_bin_%s-%s'%(cat_name,xbin,ybin)
self.binArgLists[cat].add(self.binVars[bin_name])
out_rph[cat] = RooParametricHist2D(
obj_name, obj_name,
self.binning.xVars[cat],
self.binning.yVar,
self.binArgLists[cat], cat_hist
)
out_add[cat] = RooAddition(obj_name+'_norm',obj_name+'_norm',self.binArgLists[cat])
return out_rph, out_add
def test_2d():
obs_x = RooRealVar("obs_x", "obs_x", 0, 10)
obs_y = RooRealVar("obs_y", "obs_y", 0, 10)
obs_list = RooArgList(obs_x, obs_y)
formular = "obs_x + obs_y*0.3"
pdf_sum = ROOT.RooGenericPdf("pdf_sum", "sum pdf", formular, obs_list)
f_up = "obs_x*1.8 + obs_y*0.3"
f_down = "obs_x*0.2 + obs_y*0.3"
pdf_up = ROOT.RooGenericPdf("pdf_up", "sum pdf", f_up, obs_list)
pdf_down = ROOT.RooGenericPdf("pdf_down", "sum pdf", f_down, obs_list)
nuis_var = RooRealVar('nuis_var', "nuis_var", 0., -5., 5.)
morph = createMorph(obs_list, nuis_var, pdf_sum, pdf_up, pdf_down)
morph.Print()
th2f = pdf_sum.createHistogram("th2f", obs_x, ROOT.RooFit.YVar(obs_y))
th2f_morph = morph.createHistogram("th2f_morph", obs_x,
ROOT.RooFit.YVar(obs_y))
canvas = ROOT.TCanvas("canvas", "canvas", 450, 450)
th2f.Draw('colz')
canvas.SaveAs("sum_hist.pdf")
##project to X
th1_x = th2f.ProjectionX("th1_x", 1)
th1_x.Draw()
th1_x_morph = th2f_morph.ProjectionX("th1_x_morph", 1)
th1_x_morph.Draw("same")
canvas.SaveAs("sum_hist_x.pdf")
def getInitialFitRes(cfg, ws):
""" Create a prefit RooExpandedFitResult for this workspace """
mc = ws.obj("ModelConfig")
force_mu, mu_val = cfg.force_mu_value()
if force_mu:
mc.GetParametersOfInterest().first().setVal(mu_val)
np = RooArgList(mc.GetNuisanceParameters())
np.add(mc.GetParametersOfInterest())
ws.loadSnapshot("snapshot_paramsVals_initial")
#removeGamma(np)
it = np.createIterator()
n = it.Next()
while n:
if "alpha" in n.GetName():
n.setError(1)
else:
n.setError(1.e-4)
#if "alpha_SysJetEResol" in n.GetName():
#n.setVal(-1)
n = it.Next()
ws.saveSnapshot("vars_initial", RooArgSet(np))
re = ROOT.RooExpandedFitResult(np)
cfg._muhat = mc.GetParametersOfInterest().first().getVal()
if logging.getLogger().isEnabledFor(logging.DEBUG):
logging.debug("Expanded RooFit results")
re.Print("v")
return re
def doFit(hist,output,rap="BB",flavour="DATA",trackType="TunePNew",funct="doubleCB"):
sig = []
sige = []
meanList = []
meanListe = []
nChi2 = []
gSystem.Load("./RooCruijff_cxx.so")
gSystem.Load("./RooDCBShape_cxx.so")
for i,h in enumerate(hist):
ws = RooWorkspace("tempWS")
mass = RooRealVar('mass','mass',91, xLow, xHigh )
getattr(ws,'import')(mass,RooCmdArg())
dataHist = RooDataHist("hist","hist",RooArgList(ws.var("mass")),h)
getattr(ws,'import')(dataHist,RooCmdArg())
ws.writeToFile("tmpWorkspace.root")
subprocess.call(["python","fitCapsule.py",output,rap,flavour,trackType,funct,"%d"%xLow,"%d"%xHigh,"%d"%rebinFactor,"%d"%i])
returnFile = TFile("tmpWorkspaceReturn.root","OPEN")
wsReturn = returnFile.Get("tempWS")
sig.append(wsReturn.var("Sig").getVal())
sige.append(wsReturn.var("Sige").getVal())
meanList.append(wsReturn.var("Mean").getVal())
meanListe.append(wsReturn.var("Meane").getVal())
nChi2.append(wsReturn.var("chi2").getVal()/wsReturn.var("nDOF").getVal())
return meanList,meanListe,sig,sige, nChi2
def make_weighted_dataset(subproc,ws,tree,mc_events):
data = RooDataSet('%s_shape_data'%subproc,
'M_{ll#gamma} Shape Data for %s'%subproc,
tree,
ws.set('vars_with_weights')
)
mc_yield_var = RooConstVar('temp','temp',mc_events)
weighter = RooFormulaVar('weight','weight','@0*@1/@2',
RooArgList( ws.var('procWeight'),
ws.var('puWeight'),
mc_yield_var )
)
data.addColumn(weighter)
data_total_weight = RooDataSet('%s_shape_data'%subproc,
'M_{ll#gamma} Shape Data for %s'%subproc,
data,
ws.set('vars_with_weights_final'),
'','weight')
data_pu_weight = RooDataSet('%s_shape_data_puonly'%subproc,
'M_{ll#gamma} Shape Data for %s'%subproc,
data,
ws.set('vars_with_weights_final'),
'','puWeight')
return data_total_weight, data_pu_weight
def performFitInLeptonAbsEta(data_histogram, signal_histogram, bkg1_histogram,
bkg2_histogram):
N_Data = data_histogram.Integral()
N_signal = signal_histogram.Integral()
N_bkg1 = bkg1_histogram.Integral()
N_bkg2 = bkg2_histogram.Integral()
leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.)
variables = RooArgList()
variables.add(leptonAbsEta)
variable_set = RooArgSet()
variable_set.add(leptonAbsEta)
lowerBound = 0
upperBound = N_Data * 2
data_RooDataHist = RooDataHist("data", "dataset with leptonAbsEta",
variables, data_histogram)
signal_RooDataHist = RooDataHist("rh_signal", "signal", variables,
signal_histogram)
bkg1_RooDataHist = RooDataHist("rh_bkg1", "bkg1", variables,
bkg1_histogram)
bkg2_RooDataHist = RooDataHist("rh_bkg2", "bkg2", variables,
bkg2_histogram)
signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set,
signal_RooDataHist, 0)
signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set,
signal_RooDataHist, 0)
def add_data(self, data_histogram):
print "[MjFit.add_data] INFO : Adding data histogram"
# Add a data histogram
self.data_histogram_ = data_histogram.Clone()
self.data_histogram_.SetDirectory(0)
self.data_roohistogram_ = RooDataHist('data_roohistogram','data_roohistogram',RooArgList(self.mjj_),self.data_histogram_)
self.data_roohistogram_.Print()
def addHistData(self,
ws,
ds_name,
item_title,
var_set_name,
var_set_type,
ds_object,
sets=None):
legend = '[exostConfig::addHistData]:'
arg_list = RooArgList()
if (var_set_type == 'set'):
#arg_list.add(ws.set(var_set_name))
arg_list.add(sets[var_set_name])
elif (var_set_type == 'var'):
arg_list.add(ws.var(var_set_name))
else:
print legend, 'error: unknown var_set_type, cannot create dataset', ds_name
return -1
#create the hist dataset
ds = RooDataHist(ds_name, item_title, arg_list, ds_object, 1)
# import the datahist. Note workaround 'import' being a reserved word
getattr(ws, 'import')(ds)
def createWidthDeviation(self):
'''Compute the width deviation (denoted \kappa_H^2 by M.Peskin in arxiv 1312.4974).
Note that we fit an additive modification of the coupling: (1 + dx)
is therefore equal to kappa_x
'''
expr = '0'
sumBR = sum(self.BR.values())
pwidths = []
for dcoupling, br in self.BR.iteritems():
pwidth = None
if dcoupling in self.poi:
pwidth = str(
br /
sumBR) + "*(1+" + dcoupling + ")*(1+" + dcoupling + ")"
else:
# using sm partial width
pwidth = str(br / sumBR)
pwidths.append(pwidth)
expr = '+'.join(pwidths)
if 'inv' in self.poi:
expr = '(' + expr + ')/(1.0-inv)'
else:
# setting invisible width to 0.
expr = '(' + expr + ')'
dependentlist = RooArgList()
for dep in self.poi.values():
dependentlist.add(dep)
self.width = RooGenericPdf('width', 'width', expr, dependentlist)
def tripleG(doublegaus, mean, sigma3_, f2_, tagged_mass, w):
sigma3 = RooRealVar ("#sigma_{TG3}" , "sigmaTG3" , sigma3_ , 0, 0.2, "GeV")
signalGauss3 = RooGaussian("thirdGauss" , "thirdGauss" , tagged_mass, mean, sigma3)
f2 = RooRealVar ("f2" , "f2" , f2_ , 0., 1. )
triplegaus = RooAddPdf ("triplegaus" , "doublegaus+gaus3", RooArgList(doublegaus,signalGauss3), RooArgList(f2))
_import(w,triplegaus)
def generate_testfiles():
h = TH1D("gaussian_hist", "Gaussian histgram", 100, -3, 3)
h.FillRandom("gaus", 1000)
file = TFile(
os.path.dirname(__file__) + ('/../testfiles/root_testfiles.root'),
'RECREATE')
file.cd()
h.Write()
x = RooRealVar("D0_M", "m(K_{S}^{0}K^{+}K^{-})", 1860, 1800, 1930,
"\\mathrm{MeV}/c^{2}")
x.setBins(130)
m1 = RooRealVar("m1", "mean 1", 1864, 1860, 1870)
s1 = RooRealVar("s1", "sigma 1", 2, 0, 5)
g1 = RooGaussian("g1", "Gaussian 1", x, m1, s1)
m2 = RooRealVar("m2", "mean 2", 1864, 1860, 1870)
s2 = RooRealVar("s2", "sigma 2", 4, 0, 5)
g2 = RooGaussian("g2", "Gaussian 2", x, m2, s2)
f1 = RooRealVar("f", "f", 0.5, 0, 1)
m = RooAddPdf("model", "model", RooArgList(g1, g2), f1)
data = m.generate(x, 1e6)
x.Write("x")
m.Write("model")
data.Write("data")
file.Close()
return
def _make_fit_model(self):
p0 = RooRealVar("p0", "p0", 100, -10000, 10000)
p1 = RooRealVar("p1", "p1", 100, -10000, 10000)
p2 = RooRealVar("p2", "p2", 100, -10000, 10000)
p3 = RooRealVar("p3", "p3", 100, -10000, 10000)
bgd = RooPolynomial("bgd", "bgd", self.xvar,
RooArgList(p0, p1, p2, p3))
def test_plottable():
# construct pdf and toy data following example at
# http://root.cern.ch/drupal/content/roofit
# Observable
mes = RooRealVar("mes", "m_{ES} (GeV)", 5.20, 5.30)
# Parameters
sigmean = RooRealVar("sigmean", "B^{#pm} mass", 5.28, 5.20, 5.30)
sigwidth = RooRealVar("sigwidth", "B^{#pm} width", 0.0027, 0.001, 1.)
# Build Gaussian PDF
signal = RooGaussian("signal", "signal PDF", mes, sigmean, sigwidth)
# Build Argus background PDF
argpar = RooRealVar("argpar", "argus shape parameter", -20.0, -100., -1.)
background = RooArgusBG("background", "Argus PDF",
mes, RooFit.RooConst(5.291), argpar)
# Construct signal+background PDF
nsig = RooRealVar("nsig", "#signal events", 200, 0., 10000)
nbkg = RooRealVar("nbkg", "#background events", 800, 0., 10000)
model = RooAddPdf("model", "g+a",
RooArgList(signal, background),
RooArgList(nsig, nbkg))
# Generate a toyMC sample from composite PDF
data = model.generate(RooArgSet(mes), 2000)
# Perform extended ML fit of composite PDF to toy data
fitresult = model.fitTo(data, RooFit.Save(), RooFit.PrintLevel(-1))
# Plot toy data and composite PDF overlaid
mesframe = asrootpy(mes.frame())
data.plotOn(mesframe)
model.plotOn(mesframe)
for obj in mesframe.objects:
assert_true(obj)
for curve in mesframe.curves:
assert_true(curve)
for hist in mesframe.data_hists:
assert_true(hist)
assert_true(mesframe.plotvar)
with TemporaryFile():
mesframe.Write()
def fit(self, save_to, signal_name=None, fix_p3=False, fit_range=[300., 1200.], fit_strategy=1):
# Run a RooFit fit
# Create background PDF
p1 = RooRealVar('p1','p1',args.p1,0.,100.)
p2 = RooRealVar('p2','p2',args.p2,0.,60.)
p3 = RooRealVar('p3','p3',args.p3,-10.,10.)
if args.fix_p3:
p3.setConstant()
background_pdf = RooGenericPdf('background_pdf','(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))'%(self.collision_energy,self.collision_energy,self.collision_energy),RooArgList(self.mjj_,p1,p2,p3))
background_pdf.Print()
data_integral = data_histogram.Integral(data_histogram.GetXaxis().FindBin(float(fit_range[0])),data_histogram.GetXaxis().FindBin(float(fit_range[1])))
background_norm = RooRealVar('background_norm','background_norm',data_integral,0.,1e+08)
background_norm.Print()
# Create signal PDF and fit model
if signal_name:
signal_pdf = RooHistPdf('signal_pdf', 'signal_pdf', RooArgSet(self.mjj_), self.signal_roohistograms_[signal_name])
signal_pdf.Print()
signal_norm = RooRealVar('signal_norm','signal_norm',0,-1e+05,1e+05)
signal_norm.Print()
model = RooAddPdf("model","s+b",RooArgList(background_pdf,signal_pdf),RooArgList(background_norm,signal_norm))
else:
model = RooAddPdf("model","b",RooArgList(background_pdf),RooArgList(background_norm))
# Run fit
res = model.fitTo(data_, RooFit.Save(kTRUE), RooFit.Strategy(fit_strategy))
# Save to workspace
self.workspace_ = RooWorkspace('w','workspace')
#getattr(w,'import')(background,ROOT.RooCmdArg())
getattr(self.workspace_,'import')(background_pdf,RooFit.Rename("background"))
getattr(self.workspace_,'import')(background_norm,ROOT.RooCmdArg())
getattr(self.workspace_,'import')(self.data_roohistogram_,RooFit.Rename("data_obs"))
getattr(self.workspace_, 'import')(model, RooFit.Rename("model"))
if signal_name:
getattr(self.workspace_,'import')(signal_roohistogram,RooFit.Rename("signal"))
getattr(self.workspace_,'import')(signal_pdf,RooFit.Rename("signal_pdf"))
getattr(self.workspace_,'import')(signal_norm,ROOT.RooCmdArg())
self.workspace_.Print()
self.workspace_.writeToFile(save_to)
if signal_name:
roofit_results[signal_name] = save_to
else:
roofit_results["background"] = save_to
