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 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 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 _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 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 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 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 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
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 __init__(self, gauss_1n, cb_2xn, name):
self.gauss_1n = gauss_1n
self.cb_2xn = cb_2xn
#number in the model
n1n_nam = "num_1n_" + name
self.num_1n = RooRealVar(n1n_nam, n1n_nam, 200, 0, 3000) # 1
n2n_nam = "num_2n_" + name
self.num_2n = RooRealVar(n2n_nam, n2n_nam, 100, 0, 3000) # 0.5
#1D model Gauss + Crystal Ball
model_nam = "model_" + name
self.model = RooAddPdf(model_nam, model_nam, RooArgList(self.gauss_1n, self.cb_2xn), RooArgList(self.num_1n, self.num_2n))
def doubleG(mean_, sigma1_, sigma2_, f1_, tagged_mass, w, fn):
mean = RooRealVar ("mean^{%s}"%fn , "massDG" , mean_ , 5, 6, "GeV")
sigma1 = RooRealVar ("#sigma_{1}^{%s}"%fn , "sigmaDG1" , sigma1_ , 0, 1, "GeV")
signalGauss1 = RooGaussian("dg_firstGauss_%s"%fn , "firstGauss" , tagged_mass, mean, sigma1)
sigma2 = RooRealVar ("#sigma_{2}^{%s}"%fn , "sigmaDG2" , sigma2_ , 0, 0.12, "GeV")
signalGauss2 = RooGaussian("dg_secondGauss_%s"%fn , "secondGauss" , tagged_mass, mean, sigma2)
f1 = RooRealVar ("f^{%s}"%fn , "f1" , f1_ , 0., 1. )
doublegaus = RooAddPdf ("doublegaus_%s"%fn , "gaus1+gaus2" , RooArgList(signalGauss1,signalGauss2), RooArgList(f1))
_import(w,doublegaus)
def rooFit502():
print ">>> setup model components..."
x = RooRealVar("x", "x", 0, 10)
mean = RooRealVar("mean", "mean of gaussians", 5, 0, 10)
sigma1 = RooRealVar("sigma1", "width of gaussians", 0.5)
sigma2 = RooRealVar("sigma2", "width of gaussians", 1)
sig1 = RooGaussian("sig1", "Signal component 1", x, mean, sigma1)
sig2 = RooGaussian("sig2", "Signal component 2", x, mean, sigma2)
a0 = RooRealVar("a0", "a0", 0.5, 0., 1.)
a1 = RooRealVar("a1", "a1", -0.2, 0., 1.)
bkg = RooChebychev("bkg", "Background", x, RooArgList(a0, a1))
print ">>> sum model components..."
sig1frac = RooRealVar("sig1frac", "fraction of component 1 in signal", 0.8,
0., 1.)
sig = RooAddPdf("sig", "Signal", RooArgList(sig1, sig2),
RooArgList(sig1frac))
bkgfrac = RooRealVar("bkgfrac", "fraction of background", 0.5, 0., 1.)
model = RooAddPdf("model", "g1+g2+a", RooArgList(bkg, sig),
RooArgList(bkgfrac))
print ">>> generate data..."
data = model.generate(RooArgSet(x), 1000) # RooDataSet
print ">>> create workspace, import data and model..."
workspace = RooWorkspace("workspace", "workspace") # empty RooWorkspace
getattr(workspace, 'import')(model) # import model and all its components
getattr(workspace, 'import')(data) # import data
#workspace.import(model) # causes synthax error in python
#workspace.import(data) # causes synthax error in python
print "\n>>> print workspace contents:"
workspace.Print()
print "\n>>> save workspace in file..."
workspace.writeToFile("rooFit502_workspace.root")
print ">>> save workspace in memory (gDirectory)..."
gDirectory.Add(workspace)
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 rooFit602():
print ">>> setup model..."
x = RooRealVar("x","x",0,10)
mean = RooRealVar("mean","mean of gaussian",5)
sigma1 = RooRealVar("sigma1","width of gaussian",0.5)
sigma2 = RooRealVar("sigma2","width of gaussian",1)
sig1 = RooGaussian("sig1","Signal component 1",x,mean,sigma1)
sig2 = RooGaussian("sig2","Signal component 2",x,mean,sigma2)
a0 = RooRealVar("a0","a0",0.5,0.,1.)
a1 = RooRealVar("a1","a1",-0.2,0.,1.)
bkg = RooChebychev("bkg","Background",x,RooArgSet(a0,a1))
sig1frac = RooRealVar("sig1frac","fraction of component 1 in signal",0.8,0.,1.)
sig = RooAddPdf("sig","Signal",RooArgList(sig1,sig2),sig1frac)
bkgfrac = RooRealVar("bkgfrac","fraction of background",0.5,0.,1.)
model = RooAddPdf("model","g1+g2+a",RooArgList(bkg,sig),bkgfrac)
print ">>> create binned dataset..."
data = model.generate(RooArgSet(x),10000) # RooDataSet
hist = data.binnedClone() # RooDataHist
# Construct a chi^2 of the data and the model.
# When a p.d.f. is used in a chi^2 fit, the probability density scaled
# by the number of events in the dataset to obtain the fit function
# If model is an extended p.d.f, the expected number events is used
# instead of the observed number of events.
model.chi2FitTo(hist)
# NB: It is also possible to fit a RooAbsReal function to a RooDataHist
# using chi2FitTo().
# Note that entries with zero bins are _not_ allowed
# for a proper chi^2 calculation and will give error
# messages
data_small = date.reduce(EventRange(1,100)) # RooDataSet
hist_small = data_small.binnedClone() # RooDataHist
chi2_lowstat("chi2_lowstat","chi2",model,hist_small)
print ">>> chi2_lowstat.getVal() = %s" % chi2_lowstat.getVal()
def makeMorphingPdf(self, component, useAlternateModels, convModels):
if self.ws.pdf(component):
return self.ws.pdf(component)
filesNom = getattr(self.pars, '%s_NomFiles' % component)
modelsNom = getattr(self.pars, '%s_NomModels' % component)
filesMU = getattr(self.pars, '%s_MUFiles' % component)
modelsMU = getattr(self.pars, '%s_MUModels' % component)
filesMD = getattr(self.pars, '%s_MDFiles' % component)
modelsMD = getattr(self.pars, '%s_MDModels' % component)
filesSU = getattr(self.pars, '%s_SUFiles' % component)
modelsSU = getattr(self.pars, '%s_SUModels' % component)
filesSD = getattr(self.pars, '%s_SDFiles' % component)
modelsSD = getattr(self.pars, '%s_SDModels' % component)
if useAlternateModels:
modelsNom = getattr(self.pars, '%s_NomModelsAlt' % component)
modelsMU = getattr(self.pars, '%s_MUModelsAlt' % component)
modelsMD = getattr(self.pars, '%s_MDModelsAlt' % component)
modelsSU = getattr(self.pars, '%s_SUModelsAlt' % component)
modelsSD = getattr(self.pars, '%s_SDModelsAlt' % component)
# Adds five (sub)components for the component with suffixes Nom, MU, MD, SU, SD
NomPdf = self.makeComponentPdf('%s_Nom' % component, filesNom, modelsNom, False, convModels)
if hasattr(self, '%s_NomExpected' % component):
setattr(self, '%sExpected' % component,
getattr(self, '%s_NomExpected' % component))
MUPdf = self.makeComponentPdf('%s_MU' % component, filesMU, modelsMU, False, convModels)
MDPdf = self.makeComponentPdf('%s_MD' % component, filesMD, modelsMD, False, convModels)
SUPdf = self.makeComponentPdf('%s_SU' % component, filesSU, modelsSU, False, convModels)
SDPdf = self.makeComponentPdf('%s_SD' % component, filesSD, modelsSD, False, convModels)
fMU_comp = self.ws.factory("fMU_%s[0., -1., 1.]" % component)
fSU_comp = self.ws.factory("fSU_%s[0., -1., 1.]" % component)
fMU = RooFormulaVar("f_fMU_%s" % component, "1.0*@0*(@0 >= 0.)",
RooArgList( fMU_comp ) )
fMD = RooFormulaVar("f_fMD_%s" % component, "-1.0*@0*(@0 < 0.)",
RooArgList( fMU_comp ) )
fSU = RooFormulaVar("f_fSU_%s" % component, "@0*(@0 >= 0.)",
RooArgList( fSU_comp ) )
fSD = RooFormulaVar("f_fSD_%s" % component, "@0*(-1)*(@0 < 0.)",
RooArgList( fSU_comp ) )
fNom = RooFormulaVar("f_fNom_%s" % component, "(1.-abs(@0)-abs(@1))",
RooArgList(fMU_comp,fSU_comp) )
morphPdf = RooAddPdf(component,component,
RooArgList(MUPdf,MDPdf,SUPdf,SDPdf,NomPdf),
RooArgList(fMU, fMD, fSU, fSD, fNom))
morphPdf.SetName(component)
getattr(self.ws, 'import')(morphPdf)
return self.ws.pdf(component)
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 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 predict(self, x, theta_true):
"""
Run an unbinned ML fit to make predictions
"""
# Create RooDataSet
xs = self.scaler.transform(x)
preds = self.model.predict(xs)[:, 1]
min_nn_output_local, max_nn_output_local = np.min(preds), np.max(preds)
if min_nn_output_local < self.min_nn_output:
self.min_nn_output = min_nn_output_local
if max_nn_output_local > self.max_nn_output:
self.max_nn_output = max_nn_output_local
roodata = RooDataSet('data', 'data', RooArgSet(self.roopred))
for pred in preds:
self.roopred.setVal(pred)
roodata.add(RooArgSet(self.roopred))
# Fit
theta = RooRealVar('theta', 'theta', 0.5, self.theta_min, self.theta_max)
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()
fitstatus = res.status()
fitstatus |= (not subprocess.call(['grep', 'p.d.f value is less than zero', 'output_MLE_unbinned/minuit_output.log']))
fitted_theta = theta.getValV()
# Get Lambda(theta_true | theta_best)
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, fitstatus
def __init__(self, adc_east, adc_west):
#input ADC values
self.adc_east = adc_east
self.adc_west = adc_west
#self.adc_east = RooRealVar("adc_east", "adc_east", 10, 1300)
#self.adc_west = RooRealVar("adc_west", "adc_west", 10, 1300)
#east Gaussian
self.gauss_east = Gauss(self.adc_east, "east")
self.gauss_east.mean_1n.setVal(72.9)
self.gauss_east.sigma_1n.setVal(21.4)
#west Gaussian
self.gauss_west = Gauss(self.adc_west, "west")
self.gauss_west.mean_1n.setVal(87.7)
self.gauss_west.sigma_1n.setVal(26.9)
#east Crystal Ball
self.cb_east = CrystalBall(self.adc_east, "east")
self.cb_east.mean_2n.setVal(166.)
self.cb_east.sigma_2n.setVal(42.1)
self.cb_east.alpha_2xn.setVal(-0.7)
self.cb_east.n_2xn.setVal(0.5)
#west Crystal Ball
self.cb_west = CrystalBall(self.adc_west, "west")
self.cb_west.mean_2n.setVal(174.1)
self.cb_west.sigma_2n.setVal(29.3)
self.cb_west.alpha_2xn.setVal(-0.3)
self.cb_west.n_2xn.setVal(0.8)
# (g_e + c_e)*(g_w + c_w) = g_e*g_w + c_e*c_w + g_e*c_w + c_e*g_w
#self.num_max = 3000
self.num_max = 300000
#1n1n 2D Gaussian
self.pdf_1n1n = RooProdPdf("pdf_1n1n", "pdf_1n1n", RooArgList(self.gauss_east.gauss_1n, self.gauss_west.gauss_1n))
self.num_1n1n = RooRealVar("num_1n1n", "num_1n1n", 200, 0, self.num_max) # 1
#1n2xn Gaussian * Crystal Ball
self.pdf_1n2xn = RooProdPdf("pdf_1n2xn", "pdf_1n2xn", RooArgList(self.gauss_east.gauss_1n, self.cb_west.cb_2xn))
self.num_1n2xn = RooRealVar("num_1n2xn", "num_1n2xn", 100, 0, self.num_max) # 1
#2xn1n Crystal Ball * Gaussian
self.pdf_2xn1n = RooProdPdf("pdf_2xn1n", "pdf_2xn1n", RooArgList(self.cb_east.cb_2xn, self.gauss_west.gauss_1n))
self.num_2xn1n = RooRealVar("num_2xn1n", "num_2xn1n", 100, 0, self.num_max) # 1
#2xn2xn 2D Crystal Ball
self.pdf_2xn2xn = RooProdPdf("pdf_2xn2xn", "pdf_2xn2xn", RooArgList(self.cb_east.cb_2xn, self.cb_west.cb_2xn))
self.num_2xn2xn = RooRealVar("num_2xn2xn", "num_2xn2xn", 50, 0, self.num_max) # 1
#fit model
self.model = RooAddPdf("model", "model", RooArgList(self.pdf_1n1n, self.pdf_1n2xn, self.pdf_2xn1n, self.pdf_2xn2xn),
RooArgList(self.num_1n1n, self.num_1n2xn, self.num_2xn1n, self.num_2xn2xn))
def get_num_sig_bkg(hist_DataTemplate, hist_SignalTemplate,
hist_BackgdTemplate, fit_range_min, fit_range_max):
'''Given 3 input histograms (TH1F), and a fit range, this function finds
the amount of signal and background that sum up to the data histogram.
It does histogram fits.'''
# Find range of data template
data_min = hist_DataTemplate.GetXaxis().GetXmin()
data_max = hist_DataTemplate.GetXaxis().GetXmax()
# Create basic variables
x = RooRealVar("x", "x", data_min, data_max)
x.setBins(hist_DataTemplate.GetXaxis().GetNbins()) # Binned x values
nsig = RooRealVar("nsig", "number of signal events", 0,
hist_DataTemplate.Integral())
nbkg = RooRealVar("nbkg", "number of background events", 0,
hist_DataTemplate.Integral())
# Create RooDataHists from input TH1Fs
dh = RooDataHist("dh", "dh", RooArgList(x), hist_DataTemplate)
ds = RooDataHist("ds", "ds", RooArgList(x), hist_SignalTemplate)
db = RooDataHist("db", "db", RooArgList(x), hist_BackgdTemplate)
# Create Probability Distribution Functions from Monte Carlo
sigPDF = RooHistPdf("sigPDF", "sigPDF", RooArgSet(x), ds)
bkgPDF = RooHistPdf("bkgPDF", "bkgPDF", RooArgSet(x), db)
model = RooAddPdf("model", "(g1+g2)+a", RooArgList(bkgPDF, sigPDF),
RooArgList(nbkg, nsig))
# Find the edges of the bins that contain the fit range min/max
data_min = hist_DataTemplate.GetXaxis().GetBinLowEdge(
hist_DataTemplate.GetXaxis().FindFixBin(fit_range_min))
data_max = hist_DataTemplate.GetXaxis().GetBinUpEdge(
hist_DataTemplate.GetXaxis().FindFixBin(fit_range_max))
r = model.fitTo(dh, RooFit.Save(), RooFit.Minos(0),
RooFit.PrintEvalErrors(0), RooFit.Extended(),
RooFit.Range(data_min, data_max))
r.Print("v")
#print nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError()
return [nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError()]
def _make_underlying_model(self):
self.pdfs = {}
self.yields = {} # yields are plain floats
self.ryields = {} # keep track of roofit objects for memory management
h = self._histos[0]
nbins = h.GetXaxis().GetNbins()
xmin = h.GetXaxis().GetXmin()
xmax = h.GetXaxis().GetXmax()
self.xvar = RooRealVar("x", "x", xmin, xmax)
self.xvar.setBins(nbins)
self.pdfs = {}
self.hists = []
pdfs = RooArgList()
yields = RooArgList()
for histo in self._histos:
if histo.Integral() == 0:
continue
compname = histo.GetName()
hist = RooDataHist(compname, compname, RooArgList(self.xvar),
histo)
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 = histo.Integral()
uncertainty = self._uncertainty
nmin = min(0, nevts * (1 - uncertainty))
nmax = nevts * (1 + 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 build_pdf():
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)
mean3 = RooRealVar("mean3", "mean of gaussian", 0.5, -1, 1)
sigma3 = RooRealVar("sigma3", "sigma of gaussian", 0.3, -1, 1)
gauss3 = RooGaussian("gauss3", "gaussian PDF", obs, mean3, sigma3)
mean4 = RooRealVar("mean4", "mean of gaussian", 0.5, -1, 1)
sigma4 = RooRealVar("sigma4", "sigma of gaussian", 0.4, -1, 1)
gauss4 = RooGaussian("gauss4", "gaussian PDF", obs, mean4, sigma4)
mean5 = RooRealVar("mean5", "mean of gaussian", 0.5, -1, 1)
sigma5 = RooRealVar("sigma5", "sigma of gaussian", 0.5, -1, 1)
gauss5 = RooGaussian("gauss5", "gaussian PDF", obs, mean5, sigma5)
frac1 = RooRealVar("frac", "Fraction of a gauss", 0.5, 0, 1)
frac2 = RooRealVar("frac", "Fraction of a gauss", 0.5, 0, 1)
frac3 = RooRealVar("frac", "Fraction of a gauss", 0.5, 0, 1)
frac4 = RooRealVar("frac", "Fraction of a gauss", 0.5, 0, 1)
model = RooAddPdf(
"sum_pdf", "sum of pdfs",
RooArgList(RooArgList(gauss1, gauss2),
RooArgList(gauss3, gauss4, gauss5)),
RooArgList(frac1, frac2, frac3, frac4))
return obs, model
def rooFit207():
print ">>> setup model signal components: gaussians..."
x = RooRealVar("x","x",0,10)
mean = RooRealVar("mean","mean of gaussians",5)
sigma = RooRealVar("sigma","width of gaussians",0.5)
sig = RooGaussian("sig","Signal",x,mean,sigma)
print ">>> setup model background components: Chebychev polynomial plus exponential..."
a0 = RooRealVar("a0","a0",0.5,0.,1.)
a1 = RooRealVar("a1","a1",-0.2,0.,1.)
bkg1 = RooChebychev("bkg1","Background 1",x,RooArgList(a0,a1))
alpha = RooRealVar("alpha","alpha",-1)
bkg2 = RooExponential("bkg2","Background 2",x,alpha)
bkg1frac = RooRealVar("bkg1frac","fraction of component 1 in background",0.2,0.,1.)
bkg = RooAddPdf("bkg","Signal",RooArgList(bkg1,bkg2),RooArgList(bkg1frac))
print ">>> sum signal and background component..."
bkgfrac = RooRealVar("bkgfrac","fraction of background",0.5,0.,1.)
model = RooAddPdf("model","g1+g2+a",RooArgList(bkg,sig),RooArgList(bkgfrac))
# Create dummy dataset that has more observables than the above pdf
y = RooRealVar("y","y",-10,10)
data = RooDataSet("data","data",RooArgSet(x,y))
# Basic information requests:"
print ">>> get list of observables of pdf in context of a dataset..."
# Observables are define each context as the variables
# shared between a model and a dataset. In this case
# that is the variable 'x'
model_obs = model.getObservables(data) # RooArgSet
model_obs.Print('v')
print "\n>>> get list of parameters..."
# Get list of parameters, given list of observables
model_params = model.getParameters(RooArgSet(x)) # RooArgSet
print ">>> model_params.getStringValue(\"a0\") = %s" % (model_params.getStringValue("a0"))
print ">>> model_params.getRealValue(\"a0\") = %s" % (model_params.getRealValue("a0"))
print ">>> model_params.find(\"a0\").GetName() = %s" % (model_params.find("a0").GetName())
print ">>> model_params.find(\"a0\").getVal() = %s" % (model_params.find("a0").getVal())
# print ">>> for param in model_params:"
# for param in model_params.():
# print ">>> %s"%(model_params.first())
# print ">>> %s"%(model_params.first())
# model_params.selectByName("a*").Print('v')
model_params.Print('v')
print "\n>>> get list of parameters of a dataset..."
# Gives identical results to operation above
model_params2 = model.getParameters(data) # RooArgSet
model_params2.Print()
print "\n>>> get list of components..."
# Get list of component objects, including top-level node
model_comps = model.getComponents() # RooArgSet
model_comps.Print('v')
print "\n>>> modifications to structure of composites..."
sigma2 = RooRealVar("sigma2","width of gaussians",1)
sig2 = RooGaussian("sig2","Signal component 1",x,mean,sigma2)
sig1frac = RooRealVar("sig1frac","fraction of component 1 in signal",0.8,0.,1.)
sigsum = RooAddPdf("sigsum","sig+sig2",RooArgList(sig,sig2),RooArgList(sig1frac))
print ">>> construct a customizer utility to customize model..."
cust = RooCustomizer(model,"cust")
print ">>> instruct the customizer to replace node 'sig' with node 'sigsum'..."
cust.replaceArg(sig,sigsum)
# Build a clone of the input pdf according to the above customization
# instructions. Each node that requires modified is clone so that the
# original pdf remained untouched. The name of each cloned node is that
# of the original node suffixed by the name of the customizer object
#
# The returned head node own all nodes that were cloned as part of
# the build process so when cust_clone is deleted so will all other
# nodes that were created in the process.
cust_clone = cust.build(kTRUE) # RooAbsPdf
# Print structure of clone of model with sig->sigsum replacement.
cust_clone.Print("t")
# delete clone
del cust_clone
def fitChicSpectrum(dataset, binname):
""" Fit chic spectrum"""
x = RooRealVar('Qvalue', 'Q', 9.7, 10.1)
x.setBins(80)
mean_1 = RooRealVar("mean_1", "mean ChiB1", 9.892, 9, 10, "GeV")
sigma_1 = RooRealVar("sigma_1", "sigma ChiB1", 0.0058, 'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', 0.748)
n1_1 = RooRealVar('n1_1', 'n1_1', 2.8)
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1', 1.739)
n2_1 = RooRealVar('n2_1', 'n2_1', 3.0)
deltam = RooRealVar('deltam', 'deltam', 0.01943)
mean_2 = RooFormulaVar("mean_2", "@0+@1", RooArgList(mean_1, deltam))
sigma_2 = RooRealVar("sigma_2", "sigma ChiB2", 0.0059, 'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', 0.738)
n1_2 = RooRealVar('n1_2', 'n1_2', 2.8)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', 1.699)
n2_2 = RooRealVar('n2_2', 'n2_2', 3.0)
parameters = RooArgSet()
parameters.add(RooArgSet(sigma_1, sigma_2))
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
parameters.add(RooArgSet(a1_2, a2_2, n1_2, n2_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1,
a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2,
a2_2, n2_2)
#background
q01S_Start = 9.5
alpha = RooRealVar("#alpha", "#alpha", 1.5, -1, 3.5) #0.2 anziche' 1
beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.)
q0 = RooRealVar("q0", "q0", q01S_Start) #,9.5,9.7)
delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0))
b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0))
signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.",
RooArgList(x, q0))
background = RooGenericPdf("background", "Background",
"signum1*pow(delta,#alpha)*exp(b1)",
RooArgList(signum1, delta, alpha, b1))
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf, chib2_pdf, background)
n_chib = RooRealVar("n_chib", "n_chib", 2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21", "ratio_21", 0.5, 0, 1)
n_chib1 = RooFormulaVar("n_chib1", "@0/(1+@1)",
RooArgList(n_chib, ratio_21))
n_chib2 = RooFormulaVar("n_chib2", "@0/(1+1/@1)",
RooArgList(n_chib, ratio_21))
n_background = RooRealVar('n_background', 'n_background', 4550, 0, 50000)
ratio_list = RooArgList(n_chib1, n_chib2, n_background)
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
frame = x.frame(RooFit.Title('m'))
range = x.setRange('range', 9.7, 10.1)
result = modelPdf.fitTo(dataset, RooFit.Save(), RooFit.Range('range'))
dataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
#plotting
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
canvas.SaveAs('out-' + binname + '.png')
a5 = RooRealVar("p_5", "p_5", -0.000001, -10., 10.)
poliset = RooArgList(a0, a1, a2, a3, a4)
# gaussFrac = RooRealVar("s","fraction of component 1 in kkSig",0.3,0.0,1.0)
nSigKK = RooRealVar("nSig", "nSig",
theData.numEntries() * 0.3, 0.0,
theData.numEntries() * 1.5)
nBkgKK = RooRealVar("nBkg", "nBkg",
theData.numEntries() * 0.7, 0.0,
theData.numEntries() * 1.5)
kkSig = RooVoigtian("kkSig", "kkSig", tt_mass, kkMean, kkGamma, kkSigma)
#kkSig = RooGaussian("kkSig","kkSig",tt_mass,kkMean,kkGamma)#,kkSigma)
#kkBkg = RooBernstein("kkBkg" , "kkBkg", tt_mass, RooArgList(B_1, B_2,B_3,B_4))#,B_5) )#,B_6))
kkBkg = RooChebychev("kkBkg", "Background", tt_mass, poliset)
kkTot = RooAddPdf("kkTot", "kkTot", RooArgList(kkSig, kkBkg),
RooArgList(nSigKK, nBkgKK))
nfit = 0
#kkfit = kkTot.fitTo(traKFitData,Range(fitphimin+0.005,fitphimax-0.005),RooFit.PrintLevel(-1), RooFit.NumCPU(7),RooFit.Save())
#nfit +=1
if debugging:
kkGamma.setConstant(kTRUE)
kkMean.setConstant(kTRUE)
kkSigma.setConstant(kTRUE)
a0.setConstant(kTRUE)
a1.setConstant(kTRUE)
a2.setConstant(kTRUE)
a3.setConstant(kTRUE)
a4.setConstant(kTRUE)
m = RooRealVar('mean', 'mean', float(mass),
float(mass) - 200,
float(mass) + 200)
s = RooRealVar('sigma', 'sigma', 0.1 * float(mass), 0, 10000)
a = RooRealVar('alpha', 'alpha', 1, -10, 10)
n = RooRealVar('n', 'n', 1, 0, 100)
sig = RooCBShape('sig', 'sig', x, m, s, a, n)
p = RooRealVar('p', 'p', 1, 0, 5)
x0 = RooRealVar('x0', 'x0', 1000, 100, 5000)
bkg = RooGenericPdf('bkg', '1/(exp(pow(@0/@1,@2))+1)',
RooArgList(x, x0, p))
fsig = RooRealVar('fsig', 'fsig', 0.5, 0., 1.)
signal = RooAddPdf('signal', 'signal', sig, bkg, fsig)
# -----------------------------------------
# fit signal
canSname = 'can_Mjj' + str(mass)
canS = TCanvas(canSname, canSname, 900, 600)
gPad.SetLogy()
roohistSig = RooDataHist('roohist', 'roohist', RooArgList(x), hSig)
roohistSig.Print()
res_sig = signal.fitTo(roohistSig, RooFit.Save(ROOT.kTRUE))
res_sig.Print()
frame = x.frame()
roohistSig.plotOn(frame, RooFit.Binning(166))
signal.plotOn(frame)
a4 = RooRealVar("a4", "a4", 0.01, -5.0, 5.0)
a5 = RooRealVar("a5", "a5", 0.01, -5.0, 5.0)
a6 = RooRealVar("a6", "a6", 0.01, -5.0, 5.0)
a7 = RooRealVar("a7", "a7", 0.001, -5.0, 5.0)
a8 = RooRealVar("a8", "a8", 0.001, -5.0, 5.0)
aset = RooArgList(a0, a1, a2, a3, a4, a5, a6, a7, a8)
bkg = RooBernstein("cheb", "Background", mass, aset)
#bkg = RooExponential("bkg","bkg",mass,alpha)
#gauss = RooGaussian("gauss","gaussian PDF ",mass,mean,sigma)
sig_1 = RooGaussian("sig_1", "sig_1", mass, mean, sigma)
sig_2 = RooGaussian("sig_1", "sig_1", mass, mean, sigma_2)
sig_3 = RooGaussian("bump", "bump", mass, mean_3, sigma_3)
sig = RooAddPdf("sig", "g+g", sig_1, sig_2, gFrac)
#sig_1 = RooGaussian("sig_1","sig_1",mass,mean,sigma)
nSig = RooRealVar("nSig", "nSig", 100, 100, len(data["mass"].values))
nBkg = RooRealVar("nBkg", "nBkg", 1000, 100, len(data["mass"].values))
#tot = RooAddPdf("tot","g+cheb",RooArgList(sig,sig_3,bkg),RooArgList(sFrac,bumpFrac))
tot = RooAddPdf("tot", "g+cheb", RooArgList(sig_1, bkg),
RooArgList(nSig, nBkg))
h1 = TH1F("hist", "hist", 200, 4.05, 5.75)
map(h1.Fill, data["mass"].values)
masslist = RooArgList(mass)
dh = RooDataHist("dh", "dh", masslist, h1)
def main(infiles=None):
infile = infiles[0]
var = "leadmupt"
bounds = [25, 300]
c1 = ROOT.TCanvas("NLL", "NLL", 1000, 1000)
x = ROOT.RooRealVar(var, var, bounds[0], bounds[1])
aset = ROOT.RooArgSet(x, "aset")
frame = x.frame()
f = ROOT.TFile.Open(infile)
tree = f.Get(f.GetListOfKeys().At(0).GetName())
tree.Print()
nentries = tree.GetEntries()
y = []
dh2 = ROOT.TH1F()
data = ROOT.RooDataSet("Data", "Data", aset)
for n in range(nentries):
tree.GetEntry(n)
y.append(getattr(tree, var))
if y[n] <= bounds[1] and y[n] >= bounds[0]:
x.setVal(y[n])
data.add(aset)
dh2.Fill(y[n])
data.plotOn(frame)
dh = RooDataHist("dh", "dh", RooArgSet(x), data)
nbins = dh2.GetNbinsX()
nbinsy = dh2.GetNbinsX()
print("nbins: ", nbins)
print("nbinsy: ", nbinsy)
for i in range(nbins):
if dh2.GetBinContent(dh2.GetBin(i)) == 0:
print("bin: ", i)
#dh2.SetBinError(bin,0.01)
## CREATE GAUSSIAN MODEL
mx = RooRealVar("mx", "mx", 10, 0, 350)
sx = RooRealVar("sx", "sx", 3, 0, 10)
gx = RooGaussian("gx", "gx", x, mx, sx)
## CREATE EXPONENTIAL MODEL
lambda1 = RooRealVar("lambda1", "slope1", -100, 100)
expo1 = RooExponential("expo1", "exponential PDF 1", x, lambda1)
lambda2 = RooRealVar("lambda2", "slope2", -.03, -1000, 1000)
expo2 = RooExponential("expo2", "exponential PDF 2", x, lambda2)
l1 = RooRealVar("l1", "yield1", 100, 0, 10000)
l2 = RooRealVar("l2", "yield2", 100, 0, 10000)
#sum = RooAddPdf("sum","exp and gauss",RooArgList(expo1,gx),RooArgList(l1,l2))
sum = RooAddPdf("sum", "2 exps", RooArgList(expo1, expo2),
RooArgList(l1, l2))
## Construct binned likelihood
nll = RooNLLVar("nll", "nll", expo1, data, ROOT.RooFit.Extended(True))
## Start Minuit session on NLL
m = RooMinuit(nll)
m.migrad()
m.hesse()
r1 = m.save()
#sum.plotOn(frame,ROOT.RooFit.LineColor(1))
#sum.plotOn(frame,ROOT.RooFit.Components("expo1"),ROOT.RooFit.LineColor(2))
#sum.plotOn(frame,ROOT.RooFit.Components("expo2"),ROOT.RooFit.LineColor(3))
expo1.plotOn(frame)
## Construct Chi2
chi2 = RooChi2Var("chi2", "chi2", expo2, dh)
## Start Minuit session on Chi2
m2 = RooMinuit(chi2)
m2.migrad()
m2.hesse()
r2 = m2.save()
frame.Draw()
c2 = ROOT.TCanvas("Chi2", "Chi2", 1000, 1000)
frame2 = x.frame()
data.plotOn(frame2)
expo2.plotOn(frame2)
#sum.plotOn(frame2,ROOT.RooFit.LineColor(4))
#sum.plotOn(frame2,ROOT.RooFit.Components("expo1"),ROOT.RooFit.LineColor(5))
#sum.plotOn(frame2,ROOT.RooFit.Components("expo2"),ROOT.RooFit.LineColor(6))
## Print results
print("result of likelihood fit")
r1.Print("v")
print("result of chi2 fit")
r2.Print("v")
frame2.Draw()
c1.Draw()
c2.Draw()
rep = ''
while not rep in ['q', 'Q']:
rep = input('enter "q" to quit: ')
if 1 < len(rep):
rep = rep[0]
def fitMass(rangem=[0.4, 2.0], iflag=1, iopt_bkgshape=0, CBpar=[0., 0., 0.]):
global myc, fitres
m0 = sum(rangem) / 2
#w0=(rangem[1]-rangem[0])/10
w0 = 0.004
mass = RooRealVar("ee_ivm", "ee_ivm", rangem[0], rangem[1])
if iflag == 1:
###Construct signal pdf with gaus
mean = RooRealVar("mean", "mean", m0)
sigma = RooRealVar("sigma", "sigma", w0)
signal = RooGaussian("signal", "signal", mass, mean, sigma)
elif iflag == 2 or iflag == 3:
## Construct signal pdf with CB function
##print "outinfo",x,CBpar[0],CBpar[1],CBpar[2],CBpar[3]
cbmean = RooRealVar("cbmean", "cbmean", m0)
cbsigma = RooRealVar("cbsigma", "cbsigma", CBpar[0])
n1 = RooRealVar("n1", "", CBpar[1])
alpha = RooRealVar("alpha", "", CBpar[2])
cbsigma.setConstant(ROOT.kTRUE)
n1.setConstant(ROOT.kTRUE)
alpha.setConstant(ROOT.kTRUE)
signal = RooCBShape("cball", "crystal ball1", mass, cbmean, cbsigma,
alpha, n1)
# elif iflag ==3:
# pass
else:
print "ERROR, please specify signal shape for fitting!!"
sys.exit()
# Construct background pdf
a0 = RooRealVar("a0", "a0", 0.1, -1, 1)
a1 = RooRealVar("a1", "a1", 0.004, -1, 1)
a2 = RooRealVar("a2", "a2", 0.001, -1, 1)
if iopt_bkgshape == 0:
background = RooChebychev("background", "background", mass,
RooArgList(a0, a1))
else:
background = RooChebychev("background", "background", mass,
RooArgList(a0, a1, a2))
# Construct composite pdf
if iflag == 1:
up_nsig = 40
else:
up_nsig = 60
nsig = RooRealVar("nsig", "nsig", 5, 0.0, up_nsig)
nbkg = RooRealVar("nbkg", "nbkg", 800, 0, 3000)
#frac = RooRealVar("frac", "frac", 0.001, 0.0001, 0.1)
model = RooAddPdf("model", "model", RooArgList(signal, background),
RooArgList(nsig, nbkg))
#model = RooAddPdf("model", "model", RooArgList(signal, background), RooArgList(frac))
mcdata = RooDataSet(
"ds", "ds", RooArgSet(mass), RooFit.Import(data),
RooFit.Cut("ee_ivm<" + str(rangem[1]) + "&&ee_ivm>" + str(rangem[0])))
if optp == 1:
ipr = 1
verbose = 0
elif optp == 2:
ipr = 1
verbose = 1
else:
ipr = -1
verbose = 0
fitres=model.fitTo(mcdata,RooFit.Save(),RooFit.Minos(1), RooFit.Strategy(2),\
RooFit.PrintLevel(ipr), RooFit.Verbose(verbose))
nll = RooNLLVar("nll", "nll", model, mcdata,
RooFit.Range(rangem[0], rangem[1]))
pll = nll.createProfile(RooArgSet(nsig))
Profile = RooProfileLL("Profile", "Profile", nll, RooArgSet(nsig))
llhoodP = RooFormulaVar("llhoodP", "exp(-0.5*Profile)",
RooArgList(Profile))
xframe2 = nsig.frame(RooFit.Title("number of signal"))
nllplot = nll.plotOn(xframe2, RooFit.ShiftToZero())
themin = RooConstVar("themin", "themin", nllplot.GetMinimum())
llhood = RooFormulaVar("llhood", "exp(-0.5*(nll-themin*0.95))",
RooArgList(nll, themin))
if optp:
xframe = mass.frame(RooFit.Title("mass of ee pair"))
xframe3 = nsig.frame(RooFit.Title("number of signal"))
xframe3.SetYTitle("Likelihood")
mcdata.plotOn(xframe)
model.plotOn(xframe)
model.plotOn(xframe, RooFit.Components("background"),
RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kRed))
model.plotOn(xframe, RooFit.Components("cball"),
RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kGreen))
myc.cd(1)
xframe.Draw()
#pll.plotOn(xframe2,RooFit.LineColor(ROOT.kRed))
if optp: print "***** archmin ", themin.Print()
#llhoodP.plotOn(xframe3, RooFit.LineColor(ROOT.kRed))
llhood.plotOn(xframe3)
myc.cd(2)
xframe2.SetMinimum(0)
xframe2.Draw()
myc.cd(3)
xframe3.Draw()
myc.Update()
raw_input()
nsig.setRange("IntRange1", 0, 1000.)
Int1 = llhood.createIntegral(RooArgSet(nsig),
ROOT.RooFit.Range('IntRange1'))
Int1Val = Int1.getVal()
i = 0
hit = False
while not (hit):
i = i + 1
nsig.setRange("IntRange2", 0, float(i))
Int2 = llhood.createIntegral(RooArgSet(nsig),
ROOT.RooFit.Range('IntRange2'))
if Int2.getVal() >= Int1Val * 0.9:
if optp: print "&&& ", i
hit = True
return i
def doubleGausCB(cbshape, doublegaus, f3_, tagged_mass, w):
f4 = RooRealVar ("f4" , "f4" , f4_ , 0., 1.)
doublegauscb = RooAddPdf ("doublegauscb" , "doublegauscb" , RooArgList(doublegaus,cbshape), RooArgList(f4))
_import(w,doublegauscb)
