def applyDecayTimeErrPdf(config, name, ws, time, timeerr, qt, qf, mistagobs,
timepdf, timeerrpdf, mistagpdf):
"""
apply the per-event time error pdf
config -- configuration dictionary
name -- prefix to be used for new RooFit objects
ws -- workspace to import new objects into
time -- time observable
timeerr -- decay time error observable (or None for average decay time
error)
qt -- tagging decision
qf -- final state charge
mistagobs -- mistag observable (or None for average mistag)
timepdf -- decay time pdf
timeerrpdf -- decay time error pdf (or None for av. decay time error)
mistagpdf -- mistag pdf (or None for average mistag)
returns the (possibly modified) decay time error pdf (with decay time
error multiplied on, if applicable).
"""
# no per-event time error is easy...
if None == timeerrpdf: return timepdf
from ROOT import RooFit, RooArgSet, RooProdPdf
noncondset = RooArgSet(time, qf, qt)
if None != mistagpdf:
noncondset.add(mistagobs)
timepdf = WS(ws, RooProdPdf('%s_TimeTimeerrPdf' % name,
'%s (time,timeerr) pdf' % name, RooArgSet(timeerrpdf),
RooFit.Conditional(RooArgSet(timepdf), noncondset)))
return timepdf
def get_roofit_model( histograms, fit_boundaries, name = 'model' ):
data_label = 'data'
samples = sorted( histograms.keys() )
samples.remove( data_label )
roofit_histograms = {}
roofit_pdfs = {}
roofit_variables = {}
variables = RooArgList()
variable_set = RooArgSet()
fit_variable = RooRealVar( name , name, fit_boundaries[0], fit_boundaries[1] )
variables.add( fit_variable )
variable_set.add( fit_variable )
roofit_histograms[data_label] = RooDataHist( data_label,
data_label,
variables,
histograms[data_label] )
pdf_arglist = RooArgList()
variable_arglist = RooArgList()
N_total = histograms[data_label].Integral() * 2
N_min = 0
for sample in samples:
roofit_histogram = RooDataHist( sample, sample, variables, histograms[sample] )
roofit_histograms[sample] = roofit_histogram
roofit_pdf = RooHistPdf ( 'pdf' + sample, 'pdf' + sample, variable_set, roofit_histogram, 0 )
roofit_pdfs[sample] = roofit_pdf
roofit_variable = RooRealVar( sample, "number of " + sample + " events", histograms[sample].Integral(), N_min, N_total, "event" )
roofit_variables[sample] = roofit_variable
pdf_arglist.add( roofit_pdf )
variable_arglist.add( roofit_variable )
model = RooAddPdf( name, name, pdf_arglist, variable_arglist )
return model, roofit_histograms, fit_variable
def get_argset(args):
"""Return and argset of the RooFit objects."""
argset = RooArgSet()
for arg in args:
if arg.InheritsFrom(RooAbsArg.Class()): argset.add(arg)
else: TypeError('%s should inherit from RooAbsArg' % arg.GetName())
return argset
def cnvrt(i) :
if not hasattr(i,'__iter__') or any( isinstance(i, t) for t in __doNotConvert ): return i
_i = RooArgSet()
for j in i :
from ROOT import RooAbsArg
if not isinstance(j,RooAbsArg) : return i
_i.add( j )
return _i
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 expectedPlcLimit(obs_, poi_, model, ws, ntoys = 30, CL = 0.95):
# obs : observable variable or RooArgSet of observables
# poi : parameter of interest or RooArgSet of parameters
# model : RooAbsPdf of model to consider including any constraints
# the parameters should have the values corresponding to the
# background-only hypothesis which will be used to estimate the
# expected limit.
# ntoys : number of toy datsets to generate to get expected limit
# CL : confidence level for interval
# returns a dictionary containing the expected limits and their 1 sigma
# errors for the first/only parameter in poi_ and a list of the results
# from the individual toys.
from math import sqrt
obs = RooArgSet(obs_)
obs.setName('observables')
mPars = model.getParameters(obs)
genPars = mPars.snapshot()
print "parameters for generating toy datasets"
genPars.Print("v")
limits = []
sumUpper = 0.
sumUpper2 = 0.
sumLower = 0.
sumLower2 = 0.
nOK = 0
for i in range(0,ntoys):
print 'generate limit of toy %i of %i' % (i+1, ntoys)
mPars.assignValueOnly(genPars)
toyData = model.generate(obs, RooFit.Extended())
toyData.SetName('data_obs_%i' % i)
limits.append(plcLimit(obs_, poi_, model, ws, toyData, CL))
if limits[-1]['limits'][poi_.GetName()]['ok']:
nOK += 1
sumUpper += limits[-1]['limits'][poi_.GetName()]['upper']
sumUpper2 += limits[-1]['limits'][poi_.GetName()]['upper']**2
sumLower += limits[-1]['limits'][poi_.GetName()]['lower']
sumLower2 += limits[-1]['limits'][poi_.GetName()]['lower']**2
toyData.IsA().Destructor(toyData)
expLimits = {'upper' : sumUpper/nOK,
'upperErr' : sqrt(sumUpper2/(nOK-1)-sumUpper**2/nOK/(nOK-1)),
'lower' : sumLower/nOK,
'lowerErr' : sqrt(sumLower2/(nOK-1)-sumLower**2/nOK/(nOK-1)),
'ntoys': nOK
}
return (expLimits, limits)
def rooFit103():
print ">>> construct generic pdf from interpreted expression..."
# To construct a proper p.d.f, the formula expression is explicitly normalized internally
# by dividing it by a numeric integral of the expresssion over x in the range [-20,20]
x = RooRealVar("x", "x", -20, 20)
alpha = RooRealVar("alpha", "alpha", 5, 0.1, 10)
genpdf = RooGenericPdf("genpdf", "genpdf",
"(1+0.1*abs(x)+sin(sqrt(abs(x*alpha+0.1))))",
RooArgList(x, alpha))
print ">>> generate and fit toy data...\n"
data = genpdf.generate(RooArgSet(x), 10000) # RooDataSet
genpdf.fitTo(data)
frame1 = x.frame(Title("Interpreted expression pdf")) # RooPlot
data.plotOn(frame1, Binning(40))
genpdf.plotOn(frame1)
print "\n>>> construct standard pdf with formula replacing parameter..."
mean2 = RooRealVar("mean2", "mean^2", 10, 0, 200)
sigma = RooRealVar("sigma", "sigma", 3, 0.1, 10)
mean = RooFormulaVar("mean", "mean", "sqrt(mean2)", RooArgList(mean2))
gaus2 = RooGaussian("gaus2", "gaus2", x, mean, sigma)
print ">>> generate and fit toy data...\n"
gaus1 = RooGaussian("gaus1", "gaus1", x, RooConst(10), RooConst(3))
data2 = gaus1.generate(RooArgSet(x), 1000) # RooDataSet
result = gaus2.fitTo(data2, Save()) # RooFitResult
result.Print()
frame2 = x.frame(Title("Tailored Gaussian pdf")) # RooPlot
data2.plotOn(frame2, Binning(40))
gaus2.plotOn(frame2)
print "\n>>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600)
canvas.Divide(2)
canvas.cd(1)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
canvas.cd(2)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame2.GetYaxis().SetLabelOffset(0.008)
frame2.GetYaxis().SetTitleOffset(1.6)
frame2.GetYaxis().SetTitleSize(0.045)
frame2.GetXaxis().SetTitleSize(0.045)
frame2.Draw()
canvas.SaveAs("rooFit103.png")
def 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 plcLimit(obs_, poi_, model, ws, data, CL = 0.95, verbose = False):
# obs : observable variable or RooArgSet of observables
# poi : parameter of interest or RooArgSet of parameters
# model : RooAbsPdf of model to consider including any constraints
# data : RooAbsData of the data
# CL : confidence level for interval
# returns a dictionary with the upper and lower limits for the first/only
# parameter in poi_ as well as the interval object and status flag
obs = RooArgSet(obs_)
obs.setName('observables')
poi = RooArgSet(poi_)
poi.setName('poi')
poi.setAttribAll('Constant', False)
nuis = model.getParameters(obs)
nuis.remove(poi)
nuis.remove(nuis.selectByAttrib('Constant', True))
nuis.setName('nuisance')
if verbose:
print 'observables'
obs.Print('v')
print 'parameters of interest'
poi.Print('v')
print 'nuisance parameters'
nuis.Print('v')
mc = RooStats.ModelConfig('mc')
mc.SetWorkspace(ws)
mc.SetPdf(model)
mc.SetObservables(obs)
mc.SetParametersOfInterest(poi)
mc.SetNuisanceParameters(nuis)
plc = RooStats.ProfileLikelihoodCalculator(data, mc)
plc.SetConfidenceLevel(CL)
interval = plc.GetInterval()
upperLimit = Double(999.)
lowerLimit = Double(0.)
Limits = {}
paramIter = poi.createIterator()
param = paramIter.Next()
while param:
ok = interval.FindLimits(param, lowerLimit, upperLimit)
Limits[param.GetName()] = {'ok' : ok, 'upper' : float(upperLimit),
'lower' : float(lowerLimit)}
param = paramIter.Next()
if verbose:
print '%.0f%% CL limits' % (interval.ConfidenceLevel() * 100)
print Limits
Limits['interval'] = interval
return Limits
def gen_params(self, observables=None):
from ROOT import RooArgSet
if self.__parameters:
return self.__parameters
else:
if observables and not isinstance(observables, RooArgSet):
obs = RooArgSet()
for o in observables:
obs.add(o._target_() if hasattr(o, "_target_") else o)
observables = obs
params = self.__pdf.getParameters(observables)
self.__parameters = [p for p in params] + [self.__status]
return self.__parameters
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 fitNBkg(ibdt, fullbkg, isample):
slope = RooRealVar("slope", "slope", 0.5, -10, 10)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass)
cut = cut_base + '&& bdt_prob > %s' % (ibdt)
theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt],
B0Mass_ + 3 * dict_sigma[ibdt])
databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut)
r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right'),
RooFit.PrintLevel(-1))
frame = theBMass.frame()
databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7))
bkg_exp.plotOn(frame, )
canv = ROOT.TCanvas()
frame.Draw()
nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000)
ebkg = RooExtendPdf(
'ebkg', 'ebkg', bkg_exp, nbkg,
'sigRangeMC') ## here imposing the range to calculate bkg yield
ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right'), RooFit.PrintLevel(-1))
ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6))
frame.Draw()
# canv.SaveAs('bkg_fit_bdt%f_sample%i.pdf'%(ibdt,isample))
dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def main():
# setting for reduced DS to be used on the output of makeSubset.C
inputfile_name = "small.root"
tree_name = "upsTree"
# settings for full dataset (long processing time for unbinned lh)
#inputfile_name = "/data1/chibdata/collision/v2/2012_AllData_v2.root"
#tree_name = "rootuple/upsTree"
print "Opening file"
inputfile = TFile.Open(inputfile_name, "READ")
print "Importing tree"
tree = TTree()
inputfile.GetObject(tree_name, tree)
mass = RooRealVar("ups_mass", "ups_mass", 7, 11)
y = RooRealVar("ups_rapidity", "ups_rapidity", -3, 3)
pt = RooRealVar("ups_pt", "ups_pt", 0, 100)
print "Assigning dataset"
dataArgSet = RooArgSet(mass, y, pt)
dataSet = RooDataSet("yds", "Y data set", tree, dataArgSet)
cuts= "abs(ups_rapidity) < 1.25"+\
"&& ups_pt>9.5"\
reduced_ds = dataSet.reduce(RooFit.Cut(cuts))
print "Performing likelihood analysis"
dofit(reduced_ds, "Y3S")
def _make_underlying_model(self):
self.pdfs = {}
self.yields = {} # yields are plain floats
self.ryields = {} # keep track of roofit objects for memory management
nbins, xmin, xmax = self.plot.histos[0].GetBinning()
self.xvar = RooRealVar("x", "x", xmin, xmax)
self.xvar.setBins(nbins)
self.pdfs = {}
self.hists = []
pdfs = RooArgList()
yields = RooArgList()
for compname, comp in self.plot.histosDict.iteritems():
if comp.weighted.Integral() == 0:
continue
assert (isinstance(comp, Histogram))
hist = RooDataHist(compname, compname, RooArgList(self.xvar),
comp.weighted)
SetOwnership(hist, False)
# self.hists.append(hist)
pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist)
self.pdfs[compname] = pdf
# self.pdfs[compname].Print()
pdfs.add(pdf)
nevts = comp.Integral(xmin=xmin, xmax=xmax)
nmin = min(0, nevts * (1 - comp.uncertainty))
nmax = nevts * (1 + comp.uncertainty)
theyield = RooRealVar('n{}'.format(compname),
'n{}'.format(compname), nevts, nmin, nmax)
self.ryields[compname] = theyield
self.yields[compname] = nevts
yields.add(theyield)
self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def getValueAndError(cfg, obs, comp, binWidth, rfr, ttname, window=None):
""" Try to be clever and not re-compute something that has already been computed """
obs_set = RooArgSet(obs)
compname = comp.GetName()
bwidth = binWidth.getVal()
compInt = None
if ttname in cfg._yields and compname in cfg._yields[ttname]:
Ntemp = cfg._yields[ttname][compname][0]
else:
if window:
obs.setRange("myrange", window[0], window[1])
compInt = comp.createIntegral(obs_set, RF.Range("myrange"))
else:
compInt = comp.createIntegral(obs_set)
Ntemp = compInt.getVal() * bwidth
error = -1
if rfr:
if ttname in cfg._yields and compname in cfg._yields[ttname] \
and cfg._yields[ttname][compname][1] != -1:
error = cfg._yields[ttname][compname][1]
else:
if not compInt:
if window:
obs.setRange("myrange", window[0], window[1])
compInt = comp.createIntegral(obs_set, RF.Range("myrange"))
else:
compInt = comp.createIntegral(obs_set)
error = ROOT.RU.getPropagatedError(compInt, rfr) * bwidth
logging.info("Found {} +/- {} for {} in region {}".format(
Ntemp, error, compname, ttname))
return [Ntemp, error]
def write_output(self):
# Write the results to a file
from ROOT import TFile
output_file = TFile.Open(self.options().output, "recreate")
output_file.WriteTObject(self._data, self._data.GetName())
gp = self.gen_params()
if gp:
from ROOT import RooArgSet
gpars = RooArgSet()
for p in gp:
gpars.add(p)
gpars = gpars.snapshot(True)
output_file.WriteTObject(gpars, "gen_params")
output_file.Close()
def fitNBkg(ibdt, fullbkg):
slope = RooRealVar("slope", "slope", 0.5, -10, 10)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass)
cut = cut_base + '&& bdt_prob > %s' % (ibdt)
theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt],
B0Mass_ + 3 * dict_sigma[ibdt])
databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut)
r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right'))
frame = theBMass.frame()
databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7))
bkg_exp.plotOn(frame, )
# bkg_exp.fixCoefRange('left,right')
nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000)
ebkg = RooExtendPdf('ebkg', 'ebkg', bkg_exp, nbkg, 'sigRangeMC')
ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right'))
ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed),
RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6))
frame.Draw()
dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def main():
# independent variable
x = RooRealVar("x", "x", -10, 10)
# parameters
width = RooRealVar("width", "gaussian width", 2., 0., 10.)
mean = RooRealVar("mean", "gaussian mean", 0., -10., 10.)
decay = RooRealVar("decay", "decay coeff", -0.5, -1.0, 0.)
# instantiate the custom pdf
pdf = RooExpAndGauss("pdf", "custom pdf", x, mean, width, decay)
# generate random dataset
toydata = pdf.generate(RooArgSet(x), 5000)
# fit back to the dataset (I expect it will fit quite well!)
pdf.fitTo(toydata, rf.Strategy(2))
# plot the thing
canvas = TCanvas()
plot = x.frame(50)
toydata.plotOn(plot)
pdf.plotOn(plot)
plot.Draw()
canvas.SaveAs("plots/fittedRooExpAndGauss_fromPython.pdf")
return
def rooFit106():
print ">>> setup model..."
x = RooRealVar("x", "x", -3, 3)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
gauss = RooGaussian("gauss", "gauss", x, mean, sigma)
data = gauss.generate(RooArgSet(x), 10000) # RooDataSet
gauss.fitTo(data)
print ">>> plot pdf and data..."
frame = x.frame(Name("frame"), Title("RooPlot with decorations"),
Bins(40)) # RooPlot
data.plotOn(frame)
gauss.plotOn(frame)
print ">>> RooGaussian::paramOn - add box with pdf parameters..."
# https://root.cern.ch/doc/master/classRooAbsPdf.html#aa43b2556a1b419bad2b020ba9b808c1b
# Layout(Double_t xmin, Double_t xmax, Double_t ymax)
# left edge of box starts at 20% of x-axis
gauss.paramOn(frame, Layout(0.55))
print ">>> RooDataSet::statOn - add box with data statistics..."
# https://root.cern.ch/doc/master/classRooAbsData.html#a538d58020b296a1623323a84d2bb8acb
# x size of box is from 55% to 99% of x-axis range, top of box is at 80% of y-axis range)
data.statOn(frame, Layout(0.20, 0.55, 0.8))
print ">>> add text and arrow..."
text = TText(2, 100, "Signal")
text.SetTextSize(0.04)
text.SetTextColor(kRed)
frame.addObject(text)
arrow = TArrow(2, 100, -1, 50, 0.01, "|>")
arrow.SetLineColor(kRed)
arrow.SetFillColor(kRed)
arrow.SetLineWidth(3)
frame.addObject(arrow)
print ">>> persist frame with all decorations in ROOT file..."
file = TFile("rooFit106.root", "RECREATE")
frame.Write()
file.Close()
# To read back and plot frame with all decorations in clean root session do
# [0] TFile f("rooFit106.root")
# [1] xframe->Draw()
print ">>> draw functions and toy data on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.05)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit106.png")
def pdf_eval2D(self, x):
self.model.adc_east.setVal(x[0])
self.model.adc_west.setVal(x[1])
#return self.model.model.evaluate()
return 2e6*self.model.model.getValV(RooArgSet(self.adc_east, self.adc_west))
def makeHistPdf(hist, ws, x):
theVars = RooArgList(x)
v = RooArgSet(x)
dataHist = RooDataHist(hist.GetName() + '_dh', 'dataHist', theVars, hist)
hpdf = RooHistPdf(hist.GetName() + '_pdf', 'hist pdf', v, dataHist)
getattr(ws, 'import')(hpdf)
return hpdf
def getInitialFitRes(cfg, ws):
""" Create a prefit RooExpandedFitResult for this workspace """
mc = ws.obj("ModelConfig")
force_mu, mu_val = cfg.force_mu_value()
if force_mu:
mc.GetParametersOfInterest().first().setVal(mu_val)
np = RooArgList(mc.GetNuisanceParameters())
np.add(mc.GetParametersOfInterest())
ws.loadSnapshot("snapshot_paramsVals_initial")
#removeGamma(np)
it = np.createIterator()
n = it.Next()
while n:
if "alpha" in n.GetName():
n.setError(1)
else:
n.setError(1.e-4)
#if "alpha_SysJetEResol" in n.GetName():
#n.setVal(-1)
n = it.Next()
ws.saveSnapshot("vars_initial", RooArgSet(np))
re = ROOT.RooExpandedFitResult(np)
cfg._muhat = mc.GetParametersOfInterest().first().getVal()
if logging.getLogger().isEnabledFor(logging.DEBUG):
logging.debug("Expanded RooFit results")
re.Print("v")
return re
def 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 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 plotResults(ptBin1, ptBin2, combData, canvas2, canvas3):
frame1 = mass.frame(ROOT.RooFit.Bins(30), ROOT.RooFit.Title("All events"))
# Plot all data tagged as physics sample
combData.plotOn(frame1, ROOT.RooFit.Cut("sample==sample::all"))
# Plot "physics" slice of simultaneous pdf.
# NBL You _must_ project the sample index category with data using ProjWData
# as a RooSimultaneous makes no prediction on the shape in the index category
# and can thus not be integrated
simPdf.plotOn(frame1, ROOT.RooFit.Slice(sample, "all"),
ROOT.RooFit.ProjWData(RooArgSet(sample), combData))
simPdf.plotOn(frame1, ROOT.RooFit.Slice(sample, "all"),
ROOT.RooFit.Components("backgroundAll"),
ROOT.RooFit.ProjWData(RooArgSet(sample), combData),
ROOT.RooFit.LineStyle(ROOT.kDashed))
# The same plot for the control sample slice
frame2 = mass.frame(ROOT.RooFit.Bins(30),
ROOT.RooFit.Title("Passing events"))
combData.plotOn(frame2, ROOT.RooFit.Cut("sample==sample::pass"))
simPdf.plotOn(frame2, ROOT.RooFit.Slice(sample, "pass"),
ROOT.RooFit.ProjWData(RooArgSet(sample), combData))
simPdf.plotOn(frame2, ROOT.RooFit.Slice(sample, "pass"),
ROOT.RooFit.Components("backgroundPass"),
ROOT.RooFit.ProjWData(RooArgSet(sample), combData),
ROOT.RooFit.LineStyle(ROOT.kDashed))
canvas2.cd(find_position(ptBin1, ptBin2, ptBinsX) + 1)
frame1.GetYaxis().SetTitleOffset(1.4)
frame1.Draw()
frame1.SetName(
buildNamePars("fitAll_", ptBin1, ptBin1 + 1, ptBin2, ptBin2 + 1,
ptBinsX, ptBinsY))
frame1.SaveAs(
buildNamePars("fitAll_", ptBin1, ptBin1 + 1, ptBin2, ptBin2 +
1, ptBinsX, ptBinsY) + ".root")
canvas3.cd(find_position(ptBin1, ptBin2, ptBinsX) + 1)
frame2.GetYaxis().SetTitleOffset(1.4)
frame2.Draw()
frame2.SetName(
buildNamePars("fitPass_", ptBin1, ptBin1 + 1, ptBin2, ptBin2 + 1,
ptBinsX, ptBinsY))
frame2.SaveAs(
buildNamePars("fitPass_", ptBin1, ptBin1 + 1, ptBin2, ptBin2 +
1, ptBinsX, ptBinsY) + ".root")
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 rooFit203():
print ">>> setup model..."
x = RooRealVar("x", "x", -10, 10)
mean = RooRealVar("mean", "mean of gaussian", 0, -10, 10)
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, RooConst(1))
# Construct px = 1 (flat in x)
px = RooPolynomial("px", "px", x)
# Construct model = f*gx + (1-f)px
f = RooRealVar("f", "f", 0., 1.)
model = RooAddPdf("model", "model", RooArgList(gauss, px), RooArgList(f))
data = model.generate(RooArgSet(x), 10000) # RooDataSet
print ">>> fit to full data range..."
result_full = model.fitTo(data, Save(kTRUE)) # RooFitResult
print "\n>>> fit \"signal\" range..."
# Define "signal" range in x as [-3,3]
x.setRange("signal", -3, 3)
result_sig = model.fitTo(data, Save(kTRUE),
Range("signal")) # RooFitResult
print "\n>>> plot and print results..."
# Make plot frame in x and add data and fitted model
frame1 = x.frame(Title("Fitting a sub range")) # RooPlot
data.plotOn(frame1, Name("data"))
model.plotOn(frame1, Range("Full"), LineColor(kBlue),
Name("model")) # Add shape in full ranged dashed
model.plotOn(frame1, LineStyle(kDashed), LineColor(kRed),
Name("model2")) # By default only fitted range is shown
print "\n>>> result of fit on all data:"
result_full.Print()
print "\n>>> result of fit in in signal region (note increased error on signal fraction):"
result_sig.Print()
print ">>> draw on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
legend = TLegend(0.2, 0.85, 0.4, 0.65)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
gPad.SetLeftMargin(0.14)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.4)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend.AddEntry("data", "data", 'LEP')
legend.AddEntry("model", "fit (full range)", 'L')
legend.AddEntry("model2", "fit (signal range)", 'L')
legend.Draw()
canvas.SaveAs("rooFit203.png")
def 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 generate_poly(self, b, low, high, nbins, nev):
ws = RooWorkspace('ws', 'ws')
ws.factory('Polynomial::bgPol(mass[200, 500], b[-0.001])')
ws.var('mass').setRange(low, high)
ws.var('b').setVal(b)
_pdf = ws.pdf('bgPol')
ws.var('mass').setBins(nbins)
_ds = _pdf.generateBinned(RooArgSet(ws.var('mass')), nev)
_h = _ds.createHistogram('hBgpol', ws.var('mass'))
return _h
def getPrefitCurve(cfg, w, obs=None, pdf=None, regname=None):
w.loadSnapshot("vars_initial")
mc = w.obj("ModelConfig")
mc.GetParametersOfInterest().first().setVal(0)
mubeforefit = mc.GetParametersOfInterest().first().getVal()
muValueBeforeFitLegend = "Pre-fit background"
if regname is not None:
simPdf = w.pdf("simPdf")
pdf = simPdf.getPdf(regname)
obs = pdf.getObservables(mc.GetObservables()).first()
preFitIntegral = pdf.expectedEvents(RooArgSet(obs))
h = pdf.createHistogram(pdf.GetName(), obs)
h.Scale(preFitIntegral / h.Integral())
else:
preFitIntegral = pdf.expectedEvents(RooArgSet(obs))
h = pdf.createHistogram(pdf.GetName(), obs)
h.Scale(preFitIntegral / h.Integral())
w.loadSnapshot("vars_final")
return h, muValueBeforeFitLegend
def make_roodataset(python_list_of_vars, file_name,
tree_name = "BdToKstarMuMu_Data",
path_to_save = "select_kstarmumu_roodataset.root", cuts=None):
"""
Makes a RooDataSet in the current directory.
I only really want to do this once since python is slow.
"""
from ROOT import RooArgSet, RooDataSet
# open the files and get the trees
from sam.pp.utils.root import get_tree_from_file
(f,t) = get_tree_from_file(file_name, tree_name)
# get the variables into the stupid roofit format
ras = RooArgSet()
for var in python_list_of_vars:
ras.add(var)
ras.Print()
from ROOT import TFile
fcut = TFile('/tmp/temp.root', 'RECREATE')
if cuts:
tr = t.CopyTree(cuts)
else:
tr = t
# make a RooDataSet from both trees
print("making the RooArgSet... yes this takes a long time because python"\
+ " is slower than C++ \nperhaps you could use the time to reflect"\
+ "on how much you hate coding C++ and how beautiful python is")
ds = RooDataSet("ds", "data set", tr, ras)
print("made the RooDataSet")
fcut.Close()
# save it
#from ROOT import TFile
fds = TFile(path_to_save, "RECREATE")
fds.cd()
ds.Write()
print("saved the RooDataSet")
return ds
def get_num_sig_bkg(hist_DataTemplate, hist_SignalTemplate,
hist_BackgdTemplate, fit_range_min, fit_range_max):
'''Given 3 input histograms (TH1F), and a fit range, this function finds
the amount of signal and background that sum up to the data histogram.
It does histogram fits.'''
# Find range of data template
data_min = hist_DataTemplate.GetXaxis().GetXmin()
data_max = hist_DataTemplate.GetXaxis().GetXmax()
# Create basic variables
x = RooRealVar("x", "x", data_min, data_max)
x.setBins(hist_DataTemplate.GetXaxis().GetNbins()) # Binned x values
nsig = RooRealVar("nsig", "number of signal events", 0,
hist_DataTemplate.Integral())
nbkg = RooRealVar("nbkg", "number of background events", 0,
hist_DataTemplate.Integral())
# Create RooDataHists from input TH1Fs
dh = RooDataHist("dh", "dh", RooArgList(x), hist_DataTemplate)
ds = RooDataHist("ds", "ds", RooArgList(x), hist_SignalTemplate)
db = RooDataHist("db", "db", RooArgList(x), hist_BackgdTemplate)
# Create Probability Distribution Functions from Monte Carlo
sigPDF = RooHistPdf("sigPDF", "sigPDF", RooArgSet(x), ds)
bkgPDF = RooHistPdf("bkgPDF", "bkgPDF", RooArgSet(x), db)
model = RooAddPdf("model", "(g1+g2)+a", RooArgList(bkgPDF, sigPDF),
RooArgList(nbkg, nsig))
# Find the edges of the bins that contain the fit range min/max
data_min = hist_DataTemplate.GetXaxis().GetBinLowEdge(
hist_DataTemplate.GetXaxis().FindFixBin(fit_range_min))
data_max = hist_DataTemplate.GetXaxis().GetBinUpEdge(
hist_DataTemplate.GetXaxis().FindFixBin(fit_range_max))
r = model.fitTo(dh, RooFit.Save(), RooFit.Minos(0),
RooFit.PrintEvalErrors(0), RooFit.Extended(),
RooFit.Range(data_min, data_max))
r.Print("v")
#print nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError()
return [nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError()]
def reGenerate(dataset, pdf, variable):
from ROOT import RooFit, RooArgSet
# step 1: preliminary fit
fr = pdf.fitTo(dataset, RooFit.SumW2Error(True), RooFit.Range("X_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(-1))
# step 2: generate new dataset
nev = dataset.sumEntries()
nev = max(nev, 1000)
dataset2 = pdf.generate(RooArgSet(variable), nev)
#step 3: refit
fr2 = pdf.fitTo(dataset2, RooFit.SumW2Error(False), RooFit.Range("X_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(-1))
return pdf, fr2
def histoToCountingSet(ws, cfg, section, histo, rds, nObs):
nBins = len(cfg.get(section, 'obsBins').split(',')) - 1
makeLastBinOverflow(histo, nBins)
getattr(ws, 'import')(histo)
obsTemp = ws.var('%s_%s' % (cfg.get(section, 'obsVar'), section))
for i in range(1, histo.GetNbinsX() + 1): # last bin = overflow + last bin
# push bin values into the histos
obsTemp.setVal(histo.GetBinCenter(i))
nObs.setVal(histo.GetBinContent(i))
rds.add(RooArgSet(obsTemp, nObs))
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 __init__(self, name, expr, deps):
self.name = name
self.expr = expr
self.deps = deps
dependentlist = RooArgList()
for dep in deps:
dependentlist.add(dep)
self.pdf_yield = RooGenericPdf(name, name, expr, dependentlist)
pname = name + "Constraint"
self.pdf_constraint = RooUniform(pname, pname,
RooArgSet(self.pdf_yield))
self.pulls = ROOT.TH1F('pulls_' + name, name, 1000, -10, 10)
def getYields(cfg, w, rfr=None, onlyTot=False, window=None):
""" Give map of yields (each category and total) for current snapshot of workspace
If RooFitResult is given, the errors are computed
If onlyTot = True, error is computed only on the sum of MC
"""
if cfg._comps is None:
cfg._comps = getComponents(cfg, w)
comps = cfg._comps
if window:
logging.info("Will compute weights in window {}".format(window))
cfg._read_yields()
yields = cfg._yields
if len(cfg._yields) > 0 and rfr is None:
return cfg._yields
if onlyTot:
comp_rfr = None
else:
comp_rfr = rfr
for ttname, comptt in comps.iteritems():
logging.info(" Computing yields for category : {}".format(ttname))
obs_set = RooArgSet(comptt[0])
yieldsChan = {}
if window:
rname = comptt[0].GetName() + "_range"
comptt[0].setRange(rname, window[0], window[1])
yieldsChan["data"] = comptt[2].sumEntries("1", rname)
else:
yieldsChan["data"] = comptt[2].sumEntries()
for compname, comp in comptt[3].iteritems():
if compname != "MC":
yieldsChan[compname] = getValueAndError(
cfg, comptt[0], comp, comptt[1], comp_rfr, ttname, window)
else:
yieldsChan[compname] = getValueAndError(
cfg, comptt[0], comp, comptt[1], rfr, ttname, window)
if compname == "Signal" and cfg._muhat:
yieldsChan["SignalExpected"] = [
y / cfg._muhat for y in yieldsChan[compname]
]
yieldsChan["S/B"] = yieldsChan["Signal"][0] / yieldsChan["Bkg"][0]
yieldsChan["S/sqrt(S+B)"] = yieldsChan["Signal"][0] / (
yieldsChan["Bkg"][0] + yieldsChan["Signal"][0])**.5
yields[ttname] = yieldsChan
cfg._yields = yields
cfg._save_yields()
return yields
def getSumAndError(list_comps, rfr, window=None):
""" list_comps: list of tuples (obs, bwidth, comp)
"""
complist = RooArgList()
widthlist = RooArgList()
logging.debug("{}".format(list_comps))
for l in list_comps:
if window:
l[0].setRange("myrange", window[0], window[1])
inte = l[2].createIntegral(RooArgSet(l[0]), RF.Range("myrange"))
else:
inte = l[2].createIntegral(RooArgSet(l[0]))
complist.add(inte)
widthlist.add(RF.RooConst(l[1]))
roosum = RooAddition("sum", "sum", complist, widthlist)
val = roosum.getVal()
if rfr is not None:
error = ROOT.RU.getPropagatedError(roosum, rfr)
else:
error = -1
return [val, error]
def fillSingleCandidate(mass, p, track1, track2, histoMap, datasetMap):
cosineAndMass = computeCosineAndMass(track1, track2)
if not passDileptonSelection(track1, track2, cosineAndMass[0]): return False
if cosineAndMass[1] < p.minMass or cosineAndMass[1] > p.maxMass: return False
mass.setVal(cosineAndMass[1])
bins = find_bins(track1.pt, track2.pt, p.ptBinsX, p.ptBinsY)
if bins[0] == -1 or bins[1] == -1: return False
if track1.charge == track2.charge: return False
histoMap[bins].Fill(mass.getVal())
#print bins, cosineAndMass[1], track1.pt, track2.pt
datasetMap[bins].add(RooArgSet(mass))
return True
def performFitInLeptonAbsEta(data_histogram, signal_histogram, bkg1_histogram, bkg2_histogram):
N_Data = data_histogram.Integral()
N_signal = signal_histogram.Integral()
N_bkg1 = bkg1_histogram.Integral()
N_bkg2 = bkg2_histogram.Integral()
leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.)
variables = RooArgList()
variables.add(leptonAbsEta)
variable_set = RooArgSet()
variable_set.add(leptonAbsEta)
lowerBound = 0
upperBound = N_Data*2
data_RooDataHist = RooDataHist("data", "dataset with leptonAbsEta", variables, data_histogram)
signal_RooDataHist = RooDataHist("rh_signal", "signal", variables, signal_histogram);
bkg1_RooDataHist = RooDataHist("rh_bkg1", "bkg1", variables, bkg1_histogram);
bkg2_RooDataHist = RooDataHist("rh_bkg2", "bkg2", variables, bkg2_histogram);
signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0)
signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0)
def generate_bw(self, peak, width, low, high, nbins, nev):
ws = RooWorkspace('ws', 'ws')
ws.factory(
'BreitWigner::bw(mass[200, 600], peak[350, 200, 700], width[50])')
ws.var('mass').setRange(low, high)
ws.var('peak').setVal(peak)
ws.var('width').setVal(width)
_bw = ws.pdf('bw')
ws.var('mass').setBins(nbins)
_ds = _bw.generateBinned(RooArgSet(ws.var('mass')), nev)
_h = _ds.createHistogram('hBw', ws.var('mass'))
return _h
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 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 hessian(nll, parameters, N = 9):
values = dict([(p.GetName(), (p.getVal(), p.getError())) for p in parameters])
nll_min = nll.getVal()
__parameters = RooArgSet()
for p in parameters:
__parameters.add(p)
nll_params = nll.getObservables(__parameters)
H = TMatrixTSym('double')(parameters.getSize())
diagonals = {}
for i, x in enumerate(parameters):
p = nll_params.find(x.GetName())
r = fit_parabola(nll, nll_min, p, N)
diagonals[p.GetName()] = r
H[i][i] = 2 * r[1]
for i, x in enumerate(parameters):
x = nll_params.find(x.GetName())
for j in range(i + 1, parameters.getSize()):
y = nll_params.find(parameters.at(j).GetName())
H[i][j] = H[j][i] = fit_cross(nll, nll_min, x, y, diagonals, N)
return H
def fit(self):
fit_variable = RooRealVar("fit_variable", "fit_variable", self.fit_boundaries[0], self.fit_boundaries[1])
fit_variable.setBins(self.histograms[self.data_label].nbins())
variables = RooArgList()
variables.add(fit_variable)
variable_set = RooArgSet()
variable_set.add(fit_variable)
roofit_histograms = {}
roofit_pdfs = {}
roofit_variables = {}
N_min = 0.0
N_max = self.normalisation[self.data_label] * 2.0
pdf_arglist = RooArgList()
variable_arglist = RooArgList()
roofit_histograms[self.data_label] = RooDataHist(
self.data_label, self.data_label, variables, self.histograms[self.data_label]
)
for sample in self.samples:
roofit_histogram = RooDataHist(sample, sample, variables, self.histograms[sample])
roofit_histograms[sample] = roofit_histogram
roofit_pdf = RooHistPdf("pdf" + sample, "pdf" + sample, variable_set, roofit_histogram)
roofit_pdfs[sample] = roofit_pdf
roofit_variable = RooRealVar(sample, sample + " events", self.normalisation[sample], N_min, N_max)
roofit_variables[sample] = roofit_variable
pdf_arglist.add(roofit_pdf)
variable_arglist.add(roofit_variable)
model = RooAddPdf("model", "sum of all known", pdf_arglist, variable_arglist)
use_model = model
if self.constraints:
arg_set = RooArgSet(model)
constraints = self.get_fit_normalisation_constraints(model, roofit_variables)
for constraint in constraints:
arg_set.add(constraint)
model_with_constraints = RooProdPdf(
"model_with_constraints", "model with gaussian constraints", arg_set, RooLinkedList()
)
use_model = model_with_constraints
if self.method == "TMinuit":
# WARNING: number of cores changes the results!!!
self.saved_result = use_model.fitTo(
roofit_histograms[self.data_label],
RooFit.Minimizer("Minuit2", "Migrad"),
RooFit.NumCPU(1),
RooFit.Extended(),
RooFit.Save(),
)
results = {}
for sample in self.samples:
results[sample] = (roofit_variables[sample].getVal(), roofit_variables[sample].getError())
self.results = results
def stackedPlot(self, var, logy = False, pdfName = None, Silent = False):
if not pdfName:
pdfName = 'total'
xvar = self.ws.var(var)
nbins = xvar.getBins()
# if hasattr(self.pars, 'plotRanges') and not xvar.hasRange('plotRange'):
# xvar.setRange('plotRange', self.pars.plotRanges[var][1],
# self.pars.plotRanges[var][2])
# xvar.setBins(self.pars.plotRanges[var][0], 'plotBins')
# elif not xvar.hasRange('plotRange'):
# xvar.setRange('plotRange', xvar.getMin(), xvar.getMax())
# xvar.setBins(nbins, 'plotBins')
sframe = xvar.frame(RooFit.Range('plotRange'),
RooFit.Bins(xvar.getBins('plotBins')))
sframe.SetName("%s_stacked" % var)
pdf = self.ws.pdf(pdfName)
if isinstance(pdf, RooAddPdf):
compList = RooArgList(pdf.pdfList())
else:
compList = None
data = self.ws.data('data_obs')
nexp = pdf.expectedEvents(self.ws.set('obsSet'))
if not Silent:
print pdf.GetName(),'expected: %.0f' % (nexp)
print 'data events: %.0f' % (data.sumEntries())
if nexp < 1:
nexp = data.sumEntries()
theComponents = []
if self.pars.includeSignal:
theComponents += self.pars.signals
theComponents += self.pars.backgrounds
data.plotOn(sframe, RooFit.Invisible(),
RooFit.Binning('plotBins'))
# dataHist = RooAbsData.createHistogram(data,'dataHist_%s' % var, xvar,
# RooFit.Binning('%sBinning' % var))
# #dataHist.Scale(1., 'width')
# invData = RooHist(dataHist, 1., 1, RooAbsData.SumW2, 1.0, False)
# #invData.Print('v')
# sframe.addPlotable(invData, 'pe', True, True)
for (idx,component) in enumerate(theComponents):
if not Silent:
print 'plotting',component,'...',
if hasattr(self.pars, '%sPlotting' % (component)):
plotCharacteristics = getattr(self.pars, '%sPlotting' % \
(component))
else:
plotCharacteristics = {'color' : colorwheel[idx%6],
'title' : component }
compCmd = RooCmdArg.none()
if compList:
compSet = RooArgSet(compList)
if compSet.getSize() > 0:
compCmd = RooFit.Components(compSet)
removals = compList.selectByName('%s*' % component)
compList.remove(removals)
if not Silent:
print 'events', self.ws.function('f_%s_norm' % component).getVal()
sys.stdout.flush()
if abs(self.ws.function('f_%s_norm' % component).getVal()) >= 1.:
pdf.plotOn(sframe, #RooFit.ProjWData(data),
RooFit.DrawOption('LF'), RooFit.FillStyle(1001),
RooFit.FillColor(plotCharacteristics['color']),
RooFit.LineColor(plotCharacteristics['color']),
RooFit.VLines(),
RooFit.Range('plotRange'),
RooFit.NormRange('plotRange'),
RooFit.Normalization(nexp, RooAbsReal.NumEvent),
compCmd
)
tmpCurve = sframe.getCurve()
tmpCurve.SetName(component)
tmpCurve.SetTitle(plotCharacteristics['title'])
if 'visible' in plotCharacteristics:
sframe.setInvisible(component,
plotCharacteristics['visible'])
data.plotOn(sframe, RooFit.Name('theData'),
RooFit.Binning('plotBins'))
sframe.getHist('theData').SetTitle('data')
# theData = RooHist(dataHist, 1., 1, RooAbsData.SumW2, 1.0, True)
# theData.SetName('theData')
# theData.SetTitle('data')
# sframe.addPlotable(theData, 'pe')
if (logy):
sframe.SetMinimum(0.01)
sframe.SetMaximum(1.0e6)
else:
sframe.SetMaximum(sframe.GetMaximum()*1.35)
pass
excluded = (var in self.pars.exclude)
bname = var
if not excluded:
for v in self.pars.exclude:
if hasattr(self.pars, 'varNames') and \
(self.pars.varNames[v] == var):
excluded = True
bname = v
if excluded:
blinder = TBox(self.pars.exclude[bname][0], sframe.GetMinimum(),
self.pars.exclude[bname][1], sframe.GetMaximum())
# blinder.SetName('blinder')
# blinder.SetTitle('signal region')
blinder.SetFillColor(kBlack)
if self.pars.blind:
blinder.SetFillStyle(1001)
else:
blinder.SetFillStyle(0)
blinder.SetLineStyle(2)
sframe.addObject(blinder)
elif self.pars.blind:
if not Silent:
print "blind but can't find exclusion region for", var
print 'excluded',excluded,self.pars.exclude
print 'hiding data points'
sframe.setInvisible('theData', True)
else:
sframe.setInvisible('theData', False)
#sframe.GetYaxis().SetTitle('Events / GeV')
# dataHist.IsA().Destructor(dataHist)
if not Silent:
print
xvar.setBins(nbins)
return sframe
runPeriods = [ 2011 ]
KKMassBins = [ 990., 1050. ]
removeVars = [ 'tagCatP2VV' ]
selection = 'hlt2_biased==1'
numDataSets = 40
weightName = ''
import P2VV.RooFitWrappers
from ROOT import TFile, RooArgSet
protoFile = TFile.Open(protoFilePathIn)
nTupleFileIn = TFile.Open(nTupleFilePathIn)
protoData = protoFile.Get('JpsiKK_sigSWeight')
nTupleIn = nTupleFileIn.Get('DecayTree')
from ROOT import RooRealVar, RooCategory
obsSet = RooArgSet( protoData.get() )
if runPeriods :
rp = obsSet.find('runPeriod')
if rp : obsSet.remove(rp)
rp = RooCategory( 'runPeriod', 'runPeriod' )
for per in runPeriods : rp.defineType( 'p%d' % per, per )
obsSet.add(rp)
if KKMassBins :
KKCat = obsSet.find('KKMassCat')
if KKCat : obsSet.remove(KKCat)
KKCat = RooCategory( 'KKMassCat', 'KKMassCat' )
for ind in range( len(KKMassBins) - 1 ) : KKCat.defineType( 'bin%d' % ind, ind )
obsSet.add(KKCat)
from array import array
def doFit(ws,options):
rap_bins = range(1,len(jpsi.pTRange))
pt_bins = None
if options.testBin is not None:
rap_bins = [int(options.testBin.split(',')[0])]
pt_bins = [int(options.testBin.split(',')[1])-1]
for rap_bin in rap_bins:
if options.testBin is None:
pt_bins = range(len(jpsi.pTRange[rap_bin]))
for pt_bin in pt_bins:
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]
jPsiMass = ws.var('JpsiMass')
jPsicTau = ws.var('Jpsict')
jPsiMass.setRange('mlfit_prompt',2.7,3.5)
jPsiMass.setRange('mlfit_nonPrompt',2.7,3.5)
jPsiMass.setRange('NormalizationRangeFormlfit_prompt',2.7,3.5)
jPsiMass.setRange('NormalizationRangeFormlfit_nonPrompt',2.7,3.5)
jPsicTau.setRange('mlfit_signal',-1,2.5)
jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5)
jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5)
jPsicTau.setRange('NormalizationRangeFormlfit_signal',-1,2.5)
jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5)
jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5)
#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)
#jPsicTau.setRange('mlfit_promptSignal',-1,.1)
#jPsicTau.setRange('mlfit_nonPromptSignal',.1,2.5)
#jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5)
#jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5)
#reset parameters
ws.var('CBn').setVal(.5)
ws.var('CBalpha').setVal(.5)
ws.var('CBmass').setVal(3.1)
ws.var('CBsigma').setVal(.02)
ws.var('bkgLambda').setVal(0)
ws.var('bkgTauSSDL').setVal(.5)
#ws.var('bkgTauFDL').setVal(.5)
ws.var('bkgTauDSDL').setVal(.5)
ws.var('fBkgSSDL').setVal(.5)
ws.var('fBkgLR').setVal(.5)
ws.var('bkgTauSSDR').setVal(.5)
#ws.var('bkgTauFDR').setVal(.5)
ws.var('bkgTauDSDR').setVal(.5)
ws.var('fBkgSSDR').setVal(.5)
#ws.var('fBkgFDR').setVal(.25)
#ws.var('nPrompt').setVal(5000)
#ws.var('nNonPrompt').setVal(500)
#ws.var('nBackground').setVal(100)
#ws.var('nBackgroundL').setVal(50)
#ws.var('nBackgroundR').setVal(50)
ws.var('nonPromptTau').setVal(.5)
ws.var('promptMean').setVal(0)
ws.var('ctResolution').setVal(1)
LPdf = ws.pdf('LPdf')
MPdf = ws.pdf('MPdf')
data = ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1))
NLLs = RooArgSet()
MassNLL = MPdf.createNLL(data,
ROOT.RooFit.Range('mlfit'),
ROOT.RooFit.SplitRange(True),
ROOT.RooFit.ConditionalObservables(RooArgSet(ws.var('JpsictErr'))),
ROOT.RooFit.NumCPU(2))
CTauNLL = LPdf.createNLL(data,
ROOT.RooFit.Range('mlfit'),
ROOT.RooFit.SplitRange(True),
ROOT.RooFit.ConditionalObservables(RooArgSet(ws.var('JpsictErr'))),
ROOT.RooFit.NumCPU(2))
NLLs.add(MassNLL)
NLLs.add(CTauNLL)
simNLL = RooAddition('add','add',NLLs)
minuit = RooMinuit(simNLL)
minuit.setStrategy(2)
minuit.setPrintEvalErrors(-1)
minuit.simplex()
minuit.migrad()
minuit.migrad()
minuit.hesse()
fitresult = minuit.save('polfitresult_rap'+str(rap_bin)+'_pt'+str(pt_bin+1))
getattr(ws,'import')(fitresult)
ws.saveSnapshot('snapshot_rap'+str(rap_bin)+'_pt'+str(pt_bin+1),ws.allVars())
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)
def latexfitresults(filename,regionList,sampleList,exactRegionNames=False,dataname='obsData',showSum=False, doAsym=True, blinded=False):
workspacename = 'w'
w = Util.GetWorkspaceFromFile(filename,'w')
if w==None:
print "ERROR : Cannot open workspace : ", workspacename
sys.exit(1)
resultAfterFit = w.obj('RooExpandedFitResult_afterFit')
if resultAfterFit==None:
print "ERROR : Cannot open fit result after fit RooExpandedFitResult_afterFit"
sys.exit(1)
resultBeforeFit = w.obj('RooExpandedFitResult_beforeFit')
if resultBeforeFit==None:
print "ERROR : Cannot open fit result before fit RooExpandedFitResult_beforeFit"
sys.exit(1)
data_set = w.data(dataname)
if data_set==None:
print "ERROR : Cannot open dataset : ", "data_set"+suffix
sys.exit(1)
regionCat = w.obj("channelCat")
data_set.table(regionCat).Print("v");
regionFullNameList = [ Util.GetFullRegionName(regionCat, region) for region in regionList]
print regionFullNameList
######
snapshot = 'snapshot_paramsVals_RooExpandedFitResult_afterFit'
w.loadSnapshot(snapshot)
if not w.loadSnapshot(snapshot):
print "ERROR : Cannot load snapshot : ", snapshot
sys.exit(1)
tablenumbers = {}
# SUM ALL REGIONS
sumName = ""
for index, reg in enumerate(regionList):
if index == 0:
sumName = reg
else:
sumName = sumName + " + " + reg
regionListWithSum = list(regionList)
if showSum:
regionListWithSum.append(sumName)
tablenumbers['names'] = regionListWithSum
regionCatList = [ 'channelCat==channelCat::' +region.Data() for region in regionFullNameList]
regionDatasetList = [data_set.reduce(regioncat) for regioncat in regionCatList]
for index, data in enumerate(regionDatasetList):
data.SetName("data_" + regionList[index])
data.SetTitle("data_" + regionList[index])
nobs_regionList = [ data.sumEntries() for data in regionDatasetList]
#SUM
sumNobs = 0.
for nobs in nobs_regionList:
sumNobs += nobs
## print " \n XXX nobs = ", nobs, " sumNobs = ", sumNobs
if showSum:
nobs_regionList.append(sumNobs)
tablenumbers['nobs'] = nobs_regionList
######
######
###### FROM HERE ON OUT WE CALCULATE THE FITTED NUMBER OF EVENTS __AFTER__ THE FIT
######
######
# total pdf, not splitting in components
pdfinRegionList = [ Util.GetRegionPdf(w, region) for region in regionList]
varinRegionList = [ Util.GetRegionVar(w, region) for region in regionList]
rrspdfinRegionList = []
for index,pdf in enumerate(pdfinRegionList):
# pdf.Print("t")
prodList = pdf.pdfList()
foundRRS = 0
for idx in range(prodList.getSize()):
# if "BG" in prodList[idx].GetName():
# prodList[idx].Print("t")
if prodList[idx].InheritsFrom("RooRealSumPdf"):
rrspdfInt = prodList[idx].createIntegral(RooArgSet(varinRegionList[index]));
rrspdfinRegionList.append(rrspdfInt)
foundRRS += 1
if foundRRS >1 or foundRRS==0:
print " \n\n WARNING: ", pdf.GetName(), " has ", foundRRS, " instances of RooRealSumPdf"
print pdf.GetName(), " component list:", prodList.Print("v")
nFittedInRegionList = [ pdf.getVal() for index, pdf in enumerate(rrspdfinRegionList)]
pdfFittedErrInRegionList = [ Util.GetPropagatedError(pdf, resultAfterFit, doAsym) for pdf in rrspdfinRegionList]
if showSum:
pdfInAllRegions = RooArgSet()
for index, pdf in enumerate(rrspdfinRegionList):
pdfInAllRegions.add(pdf)
pdfSumInAllRegions = RooAddition( "pdf_AllRegions_AFTER", "pdf_AllRegions_AFTER", RooArgList(pdfInAllRegions))
pdfSumInAllRegions.Print()
nPdfSumVal = pdfSumInAllRegions.getVal()
nPdfSumError = Util.GetPropagatedError(pdfSumInAllRegions, resultAfterFit, doAsym)
nFittedInRegionList.append(nPdfSumVal)
pdfFittedErrInRegionList.append(nPdfSumError)
tablenumbers['TOTAL_FITTED_bkg_events'] = nFittedInRegionList
tablenumbers['TOTAL_FITTED_bkg_events_err'] = pdfFittedErrInRegionList
if blinded:
nobs_regionList = [ data.sumEntries() for data in regionDatasetList]
nobs_regionList[-1] = -1
tablenumbers['nobs'] = nobs_regionList
# components
for isam, sample in enumerate(sampleList):
sampleName=getName(sample)
nSampleInRegionVal = []
nSampleInRegionError = []
sampleInAllRegions = RooArgSet()
for ireg, region in enumerate(regionList):
sampleInRegion=getPdfInRegions(w,sample,region)
#sampleInRegion = Util.GetComponent(w,sample,region,exactRegionNames)
sampleInRegionVal = 0.
sampleInRegionError = 0.
if not sampleInRegion==None:
sampleInRegion.Print()
sampleInRegionVal = sampleInRegion.getVal()
sampleInRegionError = Util.GetPropagatedError(sampleInRegion, resultAfterFit, doAsym)
sampleInAllRegions.add(sampleInRegion)
else:
print " \n YieldsTable.py: WARNING: sample =", sampleName, " non-existent (empty) in region =",region, "\n"
nSampleInRegionVal.append(sampleInRegionVal)
nSampleInRegionError.append(sampleInRegionError)
if showSum:
sampleSumInAllRegions = RooAddition( (sampleName+"_AllRegions_FITTED"), (sampleName+"_AllRegions_FITTED"), RooArgList(sampleInAllRegions))
sampleSumInAllRegions.Print()
nSampleSumVal = sampleSumInAllRegions.getVal()
nSampleSumError = Util.GetPropagatedError(sampleSumInAllRegions, resultAfterFit, doAsym)
nSampleInRegionVal.append(nSampleSumVal)
nSampleInRegionError.append(nSampleSumError)
tablenumbers['Fitted_events_'+sampleName] = nSampleInRegionVal
tablenumbers['Fitted_err_'+sampleName] = nSampleInRegionError
print tablenumbers
######
######
###### FROM HERE ON OUT WE CALCULATE THE EXPECTED NUMBER OF EVENTS __BEFORE__ THE FIT
######
######
# FROM HERE ON OUT WE CALCULATE THE EXPECTED NUMBER OF EVENTS BEFORE THE FIT
w.loadSnapshot('snapshot_paramsVals_RooExpandedFitResult_beforeFit')
# check if any of the initial scaling factors is != 1
_result = w.obj('RooExpandedFitResult_beforeFit')
_muFacs = _result.floatParsFinal()
for i in range(len(_muFacs)):
if "mu_" in _muFacs[i].GetName() and _muFacs[i].getVal() != 1.0:
print " \n WARNING: scaling factor %s != 1.0 (%g) expected MC yield WILL BE WRONG!" % (_muFacs[i].GetName(), _muFacs[i].getVal())
pdfinRegionList = [ Util.GetRegionPdf(w, region) for region in regionList]
varinRegionList = [ Util.GetRegionVar(w, region) for region in regionList]
rrspdfinRegionList = []
for index,pdf in enumerate(pdfinRegionList):
prodList = pdf.pdfList()
foundRRS = 0
for idx in range(prodList.getSize()):
if prodList[idx].InheritsFrom("RooRealSumPdf"):
prodList[idx].Print()
rrspdfInt = prodList[idx].createIntegral(RooArgSet(varinRegionList[index]))
rrspdfinRegionList.append(rrspdfInt)
foundRRS += 1
if foundRRS >1 or foundRRS==0:
print " \n\n WARNING: ", pdf.GetName(), " has ", foundRRS, " instances of RooRealSumPdf"
print pdf.GetName(), " component list:", prodList.Print("v")
nExpInRegionList = [ pdf.getVal() for index, pdf in enumerate(rrspdfinRegionList)]
pdfExpErrInRegionList = [ Util.GetPropagatedError(pdf, resultBeforeFit, doAsym) for pdf in rrspdfinRegionList]
if showSum:
pdfInAllRegions = RooArgSet()
for index, pdf in enumerate(rrspdfinRegionList):
pdfInAllRegions.add(pdf)
pdfSumInAllRegions = RooAddition( "pdf_AllRegions_BEFORE", "pdf_AllRegions_BEFORE", RooArgList(pdfInAllRegions))
nPdfSumVal = pdfSumInAllRegions.getVal()
nPdfSumError = Util.GetPropagatedError(pdfSumInAllRegions, resultBeforeFit, doAsym)
nExpInRegionList.append(nPdfSumVal)
pdfExpErrInRegionList.append(nPdfSumError)
tablenumbers['TOTAL_MC_EXP_BKG_events'] = nExpInRegionList
tablenumbers['TOTAL_MC_EXP_BKG_err'] = pdfExpErrInRegionList
for isam, sample in enumerate(sampleList):
sampleName=getName(sample)
nMCSampleInRegionVal = []
nMCSampleInRegionError = []
MCSampleInAllRegions = RooArgSet()
for ireg, region in enumerate(regionList):
MCSampleInRegion = getPdfInRegions(w,sample,region)
#MCSampleInRegion = Util.GetComponent(w,sample,region,exactRegionNames)
MCSampleInRegionVal = 0.
MCSampleInRegionError = 0.
if not MCSampleInRegion==None:
MCSampleInRegionVal = MCSampleInRegion.getVal()
MCSampleInRegionError = Util.GetPropagatedError(MCSampleInRegion, resultBeforeFit, doAsym)
MCSampleInAllRegions.add(MCSampleInRegion)
else:
print " \n WARNING: sample=", sampleName, " non-existent (empty) in region=",region
nMCSampleInRegionVal.append(MCSampleInRegionVal)
nMCSampleInRegionError.append(MCSampleInRegionError)
if showSum:
MCSampleSumInAllRegions = RooAddition( (sampleName+"_AllRegions_MC"), (sampleName+"_AllRegions_MC"), RooArgList(MCSampleInAllRegions))
nMCSampleSumVal = MCSampleSumInAllRegions.getVal()
nMCSampleSumError = Util.GetPropagatedError(MCSampleSumInAllRegions, resultBeforeFit, doAsym)
nMCSampleInRegionVal.append(nMCSampleSumVal)
nMCSampleInRegionError.append(nMCSampleSumError)
tablenumbers['MC_exp_events_'+sampleName] = nMCSampleInRegionVal
tablenumbers['MC_exp_err_'+sampleName] = nMCSampleInRegionError
# sorted(tablenumbers, key=lambda sample: sample[1]) # sort by age
map_listofkeys = tablenumbers.keys()
map_listofkeys.sort()
for name in map_listofkeys:
if tablenumbers.has_key(name) :
print name, ": ", tablenumbers[name]
###
return tablenumbers
def doDataFit(Chib1_parameters,Chib2_parameters, cuts, inputfile_name = None, RooDataSet = None, ptBin_label='', plotTitle = "#chi_{b}",fittedVariable='qValue', printSigReso = False, noPlots = False, useOtherSignalParametrization = False, useOtherBackgroundParametrization = False, massFreeToChange = False, sigmaFreeToChange = False, legendOnPlot=True, drawPulls=False, titleOnPlot=False, cmsOnPlot=True, printLegend=True):
if RooDataSet != None:
dataSet = RooDataSet
elif inputfile_name != None:
print "Creating DataSet from file "+str(inputfile_name)
dataSet = makeRooDataset(inputfile_name)
else:
raise ValueError('No dataset and no inputfile passed to function doDataFit')
if(fittedVariable == 'refittedMass'):
x_var = 'rf1S_chib_mass'
output_suffix = '_refit'
x_axis_label= 'm_{#mu^{+} #mu^{-} #gamma} [GeV]'
else:
x_var = 'invm1S'
output_suffix = '_qValue'
x_axis_label = 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon} [GeV]'
cuts_str = str(cuts)
#cuts_str = quality_cut + "photon_pt > 0.5 && abs(photon_eta) < 1.0 && ctpv < 0.01 && abs(dimuon_rapidity) < 1.3 && pi0_abs_mass > 0.025 && abs(dz) < 0.5"
data = dataSet.reduce( RooFit.Cut(cuts_str) )
print 'Creating pdf'
x=RooRealVar(x_var, 'm(#mu #mu #gamma) - m(#mu #mu) + m_{#Upsilon}',9.7,10.1,'GeV')
numBins = 80 # define here so that if I change it also the ndof change accordingly
x.setBins(numBins)
# cristal balls
mean_1 = RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,"GeV")
sigma_1 = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', Chib1_parameters.a1)
n1_1 = RooRealVar('n1_1', 'n1_1', Chib1_parameters.n1)
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1',Chib1_parameters.a2)
n2_1 = RooRealVar('n2_1', 'n2_1', Chib1_parameters.n2)
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
mean_2 = RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,"GeV")
sigma_2 = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', Chib2_parameters.a1)
n1_2 = RooRealVar('n1_2', 'n1_2', Chib2_parameters.n1)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', Chib2_parameters.a2)
n2_2 = RooRealVar('n2_2', 'n2_2', Chib2_parameters.n2)
parameters.add(RooArgSet( a1_2, a2_2, n1_2, n2_2))
if massFreeToChange:
# scale_mean = RooRealVar('scale_mean', 'Scale that multiplies masses found with MC', 0.8,1.2)
# mean_1_fixed = RooRealVar("mean_1_fixed","mean ChiB1",Chib1_parameters.mean,"GeV")
# mean_2_fixed = RooRealVar("mean_2_fixed","mean ChiB2",Chib2_parameters.mean,"GeV")
# mean_1 = RooFormulaVar("mean_1",'@0*@1', RooArgList(scale_mean, mean_1_fixed))
# mean_2 = RooFormulaVar("mean_2",'@0*@1', RooArgList(scale_mean, mean_2_fixed))
variazione_m = 0.05 # 50 MeV
diff_m_12 = RooRealVar('diff_m_12', 'Difference between masses chib1 and chib2',0.0194,'GeV') # 19.4 MeV from PDG
mean_1=RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,Chib1_parameters.mean-variazione_m,Chib1_parameters.mean+variazione_m ,"GeV")
mean_2=RooFormulaVar('mean_2', '@0+@1',RooArgList(mean_1, diff_m_12))
# mean_2=RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,Chib2_parameters.mean-variazione_m,Chib2_parameters.mean+variazione_m ,"GeV")
parameters.add(mean_1)
else:
parameters.add(RooArgSet(mean_1, mean_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2)
if sigmaFreeToChange:
scale_sigma = RooRealVar('scale_sigma', 'Scale that multiplies sigmases found with MC', 1, 1.1)#1.01
sigma_1_fixed = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV')
sigma_2_fixed = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV')
sigma_1 = RooFormulaVar("sigma_1",'@0*@1', RooArgList(scale_sigma, sigma_1_fixed))
sigma_2 = RooFormulaVar("sigma_2",'@0*@1', RooArgList(scale_sigma, sigma_2_fixed))
parameters.add(scale_sigma)
else:
parameters.add(RooArgSet(sigma_1, sigma_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2)
if useOtherSignalParametrization: # In this case I redefine cb_pdf
cb1 = RooCBShape('cb1', 'cb1', x, mean_1, sigma_1, a1_1, n1_1)
cb2 = RooCBShape('cb2', 'cb2', x, mean_2, sigma_2, a1_2, n1_2)
# I use a2 as the sigma of my gaussian
gauss1 = RooCBShape('gauss1', 'gauss1',x, mean_1, a2_1, a1_1, n1_1)
gauss2 = RooCBShape('gauss2', 'gauss2',x, mean_2, a2_2, a1_2, n1_2)
# I use n2 as the ratio of cb with respect to gauss
chib1_pdf = RooAddPdf('chib1','chib1',RooArgList(cb1, gauss1),RooArgList(n2_1))
chib2_pdf = RooAddPdf('chib2','chib2',RooArgList(cb2, gauss2),RooArgList(n2_2))
#background
q01S_Start = 9.5
alpha = RooRealVar("#alpha","#alpha",1.5,-1,3.5)#0.2 anziche' 1
beta = RooRealVar("#beta","#beta",-2.5,-7.,0.)
q0 = RooRealVar("q0","q0",q01S_Start)#,9.5,9.7)
delta = RooFormulaVar("delta","TMath::Abs(@0-@1)",RooArgList(x,q0))
b1 = RooFormulaVar("b1","@0*(@1-@2)",RooArgList(beta,x,q0))
signum1 = RooFormulaVar( "signum1","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q0) )
background = RooGenericPdf("background","Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1,delta,alpha,b1) )
if useOtherBackgroundParametrization: # in thies case I redefine background
a0 = RooRealVar('a0','a0',1.,-1.,1.) #,0.5,0.,1.)
a1 = RooRealVar('a1','a1',0.1,-1.,1.) #-0.2,0.,1.)
#a2 = RooRealVar('a2','a2',-0.1,1.,-1.)
background = RooChebychev('background','Background',x,RooArgList(a0,a1))
parameters.add(RooArgSet(a0, a1))
else:
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf,chib2_pdf,background)
# ndof
floatPars = parameters.selectByAttrib("Constant",ROOT.kFALSE)
ndof = numBins - floatPars.getSize() - 1
# # Here I have as parameters N1, N2, and N_background
# n_chib1 = RooRealVar("n_chib1","n_chib1",1250, 0, 50000)
# n_chib2 = RooRealVar("n_chib2","n_chib2",825, 0, 50000)
# n_background = RooRealVar('n_background','n_background',4550, 0, 50000)
# ratio_list = RooArgList(n_chib1, n_chib2, n_background)
# modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
# Here I have as parameters N_12, ratio_12, N_background
n_chib = RooRealVar("n_chib","n_chib",2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21","ratio_21",0.6, 0, 1)
n_chib1 = RooFormulaVar("n_chib1","@0/(1+@1)",RooArgList(n_chib, ratio_21))
n_chib2 = RooFormulaVar("n_chib2","@0/(1+1/@1)",RooArgList(n_chib, ratio_21))
n_background = RooRealVar('n_background','n_background',4550, 0, 50000)
ratio_list = RooArgList(n_chib1, n_chib2, n_background)
parameters.add(RooArgSet(n_chib1, n_chib2, n_background))
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
print 'Fitting to data'
fit_region = x.setRange("fit_region",9.7,10.1)
result=modelPdf.fitTo(data,RooFit.Save(), RooFit.Range("fit_region"))
# define frame
frame = x.frame()
frame.SetNameTitle("fit_resonance","Fit Resonanace")
frame.GetXaxis().SetTitle(x_axis_label )
frame.GetYaxis().SetTitle( "Events/5 MeV " )
frame.GetXaxis().SetTitleSize(0.04)
frame.GetYaxis().SetTitleSize(0.04)
frame.GetXaxis().SetTitleOffset(1.1)
frame.GetXaxis().SetLabelSize(0.04)
frame.GetYaxis().SetLabelSize(0.04)
frame.SetLineWidth(1)
frame.SetTitle(plotTitle)
# plot things on frame
data.plotOn(frame, RooFit.MarkerSize(0.7))
chib1P_set = RooArgSet(chib1_pdf)
modelPdf.plotOn(frame,RooFit.Components(chib1P_set), RooFit.LineColor(ROOT.kGreen+2), RooFit.LineStyle(2), RooFit.LineWidth(1))
chib2P_set = RooArgSet(chib2_pdf)
modelPdf.plotOn(frame, RooFit.Components(chib2P_set),RooFit.LineColor(ROOT.kRed), RooFit.LineStyle(2), RooFit.LineWidth(1))
background_set = RooArgSet(background)
modelPdf.plotOn(frame,RooFit.Components(background_set), RooFit.LineColor(ROOT.kBlack), RooFit.LineStyle(2), RooFit.LineWidth(1))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
frame.SetName("fit_resonance")
# Make numChib object
numChib = NumChib(numChib=n_chib.getVal(), s_numChib=n_chib.getError(), ratio_21=ratio_21.getVal(), s_ratio_21=ratio_21.getError(), numBkg=n_background.getVal(), s_numBkg=n_background.getError(), corr_NB=result.correlation(n_chib, n_background),corr_NR=result.correlation(n_chib, ratio_21) , name='numChib'+output_suffix+ptBin_label,q0=q0.getVal(),s_q0=q0.getError(),alpha=alpha.getVal(),s_alpha=alpha.getError(), beta=beta.getVal(), s_beta=beta.getError(), chiSquare=frame.chiSquare())
#numChib.saveToFile('numChib'+output_suffix+'.txt')
if noPlots:
chi2 = frame.chiSquare()
del frame
return numChib, chi2
# Legend
parameters_on_legend = RooArgSet()#n_chib, ratio_21, n_background)
if massFreeToChange:
#parameters_on_legend.add(scale_mean)
parameters_on_legend.add(mean_1)
#parameters_on_legend.add(mean_2)
if sigmaFreeToChange:
parameters_on_legend.add(scale_sigma)
if massFreeToChange or sigmaFreeToChange:
modelPdf.paramOn(frame, RooFit.Layout(0.1,0.6,0.2),RooFit.Parameters(parameters_on_legend))
if printLegend: #chiquadro, prob, numchib...
leg = TLegend(0.48,0.75,0.97,0.95)
leg.SetBorderSize(0)
#leg.SetTextSize(0.04)
leg.SetFillStyle(0)
chi2 = frame.chiSquare()
probChi2 = TMath.Prob(chi2*ndof, ndof)
chi2 = round(chi2,2)
probChi2 = round(probChi2,2)
leg.AddEntry(0,'#chi^{2} = '+str(chi2),'')
leg.AddEntry(0,'Prob #chi^{2} = '+str(probChi2),'')
N_bkg, s_N_bkg = roundPair(numChib.numBkg, numChib.s_numBkg)
leg.AddEntry(0,'N_{bkg} = '+str(N_bkg)+' #pm '+str(s_N_bkg),'')
N_chib12, s_N_chib12 = roundPair(numChib.numChib, numChib.s_numChib)
leg.AddEntry(0,'N_{#chi_{b}} = '+str(N_chib12)+' #pm '+str(s_N_chib12),'')
Ratio = numChib.calcRatio()
s_Ratio = numChib.calcRatioError()
Ratio, s_Ratio = roundPair(Ratio, s_Ratio)
leg.AddEntry(0,'N_{2}/N_{1} = '+str(Ratio)+' #pm '+str(s_Ratio),'')
if printSigReso: # Add Significance
Sig = numChib.calcSignificance()
s_Sig = numChib.calcSignificanceError()
Sig, s_Sig = roundPair(Sig, s_Sig)
leg.AddEntry(0,'Sig = '+str(Sig)+' #pm '+str(s_Sig),'')
if(Chib1_parameters.sigma>Chib2_parameters.sigma):
Reso = Chib1_parameters.sigma * 1000 # So it's in MeV and not in GeV
s_Reso = Chib1_parameters.s_sigma * 1000 # So it's in MeV and not in GeV
else:
Reso = Chib2_parameters.sigma * 1000 # So it's in MeV and not in GeV
s_Reso = Chib2_parameters.s_sigma * 1000 # So it's in MeV and not in GeV
Reso, s_Reso =roundPair(Reso, s_Reso)
leg.AddEntry(0,'Reso = '+str(Reso)+' #pm '+str(s_Reso)+' MeV','')
#N1 = numChib.numChib1
#s_N1 = numChib.s_numChib1
#N1, s_N1 = roundPair(N1, s_N1)
#leg.AddEntry(0,'N_{1} = '+str(N1)+' #pm '+str(s_N1),'')
#N2 = numChib.numChib2
#s_N2 = numChib.s_numChib2
#N2, s_N2 = roundPair(N2, s_N2)
#leg.AddEntry(0,'N_{2} = '+str(N2)+' #pm '+str(s_N2),'')
frame.addObject(leg)
if legendOnPlot: # < pT <
legend = TLegend(.06,.75,.53,.93)
legend.SetFillStyle(0)
legend.SetBorderSize(0)
#legend.AddEntry(0,'CMS','')
legend.AddEntry(0,str(cuts.upsilon_pt_lcut)+' GeV < p_{T}(#Upsilon) < '+str(cuts.upsilon_pt_hcut)+' GeV','')
#legend.AddEntry(0,'p_{T}(#Upsilon)<'+str(cuts.upsilon_pt_hcut),'')
frame.addObject(legend)
if titleOnPlot:
titleLegend = TLegend(.06,.4,.55,.73)
#titleLegend.SetTextSize(0.03)
titleLegend.SetFillStyle(0)
titleLegend.SetBorderSize(0)
titleLegend.AddEntry(0,plotTitle,'')
frame.addObject(titleLegend)
if cmsOnPlot:
if printLegend:
pvtxt = TPaveText(.1,.55,.55,.73,"NDC")
else:
pvtxt = TPaveText(0.5,0.75,0.97,0.9,"NDC") #(.06,.4,.55,.73)
pvtxt.AddText('CMS Preliminary')
pvtxt.AddText('pp, #sqrt{s} = 8 TeV')
pvtxt.AddText('L = 20.7 fb^{-1}')
pvtxt.SetFillStyle(0)
pvtxt.SetBorderSize(0)
pvtxt.SetTextSize(0.04)
frame.addObject(pvtxt)
# Canvas
c1=TCanvas('Chib12_1P'+output_suffix+ptBin_label,'Chib12_1P'+output_suffix+ptBin_label)
frame.Draw()
if drawPulls:
#c1=TCanvas(output_name+output_suffix,output_name+output_suffix,700, 625)
hpull = frame.pullHist()
framePulls = x.frame()
framePulls.SetTitle(';;Pulls')
framePulls.GetYaxis().SetLabelSize(0.18)
framePulls.GetYaxis().SetTitle('Pulls')
framePulls.GetYaxis().SetTitleSize(0.18)
framePulls.GetYaxis().SetTitleOffset(0.15)
framePulls.GetYaxis().SetNdivisions(005)
framePulls.GetXaxis().SetLabelSize(0.16)
framePulls.GetXaxis().SetTitle('')
line0 = TLine(9.7, 0, 10.1, 0)
line0.SetLineColor(ROOT.kBlue)
line0.SetLineWidth(2)
framePulls.addObject(line0)
framePulls.addPlotable(hpull,"P")
framePulls.SetMaximum(5)
framePulls.SetMinimum(-5)
pad1 = TPad("pad1", "The pad 80% of the height",0.0,0.2,1.0,1.0)
pad1.cd()
frame.Draw()
pad2 = TPad("pad2", "The pad 20% of the height",0.0,0.01,1.0,0.2)
pad2.cd()
framePulls.Draw()
c1.cd()
pad1.Draw()
pad2.Draw()
#c1.SaveAs('Chib12_1P'+output_suffix+'.png')
print 'Chi2 = '+str(frame.chiSquare())
# print ratio background/all in the signal refion
signal_region = x.setRange("signal_region",9.87,9.92)
pdf_integral = modelPdf.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * (n_chib.getVal() + n_background.getVal())
bkg_integral = background.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * n_background.getVal()
print 'Ratio bkg/all in signal region = '+str(bkg_integral/pdf_integral)
return numChib, c1
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()
def doFit(ws,options):
rap_bins = range(1,len(jpsi.pTRange))
pt_bins = None
if options.testBin is not None:
rap_bins = [int(options.testBin.split(',')[0])]
pt_bins = [int(options.testBin.split(',')[1])-1]
for rap_bin in rap_bins:
if options.testBin is None:
pt_bins = range(len(jpsi.pTRange[rap_bin]))
for pt_bin in pt_bins:
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]
jPsiMass = ws.var('JpsiMass')
jPsicTau = ws.var('Jpsict')
jPsiMass.setRange('mlfit_prompt',2.7,3.5)
jPsiMass.setRange('mlfit_nonPrompt',2.7,3.5)
jPsiMass.setRange('NormalizationRangeFormlfit_prompt',2.7,3.5)
jPsiMass.setRange('NormalizationRangeFormlfit_nonPrompt',2.7,3.5)
jPsicTau.setRange('mlfit_signal',-1,2.5)
jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5)
jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5)
jPsicTau.setRange('NormalizationRangeFormlfit_signal',-1,2.5)
jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5)
jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5)
#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)
#jPsicTau.setRange('mlfit_promptSignal',-1,.1)
#jPsicTau.setRange('mlfit_nonPromptSignal',.1,2.5)
#jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5)
#jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5)
#reset parameters
ws.var('CBn').setVal(.5)
ws.var('CBalpha').setVal(.5)
ws.var('CBmass').setVal(3.1)
ws.var('CBsigma').setVal(.02)
ws.var('bkgLambda').setVal(0)
ws.var('bkgTauSSDL').setVal(.5)
#ws.var('bkgTauFDL').setVal(.5)
ws.var('bkgTauDSDL').setVal(.5)
ws.var('fBkgSSDL').setVal(.5)
ws.var('fBkgLR').setVal(.5)
ws.var('bkgTauSSDR').setVal(.5)
#ws.var('bkgTauFDR').setVal(.5)
ws.var('bkgTauDSDR').setVal(.5)
ws.var('fBkgSSDR').setVal(.5)
#ws.var('fBkgFDR').setVal(.25)
#ws.var('nPrompt').setVal(5000)
#ws.var('nNonPrompt').setVal(500)
#ws.var('nBackground').setVal(100)
#ws.var('nBackgroundL').setVal(50)
#ws.var('nBackgroundR').setVal(50)
ws.var('nonPromptTau').setVal(.5)
ws.var('promptMean').setVal(0)
ws.var('ctResolution').setVal(1)
if options.fixBfrac:
cutStringM1 = '('+jPsiMass.GetName()+' > '+str(sigMinMass)+' && '+jPsiMass.GetName()+' < '+str(sigMaxMass)+')'
data2 = ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1))
dataSizeBfrac1 = data2.numEntries()
print dataSizeBfrac1
bfracVars = RooArgSet(jPsiMass)
bfracData = data2.reduce(ROOT.RooFit.SelectVars(bfracVars),
ROOT.RooFit.Cut(cutStringM1),
ROOT.RooFit.Name('data_for_normalizing_bfrac'),
ROOT.RooFit.Title('data_for_normalizing_bfrac'))
print rap_bin
print pt_bin
bfrac = jpsi.Bfrac[rap_bin-1][pt_bin]
print bfrac
dataSizeBfrac = bfracData.numEntries()
factPrompt = 1-bfrac
dataSizePrompt = dataSizeBfrac*factPrompt
dataSizeNonPrompt = dataSizeBfrac*bfrac
print factPrompt
print dataSizeBfrac
print dataSizePrompt
print dataSizeNonPrompt
ws.var('nPromptSignal').setVal(dataSizePrompt)
ws.var('nNonPromptSignal').setVal(dataSizeNonPrompt)
ws.var('nPromptSignal').setConstant()
ws.var('nNonPromptSignal').setConstant()
LPdf = ws.pdf('LPdf')
MPdf = ws.pdf('MPdf')
data = ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1))
NLLs = RooArgSet()
MassNLL = MPdf.createNLL(data,
ROOT.RooFit.Range('mlfit'),
ROOT.RooFit.SplitRange(True),
ROOT.RooFit.ConditionalObservables(RooArgSet(ws.var('JpsictErr'))),
ROOT.RooFit.NumCPU(2))
CTauNLL = LPdf.createNLL(data,
ROOT.RooFit.Range('mlfit'),
ROOT.RooFit.SplitRange(True),
ROOT.RooFit.ConditionalObservables(RooArgSet(ws.var('JpsictErr'))),
ROOT.RooFit.NumCPU(2))
NLLs.add(MassNLL)
NLLs.add(CTauNLL)
simNLL = RooAddition('add','add',NLLs)
minuit = RooMinuit(simNLL)
minuit.setStrategy(2)
minuit.setPrintEvalErrors(-1)
if options.do_fit:
minuit.simplex()
minuit.migrad()
minuit.migrad()
minuit.hesse()
fitresult = minuit.save('polfitresult_rap'+str(rap_bin)+'_pt'+str(pt_bin+1))
getattr(ws,'import')(fitresult)
ws.saveSnapshot('snapshot_rap'+str(rap_bin)+'_pt'+str(pt_bin+1),ws.allVars())
fitresult.Print()
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)
)
from itertools import product
states = [ stList for stList in product( *tuple( [ st for st in splitPars[cat][2] ] for cat in splitCats ) ) ]
###########################################################################################################################################
## select events from input file ##
###################################
# read prototype data
from ROOT import TFile, RooArgSet
protoFile = TFile.Open(args.protoFile)
protoData = protoFile.Get(args.protoDataName)
protoFile.Close()
assert protoData and all( protoData.get().find(obs) for obs in obsNames )
protoSet = RooArgSet( protoData.get() )
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
def expectedPlcLimit(obs_, poi_, model, ws, ntoys = 30, CL = 0.95,
binData = False):
# obs : observable variable or RooArgSet of observables
# poi : parameter of interest or RooArgSet of parameters
# model : RooAbsPdf of model to consider including any constraints
# the parameters should have the values corresponding to the
# background-only hypothesis which will be used to estimate the
# expected limit.
# ntoys : number of toy datsets to generate to get expected limit
# CL : confidence level for interval
# returns a dictionary containing the expected limits and their 1 sigma
# errors for the first/only parameter in poi_ and a list of the results
# from the individual toys.
from math import sqrt
obs = RooArgSet(obs_)
obs.setName('observables')
mPars = model.getParameters(obs)
genPars = mPars.snapshot()
print "parameters for generating toy datasets"
genPars.Print("v")
limits = []
upperLimits = []
lowerLimits = []
probs = array('d', [0.022, 0.16, 0.5, 0.84, 0.978])
upperQs = array('d', [0.]*len(probs))
lowerQs = array('d', [0.]*len(probs))
for i in range(0,ntoys):
print 'generate limit of toy %i of %i' % (i+1, ntoys)
mPars.assignFast(genPars)
toyData = model.generate(obs, RooFit.Extended())
if binData:
toyData = RooDataHist('data_obs_%i' % i, 'data_obs_%i' % i,
obs, toyData)
toyData.SetName('data_obs_%i' % i)
toyData.Print()
limits.append(plcLimit(obs_, poi_, model, ws, toyData, CL))
#print limits[-1]
if limits[-1][poi_.GetName()]['ok'] and \
((poi_.getMax()-limits[-1][poi_.GetName()]['upper']) > 0.001*poi_.getMax()):
upperLimits.append(limits[-1][poi_.GetName()]['upper'])
if limits[-1][poi_.GetName()]['ok'] and \
((limits[-1][poi_.GetName()]['lower']-poi_.getMin()) > 0.001*abs(poi_.getMin())):
lowerLimits.append(limits[-1][poi_.GetName()]['lower'])
toyData.IsA().Destructor(toyData)
mPars.assignFast(genPars)
upperLimits.sort()
upperArray = array('d', upperLimits)
if len(upperLimits) > 4:
TMath.Quantiles(len(upperLimits), len(probs), upperArray, upperQs,
probs)
# upperLimits.GetQuantiles(len(probs), upperQs, probs)
# upperLimits.Print()
print 'expected upper limit quantiles using %i toys: [' % len(upperLimits),
for q in upperQs:
print '%0.4f' % q,
print ']'
lowerLimits.sort()
lowerArray = array('d', lowerLimits)
if len(lowerLimits) > 4:
TMath.Quantiles(len(lowerLimits), len(probs), lowerArray, lowerQs,
probs)
# lowerLimits.GetQuantiles(len(probs), lowerQs, probs)
# lowerLimits.Print()
print 'expected lower limit quantiles using %i toys: [' % len(lowerLimits),
for q in lowerQs:
print '%0.4f' % q,
print ']'
expLimits = {'upper' : upperQs[2],
'upperErr' : sqrt((upperQs[2]-upperQs[1])*(upperQs[3]-upperQs[2])),
'lower' : lowerQs[2],
'lowerErr' : sqrt((lowerQs[2]-lowerQs[1])*(lowerQs[3]-lowerQs[2])),
'ntoys': len(limits),
'upperQuantiles': upperQs,
'lowerQuantiles': lowerQs,
'quantiles': probs
}
return (expLimits, limits)
temp_wj.Rebin(20)
temp_zj.Rebin(20)
temp_stop.Rebin(20)
temp_qcd.Rebin(20)
temp_qcd.Scale(800/temp_qcd.Integral())
temp_signal = temp_tt.Clone('signal')
temp_signal.Add(temp_stop)
#temp_tt.Scale(1/temp_tt.Integral())
#temp_wj.Scale(1/temp_wj.Integral())
#temp_zj.Scale(1/temp_zj.Integral())
#temp_stop.Scale(1/temp_stop.Integral())
#temp_qcd.Scale(1/temp_qcd.Integral())
leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.)
vars = RooArgList()
vars.add(leptonAbsEta)
vars_set = RooArgSet()
vars_set.add(leptonAbsEta)
n_event_obs = h_m3_data.GetEntries();
lowerBound = -10 * sqrt(n_event_obs);
upperBound = n_event_obs + 10 * sqrt(n_event_obs);
n_init = n_event_obs / 2.;
data = RooDataHist("data", "dataset with leptonAbsEta", vars, h_m3_data)
rh_tt = RooDataHist("rh_tt", "tt", vars, temp_tt);
rh_wj = RooDataHist("rh_wj", "wj", vars, temp_wj);
rh_zj = RooDataHist("rh_zj", "zj", vars, temp_zj);
rh_qcd = RooDataHist("rh_qcd", "qcd", vars, temp_qcd);
rh_stop = RooDataHist("rh_stop", "singletop", vars, temp_stop);
rh_signal = RooDataHist("rh_signal", "signal", vars, temp_signal);
pdf_tt = RooHistPdf("pdf_tt", "Signal pdf", vars_set, rh_tt, 0);
pdf_wj = RooHistPdf ("pdf_wj", "W+jets pdf", vars_set, rh_wj, 0);
pars.Print('v')
#assert(False)
fr = simPdf.fitTo(data, RooFit.Extended(),
RooFit.Minos(False),
RooFit.NumCPU(2),
RooFit.Save(True))
pars.writeToFile('lastSimFit.txt')
ws.saveSnapshot('fit_snapshot', pars)
#assert(False)
dataCat = ws.cat('dataCat')
catSet = RooArgSet(dataCat)
Nexp = simPdf.expectedEvents(data.get())
print 'Nexp:', Nexp
hican = TCanvas("hi", "hi")
dataCat.setLabel('hi')
mf_hi = mass.frame(mmin, mmax, int((mmax-mmin)*10))
simPdf.plotOn(mf_hi, RooFit.Slice(catSet),
RooFit.Normalization(Nexp, RooAbsReal.NumEvent),
RooFit.ProjWData(catSet,data),
RooFit.Name('fullFit')
)
simPdf.plotOn(mf_hi, RooFit.Components('bkg*'),
RooFit.Normalization(Nexp, RooAbsReal.NumEvent),
RooFit.Slice(catSet),
print 'P2VV - INFO: createBs2JpsiKKDataSet: creating data set'
# create data sets with final columns
obsSetMain = obsSetNTuple + [ var for var in weightVars ]
mainDataSet = dataTree.buildDataSet( Observables = obsSetMain, Name = 'JpsiKK', Title = 'JpsiKK', IndexName = 'index'
, OrigDataSet = preSDataSet )
del preSDataSet
del preDataSet
dataTreeFile.Close()
from ROOT import gROOT
gROOT.cd('PyROOT:/')
from ROOT import RooArgSet, RooDataSet
dataSets = { }
for it, var in enumerate(weightVars) :
argSet = RooArgSet( mainDataSet.get() )
for remVar in weightVars :
if remVar != var : argSet.remove( argSet.find( remVar.GetName() ) )
dataName = dataSetNameOut if it == 0 else 'JpsiKK_%d' % it
dataSets[var] = RooDataSet( dataName, dataName, argSet, Import = mainDataSet, WeightVar = ( var.GetName(), True ) )
if not printYields : break
print 'P2VV - INFO: createBs2JpsiKKDataSet: produced data sets:'
mainDataSet.Print()
for var in weightVars :
dataSets[var].Print()
if not printYields : break
print
if printYields :
# print event yields
