def get_dataset(varargset, ftree, cut="", wt="", scale=1):
"""Return a dataset.
Return a dataset from the ntuple `ftree'. Apply a selection cut
using the `cutVar' variable and the selection `cut'.
"""
from rplot.fixes import ROOT
from rplot.tselect import Tsplice
splice = Tsplice(ftree)
splice.make_splice("sel", cut)
from ROOT import RooDataSet, RooFit, RooFormulaVar, RooArgList
tmpdst = RooDataSet("tmpdataset", "", varargset, RooFit.Import(ftree))
if wt:
wtvar = RooFormulaVar("wt", "{}*@0".format(scale), RooArgList(varargset[wt]))
wtvar = tmpdst.addColumn(wtvar)
varargset.remove(varargset[wt])
varargset.add(wtvar)
dst = RooDataSet("dataset", "Dataset", varargset, RooFit.Import(tmpdst), RooFit.WeightVar(wtvar))
varargset.remove(wtvar)
dst = dst.reduce(varargset)
return dst
def 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 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 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 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 fillDataSet(data, x, N, dsName='ds'):
cols = RooArgSet(x)
ds = RooDataSet(dsName, dsName, cols)
#ds.Print()
print 'length data:', N
for datum in range(0, N):
if (data[datum] < x.getMax()) and (data[datum] > x.getMin()):
x.setVal(data[datum])
ds.add(cols)
ds.Print()
return ds
def main():
inputfile_name = "/data1/chibdata/collision/v2/2012_AllData_v2.root"
chibTree_name = "rootuple/chibTree"
print "Opening file"
inputfile = TFile.Open(inputfile_name, "READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(chibTree_name, tree)
invm1S = RooRealVar("invm1S", "invm1S", 9.5, 11.5)
invm2S = RooRealVar("invm2S", "invm2S", 9.5, 20.0)
invm3S = RooRealVar("invm3S", "invm3S", 9.5, 20.0)
dimuon_mass = RooRealVar("dimuon_mass", "dimuon_mass", 8.0, 12.0)
dimuon_rapidity = RooRealVar("dimuon_rapidity", "dimuon_rapidity", -5.0,
5.0)
dimuon_pt = RooRealVar("dimuon_pt", "dimuon_pt", 0.0, 100.0)
photon_eta = RooRealVar("photon_eta", "photon_eta", -5.0, 5.0)
photon_pt = RooRealVar("photon_pt", "photon_pt", 0.0, 100.0)
ctpv = RooRealVar("ctpv", "ctpv", -5.0, 5.0)
ctpv_error = RooRealVar("ctpv_err", "ctpv_err", -5.0, 5.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass", "pi0_abs_mass", 0.0, 2.0)
Y1S_nsigma = RooRealVar("Y1S_nsigma", "Y1S_nsigma", 0.0, 30.0)
Y2S_nsigma = RooRealVar("Y2S_nsigma", "Y2S_nsigma", 0.0, 30.0)
Y3S_nsigma = RooRealVar("Y3S_nsigma", "Y3S_nsigma", 0.0, 35.0)
conv_vertex = RooRealVar("conv_vertex", "conv_vertex", 0.0, 70.0)
dz = RooRealVar("dz", "dz", -50.0, 50.0)
print "Assigning argset"
dataArgSet = RooArgSet(invm1S, invm2S, invm3S, dimuon_mass,
dimuon_rapidity, dimuon_pt, photon_eta, photon_pt,
ctpv)
dataArgSet.add(ctpv_error)
dataArgSet.add(pi0_abs_mass)
dataArgSet.add(Y1S_nsigma)
dataArgSet.add(Y2S_nsigma)
dataArgSet.add(Y3S_nsigma)
dataArgSet.add(conv_vertex)
dataArgSet.add(dz)
print "Creating DataSet"
dataSet = RooDataSet("chibds", "Chib RooDataSet", tree, dataArgSet)
# Selection
cuts = "photon_pt > 0.0" + \
"&&dimuon_pt > 9.5" \
"&& abs(photon_eta) < 1.4" + \
"&& abs(dimuon_rapidity) < 1.25 " + \
"&& Y3S_nsigma < 2.5 " + \
"&& abs(dz) < 0.1"
rds_cutted = dataSet.reduce(RooFit.Cut(cuts))
dofit(rds_cutted, "Chib_fit_2012_3S")
def fillDataSet(data, x, N, dsName = 'ds'):
cols = RooArgSet(x)
ds = RooDataSet(dsName, dsName, cols)
#ds.Print()
print 'length data:', N
for datum in range(0,N):
if (data[datum] < x.getMax()) and (data[datum] > x.getMin()):
x.setVal(data[datum])
ds.add(cols)
ds.Print()
return ds
def main() :
inputfile_name = "/data1/chibdata/collision/v2/2012_AllData_v2.root"
chibTree_name = "rootuple/chibTree"
print "Opening file"
inputfile = TFile.Open(inputfile_name,"READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(chibTree_name, tree)
invm1S = RooRealVar("invm1S", "invm1S", 9.5, 11.5)
invm2S = RooRealVar("invm2S", "invm2S", 9.5, 20.0)
invm3S = RooRealVar("invm3S", "invm3S", 9.5, 20.0)
dimuon_mass = RooRealVar("dimuon_mass","dimuon_mass", 8.0, 12.0)
dimuon_rapidity = RooRealVar("dimuon_rapidity", "dimuon_rapidity", -5.0, 5.0)
dimuon_pt = RooRealVar("dimuon_pt","dimuon_pt", 0.0, 100.0)
photon_eta = RooRealVar("photon_eta","photon_eta", -5.0, 5.0)
photon_pt = RooRealVar("photon_pt","photon_pt", 0.0, 100.0)
ctpv = RooRealVar("ctpv","ctpv", -5.0, 5.0)
ctpv_error = RooRealVar("ctpv_err","ctpv_err", -5.0, 5.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass","pi0_abs_mass", 0.0, 2.0)
Y1S_nsigma = RooRealVar("Y1S_nsigma","Y1S_nsigma",0.0,30.0)
Y2S_nsigma = RooRealVar("Y2S_nsigma","Y2S_nsigma",0.0,30.0)
Y3S_nsigma = RooRealVar("Y3S_nsigma","Y3S_nsigma",0.0,35.0)
conv_vertex = RooRealVar("conv_vertex", "conv_vertex", 0.0, 70.0)
dz = RooRealVar("dz","dz", -50.0, 50.0)
print "Assigning argset"
dataArgSet = RooArgSet(invm1S, invm2S, invm3S, dimuon_mass, dimuon_rapidity, dimuon_pt, photon_eta, photon_pt, ctpv)
dataArgSet.add( ctpv_error )
dataArgSet.add( pi0_abs_mass )
dataArgSet.add( Y1S_nsigma )
dataArgSet.add( Y2S_nsigma )
dataArgSet.add( Y3S_nsigma )
dataArgSet.add( conv_vertex )
dataArgSet.add( dz )
print "Creating DataSet"
dataSet = RooDataSet("chibds","Chib RooDataSet", tree, dataArgSet)
# Selection
cuts = "photon_pt > 0.0" + \
"&&dimuon_pt > 9.5" \
"&& abs(photon_eta) < 1.4" + \
"&& abs(dimuon_rapidity) < 1.25 " + \
"&& Y3S_nsigma < 2.5 " + \
"&& abs(dz) < 0.1"
rds_cutted = dataSet.reduce( RooFit.Cut(cuts) )
dofit(rds_cutted, "Chib_fit_2012_3S")
class MLFit :
def __init__(self, plot_dire, condition):
self.plot_dire = plot_dire
self.condition = condition
self.mjj = RooRealVar("ZJJMass", "ZJJMass", 50., 7000.)
#self.costhetastar = RooRealVar("costhetastar", "costhetastar", -1., 1.)
self.weight = RooRealVar("weight", "weight", -100., 100.)
self.isSignal = RooCategory("isSignal", "isSignal")
self.isSignal.defineType("signal", 1);
self.isSignal.defineType("background", 0);
self.ras = RooArgSet(self.mjj, self.weight)
self.ds = RooDataSet("ds"+condition, "ds"+condition, self.ras, "weight")
#self.mu = RooRealVar("mu", "mu", 90., 80., 100.)
#self.widthL = RooRealVar("widthL", "widthL", 15., 2., 30.)
#self.widthR = RooRealVar("widthR", "widthR", 4., 2., 15.)
#self.sigmass = RooBifurGauss("bifurgauss", "bifurgauss", self.mjj, self.mu, self.widthL, self.widthR)
self.c0 = RooRealVar("c0", "c0", -100., 100.)
self.bkgmass = RooExponential("expo", "expo", self.mjj, self.c0)
#self.nsig = RooRealVar("nsig", "nsig", 100, 0, 200)
#self.nbkg = RooRealVar("nbkg", "nbkg", 100, 0, 200)
#self.components = RooArgList(self.sigmass, self.bkgmass)
#self.coefficients = RooArgList(self.nsig, self.nbkg)
self.modelmass = self.bkgmass #RooAddPdf("massmodel", "massmodel", self.components, self.coefficients)
def addToDataset(self, event, isSignal):
if not eval(self.condition):
return
self.mjj = event.ZJJMass
print self.mjj
#self.costhetastar = event.costhetastar
self.weight = event.weight
#self.isSignal = isSignal
self.ds.fill()
def fit(self):
print "nentries", self.ds.numEntries()
#for i in range(self.ds.numEntries()):
# argset = self.ds.get(i)
# argset.Dump()
fitresult = self.modelmass.fitTo(self.ds, RooFit.Save(True), RooFit.Extended(), RooFit.PrintLevel(3), RooFit.Strategy(2)) #, RooFit.SumW2Error(True))
def File2Dataset(self, fnames, dsName, ws, noCuts = False,
weighted = False, CPweight = False, cutOverride = None,
interference = 0, additionalWgt = 1.0):
if ws.data(dsName):
return ws.data(dsName)
cols = RooArgSet(ws.set('obsSet'))
# print 'interference weight flag:',interference
if (weighted):
evtWgt = RooRealVar('evtWgt', 'evtWgt', 1.0)
cols.add(evtWgt)
ds = RooDataSet(dsName, dsName, cols, 'evtWgt')
print 'including weights for eff',
if CPweight:
print 'and CP weight',
if interference in [1,2,3]:
print 'and interference',
print
else:
ds = RooDataSet(dsName, dsName, cols)
if not (type(fnames) == type([])):
fnames = [fnames]
try:
obs = [ self.pars.varNames[x] for x in self.pars.var ]
except AttributeError:
obs = self.pars.var
for fname in fnames:
for (row, effWgt, cpw, iwt) in \
self.TreeLoopFromFile(fname, noCuts,
CPweight = CPweight,
cutOverride = cutOverride,
interference = interference):
inRange = True
for (i,v) in enumerate(obs):
inRange = (inRange and ws.var(v).inRange(row[i], ''))
cols.setRealValue(v, row[i])
if CPweight:
effWgt *= cpw
if interference in [1,2,3]:
effWgt *= iwt
if inRange:
ds.add(cols, effWgt*additionalWgt)
getattr(ws, 'import')(ds)
return ws.data(dsName)
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, plot_dire, condition):
self.plot_dire = plot_dire
self.condition = condition
self.mjj = RooRealVar("ZJJMass", "ZJJMass", 50., 7000.)
#self.costhetastar = RooRealVar("costhetastar", "costhetastar", -1., 1.)
self.weight = RooRealVar("weight", "weight", -100., 100.)
self.isSignal = RooCategory("isSignal", "isSignal")
self.isSignal.defineType("signal", 1);
self.isSignal.defineType("background", 0);
self.ras = RooArgSet(self.mjj, self.weight)
self.ds = RooDataSet("ds"+condition, "ds"+condition, self.ras, "weight")
#self.mu = RooRealVar("mu", "mu", 90., 80., 100.)
#self.widthL = RooRealVar("widthL", "widthL", 15., 2., 30.)
#self.widthR = RooRealVar("widthR", "widthR", 4., 2., 15.)
#self.sigmass = RooBifurGauss("bifurgauss", "bifurgauss", self.mjj, self.mu, self.widthL, self.widthR)
self.c0 = RooRealVar("c0", "c0", -100., 100.)
self.bkgmass = RooExponential("expo", "expo", self.mjj, self.c0)
#self.nsig = RooRealVar("nsig", "nsig", 100, 0, 200)
#self.nbkg = RooRealVar("nbkg", "nbkg", 100, 0, 200)
#self.components = RooArgList(self.sigmass, self.bkgmass)
#self.coefficients = RooArgList(self.nsig, self.nbkg)
self.modelmass = self.bkgmass #RooAddPdf("massmodel", "massmodel", self.components, self.coefficients)
def createDataSet(self, dname, dcut):
"""Create named dataset"""
if dname in self.dataset.keys():
return self.dataset[dname]
data = RooDataSet(dname, "", self.ch, self.argset, dcut)
self.dataset[dname] = data
return data
def addAsciiData(self,
ws,
ds_name,
item_title,
var_set_name,
var_set_type,
ds_file_name,
weight_var_name=None,
debug=0,
sets=None):
legend = '[exostConfig::addAsciiData]:'
arg_set = RooArgSet()
if (var_set_type == 'set'):
#_var_set = ws.set(var_set_name)
_var_set = sets[var_set_name]
arg_set.add(_var_set)
if _var_set.getSize() != 1:
print legend, 'Error: too many or too few columns in the input ASCII file'
print legend, 'Error: Smart program as I am, I can only handle ASCII files'
print legend, 'Error: with exactly one column at the moment.'
print legend, 'Error: Support for multiple columns will be implemented'
print legend, 'Error: eventually, contact the developers.'
print legend, 'Error: Better yet, switch to ROOT input files,'
print legend, 'Error: all the cool kids are doing that!'
return -1
elif (var_set_type == 'var'):
arg_set.add(ws.var(var_set_name))
else:
print legend, 'error: unknown var_set_type, cannot create dataset', ds_name
return -1
#create the dataset
if weight_var_name == None: #no weight
if (debug > 0):
print legend, 'no weight variable given'
_arglist = RooArgList(arg_set)
#ds = RooDataSet()ds_name, item_title)
ds = RooDataSet.read(ds_file_name, _arglist)
ds.SetName(ds_name)
ds.SetTitle(item_title)
else:
if (debug > 0):
print legend, 'using variable', weight_var_name, 'as weight'
print legend, 'Error: Smart program as I am, I cannot handle'
print legend, 'Error: weights when loading from ASCII files yet.'
print legend, 'Error: Support for weights from ASCII files will'
print legend, 'Error: be implemented eventually, contact the developers.'
print legend, 'Error: Better yet, switch to ROOT input files,'
print legend, 'Error: all the cool kids are doing that!'
return -1
# import the datahist. Note workaround 'import' being a reserved word
getattr(ws, 'import')(ds)
def get_dataset(varargset, ftree, cut='', cutVars=[], *cmdArgs):
"""Return a dataset.
Return a dataset from the ntuple `ftree'. Apply a selection cut
using the `cutVar' variable and the selection `cut'.
"""
varargsetclone = varargset.clone('varargsetclone')
for cvar in cutVars:
varargsetclone.add(cvar) # Add selVar to apply cut
tmpdataset = RooDataSet('dataset', 'Dataset', varargsetclone,
RooFit.Import(ftree), RooFit.Cut(cut), *cmdArgs)
dataset = tmpdataset.reduce(varargset)
del tmpdataset
return dataset
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 addData(self,
ws,
ds_name,
item_title,
var_set_name,
var_set_type,
ds_object,
weight_var_name=None,
debug=0,
sets=None):
legend = '[exostConfig::addData]:'
arg_set = RooArgSet()
if (var_set_type == 'set'):
#arg_set.add(ws.set(var_set_name))
arg_set.add(sets[var_set_name])
elif (var_set_type == 'var'):
arg_set.add(ws.var(var_set_name))
else:
print legend, 'error: unknown var_set_type, cannot create dataset', ds_name
return -1
#create the dataset
if weight_var_name == None: #no weight
if (debug > 0):
print legend, 'no weight branch given'
ds = RooDataSet(ds_name, item_title, ds_object, arg_set)
else:
if (debug > 0):
print legend, 'using weight branch', weight_var_name
# old and incorrect(?) way of applying weights
#
#_var_formula = RooFormulaVar('f'+weight_var_name,
# 'f'+weight_var_name,
# '@0',
# RooArgList(ws.var(weight_var_name)))
#ds = RooDataSet(ds_name, item_title, ds_object, arg_set, _var_formula, weight_var_name)
arg_set.add(ws.var(weight_var_name))
ds = RooDataSet(ds_name, item_title, ds_object, arg_set, "1>0",
weight_var_name)
# import the datahist. Note workaround 'import' being a reserved word
getattr(ws, 'import')(ds)
def fit(self):
pdfs = RooArgList()
obsvars = RooArgSet('set')
for constraint in self.constraint.values():
pdfs.add(constraint.pdf_constraint)
if hasattr(constraint, 'var_obs'):
obsvars.add(constraint.var_obs)
self.model = RooProdPdf('model', 'model', pdfs)
self.data = RooDataSet('data', 'data', obsvars)
self.data.add(obsvars)
self.data.Print()
self.fit_result = self.model.fitTo(self.data,
ROOT.RooFit.PrintLevel(3),
ROOT.RooFit.Optimize(1),
ROOT.RooFit.Hesse(1),
ROOT.RooFit.Minos(1),
ROOT.RooFit.Strategy(2),
ROOT.RooFit.Save(1))
def get_dataset_from_tree(
self,
path_to_tree,
tree_variables,
weight="1==1",
weight_var_name=0,
dataset_name="my_dataset",
basket=True,
category=None,
):
"""
Creates RooDataSet from a plain root tree given:
- variables name list
- weight expression. It works in the same way as TTree cut.
Returns:
--------
- RooDataSet
- also fills the basket with datasets (basket inhereted from RootHelperBase class)
TODO
----
- add implementation for category setting(check in prepare_toy_datasets_for_sync)
- check if adding toy dataset to each channel workspace individually behaves well
after combineCards.py.
"""
# make RooRealVars from tree_variables
my_arg_set = RooArgSet()
my_rrv = dict()
for var_name in tree_variables:
# TODO implement check that branch exist
my_rrv[var_name] = RooRealVar(var_name, var_name, -999999999, 999999999)
my_arg_set.add(my_rrv[var_name])
if self.DEBUG:
self.log.debug("RooArgSet is now:")
my_arg_set.Print()
# get the tree from path_to_tree
my_tree = self.get_TTree(path_to_tree, cut=weight)
self.log.debug("Selected tree contains {0} events".format(my_tree.GetEntries()))
# create RooDataSet and reduce tree if needed
# self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, weight).reduce(my_arg_set)
self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set)
# self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, "", weight_var_name)
# data[j]=new RooDataSet(Form("data%d",j),Form("data%d",j),outTree,RooArgSet(rCMS_zz4l_widthKD,rCMS_zz4l_widthMass,rweightFit),"","_weight_");
self.log.debug("RooDataSet contains {0} events".format(self.dataset_from_tree.sumEntries()))
# .reduce(ROOT.RooArgSet(self.D0))
self.current_arg_set = my_arg_set
# add dataset to basket
if basket:
self.add_to_basket(self.dataset_from_tree, new_name=dataset_name, new_title=dataset_name)
return self.dataset_from_tree
def makeRooDataset(inputfile_name):
chibTree_name = 'rootuple/chibTree'
inputfile = TFile.Open(inputfile_name,"READ")
tree = TTree()
inputfile.GetObject(chibTree_name, tree)
invm1S = RooRealVar("invm1S", "invm1S", 9.7, 10.1)#9.5, 11.5
invm2S = RooRealVar("invm2S", "invm2S", 9.5, 13.0)
invm3S = RooRealVar("invm3S", "invm3S", 9.5, 13.0)
chib_mass = RooRealVar("chib_mass", "chib_mass", 5., 15.0)
chib_pt = RooRealVar("chib_pt", "chib_pt", 0., 300.)
chib_eta = RooRealVar("chib_eta", "chib_eta", -5., 5.)
chib_phi = RooRealVar("chib_phi", "chib_phi", -3.2, 3.2)
dimuon_mass = RooRealVar("dimuon_mass","dimuon_mass", 8.0, 12.0)
dimuon_rapidity = RooRealVar("dimuon_rapidity", "dimuon_rapidity", -5.0, 5.0)
dimuon_pt = RooRealVar("dimuon_pt","dimuon_pt", 0.0, 100.0)
photon_eta = RooRealVar("photon_eta","photon_eta", -5.0, 5.0)
photon_pt = RooRealVar("photon_pt","photon_pt", 0.0, 100.0)
ctpv = RooRealVar("ctpv","ctpv", -5.0, 5.0)
ctpv_error = RooRealVar("ctpv_err","ctpv_err", -5.0, 5.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass","pi0_abs_mass", 0.0, 2.0)
Y1S_nsigma = RooRealVar("Y1S_nsigma","Y1S_nsigma",0.0,30.0)
Y2S_nsigma = RooRealVar("Y2S_nsigma","Y2S_nsigma",0.0,30.0)
Y3S_nsigma = RooRealVar("Y3S_nsigma","Y3S_nsigma",0.0,35.0)
conv_vertex = RooRealVar("conv_vertex", "conv_vertex", 0.0, 70.0)
dz = RooRealVar("dz","dz", 0., 0.6)
numPrimaryVertices = RooRealVar("numPrimaryVertices","numPrimaryVertices",0,60)
rf1S_chib_mass = RooRealVar("rf1S_chib_mass","rf1S_chib_mass",9.5,60.)
probFit1S = RooRealVar("probFit1S","probFit1S",0.,1.)
rf1S_chib_pt = RooRealVar("rf1S_chib_pt", "rf1S_chib_pt", 0., 300.)
rf1S_chib_eta = RooRealVar("rf1S_chib_eta", "rf1S_chib_eta", -5., 5.)
rf1S_dimuon_mass = RooRealVar("rf1S_dimuon_mass","rf1S_dimuon_mass", 8.0, 12.0)
rf1S_dimuon_rapidity = RooRealVar("rf1S_dimuon_rapidity", "rf1S_dimuon_rapidity", -5.0, 5.0)
rf1S_dimuon_pt = RooRealVar("rf1S_dimuon_pt","rf1S_dimuon_pt", 0.0, 230.0)
rf1S_photon_eta = RooRealVar("rf1S_photon_eta","rf1S_photon_eta", -5.0, 5.0)
rf1S_photon_pt = RooRealVar("rf1S_photon_pt","rf1S_photon_pt", 0.0, 100.0)
rf2S_chib_mass = RooRealVar("rf2S_chib_mass","rf2S_chib_mass",9.5,60.)
probFit2S = RooRealVar("probFit2S","probFit2S",0.,1.)
rf3S_chib_mass = RooRealVar("rf3S_chib_mass","rf3S_chib_mass",9.5,60.)
probFit3S = RooRealVar("probFit3S","probFit3S",0.,1.)
muonP_pt = RooRealVar("muonP_pt","muonP_pt",0.,100.)
muonM_pt = RooRealVar("muonM_pt","muonM_pt",0.,100.)
muonP_eta = RooRealVar("muonP_eta","muonP_eta",-5.,5.)
muonM_eta = RooRealVar("muonM_eta","muonM_eta",-5.,5.)
dataArgSet = RooArgSet(invm1S, invm2S, invm3S, dimuon_mass, dimuon_rapidity, dimuon_pt, photon_eta, photon_pt, ctpv)
dataArgSet.add(RooArgSet(chib_mass, chib_pt, chib_eta, chib_phi))
dataArgSet.add(RooArgSet(ctpv_error, pi0_abs_mass, Y1S_nsigma, Y2S_nsigma, Y3S_nsigma, conv_vertex, dz, numPrimaryVertices))
dataArgSet.add(RooArgSet(rf1S_chib_mass, probFit1S, rf2S_chib_mass, probFit2S, rf3S_chib_mass, probFit3S))
dataArgSet.add(RooArgSet(rf1S_chib_pt, rf1S_chib_eta, rf1S_dimuon_mass, rf1S_dimuon_rapidity, rf1S_dimuon_pt, rf1S_photon_eta, rf1S_photon_pt))
dataArgSet.add(RooArgSet(muonP_pt, muonM_pt, muonP_eta, muonM_eta))
dataSet = RooDataSet("chibds","Chib RooDataSet", tree, dataArgSet)
return dataSet
def make_weighted_dataset(subproc,ws,tree,mc_events):
data = RooDataSet('%s_shape_data'%subproc,
'M_{ll#gamma} Shape Data for %s'%subproc,
tree,
ws.set('vars_with_weights')
)
mc_yield_var = RooConstVar('temp','temp',mc_events)
weighter = RooFormulaVar('weight','weight','@0*@1/@2',
RooArgList( ws.var('procWeight'),
ws.var('puWeight'),
mc_yield_var )
)
data.addColumn(weighter)
data_total_weight = RooDataSet('%s_shape_data'%subproc,
'M_{ll#gamma} Shape Data for %s'%subproc,
data,
ws.set('vars_with_weights_final'),
'','weight')
data_pu_weight = RooDataSet('%s_shape_data_puonly'%subproc,
'M_{ll#gamma} Shape Data for %s'%subproc,
data,
ws.set('vars_with_weights_final'),
'','puWeight')
return data_total_weight, data_pu_weight
def get_dataset(varargset, ftree, cut='', wt='', scale=1):
"""Return a dataset.
Return a dataset from the ntuple `ftree'. Apply a selection cut
using the `cutVar' variable and the selection `cut'.
"""
from rplot.fixes import ROOT
from rplot.tselect import Tsplice
splice = Tsplice(ftree)
splice.make_splice('sel', cut)
from ROOT import RooDataSet, RooFit, RooFormulaVar, RooArgList
tmpdst = RooDataSet('tmpdataset', '', varargset, RooFit.Import(ftree))
if wt:
wtvar = RooFormulaVar('wt', '{}*@0'.format(scale),
RooArgList(varargset[wt]))
wtvar = tmpdst.addColumn(wtvar)
varargset.remove(varargset[wt])
varargset.add(wtvar)
dst = RooDataSet('dataset', 'Dataset', varargset,
RooFit.Import(tmpdst), RooFit.WeightVar(wtvar))
varargset.remove(wtvar)
dst = dst.reduce(varargset)
return dst
def fill_dataset(varargset, ftree, wt, wtvar, cut=""):
"""Return a dataset (slow, get_dataset is more efficient).
Return a dataset from the ntuple `ftree', also apply `cut'. Use
`wt' as the weight expression in the tree. `wtvar' is the
corresponding RooRealVar weight. Note, varargset should contain
wtvar.
The dataset is filled by iterating over the tree. This is needed
when you want to ensure different datasets have the same weight
variable names, so that they can be combined later on. This is
needed even if they are combined as different categories.
"""
from rplot.fixes import ROOT
from ROOT import RooDataSet, RooFit, TTreeFormula
from helpers import suppress_warnings
suppress_warnings()
from rplot.tselect import Tsplice
splice = Tsplice(ftree)
splice.make_splice("sel", cut)
formulae = {}
wtname = wtvar.GetName()
for var in varargset:
name = var.GetName()
expr = wt if name == wtname else name
formulae[name] = TTreeFormula(name, expr, ftree)
dataset = RooDataSet("dataset", "Dataset", varargset, RooFit.WeightVar(wtvar))
for i in xrange(ftree.GetEntries()):
ftree.GetEntry(i)
for var, expr in formulae.iteritems():
realvar = varargset.find(var)
realvar.setVal(expr.EvalInstance())
dataset.add(varargset, varargset[wtname].getVal())
return dataset
def addAsciiData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_file_name, weight_var_name = None, debug = 0, sets = None):
legend = '[exostConfig::addAsciiData]:'
arg_set = RooArgSet()
if (var_set_type == 'set'):
#_var_set = ws.set(var_set_name)
_var_set = sets[var_set_name]
arg_set.add(_var_set)
if _var_set.getSize() != 1:
print legend, 'Error: too many or too few columns in the input ASCII file'
print legend, 'Error: Smart program as I am, I can only handle ASCII files'
print legend, 'Error: with exactly one column at the moment.'
print legend, 'Error: Support for multiple columns will be implemented'
print legend, 'Error: eventually, contact the developers.'
print legend, 'Error: Better yet, switch to ROOT input files,'
print legend, 'Error: all the cool kids are doing that!'
return -1
elif (var_set_type == 'var'):
arg_set.add(ws.var(var_set_name))
else:
print legend, 'error: unknown var_set_type, cannot create dataset', ds_name
return -1
#create the dataset
if weight_var_name == None: #no weight
if (debug>0):
print legend, 'no weight variable given'
_arglist = RooArgList(arg_set)
#ds = RooDataSet()ds_name, item_title)
ds = RooDataSet.read(ds_file_name, _arglist)
ds.SetName(ds_name)
ds.SetTitle(item_title)
else:
if (debug>0):
print legend, 'using variable', weight_var_name, 'as weight'
print legend, 'Error: Smart program as I am, I cannot handle'
print legend, 'Error: weights when loading from ASCII files yet.'
print legend, 'Error: Support for weights from ASCII files will'
print legend, 'Error: be implemented eventually, contact the developers.'
print legend, 'Error: Better yet, switch to ROOT input files,'
print legend, 'Error: all the cool kids are doing that!'
return -1
# import the datahist. Note workaround 'import' being a reserved word
getattr(ws, 'import')(ds)
def CreateSimData(w, typ):
sim_dsets = []
for c in range(w.cat("cat").numTypes()):
w.cat("cat").setIndex(c)
samp = w.cat("cat").getLabel()
name = "%s_sim_data" % typ if c == 0 else "%s_sim_data%d" % (typ, c)
sim_dsets.append(
RooDataSet(name, "", RooArgSet(w.var("B_DTFDict_D0_B_M")),
rf.Index(w.cat("cat")),
rf.Import(samp, w.data("%s_%s" % (typ, samp)))))
if c != 0:
sim_dsets[0].append(sim_dsets[c])
getattr(w, 'import')(sim_dsets[0])
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 fill_dataset(varargset, ftree, wt, wtvar, cut=''):
"""Return a dataset (slow, get_dataset is more efficient).
Return a dataset from the ntuple `ftree', also apply `cut'. Use
`wt' as the weight expression in the tree. `wtvar' is the
corresponding RooRealVar weight. Note, varargset should contain
wtvar.
The dataset is filled by iterating over the tree. This is needed
when you want to ensure different datasets have the same weight
variable names, so that they can be combined later on. This is
needed even if they are combined as different categories.
"""
from rplot.fixes import ROOT
from ROOT import RooDataSet, RooFit, TTreeFormula
from helpers import suppress_warnings
suppress_warnings()
from rplot.tselect import Tsplice
splice = Tsplice(ftree)
splice.make_splice('sel', cut)
formulae = {}
wtname = wtvar.GetName()
for var in varargset:
name = var.GetName()
expr = wt if name == wtname else name
formulae[name] = TTreeFormula(name, expr, ftree)
dataset = RooDataSet('dataset', 'Dataset', varargset,
RooFit.WeightVar(wtvar))
for i in xrange(ftree.GetEntries()):
ftree.GetEntry(i)
for var, expr in formulae.iteritems():
realvar = varargset.find(var)
realvar.setVal(expr.EvalInstance())
dataset.add(varargset, varargset[wtname].getVal())
return dataset
def File2Dataset(self,
fnames,
dsName,
ws,
noCuts=False,
weighted=False,
CPweight=False,
cutOverride=None,
interference=0,
additionalWgt=1.0):
if ws.data(dsName):
return ws.data(dsName)
cols = RooArgSet(ws.set('obsSet'))
# print 'interference weight flag:',interference
if (weighted):
evtWgt = RooRealVar('evtWgt', 'evtWgt', 1.0)
cols.add(evtWgt)
ds = RooDataSet(dsName, dsName, cols, 'evtWgt')
print 'including weights for eff',
if CPweight:
print 'and CP weight',
if interference in [1, 2, 3]:
print 'and interference',
print
else:
ds = RooDataSet(dsName, dsName, cols)
if not (type(fnames) == type([])):
fnames = [fnames]
try:
obs = [self.pars.varNames[x] for x in self.pars.var]
except AttributeError:
obs = self.pars.var
for fname in fnames:
for (row, effWgt, cpw, iwt) in \
self.TreeLoopFromFile(fname, noCuts,
CPweight = CPweight,
cutOverride = cutOverride,
interference = interference):
inRange = True
for (i, v) in enumerate(obs):
inRange = (inRange and ws.var(v).inRange(row[i], ''))
cols.setRealValue(v, row[i])
if CPweight:
effWgt *= cpw
if interference in [1, 2, 3]:
effWgt *= iwt
if inRange:
ds.add(cols, effWgt * additionalWgt)
getattr(ws, 'import')(ds)
return ws.data(dsName)
def gendata(filename, q2Bin, nSample):
time_start = time.time()
obs = getobs()
file = TFile.Open(filename)
if not file:
print('File not found: ', filename)
return
wspname = 'ws_b{}p0'.format(q2Bin)
wsp = file.Get(wspname)
if not wsp:
print('Workspace not found in file: ', filename)
return
ctK = wsp.var('ctK')
ctL = wsp.var('ctL')
phi = wsp.var('phi')
rand = wsp.var("rand")
if (not ctK) or (not ctL) or (not phi):
print('Variables not found in file: ', filename)
return
vars = RooArgList(ctK, ctL, phi)
datasetname = 'data_genDen_ev_b{}'.format(q2Bin)
fullData = wsp.data(datasetname)
if not fullData:
print('DataSet ', datasetname, ' not found in file: ', filename)
return
data = RooDataSet()
if nSample == 0:
data = fullData
elif nSample <= 10000:
data = fullData.reduce(
RooArgSet(vars), 'rand > {:1.6f} && rand < {:1.6f}'.format(
(nSample - 1) * dataStat[q2Bin] / genStat[q2Bin],
nSample * dataStat[q2Bin] / genStat[q2Bin]))
else:
data = fullData.reduce(
RooArgSet(vars), 'rand > {:.6f} && rand < {:.6f}'.format(
(nSample % 10000 - 1) * d16Stat[q2Bin] / genStat[q2Bin],
(nSample % 10000) * d16Stat[q2Bin] / genStat[q2Bin]))
print('Fit ', data.numEntries(), ' events')
###convert the final dataset to pd.dataframe
datalist = []
for i in range(0, data.numEntries()):
ctKvalue = data.get(i).getRealValue('ctK')
ctLvalue = data.get(i).getRealValue('ctL')
phivalue = data.get(i).getRealValue('phi')
datalist.append([ctKvalue, ctLvalue, phivalue])
#print ('lenth of datalist ', len(datalist))
finaldata_df = pd.DataFrame(datalist, columns=['costk', 'costl', 'phi'])
finaldata = zfit.Data.from_pandas(finaldata_df, obs=obs)
print('generate zfit data from RooDataSet successfully')
time_end = time.time()
time_c = time_end - time_start
print('time used in fit data import: ', time_c, 's')
return finaldata
def extract_data_in_categories(channel,input_file,ws):
pwd = gDirectory.GetPath()
fin = TFile.Open(input_file,'read')
gDirectory.cd(pwd)
tree = fin.Get('selected_zg')
data = RooDataSet('%s_data'%channel,
'real data %s channel'%channel,
tree,
ws.set('vars') )
data_in_ws = ws.data('%s_data'%channel)
if not not data_in_ws:
data_in_ws.append(data)
else:
getattr(ws,'import')(data)
def Split_DS(Save_DS=False):
ws_file = TFile(
"/afs/cern.ch/user/" + prefix + "/" + user + "/eos/lhcb/user/" +
prefix + "/" + user +
"/WrongSign/2015/WorkSpaces/Merged_Merged_WS.root", "read")
wsp = ws_file.Get("wspace")
ws_file.Close()
LOG_D0_IPCHI2_OWNPV = wsp.var("LOG_D0_IPCHI2_OWNPV")
Dst_DTF_D0_CTAU = wsp.var("Dst_DTF_D0_CTAU")
Dst_DTF_D0_M = wsp.var("Dst_DTF_D0_M")
DTF_D0sPi_M = wsp.var("DTF_D0sPi_M")
DTF_D0sPi_M.setMax(2020)
DTF_D0sPi_M.setMin(2000)
dataset_RS_tot = wsp.data("dataset_RS")
dataset_RS_tot.SetName("dataset_RS_tot")
varset = RooArgSet("varset")
varset.add(LOG_D0_IPCHI2_OWNPV)
varset.add(DTF_D0sPi_M)
varset.add(Dst_DTF_D0_CTAU)
varset.add(Dst_DTF_D0_M)
for i, bin in enumerate(decaytime_binnning):
start = datetime.now()
dataset_RS_dtb_init = RooDataSet(
"dataset_RS_dtb_init", "Decaytime bin" + str(i), dataset_RS_tot,
varset, "Dst_DTF_D0_CTAU>" + str(bin[0] * ctau) +
"&&Dst_DTF_D0_CTAU<" + str(bin[1] * ctau) + "&&" + offline_cut)
dataset_RS = Subtract_Distribution(dataset_RS_dtb_init, DTF_D0sPi_M,
LOG_D0_IPCHI2_OWNPV, str(i))
dataset_RS.SetName("dataset_RS")
wspace = RooWorkspace("wspace")
wsfile2 = TFile(
"~/eos/lhcb/user/" + prefix + "/" + user +
"/WrongSign/2015/WorkSpaces/Merged_WS_Bin_" + str(i) + ".root",
"recreate")
wspace.rfimport(varset)
wspace.rfimport(dataset_RS)
wspace.Write("wspace")
wsfile2.Close()
print "Dataset " + str(i) + " creation took " + str(datetime.now() -
start) + " \n"
return True
def createDataSet(self, dname, dcut):
"""Return named dataset, create if not exist"""
if dname in self.dataset.keys() and not self.process.cfg['args'].force:
self.logger.logINFO("\033[0;34;47m Dataset: ", dname,
" Already Exists! \033[0m. Total Entries:",
self.dataset[dname].sumEntries())
self.logger.logDEBUG(dcut, Stamp=False)
return 1
tempfile_preload = ROOT.TFile(tempfile.gettempdir() + "/temp.root",
'RECREATE') #Pritam
RooCut = ROOT.RooFit.Cut(dcut)
Import = ROOT.RooFit.Import(self.ch)
Range = ROOT.RooFit.CutRange(
dname.split(".")[2]) # Not taking effect, need review
Weight = ROOT.RooFit.WeightVar(self.cfg['weight'])
if self.argset.find("Bmass"):
self.argset.find(
"Bmass").removeRange() # Analysis specific line introduced
if "dataReader" in dname or "sigMCGENReader" in dname:
data = RooDataSet(dname, "", self.argset, Import, RooCut, Range)
else:
data = RooDataSet(dname, "Weighted dataset", self.argset, Import,
RooCut, Range, Weight)
if self.argset.find("Phimass"):
self.argset.find("Phimass").setBins(20)
datahist = ROOT.RooDataHist(
dname + ".hist", "",
ROOT.RooArgSet(self.argset.find("Phimass")), data)
self.dataset[dname + ".hist"] = deepcopy(datahist)
data.Write()
self.dataset[dname] = deepcopy(data)
self.logger.logINFO("\033[0;34;47m Creating Dataset: ", dname,
": \033[0m. Total Entries:", data.sumEntries())
self.logger.logDEBUG(dcut, Stamp=False)
tempfile_preload.Close() #Pritam
return 1
pvz_pdf = Pdf(Name = 'pvz_pdf', Type = Gaussian, Parameters = (pvz, pvz_mean, pvz_sigma))
from ROOT import TFile
pv_file = TFile("/stuff/PhD/p2vv/data/pv_data.root")
pv_data = pv_file.Get("pv_data")
tp_gen = TPGen('tp_gen', TurningPoints = tps, PVZ = pvz, PVZPdf = pvz_pdf,
nPVs = pv_data.get().find('nPVs'), Data = pv_data)
tp_gen.setDistance(2)
tp_gen.setSmearing(3)
tp_gen.setDebug(options.debug)
## tp_decay = TPDecay('tp_decay', TPGen = tp_gen, Time = t, Tau = tau, ResolutionModel = tres)
from ROOT import RooDataSet, RooPullVar
tau_result = RealVar("tau_result", MinMax = (0.1, 4))
result_data = RooDataSet("result_data", "result_data", RooArgSet(tau_result))
# Make a dummy histogram to
fitOpts = dict(NumCPU = 1, Timer = 1, Save = True, Minimizer = 'Minuit2', Optimize = 2,
Offset = True, Strategy = 2)
from ROOT import RooDecay
if swimming:
sig_t = Pdf(Name = 'sig_t', Type = RooDecay, Parameters = (t, tau, tres, 'SingleSided'))
sig_t.setNormRange(','.join(b for b in binnings))
else:
# Make an exponential binning
def next_bin(prev_bin, tau, n_bins, min_bin, max_bin):
from math import e, log
a = e ** (- min_bin / tau) - e ** (- max_bin / tau)
return - tau * log(e ** (- prev_bin / tau) - a / n_bins)
print 'P2VV - INFO: generateFromFile(): prototype data:'
protoData.Print()
# read input data
inputFile = TFile.Open(args.inputFile)
assert inputFile
inNTuples = dict( [ ( state, ( inputFile.Get( '%s_%s' % ( args.inputNTupleName
, '_'.join( '%s%d' % ( cat, st ) for cat, st in zip( splitCats, state ) ) ) ), [ ] ) )\
for state in states ] )
print 'P2VV - INFO: generateFromFile(): numbers of input events:'
for state in states :
print ' %s: %7d' % ( state, inNTuples[state][0].GetEntries() )
# create output dataset
from ROOT import RooDataSet
outputData = RooDataSet( args.protoDataName, args.protoDataName, protoSet )
# draw events from input datasets and combine with proto data
import sys
import P2VV.RooFitWrappers
from ROOT import TRandom3
randGen = TRandom3(args.jobID)
for pEvIt, pSet in enumerate(protoData) :
if pEvIt % 10000 == 0 :
print 'P2VV - INFO: generateFromFile(): processing event %d' % pEvIt
sys.stdout.flush()
# get state of conditional observables in proto data
state = [ ]
for cat in splitCats :
if splitPars[cat][0] == 'cat' :
def run(self, **kwargs):
from ROOT import RooArgSet
__check_req_kw__("Observables", kwargs)
__check_req_kw__("Pdf", kwargs)
__check_req_kw__("Sigmat", kwargs)
__check_req_kw__("Time", kwargs)
__check_req_kw__("SigmaGen", kwargs)
sigma_gen = kwargs.pop("SigmaGen")
observables = kwargs.pop("Observables")
obs_set = RooArgSet(*observables)
pdf = kwargs.pop("Pdf")
sigmat = kwargs.pop("Sigmat")
time = kwargs.pop("Time")
gen_obs_set = RooArgSet(*observables)
# Make another ArgSet to put the fit results in
result_params = RooArgSet("result_params")
from P2VV.RooFitWrappers import RealVar
da = RealVar("da", Observable=True, MinMax=(0.01, 1.1))
dft = RealVar("dft", Observable=True, MinMax=(0.01, 1.1))
result_params.add(da._target_())
result_params.add(dft._target_())
transform = self.transform()
if transform:
trans_params = transform.gen_params(gen_obs_set)
self._gen_params.extend(trans_params)
for p in trans_params:
result_params.add(p)
# Some extra numbers of interest
from ROOT import RooRealVar
seed = RooRealVar("seed", "random seed", 0.0)
result_params.add(seed)
# The dataset to store the results
from ROOT import RooDataSet
self._data = RooDataSet("result_data", "result_data", result_params)
data_params = self._data.get()
from ROOT import RooRandom
import struct, os
# Reset pdf parameters to initial values. Note: this does not reset the estimated errors...
args = dict(NumEvents=self.options().nevents)
if "ProtoData" in kwargs:
args["ProtoData"] = kwargs.pop("ProtoData")
spec = pdf.prepareMultiGen(obs_set, **args)
while self._data.numEntries() < self.options().ntoys:
# Get a good random seed, set it and store it
s = struct.unpack("I", os.urandom(4))[0]
RooRandom.randomGenerator().SetSeed(s)
seed.setVal(s)
data = pdf.generate(spec)
if self.transform():
old_data = data
data = self.transform()(old_data)
if not data:
transform.set_params(data_params)
self._data.add(data_params)
continue
from P2VV import Dilution
d_ft = Dilution.dilution_ft(data, time, t_range=2, quiet=True)
d_a = Dilution.signal_dilution_dg(data, sigmat, *sigma_gen)
da.setVal(d_a[0])
da.setError(d_a[1] if d_a[1] != None else 0.0)
dft.setVal(d_ft[0])
dft.setError(d_ft[1] if d_ft[1] != None else 0.0)
if transform:
transform.set_params(data_params)
self._data.add(result_params)
return self.data()
def makeRooDataSet(type,infile_name,outfile_name,tree_name,nevents):
""" Make RooDataSets from TTrees"""
inputfile = TFile.Open(infile_name,"READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(tree_name, tree) #get the tree from the data file
#define variables for the RooDataSet
m_mumu = RooRealVar("m_mumu", "m_mumu", 0.0, 4.0)
y_mumu = RooRealVar("y_mumu", "y_mumu", 0.0, 2.0 )
pt_mumu = RooRealVar("pt_mumu", "pt_mumu", 0.0, 260.0)
eta_gamma = RooRealVar("eta_gamma","eta_gamma",-3.5, 3.5)
pt_gamma = RooRealVar("pt_gamma", "pt_gamma", 0.0, 100.0)
m_gamma = RooRealVar("m_gamma", "m_gamma", -0.1,0.1)
m_chi_rf1S = RooRealVar("m_chi_rf1S", "m_chi_rf1S", 0.0, 7.0)
m_chi_rf2S = RooRealVar("m_chi_rf2S", "m_chi_rf2S", -1.0, 1.0)
Qvalue = RooRealVar("Qvalue","Q", -15., 15.)
ctpv = RooRealVar("ctpv","ctpv", -1.0, 3.5)
ctpv_error = RooRealVar("ctpv_err","ctpv_err", -1.0, 1.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass","pi0_abs_mass", 0.0, 2.2)
psi1S_nsigma = RooRealVar("psi1S_nsigma","psi1S_nsigma",0.0,1.0)
psi2S_nsigma = RooRealVar("psi2S_nsigma","psi2S_nsigma",0.0,1.0)
psi3S_nsigma = RooRealVar("psi3S_nsigma","psi3S_nsigma",0.0,1.0)
rho_conv = RooRealVar("rho_conv", "rho_conv", 0.0, 70.0)
dz = RooRealVar("dz","dz", -1.0, 1.0)
probFit1S = RooRealVar('probFit1S','probFit1S',0,1)
probFit2S = RooRealVar('probFit2S','probFit2S',0,1)
probFit3S = RooRealVar('probFit3S','probFit3S',0,1)
dataArgSet = RooArgSet(m_mumu,
y_mumu,
pt_mumu,
eta_gamma,
pt_gamma,
m_gamma,
m_chi_rf1S)
dataArgSet.add( m_chi_rf2S )
dataArgSet.add( Qvalue )
dataArgSet.add( ctpv )
dataArgSet.add( ctpv_error )
dataArgSet.add( pi0_abs_mass )
dataArgSet.add( psi1S_nsigma )
dataArgSet.add( psi2S_nsigma )
dataArgSet.add( psi3S_nsigma )
dataArgSet.add( rho_conv )
dataArgSet.add( dz )
dataArgSet.add( probFit1S)
dataArgSet.add( probFit2S)
dataArgSet.add( probFit3S)
print "Creating DataSet"
dataSet = RooDataSet("chicds","Chic RooDataSet", dataArgSet)
entries = tree.GetEntries()
print entries
if nevents is not 0:
entries = nevents
for ientry in range(0,entries):
tree.GetEntry(ientry)
# unfort ntuples are slightly different for chic and chib
if applyscale:
if usekinfit :
spatial = tree.rf3S_photon_p4.Vect()
#spatial = tree.photon_p4.Vect()
spatial *= (1/escale)
corr_photon_p4=TLorentzVector()
#corr_photon_p4.SetVectM(spatial,tree.rf1S_photon_p4.M())
corr_photon_p4.SetVectM(spatial,0)
corr_chi_p4 = tree.rf3S_dimuon_p4 + corr_photon_p4
else:
spatial = tree.photon_p4.Vect()
spatial *= (1/escale)
corr_photon_p4=TLorentzVector()
corr_photon_p4.SetVectM(spatial,tree.photon_p4.M())
corr_chi_p4 = tree.dimuon_p4 + corr_photon_p4
else :
corr_chi_p4 = tree.chi_p4
if type == 'chic':
m_mumu.setVal(tree.dimuon_p4.M())
y_mumu.setVal(tree.dimuon_p4.Rapidity())
pt_mumu.setVal(tree.dimuon_p4.Pt())
eta_gamma.setVal(tree.photon_p4.Eta())
pt_gamma.setVal(tree.photon_p4.Pt())
m_gamma.setVal(tree.photon_p4.M())
m_chi_rf1S.setVal(tree.rf1S_chi_p4.M())
m_chi_rf2S.setVal(tree.rf2S_chi_p4.M())
if usekinfit : Qvalue.setVal(corr_chi_p4.M())
else: Qvalue.setVal((corr_chi_p4).M() - tree.dimuon_p4.M())
#Qvalue.setVal((tree.chi_p4).M()**2 - tree.dimuon_p4.M()**2)
psi1S_nsigma.setVal(tree.psi1S_nsigma)
psi2S_nsigma.setVal(tree.psi2S_nsigma)
psi3S_nsigma.setVal(0)
elif type == 'chib':
m_mumu.setVal(tree.dimuon_p4.M())
y_mumu.setVal(tree.dimuon_p4.Rapidity())
pt_mumu.setVal(tree.dimuon_p4.Pt())
eta_gamma.setVal(tree.photon_p4.Eta())
pt_gamma.setVal(tree.photon_p4.Pt())
m_chi_rf1S.setVal(tree.rf1S_chi_p4.M())
m_chi_rf2S.setVal(tree.rf2S_chi_p4.M())
if usekinfit : Qvalue.setVal(corr_chi_p4.M())
#if usekinfit : Qvalue.setVal(tree.rf3S_chi_p4.M()) #uncorrected
else: Qvalue.setVal(corr_chi_p4.M() - tree.dimuon_p4.M())
psi1S_nsigma.setVal(tree.Y1S_nsigma)
psi2S_nsigma.setVal(tree.Y2S_nsigma)
psi3S_nsigma.setVal(tree.Y3S_nsigma)
ctpv.setVal(tree.ctpv)
ctpv_error.setVal(tree.ctpv_error)
pi0_abs_mass.setVal(tree.pi0_abs_mass)
rho_conv.setVal(tree.conv_vertex)
dz.setVal(tree.dz)
probFit1S.setVal(tree.probFit1S)
probFit2S.setVal(tree.probFit2S)
probFit3S.setVal(tree.probFit3S)
if selectchi1:
if ( tree.chic_pdgId == 20443): dataSet.add(dataArgSet)
else :
dataSet.add(dataArgSet)
outfile = TFile(outfile_name,'recreate')
dataSet.Write()
dataset.SetNameTitle(name_title, name_title)
print '%s is weighted: %s' % (dataset.GetName(), dataset.isWeighted())
dsetlist += [dataset]
decaycat = RooCategory('decaycat', 'Decay mode category')
decaycat.defineType('DsPi')
decaycat.defineType('DsK')
varlist += [decaycat]
for idx, mode in enumerate(['DsPi', 'DsK']):
decaycat.setLabel(mode)
dsetlist[idx].addColumn(decaycat)
dataset = RooDataSet('dataset', 'Combined dataset (DsK + DsPi)',
RooArgSet(time, decaycat),
RooFit.Import(dsetlist[0]))
dataset.append(dsetlist[1])
for dset in dsetlist:
dset.Print()
dataset.Print()
## Basic B decay pdf with time resolution
# Resolution model
mean = RooRealVar('mean', 'Mean', 0.)
# scale = RooRealVar('scale', 'Per-event time error scale factor', 1.19)
resmodel = RooGaussModel('resmodel', 'Time resolution model', time,
mean, RooRealConstant.value(0.044),
RooRealConstant.value(1.0),
RooRealConstant.value(1.0))
# DAS_EX_2.1
# Define a RooRealVar object for the ST variable
st = RooRealVar("st", "st", ranges["fit","lo"], ranges["fit","hi"])
############################################
# Get data and models
############################################
#
print "Reading Files"
# DAS_EX_2.2
# Read data from file into RooDataSet using the RooDataSet.read() method.
#rdata = RooDataSet.add(files["dat"], RooArgList(st))
rdata = RooDataSet.read(files["dat"], RooArgList(st))
###################################
# Set up fit PDFs with information
# from fitFuncs dictionary
###################################
# Declare a few dictionaries
pdfs = {}; pars = {}; aset = {}
for func in ["f2", "f1", "f3"]:
# DAS_EX_2.3
# Define and initialize (with your ST RooRealVar) a RooArgSet for use in the pdf
# We need one RooArgSet for each function, so store in python dictionary indexed
# by "func" string:
def setupWorkspace(ws,options):
cfg = options.config #for convenience
fit_sections = cfg.sections()
fit_sections.remove('Global') #don't need to iterate over the global configuration
if not isinstance(ws,RooWorkspace):
print "You didn't pass a RooWorkspace!"
exit(1)
cpling_type = cfg.get('Global','couplingType')
par1 = cfg.get('Global','par1Name')
par1bound = [-cfg.getfloat('Global','par1Max'),
cfg.getfloat('Global','par1Max')]
par2 = cfg.get('Global','par2Name')
par2bound = [-cfg.getfloat('Global','par2Max'),
cfg.getfloat('Global','par2Max')]
#create the parameters in the workspace
ws.factory('%s_%s[0,%f,%f]'%(par1,cpling_type,par1bound[0],par1bound[1]))
ws.factory('%s_%s[0,%f,%f]'%(par2,cpling_type,par2bound[0],par2bound[1]))
# since the lumi error is correlated among all channels we only need one penalty term for it
lumi_err = exp(options.config.getfloat('Global','lumi_err')) # exp because we use log normal
ws.factory('luminosityError[%f]'%lumi_err)
ws.factory('RooLognormal::lumiErr(err_gl[1,0.0001,50],1,luminosityError)')
channel_cat = RooCategory('channels','channels')
#first pass: process the backgrounds, signal and data into
# simultaneous counting pdfs over the bins
for section in fit_sections:
#create the basic observable, this is used behind the scenes
#in the background and signal models
channel_cat.defineType(section)
channel_cat.setLabel(section)
print 'Building pdf for configuration section:',section
for it,bkg in getBackgroundsInCfg(section,cfg).iteritems():
ws.factory('backgroundError_%s_%s[%f]'%(section,it,exp(bkg[1])))
ws.factory('selectionError_%s[%f]'%(section,exp(cfg.getfloat(section,'selection_err'))))
processFittingData(ws,cfg,section)
processSignalModel(ws,cfg,section)
processBackgroundModel(ws,cfg,section)
createPdfForChannel(ws,cfg,section)
ws.data('countingdata_%s'%section).addColumn(channel_cat)
getattr(ws,'import')(channel_cat)
top = RooSimultaneous('TopLevelPdf',
'TopLevelPdf',
ws.cat('channels'))
alldatavars = RooArgSet(ws.cat('channels'))
conditionals = RooArgSet()
#second pass: process counting pdfs into simultaneous pdf over channels
for section in fit_sections:
top.addPdf(ws.pdf('countingpdf_%s'%section),section)
alldatavars.add(ws.var('%s_%s'%(cfg.get(section,'obsVar'),section)))
conditionals.add(ws.var('%s_%s'%(cfg.get(section,'obsVar'),section)))
alldatavars.add(ws.var('n_observed_%s'%section))
getattr(ws,'import')(top)
ws.defineSet('condObs',conditionals)
allcountingdata = RooDataSet('allcountingdata',
'allcountingdata',
alldatavars)
getattr(ws,'import')(allcountingdata)
allcountingdata = ws.data('allcountingdata')
#third pass: make the final combined dataset
for section in fit_sections:
current = ws.data('countingdata_%s'%section)
print 'countingdata_%s has %d entries'%(section,current.numEntries())
for i in range(current.numEntries()):
alldatavars = current.get(i)
allcountingdata.add(alldatavars)
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
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]
sig_data = RooDataSet('sig_data', 'sig_data', RooArgSet(momentum, weight, runPeriod),
RooFit.Import(sig_tree), RooFit.WeightVar(weight),
RooFit.Cut('runPeriod == runPeriod::%s' % period))
from ROOT import TFile
prompt_file = TFile(input_data['cache'])
prompt_data = prompt_file.Get(input_data['dataset'])
from ROOT import TCanvas
canvas = TCanvas('momentum_canvas', 'momentum_canvas', 600, 400)
canvas.SetLogy()
frame = momentum.frame(Range = (0, 500000))
from ROOT import kBlue, kGreen
sig_data.plotOn(frame, Rescale = (1 / sig_data.sumEntries()), MarkerColor = kBlue)
prompt_data.plotOn(frame, Rescale = (1 / prompt_data.sumEntries()), MarkerColor = kGreen)
frame.GetXaxis().SetTitle("P_{B} [MeV]")
obsSet.add(wVar)
import os, subprocess, tempfile
tmp = tempfile.NamedTemporaryFile()
tmpFileName = os.path.realpath(tmp.name)
tmp.close()
from ROOT import RooDataSet, TObject, gROOT
nEvTot = 0
nEvDS = nTupleIn.GetEntries() / numDataSets
for it in range(numDataSets) :
startEv = it * nEvDS
nEv = nEvDS if it < numDataSets - 1 else nTupleIn.GetEntries() - ( numDataSets - 1 ) * nEvDS
tmpFile = TFile.Open( tmpFileName, 'RECREATE' )
nTupleSplit = nTupleIn.CopyTree( selection, '', nEv, startEv )
if weightName :
dataOut = RooDataSet( protoData.GetName(), protoData.GetTitle(), obsSet, Import = nTupleSplit, WeightVar = ( weightName, True ) )
else :
dataOut = RooDataSet( protoData.GetName(), protoData.GetTitle(), obsSet, Import = nTupleSplit )
tmpFile.Close()
print 'produced dataset:'
dataOut.Print()
nEvTot += dataOut.numEntries()
dataFileOut = TFile.Open( dataFilePathOut % it, 'RECREATE' )
dataFileOut.Append(dataOut)
dataFileOut.Write( dataFilePathOut % it, TObject.kOverwrite )
dataFileOut.Close()
os.remove(tmpFileName)
print 'total number of events: %d' % nEvTot
def signal(channel, stype):
if 'VBF' in channel:
stype = 'XZHVBF'
else:
stype = 'XZH'
# HVT model
if stype.startswith('X'):
signalType = 'HVT'
genPoints = [800, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500, 4000, 4500, 5000]
massPoints = [x for x in range(800, 5000+1, 100)]
interPar = True
else:
print "Signal type", stype, "not recognized"
return
n = len(genPoints)
category = channel
cColor = color[category] if category in color else 1
nElec = channel.count('e')
nMuon = channel.count('m')
nLept = nElec + nMuon
nBtag = channel.count('b')
if '0b' in channel:
nBtag = 0
X_name = "VH_mass"
if not os.path.exists(PLOTDIR+stype+category): os.makedirs(PLOTDIR+stype+category)
#*******************************************************#
# #
# Variables and selections #
# #
#*******************************************************#
X_mass = RooRealVar( "X_mass", "m_{ZH}", XBINMIN, XBINMAX, "GeV")
J_mass = RooRealVar( "H_mass", "jet mass", LOWMIN, HIGMAX, "GeV")
V_mass = RooRealVar( "V_mass", "V jet mass", -9., 1.e6, "GeV")
CSV1 = RooRealVar( "H_csv1", "", -999., 2. )
CSV2 = RooRealVar( "H_csv2", "", -999., 2. )
DeepCSV1= RooRealVar( "H_deepcsv1", "", -999., 2. )
DeepCSV2= RooRealVar( "H_deepcsv2", "", -999., 2. )
H_ntag = RooRealVar( "H_ntag", "", -9., 9. )
H_dbt = RooRealVar( "H_dbt", "", -2., 2. )
H_tau21 = RooRealVar( "H_tau21", "", -9., 2. )
H_eta = RooRealVar( "H_eta", "", -9., 9. )
H_tau21_ddt = RooRealVar( "H_ddt", "", -9., 2. )
MaxBTag = RooRealVar( "MaxBTag", "", -10., 2. )
H_chf = RooRealVar( "H_chf", "", -1., 2. )
MinDPhi = RooRealVar( "MinDPhi", "", -1., 99. )
DPhi = RooRealVar( "DPhi", "", -1., 99. )
DEta = RooRealVar( "DEta", "", -1., 99. )
Mu1_relIso = RooRealVar( "Mu1_relIso", "", -1., 99. )
Mu2_relIso = RooRealVar( "Mu2_relIso", "", -1., 99. )
nTaus = RooRealVar( "nTaus", "", -1., 99. )
Vpt = RooRealVar( "V.Pt()", "", -1., 1.e6 )
V_pt = RooRealVar( "V_pt", "", -1., 1.e6 )
H_pt = RooRealVar( "H_pt", "", -1., 1.e6 )
VH_deltaR=RooRealVar( "VH_deltaR", "", -1., 99. )
isZtoNN = RooRealVar( "isZtoNN", "", 0., 2. )
isZtoEE = RooRealVar( "isZtoEE", "", 0., 2. )
isZtoMM = RooRealVar( "isZtoMM", "", 0., 2. )
isHtobb = RooRealVar( "isHtobb", "", 0., 2. )
isVBF = RooRealVar( "isVBF", "", 0., 2. )
isMaxBTag_loose = RooRealVar( "isMaxBTag_loose", "", 0., 2. )
weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1.e9 )
Xmin = XBINMIN
Xmax = XBINMAX
# Define the RooArgSet which will include all the variables defined before
# there is a maximum of 9 variables in the declaration, so the others need to be added with 'add'
variables = RooArgSet(X_mass, J_mass, V_mass, CSV1, CSV2, H_ntag, H_dbt, H_tau21)
variables.add(RooArgSet(DEta, DPhi, MaxBTag, MinDPhi, nTaus, Vpt))
variables.add(RooArgSet(DeepCSV1, DeepCSV2,VH_deltaR, H_tau21_ddt))
variables.add(RooArgSet(isZtoNN, isZtoEE, isZtoMM, isHtobb, isMaxBTag_loose, weight))
variables.add(RooArgSet(isVBF, Mu1_relIso, Mu2_relIso, H_chf, H_pt, V_pt,H_eta))
#X_mass.setRange("X_extended_range", X_mass.getMin(), X_mass.getMax())
X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax())
X_mass.setRange("X_integration_range", Xmin, Xmax)
X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/100))
binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax())
X_mass.setBinning(binsXmass, "PLOT")
massArg = RooArgSet(X_mass)
# Cuts
SRcut = selection[category]+selection['SR']
print " Cut:\t", SRcut
#*******************************************************#
# #
# Signal fits #
# #
#*******************************************************#
treeSign = {}
setSignal = {}
vmean = {}
vsigma = {}
valpha1 = {}
vslope1 = {}
smean = {}
ssigma = {}
salpha1 = {}
sslope1 = {}
salpha2 = {}
sslope2 = {}
a1 = {}
a2 = {}
sbrwig = {}
signal = {}
signalExt = {}
signalYield = {}
signalIntegral = {}
signalNorm = {}
signalXS = {}
frSignal = {}
frSignal1 = {}
frSignal2 = {}
frSignal3 = {}
# Signal shape uncertainties (common amongst all mass points)
xmean_fit = RooRealVar("sig_p1_fit", "Variation of the resonance position with the fit uncertainty", 0.005, -1., 1.)
smean_fit = RooRealVar("CMSRunII_sig_p1_fit", "Change of the resonance position with the fit uncertainty", 0., -10, 10)
xmean_jes = RooRealVar("sig_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.010, -1., 1.) #0.001
smean_jes = RooRealVar("CMSRunII_sig_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10)
xmean_e = RooRealVar("sig_p1_scale_e", "Variation of the resonance position with the electron energy scale", 0.001, -1., 1.)
smean_e = RooRealVar("CMSRunII_sig_p1_scale_e", "Change of the resonance position with the electron energy scale", 0., -10, 10)
xmean_m = RooRealVar("sig_p1_scale_m", "Variation of the resonance position with the muon energy scale", 0.001, -1., 1.)
smean_m = RooRealVar("CMSRunII_sig_p1_scale_m", "Change of the resonance position with the muon energy scale", 0., -10, 10)
xsigma_fit = RooRealVar("sig_p2_fit", "Variation of the resonance width with the fit uncertainty", 0.02, -1., 1.)
ssigma_fit = RooRealVar("CMSRunII_sig_p2_fit", "Change of the resonance width with the fit uncertainty", 0., -10, 10)
xsigma_jes = RooRealVar("sig_p2_scale_jes", "Variation of the resonance width with the jet energy scale", 0.010, -1., 1.) #0.001
ssigma_jes = RooRealVar("CMSRunII_sig_p2_jes", "Change of the resonance width with the jet energy scale", 0., -10, 10)
xsigma_jer = RooRealVar("sig_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.020, -1., 1.)
ssigma_jer = RooRealVar("CMSRunII_sig_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10)
xsigma_e = RooRealVar("sig_p2_scale_e", "Variation of the resonance width with the electron energy scale", 0.001, -1., 1.)
ssigma_e = RooRealVar("CMSRunII_sig_p2_scale_e", "Change of the resonance width with the electron energy scale", 0., -10, 10)
xsigma_m = RooRealVar("sig_p2_scale_m", "Variation of the resonance width with the muon energy scale", 0.040, -1., 1.)
ssigma_m = RooRealVar("CMSRunII_sig_p2_scale_m", "Change of the resonance width with the muon energy scale", 0., -10, 10)
xalpha1_fit = RooRealVar("sig_p3_fit", "Variation of the resonance alpha with the fit uncertainty", 0.03, -1., 1.)
salpha1_fit = RooRealVar("CMSRunII_sig_p3_fit", "Change of the resonance alpha with the fit uncertainty", 0., -10, 10)
xslope1_fit = RooRealVar("sig_p4_fit", "Variation of the resonance slope with the fit uncertainty", 0.10, -1., 1.)
sslope1_fit = RooRealVar("CMSRunII_sig_p4_fit", "Change of the resonance slope with the fit uncertainty", 0., -10, 10)
xmean_fit.setConstant(True)
smean_fit.setConstant(True)
xmean_jes.setConstant(True)
smean_jes.setConstant(True)
xmean_e.setConstant(True)
smean_e.setConstant(True)
xmean_m.setConstant(True)
smean_m.setConstant(True)
xsigma_fit.setConstant(True)
ssigma_fit.setConstant(True)
xsigma_jes.setConstant(True)
ssigma_jes.setConstant(True)
xsigma_jer.setConstant(True)
ssigma_jer.setConstant(True)
xsigma_e.setConstant(True)
ssigma_e.setConstant(True)
xsigma_m.setConstant(True)
ssigma_m.setConstant(True)
xalpha1_fit.setConstant(True)
salpha1_fit.setConstant(True)
xslope1_fit.setConstant(True)
sslope1_fit.setConstant(True)
# the alpha method is now done.
for m in massPoints:
signalString = "M%d" % m
signalMass = "%s_M%d" % (stype, m)
signalName = "%s%s_M%d" % (stype, category, m)
signalColor = sample[signalMass]['linecolor'] if signalName in sample else 1
# define the signal PDF
vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m*0.5, m*1.25)
smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)", RooArgList(vmean[m], xmean_e, smean_e, xmean_m, smean_m, xmean_jes, smean_jes, xmean_fit, smean_fit))
vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m*0.035, m*0.01, m*0.4)
sigmaList = RooArgList(vsigma[m], xsigma_e, ssigma_e, xsigma_m, ssigma_m, xsigma_jes, ssigma_jes, xsigma_jer, ssigma_jer)
sigmaList.add(RooArgList(xsigma_fit, ssigma_fit))
ssigma[m] = RooFormulaVar(signalName + "_sigma", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)*(1+@9*@10)", sigmaList)
valpha1[m] = RooRealVar(signalName + "_valpha1", "Crystal Ball alpha", 1., 0., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right
salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0*(1+@1*@2)", RooArgList(valpha1[m], xalpha1_fit, salpha1_fit))
vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope", 10., 1., 60.) # slope of the power tail #10 1 60
sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0*(1+@1*@2)", RooArgList(vslope1[m], xslope1_fit, sslope1_fit))
salpha2[m] = RooRealVar(signalName + "_alpha2", "Crystal Ball alpha", 2, 1., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right
sslope2[m] = RooRealVar(signalName + "_slope2", "Crystal Ball slope", 10, 1.e-1, 115.) # slope of the power tail
#define polynomial
#a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", m, 0.5*m, 2*m)
a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", 0.001*m, 0.0005*m, 0.01*m)
a2[m] = RooRealVar(signalName + "_a2", "par 2 for polynomial", 0.05, -1.,1.)
#if channel=='nnbbVBF' or channel=='nn0bVBF':
# signal[m] = RooPolynomial(signalName,"m_{%s'} = %d GeV" % (stype[1], m) , X_mass, RooArgList(a1[m],a2[m]))
#else:
# signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel
signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel
# extend the PDF with the yield to perform an extended likelihood fit
signalYield[m] = RooRealVar(signalName+"_yield", "signalYield", 100, 0., 1.e6)
signalNorm[m] = RooRealVar(signalName+"_norm", "signalNorm", 1., 0., 1.e6)
signalXS[m] = RooRealVar(signalName+"_xs", "signalXS", 1., 0., 1.e6)
signalExt[m] = RooExtendPdf(signalName+"_ext", "extended p.d.f", signal[m], signalYield[m])
vslope1[m].setMax(50.)
vslope1[m].setVal(20.)
#valpha1[m].setVal(1.0)
#valpha1[m].setConstant(True)
if 'bb' in channel and 'VBF' not in channel:
if 'nn' in channel:
valpha1[m].setVal(0.5)
elif '0b' in channel and 'VBF' not in channel:
if 'nn' in channel:
if m==800:
valpha1[m].setVal(2.)
vsigma[m].setVal(m*0.04)
elif 'ee' in channel:
valpha1[m].setVal(0.8)
if m==800:
#valpha1[m].setVal(1.2)
valpha1[m].setVal(2.5)
vslope1[m].setVal(50.)
elif 'mm' in channel:
if m==800:
valpha1[m].setVal(2.)
vsigma[m].setVal(m*0.03)
else:
vmean[m].setVal(m*0.9)
vsigma[m].setVal(m*0.08)
elif 'bb' in channel and 'VBF' in channel:
if 'nn' in channel:
if m!=1800:
vmean[m].setVal(m*0.8)
vsigma[m].setVal(m*0.08)
valpha1[m].setMin(1.)
elif 'ee' in channel:
valpha1[m].setVal(0.7)
elif 'mm' in channel:
if m==800:
vslope1[m].setVal(50.)
valpha1[m].setVal(0.7)
elif '0b' in channel and 'VBF' in channel:
if 'nn' in channel:
valpha1[m].setVal(3.)
vmean[m].setVal(m*0.8)
vsigma[m].setVal(m*0.08)
valpha1[m].setMin(1.)
elif 'ee' in channel:
if m<2500:
valpha1[m].setVal(2.)
if m==800:
vsigma[m].setVal(m*0.05)
elif m==1000:
vsigma[m].setVal(m*0.03)
elif m>1000 and m<1800:
vsigma[m].setVal(m*0.04)
elif 'mm' in channel:
if m<2000:
valpha1[m].setVal(2.)
if m==1000 or m==1800:
vsigma[m].setVal(m*0.03)
elif m==1200 or m==1600:
vsigma[m].setVal(m*0.04)
#if m < 1000: vsigma[m].setVal(m*0.06)
# If it's not the proper channel, make it a gaussian
#if nLept==0 and 'VBF' in channel:
# valpha1[m].setVal(5)
# valpha1[m].setConstant(True)
# vslope1[m].setConstant(True)
# salpha2[m].setConstant(True)
# sslope2[m].setConstant(True)
# ---------- if there is no simulated signal, skip this mass point ----------
if m in genPoints:
if VERBOSE: print " - Mass point", m
# define the dataset for the signal applying the SR cuts
treeSign[m] = TChain("tree")
for j, ss in enumerate(sample[signalMass]['files']):
treeSign[m].Add(NTUPLEDIR + ss + ".root")
if treeSign[m].GetEntries() <= 0.:
if VERBOSE: print " - 0 events available for mass", m, "skipping mass point..."
signalNorm[m].setVal(-1)
vmean[m].setConstant(True)
vsigma[m].setConstant(True)
salpha1[m].setConstant(True)
sslope1[m].setConstant(True)
salpha2[m].setConstant(True)
sslope2[m].setConstant(True)
signalNorm[m].setConstant(True)
signalXS[m].setConstant(True)
continue
setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeSign[m]))
if VERBOSE: print " - Dataset with", setSignal[m].sumEntries(), "events loaded"
# FIT
signalYield[m].setVal(setSignal[m].sumEntries())
if treeSign[m].GetEntries(SRcut) > 5:
if VERBOSE: print " - Running fit"
frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1), RooFit.Extended(True), RooFit.SumW2Error(True), RooFit.PrintLevel(-1))
if VERBOSE: print "********** Fit result [", m, "] **", category, "*"*40, "\n", frSignal[m].Print(), "\n", "*"*80
if VERBOSE: frSignal[m].correlationMatrix().Print()
drawPlot(signalMass, stype+channel, X_mass, signal[m], setSignal[m], frSignal[m])
else:
print " WARNING: signal", stype, "and mass point", m, "in channel", channel, "has 0 entries or does not exist"
# Remove HVT cross section (which is the same for Zlep and Zinv)
if stype == "XZHVBF":
sample_name = 'Zprime_VBF_Zh_Zlephinc_narrow_M-%d' % m
else:
sample_name = 'ZprimeToZHToZlepHinc_narrow_M%d' % m
xs = xsection[sample_name]['xsec']
signalXS[m].setVal(xs * 1000.)
signalIntegral[m] = signalExt[m].createIntegral(massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range"))
boundaryFactor = signalIntegral[m].getVal()
if VERBOSE:
print " - Fit normalization vs integral:", signalYield[m].getVal(), "/", boundaryFactor, "events"
if channel=='nnbb' and m==5000:
signalNorm[m].setVal(2.5)
elif channel=='nn0b' and m==5000:
signalNorm[m].setVal(6.7)
else:
signalNorm[m].setVal( boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal()) # here normalize to sigma(X) x Br(X->VH) = 1 [fb]
a1[m].setConstant(True)
a2[m].setConstant(True)
vmean[m].setConstant(True)
vsigma[m].setConstant(True)
valpha1[m].setConstant(True)
vslope1[m].setConstant(True)
salpha2[m].setConstant(True)
sslope2[m].setConstant(True)
signalNorm[m].setConstant(True)
signalXS[m].setConstant(True)
#*******************************************************#
# #
# Signal interpolation #
# #
#*******************************************************#
# ====== CONTROL PLOT ======
c_signal = TCanvas("c_signal", "c_signal", 800, 600)
c_signal.cd()
frame_signal = X_mass.frame()
for m in genPoints[:-2]:
if m in signalExt.keys():
signal[m].plotOn(frame_signal, RooFit.LineColor(sample["%s_M%d" % (stype, m)]['linecolor']), RooFit.Normalization(signalNorm[m].getVal(), RooAbsReal.NumEvent), RooFit.Range("X_reasonable_range"))
frame_signal.GetXaxis().SetRangeUser(0, 6500)
frame_signal.Draw()
drawCMS(-1, YEAR, "Simulation")
drawAnalysis(channel)
drawRegion(channel)
c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.pdf")
c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.png")
#if VERBOSE: raw_input("Press Enter to continue...")
# ====== CONTROL PLOT ======
# Normalization
gnorm = TGraphErrors()
gnorm.SetTitle(";m_{X} (GeV);integral (GeV)")
gnorm.SetMarkerStyle(20)
gnorm.SetMarkerColor(1)
gnorm.SetMaximum(0)
inorm = TGraphErrors()
inorm.SetMarkerStyle(24)
fnorm = TF1("fnorm", "pol9", 800, 5000) #"pol5" if not channel=="XZHnnbb" else "pol6" #pol5*TMath::Floor(x-1800) + ([5]*x + [6]*x*x)*(1-TMath::Floor(x-1800))
fnorm.SetLineColor(920)
fnorm.SetLineStyle(7)
fnorm.SetFillColor(2)
fnorm.SetLineColor(cColor)
# Mean
gmean = TGraphErrors()
gmean.SetTitle(";m_{X} (GeV);gaussian mean (GeV)")
gmean.SetMarkerStyle(20)
gmean.SetMarkerColor(cColor)
gmean.SetLineColor(cColor)
imean = TGraphErrors()
imean.SetMarkerStyle(24)
fmean = TF1("fmean", "pol1", 0, 5000)
fmean.SetLineColor(2)
fmean.SetFillColor(2)
# Width
gsigma = TGraphErrors()
gsigma.SetTitle(";m_{X} (GeV);gaussian width (GeV)")
gsigma.SetMarkerStyle(20)
gsigma.SetMarkerColor(cColor)
gsigma.SetLineColor(cColor)
isigma = TGraphErrors()
isigma.SetMarkerStyle(24)
fsigma = TF1("fsigma", "pol1", 0, 5000)
fsigma.SetLineColor(2)
fsigma.SetFillColor(2)
# Alpha1
galpha1 = TGraphErrors()
galpha1.SetTitle(";m_{X} (GeV);crystal ball lower alpha")
galpha1.SetMarkerStyle(20)
galpha1.SetMarkerColor(cColor)
galpha1.SetLineColor(cColor)
ialpha1 = TGraphErrors()
ialpha1.SetMarkerStyle(24)
falpha1 = TF1("falpha", "pol0", 0, 5000)
falpha1.SetLineColor(2)
falpha1.SetFillColor(2)
# Slope1
gslope1 = TGraphErrors()
gslope1.SetTitle(";m_{X} (GeV);exponential lower slope (1/Gev)")
gslope1.SetMarkerStyle(20)
gslope1.SetMarkerColor(cColor)
gslope1.SetLineColor(cColor)
islope1 = TGraphErrors()
islope1.SetMarkerStyle(24)
fslope1 = TF1("fslope", "pol0", 0, 5000)
fslope1.SetLineColor(2)
fslope1.SetFillColor(2)
# Alpha2
galpha2 = TGraphErrors()
galpha2.SetTitle(";m_{X} (GeV);crystal ball upper alpha")
galpha2.SetMarkerStyle(20)
galpha2.SetMarkerColor(cColor)
galpha2.SetLineColor(cColor)
ialpha2 = TGraphErrors()
ialpha2.SetMarkerStyle(24)
falpha2 = TF1("falpha", "pol0", 0, 5000)
falpha2.SetLineColor(2)
falpha2.SetFillColor(2)
# Slope2
gslope2 = TGraphErrors()
gslope2.SetTitle(";m_{X} (GeV);exponential upper slope (1/Gev)")
gslope2.SetMarkerStyle(20)
gslope2.SetMarkerColor(cColor)
gslope2.SetLineColor(cColor)
islope2 = TGraphErrors()
islope2.SetMarkerStyle(24)
fslope2 = TF1("fslope", "pol0", 0, 5000)
fslope2.SetLineColor(2)
fslope2.SetFillColor(2)
n = 0
for i, m in enumerate(genPoints):
if not m in signalNorm.keys(): continue
if signalNorm[m].getVal() < 1.e-6: continue
signalString = "M%d" % m
signalName = "%s_M%d" % (stype, m)
if gnorm.GetMaximum() < signalNorm[m].getVal(): gnorm.SetMaximum(signalNorm[m].getVal())
gnorm.SetPoint(n, m, signalNorm[m].getVal())
gmean.SetPoint(n, m, vmean[m].getVal())
gmean.SetPointError(n, 0, min(vmean[m].getError(), vmean[m].getVal()*0.02))
gsigma.SetPoint(n, m, vsigma[m].getVal())
gsigma.SetPointError(n, 0, min(vsigma[m].getError(), vsigma[m].getVal()*0.05))
galpha1.SetPoint(n, m, valpha1[m].getVal())
galpha1.SetPointError(n, 0, min(valpha1[m].getError(), valpha1[m].getVal()*0.10))
gslope1.SetPoint(n, m, vslope1[m].getVal())
gslope1.SetPointError(n, 0, min(vslope1[m].getError(), vslope1[m].getVal()*0.10))
galpha2.SetPoint(n, m, salpha2[m].getVal())
galpha2.SetPointError(n, 0, min(salpha2[m].getError(), salpha2[m].getVal()*0.10))
gslope2.SetPoint(n, m, sslope2[m].getVal())
gslope2.SetPointError(n, 0, min(sslope2[m].getError(), sslope2[m].getVal()*0.10))
n = n + 1
print "fit on gmean:"
gmean.Fit(fmean, "Q0", "SAME")
print "fit on gsigma:"
gsigma.Fit(fsigma, "Q0", "SAME")
print "fit on galpha:"
galpha1.Fit(falpha1, "Q0", "SAME")
print "fit on gslope:"
gslope1.Fit(fslope1, "Q0", "SAME")
galpha2.Fit(falpha2, "Q0", "SAME")
gslope2.Fit(fslope2, "Q0", "SAME")
#for m in [5000, 5500]: gnorm.SetPoint(gnorm.GetN(), m, gnorm.Eval(m, 0, "S"))
gnorm.Fit(fnorm, "Q", "SAME", 700, 5000)
for m in massPoints:
signalName = "%s_M%d" % (stype, m)
if vsigma[m].getVal() < 10.: vsigma[m].setVal(10.)
# Interpolation method
syield = gnorm.Eval(m)
spline = gnorm.Eval(m, 0, "S")
sfunct = fnorm.Eval(m)
#delta = min(abs(1.-spline/sfunct), abs(1.-spline/syield))
delta = abs(1.-spline/sfunct) if sfunct > 0 else 0
syield = spline
if interPar:
jmean = gmean.Eval(m)
jsigma = gsigma.Eval(m)
jalpha1 = galpha1.Eval(m)
jslope1 = gslope1.Eval(m)
else:
jmean = fmean.GetParameter(0) + fmean.GetParameter(1)*m + fmean.GetParameter(2)*m*m
jsigma = fsigma.GetParameter(0) + fsigma.GetParameter(1)*m + fsigma.GetParameter(2)*m*m
jalpha1 = falpha1.GetParameter(0) + falpha1.GetParameter(1)*m + falpha1.GetParameter(2)*m*m
jslope1 = fslope1.GetParameter(0) + fslope1.GetParameter(1)*m + fslope1.GetParameter(2)*m*m
inorm.SetPoint(inorm.GetN(), m, syield)
signalNorm[m].setVal(syield)
imean.SetPoint(imean.GetN(), m, jmean)
if jmean > 0: vmean[m].setVal(jmean)
isigma.SetPoint(isigma.GetN(), m, jsigma)
if jsigma > 0: vsigma[m].setVal(jsigma)
ialpha1.SetPoint(ialpha1.GetN(), m, jalpha1)
if not jalpha1==0: valpha1[m].setVal(jalpha1)
islope1.SetPoint(islope1.GetN(), m, jslope1)
if jslope1 > 0: vslope1[m].setVal(jslope1)
c1 = TCanvas("c1", "Crystal Ball", 1200, 800)
c1.Divide(2, 2)
c1.cd(1)
gmean.SetMinimum(0.)
gmean.Draw("APL")
imean.Draw("P, SAME")
drawRegion(channel)
c1.cd(2)
gsigma.SetMinimum(0.)
gsigma.Draw("APL")
isigma.Draw("P, SAME")
drawRegion(channel)
c1.cd(3)
galpha1.Draw("APL")
ialpha1.Draw("P, SAME")
drawRegion(channel)
galpha1.GetYaxis().SetRangeUser(0., 5.)
c1.cd(4)
gslope1.Draw("APL")
islope1.Draw("P, SAME")
drawRegion(channel)
gslope1.GetYaxis().SetRangeUser(0., 125.)
if False:
c1.cd(5)
galpha2.Draw("APL")
ialpha2.Draw("P, SAME")
drawRegion(channel)
c1.cd(6)
gslope2.Draw("APL")
islope2.Draw("P, SAME")
drawRegion(channel)
gslope2.GetYaxis().SetRangeUser(0., 10.)
c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.pdf")
c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.png")
c2 = TCanvas("c2", "Signal Efficiency", 800, 600)
c2.cd(1)
gnorm.SetMarkerColor(cColor)
gnorm.SetMarkerStyle(20)
gnorm.SetLineColor(cColor)
gnorm.SetLineWidth(2)
gnorm.Draw("APL")
inorm.Draw("P, SAME")
gnorm.GetXaxis().SetRangeUser(genPoints[0]-100, genPoints[-1]+100)
gnorm.GetYaxis().SetRangeUser(0., gnorm.GetMaximum()*1.25)
drawCMS(-1,YEAR , "Simulation")
drawAnalysis(channel)
drawRegion(channel)
c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.pdf")
c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.png")
#*******************************************************#
# #
# Generate workspace #
# #
#*******************************************************#
# create workspace
w = RooWorkspace("ZH_RunII", "workspace")
for m in massPoints:
getattr(w, "import")(signal[m], RooFit.Rename(signal[m].GetName()))
getattr(w, "import")(signalNorm[m], RooFit.Rename(signalNorm[m].GetName()))
getattr(w, "import")(signalXS[m], RooFit.Rename(signalXS[m].GetName()))
w.writeToFile("%s%s.root" % (WORKDIR, stype+channel), True)
print "Workspace", "%s%s.root" % (WORKDIR, stype+channel), "saved successfully"
sys.exit()
fitfunc.SetParName(3,"Tail Z")
fitfunc.SetParName(4,"Tail length")
w = RooWorkspace("w")
w.factory("{0}[0,0.1]".format("uncM"))
w.factory("uncVZ[-100,100]")
w.factory("uncP[0,10]")
w.factory("cut[0,1]")
w.defineSet("myVars","{0},uncVZ".format("uncM"))
events = infile.Get("cut")
#eventsrad = radfile.Get("ntuple")
eventsprompt = promptfile.Get("cut")
dataset = RooDataSet("data","data",events,w.set("myVars"),"")
w.factory("Gaussian::vtx_model(uncVZ,mean[-50,50],sigma[0,50])")
gauss_pdf = w.pdf("vtx_model")
w.factory("EXPR::gaussExp('exp( ((@0-@1)<@3)*(-0.5*(@0-@1)^2/@2^2) + ((@0-@1)>=@3)*(-0.5*@3^2/@2^2-(@0-@1-@3)/@4))',uncVZ,gauss_mean[-5,-20,20],gauss_sigma[5,1,50],exp_breakpoint[10,0,50],exp_length[3,0.5,20])")
gaussexp_pdf = w.pdf("gaussExp")
w.defineSet("obs_1d","uncVZ")
obs=w.set("obs_1d")
uncVZ = w.var("uncVZ")
uncVZ.setBins(200)
gauss_params = gauss_pdf.getParameters(obs)
gaussexp_params = gaussexp_pdf.getParameters(obs)
Medges = array.array('d')
Epsedges = array.array('d')
for i in range(0,nApMass+1):
def prepare_truth_models(ws,cat,mass,channel,turnon,truth):
if channel in study_inputs:
bkg_data = RooDataSet("bkgdata_%s"%(channel),
"M_{ll#gamma} with Errors",
ws.set("observables_weight"),
"weight")
for k,file in enumerate(study_inputs[channel]):
f_in = TFile.Open(file,"READ")
gDirectory.cd(pwd)
n_events = f_in.Get("eventCount").GetBinContent(1)
tree = f_in.Get("selected_zg").CloneTree()
tree.SetName("tree_%s_%i"%(channel,k))
f_in.Close()
d_in = RooDataSet("temp",
"M_{ll#gamma} with Errors",
tree,
ws.set("observables"))
norm = RooConstVar("norm","norm",n_events)
weight = RooFormulaVar("weight",
"weight",
"1.3*@0*@1/@2", #1.3 gives 19.6/fb
RooArgList(ws.var("puWeight"),
ws.var("procWeight"),
norm)
)
d_in.addColumn(weight)
d_in_weight = RooDataSet("temp_weight",
"M_{ll#gamma} with Errors",
d_in,
ws.set("observables_weight"),
'','weight')
bkg_data.append(d_in_weight)
# split off data for each category, create the
# toy dataset truth models
data = bkg_data.reduce("Mz + Mzg > 185 && r94cat == %i"%cat)
getattr(ws,'import')(data,
RooFit.Rename('bkgdata_%s_%i'%(channel,
cat)))
nevts = data.sumEntries('Mzg > %f && Mzg < %f'%(mass-1.5,mass+1.5))
#for sigm turn on we want erf truth
if turnon == 'sigm' and truth == 'exp':
#make RooDecay 'truth' model with erf turn on
ws.factory(
'RooGaussModel::MzgResoShape_exp_erf_%s_cat%i(Mzg,'\
'bias_exp_erf_%s_cat%i[120,90,150],sigma_exp_erf_%s_cat%i[1,0.01,10])'%(
channel,cat,
channel,cat,
channel,cat)
)
ws.factory(
'RooDecay::MzgTruthModelBase_exp_erf_%s_cat%i(Mzg,'\
'tau_erf_%s_cat%i[25,0,50],MzgResoShape_exp_erf_%s_cat%i,'
'RooDecay::SingleSided)'%(channel,cat,
channel,cat,
channel,cat)
)
ws.factory(
'RooExtendPdf::MzgTruthModel_exp_erf_%s_cat%i('\
'MzgTruthModelBase_exp_erf_%s_cat%i,'\
'norm_truth_exp_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit2','scan'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit','simplex'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.SumW2Error(True)
)
if turnon == 'sigm' and truth == 'pow':
#make power-law truth model with erf turn on
ws.factory('EXPR::MzgTruthModelShape_pow_erf_%s_cat%i('\
'"1e-20 + (@0 > @1)*((@0)^(-@2))",'\
'{Mzg,step_pow_erf_%s_cat%i[105,100,130],'\
'pow_%s_cat%i[2,0,10]})'\
%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooGaussModel::MzgResoShape_pow_erf_%s_cat%i(Mzg,'\
'bias_pow_erf_%s_cat%i[0],sigma_pow_erf_%s_cat%i[1,0.01,10])'%(
channel,cat,
channel,cat,
channel,cat)
)
ws.factory('FCONV::MzgTruthModelBase_pow_erf_%s_cat%i(Mzg,'\
'MzgTruthModelShape_pow_erf_%s_cat%i,'\
'MzgResoShape_pow_erf_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_pow_erf_%s_cat%i('\
'MzgTruthModelBase_pow_erf_%s_cat%i,'\
'norm_truth_pow_erf_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit2','scan'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit','simplex'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.SumW2Error(True)
)
#for erf fitting turn on we want sigmoid truth
if turnon == 'erf' and truth == 'exp':
#build exponential convoluted with sigmoid turn-on
ws.factory('RooStepExponential::MzgTruthModelShape_exp_sigm_%s_cat%i'\
'(Mzg,tau_sigm_%s_cat%i[-0.05,-10,0],'\
'step_exp_sigm_%s_cat%i[110,100,130])'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooLogistics::MzgResoShape_exp_sigm_%s_cat%i(%s)'%(
channel,cat,
','.join(['Mzg',
'bias_exp_sigm_%s_cat%i[0]'%(channel,cat),
'sigma_exp_sigm_%s_cat%i[5,0.01,20]'%(channel,cat)])
)
)
ws.factory('FCONV::MzgTruthModelBase_exp_sigm_%s_cat%i(Mzg,'\
'MzgTruthModelShape_exp_sigm_%s_cat%i,'\
'MzgResoShape_exp_sigm_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_exp_sigm_%s_cat%i('\
'MzgTruthModelBase_exp_sigm_%s_cat%i,'\
'norm_truth_exp_sigm_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit2','scan'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit','simplex'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.SumW2Error(True)
)
if turnon == 'erf' and truth == 'pow':
#build power-law convoluted with sigmoid turn-on
ws.factory('EXPR::MzgTruthModelShape_pow_sigm_%s_cat%i('\
'"1e-20 + (@0 > @1)*((@0)^(-@2))",'\
'{Mzg,step_pow_sigm_%s_cat%i[105,100,130],'\
'pow_sigm_%s_cat%i[2,0,10]})'\
%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooLogistics::MzgResoShape_pow_sigm_%s_cat%i(%s)'%(
channel,cat,
','.join(['Mzg',
'bias_pow_sigm_%s_cat%i[0]'%(channel,cat),
'sigma_pow_sigm_%s_cat%i[5,0.01,20]'%(channel,cat)])
)
)
ws.factory('FCONV::MzgTruthModelBase_pow_sigm_%s_cat%i(Mzg,'\
'MzgTruthModelShape_pow_sigm_%s_cat%i,'\
'MzgResoShape_pow_sigm_%s_cat%i)'%(channel,cat,
channel,cat,
channel,cat))
ws.factory(
'RooExtendPdf::MzgTruthModel_pow_sigm_%s_cat%i('\
'MzgTruthModelBase_pow_sigm_%s_cat%i,'\
'norm_truth_pow_sigm_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat,
channel,cat,
channel,cat,
nevts,
0.25*nevts,1.75*nevts)
)
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit2','scan'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.Minimizer('Minuit','simplex'),
RooFit.SumW2Error(False)
)
ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo(
ws.data('bkgdata_%s_%i'%(channel,cat)),
RooFit.SumW2Error(True)
)
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),
RooFit.Import(ch)
)
hist = data.binnedClone()
p1 = RooHistPdf(
'histpdf',
'',
RooArgSet(x),
hist,
2 # Order of interpolation function
)
#p2 = RooGaussian(
p2 = RooGaussModel(
"comp_2",
"",
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)
for i in range(len(tupleDict)):
varName = tupleDict.keys()[i]
varList += [
RooRealVar(varName,
tree1.GetBranch(varName).GetTitle(),
tree1.GetMinimum(varName), tree1.GetMaximum(varName))
]
varRenamedList += [RooFit.RenameVariable(varName, tupleDict[varName])]
#RooFit.RenameVariable(varName, tupleDict[varName]);
#varList[i].SetName(tupleDict.keys()[i]);
#tupleDataSet = RooDataSet("treeData","treeData",tree1,RooArgSet(*varList));
weightvar = RooRealVar("weight", "weight", -1e7, 1e7)
tupleDataSet = RooDataSet("tupleDataSet", "tupleDataSet",
RooArgSet(*varList), RooFit.Import(tree1),
RooFit.WeightVar(weightvar))
ws = RooWorkspace('ws_FIT')
tupleDataSet = WS(ws, tupleDataSet, varRenamedList)
tupleDataSet.Print()
sys.exit(0)
#qt needs to be a category?
# Manuel's shit...
#weightvar = RooRealVar("weight", "weight", -1e7, 1e7)
#tupleDataSet = RooDataSet("tupleDataSet", "tupleDataSet",
# RooArgSet(treetime, treeqt, treeqf, treeeta),
# RooFit.Import(tree1), RooFit.WeightVar(weightvar))
#tupleDS = WS(ws, tupleDS, [
# RooFit.RenameVariable("Bs_ctau", "time"), ... ])
sample = ws.cat("sample")
simPdf = ws.pdf("simPdf")
efficiency = ws.var("efficiency")
meanB = ws.var("meanB")
# prepare_datasets(ws, p)
# Prepare datasets
datasetAllMap = {}
datasetPassMap = {}
hAllMap = {}
hPassMap = {}
for ptBin1 in range(0, len(ptBinsX)):
for ptBin2 in range(0, len(ptBinsY)):
datasetAllMap[(ptBin1, ptBin2)] = RooDataSet(
buildName("datasetAll_", ptBin1, ptBin2, ptBinsX, ptBinsY),
buildName("datasetAll_", ptBin1, ptBin2, ptBinsX, ptBinsY),
RooArgSet(mass))
datasetPassMap[(ptBin1, ptBin2)] = RooDataSet(
buildName("datasetPass_", ptBin1, ptBin2, ptBinsX, ptBinsY),
buildName("datasetPass_", ptBin1, ptBin2, ptBinsX, ptBinsY),
RooArgSet(mass))
hAllMap[(ptBin1, ptBin2)] = ROOT.TH1F(
buildName("hAll_", ptBin1, ptBin2, ptBinsX, ptBinsY),
buildName("All events passing old trigger ", ptBin1, ptBin2,
ptBinsX, ptBinsY), 100, 60, 120)
hPassMap[(ptBin1, ptBin2)] = ROOT.TH1F(
buildName("hPass_", ptBin1, ptBin2, ptBinsX, ptBinsY),
buildName("All events passing old trigger and new trigger ",
ptBin1, ptBin2, ptBinsX, ptBinsY), 100, 60, 120)
# Event loop
LbStabilityFit = False
inFile16 = TFile.Open(dataFileName)
inN16 = inFile16.Get('pLbL0/2016Data')
inn16 = inFile16.Get('nLbL0/2016Data')
# load parameters from other workspace and import them in current workspace
massLb = space.var('lbl0Mass')
massTkTk = space.var('tktkMass')
massLb.setBins(50)
massLb.setRange('sigRangeLb', 5.4, 5.9)
loadDatasetLb = RooDataSet(
'loadDatasetLb', 'loadData16', inN16,
RooArgSet(massLb, massTkTk, space.var('lbl0Pt'))).reduce(
'tktkMass>1.110&&tktkMass<1.120 &&{0}'.format(ptCut))
loadDatasetlB = RooDataSet(
'loadDatasetlB', 'loadData16', inn16,
RooArgSet(massLb, massTkTk, space.var('lbl0Pt'))).reduce(
'tktkMass>1.110&&tktkMass<1.120 &&{0}'.format(ptCut))
totNum = loadDatasetLb.sumEntries()
space.factory('numLb[{0},-1000.,{1}]'.format(
space1st.var('numLb').getVal(), totNum))
simulComponents = []
# scan Lb likelihood {{{
# jack's profile likelihood scan
if sysFitLb:
label = 'sysLbFit'
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
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)
aa.SetBranchStatus("piz*",0)
print aa.GetEntries()
for i in range(aa.GetEntries()):
s = aa.GetEntry(i)
if s == -1:
print "Error reading event ",i,", skipping"
continue
if i%10000 == 0:
# read ntuple
ffile_tp = TFile(tpfile, 'read')
fkeys = ffile_tp.GetListOfKeys()
keys = []
for i in range(fkeys.GetEntries()):
keys.append(fkeys.At(i).GetName())
keys.sort()
for i in range(0,len(keys),2):
if keys[i].find(mode) > 0:
ntuples = (ffile_tp.Get(keys[i]), ffile_tp.Get(keys[i+1]))
break # found mode
# make dataset from tree
wt = RooRealVar('wt', '', 1.0, 0.0, 1.0)
dst = RooDataSet('dst', '', RooArgSet(time, wt), RooFit.WeightVar(wt))
for tp in ntuples:
print '{}: {}'.format(tp.GetName(), tp.GetEntries())
tp.SetBranchStatus('*', 0)
tp.SetBranchStatus('wt', 1)
tp.SetBranchStatus('Bid', 1)
tp.SetBranchStatus('hid', 1)
tp.SetBranchStatus('time', 1)
for i in range(tp.GetEntries()):
tp.GetEntry(i)
# choose decay equation (1 of 2 for Dspi)
if (tp.Bid == 531 and tp.hid == 211):
time.setVal(tp.time)
dst.add(RooArgSet(time), tp.wt)
dst.Print()
def make_fit():
adc_bin = 12 #18 for low-m gg, 24 for jpsi
adc_min = 0. #10.
adc_max = 400.
#adc_max = 1200
ptmax = 0.18
#mmin = 1.6
#mmin = 2.1
#mmax = 2.6
#mmin = 1.5
#mmax = 5.
mmin = 2.9
mmax = 3.2
#mmin = 3.4
#mmax = 4.6
#east/west projections and 2D plot
ew = 1
p2d = 2 # 0: single projection by 'ew', 1: 2D plot, 2: both projections
#plot colors
model_col = rt.kMagenta
model_col = rt.kBlue
out = open("out.txt", "w")
lmg = 6
ut.log_results(out, "in " + infile, lmg)
strlog = "adc_bin " + str(adc_bin) + " adc_min " + str(
adc_min) + " adc_max " + str(adc_max)
strlog += " ptmax " + str(ptmax) + " mmin " + str(mmin) + " mmax " + str(
mmax)
ut.log_results(out, strlog, lmg)
#adc distributions
adc_east = RooRealVar("jZDCUnAttEast", "ZDC ADC east", adc_min, adc_max)
adc_west = RooRealVar("jZDCUnAttWest", "ZDC ADC west", adc_min, adc_max)
#kinematics variables
m = RooRealVar("jRecM", "e^{+}e^{-} mass (GeV)", 0., 10.)
y = RooRealVar("jRecY", "rapidity", -1., 1.)
pT = RooRealVar("jRecPt", "pT", 0., 10.)
#adc distributions
#adc_east = RooRealVar("zdce", "ZDC ADC east", adc_min, adc_max)
#adc_west = RooRealVar("zdcw", "ZDC ADC west", adc_min, adc_max)
#kinematics variables
#m = RooRealVar("mee", "e^{+}e^{-} mass (GeV)", 0., 10.)
#y = RooRealVar("rapee", "rapidity", -1., 1.)
#pT = RooRealVar("ptpair", "pT", 0., 10.)
strsel = "jRecPt<{0:.3f} && jRecM>{1:.3f} && jRecM<{2:.3f}".format(
ptmax, mmin, mmax)
#strsel = "ptpair<{0:.3f} && mee>{1:.3f} && mee<{2:.3f}".format(ptmax, mmin, mmax)
data_all = RooDataSet("data", "data", tree,
RooArgSet(adc_east, adc_west, m, y, pT))
print "All input:", data_all.numEntries()
data = data_all.reduce(strsel)
print "Sel input:", data.numEntries()
model = Model2D(adc_east, adc_west)
r1 = model.model.fitTo(data, rf.Save())
ut.log_results(out, ut.log_fit_result(r1), lmg)
ut.log_results(out, "Fit parameters:\n", lmg)
out.write(ut.log_fit_parameters(r1, lmg + 2) + "\n")
#out.write(ut.table_fit_parameters(r1))
#print ut.table_fit_parameters(r1)
#create the plot
if p2d != 2: can = ut.box_canvas()
nbins, adc_max = ut.get_nbins(adc_bin, adc_min, adc_max)
adc_east.setMax(adc_max)
adc_west.setMax(adc_max)
frame_east = adc_east.frame(rf.Bins(nbins), rf.Title(""))
frame_west = adc_west.frame(rf.Bins(nbins), rf.Title(""))
data.plotOn(frame_east, rf.Name("data"))
model.model.plotOn(frame_east, rf.Precision(1e-6), rf.Name("model"),
rf.LineColor(model_col))
data.plotOn(frame_west, rf.Name("data"))
model.model.plotOn(frame_west, rf.Precision(1e-6), rf.Name("model"),
rf.LineColor(model_col))
#reduced chi^2 in east and west projections
ut.log_results(out, "chi2/ndf:\n", lmg)
ut.log_results(
out,
" East chi2/ndf: " + str(frame_east.chiSquare("model", "data", 16)),
lmg)
ut.log_results(
out,
" West chi2/ndf: " + str(frame_west.chiSquare("model", "data", 16)),
lmg)
ut.log_results(out, "", 0)
ytit = "Events / ({0:.0f} ADC units)".format(adc_bin)
frame_east.SetYTitle(ytit)
frame_west.SetYTitle(ytit)
frame_east.SetTitle("")
frame_west.SetTitle("")
frame = [frame_east, frame_west]
if p2d == 0: plot_projection(frame[ew], ew)
plot_pdf = PlotPdf(model, adc_east, adc_west)
if p2d == 1: plot_2d(plot_pdf)
if p2d == 2:
frame2 = ut.prepare_TH1D("frame2", adc_bin, adc_min,
2. * adc_max + 4.1 * adc_bin)
plot_proj_both(frame2, frame_east, frame_west, adc_bin, adc_min,
adc_max, ptmax, mmin, mmax)
lhead = ["east ZDC", "west ZDC"]
if p2d == 1:
leg = ut.prepare_leg(0.003, 0.9, 0.3, 0.1, 0.035)
else:
leg = ut.prepare_leg(0.66, 0.8, 0.32, 0.13, 0.03)
if p2d == 0: leg.AddEntry(None, "#bf{Projection to " + lhead[ew] + "}", "")
leg.SetMargin(0.05)
leg.AddEntry(None,
"#bf{#it{p}_{T} < " + "{0:.2f}".format(ptmax) + " GeV/c}", "")
mmin_fmt = "{0:.1f}".format(mmin)
mmax_fmt = "{0:.1f}".format(mmax)
leg.AddEntry(
None, "#bf{" + mmin_fmt + " < #it{m}_{e^{+}e^{-}} < " + mmax_fmt +
" GeV/c^{2}}", "")
leg.Draw("same")
pleg = ut.prepare_leg(0.99, 0.87, -0.4, 0.11, 0.035)
pleg.SetFillStyle(1001)
#pleg.AddEntry(None, "STAR Preliminary", "")
pleg.AddEntry(None, "AuAu@200 GeV", "")
pleg.AddEntry(None, "UPC sample", "")
#pleg.Draw("same")
#ut.print_pad(gPad)
#b3d = TBuffer3D(0)
#b3d = None
#gPad.GetViewer3D().OpenComposite(b3d)
#print b3d
#print "All input: ", data.numEntries()
#print "All input: 858"
#all input data
nall = float(tree.Draw("", strsel))
print "All input: ", nall
n_1n1n = float(model.num_1n1n.getVal())
print "1n1n events: ", n_1n1n
ratio_1n1n = n_1n1n / nall
sigma_ratio_1n1n = ratio_1n1n * TMath.Sqrt(
(nall - n_1n1n) / (nall * n_1n1n))
print "Ratio 1n1n / all: ", ratio_1n1n, "+/-", sigma_ratio_1n1n
ut.log_results(out, "Fraction of 1n1n events:\n", lmg)
ut.log_results(out, "All input: " + str(nall), lmg)
ut.log_results(out, "1n1n events: " + str(model.num_1n1n.getVal()), lmg)
ratio_str = "Ratio 1n1n / all: " + str(ratio_1n1n) + " +/- " + str(
sigma_ratio_1n1n)
ut.log_results(out, ratio_str, lmg)
if p2d != 2:
#ut.print_pad(gPad)
ut.invert_col(gPad)
can.SaveAs("01fig.pdf")
if interactive == True: start_interactive()
mmtt_mass = RooRealVar("xM", "xM" + region + "m(#mu#muKK)[GeV]", xmin, xmax)
tt_pt = RooRealVar("ttPt", "ttPt" + region + "p_{t}(KK)[GeV]", 0.0, ptmax)
mm_pt = RooRealVar("mmPt", "mmPt" + region + "p{t}(#mu#mu)[GeV]", 0.0, ptmax)
mmtt_pt = RooRealVar("xPt", "xPt" + region + "p_{t}(#mu#muKK)[GeV]", 0.0,
ptmax)
lxysig = RooRealVar("xL", "l_{xy} sign." + region + "l_{xy} / #sigma(l_{xy})",
-1000.0, 1000.0)
massvars = RooArgSet(tt_mass, mm_mass, mmtt_mass)
ptvars = RooArgSet(tt_pt, mm_pt, mmtt_pt)
kinvars = RooArgSet(massvars, ptvars)
extravars = RooArgSet(lxysig)
theData = RooDataSet("theData", "theData", theTree,
RooArgSet(kinvars, extravars))
c = TCanvas("canvas", "canvas", 1200, 800)
if args.nonprompt:
theData = theData.reduce("xL > 3.0")
if args.prompt:
theData = theData.reduce("xL < 1.5")
if args.ptcuts is not None:
theData = theData.reduce("trigp_pT > " + str(args.ptcuts))
theData = theData.reduce("trign_pT > " + str(args.ptcuts))
cuts += "P_t_" + str(args.ptcuts) + "_"
#### #### Plotting variables
#### TrakTrak Data
binWidth = 50. #GeV
# DAS_EX_2.1
# Define a RooRealVar object for the ST variable
st = RooRealVar("st", "st", ranges["fit", "lo"], ranges["fit", "hi"])
############################################
# Get data and models
############################################
#
print "Reading Files"
# DAS_EX_2.2
# Read data from file into RooDataSet using the RooDataSet.read() method.
#rdata = RooDataSet.add(files["dat"], RooArgList(st))
rdata = RooDataSet.read(files["dat"], RooArgList(st))
###################################
# Set up fit PDFs with information
# from fitFuncs dictionary
###################################
# Declare a few dictionaries
pdfs = {}
pars = {}
aset = {}
for func in ["f2", "f1", "f3"]:
# DAS_EX_2.3
# Define and initialize (with your ST RooRealVar) a RooArgSet for use in the pdf
fcUpperHist=TH2D("fcUpperLimit","fcUpperLimit",n_massbins,xedges,n_epsbins,yedges)
plrPvalHist=TH2D("plrPval","plrPval",n_massbins,xedges,n_epsbins,yedges)
plrSigHist=TH2D("plrSig","plrSig",n_massbins,xedges,n_epsbins,yedges)
logplrHist=TH2D("logplr","logplr",n_massbins,xedges,n_epsbins,yedges)
candRescaledHist=TH1D("candidates_rescaled","candidates_rescaled",100,0,1.0)
candRescaled2DHist=TH2D("candidates_rescaled_2d","candidates_rescaled_2d",n_massbins,xedges,100,0,1.0)
w = RooWorkspace("w")
w.factory("{0}[0,0.1]".format(massVar))
w.factory("uncVZ[-100,100]")
w.factory("uncP[0,10]")
w.factory("cut[0,1]")
w.defineSet("myVars","{0},uncVZ".format(massVar))
dataset = RooDataSet("data","data",events,w.set("myVars"),"")
w.factory("Gaussian::vtx_model(uncVZ,mean[-50,50],sigma[0,50])")
gauss_pdf = w.pdf("vtx_model")
w.factory("EXPR::gaussExp('exp( ((@0-@1)<@3)*(-0.5*(@0-@1)^2/@2^2) + ((@0-@1)>=@3)*(-0.5*@3^2/@2^2-(@0-@1-@3)/@4))',uncVZ,gauss_mean[-5,-20,20],gauss_sigma[5,1,50],exp_breakpoint[10,0,50],exp_length[3,0.5,20])")
gaussexp_pdf = w.pdf("gaussExp")
w.defineSet("obs_1d","uncVZ")
obs=w.set("obs_1d")
uncVZ = w.var("uncVZ")
uncVZ.setBins(200)
gauss_params = gauss_pdf.getParameters(obs)
gaussexp_params = gaussexp_pdf.getParameters(obs)
exppol4=TF1("exppol4","exp(pol4(0))",-5,100)
w.factory("EXPR::signal('(@0>{0})*exp(@1 + @2*@0 + @3*@0^2 + @4*@0^3 + @5*@0^4)',uncVZ,eff_p0[-1,1],eff_p1[-1,1],eff_p2[-1,1],eff_p3[-1,1],eff_p4[-1,1])".format(targetz))
w.factory("SUM::model(strength[0,1]*signal,gaussExp)")
def gen_data_and_fit(ws, iterations,cat, mass,channel,turnon,truth):
if channel in channels:
#fit gaus(x)bern to sigm(x)pow and sigm(x)exp
#fit sigm(x)bern to erf(x)pow and erf(x)exp
n_sample = int(ws.data('bkgdata_%s_%i'%(channel,cat)).sumEntries())
if turnon == 'erf' and truth == 'exp':
ws.factory('pull_ROI_erf_on_sigmexp_%s_cat%i[0]'%(channel,cat))
ws.defineSet('biasVars_%s_cat%i'%(channel,cat),
'pull_ROI_erf_on_sigmexp_%s_cat%i,'%(channel,cat))
if turnon == 'erf' and truth == 'pow':
ws.factory('pull_ROI_erf_on_sigmpow_%s_cat%i[0]'%(channel,cat))
ws.defineSet('biasVars_%s_cat%i'%(channel,cat),
'pull_ROI_erf_on_sigmpow_%s_cat%i,'%(channel,cat)
)
if turnon == 'sigm' and truth == 'exp':
ws.factory('pull_ROI_sigm_on_erfexp_%s_cat%i[0]'%(channel,cat))
ws.defineSet('biasVars_%s_cat%i'%(channel,cat),
'pull_ROI_sigm_on_erfexp_%s_cat%i,'%(channel,cat)
)
if turnon == 'sigm' and truth == 'pow':
ws.factory('pull_ROI_sigm_on_erfpow_%s_cat%i[0]'%(channel,cat))
ws.defineSet('biasVars_%s_cat%i'%(channel,cat),
'pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat)
)
biasData = RooDataSet('biasData_%s_cat%i'%(channel,cat),
'bias data',
ws.set('biasVars_%s_cat%i'%(channel,cat)))
for i in xrange(iterations):
### SIGM
#build ERF toy data to fit with SIGM
if turnon == 'sigm' and truth == 'exp':
truth_exp_erf = ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat))
toy_data_exp_erf = truth_exp_erf.generate(
RooArgSet(ws.var('Mzg')),
n_sample,
RooFit.Extended(),
RooFit.Name('toy_erfexp_%s_cat%i_%i'%(channel,cat,i))
)
true_ROI_yield_erfexp = ws.var('norm_truth_exp_%s_cat%i'%(channel,cat)).getVal()
#fit logistics(x)bern to erfexp
ws.var('norm_altrsb_cat%i'%cat).setMin(true_ROI_yield_erfexp*0.25)
ws.var('norm_altrsb_cat%i'%cat).setMax(true_ROI_yield_erfexp*1.75)
ws.var('norm_altrsb_cat%i'%cat).setVal(true_ROI_yield_erfexp)
minos_var = RooArgSet(ws.var('norm_altrsb_cat%i'%cat))
sigm_nll = ws.pdf('RSBFitModelAlt_cat%i'%cat).createNLL(
toy_data_exp_erf
)
sigm_min = RooMinimizer(sigm_nll)
sigm_min.setPrintLevel(1)
sigm_min.minimize('Minuit2','scan')
sigm_min.minimize('Minuit2','simplex')
migrad_out = sigm_min.migrad()
migrad_out = sigm_min.migrad()
hesse_out = sigm_min.hesse()
fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal()
fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError()
fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfexp)/fit_sigm_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = sigm_min.migrad()
if migrad_out != 0:
sigm_min.minos(minos_var)
fit_sigm_err = max(abs(ws.var('norm_altrsb_cat%i'%cat).getErrorHi()),
abs(ws.var('norm_altrsb_cat%i'%cat).getErrorLo()))
else:
fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError()
fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal()
fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfexp)/fit_sigm_err
print i, fit_sigm_norm, fit_sigm_err, true_ROI_yield_erfexp, fit_sigm_pull
ws.var('pull_ROI_sigm_on_erfexp_%s_cat%i'%(channel,cat)).setVal(
fit_sigm_pull
)
biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat)))
var = ws.var('pull_ROI_sigm_on_erfexp_%s_cat%i'%(channel,cat))
print 'cumulative median bias: %.3f'%calculate_median(var,biasData)
var = None
del sigm_min
del sigm_nll
del truth_exp_erf
if turnon =='sigm' and truth =='pow':
truth_pow_erf = ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat))
toy_data_pow_erf = truth_pow_erf.generate(
RooArgSet(ws.var('Mzg')),
n_sample,
RooFit.Extended(),
RooFit.Name('toy_erfpow_%s_cat%i_%i'%(channel,cat,i))
)
true_ROI_yield_erfpow = ws.var('norm_truth_pow_erf_%s_cat%i'%(channel,cat)).getVal()
#fit logistics(x)bern to erfpow
ws.var('norm_altrsb_cat%i'%cat).setMin(true_ROI_yield_erfpow*0.25)
ws.var('norm_altrsb_cat%i'%cat).setMax(true_ROI_yield_erfpow*1.75)
ws.var('norm_altrsb_cat%i'%cat).setVal(true_ROI_yield_erfpow)
minos_var = RooArgSet(ws.var('norm_altrsb_cat%i'%cat))
sigm_nll = ws.pdf('RSBFitModelAlt_cat%i'%cat).createNLL(
toy_data_pow_erf
)
sigm_min = RooMinimizer(sigm_nll)
sigm_min.setPrintLevel(1)
sigm_min.minimize('Minuit2','scan')
sigm_min.minimize('Minuit2','simplex')
migrad_out = sigm_min.migrad()
migrad_out = sigm_min.migrad()
hesse_out = sigm_min.hesse()
fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal()
fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError()
fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfpow)/fit_sigm_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = sigm_min.migrad()
if migrad_out != 0:
sigm_min.minos(minos_var)
fit_sigm_err = max(abs(ws.var('norm_altrsb_cat%i'%cat).getErrorHi()),
abs(ws.var('norm_altrsb_cat%i'%cat).getErrorLo()))
else:
fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError()
fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal()
fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfpow)/fit_sigm_err
ws.var('pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat)).setVal(
fit_sigm_pull
)
print i, fit_sigm_norm, fit_sigm_err, true_ROI_yield_erfpow, fit_sigm_pull
biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat)))
var = ws.var('pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat))
print 'cumulative median bias: %.3f'%calculate_median(var,biasData)
var = None
del sigm_min
del sigm_nll
del truth_pow_erf
##### ERF
# generate SIGM data to fit with ERF
#### fit erf(x)bern models
if turnon == 'erf' and truth == 'exp':
truth_exp_sigm = ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat))
toy_data_exp_sigm = truth_exp_sigm.generate(
RooArgSet(ws.var('Mzg')),
n_sample,
RooFit.Extended(),
RooFit.Name('toy_sigmexp_%s_cat%i_%i'%(channel,cat,i))
)
true_ROI_yield_sigmexp = ws.var('norm_truth_exp_sigm_%s_cat%i'%(channel,cat)).getVal()
#fit erf(x)bern to sigmexp
ws.var('norm_rsb_cat%i'%cat).setMin(true_ROI_yield_sigmexp*0.25)
ws.var('norm_rsb_cat%i'%cat).setMax(true_ROI_yield_sigmexp*1.75)
ws.var('norm_rsb_cat%i'%cat).setVal(true_ROI_yield_sigmexp)
minos_var = RooArgSet(ws.var('norm_rsb_cat%i'%cat))
gaus_nll = ws.pdf('RSBFitModel_cat%i'%cat).createNLL(
toy_data_exp_sigm
)
gaus_min= RooMinimizer(gaus_nll)
gaus_min.setPrintLevel(1)
gaus_min.minimize('Minuit2','scan')
gaus_min.minimize('Minuit2','simplex')
migrad_out = gaus_min.migrad()
migrad_out = gaus_min.migrad()
hesse_out = gaus_min.hesse()
#get parabolic errors regardless
fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal()
fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError()
fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmexp)/fit_erf_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = gaus_min.migrad()
if migrad_out != 0:
gaus_min.minos(minos_var)
fit_erf_err = max(abs(ws.var('norm_rsb_cat%i'%cat).getErrorHi()),
abs(ws.var('norm_rsb_cat%i'%cat).getErrorLo()))
else:
fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError()
fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal()
fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmexp)/fit_erf_err
ws.var('pull_ROI_erf_on_sigmexp_%s_cat%i'%(channel,cat)).setVal(
fit_erf_pull
)
print i,fit_erf_norm, fit_erf_err, true_ROI_yield_sigmexp, fit_erf_pull
biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat)))
var = ws.var('pull_ROI_erf_on_sigmerf_%s_cat%i'%(channel,cat))
print 'cumulative median bias: %.3f'%calculate_median(var,biasData)
var = None
del gaus_min
del gaus_nll
del truth_exp_sigm
if turnon == 'erf' and truth == 'pow':
truth_pow_sigm = ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat))
toy_data_pow_sigm = truth_pow_sigm.generate(
RooArgSet(ws.var('Mzg')),
n_sample,
RooFit.Extended(),
RooFit.Name('toy_sigmpow_%s_cat%i_%i'%(channel,cat,i))
)
true_ROI_yield_sigmpow = ws.var('norm_truth_pow_sigm_%s_cat%i'%(channel,cat)).getVal()
#fit erf(x)bern to sigmpow
ws.var('norm_rsb_cat%i'%cat).setMin(true_ROI_yield_sigmpow*0.25)
ws.var('norm_rsb_cat%i'%cat).setMax(true_ROI_yield_sigmpow*1.75)
ws.var('norm_rsb_cat%i'%cat).setVal(true_ROI_yield_sigmpow)
minos_var = RooArgSet(ws.var('norm_rsb_cat%i'%cat))
gaus_nll = ws.pdf('RSBFitModel_cat%i'%cat).createNLL(
toy_data_pow_sigm
)
gaus_min= RooMinimizer(gaus_nll)
gaus_min.setPrintLevel(1)
gaus_min.minimize('Minuit2','scan')
gaus_min.minimize('Minuit2','simplex')
migrad_out = gaus_min.migrad()
migrad_out = gaus_min.migrad()
hesse_out = gaus_min.hesse()
fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal()
fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError()
fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmpow)/fit_erf_err
#if fit failed run minos
if migrad_out != 0 or hesse_out != 0:
migrad_out = gaus_min.migrad()
if migrad_out != 0:
gaus_min.minos(minos_var)
fit_erf_err = max(abs(ws.var('norm_rsb_cat%i'%cat).getErrorHi()),
abs(ws.var('norm_rsb_cat%i'%cat).getErrorLo()))
else:
fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError()
fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal()
fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmpow)/fit_erf_err
print i, fit_erf_norm, fit_erf_err, true_ROI_yield_sigmpow, fit_erf_pull
ws.var('pull_ROI_erf_on_sigmpow_%s_cat%i'%(channel,cat)).setVal(
fit_erf_pull
)
biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat)))
var = ws.var('pull_ROI_erf_on_sigmpow_%s_cat%i'%(channel,cat))
print 'cumulative median bias: %.3f'%calculate_median(var,biasData)
var = None
#getattr(ws,'import')(toy_data_exp_sigm)
#getattr(ws,'import')(toy_data_pow_sigm)
del gaus_min
del gaus_nll
del truth_pow_sigm
getattr(ws,'import')(biasData)
def getData(workspace,
mean1 = 1., sigma1 = 0.01,
mean2 = 1., sigma2 = 0.01, nevents = 5000):
## Make a local workspace to use as a factory.
w = RooWorkspace('w', 'w')
## Define the PDF's for m, f1 and f2 in m*sqrt(f1*f2)
mPdf = w.factory("BreitWigner::mPdf(m[50,130], MZ[91.12], GammaZ[2.5])")
f1Pdf = w.factory("Gaussian::f1Pdf(f1[0.5, 2], mean1[%f], sigma1[%f])" %
(mean1, sigma1))
f2Pdf = w.factory("Gaussian::f2Pdf(f2[0.5, 2], mean2[%f], sigma2[%f])" %
(mean2, sigma2))
## Import the PDF's in the given workspace.
workspace.Import(mPdf, RenameAllVariables("True"))
workspace.Import(f1Pdf, RenameAllVariables("True"))
workspace.Import(f2Pdf, RenameAllVariables("True"))
## Generate samples of M, F1 and F2 with a 10% margin for boundaries.
moreEvents = int(2*nevents)
mData = mPdf.generate(RooArgSet(w.var("m")), moreEvents, NumCPU(3))
f1Data = f1Pdf.generate(RooArgSet(w.var("f1")), moreEvents, NumCPU(3))
f2Data = f2Pdf.generate(RooArgSet(w.var("f2")), moreEvents, NumCPU(3))
## Create the new data with toy reco mass
data = RooDataSet('data', 'toy reco Z->ll mass data',
RooArgSet(w.factory('mass[40,140]')))
entry = data.get()
## Loop over the generated values and fill the new reco mass data.
for i in range(moreEvents):
## Do we have enough entries already?
if data.sumEntries() >= nevents:
break
## Get the values of the random variables m, f1, f2.
m = mData.get(i).first().getVal()
f1 = f1Data.get(i).first().getVal()
f2 = f2Data.get(i).first().getVal()
## Here comes the formula!!
mass = m * sqrt(f1*f2)
## Is the reco mass within its range?
if 60. < mass and mass < 120.:
## Add the reco mass to the data
entry.first().setVal(mass)
data.addFast(entry)
## End of loop over the generated values
workspace.Import(data)
return data
