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 main1():
m = RooRealVar('evt.m', 'evt.m', 1.92, 2.02)
mode = RooCategory('evt.mode', 'evt.mode')
mode.defineType('phipi', 0)
aset = RooArgSet('aset')
aset.add(m)
aset.add(mode)
tuplist = tupleList('genmc', 7)
dst, _, f = getTree('/'.join([tuplePath(), tuplist[-1]]))
# dst.Print()
# dst.Show(0)
# for evt in dst:
# print('Hello!')
# print(evt.evt.m)
# break
ds = RooDataSet('ds', 'ds', dst, aset)
print(ds.numEntries())
mean = RooRealVar('mean', 'mean', 1.96, 1.92, 2.0)
width = RooRealVar('width', 'width', 0.006, 0.001, 0.010)
pdf = RooGaussian('pdf', 'pdf', m, mean, width)
pdf.fitTo(ds, Verbose(), Timer(True))
makePlot(m, ds, pdf)
raw_input("Press Enter to continue...")
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 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 crystalBall(mean, sigma_, alpha_, n_, tagged_mass, w, fn, bin, rangeAlpha):
sigmaCB = RooRealVar ("#sigma_{%s}^{%s}"%(fn, bin) , "sigmaCB_%s"%fn , sigma_ , 0, 1 )
alpha = RooRealVar ("#alpha_{%s}^{%s}"%(fn, bin) , "#alpha_{%s}^{%s}"%(fn, bin) , alpha_ , rangeAlpha[0], rangeAlpha[1] ) # was 0 - 5
n = RooRealVar ("n_{%s}^{%s}"%(fn, bin) , "n_%s"%fn , n_ , 0.001, 100 )
cbshape = RooCBShape ("cbshape_%s_%s"%(fn,bin) , "cbshape_%s_%s"%(fn, bin) , tagged_mass, mean, sigmaCB, alpha, n)
_import(w,cbshape)
class GaussianConstraint(object):
def __init__(self, name, expr, deps, mean, sigma):
self.name = name
self.expr = expr
self.deps = deps
self.mean = mean
self.sigma = sigma
# pdf of yield vs coupling modificators
dependentlist = RooArgList()
for dep in deps:
dependentlist.add(dep)
self.pdf_yield = RooGenericPdf(name, name, expr, dependentlist)
# observable (measurement)
obsname = name + 'Obs'
self.var_obs = RooRealVar(obsname, obsname, mean)
# width of Gaussian pdf
sname = name + 'Sigma'
self.var_sigma = RooRealVar(sname, sname, sigma)
# Gaussian pdf
gname = name + "Constraint"
self.pdf_constraint = RooGaussian(gname, gname, self.var_obs,
self.pdf_yield, self.var_sigma)
self.pulls = ROOT.TH1F('pulls_' + name, name, 1000, -10, 10)
def fill_pull(self):
pull = (self.pdf_yield.getVal() - 1) / self.var_sigma.getVal()
self.pulls.Fill(pull)
def info(self):
print self.name
self.pdf_yield.Print()
self.var_obs.Print()
self.var_sigma.Print()
self.pdf_constraint.Print()
def main():
# independent variable
x = RooRealVar("x", "x", -10, 10)
# parameters
width = RooRealVar("width", "gaussian width", 2., 0., 10.)
mean = RooRealVar("mean", "gaussian mean", 0., -10., 10.)
decay = RooRealVar("decay", "decay coeff", -0.5, -1.0, 0.)
# instantiate the custom pdf
pdf = RooExpAndGauss("pdf", "custom pdf", x, mean, width, decay)
# generate random dataset
toydata = pdf.generate(RooArgSet(x), 5000)
# fit back to the dataset (I expect it will fit quite well!)
pdf.fitTo(toydata, rf.Strategy(2))
# plot the thing
canvas = TCanvas()
plot = x.frame(50)
toydata.plotOn(plot)
pdf.plotOn(plot)
plot.Draw()
canvas.SaveAs("plots/fittedRooExpAndGauss_fromPython.pdf")
return
def rooFit106():
print ">>> setup model..."
x = RooRealVar("x", "x", -3, 3)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
gauss = RooGaussian("gauss", "gauss", x, mean, sigma)
data = gauss.generate(RooArgSet(x), 10000) # RooDataSet
gauss.fitTo(data)
print ">>> plot pdf and data..."
frame = x.frame(Name("frame"), Title("RooPlot with decorations"),
Bins(40)) # RooPlot
data.plotOn(frame)
gauss.plotOn(frame)
print ">>> RooGaussian::paramOn - add box with pdf parameters..."
# https://root.cern.ch/doc/master/classRooAbsPdf.html#aa43b2556a1b419bad2b020ba9b808c1b
# Layout(Double_t xmin, Double_t xmax, Double_t ymax)
# left edge of box starts at 20% of x-axis
gauss.paramOn(frame, Layout(0.55))
print ">>> RooDataSet::statOn - add box with data statistics..."
# https://root.cern.ch/doc/master/classRooAbsData.html#a538d58020b296a1623323a84d2bb8acb
# x size of box is from 55% to 99% of x-axis range, top of box is at 80% of y-axis range)
data.statOn(frame, Layout(0.20, 0.55, 0.8))
print ">>> add text and arrow..."
text = TText(2, 100, "Signal")
text.SetTextSize(0.04)
text.SetTextColor(kRed)
frame.addObject(text)
arrow = TArrow(2, 100, -1, 50, 0.01, "|>")
arrow.SetLineColor(kRed)
arrow.SetFillColor(kRed)
arrow.SetLineWidth(3)
frame.addObject(arrow)
print ">>> persist frame with all decorations in ROOT file..."
file = TFile("rooFit106.root", "RECREATE")
frame.Write()
file.Close()
# To read back and plot frame with all decorations in clean root session do
# [0] TFile f("rooFit106.root")
# [1] xframe->Draw()
print ">>> draw functions and toy data on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.05)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit106.png")
def fitNBkg(ibdt, fullbkg):
slope = RooRealVar("slope", "slope", 0.5, -10, 10)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass)
cut = cut_base + '&& bdt_prob > %s' % (ibdt)
theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt],
B0Mass_ + 3 * dict_sigma[ibdt])
databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut)
r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right'))
frame = theBMass.frame()
databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7))
bkg_exp.plotOn(frame, )
# bkg_exp.fixCoefRange('left,right')
nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000)
ebkg = RooExtendPdf('ebkg', 'ebkg', bkg_exp, nbkg, 'sigRangeMC')
ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right'))
ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6))
frame.Draw()
dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
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 NEvtsCalc( uPars, uEPars):
Pars = {}
Pars[0] = RooRealVar('c1', 'Exponential constant', -1, -10, 0)
Pars[1] = RooRealVar('ExpY', 'Background Yield', 100, 0, 10000000)
Pars[2] = RooRealVar('Mean', 'Voigtian Mean' , 90.0, 20, 180.0)
Pars[3] = RooRealVar('Width', 'Voigtian Width' , 5.0, 0.5, 40.0)
Pars[4] = RooRealVar('Sigma', 'Voigtian Sigma' , 5.0, 0.5, 40.0)
Pars[5] = RooRealVar('VoY', 'Signal Yield', 100, 0, 10000000)
if len(Pars) != len(uPars):
print 'The input array has a weird number of entries...'
return 0
if len(uPars) != len(uEPars):
print 'The input arrays are of different sizes...'
return 0
for x in xrange(0, 6):
Pars[x].setVal(uPars[x])
Pars[x].setError(uEPars[x])
v = RooRealVar('v', 'Invariant Mass (GeV)', 60, 120)
Voigt = RooVoigtian('Voigt', 'Voigtian - Signal', v, Pars[2], Pars[3], Pars[4])
## Calculate integral from -2sigma to 2sigma
VStDev_r = Voigt.sigma(v)
VStDev = VStDev_r.getVal()
v.setRange("sobRange", Pars[2].getVal() - 2.*VStDev, Pars[2].getVal() + 2.*VStDev)
integralSig = Voigt.createIntegral(RooArgSet(v), RooFit.NormSet(RooArgSet(v)), RooFit.Range("sobRange"))
FinalNumber = integralSig.getVal()*Pars[5].getVal()
return FinalNumber
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 _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 plotPDF():
gStyle.SetOptFit(1111)
x_var = 'Tau_DTF_Phi_M' #'Phi_M'
#x_var = 'Phi_M'
x = RooRealVar(x_var, 'm_{#Phi}', 1008,1032, 'MeV')
x = RooRealVar(x_var, 'm_{#Phi}', 0,10, 'MeV')
# mean = RooRealVar("#mu","#mu",1020,1010,1025)
mean = RooRealVar("#mu","#mu",5)
gamma = RooRealVar("#Gamma_{0}","#Gamma",3,0.1,10)
spin = RooRealVar("J","J",1)
radius = RooRealVar("radius","radius",0.003)#, 0, 0.01)
# m_K = RooRealVar("m_K","m_K", 493.677)
m_K = RooRealVar("m_K","m_K", 0.5)
NRBW = ROOT.RooBreitWigner('BW','BW',x,mean, gamma)
RBW = ROOT.RooRelBreitWigner('BW','BW',x,mean, gamma,spin,radius,m_K,m_K)
frame = x.frame(RooFit.Title('Breit Wigner'))
NRBW.plotOn(frame, RooFit.LineWidth(2),RooFit.LineColor(ROOT.kRed), RooFit.LineStyle(1))
RBW.plotOn(frame, RooFit.LineWidth(2),RooFit.LineColor(ROOT.kBlue), RooFit.LineStyle(2))
c1 = TCanvas('c1', 'c1')
frame.Draw()
c1.Update()
return c1
def fitNBkg(ibdt, fullbkg, isample):
slope = RooRealVar("slope", "slope", 0.5, -10, 10)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass)
cut = cut_base + '&& bdt_prob > %s' % (ibdt)
theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt],
B0Mass_ + 3 * dict_sigma[ibdt])
databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut)
r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right'),
RooFit.PrintLevel(-1))
frame = theBMass.frame()
databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7))
bkg_exp.plotOn(frame, )
canv = ROOT.TCanvas()
frame.Draw()
nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000)
ebkg = RooExtendPdf(
'ebkg', 'ebkg', bkg_exp, nbkg,
'sigRangeMC') ## here imposing the range to calculate bkg yield
ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right'), RooFit.PrintLevel(-1))
ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6))
frame.Draw()
# canv.SaveAs('bkg_fit_bdt%f_sample%i.pdf'%(ibdt,isample))
dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def main():
# setting for reduced DS to be used on the output of makeSubset.C
inputfile_name = "small.root"
tree_name = "upsTree"
# settings for full dataset (long processing time for unbinned lh)
#inputfile_name = "/data1/chibdata/collision/v2/2012_AllData_v2.root"
#tree_name = "rootuple/upsTree"
print "Opening file"
inputfile = TFile.Open(inputfile_name, "READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(tree_name, tree)
mass = RooRealVar("ups_mass", "ups_mass", 7, 11)
y = RooRealVar("ups_rapidity", "ups_rapidity", -3, 3)
pt = RooRealVar("ups_pt", "ups_pt", 0, 100)
print "Assigning dataset"
dataArgSet = RooArgSet(mass, y, pt)
dataSet = RooDataSet("yds", "Y data set", tree, dataArgSet)
cuts= "abs(ups_rapidity) < 1.25"+\
"&& ups_pt>9.5"\
reduced_ds = dataSet.reduce(RooFit.Cut(cuts))
print "Performing likelihood analysis"
dofit(reduced_ds, "Y3S")
def addConstraint(workspace,rrv_x, x_mean, x_sigma, ConstraintsList):
rrv_x_mean = RooRealVar(rrv_x.GetName()+"_mean",rrv_x.GetName()+"_mean",x_mean )
rrv_x_sigma = RooRealVar(rrv_x.GetName()+"_sigma",rrv_x.GetName()+"_sigma",x_sigma )
constrainpdf_x = RooGaussian("constrainpdf_"+rrv_x.GetName(),"constrainpdf_"+rrv_x.GetName(),rrv_x, rrv_x_mean, rrv_x_sigma)
ConstraintsList.append(constrainpdf_x.GetName())
getattr(workspace,"import")(constrainpdf_x)
return constrainpdf_x
def buildPdf(ws, p):
mass = RooRealVar("mass", "mass", p.minMass, p.maxMass)
getattr(ws,'import')(mass)
# Construct signal pdf
mean = RooRealVar("mean", "mean", 90, 85, 95)
width = RooRealVar("width", "width", 2.4952, 1, 3)
width.setConstant(ROOT.kTRUE)
sigma = RooRealVar("sigma", "sigma", 1.2, 0.2, 10)
signalAll = RooVoigtian("signalAll", "signalAll", mass, mean, width, sigma)
turnOnAll = RooRealVar("turnOnAll","turnOnAll", 80., 40., 150.)
widthAll_bkg = RooRealVar("widthAll","widthAll", 2., 0., 50.)
decayAll_bkg = RooRealVar("decayAll","decayAll", 80., 20., 150.)
meanB = RooRealVar("meanB", "meanB", 90, 60, 130)
sigmaB = RooRealVar("sigmaB", "sigmaB", 10, 1, 20)
bkg_a1 = RooRealVar("bkg_a1", "bkg_a1", 0., -2., 2.)
bkg_a2 = RooRealVar("bkg_a2", "bkg_a2", 0., -2., 2.)
backgroundAll = RooGaussian("backgroundAll", "backgroundAll", mass, meanB, sigmaB)
# Construct composite pdf
sigAll = RooRealVar("sigAll", "sigAll", 2000, 0, 100000)
bkgAll = RooRealVar("bkgAll", "bkgAll", 100, 0, 10000)
modelAll = RooAddPdf("modelAll", "modelAll", RooArgList(signalAll, backgroundAll), RooArgList(sigAll, bkgAll))
if p.NoBkgd:
modelAll = RooAddPdf("modelAll", "modelAll", RooArgList(signalAll), RooArgList(sigAll))
# Define pdf for all probes
# Construct signal pdf.
# NOTE that sigma is shared with the signal sample model
signalPass = RooVoigtian("signalPass","signalPass",mass,mean,width,sigma)
# Construct the background pdf
backgroundPass = RooGaussian("backgroundPass", "backgroundPass", mass, meanB, sigmaB)
# Construct the composite model
efficiency = RooRealVar("efficiency","efficiency",0.9,0.3,1.)
sigPass = RooFormulaVar("sigPass", "@0*@1", RooArgList(sigAll, efficiency))
bkgPass = RooRealVar("bkgPass", "bkgPass", 100, 0, 10000)
modelPass = RooAddPdf("modelPass", "modelPass", RooArgList(signalPass, backgroundPass), RooArgList(sigPass, bkgPass))
if p.NoBkgd:
modelPass = RooAddPdf("modelPass", "modelPass", RooArgList(signalPass), RooArgList(sigPass))
frac = RooRealVar("frac", "frac", 0.8, 0., 1.)
# Define combined pdf for simultaneous fit
# Define category to distinguish physics and control samples events
sample = RooCategory("sample","sample")
sample.defineType("all")
sample.defineType("pass")
simPdf = RooSimultaneous("simPdf","simultaneous pdf",sample)
# Associate model with the physics state and model_ctl with the control state
simPdf.addPdf(modelAll,"all")
simPdf.addPdf(modelPass,"pass")
# ws.import(simPdf)
getattr(ws,'import')(simPdf)
def rooFitVar( self ):
## Get the corresponding RooRealVar used in RooFit
# @return the RooRealVar
if not self.__rooFitVar:
from ROOT import RooRealVar
self.__rooFitVar = RooRealVar( self.name, self.title, self.low, self.up, self.unit )
self.__rooFitVar.setBins( self.nBins )
return self.__rooFitVar
def fit(self):
fit_variable = RooRealVar("fit_variable", "fit_variable", self.fit_boundaries[0], self.fit_boundaries[1])
fit_variable.setBins(self.histograms[self.data_label].nbins())
variables = RooArgList()
variables.add(fit_variable)
variable_set = RooArgSet()
variable_set.add(fit_variable)
roofit_histograms = {}
roofit_pdfs = {}
roofit_variables = {}
N_min = 0.0
N_max = self.normalisation[self.data_label] * 2.0
pdf_arglist = RooArgList()
variable_arglist = RooArgList()
roofit_histograms[self.data_label] = RooDataHist(
self.data_label, self.data_label, variables, self.histograms[self.data_label]
)
for sample in self.samples:
roofit_histogram = RooDataHist(sample, sample, variables, self.histograms[sample])
roofit_histograms[sample] = roofit_histogram
roofit_pdf = RooHistPdf("pdf" + sample, "pdf" + sample, variable_set, roofit_histogram)
roofit_pdfs[sample] = roofit_pdf
roofit_variable = RooRealVar(sample, sample + " events", self.normalisation[sample], N_min, N_max)
roofit_variables[sample] = roofit_variable
pdf_arglist.add(roofit_pdf)
variable_arglist.add(roofit_variable)
model = RooAddPdf("model", "sum of all known", pdf_arglist, variable_arglist)
use_model = model
if self.constraints:
arg_set = RooArgSet(model)
constraints = self.get_fit_normalisation_constraints(model, roofit_variables)
for constraint in constraints:
arg_set.add(constraint)
model_with_constraints = RooProdPdf(
"model_with_constraints", "model with gaussian constraints", arg_set, RooLinkedList()
)
use_model = model_with_constraints
if self.method == "TMinuit":
# WARNING: number of cores changes the results!!!
self.saved_result = use_model.fitTo(
roofit_histograms[self.data_label],
RooFit.Minimizer("Minuit2", "Migrad"),
RooFit.NumCPU(1),
RooFit.Extended(),
RooFit.Save(),
)
results = {}
for sample in self.samples:
results[sample] = (roofit_variables[sample].getVal(), roofit_variables[sample].getError())
self.results = results
def __init__(self, adc, name):
#input ADC values
self.adc = adc
#1n Gaussian
mean_nam = "mean_1n_" + name
self.mean_1n = RooRealVar(mean_nam, mean_nam, 40., 120.)
sigma_nam = "sigma_1n_" + name
self.sigma_1n = RooRealVar(sigma_nam, sigma_nam, 0., 100.)
gauss_nam = "gauss_1n_" + name
self.gauss_1n = RooGaussian(gauss_nam, gauss_nam, self.adc, self.mean_1n, self.sigma_1n)
def doMCFit(dataSet, x_var, addTitlePlot=''):
cuts_str = ''
data = dataSet.reduce( RooFit.Cut(cuts_str) )
x=RooRealVar(x_var, 'm_{#tau}',1757,1797,'MeV')
numBins = 100 # define here so that if I change it also the ndof change accordingly
x.setBins(numBins)
######################################################
# DEFINE PDF
######################################################
w = RooWorkspace('w')
getattr(w,'import')(x)
w.factory('''RooDSCBShape::DSCB({0},
#mu[1777, 1760,1790],
#sigma[5,0,10],
#alpha[1.2], n[50, 1, 150],
#alpha, n
)'''.format(x_var))
#w.var('n').setConstant(False)
signal = w.pdf('DSCB')
# w.factory('''RooGaussian::GG({0},
# #mu, #sigma
# )'''.format(x_var))
# signal = w.pdf('GG')
# Fit
fit_region = x.setRange('fit_region',1757,1797)
result = signal.fitTo(dataSet, RooFit.Save(), RooFit.Range('fit_region'))
# Frame
frame = x.frame(RooFit.Title(' Combined mass KK#mu '+addTitlePlot))
dataSet.plotOn(frame)
signal.plotOn(frame, RooFit.LineWidth(2))
# Legends
signal.paramOn(frame, RooFit.Layout(0.6,0.9,0.9))
chi2 = round(frame.chiSquare(),2)
leg = TLegend(0.3,0,.10,.10)
leg.SetBorderSize(0)
leg.SetFillStyle(0)
leg.AddEntry(0,'#chi^{2} ='+str(chi2),'')
frame.addObject(leg)
c1 = TCanvas('c1', 'c1')
frame.Draw()
c1.Update()
for prm in ('#mu', '#sigma', '#alpha', 'n'): # TODO: automatize finding of variables from the function
w.var(prm).setConstant()
return w, c1
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 CBintialization(self):
round_energy = round(float(self.energy),-1)
if round_energy ==240 : round_energy = 250
self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist)
self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale))
self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,0.001,1.) #500.
self.a = RooRealVar("alpha_%s_%s"%(self.crystal,self.energy),"alpha_%s_%s"%(self.crystal,self.energy),self.a_initial,-10.,10)
self.n = RooRealVar("exp_%s_%s"%(self.crystal,self.energy),"exp_%s_%s"%(self.crystal,self.energy),self.n_initial,0.,30)
self.sig = RooCBShape("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s,self.a,self.n)
def Fit(h, Lc_M):
h_LcM = RooDataHist('h_LcM', 'h_LcM', RooArgList(Lc_M), h)
#Create a workspace named 'w' with the model to fit the Lc_Mass peak
nsig = RooRealVar("nsig", "N signal evts", 100000, 0, 5000000)
nbkg = RooRealVar("nbkg", "N bkg evts", 400000, 0, 1E10)
w = CreateMassFitModel(Lc_M, nsig, nbkg)
model = w.pdf("model")
model.fitTo(h_LcM, RF.Extended(True))
return model, w, h_LcM
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 generateBkg(tagged_mass, ibin, n_bkg):
slope = RooRealVar("slope", "slope", -4.2)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass)
pol_c1 = RooRealVar("p1", "coeff x^0 term", -1.2)
pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.3)
bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass,
RooArgList(pol_c1, pol_c2))
n_togen = np.random.poisson(n_bin[ibin] * n_bkg, 1)
toybkg = bkg_pol.generate(RooArgSet(tagged_mass), n_togen[0])
return toybkg
def __init__(self, mass_range=[0., 2000.]):
self.data_histogram_ = None
self.data_roohistogram_ = None
self.luminosity_ = 0.
self.collision_energy_ = 8000.
self.signal_histograms_ = {}
self.signal_roohistograms_ = {}
self.signal_names_ = []
# Fit storage
self.simple_fit_ = None
self.mjj_ = RooRealVar('mjj','mjj',float(mass_range[0]),float(mass_range[1]))
self.workspace_ = None
def __init__(self, name, lower, higher=None):
"""Initialize a variable.
Takes a name (string) and one or two numbers (float) as arguments.
One number: Initialize variable with a constant value.
Two numbers: Initialize variable with a fixed range.
"""
if higher is None:
RooRealVar.__init__(self, name, name, lower)
else:
RooRealVar.__init__(self, name, name, lower, higher)
self._fixed_minimum = None
self._fixed_maximum = None
class RealVar():
def __init__(self, *args):
self.var = RooRealVar(args[0], args[0], *args[1:])
@property
def min(self):
return self.var.getMin()
@min.setter
def min(self, val):
self.var.setMin(val)
@property
def val(self):
return self.var.getVal()
@property
def max(self):
return self.var.getMax()
@max.setter
def max(self, val):
self.var.setMax(val)
def __getattr__(self, name):
return getattr(self.var, name)
def __repr__(self):
ret = f'RooRealVar {self.var.GetName()} = {self.var.getVal()}'
if not self.var.isConstant():
ret += f' [{self.min}, {self.max}]'
return ret
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 __init__(self,name,inhist,binning,constant=False,forcePositive=True):
'''Represents a binned distribution as a group of RooRealVar parameters.
If constant == False, each bin is considered an unconstrained parameter of the model.
Args:
name (str): Unique name for the new object.
inhist (TH2): Input 2D histogram to build set of variables.
binning (Binning): Binning object used to create LOW, SIG, HIGH regions along X axis.
constant (bool, optional): If true, use RooConstVars for bins. Defaults to False and RooRealVars are used.
forcePositive (bool, optional). Defaults to True in which case the bin values will be lower bound by 1e-9
and any shape templates will asymptotically approach zero as the associated nuisance increases/decreases.
'''
super(BinnedDistribution,self).__init__(name,binning,forcePositive=forcePositive)
for cat in _subspace:
cat_name = name+'_'+cat
cat_hist = copy_hist_with_new_bins(cat_name,'X',inhist,self.binning.xbinByCat[cat])
for ybin in range(1,cat_hist.GetNbinsY()+1):
for xbin in range(1,cat_hist.GetNbinsX()+1):
bin_name = '%s_bin_%s-%s'%(cat_name,xbin,ybin)
if constant or self._nSurroundingZeros(cat_hist,xbin,ybin) > 7:
self.binVars[bin_name] = RooConstVar(bin_name, bin_name, cat_hist.GetBinContent(xbin,ybin))
else:
self.binVars[bin_name] = RooRealVar(bin_name, bin_name, max(5,cat_hist.GetBinContent(xbin,ybin)), 1e-6, 1e6)
self.nuisances.append({'name':bin_name, 'constraint':'flatParam', 'obj': self.binVars[bin_name]})
self._varStorage.append(self.binVars[bin_name]) # For safety if we add shape templates
def _createFuncVars(self,constraints):
'''Creates the nuisances list of the function variables (RooRealVars)
and associated meta data (nuisance name, constraint).
Args:
constraints (dict): Information of which parameters to constrain differently from the default.
By default, the constraint will be flat, the starting value of the parameter will be 0 with a step size of 0.1,
and the range of the parameter will be [-1000,1000].
Returns:
list: List of dictionaries with keys "name" (str), "obj" (RooRealVar), "constraint" (str).
'''
out = []
for i in range(self.getNparams()):
name = '%s_par%s'%(self.name,i)
constraint = 'flatParam'; MIN = -1000; MAX = 1000; NOM = 0.1; ERROR = 0.1
if i in constraints:
if 'constraint' in constraints[i]: constraint = constraints[i]['constraint']
if 'MIN' in constraints[i]: MIN = constraints[i]['MIN']
if 'MAX' in constraints[i]: MAX = constraints[i]['MAX']
if 'NOM' in constraints[i]: NOM = constraints[i]['NOM']
if 'ERROR' in constraints[i]: ERROR = constraints[i]['ERROR']
this_out = {'name':name, 'obj': RooRealVar(name,name,NOM,MIN,MAX), 'constraint': constraint}
this_out['obj'].setError(ERROR)
out.append(this_out)
return out
def EfficiencySignal(fname, bdtcut):
f = r.TFile(fname, 'read')
t = f.Get('DecayTree')
LcM_range = [2230, 2330]
Lc_M = RooRealVar('Lc_M', '#Lambda_{c} mass', LcM_range[0], LcM_range[1])
h0 = r.TH1F('h0', '#Lambda_{c} mass peak', 200, 2230, 2330)
t.Draw('Lc_M>>h0', 'Lc_BKGCAT<30.')
h0 = r.gPad.GetPrimitive('h0')
model, w, h_LcM = Fit(h0, Lc_M)
nsig_nocut = w.var('nsig')
nbkg_nocut = w.var('nbkg')
h1 = r.TH1F('h1', '#Lambda_{c} mass peak with BDT cut', 200, 2230, 2330)
t.Draw('Lc_M>>h1', 'Lc_BKGCAT<30.&&bdt>' + str(bdtcut))
h1 = r.gPad.GetPrimitive('h1')
model1, w1, h_LcM1 = Fit(h1, Lc_M)
nsig_cut = w1.var('nsig')
nbkg_cut = w1.var('nbkg')
return nsig_cut.getValV() / nsig_nocut.getValV()
'''
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
def main():
# Mjj0 of TT MC Bkg
f1 = TFile("Merged_TT_TuneCUETP8M1_13TeV-powheg-pythia8-runallAnalysis.root")
h_Mjj = f1.Get("histfacFatJet_ZLight/h_Mjj0")
h_Mjj.GetXaxis().SetRangeUser(0,300)
var_mean = h_Mjj.GetMean()
# Build Gaussian PDF
x = RooRealVar( 'x', 'x', 0, 300 )
mean = RooRealVar( 'mean', 'mean of gaussian', var_mean )
sigma = RooRealVar( 'sigma', 'width of gaussian', 5)
gauss = RooGaussian( 'gauss', 'gaussian PDF', x, mean, sigma)
data = RooDataHist("data","Mjj dataset",RooArgList(x), h_Mjj);
# Plot PDF
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
gauss.plotOn( xframe )
gauss.plotOn(xframe,RooFit.LineColor(2))
# Generate a toy MC set
# data = gauss.generate( RooArgSet(x), 10000 )
# Plot PDF and toy data overlaid
xframe2 = x.frame(RooFit.Title("Gaussian p.d.f. with Mjj"))
# data.plotOn( xframe2, RooLinkedList() )
# data.plotOn( xframe2 )
data.plotOn( xframe2 )
gauss.plotOn( xframe2)
# Fit PDF to toy
mean.setConstant( kFALSE )
sigma.setConstant( kFALSE )
gauss.fitTo(data)
c1 = TCanvas("c1","Example",800,400)
c1.Divide(3)
c1.cd(1)
gPad.SetLeftMargin(0.15)
xframe.GetYaxis().SetTitleOffset(1.6)
xframe.Draw()
c1.cd(2)
gPad.SetLeftMargin(0.15)
xframe2.GetYaxis().SetTitleOffset(1.6)
xframe2.Draw()
c1.SaveAs('testMjj0.png')
# # Print final value of parameters
fout = TFile("output.root","recreate")
c1.Write()
fout.Close()
def fitPed(hist, ws, name='x'):
maxBin = hist.GetMaximumBin()
x = ws.var(name)
#rds = ds.reduce('{1}<{0:0.2f}'.format(hist.GetBinLowEdge(maxBin+2),name))
#rds.Print()
x.setRange('ped_fit', x.getMin(), hist.GetBinLowEdge(maxBin+3))
pedMean = RooRealVar('pedMean', 'mean_{ped}', hist.GetBinCenter(maxBin),
x.getMin(), x.getMax())
pedMean.Print()
pedWidth = RooRealVar('pedWidth', 'sigma_{ped}', 1., 0., 10.)
pedWidth.Print()
ped = RooGaussian('ped', 'ped', x, pedMean, pedWidth)
pedMean.setConstant(False)
ped.fitTo(ws.data('ds'), RooFit.Minos(False), RooFit.Range('ped_fit'),
RooFit.PrintLevel(0))
getattr(ws, 'import')(ped)
def saveLandauHistoSignalToNoise(histo,outfile,canvas,XaxisTitle="",YaxisTitle="",plotTitle="",stats=0):
ex = "Null Fit"
signal_to_noise = RooRealVar("signal_to_noise", "Signal to Noise", 0, 50)
landau_data = RooDataHist("landau_data", "landau_data", RooArgList(signal_to_noise), histo)
ml = RooRealVar("ml","mean landau",25, 20, 26)
sl = RooRealVar("sl","sigma landau", 5, 2, 10)
landau = RooLandau("lx","lx",signal_to_noise,ml,sl)
mg = RooRealVar("mg","mg",0) ;
sg = RooRealVar("sg","sg", 2, 1, 8)
gauss = RooGaussian("gauss","gauss",signal_to_noise,mg,sg)
lxg = RooNumConvPdf("lxg", "lxg", signal_to_noise, landau, gauss)
result = lxg.fitTo(landau_data)
frame = signal_to_noise.frame()
landau_data.plotOn(frame)
lxg.plotOn(frame)
frame.Draw("")
frame.SetTitle(plotTitle)
frame.GetXaxis().SetTitle(XaxisTitle)
frame.GetYaxis().SetTitle(YaxisTitle)
frame.SetStats(stats)
frame.Write(plotTitle)
canvas.Print(outfile+".pdf")
peak = []
try:
mean = RooRealVar(result.floatParsFinal().find("landau_mean"))
err = RooRealVar(mean.errorVar())
peak.append(mean.GetVal())
peak.append(err.GetVal())
except Exception as ex:
print(ex)
peak.append(0)
peak.append(0)
return peak
def 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()
# Create pull distribution
#mcstudy = RooMCStudy(model, RooArgSet(x), RooFit.Binned(1), RooFit.Silence(),
# RooFit.Extended(),
# RooFit.FitOptions(RooFit.Save(1),
# RooFit.PrintEvalErrors(0),
# RooFit.Minos(0))
# )
#mcstudy.generateAndFit(500) # Generate and fit toy MC
#pull_dist = mcstudy.plotPull(nsig, -3.0, 3.0, 30, 1) # make pull distribution
pull_dist = None
return [nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError(), pull_dist]
def __init__( self, roovar, **kwargs ):
'''
To build the class, the variable to be blinded must be provided. In < scale >
one modifies the range of values for the blinded variable. Also the names for
the constant variable and the generated formula can be modified.
'''
name = roovar.GetName()
print 'Defining a new blinded variable for <', name, '>'
scale = kwargs.get( 'scale', 1000 )
eqname = kwargs.get( 'bvarname', name + '_BlindExpr' )
''' The seed is different for each call, which guarantees the blinding procedure '''
print 'Generating new set of random bounds'
rndm = TRandom3( 0 )
vmin = roovar.getMin()
boundlo = rndm.Uniform( vmin, vmin*scale )
vmax = roovar.getMax()
boundhi = rndm.Uniform( vmax, vmax*scale )
clonename = name + '_BLIND'
blindVar = RooRealVar( clonename, clonename, roovar.getVal(), boundlo, boundhi )
print 'Created clone variable named <', clonename, '>'
alpha = ( vmax - vmin )/( boundhi - boundlo )
beta = ( vmax*boundlo - vmin*boundhi )/( vmax - vmin )
blindVar.setVal( alpha*( roovar.getVal() - beta ) )
alpha = RooConstVar( 'alpha', 'alpha', alpha )
beta = RooConstVar( 'beta', 'beta', beta )
formula = 'alpha*( %s - beta)' % clonename
varlist = RooArgList( blindVar, alpha, beta )
blindEq = RooFormulaVar( eqname, eqname, formula, varlist )
print 'The blinding formula is:', formula
self.Alpha = alpha
self.Beta = beta
self.BlindEq = blindEq
self.BlindVar = blindVar
def test_plot():
c = TCanvas('c', 'canvas', 300, 300)
x = RooRealVar("x","x",-10,10)
mean = RooRealVar("mean","mean of gaussian",1,-10,10)
sigma = RooRealVar("sigma","width of gaussian",1,0.1,10)
gauss = RooGaussian("gauss","gaussian PDF",x,mean,sigma)
xframe = x.frame(RooFit.Title("Gaussian p.d.f."))
#gauss.plotOn(xframe)
sigma.setVal(3)
as_x = RooArgSet(x)
data = gauss.generate(as_x,10000)
data.plotOn(xframe, RooFit.MarkerSize(0.6), RooFit.MarkerStyle(20))
xframe.Draw()
pdffile = 'test.pdf'
c.SaveAs(pdffile)
def __init__(self, file_names, br_name="mass"):
self.file_names = file_names
self.br_name = br_name
min_x = 8
max_x = 12
self.obs = RooRealVar("obs", "m4l", min_x, max_x)
self.nbins = int((max_x - min_x) * 20)
self.obs.setBin(self.nbins)
# self.ws = ROOT.RooWorkspace("combined", "combined")
self.obs.setRange("fit", 8.5, 11.5)
self.dummy_hists = []
self.chi2_cut = 10000
def dump_simple():
# try poisson
roo_lam = RooRealVar("lambda", ".", lam, 0.0, 1.5)
roo_x = RooRealVar('x', 'x range', 0, bins)
model = RooPoisson("poisson", "Poisson Model", roo_x, roo_lam)
#data = model.generate(RooArgSet(roo_x), n_events)
data = RooDataSet('data', 'Data', RooArgSet(roo_x))
for val in unbinned_from_binned(xdata, ydata):
roo_x.setVal(val)
data.add(RooArgSet(roo_x))
#// --- 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 = roo_x.frame(bins) ;
data.plotOn(mesframe) ;
model.plotOn(mesframe) ;
mesframe.Draw()
def getTrueOmegasPerCat(config, mistagobs, mistag, mistagpdf):
"""
estimate the per-category mistag (omega_i) as starting value for the fit
calculate true per-category omegas based on the mistagpdf and the
calibration that goes into the generation pdf
config -- config dictionary
mistagobs -- mistag observable (eta)
mistag -- calibrated mistag (omega(eta))
mistagpdf -- mistag pdf (P(eta))
returns a pair of average mistag omega, list of per-category mistag
(omega) averages
relevant config dictionary keys:
'MistagCategoryBinBounds':
list of mistag category bin bounds (one more entry than mistag
categories)
"""
from ROOT import RooRealVar, RooCustomizer, RooProduct, RooArgList, RooArgSet
eta1 = RooRealVar('eta1', 'eta1', mistagobs.getMin(),
mistagobs.getMin(), mistagobs.getMax())
eta2 = RooRealVar('eta2', 'eta2', mistagobs.getMax(),
mistagobs.getMin(), mistagobs.getMax())
prod = RooProduct('prod', 'prod', RooArgList(mistag, mistagpdf))
oldmistagobs = mistagobs
mistagobs = mistagobs.clone(mistagobs.GetName() + '_catclone')
ROOT.SetOwnership(mistagobs, True)
mistagobs.setRange(eta1, eta2)
c = RooCustomizer(prod, 'cust')
c.replaceArg(oldmistagobs, mistagobs)
prod = c.build()
ROOT.SetOwnership(prod, True)
c = RooCustomizer(mistagpdf, 'cust2')
c.replaceArg(oldmistagobs, mistagobs)
pdf = c.build()
ROOT.SetOwnership(pdf, True)
if pdf.InheritsFrom('RooHistPdf'): pdf.forceNumInt()
evnumer = prod.createIntegral(RooArgSet(mistagobs))
evdenom = pdf.createIntegral(RooArgSet(mistagobs))
totevdenom = evdenom.getVal()
avomega = evnumer.getVal() / totevdenom
omegas = [ ]
for i in xrange(0, len(config['MistagCategoryBinBounds']) - 1):
eta1.setVal(config['MistagCategoryBinBounds'][i])
eta2.setVal(config['MistagCategoryBinBounds'][i + 1])
omegas.append(evnumer.getVal() / evdenom.getVal())
print 'INFO: Mistag calibration %s:' % mistag.GetName()
print 'INFO: Average omega (PDF): %g' % avomega
print 'INFO: Per category average omegas (PDF): %s' % str(omegas)
return avomega, omegas
def roofit_poisson_unbinned(data):
"""returns lambda, error of lambda"""
x = RooRealVar('x', 'x', 0, max(data) * 10)
lam = RooRealVar('lambda', 'lambda', 0.1, 0.000001, max(data))
model = RooPoisson('model', 'model', x, lam)
dataset = RooDataSet('data', 'data', RooArgSet(x))
for val in data:
x.setVal(val)
dataset.add(RooArgSet(x))
model.fitTo(dataset, RooFit.Save(), RooFit.PrintLevel(-1))
return lam.getVal(), lam.getError()
def __init__(self, file_name, br_name="mass"):
self.file_name = file_name
self.br_name = br_name
min_x = 8
max_x = 12
self.obs = RooRealVar("obs", "m4l", min_x, max_x)
self.nbins = int((max_x - min_x) * 20)
self.obs.setBin(self.nbins)
#self.ws = ROOT.RooWorkspace("combined", "combined")
self.dummy_hists = []
self.chi2_cut = 10000
# dionia selection or onia selection
self.dionia_selection = False
# with 3mu4 trigger or not
self.with_3mu4 = True
# only unprescaled runs
self.only_unprescaled = True
# different onia_pt cuts, 0:noCut, 1:<5, 2:5-10, 3:10,20, 4:>20
self.onia_pt_cut = 0
self.onia_pt_cuts = [0, 5, 10, 20]
#self.onia_pt_cuts = [0, 10, 20]
# different muon pT cuts
# suggested by Terry to look at onia mass that have one muon with pT (3, 4) GeV.
self.use_low_pt_muon = False
# it is found that these low pT muons contributes a lot the background 40%
# while only gain 15% signal
self.no_low_pt = False
# if build new model
self.new_model = False
self.model_name = "model"
# workspace components
self.data = None
self.model = None
RooMsgService.instance().setSilentMode(ROOT.kTRUE)
RooMsgService.instance().setStreamStatus(0,ROOT.kFALSE)
RooMsgService.instance().setStreamStatus(1,ROOT.kFALSE)
filename = [
'Histo_TT.root',
'Histo_JetHT.root'
]
norm = []
nevents = []
histo = []
roohisto = []
histoCtl = []
roohistoCtl = []
# define observable
x = RooRealVar('mTop','mTop',xmin,xmax)
for ff in filename:
inf = TFile.Open(ff)
h = inf.Get('hadtopBoost/h_jetMassSoftDrop0_Cut_sig')
norm.append((inf.Get('hadtopBoost/TriggerPass')).GetBinContent(1))
nevents.append(h.Integral())
print h.GetName()
h.Rebin(rebin)
hCtl = inf.Get('hadtopBoost/h_jetMassSoftDrop0_Cut_ctl')
print hCtl.GetName()
hCtl.Rebin(rebin)
histo.append(h)
histoCtl.append(hCtl)
rooh = RooDataHist('roohist','roohist',RooArgList(x),h)
roohisto.append(rooh)
def studyVqqResolution(rootFile):
#get all from file
histos={}
inF=TFile.Open(rootFile)
keys=inF.GetListOfKeys()
for k in keys:
obj=inF.Get(k.GetName())
obj.SetDirectory(0)
histos[k.GetName()]=obj
inF.Close()
#plot
gROOT.SetBatch()
gROOT.SetStyle('Plain')
gStyle.SetOptStat(0)
gStyle.SetOptFit(1111)
gStyle.SetOptTitle(0)
gStyle.SetStatFont(42)
kin=['','30to40','40to50','50to75','75to100','100toInf']
for k in kin:
c=TCanvas('c','c',600,600)
c.cd()
c.SetCanvasSize(1000,500)
c.SetWindowSize(1000,500)
c.Divide(2,1)
c.cd(1)
histos['deta'+k+'barrel'].SetLineWidth(2)
histos['deta'+k+'barrel'].SetTitle('barrel')
histos['deta'+k+'barrel'].Draw('hist')
histos['deta'+k+'endcap'].SetLineWidth(2)
histos['deta'+k+'endcap'].SetLineStyle(7)
histos['deta'+k+'endcap'].SetTitle('endcap')
histos['deta'+k+'endcap'].Draw('histsame')
leg=TLegend(0.6,0.92,0.9,0.98)
leg.SetFillStyle(0)
leg.SetBorderSize(0)
leg.SetTextFont(42)
leg.AddEntry(histos['deta'+k+'barrel'],'barrel','f')
leg.AddEntry(histos['deta'+k+'endcap'],'endcap','f')
leg.SetNColumns(2)
leg.Draw()
drawHeader()
c.cd(2)
histos['dphi'+k+'barrel'].SetLineWidth(2)
histos['dphi'+k+'barrel'].SetTitle('barrel')
histos['dphi'+k+'barrel'].Draw('hist')
histos['dphi'+k+'endcap'].SetLineWidth(2)
histos['dphi'+k+'endcap'].SetLineStyle(7)
histos['dphi'+k+'endcap'].SetTitle('endcap')
histos['dphi'+k+'endcap'].Draw('histsame')
c.Modified()
c.Update()
c.SaveAs('dr_%s.png'%k)
labels=[]
responseVars=['dpt','den','dphi','deta','dr']
for r in responseVars:
barrelResponse=TGraphErrors()
barrelResponse.SetName(r+'barrelresponse')
barrelResponse.SetLineWidth(2)
barrelResponse.SetFillStyle(0)
barrelResponse.SetMarkerStyle(20)
barrelCoreResponse=barrelResponse.Clone(r+'barrelcoreresponse')
endcapResponse=TGraphErrors()
endcapResponse.SetName(r+'endcapresponse')
endcapResponse.SetLineWidth(2)
endcapResponse.SetFillStyle(0)
endcapResponse.SetMarkerStyle(24)
endcapCoreResponse=endcapResponse.Clone(r+'endcapresponse')
for k in kin:
c.cd()
c.Clear()
c.SetWindowSize(1000,500)
c.Divide(2,1)
for i in [1,2] :
c.cd(i)
reg='barrel'
if i==2: reg='endcap'
h=histos[r+k+reg]
x=RooRealVar("x", h.GetXaxis().GetTitle(), h.GetXaxis().GetXmin(), h.GetXaxis().GetXmax())
data=RooDataHist("data", "dataset with x", RooArgList(x), h)
frame=x.frame()
RooAbsData.plotOn( data, frame, RooFit.DataError(RooAbsData.SumW2) )
mean1=RooRealVar("mean1","mean1",0,-0.5,0.5);
sigma1=RooRealVar("sigma1","sigma1",0.1,0.01,1.0);
gauss1=RooGaussian("g1","g",x,mean1,sigma1)
if r=='dpt' or r=='den' :
mean2=RooRealVar("mean2","mean2",0,-0.5,0.5);
sigma2=RooRealVar("sigma2","sigma2",0.1,0.01,1.0);
alphacb=RooRealVar("alphacb","alphacb",1,0.1,3);
ncb=RooRealVar("ncb","ncb",4,1,100)
gauss2 = RooCBShape("cb2","cb",x,mean2,sigma2,alphacb,ncb);
else:
mean1.setRange(0,0.5)
mean2=RooRealVar("mean2","mean",0,0,1);
sigma2=RooRealVar("sigma2","sigma",0.1,0.01,1.0);
gauss2=RooGaussian("g2","g",x,mean2,sigma2) ;
frac = RooRealVar("frac","fraction",0.9,0.0,1.0)
if data.sumEntries()<100 :
frac.setVal(1.0)
frac.setConstant(True)
model = RooAddPdf("sum","g1+g2",RooArgList(gauss1,gauss2), RooArgList(frac))
status=model.fitTo(data,RooFit.Save()).status()
if status!=0 : continue
model_cdf=model.createCdf(RooArgSet(x)) ;
cl=0.90
ul=0.5*(1.0+cl)
closestToCL=1.0
closestToUL=-1
closestToMedianCL=1.0
closestToMedian=-1
for ibin in xrange(1,h.GetXaxis().GetNbins()*10):
xval=h.GetXaxis().GetXmin()+(ibin-1)*h.GetXaxis().GetBinWidth(ibin)/10.
x.setVal(xval)
cdfValToCL=math.fabs(model_cdf.getVal()-ul)
if cdfValToCL<closestToCL:
closestToCL=cdfValToCL
closestToUL=xval
cdfValToCL=math.fabs(model_cdf.getVal()-0.5)
if cdfValToCL<closestToMedianCL:
closestToMedianCL=cdfValToCL
closestToMedian=xval
RooAbsPdf.plotOn(model,frame)
frame.Draw()
if i==1: drawHeader()
labels.append( TPaveText(0.6,0.92,0.9,0.98,'brNDC') )
ilab=len(labels)-1
labels[ilab].SetName(r+k+'txt')
labels[ilab].SetBorderSize(0)
labels[ilab].SetFillStyle(0)
labels[ilab].SetTextFont(42)
labels[ilab].SetTextAlign(12)
kinReg=k.replace('to','-')
kinReg=kinReg.replace('Inf','#infty')
labels[ilab].AddText('['+reg+'] '+kinReg)
labels[ilab].Draw()
resolutionVal=math.fabs(closestToUL-closestToMedian)
responseGr=barrelResponse
responseCoreGr=barrelCoreResponse
coreResolutionVal=sigma1.getVal()
coreResolutionErr=sigma1.getError()
if frac.getVal()<0.7 and (sigma2.getVal()<sigma1.getVal()) :
coreResolutionVal=sigma2.getVal()
coreResolutionErr=sigma2.getError()
if i==2 :
responseGr=endcapResponse
responseCoreGr=endcapCoreResponse
if k!='' :
nrespPts=responseGr.GetN()
kinAvg=150
kinWidth=50
if k=='30to40' :
kinAvg=35
kinWidth=5
if k=='40to50' :
kinAvg=45
kinWidth=5
if k=='50to75' :
kinAvg=62.5
kinWidth=12.5
elif k=='75to100' :
kinAvg=87.5
kinWidth=12.5
responseGr.SetPoint(nrespPts,kinAvg,resolutionVal)
responseCoreGr.SetPoint(nrespPts,kinAvg,coreResolutionVal)
responseCoreGr.SetPointError(nrespPts,kinWidth,coreResolutionErr)
labels.append( TPaveText(0.15,0.7,0.4,0.9,'brNDC') )
ilab=len(labels)-1
labels[ilab].SetName(r+k+'fitrestxt')
labels[ilab].SetBorderSize(0)
labels[ilab].SetFillStyle(0)
labels[ilab].SetTextFont(42)
labels[ilab].SetTextAlign(12)
labels[ilab].AddText('Gaussian #1 (f=%3.3f)'%frac.getVal())
labels[ilab].AddText('#mu=%3.3f#pm%3.3f'%(mean1.getVal(),mean1.getError()))
labels[ilab].AddText('#sigma=%3.3f#pm%3.3f'%(sigma1.getVal(),sigma1.getError()))
labels[ilab].AddText('Gaussian #2 (f=%3.3f)'%(1-frac.getVal()))
labels[ilab].AddText('#mu=%3.3f#pm%3.3f'%(mean2.getVal(),mean2.getError()))
labels[ilab].AddText('#sigma=%3.3f#pm%3.3f'%(sigma2.getVal(),sigma2.getError()))
labels[ilab].Draw()
c.Modified()
c.Update()
c.SaveAs(r+'res_'+k+'.png')
frame=TGraphErrors()
frame.SetPoint(0,0,0)
frame.SetPoint(1,200,0.3)
frame.SetMarkerStyle(1)
frame.SetFillStyle(0)
frame.SetName('frame')
cresp=TCanvas('cresp','cresp',500,500)
cresp.cd()
frame.Draw('ap')
barrelResponse.Draw('pl')
endcapResponse.Draw('pl')
frame.GetXaxis().SetTitle("Quark transverse momentum [GeV]")
frame.GetYaxis().SetTitle("Resolution %3.2f C.L."%cl )
frame.GetYaxis().SetTitleOffset(1.4)
frame.GetYaxis().SetNdivisions(10)
drawHeader()
leg=TLegend(0.6,0.92,0.9,0.98)
leg.SetFillStyle(0)
leg.SetBorderSize(0)
leg.SetTextFont(42)
leg.AddEntry(barrelResponse,'barrel','fp')
leg.AddEntry(endcapResponse,'endcap','fp')
leg.SetNColumns(2)
leg.Draw()
cresp.Modified()
cresp.Update()
cresp.SaveAs(r+'res_evol.png')
frameCore=frame.Clone('framecore')
cresp.Clear()
frameCore.Draw('ap')
barrelCoreResponse.Draw('pl')
endcapCoreResponse.Draw('pl')
frameCore.GetXaxis().SetTitle("Quark transverse momentum [GeV]")
frameCore.GetYaxis().SetTitle("Core resolution")
frameCore.GetYaxis().SetTitleOffset(1.4)
frameCore.GetYaxis().SetNdivisions(10)
frameCore.GetYaxis().SetRangeUser(0,0.2)
drawHeader()
leg=TLegend(0.6,0.92,0.9,0.98)
leg.SetFillStyle(0)
leg.SetBorderSize(0)
leg.SetTextFont(42)
leg.AddEntry(barrelCoreResponse,'barrel','fp')
leg.AddEntry(endcapCoreResponse,'endcap','fp')
leg.SetNColumns(2)
leg.Draw()
cresp.Modified()
cresp.Update()
cresp.SaveAs(r+'rescore_evol.png')
bosons=['h','z','w']
kin=['','50','100']
region=['','bb','eb','ee']
for k in kin:
for r in region:
c=TCanvas('c','c',600,600)
c.cd()
histos['mjj'+k+r].Rebin()
histos['mjj'+k+r].Draw()
ic=1
leg=TLegend(0.6,0.92,0.9,0.98)
leg.SetFillStyle(0)
leg.SetBorderSize(0)
leg.SetTextFont(42)
leg.AddEntry(histos['mjj'+k+r],'inclusive','f')
for b in bosons:
if histos[b+'mjj'+k+r].Integral()<=0 : continue
ic=ic+1
histos[b+'mjj'+k+r].Rebin()
histos[b+'mjj'+k+r].SetLineColor(ic)
histos[b+'mjj'+k+r].SetLineWidth(2)
histos[b+'mjj'+k+r].SetMarkerColor(ic)
histos[b+'mjj'+k+r].SetMarkerStyle(1)
histos[b+'mjj'+k+r].SetFillStyle(3000+ic)
histos[b+'mjj'+k+r].SetFillColor(ic)
histos[b+'mjj'+k+r].Draw('histsame')
leg.AddEntry(histos[b+'mjj'+k+r],b,"f")
leg.SetNColumns(ic)
leg.Draw()
drawHeader()
labels.append( TPaveText(0.65,0.8,0.9,0.9,'brNDC') )
ilab=len(labels)-1
labels[ilab].SetName(k+r+'mjj')
labels[ilab].SetBorderSize(0)
labels[ilab].SetFillStyle(0)
labels[ilab].SetTextFont(42)
labels[ilab].SetTextAlign(12)
regionTitle="inclusive"
if r == 'bb' : regionTitle='barrel-barrel'
if r == 'eb' : regionTitle='endcap-barrel'
if r == 'ee' : regionTitle='endcap-endcap'
labels[ilab].AddText(regionTitle)
ptthreshold=30
if k!='' : ptthreshold=float(k)
labels[ilab].AddText('p_{T}>%3.0f GeV'%ptthreshold)
labels[ilab].Draw()
c.Modified()
c.Update()
c.SaveAs('mjj'+k+r+'.png')
massResolutionGrs=[]
for r in region:
massResolution=TGraphErrors()
massResolution.SetName(r+'dm')
massResolution.SetLineWidth(2)
massResolution.SetFillStyle(0)
massResolution.SetMarkerStyle(20+len(massResolutionGrs))
massResolution.SetMarkerColor(1+len(massResolutionGrs))
massResolution.SetLineColor(1+len(massResolutionGrs))
massResolution.SetFillColor(1+len(massResolutionGrs))
massResolutionGrs.append(massResolution)
for k in kin:
c=TCanvas('c','c',600,600)
c.cd()
h=histos['dmjj'+k+r]
x=RooRealVar("x", h.GetXaxis().GetTitle(), h.GetXaxis().GetXmin(), h.GetXaxis().GetXmax())
data=RooDataHist("data", "dataset with x", RooArgList(x), h)
frame=x.frame()
RooAbsData.plotOn( data, frame, RooFit.DataError(RooAbsData.SumW2) )
mean1=RooRealVar("mean1","mean1",0,-0.5,0.5);
sigma1=RooRealVar("sigma1","sigma1",0.1,0.01,1.0);
gauss1=RooGaussian("g1","g",x,mean1,sigma1)
mean2=RooRealVar("mean2","mean2",0,-0.5,0.5);
sigma2=RooRealVar("sigma2","sigma2",0.1,0.01,1.0);
alphacb=RooRealVar("alphacb","alphacb",1,0.1,3);
ncb=RooRealVar("ncb","ncb",4,1,100)
gauss2 = RooCBShape("cb2","cb",x,mean2,sigma2,alphacb,ncb);
frac = RooRealVar("frac","fraction",0.9,0.0,1.0)
model = RooAddPdf("sum","g1+g2",RooArgList(gauss1,gauss2), RooArgList(frac))
status=model.fitTo(data,RooFit.Save()).status()
if status!=0 : continue
RooAbsPdf.plotOn(model,frame)
frame.Draw()
labels.append( TPaveText(0.6,0.65,0.85,0.9,'brNDC') )
ilab=len(labels)-1
labels[ilab].SetName(r+k+'dmfitrestxt')
labels[ilab].SetBorderSize(0)
labels[ilab].SetFillStyle(0)
labels[ilab].SetTextFont(42)
labels[ilab].SetTextAlign(12)
labels[ilab].AddText('Gaussian #1 (f=%3.3f)'%frac.getVal())
labels[ilab].AddText('#mu=%3.3f#pm%3.3f'%(mean1.getVal(),mean1.getError()))
labels[ilab].AddText('#sigma=%3.3f#pm%3.3f'%(sigma1.getVal(),sigma1.getError()))
labels[ilab].AddText('Gaussian #2 (f=%3.3f)'%(1-frac.getVal()))
labels[ilab].AddText('#mu=%3.3f#pm%3.3f'%(mean2.getVal(),mean2.getError()))
labels[ilab].AddText('#sigma=%3.3f#pm%3.3f'%(sigma2.getVal(),sigma2.getError()))
labels[ilab].Draw()
drawHeader()
labels.append( TPaveText(0.15,0.8,0.4,0.9,'brNDC') )
ilab=len(labels)-1
labels[ilab].SetName(k+r+'dmjj')
labels[ilab].SetBorderSize(0)
labels[ilab].SetFillStyle(0)
labels[ilab].SetTextFont(42)
labels[ilab].SetTextAlign(12)
regionTitle="inclusive"
if r == 'bb' : regionTitle='barrel-barrel'
if r == 'eb' : regionTitle='endcap-barrel'
if r == 'ee' : regionTitle='endcap-endcap'
labels[ilab].AddText(regionTitle)
ptthreshold=30
if k!='' : ptthreshold=float(k)
labels[ilab].AddText('p_{T}>%3.0f GeV'%ptthreshold)
labels[ilab].Draw()
c.Modified()
c.Update()
c.SaveAs('dmjj'+k+r+'.png')
massResolution.SetTitle(regionTitle)
ip=massResolution.GetN()
x=40
xerr=10
if k=='50' :
x=75
xerr=25
elif k=='100':
x=150
xerr=50
y=sigma1.getVal()
yerr=sigma1.getError()
if frac.getVal()<0.8:
if sigma2.getVal()<sigma1.getVal():
y=sigma2.getVal()
ey=sigma2.getError()
massResolution.SetPoint(ip,x,y)
massResolution.SetPointError(ip,xerr,yerr)
frame=TGraphErrors()
frame.SetPoint(0,0,0)
frame.SetPoint(1,200,0.2)
frame.SetMarkerStyle(1)
frame.SetFillStyle(0)
frame.SetName('dmframe')
cdmevol=TCanvas('cdmevol','cdmevol',500,500)
cdmevol.cd()
frame.Draw('ap')
leg=TLegend(0.6,0.92,0.9,0.98)
leg.SetFillStyle(0)
leg.SetBorderSize(0)
leg.SetTextFont(42)
for dmGr in massResolutionGrs :
dmGr.Draw('pl')
leg.AddEntry(dmGr,dmGr.GetTitle(),'fp')
frame.GetXaxis().SetTitle("Leading quark transverse momentum [GeV]")
frame.GetYaxis().SetTitle("Core resolution")
frame.GetYaxis().SetTitleOffset(1.4)
frame.GetYaxis().SetNdivisions(10)
drawHeader()
leg.SetNColumns(2)
leg.Draw()
cdmevol.Modified()
cdmevol.Update()
cdmevol.SaveAs('dm_evol.png')
c=TCanvas('c','c',600,600)
c.cd()
histos['sel'].Draw('histtext')
drawHeader()
c.Modified()
c.Update()
c.SaveAs('selection.png')
return
)
sig_par = sig_parameters.createIterator()
sig_par.Reset()
sig_param = sig_par.Next()
while sig_param:
sig_param.Print()
if TString(sig_param.GetName()).Contains(
"rrv_mean_CB_ggH"
): ## copy the mean value for the DoubleCB and BW
rrv_mean_CB = sig_param
elif TString(sig_param.GetName()).Contains("rrv_sigma_CB_ggH"):
rrv_sigma_CB = RooRealVar(
"rrv_sigma_CB_ggH%s_signal_region_em_mlvj" % (mass),
"rrv_sigma_CB_ggH%s_signal_region_em_mlvj" % (mass),
sig_param.getVal() * options.narrow_factor,
)
rrv_sigma_CB.setError(sig_param.getError() * options.narrow_factor)
# rrv_sigma_CB = sig_param;
# rrv_sigma_CB.setVal(sig_param.getVal()*options.narrow_factor);
elif TString(sig_param.GetName()).Contains("rrv_alpha_CB_ggH"):
rrv_alpha_CB = sig_param
elif TString(sig_param.GetName()).Contains("rrv_n_CB_ggH"):
rrv_n_CB = sig_param
sig_param = sig_par.Next()
## cycle on DoubleCB parameters -> copy them in a new set
sig_parameters2 = RooDoubleCrystalBall2.getParameters(
old_workspace.data(datasetname + "_" + options.channel)
#from ROOT import *
import optparse
usage = "usage: %prog [options]"
parser = optparse.OptionParser(usage)
parser.add_option("-b", "--bash", action="store_true", default=False, dest="bash")
(options, args) = parser.parse_args()
if options.bash: gROOT.SetBatch(True)
# -------------------------------------------
# 1. gau1 generate toy MC, use gau2 to fit
x = RooRealVar("x","x",-10,10)
xframe1 = x.frame(RooFit.Title("1. use gauss1 generate toy MC, use gauss2 to fit"))
# -------------------------------------------
# 10. use Gaussian to test RooMCStudy
# --------------------
def RooMCStudy_box( mgr1 , list_par ):
print ""
print "RooMCStudy_box"
print ""
sys.exit(-2)
elif args[0] not in input_data:
print parser.print_usage()
sys.exit(-2)
from P2VV.Load import LHCbStyle
from P2VV.RooFitWrappers import *
from ROOT import RooRealVar
from ROOT import RooDataSet
from ROOT import RooArgSet
from ROOT import RooCategory
input_data = input_data[args[0]]
weight = RooRealVar('sWeights_ipatia', 'sWeights_ipatia', -1e3, 1e3)
momentum = RooRealVar('B_P', 'B_P', 0, 1e6, 'MeV')
runPeriod = RooCategory('runPeriod', 'runPeriod')
runPeriod.defineType('p2011', 2011)
runPeriod.defineType('p2012', 2012)
from ROOT import TFile
if args[0].startswith('MC'):
from ROOT import TFile
sig_file = TFile(input_data['sig_cache'])
sig_data = sig_file.Get(input_data['sig_dataset'])
prompt_file = TFile(input_data['prompt_cache'])
prompt_data = prompt_file.Get(input_data['prompt_dataset'])
else:
sig_file = TFile("/project/bfys/jleerdam/data/Bs2Jpsiphi/Reco14/fitNTuple_peakBkg_2011_2012_Reco14_TOS_HLT2B_20140415.root")
sig_tree = sig_file.Get("DecayTree")
period = 'p' + args[0][:4]
pi0mass = 134.9766
jpsimass = 3096.916
f = TFile.Open("root://hepgrid11.ph.liv.ac.uk///dpm/ph.liv.ac.uk/home/lhcb/eflow/Pi0Efficiency.CL16.MD.Turbo03LEPTONS.0.170412.00.root")
t = f.Get("data")
g = TFile.Open("root://hepgrid11.ph.liv.ac.uk///dpm/ph.liv.ac.uk/home/lhcb/eflow/Pi0Efficiency.CL16.MU.Turbo03LEPTONS.0.170412.00.root")
u = g.Get("data")
t.SetBranchStatus("ez*",0)
hist = TH1F("h", "h", 100, 5200, 5400)
hist2 = TH1F("h2", "h2", 100, 5000, 5700)
kstmass = TH1F("kst", "kst", 100, 700, 1100)
gamma_pt = TH1F("gamma_pt", "gamma_pt", 100, 0, 2000)
m = RooRealVar("m", "m", 5200, 5400)
argset = RooArgSet(m)
m2 = RooRealVar("m2", "m2", 5000, 5600)
g1pt = RooRealVar("gamma1_pt", "gamma1_pt", 0, 20000)
g2pt = RooRealVar("gamma2_pt", "gamma2_pt", 0, 20000)
argset2 = RooArgSet(m2, g1pt, g2pt)
ds = RooDataSet("ds", "ds", argset)
ds2 = RooDataSet("ds2", "ds2", argset2)
counters = [0, 0, 0, 0, 0, 0]
counters2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
for aa in [t,u]:
aa.SetBranchStatus("bp1*",0)
#! /bin/env python
import os
import sys
import ROOT
from ROOT import RooRealVar, RooGaussian, RooArgList
from ROOT import RooVoigtian, RooCBShape, RooArgusBG, RooDecay
from ROOT import RooGaussModel, RooFormulaVar, TCanvas
from ROOT import RooFFTConvPdf, RooNumConvPdf, gPad, RooBreitWigner
from ROOT import RooGenericPdf, TChain, RooDataSet, RooArgSet, RooFit, RooHistPdf
# Measured variable
x = RooRealVar( 'mass', 'mass', 4000, 7000 )
# Parameters
mean = RooRealVar( 'mean', 'mean of gaussian', 0.0 )
sigma = RooRealVar( 'sigma', 'width of gaussian', 5.0 )
# Load reference ROOT tree
full_ch = TChain("DecayTree")
full_ch.Add("/mnt/home/kklimaszewski/LHCb/Bs2JpsieePhi/M_Bs_Fits/mc/DVNtuples_Bs2JpsieePhi_13154001_MCfull_R14ac_TupleBsDetached_PIDCorr_S21_NewSel_tupleB.root")
# Run selection
ch = full_ch.CopyTree("sigmam>0. && sigmam<250. && time>0.3 && time<14. && sigmat<0.12 && BDT_response_NewSel>0.2 && eminus_bremmult==0 && eplus_bremmult==0")
#fit.mass.setBins(_comp['config']['bins'])
# Create hist PDF
data = RooDataSet(
'data_set',
'',
RooArgSet(x),
def buildDataAndCategories(ws,options,args):
#Get the input data
inputData = TChain(options.treeName,'The input data')
for arg in args:
print 'Adding data from: ',arg
inputData.Add(arg)
foldname = ''
phirange = [0,90]
if not options.folded:
foldname=''
phirange = [-180,180]
#variables necessary for j/psi mass,lifetime,polarization fit
jPsiMass = RooRealVar('JpsiMass','M [GeV]',2.7,3.5)
jPsiRap = RooRealVar('JpsiRap','#nu',-2.3,2.3)
jPsiPt = RooRealVar("JpsiPt","pT [GeV]",0,40);
jPsicTau = RooRealVar('Jpsict','l_{J/#psi} [mm]',-1,2.5)
jPsicTauError = RooRealVar('JpsictErr','Error on l_{J/#psi} [mm]',0,2)
jPsiVprob = RooRealVar('JpsiVprob','',.01,1)
jPsiHXcosth = None
jPsiHXphi = None
jPsicTau.setBins(10000,"cache")
if options.fitFrame is not None:
jPsiHXcosth = RooRealVar('costh_'+options.fitFrame+foldname,'cos(#theta)_{'+options.fitFrame+'}',-1,1)
jPsiHXphi = RooRealVar('phi_'+options.fitFrame+foldname,'#phi_{'+options.fitFrame+'}',phirange[0],phirange[1])
else:
jPsiHXcosth = RooRealVar('costh_CS'+foldname,'cos(#theta)_{CS}',-1,1)
jPsiHXphi = RooRealVar('phi_CS'+foldname,'#phi_{CS}',phirange[0],phirange[1])
#vars needed for on the fly calc of polarization variables
jPsimuPosPx = RooRealVar('muPosPx','+ Muon P_{x} [GeV]',0)
jPsimuPosPy = RooRealVar('muPosPy','+ Muon P_{y} [GeV]',0)
jPsimuPosPz = RooRealVar('muPosPz','+ Muon P_{z} [GeV]',0)
jPsimuNegPx = RooRealVar('muNegPx','- Muon P_{x} [GeV]',0)
jPsimuNegPy = RooRealVar('muNegPy','- Muon P_{y} [GeV]',0)
jPsimuNegPz = RooRealVar('muNegPz','- Muon P_{z} [GeV]',0)
#create RooArgSet for eventual dataset creation
dataVars = RooArgSet(jPsiMass,jPsiRap,jPsiPt,
jPsicTau,jPsicTauError,
jPsimuPosPx,jPsimuPosPy,jPsimuPosPz)
#add trigger requirement if specified
if options.triggerName:
trigger = RooRealVar(options.triggerName,'Passes Trigger',0.5,1.5)
dataVars.add(trigger)
dataVars.add(jPsiVprob)
dataVars.add(jPsimuNegPx)
dataVars.add(jPsimuNegPy)
dataVars.add(jPsimuNegPz)
dataVars.add(jPsiHXcosth)
dataVars.add(jPsiHXphi)
redVars = RooArgSet(jPsiMass,jPsiRap,jPsiPt,
jPsicTau,jPsicTauError)
redVars.add(jPsiHXcosth)
redVars.add(jPsiHXphi)
fitVars = redVars.Clone()
### HERE IS WHERE THE BIT FOR CALCULATING POLARIZATION VARS GOES
ctauStates = RooCategory('ctauRegion','Cut Region in lifetime')
ctauStates.defineType('prompt',0)
ctauStates.defineType('nonPrompt',1)
massStates = RooCategory('massRegion','Cut Region in mass')
massStates.defineType('signal',1)
massStates.defineType('separation',0)
massStates.defineType('leftMassSideBand',-2)
massStates.defineType('rightMassSideBand',-1)
states = RooCategory('mlRegion','Cut Region in mass')
states.defineType('nonPromptSignal',2)
states.defineType('promptSignal',1)
states.defineType('separation',0)
states.defineType('leftMassSideBand',-2)
states.defineType('rightMassSideBand',-1)
#define corresponding ranges in roorealvars
#mass is a little tricky since the sidebands change definitions in each rap bin
#define the names here and change as we do the fits
#jPsiMass.setRange('NormalizationRangeFormlfit_promptSignal',2.7,3.5)
#jPsiMass.setRange('NormalizationRangeFormlfit_nonPromptSignal',2.7,3.5)
#jPsiMass.setRange('NormalizationRangeFormlfit_leftMassSideBand',2.7,3.1)
#jPsiMass.setRange('NormalizationRangeFormlfit_rightMassSideBand',3.1,3.5)
#want the prompt fit only done in prompt region
#non-prompt only in non-prompt region
#background over entire cTau range
#jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1)
#jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5)
#jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5)
#jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5)
#redVars.add(ctauStates)
#redVars.add(massStates)
#redVars.add(states)
fitVars.add(ctauStates)
fitVars.add(massStates)
fitVars.add(states)
fullData = RooDataSet('fullData','The Full Data From the Input ROOT Trees',
dataVars,
ROOT.RooFit.Import(inputData))
for rap_bin in range(1,len(jpsi.pTRange)):
yMin = jpsi.rapForPTRange[rap_bin-1][0]
yMax = jpsi.rapForPTRange[rap_bin-1][-1]
for pt_bin in range(len(jpsi.pTRange[rap_bin])):
ptMin = jpsi.pTRange[rap_bin][pt_bin][0]
ptMax = jpsi.pTRange[rap_bin][pt_bin][-1]
sigMaxMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin]
sigMinMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin]
sbHighMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigBkgHigh*jpsi.sigmaMassJpsi[rap_bin]
sbLowMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigBkgLow*jpsi.sigmaMassJpsi[rap_bin]
ctauNonPrompt = .1
massFun = RooFormulaVar('massRegion','Function that returns the mass state.',
'('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+str(sigMinMass)+
') - ('+jPsiMass.GetName()+' > '+str(sbHighMass)+')'+
'-2*('+jPsiMass.GetName()+' < '+str(sbLowMass)+')',
RooArgList(jPsiMass,jPsicTau))
ctauFun = RooFormulaVar('ctauRegion','Function that returns the ctau state.',
'('+jPsicTau.GetName()+' > '+str(ctauNonPrompt)+')',
RooArgList(jPsiMass,jPsicTau))
mlFun = RooFormulaVar('mlRegion','Function that returns the mass and lifetime state.',
'('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+str(sigMinMass)+
') + ('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+
str(sigMinMass)+' && '+jPsicTau.GetName()+' > '+str(ctauNonPrompt)+
') - ('+jPsiMass.GetName()+' > '+str(sbHighMass)+')'+
'-2*('+jPsiMass.GetName()+' < '+str(sbLowMass)+')',
RooArgList(jPsiMass,jPsicTau))
cutStringPt = '('+jPsiPt.GetName()+' > '+str(ptMin)+' && '+jPsiPt.GetName()+' < '+str(ptMax)+')'
cutStringY = '( abs('+jPsiRap.GetName()+') > '+str(yMin)+' && abs('+jPsiRap.GetName()+') < '+str(yMax)+')'
#cutStringM1 = '('+jPsiMass.GetName()+' < '+str(sigMinMass)+' && '+jPsiMass.GetName()+' > '+str(sbLowMass)+')'
#cutStringM2 = '('+jPsiMass.GetName()+' < '+str(sbHighMass)+' && '+jPsiMass.GetName()+' > '+str(sigMaxMass)+')'
#cutStringMT = '!('+cutStringM1+' || '+cutStringM2+')'
cutString = cutStringPt+' && '+cutStringY #+' && '+cutStringMT
print cutString
#get the reduced dataset we'll do the fit on
binData = fullData.reduce(ROOT.RooFit.SelectVars(redVars),
ROOT.RooFit.Cut(cutString),
ROOT.RooFit.Name('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)),
ROOT.RooFit.Title('Data For Fitting'))
binDataWithCategory = RooDataSet('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1),
'Data For Fitting',
fitVars)
#categorize
binData.addColumn(ctauStates)
binData.addColumn(massStates)
binData.addColumn(states)
for ev in range(binData.numEntries()):
args = binData.get(ev)
jPsiMass.setVal(args.find(jPsiMass.GetName()).getVal())
jPsiRap.setVal(args.find(jPsiRap.GetName()).getVal())
jPsiPt.setVal(args.find(jPsiPt.GetName()).getVal())
jPsicTau.setVal(args.find(jPsicTau.GetName()).getVal())
jPsicTauError.setVal(args.find(jPsicTauError.GetName()).getVal())
jPsiHXcosth.setVal(args.find(jPsiHXcosth.GetName()).getVal())
jPsiHXphi.setVal(args.find(jPsiHXphi.GetName()).getVal())
massStates.setIndex(int(massFun.getVal()))
ctauStates.setIndex(int(ctauFun.getVal()))
states.setIndex(int(mlFun.getVal()))
binDataWithCategory.add(fitVars)
getattr(ws,'import')(binDataWithCategory)
print '>> Extracting histograms from input root files...'
file = aux_shapes + 'datacard.root'
#file = aux_shapes + 'datacard_combine_1p.root'
cb.cp().backgrounds().ExtractShapes(
file, '$BIN/$PROCESS', '$BIN/$PROCESS_$SYSTEMATIC')
cb.cp().signals().ExtractShapes(
file, '$BIN/$PROCESS$MASS', '$BIN/$PROCESS$MASS_$SYSTEMATIC')
tes = RooRealVar('tes', 'tes', 0.97, 1.03);
tes.setConstant(True)
f_debug = TFile('morph_debug.root', 'RECREATE')
ws = RooWorkspace('htt', 'htt')
bins = cb.bin_set()
for bin in bins:
for proc in procs['sig']:
BuildRooMorphing(ws, cb, bin, proc, tes, "norm", True, True, False, f_debug)
f_debug.Close()
cb.AddWorkspace(ws, False)
cb.cp().process(procs['sig']).ExtractPdfs(cb, "htt", "$BIN_$PROCESS_morph", "")
def doDataFit(Chib1_parameters,Chib2_parameters, cuts, inputfile_name = None, RooDataSet = None, ptBin_label='', plotTitle = "#chi_{b}",fittedVariable='qValue', printSigReso = False, noPlots = False, useOtherSignalParametrization = False, useOtherBackgroundParametrization = False, massFreeToChange = False, sigmaFreeToChange = False, legendOnPlot=True, drawPulls=False, titleOnPlot=False, cmsOnPlot=True, printLegend=True):
if RooDataSet != None:
dataSet = RooDataSet
elif inputfile_name != None:
print "Creating DataSet from file "+str(inputfile_name)
dataSet = makeRooDataset(inputfile_name)
else:
raise ValueError('No dataset and no inputfile passed to function doDataFit')
if(fittedVariable == 'refittedMass'):
x_var = 'rf1S_chib_mass'
output_suffix = '_refit'
x_axis_label= 'm_{#mu^{+} #mu^{-} #gamma} [GeV]'
else:
x_var = 'invm1S'
output_suffix = '_qValue'
x_axis_label = 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon} [GeV]'
cuts_str = str(cuts)
#cuts_str = quality_cut + "photon_pt > 0.5 && abs(photon_eta) < 1.0 && ctpv < 0.01 && abs(dimuon_rapidity) < 1.3 && pi0_abs_mass > 0.025 && abs(dz) < 0.5"
data = dataSet.reduce( RooFit.Cut(cuts_str) )
print 'Creating pdf'
x=RooRealVar(x_var, 'm(#mu #mu #gamma) - m(#mu #mu) + m_{#Upsilon}',9.7,10.1,'GeV')
numBins = 80 # define here so that if I change it also the ndof change accordingly
x.setBins(numBins)
# cristal balls
mean_1 = RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,"GeV")
sigma_1 = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', Chib1_parameters.a1)
n1_1 = RooRealVar('n1_1', 'n1_1', Chib1_parameters.n1)
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1',Chib1_parameters.a2)
n2_1 = RooRealVar('n2_1', 'n2_1', Chib1_parameters.n2)
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
mean_2 = RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,"GeV")
sigma_2 = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', Chib2_parameters.a1)
n1_2 = RooRealVar('n1_2', 'n1_2', Chib2_parameters.n1)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', Chib2_parameters.a2)
n2_2 = RooRealVar('n2_2', 'n2_2', Chib2_parameters.n2)
parameters.add(RooArgSet( a1_2, a2_2, n1_2, n2_2))
if massFreeToChange:
# scale_mean = RooRealVar('scale_mean', 'Scale that multiplies masses found with MC', 0.8,1.2)
# mean_1_fixed = RooRealVar("mean_1_fixed","mean ChiB1",Chib1_parameters.mean,"GeV")
# mean_2_fixed = RooRealVar("mean_2_fixed","mean ChiB2",Chib2_parameters.mean,"GeV")
# mean_1 = RooFormulaVar("mean_1",'@0*@1', RooArgList(scale_mean, mean_1_fixed))
# mean_2 = RooFormulaVar("mean_2",'@0*@1', RooArgList(scale_mean, mean_2_fixed))
variazione_m = 0.05 # 50 MeV
diff_m_12 = RooRealVar('diff_m_12', 'Difference between masses chib1 and chib2',0.0194,'GeV') # 19.4 MeV from PDG
mean_1=RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,Chib1_parameters.mean-variazione_m,Chib1_parameters.mean+variazione_m ,"GeV")
mean_2=RooFormulaVar('mean_2', '@0+@1',RooArgList(mean_1, diff_m_12))
# mean_2=RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,Chib2_parameters.mean-variazione_m,Chib2_parameters.mean+variazione_m ,"GeV")
parameters.add(mean_1)
else:
parameters.add(RooArgSet(mean_1, mean_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)
if sigmaFreeToChange:
scale_sigma = RooRealVar('scale_sigma', 'Scale that multiplies sigmases found with MC', 1, 1.1)#1.01
sigma_1_fixed = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV')
sigma_2_fixed = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV')
sigma_1 = RooFormulaVar("sigma_1",'@0*@1', RooArgList(scale_sigma, sigma_1_fixed))
sigma_2 = RooFormulaVar("sigma_2",'@0*@1', RooArgList(scale_sigma, sigma_2_fixed))
parameters.add(scale_sigma)
else:
parameters.add(RooArgSet(sigma_1, sigma_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)
if useOtherSignalParametrization: # In this case I redefine cb_pdf
cb1 = RooCBShape('cb1', 'cb1', x, mean_1, sigma_1, a1_1, n1_1)
cb2 = RooCBShape('cb2', 'cb2', x, mean_2, sigma_2, a1_2, n1_2)
# I use a2 as the sigma of my gaussian
gauss1 = RooCBShape('gauss1', 'gauss1',x, mean_1, a2_1, a1_1, n1_1)
gauss2 = RooCBShape('gauss2', 'gauss2',x, mean_2, a2_2, a1_2, n1_2)
# I use n2 as the ratio of cb with respect to gauss
chib1_pdf = RooAddPdf('chib1','chib1',RooArgList(cb1, gauss1),RooArgList(n2_1))
chib2_pdf = RooAddPdf('chib2','chib2',RooArgList(cb2, gauss2),RooArgList(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) )
if useOtherBackgroundParametrization: # in thies case I redefine background
a0 = RooRealVar('a0','a0',1.,-1.,1.) #,0.5,0.,1.)
a1 = RooRealVar('a1','a1',0.1,-1.,1.) #-0.2,0.,1.)
#a2 = RooRealVar('a2','a2',-0.1,1.,-1.)
background = RooChebychev('background','Background',x,RooArgList(a0,a1))
parameters.add(RooArgSet(a0, a1))
else:
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf,chib2_pdf,background)
# ndof
floatPars = parameters.selectByAttrib("Constant",ROOT.kFALSE)
ndof = numBins - floatPars.getSize() - 1
# # Here I have as parameters N1, N2, and N_background
# n_chib1 = RooRealVar("n_chib1","n_chib1",1250, 0, 50000)
# n_chib2 = RooRealVar("n_chib2","n_chib2",825, 0, 50000)
# 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)
# Here I have as parameters N_12, ratio_12, N_background
n_chib = RooRealVar("n_chib","n_chib",2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21","ratio_21",0.6, 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)
parameters.add(RooArgSet(n_chib1, n_chib2, n_background))
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
print 'Fitting to data'
fit_region = x.setRange("fit_region",9.7,10.1)
result=modelPdf.fitTo(data,RooFit.Save(), RooFit.Range("fit_region"))
# define frame
frame = x.frame()
frame.SetNameTitle("fit_resonance","Fit Resonanace")
frame.GetXaxis().SetTitle(x_axis_label )
frame.GetYaxis().SetTitle( "Events/5 MeV " )
frame.GetXaxis().SetTitleSize(0.04)
frame.GetYaxis().SetTitleSize(0.04)
frame.GetXaxis().SetTitleOffset(1.1)
frame.GetXaxis().SetLabelSize(0.04)
frame.GetYaxis().SetLabelSize(0.04)
frame.SetLineWidth(1)
frame.SetTitle(plotTitle)
# plot things on frame
data.plotOn(frame, RooFit.MarkerSize(0.7))
chib1P_set = RooArgSet(chib1_pdf)
modelPdf.plotOn(frame,RooFit.Components(chib1P_set), RooFit.LineColor(ROOT.kGreen+2), RooFit.LineStyle(2), RooFit.LineWidth(1))
chib2P_set = RooArgSet(chib2_pdf)
modelPdf.plotOn(frame, RooFit.Components(chib2P_set),RooFit.LineColor(ROOT.kRed), RooFit.LineStyle(2), RooFit.LineWidth(1))
background_set = RooArgSet(background)
modelPdf.plotOn(frame,RooFit.Components(background_set), RooFit.LineColor(ROOT.kBlack), RooFit.LineStyle(2), RooFit.LineWidth(1))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
frame.SetName("fit_resonance")
# Make numChib object
numChib = NumChib(numChib=n_chib.getVal(), s_numChib=n_chib.getError(), ratio_21=ratio_21.getVal(), s_ratio_21=ratio_21.getError(), numBkg=n_background.getVal(), s_numBkg=n_background.getError(), corr_NB=result.correlation(n_chib, n_background),corr_NR=result.correlation(n_chib, ratio_21) , name='numChib'+output_suffix+ptBin_label,q0=q0.getVal(),s_q0=q0.getError(),alpha=alpha.getVal(),s_alpha=alpha.getError(), beta=beta.getVal(), s_beta=beta.getError(), chiSquare=frame.chiSquare())
#numChib.saveToFile('numChib'+output_suffix+'.txt')
if noPlots:
chi2 = frame.chiSquare()
del frame
return numChib, chi2
# Legend
parameters_on_legend = RooArgSet()#n_chib, ratio_21, n_background)
if massFreeToChange:
#parameters_on_legend.add(scale_mean)
parameters_on_legend.add(mean_1)
#parameters_on_legend.add(mean_2)
if sigmaFreeToChange:
parameters_on_legend.add(scale_sigma)
if massFreeToChange or sigmaFreeToChange:
modelPdf.paramOn(frame, RooFit.Layout(0.1,0.6,0.2),RooFit.Parameters(parameters_on_legend))
if printLegend: #chiquadro, prob, numchib...
leg = TLegend(0.48,0.75,0.97,0.95)
leg.SetBorderSize(0)
#leg.SetTextSize(0.04)
leg.SetFillStyle(0)
chi2 = frame.chiSquare()
probChi2 = TMath.Prob(chi2*ndof, ndof)
chi2 = round(chi2,2)
probChi2 = round(probChi2,2)
leg.AddEntry(0,'#chi^{2} = '+str(chi2),'')
leg.AddEntry(0,'Prob #chi^{2} = '+str(probChi2),'')
N_bkg, s_N_bkg = roundPair(numChib.numBkg, numChib.s_numBkg)
leg.AddEntry(0,'N_{bkg} = '+str(N_bkg)+' #pm '+str(s_N_bkg),'')
N_chib12, s_N_chib12 = roundPair(numChib.numChib, numChib.s_numChib)
leg.AddEntry(0,'N_{#chi_{b}} = '+str(N_chib12)+' #pm '+str(s_N_chib12),'')
Ratio = numChib.calcRatio()
s_Ratio = numChib.calcRatioError()
Ratio, s_Ratio = roundPair(Ratio, s_Ratio)
leg.AddEntry(0,'N_{2}/N_{1} = '+str(Ratio)+' #pm '+str(s_Ratio),'')
if printSigReso: # Add Significance
Sig = numChib.calcSignificance()
s_Sig = numChib.calcSignificanceError()
Sig, s_Sig = roundPair(Sig, s_Sig)
leg.AddEntry(0,'Sig = '+str(Sig)+' #pm '+str(s_Sig),'')
if(Chib1_parameters.sigma>Chib2_parameters.sigma):
Reso = Chib1_parameters.sigma * 1000 # So it's in MeV and not in GeV
s_Reso = Chib1_parameters.s_sigma * 1000 # So it's in MeV and not in GeV
else:
Reso = Chib2_parameters.sigma * 1000 # So it's in MeV and not in GeV
s_Reso = Chib2_parameters.s_sigma * 1000 # So it's in MeV and not in GeV
Reso, s_Reso =roundPair(Reso, s_Reso)
leg.AddEntry(0,'Reso = '+str(Reso)+' #pm '+str(s_Reso)+' MeV','')
#N1 = numChib.numChib1
#s_N1 = numChib.s_numChib1
#N1, s_N1 = roundPair(N1, s_N1)
#leg.AddEntry(0,'N_{1} = '+str(N1)+' #pm '+str(s_N1),'')
#N2 = numChib.numChib2
#s_N2 = numChib.s_numChib2
#N2, s_N2 = roundPair(N2, s_N2)
#leg.AddEntry(0,'N_{2} = '+str(N2)+' #pm '+str(s_N2),'')
frame.addObject(leg)
if legendOnPlot: # < pT <
legend = TLegend(.06,.75,.53,.93)
legend.SetFillStyle(0)
legend.SetBorderSize(0)
#legend.AddEntry(0,'CMS','')
legend.AddEntry(0,str(cuts.upsilon_pt_lcut)+' GeV < p_{T}(#Upsilon) < '+str(cuts.upsilon_pt_hcut)+' GeV','')
#legend.AddEntry(0,'p_{T}(#Upsilon)<'+str(cuts.upsilon_pt_hcut),'')
frame.addObject(legend)
if titleOnPlot:
titleLegend = TLegend(.06,.4,.55,.73)
#titleLegend.SetTextSize(0.03)
titleLegend.SetFillStyle(0)
titleLegend.SetBorderSize(0)
titleLegend.AddEntry(0,plotTitle,'')
frame.addObject(titleLegend)
if cmsOnPlot:
if printLegend:
pvtxt = TPaveText(.1,.55,.55,.73,"NDC")
else:
pvtxt = TPaveText(0.5,0.75,0.97,0.9,"NDC") #(.06,.4,.55,.73)
pvtxt.AddText('CMS Preliminary')
pvtxt.AddText('pp, #sqrt{s} = 8 TeV')
pvtxt.AddText('L = 20.7 fb^{-1}')
pvtxt.SetFillStyle(0)
pvtxt.SetBorderSize(0)
pvtxt.SetTextSize(0.04)
frame.addObject(pvtxt)
# Canvas
c1=TCanvas('Chib12_1P'+output_suffix+ptBin_label,'Chib12_1P'+output_suffix+ptBin_label)
frame.Draw()
if drawPulls:
#c1=TCanvas(output_name+output_suffix,output_name+output_suffix,700, 625)
hpull = frame.pullHist()
framePulls = x.frame()
framePulls.SetTitle(';;Pulls')
framePulls.GetYaxis().SetLabelSize(0.18)
framePulls.GetYaxis().SetTitle('Pulls')
framePulls.GetYaxis().SetTitleSize(0.18)
framePulls.GetYaxis().SetTitleOffset(0.15)
framePulls.GetYaxis().SetNdivisions(005)
framePulls.GetXaxis().SetLabelSize(0.16)
framePulls.GetXaxis().SetTitle('')
line0 = TLine(9.7, 0, 10.1, 0)
line0.SetLineColor(ROOT.kBlue)
line0.SetLineWidth(2)
framePulls.addObject(line0)
framePulls.addPlotable(hpull,"P")
framePulls.SetMaximum(5)
framePulls.SetMinimum(-5)
pad1 = TPad("pad1", "The pad 80% of the height",0.0,0.2,1.0,1.0)
pad1.cd()
frame.Draw()
pad2 = TPad("pad2", "The pad 20% of the height",0.0,0.01,1.0,0.2)
pad2.cd()
framePulls.Draw()
c1.cd()
pad1.Draw()
pad2.Draw()
#c1.SaveAs('Chib12_1P'+output_suffix+'.png')
print 'Chi2 = '+str(frame.chiSquare())
# print ratio background/all in the signal refion
signal_region = x.setRange("signal_region",9.87,9.92)
pdf_integral = modelPdf.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * (n_chib.getVal() + n_background.getVal())
bkg_integral = background.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * n_background.getVal()
print 'Ratio bkg/all in signal region = '+str(bkg_integral/pdf_integral)
return numChib, c1
