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 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 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 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 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 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 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 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 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 get_dataset_from_tree(
self,
path_to_tree,
tree_variables,
weight="1==1",
weight_var_name=0,
dataset_name="my_dataset",
basket=True,
category=None,
):
"""
Creates RooDataSet from a plain root tree given:
- variables name list
- weight expression. It works in the same way as TTree cut.
Returns:
--------
- RooDataSet
- also fills the basket with datasets (basket inhereted from RootHelperBase class)
TODO
----
- add implementation for category setting(check in prepare_toy_datasets_for_sync)
- check if adding toy dataset to each channel workspace individually behaves well
after combineCards.py.
"""
# make RooRealVars from tree_variables
my_arg_set = RooArgSet()
my_rrv = dict()
for var_name in tree_variables:
# TODO implement check that branch exist
my_rrv[var_name] = RooRealVar(var_name, var_name, -999999999, 999999999)
my_arg_set.add(my_rrv[var_name])
if self.DEBUG:
self.log.debug("RooArgSet is now:")
my_arg_set.Print()
# get the tree from path_to_tree
my_tree = self.get_TTree(path_to_tree, cut=weight)
self.log.debug("Selected tree contains {0} events".format(my_tree.GetEntries()))
# create RooDataSet and reduce tree if needed
# self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, weight).reduce(my_arg_set)
self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set)
# self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, "", weight_var_name)
# data[j]=new RooDataSet(Form("data%d",j),Form("data%d",j),outTree,RooArgSet(rCMS_zz4l_widthKD,rCMS_zz4l_widthMass,rweightFit),"","_weight_");
self.log.debug("RooDataSet contains {0} events".format(self.dataset_from_tree.sumEntries()))
# .reduce(ROOT.RooArgSet(self.D0))
self.current_arg_set = my_arg_set
# add dataset to basket
if basket:
self.add_to_basket(self.dataset_from_tree, new_name=dataset_name, new_title=dataset_name)
return self.dataset_from_tree
def makeRooDataset(inputfile_name):
chibTree_name = 'rootuple/chibTree'
inputfile = TFile.Open(inputfile_name,"READ")
tree = TTree()
inputfile.GetObject(chibTree_name, tree)
invm1S = RooRealVar("invm1S", "invm1S", 9.7, 10.1)#9.5, 11.5
invm2S = RooRealVar("invm2S", "invm2S", 9.5, 13.0)
invm3S = RooRealVar("invm3S", "invm3S", 9.5, 13.0)
chib_mass = RooRealVar("chib_mass", "chib_mass", 5., 15.0)
chib_pt = RooRealVar("chib_pt", "chib_pt", 0., 300.)
chib_eta = RooRealVar("chib_eta", "chib_eta", -5., 5.)
chib_phi = RooRealVar("chib_phi", "chib_phi", -3.2, 3.2)
dimuon_mass = RooRealVar("dimuon_mass","dimuon_mass", 8.0, 12.0)
dimuon_rapidity = RooRealVar("dimuon_rapidity", "dimuon_rapidity", -5.0, 5.0)
dimuon_pt = RooRealVar("dimuon_pt","dimuon_pt", 0.0, 100.0)
photon_eta = RooRealVar("photon_eta","photon_eta", -5.0, 5.0)
photon_pt = RooRealVar("photon_pt","photon_pt", 0.0, 100.0)
ctpv = RooRealVar("ctpv","ctpv", -5.0, 5.0)
ctpv_error = RooRealVar("ctpv_err","ctpv_err", -5.0, 5.0)
pi0_abs_mass = RooRealVar("pi0_abs_mass","pi0_abs_mass", 0.0, 2.0)
Y1S_nsigma = RooRealVar("Y1S_nsigma","Y1S_nsigma",0.0,30.0)
Y2S_nsigma = RooRealVar("Y2S_nsigma","Y2S_nsigma",0.0,30.0)
Y3S_nsigma = RooRealVar("Y3S_nsigma","Y3S_nsigma",0.0,35.0)
conv_vertex = RooRealVar("conv_vertex", "conv_vertex", 0.0, 70.0)
dz = RooRealVar("dz","dz", 0., 0.6)
numPrimaryVertices = RooRealVar("numPrimaryVertices","numPrimaryVertices",0,60)
rf1S_chib_mass = RooRealVar("rf1S_chib_mass","rf1S_chib_mass",9.5,60.)
probFit1S = RooRealVar("probFit1S","probFit1S",0.,1.)
rf1S_chib_pt = RooRealVar("rf1S_chib_pt", "rf1S_chib_pt", 0., 300.)
rf1S_chib_eta = RooRealVar("rf1S_chib_eta", "rf1S_chib_eta", -5., 5.)
rf1S_dimuon_mass = RooRealVar("rf1S_dimuon_mass","rf1S_dimuon_mass", 8.0, 12.0)
rf1S_dimuon_rapidity = RooRealVar("rf1S_dimuon_rapidity", "rf1S_dimuon_rapidity", -5.0, 5.0)
rf1S_dimuon_pt = RooRealVar("rf1S_dimuon_pt","rf1S_dimuon_pt", 0.0, 230.0)
rf1S_photon_eta = RooRealVar("rf1S_photon_eta","rf1S_photon_eta", -5.0, 5.0)
rf1S_photon_pt = RooRealVar("rf1S_photon_pt","rf1S_photon_pt", 0.0, 100.0)
rf2S_chib_mass = RooRealVar("rf2S_chib_mass","rf2S_chib_mass",9.5,60.)
probFit2S = RooRealVar("probFit2S","probFit2S",0.,1.)
rf3S_chib_mass = RooRealVar("rf3S_chib_mass","rf3S_chib_mass",9.5,60.)
probFit3S = RooRealVar("probFit3S","probFit3S",0.,1.)
muonP_pt = RooRealVar("muonP_pt","muonP_pt",0.,100.)
muonM_pt = RooRealVar("muonM_pt","muonM_pt",0.,100.)
muonP_eta = RooRealVar("muonP_eta","muonP_eta",-5.,5.)
muonM_eta = RooRealVar("muonM_eta","muonM_eta",-5.,5.)
dataArgSet = RooArgSet(invm1S, invm2S, invm3S, dimuon_mass, dimuon_rapidity, dimuon_pt, photon_eta, photon_pt, ctpv)
dataArgSet.add(RooArgSet(chib_mass, chib_pt, chib_eta, chib_phi))
dataArgSet.add(RooArgSet(ctpv_error, pi0_abs_mass, Y1S_nsigma, Y2S_nsigma, Y3S_nsigma, conv_vertex, dz, numPrimaryVertices))
dataArgSet.add(RooArgSet(rf1S_chib_mass, probFit1S, rf2S_chib_mass, probFit2S, rf3S_chib_mass, probFit3S))
dataArgSet.add(RooArgSet(rf1S_chib_pt, rf1S_chib_eta, rf1S_dimuon_mass, rf1S_dimuon_rapidity, rf1S_dimuon_pt, rf1S_photon_eta, rf1S_photon_pt))
dataArgSet.add(RooArgSet(muonP_pt, muonM_pt, muonP_eta, muonM_eta))
dataSet = RooDataSet("chibds","Chib RooDataSet", tree, dataArgSet)
return dataSet
def 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 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 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 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 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 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 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 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 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 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 run(self, **kwargs):
from ROOT import RooArgSet
__check_req_kw__("Observables", kwargs)
__check_req_kw__("Pdf", kwargs)
observables = kwargs.pop("Observables")
obs_set = RooArgSet(*observables)
pdf = kwargs.pop("Pdf")
genPdf = kwargs.pop("GenPdf", pdf)
gen_obs_set = RooArgSet()
for o in list(observables) + list(genPdf.ConditionalObservables()):
gen_obs_set.add(o._target_())
gen_pdf_params = genPdf.getParameters(gen_obs_set).snapshot(True)
genPdf = genPdf.clone(genPdf.GetName() + "_toy_clone")
genPdf.recursiveRedirectServers(gen_pdf_params)
fit_obs_set = RooArgSet()
for o in list(observables) + list(pdf.ConditionalObservables()):
fit_obs_set.add(o._target_())
params = pdf.getParameters(fit_obs_set)
pdf_params = RooArgSet()
for p in params:
if p.isConstant():
continue
pdf_params.add(p)
## for param in pdf_params:
## if param.GetName() not in ['Gamma', 'dGamma']:
## param.setConstant()
self._gen_params = pdf_params.snapshot(True)
# Make another ArgSet to put the fit results in
result_params = RooArgSet(pdf_params, "result_params")
transform = self.transform()
if transform:
trans_params = transform.gen_params(gen_obs_set)
for p in trans_params:
result_params.add(p)
# Some extra numbers of interest
from ROOT import RooRealVar
NLL = RooRealVar("NLL", "-log(Likelihood)", 1.0)
ngen = RooRealVar("ngen", "number of generated events", self.options().nevents)
seed = RooRealVar("seed", "random seed", 0.0)
from ROOT import RooCategory
status = RooCategory("status", "fit status")
status.defineType("success", 0)
status.defineType("one", 1)
status.defineType("two", 2)
status.defineType("three", 3)
status.defineType("other", 4)
result_params.add(status)
result_params.add(NLL)
result_params.add(ngen)
result_params.add(seed)
# The dataset to store the results
from ROOT import RooDataSet
self._data = RooDataSet("result_data", "result_data", result_params)
data_params = self._data.get()
from ROOT import RooRandom
import struct, os
while self._data.numEntries() < self.options().ntoys:
# Get a good random seed, set it and store it
s = struct.unpack("I", os.urandom(4))[0]
RooRandom.randomGenerator().SetSeed(s)
seed.setVal(s)
# Reset pdf parameters to initial values. Note: this does not reset the estimated errors...
pdf_params.assignValueOnly(self.gen_params())
args = dict(NumEvents=self.options().nevents)
if "ProtoData" in kwargs:
args["ProtoData"] = kwargs.pop("ProtoData")
genPdf.getParameters(obs_set).assignValueOnly(gen_pdf_params)
data = genPdf.generate(obs_set, **args)
if transform:
data = transform(data)
if not data:
# Transform has failed
transform.set_params(data_params)
self._data.add(data_params)
continue
if data.isWeighted() and "SumW2Error" not in self.fit_opts():
self.fit_opts()["SumW2Error"] = False
j = 0
while j < 4:
fit_result = pdf.fitTo(data, NumCPU=self.options().ncpu, **(self.fit_opts()))
if fit_result.status() == 0:
fit_result.Print()
break
j += 1
if fit_result.status() != 0:
print "Fit result status = %s" % fit_result.status()
NLL.setVal(fit_result.minNll())
if fit_result.status() < 4:
status.setIndex(fit_result.status())
else:
status.setIndex(4)
for result_param in result_params:
data_param = data_params.find(result_param.GetName())
if isinstance(result_param, RooCategory):
data_param.setIndex(result_param.getIndex())
else:
data_param.setVal(result_param.getVal())
# This sets a symmetric error, but since we don't run Minos, that's ok
data_param.setError(result_param.getError())
if transform:
transform.set_params(data_params)
self._data.add(data_params)
return self.data()
def fitData(fulldata, ibin):
cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)' % (
q2binning[ibin], q2binning[ibin + 1])
data = fulldata.reduce(RooArgSet(tagged_mass, mumuMass, mumuMassE), cut)
fraction = dict_s_rt[ibin] / (dict_s_rt[ibin] + dict_s_wt[ibin])
print 'mistag fraction on MC for bin ', ibin, ' : ', fraction.n, '+/-', fraction.s
### creating RT component
w.loadSnapshot("reference_fit_RT_%s" % ibin)
sigmart1 = w.var("#sigma_{1}^{RT%s}" % ibin)
sigmart2 = w.var("#sigma_{2}^{RT%s}" % ibin)
massrt = w.var("mean^{RT%s}" % ibin)
f1rt = w.var("f^{RT%s}" % ibin)
theRTgauss = w.pdf("doublegaus_RT%s" % ibin)
c_sigma_rt1 = _constrainVar(sigmart1)
c_sigma_rt2 = _constrainVar(sigmart2)
c_mean_rt = _constrainVar(massrt)
c_f1rt = _constrainVar(f1rt)
### creating WT component
w.loadSnapshot("reference_fit_WT_%s" % ibin)
meanwt = w.var("mean^{WT%s}" % ibin)
sigmawt = w.var("#sigma_{CB}^{WT%s}" % ibin)
alphawt1 = w.var("#alpha_{1}^{WT%s}" % ibin)
alphawt2 = w.var("#alpha_{2}^{WT%s}" % ibin)
nwt1 = w.var("n_{1}^{WT%s}" % ibin)
nwt2 = w.var("n_{2}^{WT%s}" % ibin)
theWTgauss = w.pdf("doublecb_%s" % ibin)
c_mean_wt = _constrainVar(meanwt)
c_sigma_wt = _constrainVar(sigmawt)
c_alpha_wt1 = _constrainVar(alphawt1)
c_alpha_wt2 = _constrainVar(alphawt2)
c_n_wt1 = _constrainVar(nwt1)
c_n_wt2 = _constrainVar(nwt2)
### creating constraints for the RT component
c_RTgauss = RooProdPdf(
"c_RTgauss", "c_RTgauss",
RooArgList(theRTgauss, c_sigma_rt1, c_sigma_rt2, c_mean_rt, c_f1rt))
c_vars = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_f1rt, c_mean_rt)
c_vars.add(c_sigma_wt)
c_vars.add(c_mean_wt)
c_vars.add(c_alpha_wt1)
c_vars.add(c_alpha_wt2)
c_vars.add(c_n_wt1)
c_vars.add(c_n_wt2)
### creating constraints for the WT component
c_WTgauss = RooProdPdf(
"c_WTgauss", "c_WTgauss",
RooArgList(theWTgauss, c_alpha_wt1, c_n_wt1, c_sigma_wt, c_mean_wt,
c_alpha_wt2, c_n_wt2))
frt = RooRealVar("F_{RT}", "frt", fraction.n, 0, 1)
signalFunction = RooAddPdf("sumgaus", "rt+wt",
RooArgList(c_RTgauss, c_WTgauss),
RooArgList(frt))
c_frt = RooGaussian("c_frt", "c_frt", frt,
ROOT.RooFit.RooConst(fraction.n),
ROOT.RooFit.RooConst(fraction.s))
c_signalFunction = RooProdPdf("c_signalFunction", "c_signalFunction",
RooArgList(signalFunction, c_frt))
c_vars.add(frt)
### now create background parametrization
slope = RooRealVar("slope", "slope", 0.5, -10, 10)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass)
pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10)
pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10)
bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass,
RooArgList(pol_c1, pol_c2))
nsig = RooRealVar("Yield", "signal frac", 4000, 0, 1000000)
nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000)
# fitFunction = RooAddPdf ("fitfunction" , "fit function" , RooArgList(c_signalFunction, bkg_pol), RooArgList(nsig, nbkg))
fitFunction = RooAddPdf("fitfunction", "fit function",
RooArgList(c_signalFunction, bkg_exp),
RooArgList(nsig, nbkg))
r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(),
RooFit.Range("full"), RooFit.Verbose(False),
ROOT.RooFit.Constrain(c_vars))
frame = tagged_mass.frame(RooFit.Range("full"))
data.plotOn(frame, RooFit.Binning(35), RooFit.MarkerSize(.7))
fitFunction.plotOn(frame)
drawPdfComponents(fitFunction,
frame,
ROOT.kAzure,
RooFit.NormRange("full"),
RooFit.Range("full"),
isData=True)
parList = RooArgSet(nsig, massrt, sigmart1, sigmart2, f1rt, meanwt,
sigmawt, alphawt1)
parList.add(alphawt2)
parList.add(nwt1)
parList.add(nwt2)
parList.add(frt)
fitFunction.paramOn(frame, RooFit.Parameters(parList),
RooFit.Layout(0.62, 0.86, 0.89))
frame.Draw()
niceFrame(frame, '')
frame.addObject(_writeFitStatus(r))
if not args.year == 'test':
writeCMS(frame, args.year, [q2binning[ibin], q2binning[ibin + 1]])
frame.Draw()
c1.SaveAs('fit_results_mass/save_fit_data_%s_%s_LMNR.pdf' %
(ibin, args.year))
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);
pdf_zj = RooHistPdf ("pdf_zj", "Z+jets pdf", vars_set, rh_zj, 0);
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.
N_max = self.normalisation[self.data_label] * 2.
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 signal(category):
interPar = True
n = len(genPoints)
cColor = color[category] if category in color else 4
nBtag = category.count('b')
isAH = False #relict from using Alberto's more complex script
if not os.path.exists(PLOTDIR+"MC_signal_"+YEAR): os.makedirs(PLOTDIR+"MC_signal_"+YEAR)
#*******************************************************#
# #
# Variables and selections #
# #
#*******************************************************#
X_mass = RooRealVar ( "jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV")
j1_pt = RooRealVar( "jpt_1", "jet1 pt", 0., 13000., "GeV")
jj_deltaEta = RooRealVar( "jj_deltaEta_widejet", "", 0., 5.)
jbtag_WP_1 = RooRealVar("jbtag_WP_1", "", -1., 4. )
jbtag_WP_2 = RooRealVar("jbtag_WP_2", "", -1., 4. )
fatjetmass_1 = RooRealVar("fatjetmass_1", "", -1., 2500. )
fatjetmass_2 = RooRealVar("fatjetmass_2", "", -1., 2500. )
jid_1 = RooRealVar( "jid_1", "j1 ID", -1., 8.)
jid_2 = RooRealVar( "jid_2", "j2 ID", -1., 8.)
jnmuons_1 = RooRealVar( "jnmuons_1", "j1 n_{#mu}", -1., 8.)
jnmuons_2 = RooRealVar( "jnmuons_2", "j2 n_{#mu}", -1., 8.)
jmuonpt_1 = RooRealVar( "jmuonpt_1", "j1 muon pt", 0., 13000.)
jmuonpt_2 = RooRealVar( "jmuonpt_2", "j2 muon pt", 0., 13000.)
nmuons = RooRealVar( "nmuons", "n_{#mu}", -1., 10. )
nelectrons = RooRealVar("nelectrons", "n_{e}", -1., 10. )
HLT_AK8PFJet500 = RooRealVar("HLT_AK8PFJet500" , "", -1., 1. )
HLT_PFJet500 = RooRealVar("HLT_PFJet500" , "" , -1., 1. )
HLT_CaloJet500_NoJetID = RooRealVar("HLT_CaloJet500_NoJetID" , "" , -1., 1. )
HLT_PFHT900 = RooRealVar("HLT_PFHT900" , "" , -1., 1. )
HLT_AK8PFJet550 = RooRealVar("HLT_AK8PFJet550" , "", -1., 1. )
HLT_PFJet550 = RooRealVar("HLT_PFJet550" , "" , -1., 1. )
HLT_CaloJet550_NoJetID = RooRealVar("HLT_CaloJet550_NoJetID" , "" , -1., 1. )
HLT_PFHT1050 = RooRealVar("HLT_PFHT1050" , "" , -1., 1. )
HLT_DoublePFJets100_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets100_CaloBTagDeepCSV_p71" , "", -1., 1. )
HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. )
HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. )
HLT_DoublePFJets200_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets200_CaloBTagDeepCSV_p71" , "", -1., 1. )
HLT_DoublePFJets350_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets350_CaloBTagDeepCSV_p71" , "", -1., 1. )
HLT_DoublePFJets40_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets40_CaloBTagDeepCSV_p71" , "", -1., 1. )
weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1.e9 )
# Define the RooArgSet which will include all the variables defined before
# there is a maximum of 9 variables in the declaration, so the others need to be added with 'add'
variables = RooArgSet(X_mass)
variables.add(RooArgSet(j1_pt, jj_deltaEta, jbtag_WP_1, jbtag_WP_2, fatjetmass_1, fatjetmass_2, jnmuons_1, jnmuons_2, weight))
variables.add(RooArgSet(nmuons, nelectrons, jid_1, jid_2, jmuonpt_1, jmuonpt_2))
variables.add(RooArgSet(HLT_AK8PFJet500, HLT_PFJet500, HLT_CaloJet500_NoJetID, HLT_PFHT900, HLT_AK8PFJet550, HLT_PFJet550, HLT_CaloJet550_NoJetID, HLT_PFHT1050))
variables.add(RooArgSet(HLT_DoublePFJets100_CaloBTagDeepCSV_p71, HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets200_CaloBTagDeepCSV_p71, HLT_DoublePFJets350_CaloBTagDeepCSV_p71, HLT_DoublePFJets40_CaloBTagDeepCSV_p71))
X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax())
X_mass.setRange("X_integration_range", X_mass.getMin(), X_mass.getMax())
if VARBINS:
binsXmass = RooBinning(len(abins)-1, abins)
X_mass.setBinning(binsXmass)
plot_binning = RooBinning(int((X_mass.getMax()-X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax())
else:
X_mass.setBins(int((X_mass.getMax()-X_mass.getMin())/10))
binsXmass = RooBinning(int((X_mass.getMax()-X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax())
plot_binning = binsXmass
X_mass.setBinning(plot_binning, "PLOT")
#X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/10))
#binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax())
#X_mass.setBinning(binsXmass, "PLOT")
massArg = RooArgSet(X_mass)
# Cuts
if BTAGGING=='semimedium':
SRcut = aliasSM[category]
#SRcut = aliasSM[category+"_vetoAK8"]
else:
SRcut = alias[category].format(WP=working_points[BTAGGING])
#SRcut = alias[category+"_vetoAK8"].format(WP=working_points[BTAGGING])
if ADDSELECTION: SRcut += SELECTIONS[options.selection]
print " Cut:\t", SRcut
#*******************************************************#
# #
# Signal fits #
# #
#*******************************************************#
treeSign = {}
setSignal = {}
vmean = {}
vsigma = {}
valpha1 = {}
vslope1 = {}
valpha2 = {}
vslope2 = {}
smean = {}
ssigma = {}
salpha1 = {}
sslope1 = {}
salpha2 = {}
sslope2 = {}
sbrwig = {}
signal = {}
signalExt = {}
signalYield = {}
signalIntegral = {}
signalNorm = {}
signalXS = {}
frSignal = {}
frSignal1 = {}
frSignal2 = {}
frSignal3 = {}
# Signal shape uncertainties (common amongst all mass points)
xmean_jes = RooRealVar("CMS"+YEAR+"_sig_"+category+"_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.02, -1., 1.) #0.001
smean_jes = RooRealVar("CMS"+YEAR+"_sig_"+category+"_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10)
xsigma_jer = RooRealVar("CMS"+YEAR+"_sig_"+category+"_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.10, -1., 1.)
ssigma_jer = RooRealVar("CMS"+YEAR+"_sig_"+category+"_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10)
xmean_jes.setConstant(True)
smean_jes.setConstant(True)
xsigma_jer.setConstant(True)
ssigma_jer.setConstant(True)
for m in massPoints:
signalMass = "%s_M%d" % (stype, m)
signalName = "ZpBB_{}_{}_M{}".format(YEAR, category, m)
sampleName = "bstar_M{}".format(m)
signalColor = sample[sampleName]['linecolor'] if signalName in sample else 1
# define the signal PDF
vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m*0.96, m*1.05)
smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)", RooArgList(vmean[m], xmean_jes, smean_jes))
vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m*0.0233, m*0.019, m*0.025)
ssigma[m] = RooFormulaVar(signalName + "_sigma", "@0*(1+@1*@2)", RooArgList(vsigma[m], xsigma_jer, ssigma_jer))
valpha1[m] = RooRealVar(signalName + "_valpha1", "Crystal Ball alpha 1", 0.2, 0.05, 0.28) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right
salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0", RooArgList(valpha1[m]))
#vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 10., 0.1, 20.) # slope of the power tail
vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 13., 10., 20.) # slope of the power tail
sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0", RooArgList(vslope1[m]))
valpha2[m] = RooRealVar(signalName + "_valpha2", "Crystal Ball alpha 2", 1.)
valpha2[m].setConstant(True)
salpha2[m] = RooFormulaVar(signalName + "_alpha2", "@0", RooArgList(valpha2[m]))
#vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", 6., 2.5, 15.) # slope of the higher power tail
## FIXME test FIXME
vslope2_estimation = -5.88111436852 + m*0.00728809389442 + m*m*(-1.65059568762e-06) + m*m*m*(1.25128996309e-10)
vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", vslope2_estimation, vslope2_estimation*0.9, vslope2_estimation*1.1) # slope of the higher power tail
## FIXME end FIXME
sslope2[m] = RooFormulaVar(signalName + "_slope2", "@0", RooArgList(vslope2[m])) # slope of the higher power tail
signal[m] = RooDoubleCrystalBall(signalName, "m_{%s'} = %d GeV" % ('X', m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m], salpha2[m], sslope2[m])
# extend the PDF with the yield to perform an extended likelihood fit
signalYield[m] = RooRealVar(signalName+"_yield", "signalYield", 50, 0., 1.e15)
signalNorm[m] = RooRealVar(signalName+"_norm", "signalNorm", 1., 0., 1.e15)
signalXS[m] = RooRealVar(signalName+"_xs", "signalXS", 1., 0., 1.e15)
signalExt[m] = RooExtendPdf(signalName+"_ext", "extended p.d.f", signal[m], signalYield[m])
# ---------- if there is no simulated signal, skip this mass point ----------
if m in genPoints:
if VERBOSE: print " - Mass point", m
# define the dataset for the signal applying the SR cuts
treeSign[m] = TChain("tree")
if YEAR=='run2':
pd = sample[sampleName]['files']
if len(pd)>3:
print "multiple files given than years for a single masspoint:",pd
sys.exit()
for ss in pd:
if not '2016' in ss and not '2017' in ss and not '2018' in ss:
print "unknown year given in:", ss
sys.exit()
else:
pd = [x for x in sample[sampleName]['files'] if YEAR in x]
if len(pd)>1:
print "multiple files given for a single masspoint/year:",pd
sys.exit()
for ss in pd:
if options.unskimmed:
j=0
while True:
if os.path.exists(NTUPLEDIR + ss + "/" + ss + "_flatTuple_{}.root".format(j)):
treeSign[m].Add(NTUPLEDIR + ss + "/" + ss + "_flatTuple_{}.root".format(j))
j += 1
else:
print "found {} files for sample:".format(j), ss
break
else:
if os.path.exists(NTUPLEDIR + ss + ".root"):
treeSign[m].Add(NTUPLEDIR + ss + ".root")
else:
print "found no file for sample:", ss
if treeSign[m].GetEntries() <= 0.:
if VERBOSE: print " - 0 events available for mass", m, "skipping mass point..."
signalNorm[m].setVal(-1)
vmean[m].setConstant(True)
vsigma[m].setConstant(True)
salpha1[m].setConstant(True)
sslope1[m].setConstant(True)
salpha2[m].setConstant(True)
sslope2[m].setConstant(True)
signalNorm[m].setConstant(True)
signalXS[m].setConstant(True)
continue
#setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar("eventWeightLumi*BTagAK4Weight_deepJet"), RooFit.Import(treeSign[m]))
setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeSign[m]))
if VERBOSE: print " - Dataset with", setSignal[m].sumEntries(), "events loaded"
# FIT
entries = setSignal[m].sumEntries()
if entries < 0. or entries != entries: entries = 0
signalYield[m].setVal(entries)
# Instead of eventWeightLumi
#signalYield[m].setVal(entries * LUMI / (300000 if YEAR=='run2' else 100000) )
if treeSign[m].GetEntries(SRcut) > 5:
if VERBOSE: print " - Running fit"
frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1), RooFit.Extended(True), RooFit.SumW2Error(True), RooFit.PrintLevel(-1))
if VERBOSE: print "********** Fit result [", m, "] **", category, "*"*40, "\n", frSignal[m].Print(), "\n", "*"*80
if VERBOSE: frSignal[m].correlationMatrix().Print()
drawPlot(signalMass+"_"+category, stype+category, X_mass, signal[m], setSignal[m], frSignal[m])
else:
print " WARNING: signal", stype, "and mass point", m, "in category", category, "has 0 entries or does not exist"
# Remove HVT cross sections
#xs = getCrossSection(stype, channel, m)
xs = 1.
signalXS[m].setVal(xs * 1000.)
signalIntegral[m] = signalExt[m].createIntegral(massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range"))
boundaryFactor = signalIntegral[m].getVal()
if boundaryFactor < 0. or boundaryFactor != boundaryFactor: boundaryFactor = 0
if VERBOSE: print " - Fit normalization vs integral:", signalYield[m].getVal(), "/", boundaryFactor, "events"
signalNorm[m].setVal( boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal()) # here normalize to sigma(X) x Br = 1 [fb]
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)
space.factory('Polynomial::pPDF_%s(X,{c1_%s[0.01,-2.,0.2],c2_%s[0.01,-3.,1.0]})' % (label,label,label) )
#space.factory('Polynomial::pPDF_%s(lbl0Mass,{c1_%s[0.01,-5.,5.]})' % (label,label) )
# set resolution issue: Convolute a gaussian.
space.factory('numCombBkg_{0}[{1},0.,{2}]'.format(label, totNum,totNum))
myPDF=RooAddPdf('totPdf_{0}'.format(label),'totPdf_{0}'.format(label),
RooArgList( space.pdf('pPDF_{0}'.format(label)),
space.pdf('gPDF_lbl0Dist_lbl0MC') ),
RooArgList( space.var('numCombBkg_{0}'.format(label)),
space.var('numLb') ),
False)
getattr(space,'import')(myPDF)
constrSet=RooArgSet()
for constredName in constredNames['pLbL0']:
constrSet.add(space.pdf(constredName))
fitres=myPDF.fitTo(binData,RooFit.Range('sigShortRange'),RooFit.Save(),RooFit.Minos(True),RooFit.ExternalConstraints(constrSet))
#fitres=myPDF.fitTo(binData,RooFit.Range('sigShortRange'),RooFit.Save(),RooFit.Minos(True))
plotframe=massLb.frame(RooFit.Title(label),RooFit.Range('sigShortRange'))
binData.plotOn(plotframe,RooFit.Name('data'))
myPDF.plotOn(plotframe,RooFit.Name('totModel'),RooFit.LineWidth(1),RooFit.LineColor(2))
myPDF.plotOn(plotframe,RooFit.Name('combBkg'),RooFit.Components('pPDF_{0}' .format(label)),RooFit.LineWidth(1),RooFit.LineColor(27))
myPDF.plotOn(plotframe,RooFit.Name('sig') ,RooFit.Components('gPDF_lbl0Dist_lbl0MC' ),RooFit.LineStyle(5),RooFit.LineColor(8 ))
plotframe.Draw()
#canv.SaveAs('tmpLbL0.pdf')
#pfigDir.cd()
def fitChicSpectrum(dataset, binname):
""" Fit chic spectrum"""
x = RooRealVar('Qvalue', 'Q', 9.7, 10.1)
x.setBins(80)
mean_1 = RooRealVar("mean_1", "mean ChiB1", 9.892, 9, 10, "GeV")
sigma_1 = RooRealVar("sigma_1", "sigma ChiB1", 0.0058, 'GeV')
a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', 0.748)
n1_1 = RooRealVar('n1_1', 'n1_1', 2.8)
a2_1 = RooRealVar('#alpha2_1', '#alpha2_1', 1.739)
n2_1 = RooRealVar('n2_1', 'n2_1', 3.0)
deltam = RooRealVar('deltam', 'deltam', 0.01943)
mean_2 = RooFormulaVar("mean_2", "@0+@1", RooArgList(mean_1, deltam))
sigma_2 = RooRealVar("sigma_2", "sigma ChiB2", 0.0059, 'GeV')
a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', 0.738)
n1_2 = RooRealVar('n1_2', 'n1_2', 2.8)
a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', 1.699)
n2_2 = RooRealVar('n2_2', 'n2_2', 3.0)
parameters = RooArgSet()
parameters.add(RooArgSet(sigma_1, sigma_2))
parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1)
parameters.add(RooArgSet(a1_2, a2_2, n1_2, n2_2))
chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1,
a2_1, n2_1)
chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2,
a2_2, n2_2)
#background
q01S_Start = 9.5
alpha = RooRealVar("#alpha", "#alpha", 1.5, -1, 3.5) #0.2 anziche' 1
beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.)
q0 = RooRealVar("q0", "q0", q01S_Start) #,9.5,9.7)
delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0))
b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0))
signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.",
RooArgList(x, q0))
background = RooGenericPdf("background", "Background",
"signum1*pow(delta,#alpha)*exp(b1)",
RooArgList(signum1, delta, alpha, b1))
parameters.add(RooArgSet(alpha, beta, q0))
#together
chibs = RooArgList(chib1_pdf, chib2_pdf, background)
n_chib = RooRealVar("n_chib", "n_chib", 2075, 0, 100000)
ratio_21 = RooRealVar("ratio_21", "ratio_21", 0.5, 0, 1)
n_chib1 = RooFormulaVar("n_chib1", "@0/(1+@1)",
RooArgList(n_chib, ratio_21))
n_chib2 = RooFormulaVar("n_chib2", "@0/(1+1/@1)",
RooArgList(n_chib, ratio_21))
n_background = RooRealVar('n_background', 'n_background', 4550, 0, 50000)
ratio_list = RooArgList(n_chib1, n_chib2, n_background)
modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list)
frame = x.frame(RooFit.Title('m'))
range = x.setRange('range', 9.7, 10.1)
result = modelPdf.fitTo(dataset, RooFit.Save(), RooFit.Range('range'))
dataset.plotOn(frame, RooFit.MarkerSize(0.7))
modelPdf.plotOn(frame, RooFit.LineWidth(2))
#plotting
canvas = TCanvas('fit', "", 1400, 700)
canvas.Divide(1)
canvas.cd(1)
gPad.SetRightMargin(0.3)
gPad.SetFillColor(10)
modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9))
frame.Draw()
canvas.SaveAs('out-' + binname + '.png')
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())
n_rt = htag.GetBinContent(3)
n_wt = htag.GetBinContent(2) + htag.GetBinContent(4)
h_truef.Fill(float(n_rt) / (n_rt + n_wt))
tagged_mass = RooRealVar("tagged_mass", "#mu^{+}#mu^{-}K#pi mass", 5., 5.6,
"GeV")
mumuMass = RooRealVar("mumuMass", "mumuMass", 0, 6)
mumuMassE = RooRealVar("mumuMassE", "mumuMassE", 0, 10000)
tagB0 = RooRealVar("tagB0", "tagB0", 0, 6)
genSignal = RooRealVar("genSignal", "genSignal", 0, 6)
tagged_mass.setRange("full", 5.0, 5.6)
thevars = RooArgSet()
thevars.add(tagged_mass)
thevars.add(mumuMass)
thevars.add(mumuMassE)
thevars.add(tagB0)
thevars.add(genSignal)
fulldata = RooDataSet('fulldata', 'fulldataset', tData, RooArgSet(thevars))
## add to the input tree the combination of the variables, to be used for the cuts on the dimuon mass
deltaB0Mfunc = RooFormulaVar("deltaB0M", "deltaB0M", "@0 - @1",
RooArgList(tagged_mass, B0Mass))
deltaJMfunc = RooFormulaVar("deltaJpsiM", "deltaJpsiM", "@0 - @1",
RooArgList(mumuMass, JPsiMass))
deltaPMfunc = RooFormulaVar("deltaPsiPM", "deltaPsiPM", "@0 - @1",
RooArgList(mumuMass, PsiPMass))
deltaB0M = fulldata.addColumn(deltaB0Mfunc)
deltaJpsiM = fulldata.addColumn(deltaJMfunc)
dict_b_v1 = {}
dict_sigma = {}
### retrieve S from fitting the MC sample
bMass = RooRealVar("bMass", "#mu^{+}#mu^{-}K* mass", 2, 20, "GeV")
bBarMass = RooRealVar("bBarMass", "#mu^{+}#mu^{-}K* mass", 2, 20, "GeV")
mumuMass = RooRealVar("mumuMass", "mumuMass", 0, 1000)
mumuMassE = RooRealVar("mumuMassE", "mumuMassE", 0, 10000)
tagB0 = RooRealVar("tagB0", "tagB0", -1, 2)
bdt_prob = RooRealVar("bdt_prob", "bdt_prob", 0.5,
2) ## already cut here on BDT !!!
pass_pre = RooRealVar("pass_preselection", "pass_preselection", 1,
2) ## cut on preselection
thevars = RooArgSet()
thevars.add(bMass)
thevars.add(bBarMass)
thevars.add(mumuMass)
thevars.add(mumuMassE)
thevars.add(tagB0)
thevars.add(bdt_prob)
tree = ROOT.TChain('ntuple')
tree.AddFile(ifileMC)
fulldata = RooDataSet('fulldata', 'fulldataset', tree, RooArgSet(thevars))
## add to the input tree the combination of the variables for the B0 arb. mass
theBMassfunc = RooFormulaVar("theBMass",
"#mu^{+}#mu^{-}K^{#pm}#pi^{#mp} mass [GeV]",
"@0*@1 + (1-@0)*@2",
RooArgList(tagB0, bMass, bBarMass))
def fitData(fulldata, ibin, w):
cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)'%(q2binning[ibin], q2binning[ibin+1])
data = fulldata.reduce(RooArgSet(tagged_mass,mumuMass,mumuMassE), cut)
nrt_mc = _getFittedVar("nRT_%s"%ibin, w)
nwt_mc = _getFittedVar("nWT_%s"%ibin, w)
fraction = nrt_mc / (nrt_mc + nwt_mc)
print 'mistag fraction on MC for bin ', ibin , ' : ' , fraction.n , '+/-', fraction.s
### creating RT component
w.loadSnapshot("reference_fit_RT_%s"%ibin)
mean_rt = w.var("mean^{RT%s}"%ibin)
sigma_rt1 = w.var("#sigma_{RT1}^{%s}"%ibin)
sigma_rt2 = RooRealVar()
alpha_rt1 = RooRealVar()
alpha_rt2 = RooRealVar()
n_rt1 = RooRealVar()
n_rt2 = RooRealVar()
f1rt = RooRealVar()
## double cb fast
if ibin < 4:
alpha_rt1 = w.var("#alpha_{RT1}^{%s}"%ibin)
alpha_rt2 = w.var("#alpha_{RT2}^{%s}"%ibin)
n_rt1 = w.var("n_{RT1}^{%s}"%ibin)
n_rt2 = w.var("n_{RT2}^{%s}"%ibin)
## double cb old
else:
sigma_rt2 = w.var("#sigma_{RT2}^{%s}"%ibin)
alpha_rt1 = w.var("#alpha_{RT1}^{%s}"%ibin)
alpha_rt2 = w.var("#alpha_{RT2}^{%s}"%ibin)
n_rt1 = w.var("n_{RT1}^{%s}"%ibin)
n_rt2 = w.var("n_{RT2}^{%s}"%ibin)
f1rt = w.var("f^{RT%s}"%ibin)
theRTgauss = w.pdf("doublecb_RT%s"%ibin)
### creating WT component
w.loadSnapshot("reference_fit_WT_%s"%ibin)
mean_wt = w.var("mean_{WT}^{%s}"%ibin)
sigma_wt = w.var("#sigma_{WT1}^{%s}"%ibin)
alpha_wt1 = w.var("#alpha_{WT1}^{%s}"%ibin)
alpha_wt2 = w.var("#alpha_{WT2}^{%s}"%ibin)
n_wt1 = w.var("n_{WT1}^{%s}"%ibin)
n_wt2 = w.var("n_{WT2}^{%s}"%ibin)
theWTgauss = w.pdf("doublecb_%s"%ibin)
### creating variable for the difference between the two peaks
deltaPeaks = RooFormulaVar("deltaPeaks%s"%ibin, "@0 - @1", RooArgList(mean_rt, mean_wt))
frt = RooRealVar ("F_{RT}%s"%ibin , "frt" , fraction.n , 0, 1)
signalFunction = RooAddPdf ("sumgaus%s"%ibin , "rt+wt" , RooArgList(theRTgauss,theWTgauss), RooArgList(frt))
### now create background parametrization
slope = RooRealVar ("slope_%s"%ibin , "slope" , 0.5, -10, 10);
bkg_exp = RooExponential("bkg_exp%s"%ibin , "exponential" , slope, tagged_mass );
pol_c1 = RooRealVar ("p1_%s"%ibin , "coeff x^0 term" , 0.5, -10, 10);
pol_c2 = RooRealVar ("p2_%s"%ibin , "coeff x^1 term" , 0.5, -10, 10);
bkg_pol = RooPolynomial ("bkg_pol%s"%ibin , "2nd order pol" , tagged_mass, RooArgList(pol_c1, pol_c2));
fsig = RooRealVar("fsig%s"%ibin , "fsig" , 0.9, 0, 1);
# nsig = RooRealVar("Yield%s"%ibin , "signal frac" , 1000, 0, 10000);
# nbkg = RooRealVar("nbkg%s"%ibin , "bkg fraction" , 1000, 0, 500000);
nsig = RooRealVar("Yield" , "signal frac" , 600000, 0, 5000000);
nbkg = RooRealVar("nbkg" , "bkg fraction" , 100000, 0, 2000000);
# if ibin==4:
# nsig.setRange(500000,1500000)
# nsig.setVal(900000)
# nbkg.setRange(80000,1000000)
# nbkg.setVal(100000)
### creating constraints
c_vars = RooArgSet()
c_pdfs = RooArgSet()
c_sigma_rt1 = _constrainVar(sigma_rt1, 1)
c_alpha_rt1 = _constrainVar(alpha_rt1, 1)
c_alpha_rt2 = _constrainVar(alpha_rt2, 1)
c_n_rt1 = _constrainVar(n_rt1, 1)
c_n_rt2 = _constrainVar(n_rt2, 1)
c_sigma_wt = _constrainVar(sigma_wt, 1)
c_alpha_wt1 = _constrainVar(alpha_wt1, 1)
c_alpha_wt2 = _constrainVar(alpha_wt2, 1)
c_n_wt1 = _constrainVar(n_wt1, 1)
c_n_wt2 = _constrainVar(n_wt2, 1)
if ibin < 4:
c_pdfs = RooArgSet(c_sigma_rt1, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2)
c_vars = RooArgSet(sigma_rt1, alpha_rt1, alpha_rt2, n_rt1, n_rt2)
else:
c_sigma_rt2 = _constrainVar(sigma_rt2, 1)
c_pdfs = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2)
c_vars = RooArgSet( sigma_rt1, sigma_rt2, alpha_rt1, alpha_rt2, n_rt1, n_rt2)
c_pdfs.add(c_sigma_wt); c_vars.add(sigma_wt)
c_pdfs.add(c_alpha_wt1); c_vars.add(alpha_wt1)
c_pdfs.add(c_alpha_wt2); c_vars.add(alpha_wt2)
c_pdfs.add(c_n_wt1); c_vars.add(n_wt1)
c_pdfs.add(c_n_wt2); c_vars.add(n_wt2)
c_deltaPeaks = RooGaussian("c_deltaPeaks%s"%ibin , "c_deltaPeaks", deltaPeaks, ROOT.RooFit.RooConst( deltaPeaks.getVal() ),
ROOT.RooFit.RooConst( 0.0005 ) ## value to be checked
)
c_pdfs.add(c_deltaPeaks)
c_vars.add(deltaPeaks)
c_frt = RooGaussian("c_frt%s"%ibin , "c_frt" , frt, ROOT.RooFit.RooConst(fraction.n) , ROOT.RooFit.RooConst(frt_sigma[ibin]) )
c_pdfs.add(c_frt)
c_vars.add(frt)
constr_list = RooArgList(c_pdfs)
constr_list.add(signalFunction)
c_signalFunction = RooProdPdf ("c_signalFunction", "c_signalFunction", constr_list)
# mean = RooRealVar ("mass" , "mean" , B0Mass_, 3, 7, "GeV")
# sigma = RooRealVar ("#sigma_{1}" , "sigma" , 0.028, 0, 10, "GeV")
# signalGauss = RooGaussian("signalGauss" , "signal gauss" , tagged_mass, mean,sigma)
#
# sigma2 = RooRealVar ("#sigma_{2}" , "sigma2" , 0.048, 0, 0.07, "GeV")
# signalGauss2 = RooGaussian("signalGauss2" , "signal gauss2" , tagged_mass, mean,sigma2)
# f1 = RooRealVar ("f1" , "f1" , 0.8 , 0., 1.)
# gaus = RooAddPdf ("gaus" , "gaus1+gaus2" , RooArgList(signalGauss,signalGauss2), RooArgList(f1))
# pol_c1 = RooRealVar ("p1" , "coeff x^0 term", 0.5, -10, 10);
# pol_c2 = RooRealVar ("p2" , "coeff x^1 term", 0.5, -10, 10);
# pol_c3 = RooRealVar ("p3" , "coeff x^2 term", 0.5, -10, 10);
# slope = RooRealVar ("slope" , "slope" , 0.5, -10, 10);
# bkg_exp = RooExponential("bkg_exp" , "exponential" , slope, tagged_mass );
# bkg_pol = RooChebychev("bkg_pol" , "2nd order pol" , tagged_mass, RooArgList(pol_c1,pol_c2));
fitFunction = RooAddPdf ("fitfunction%s"%ibin , "fit function" , RooArgList(c_signalFunction, bkg_exp), RooArgList(nsig, nbkg))
# r = fitFunction.fitTo(data,
# # RooFit.Extended(True),
# RooFit.Range("full"),
# ROOT.RooFit.Constrain(c_vars),
# ROOT.RooFit.Minimizer("Minuit2","migrad"),
# ROOT.RooFit.Hesse(True),
# ROOT.RooFit.Strategy(2),
# ROOT.RooFit.Minos(False),
# )
print 'fit with Hesse strategy 2 done, now Minos'
r = fitFunction.fitTo(data,
RooFit.Extended(True),
RooFit.Save(),
RooFit.Range("full"),
RooFit.Verbose(False),
ROOT.RooFit.Constrain(c_vars),
# ROOT.RooFit.Minimizer("Minuit2","migrad"),
# ROOT.RooFit.Hesse(True),
# ROOT.RooFit.Strategy(2),
# ROOT.RooFit.Minos(False),
)
r.Print()
r.correlationMatrix().Print()
fitStats['data%s'%(ibin)] = r.status()
covStats['data%s'%(ibin)] = r.covQual()
frame = tagged_mass.frame( RooFit.Range("full") )
data.plotOn(frame, RooFit.Binning(nbins), RooFit.MarkerSize(.7))
fitFunction.plotOn(frame, RooFit.NormRange("full"), RooFit.Range("full"))
## evaluate sort of chi2 and save number of RT/WT events
observables = RooArgSet(tagged_mass)
flparams = fitFunction.getParameters(observables)
nparam = int(flparams.selectByAttrib("Constant",ROOT.kFALSE).getSize())
pdfstring = "fitfunction%s_Norm[tagged_mass]_Range[full]_NormRange[full]"%ibin
chi2s['data%s'%ibin] = frame.chiSquare(pdfstring, "h_fulldata", nparam)
frame. addObject(_writeChi2( chi2s['data%s'%ibin] ))
drawPdfComponents(fitFunction, frame, ROOT.kAzure, RooFit.NormRange("full"), RooFit.Range("full"), isData = True)
# fitFunction.paramOn(frame, RooFit.Layout(0.62,0.86,0.89))
parList = RooArgSet (nsig, mean_rt, sigma_rt, alpha_rt1, alpha_rt2, n_rt1, n_rt2, mean_wt, sigma_wt)
# parList.add(alphawt1)
# parList.add(alphawt2)
# parList.add(nwt1)
# parList.add(nwt2)
parList.add(frt)
fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62,0.86,0.89))
frame.Draw()
niceFrame(frame, '')
frame. addObject(_writeFitStatus(r))
c1 = ROOT.TCanvas()
upperPad = ROOT.TPad('upperPad' , 'upperPad' , 0., 0.35 , 1., 1. )
lowerPad = ROOT.TPad('lowerPad' , 'lowerPad' , 0., 0.0 , 1., 0.345 )
upperPad.SetBottomMargin(0.012)
lowerPad.SetTopMargin(0)
lowerPad.SetBottomMargin(0.2)
upperPad.Draw(); lowerPad.Draw()
upperPad.cd()
frame.Draw()
if not args.year=='test': writeCMS(frame, args.year, [ q2binning[ibin], q2binning[ibin+1] ], 0)
frame.Draw()
## add plot of pulls
lowerPad.cd()
hpull = frame.pullHist("h_fulldata", pdfstring)
frame2 = tagged_mass.frame(RooFit.Range("full"), RooFit.Title(''))
frame2.addPlotable(hpull,"P")
niceFrameLowerPad(frame2, 'pull')
frame2.Draw()
line = ROOT.TLine(5.0,1,5.6,1)
line.SetLineColor(ROOT.kGreen+3)
line.Draw()
for ilog in [True,False]:
upperPad.SetLogy(ilog)
c1.SaveAs('fit_results_mass/save_fit_data_%s_%s_LMNR_Update%s_newSigmaFRT_pars_Jpsi.pdf'%(ibin, args.year, '_logScale'*ilog))
out_f.cd()
r.Write('results_data_%s'%(ibin))
params = fitFunction.getParameters(RooArgSet(tagged_mass))
out_w.saveSnapshot("reference_fit_data_%s"%(ibin),params,ROOT.kTRUE)
getattr(out_w, 'import')(fitFunction)
ws_file.Close()
dataset_COMB_CORR = wsp_0.data("dataset_COMB_CORR")
ws_file0 = TFile("/afs/cern.ch/user/"+prefix+"/"+user+"/eos/lhcb/user/"+prefix+"/"+user+"/WrongSign/2015/WorkSpaces/Merged_WS_Bin_0.root", "read")
wsp = ws_file0.Get("wspace")
ws_file0.Close()
start = datetime.now()
LOG_D0_IPCHI2_OWNPV = wsp.var("LOG_D0_IPCHI2_OWNPV")
Dst_DTF_D0_CTAU = wsp.var("Dst_DTF_D0_CTAU")
DTF_D0sPi_M = wsp.var("DTF_D0sPi_M")
DTF_D0sPi_M.setMax(2020)
DTF_D0sPi_M.setMin(2000)
varset_small = RooArgSet("varset_small")
varset_small.add(LOG_D0_IPCHI2_OWNPV)
varset_small.add(Dst_DTF_D0_CTAU)
varset_small.add(DTF_D0sPi_M)
#Create histogram for time bin 0
dataset_RS_0 = wsp.data("dataset_RS")
dataset_RS_0.SetName("dataset_RS_0")
print "dataset_RS_0 extraction took "+str(datetime.now()-start)+" \n"
start = datetime.now()
hist_RS_0 = RooDataHist("hist_RS_0","hist_RS_0", RooArgSet(LOG_D0_IPCHI2_OWNPV), dataset_RS_0)
print "RooDataHist creation took "+str(datetime.now()-start)+" \n"
start = datetime.now()
shape_RS_0 = RooHistPdf("shape_RS_0", "shape_RS_0", RooArgSet(LOG_D0_IPCHI2_OWNPV), hist_RS_0)
print "RooHistPdf creation took "+str(datetime.now()-start)+" \n"
h_0 = hist_RS_0.createHistogram("LOG_D0_IPCHI2_OWNPV", 100)
def run(self, **kwargs):
from ROOT import RooArgSet
__check_req_kw__("Observables", kwargs)
__check_req_kw__("Pdf", kwargs)
__check_req_kw__("Sigmat", kwargs)
__check_req_kw__("Time", kwargs)
__check_req_kw__("SigmaGen", kwargs)
sigma_gen = kwargs.pop("SigmaGen")
observables = kwargs.pop("Observables")
obs_set = RooArgSet(*observables)
pdf = kwargs.pop("Pdf")
sigmat = kwargs.pop("Sigmat")
time = kwargs.pop("Time")
gen_obs_set = RooArgSet(*observables)
# Make another ArgSet to put the fit results in
result_params = RooArgSet("result_params")
from P2VV.RooFitWrappers import RealVar
da = RealVar("da", Observable=True, MinMax=(0.01, 1.1))
dft = RealVar("dft", Observable=True, MinMax=(0.01, 1.1))
result_params.add(da._target_())
result_params.add(dft._target_())
transform = self.transform()
if transform:
trans_params = transform.gen_params(gen_obs_set)
self._gen_params.extend(trans_params)
for p in trans_params:
result_params.add(p)
# Some extra numbers of interest
from ROOT import RooRealVar
seed = RooRealVar("seed", "random seed", 0.0)
result_params.add(seed)
# The dataset to store the results
from ROOT import RooDataSet
self._data = RooDataSet("result_data", "result_data", result_params)
data_params = self._data.get()
from ROOT import RooRandom
import struct, os
# Reset pdf parameters to initial values. Note: this does not reset the estimated errors...
args = dict(NumEvents=self.options().nevents)
if "ProtoData" in kwargs:
args["ProtoData"] = kwargs.pop("ProtoData")
spec = pdf.prepareMultiGen(obs_set, **args)
while self._data.numEntries() < self.options().ntoys:
# Get a good random seed, set it and store it
s = struct.unpack("I", os.urandom(4))[0]
RooRandom.randomGenerator().SetSeed(s)
seed.setVal(s)
data = pdf.generate(spec)
if self.transform():
old_data = data
data = self.transform()(old_data)
if not data:
transform.set_params(data_params)
self._data.add(data_params)
continue
from P2VV import Dilution
d_ft = Dilution.dilution_ft(data, time, t_range=2, quiet=True)
d_a = Dilution.signal_dilution_dg(data, sigmat, *sigma_gen)
da.setVal(d_a[0])
da.setError(d_a[1] if d_a[1] != None else 0.0)
dft.setVal(d_ft[0])
dft.setError(d_ft[1] if d_ft[1] != None else 0.0)
if transform:
transform.set_params(data_params)
self._data.add(result_params)
return self.data()
def 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 latexfitresults(filename,
regionList,
sampleList,
dataname='obsData',
showSum=False,
doAsym=True,
blinded=False,
splitBins=False):
"""
Calculate before/after-fit yields in all channels given
@param filename The filename containing afterFit workspace
@param regionList A list of regions to be considered
@param sampleList A list of samples to be considered
@param dataname The name of dataset (default='obsData')
@param showSum Calculates sum of all regions if set to true (default=False)
@param doAsym Calculates asymmetric errors taken from MINOS (default=True)
@param blinded Observed event count will not be shown if set to True (default=False)
@param splitBins Calculates bin-by-bin yields for all regions if set to True (default=False)
"""
"""
pick up workspace from file
"""
workspacename = 'w'
w = Util.GetWorkspaceFromFile(filename, 'w')
if w == None:
print "ERROR : Cannot open workspace : ", workspacename
sys.exit(1)
"""
pick up after-fit RooExpandedFitResult from workspace
"""
resultAfterFit = w.obj('RooExpandedFitResult_afterFit')
if resultAfterFit == None:
print "ERROR : Cannot open fit result after fit RooExpandedFitResult_afterFit"
sys.exit(1)
"""
pick up before-fit RooExpandedFitResult from workspace
"""
resultBeforeFit = w.obj('RooExpandedFitResult_beforeFit')
if resultBeforeFit == None:
print "ERROR : Cannot open fit result before fit RooExpandedFitResult_beforeFit"
sys.exit(1)
"""
pick up dataset from workspace
"""
data_set = w.data(dataname)
if data_set == None:
print "ERROR : Cannot open dataset : ", "data_set" + suffix
sys.exit(1)
"""
pick up channel category (RooCategory) from workspace
"""
regionCat = w.obj("channelCat")
if not blinded:
data_set.table(regionCat).Print("v")
"""
find full (long) name list of regions (i.e. short=SR3J, long=SR3J_meffInc30_JVF25pt50)
"""
regionFullNameList = [
Util.GetFullRegionName(regionCat, region) for region in regionList
]
"""
load afterFit workspace snapshot (=set all parameters to values after fit)
"""
snapshot = 'snapshot_paramsVals_RooExpandedFitResult_afterFit'
w.loadSnapshot(snapshot)
if not w.loadSnapshot(snapshot):
print "ERROR : Cannot load snapshot : ", snapshot
sys.exit(1)
"""
define set, for all names/yields to be saved in
"""
tablenumbers = {}
"""
if showSum=True define names for sum of all regions and add to regionList
"""
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
"""
make a list of channelCat calls for every region
"""
regionCatList = [
'channelCat==channelCat::' + region.Data()
for region in regionFullNameList
]
"""
retrieve number of observed (=data) events per region
"""
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]
"""
if showSum=True calculate the total number of observed events in all regions
"""
sumNobs = 0.
for nobs in nobs_regionList:
sumNobs += nobs
if showSum:
nobs_regionList.append(sumNobs)
tablenumbers['nobs'] = nobs_regionList
"""
FROM HERE ON OUT WE CALCULATE THE FITTED NUMBER OF EVENTS __AFTER__ THE FIT
"""
"""
get a list of pdf's and variables per region
"""
pdfinRegionList = [Util.GetRegionPdf(w, region) for region in regionList]
varinRegionList = [Util.GetRegionVar(w, region) for region in regionList]
"""
if splitBins=True get the list of Nbins, binMax and binMin; make a list of new region names for each bin
"""
varNbinsInRegionList = []
varBinLowInRegionList = []
varBinHighInRegionList = []
rangeNameBinsInRegionList = []
if splitBins:
varNbinsInRegionList = [
Util.GetRegionVar(w, region).getBinning().numBins()
for region in regionList
]
varBinLowInRegionList = [[
Util.GetRegionVar(w, region).getBinning(
(region + "binning")).binLow(ibin)
for ibin in range(0, varNbinsInRegionList[idx])
] for idx, region in enumerate(regionList)]
varBinHighInRegionList = [[
Util.GetRegionVar(w, region).getBinning(
(region + "binning")).binHigh(ibin)
for ibin in range(0, varNbinsInRegionList[idx])
] for idx, region in enumerate(regionList)]
rangeNameBinsInRegionList = [[
regionList[idx] + "_bin" + str(ibin)
for ibin in range(0, varNbinsInRegionList[idx])
] for idx, region in enumerate(regionList)]
for index, region in enumerate(regionList):
if varNbinsInRegionList[index] == 1:
print " \n YieldsTable.py: WARNING: you have called -P (= per-bin yields) but this region ", region, " has only 1 bin \n"
"""
if splitBins=True reshuffle the regionName list; each region name is followed by names of each bin (i.e. regionNameList=['SR3J','SR3J_bin1','SR3j_bin2','SR4J','SR4J_bin1'])
"""
regionListWithBins = []
if splitBins:
for index, region in enumerate(regionList):
regionListWithBins.append(region)
for ibin in range(0, varNbinsInRegionList[index]):
regionListWithBins.append(
rangeNameBinsInRegionList[index][ibin])
tablenumbers['names'] = regionListWithBins
"""
calculate number of observed(=data) events per bin
"""
nobs_regionListWithBins = []
if splitBins:
binFuncInRegionList = [
RooBinningCategory("bin_" + region, "bin_" + region,
varinRegionList[index])
for index, region in enumerate(regionList)
]
for index, data in enumerate(regionDatasetList):
data.addColumn(binFuncInRegionList[index])
if not blinded:
data.table(binFuncInRegionList[index]).Print("v")
nobs_regionListWithBins.append(data.sumEntries())
for ibin in range(0, varNbinsInRegionList[index]):
nobs_regionListWithBins.append(
(data.reduce(binFuncInRegionList[index].GetName() + "==" +
binFuncInRegionList[index].GetName() + "::" +
varinRegionList[index].GetName() + "_bin" +
str(ibin))).sumEntries())
tablenumbers['nobs'] = nobs_regionListWithBins
"""
if blinded=True, set all numbers of observed events to -1
"""
if blinded:
for index, nobs in enumerate(nobs_regionListWithBins):
nobs_regionListWithBins[index] = -1
tablenumbers['nobs'] = nobs_regionListWithBins
"""
get a list of RooRealSumPdf per region (RooRealSumPdf is the top-pdf per region containing all samples)
"""
rrspdfinRegionList = []
for index, pdf in enumerate(pdfinRegionList):
prodList = pdf.pdfList()
foundRRS = 0
for idx in range(prodList.getSize()):
if prodList[idx].InheritsFrom("RooRealSumPdf"):
rrspdfInt = prodList[idx].createIntegral(
RooArgSet(varinRegionList[index]))
rrspdfinRegionList.append(rrspdfInt)
if splitBins:
origMin = varinRegionList[index].getMin()
origMax = varinRegionList[index].getMax()
for ibin in range(0, varNbinsInRegionList[index]):
rangeName = rangeNameBinsInRegionList[index][ibin]
varinRegionList[index].setRange(
rangeName, varBinLowInRegionList[index][ibin],
varBinHighInRegionList[index][ibin])
rrspdfInt = prodList[idx].createIntegral(
RooArgSet(varinRegionList[index]), rangeName)
rrspdfinRegionList.append(rrspdfInt)
varinRegionList[index].setRange(origMin, origMax)
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")
"""
calculate total pdf number of fitted events and error
"""
nFittedInRegionList = [
pdf.getVal() for index, pdf in enumerate(rrspdfinRegionList)
]
pdfFittedErrInRegionList = [
Util.GetPropagatedError(pdf, resultAfterFit, doAsym)
for pdf in rrspdfinRegionList
]
"""
if showSum=True calculate the total number of fitted events in all regions
"""
if showSum:
pdfInAllRegions = RooArgSet()
for index, pdf in enumerate(rrspdfinRegionList):
pdfInAllRegions.add(pdf)
pdfSumInAllRegions = RooAddition("pdf_AllRegions_AFTER",
"pdf_AllRegions_AFTER",
RooArgList(pdfInAllRegions))
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
"""
calculate the fitted number of events and propagated error for each requested sample, by splitting off each sample pdf
"""
for isam, sample in enumerate(sampleList):
sampleName = getName(sample)
nSampleInRegionVal = []
nSampleInRegionError = []
sampleInAllRegions = RooArgSet()
for ireg, region in enumerate(regionList):
sampleInRegion = getPdfInRegions(w, sample, region)
sampleInRegionVal = 0.
sampleInRegionError = 0.
if not sampleInRegion == None:
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 splitBins=True calculate numbers of fitted events plus error per bin
"""
if splitBins:
origMin = varinRegionList[ireg].getMin()
origMax = varinRegionList[ireg].getMax()
for ibin in range(0, varNbinsInRegionList[ireg]):
rangeName = rangeNameBinsInRegionList[ireg][ibin]
sampleInRegion = getPdfInRegionsWithRangeName(
w, sample, region, rangeName)
sampleInRegionVal = 0.
sampleInRegionError = 0.
if not sampleInRegion == None:
varinRegionList[ireg].setRange(
rangeName, varBinLowInRegionList[ireg][ibin],
varBinHighInRegionList[ireg][ibin])
sampleInRegionVal = sampleInRegion.getVal()
sampleInRegionError = Util.GetPropagatedError(
sampleInRegion, resultAfterFit, doAsym)
else:
print " \n YieldsTable.py: WARNING: sample =", sampleName, " non-existent (empty) in region=", region, " bin=", ibin, " \n"
nSampleInRegionVal.append(sampleInRegionVal)
nSampleInRegionError.append(sampleInRegionError)
varinRegionList[ireg].setRange(origMin, origMax)
"""
if showSum=True calculate the total number of fitted events in all regions
"""
if showSum:
sampleSumInAllRegions = RooAddition(
(sampleName + "_AllRegions_FITTED"),
(sampleName + "_AllRegions_FITTED"),
RooArgList(sampleInAllRegions))
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 "\n starting BEFORE-FIT calculations \n"
"""
FROM HERE ON OUT WE CALCULATE THE EXPECTED NUMBER OF EVENTS __BEFORRE__ THE FIT
"""
"""
load beforeFit workspace snapshot (=set all parameters to values before 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())
"""
get a list of pdf's and variables per region
"""
pdfinRegionList = [Util.GetRegionPdf(w, region) for region in regionList]
varinRegionList = [Util.GetRegionVar(w, region) for region in regionList]
"""
get a list of RooRealSumPdf per region (RooRealSumPdf is the top-pdf per region containing all samples)
"""
rrspdfinRegionList = []
for index, pdf in enumerate(pdfinRegionList):
prodList = pdf.pdfList()
foundRRS = 0
for idx in range(prodList.getSize()):
if prodList[idx].InheritsFrom("RooRealSumPdf"):
rrspdfInt = prodList[idx].createIntegral(
RooArgSet(varinRegionList[index]))
rrspdfinRegionList.append(rrspdfInt)
if splitBins:
origMin = varinRegionList[index].getMin()
origMax = varinRegionList[index].getMax()
for ibin in range(0, varNbinsInRegionList[index]):
rangeName = rangeNameBinsInRegionList[index][ibin]
varinRegionList[index].setRange(
rangeName, varBinLowInRegionList[index][ibin],
varBinHighInRegionList[index][ibin])
rrspdfInt = prodList[idx].createIntegral(
RooArgSet(varinRegionList[index]), rangeName)
rrspdfinRegionList.append(rrspdfInt)
varinRegionList[index].setRange(origMin, origMax)
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")
"""
calculate total pdf number of expected events and error
"""
nExpInRegionList = [
pdf.getVal() for index, pdf in enumerate(rrspdfinRegionList)
]
pdfExpErrInRegionList = [
Util.GetPropagatedError(pdf, resultBeforeFit, doAsym)
for pdf in rrspdfinRegionList
]
"""
if showSum=True calculate the total number of expected events in all regions
"""
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
"""
calculate the fitted number of events and propagated error for each requested sample, by splitting off each sample pdf
"""
for isam, sample in enumerate(sampleList):
sampleName = getName(sample)
nMCSampleInRegionVal = []
nMCSampleInRegionError = []
MCSampleInAllRegions = RooArgSet()
for ireg, region in enumerate(regionList):
MCSampleInRegion = getPdfInRegions(w, sample, region)
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 splitBins=True calculate numbers of fitted events plus error per bin
"""
if splitBins:
origMin = varinRegionList[ireg].getMin()
origMax = varinRegionList[ireg].getMax()
for ibin in range(0, varNbinsInRegionList[ireg]):
rangeName = rangeNameBinsInRegionList[ireg][ibin]
MCSampleInRegion = getPdfInRegionsWithRangeName(
w, sample, region, rangeName)
MCSampleInRegionVal = 0.
MCSampleInRegionError = 0.
if not MCSampleInRegion == None:
varinRegionList[ireg].setRange(
rangeName, varBinLowInRegionList[ireg][ibin],
varBinHighInRegionList[ireg][ibin])
MCSampleInRegionVal = MCSampleInRegion.getVal()
MCSampleInRegionError = Util.GetPropagatedError(
MCSampleInRegion, resultBeforeFit, doAsym)
else:
print " \n YieldsTable.py: WARNING: sample =", sampleName, " non-existent (empty) in region=", region, " bin=", ibin, " \n"
nMCSampleInRegionVal.append(MCSampleInRegionVal)
nMCSampleInRegionError.append(MCSampleInRegionError)
varinRegionList[ireg].setRange(origMin, origMax)
"""
if showSum=True calculate the total number of fitted events in all regions
"""
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
"""
sort the tablenumbers set
"""
map_listofkeys = tablenumbers.keys()
map_listofkeys.sort()
"""
print the sorted tablenumbers set
"""
for name in map_listofkeys:
if tablenumbers.has_key(name):
print name, ": ", tablenumbers[name]
return tablenumbers
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 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 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())
"(Dst_DTF_P1_PY+Dst_DTF_P2_PY)",
RooArgList(Dst_DTF_P1_PY, Dst_DTF_P2_PY))
Dst_DTF_D0_PZ = RooFormulaVar("Dst_DTF_D0_PZ", "Dst_DTF_D0_PZ",
"(Dst_DTF_P1_PZ+Dst_DTF_P2_PZ)",
RooArgList(Dst_DTF_P1_PZ, Dst_DTF_P2_PZ))
Dst_M = RooRealVar("Dst_M", "Dst_M", 1700, 2100, "MeV/c^{2}")
D0_TAU = RooRealVar("D0_TAU", "D0_TAU", 0, 20 * tau, "ns")
B_M = RooRealVar("B_M", "B_M", 2900, 8000, "MeV/c^{2}")
B_ENDVERTEX_CHI2 = RooRealVar("B_ENDVERTEX_CHI2", "B_ENDVERTEX_CHI2", -1, 80)
B_ENDVERTEX_NDOF = RooRealVar("B_ENDVERTEX_NDOF", "B_ENDVERTEX_NDOF", 1, 10)
Mu_IPCHI2_OWNPV = RooRealVar("Mu_IPCHI2_OWNPV", "Mu_IPCHI2_OWNPV", 0, 8000)
Mu_IP_OWNPV = RooRealVar("Mu_IP_OWNPV", "Mu_IP_OWNPV", 0, 5)
Mu_PT = RooRealVar("Mu_PT", "Mu_PT", 0, 15000, "MeV/c")
varset = RooArgSet(D0_M)
varset.add(D0_TAU)
varset.add(runNumber)
varset.add(Dst_M)
varset.add(D0_IPCHI2_OWNPV)
varset.add(sPi_M)
varset.add(D0_PE)
varset.add(sPi_PE)
varset.add(D0_PX)
varset.add(sPi_PX)
varset.add(D0_PY)
varset.add(sPi_PY)
varset.add(D0_PZ)
varset.add(sPi_PZ)
varset.add(Dst_DTF_CHI2NDOF)
varset.add(Dst_DTF_D0_CTAU)
varset.add(Dst_DTF_D0_M)
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(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.rf1S_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.rf1S_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_rf1S.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())
print 'corr value ', corr_chi_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())
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)
probFit1S.setVal(tree.probFit1S)
probFit2S.setVal(tree.probFit2S)
probFit3S.setVal(tree.probFit3S)
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)
if selectchi1:
if (tree.chic_pdgId == 20443): dataSet.add(dataArgSet)
else:
dataSet.add(dataArgSet)
outfile = TFile(outfile_name, 'recreate')
dataSet.Write()
t_wsp = ws_file.Get("wspace")
B_M = t_wsp.var("B_M")
LOG_D0_IPCHI2_OWNPV = t_wsp.var("LOG_D0_IPCHI2_OWNPV")
D0_TAU = t_wsp.var("D0_TAU")
D0_M = t_wsp.var("D0_M")
Dst_M = t_wsp.var("Dst_M")
Dst_DTF_D0_CTAU = t_wsp.var("Dst_DTF_D0_CTAU")
Dst_DTF_D0_M = t_wsp.var("Dst_DTF_D0_M")
D0sPi_M = t_wsp.var("D0sPi_M")
B_ENDVERTEX_CHI2 = t_wsp.var("B_ENDVERTEX_CHI2")
DTF_D0sPi_M = t_wsp.var("DTF_D0sPi_M")
Mu_PT = t_wsp.var("Mu_PT")
runNumber = t_wsp.var("runNumber")
varset_comb = RooArgSet("varset_comb")
varset_comb.add(B_M)
varset_comb.add(D0_TAU)
varset_comb.add(LOG_D0_IPCHI2_OWNPV)
varset_comb.add(D0sPi_M)
varset_comb.add(D0_M)
varset_comb.add(Mu_PT)
varset_comb.add(B_ENDVERTEX_CHI2)
varset_comb.add(runNumber)
varset = RooArgSet("varset")
varset.add(D0_M)
varset.add(D0_TAU)
varset.add(LOG_D0_IPCHI2_OWNPV)
varset.add(DTF_D0sPi_M)
varset.add(Dst_DTF_D0_CTAU)
varset.add(runNumber)
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);
pdf_zj = RooHistPdf ("pdf_zj", "Z+jets pdf", vars_set, rh_zj, 0);
obsSetIn = dsIn.get()
dsIn.Print()
runPeriodCat = obsSetIn.find('runPeriod')
for period in runPeriods :
assert runPeriodCat.isValidIndex(period)
if len(runPeriods) < runPeriodCat.numTypes() :
from ROOT import RooCategory
runPeriodCatOut = RooCategory( runPeriodCat.GetName(), runPeriodCat.GetTitle() )
for catType in runPeriodCat :
if catType.getVal() in runPeriods : runPeriodCatOut.defineType( catType.GetName(), catType.getVal() )
from ROOT import RooArgSet
obsSetOut = RooArgSet(obsSetIn)
obsSetOut.remove(runPeriodCat)
obsSetOut.add(runPeriodCatOut)
else :
obsSetOut = obsSetIn
cuts = '||'.join( 'runPeriod==%d' % period for period in runPeriods )
from ROOT import RooDataSet, RooFit
print 'creating new data set for run periods %s' % runPeriods
print 'applying cuts "%s"' % cuts
dsOut = RooDataSet( dsIn.GetName(), dsIn.GetTitle(), obsSetOut, Import = dsIn, Cut = cuts, WeightVar = ( weightName, True ) )
dsOut.Print()
print 'writing data set to file "%s"' % filePathOut
fileOut = TFile.Open( filePathOut, 'RECREATE' )
fileOut.Add(dsOut)
fileOut.Write()
def signal(category):
interPar = True
n = len(genPoints)
cColor = color[category] if category in color else 4
nBtag = category.count('b')
isAH = False #relict from using Alberto's more complex script
if not os.path.exists(PLOTDIR + "MC_signal_" + YEAR):
os.makedirs(PLOTDIR + "MC_signal_" + YEAR)
#*******************************************************#
# #
# Variables and selections #
# #
#*******************************************************#
X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV")
j1_pt = RooRealVar("jpt_1", "jet1 pt", 0., 13000., "GeV")
jj_deltaEta = RooRealVar("jj_deltaEta_widejet", "", 0., 5.)
jbtag_WP_1 = RooRealVar("jbtag_WP_1", "", -1., 4.)
jbtag_WP_2 = RooRealVar("jbtag_WP_2", "", -1., 4.)
fatjetmass_1 = RooRealVar("fatjetmass_1", "", -1., 2500.)
fatjetmass_2 = RooRealVar("fatjetmass_2", "", -1., 2500.)
jid_1 = RooRealVar("jid_1", "j1 ID", -1., 8.)
jid_2 = RooRealVar("jid_2", "j2 ID", -1., 8.)
jnmuons_1 = RooRealVar("jnmuons_1", "j1 n_{#mu}", -1., 8.)
jnmuons_2 = RooRealVar("jnmuons_2", "j2 n_{#mu}", -1., 8.)
jnmuons_loose_1 = RooRealVar("jnmuons_loose_1", "jnmuons_loose_1", -1., 8.)
jnmuons_loose_2 = RooRealVar("jnmuons_loose_2", "jnmuons_loose_2", -1., 8.)
nmuons = RooRealVar("nmuons", "n_{#mu}", -1., 10.)
nelectrons = RooRealVar("nelectrons", "n_{e}", -1., 10.)
HLT_AK8PFJet500 = RooRealVar("HLT_AK8PFJet500", "", -1., 1.)
HLT_PFJet500 = RooRealVar("HLT_PFJet500", "", -1., 1.)
HLT_CaloJet500_NoJetID = RooRealVar("HLT_CaloJet500_NoJetID", "", -1., 1.)
HLT_PFHT900 = RooRealVar("HLT_PFHT900", "", -1., 1.)
HLT_AK8PFJet550 = RooRealVar("HLT_AK8PFJet550", "", -1., 1.)
HLT_PFJet550 = RooRealVar("HLT_PFJet550", "", -1., 1.)
HLT_CaloJet550_NoJetID = RooRealVar("HLT_CaloJet550_NoJetID", "", -1., 1.)
HLT_PFHT1050 = RooRealVar("HLT_PFHT1050", "", -1., 1.)
#HLT_DoublePFJets100_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets100_CaloBTagDeepCSV_p71" , "", -1., 1. )
#HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. )
#HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. )
#HLT_DoublePFJets200_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets200_CaloBTagDeepCSV_p71" , "", -1., 1. )
#HLT_DoublePFJets350_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets350_CaloBTagDeepCSV_p71" , "", -1., 1. )
#HLT_DoublePFJets40_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets40_CaloBTagDeepCSV_p71" , "", -1., 1. )
weight = RooRealVar("eventWeightLumi", "", -1.e9, 1.e9)
# Define the RooArgSet which will include all the variables defined before
# there is a maximum of 9 variables in the declaration, so the others need to be added with 'add'
variables = RooArgSet(X_mass)
variables.add(
RooArgSet(j1_pt, jj_deltaEta, jbtag_WP_1, jbtag_WP_2, fatjetmass_1,
fatjetmass_2, jnmuons_1, jnmuons_2, weight))
variables.add(
RooArgSet(nmuons, nelectrons, jid_1, jid_2, jnmuons_loose_1,
jnmuons_loose_2))
variables.add(
RooArgSet(HLT_AK8PFJet500, HLT_PFJet500, HLT_CaloJet500_NoJetID,
HLT_PFHT900, HLT_AK8PFJet550, HLT_PFJet550,
HLT_CaloJet550_NoJetID, HLT_PFHT1050))
#variables.add(RooArgSet(HLT_DoublePFJets100_CaloBTagDeepCSV_p71, HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets200_CaloBTagDeepCSV_p71, HLT_DoublePFJets350_CaloBTagDeepCSV_p71, HLT_DoublePFJets40_CaloBTagDeepCSV_p71))
X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax())
X_mass.setRange("X_integration_range", X_mass.getMin(), X_mass.getMax())
if VARBINS:
binsXmass = RooBinning(len(abins) - 1, abins)
X_mass.setBinning(binsXmass)
plot_binning = RooBinning(
int((X_mass.getMax() - X_mass.getMin()) / 100.), X_mass.getMin(),
X_mass.getMax())
else:
X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10))
binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100.),
X_mass.getMin(), X_mass.getMax())
plot_binning = binsXmass
X_mass.setBinning(plot_binning, "PLOT")
#X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/10))
#binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax())
#X_mass.setBinning(binsXmass, "PLOT")
massArg = RooArgSet(X_mass)
# Cuts
if BTAGGING == 'semimedium':
SRcut = aliasSM[category]
#SRcut = aliasSM[category+"_vetoAK8"]
else:
SRcut = alias[category].format(WP=working_points[BTAGGING])
#SRcut = alias[category+"_vetoAK8"].format(WP=working_points[BTAGGING])
if ADDSELECTION: SRcut += SELECTIONS[options.selection]
print " Cut:\t", SRcut
#*******************************************************#
# #
# Signal fits #
# #
#*******************************************************#
treeSign = {}
setSignal = {}
vmean = {}
vsigma = {}
valpha1 = {}
vslope1 = {}
valpha2 = {}
vslope2 = {}
smean = {}
ssigma = {}
salpha1 = {}
sslope1 = {}
salpha2 = {}
sslope2 = {}
sbrwig = {}
signal = {}
signalExt = {}
signalYield = {}
signalIntegral = {}
signalNorm = {}
signalXS = {}
frSignal = {}
frSignal1 = {}
frSignal2 = {}
frSignal3 = {}
# Signal shape uncertainties (common amongst all mass points)
xmean_jes = RooRealVar(
"CMS" + YEAR + "_sig_" + category + "_p1_scale_jes",
"Variation of the resonance position with the jet energy scale", 0.02,
-1., 1.) #0.001
smean_jes = RooRealVar(
"CMS" + YEAR + "_sig_" + category + "_p1_jes",
"Change of the resonance position with the jet energy scale", 0., -10,
10)
xsigma_jer = RooRealVar(
"CMS" + YEAR + "_sig_" + category + "_p2_scale_jer",
"Variation of the resonance width with the jet energy resolution",
0.10, -1., 1.)
ssigma_jer = RooRealVar(
"CMS" + YEAR + "_sig_" + category + "_p2_jer",
"Change of the resonance width with the jet energy resolution", 0.,
-10, 10)
xmean_jes.setConstant(True)
smean_jes.setConstant(True)
xsigma_jer.setConstant(True)
ssigma_jer.setConstant(True)
for m in massPoints:
signalMass = "%s_M%d" % (stype, m)
signalName = "ZpBB_{}_{}_M{}".format(YEAR, category, m)
sampleName = "ZpBB_M{}".format(m)
signalColor = sample[sampleName][
'linecolor'] if signalName in sample else 1
# define the signal PDF
vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m,
m * 0.96, m * 1.05)
smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)",
RooArgList(vmean[m], xmean_jes, smean_jes))
vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma",
m * 0.0233, m * 0.019, m * 0.025)
ssigma[m] = RooFormulaVar(
signalName + "_sigma", "@0*(1+@1*@2)",
RooArgList(vsigma[m], xsigma_jer, ssigma_jer))
valpha1[m] = RooRealVar(
signalName + "_valpha1", "Crystal Ball alpha 1", 0.2, 0.05, 0.28
) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right
salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0",
RooArgList(valpha1[m]))
#vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 10., 0.1, 20.) # slope of the power tail
vslope1[m] = RooRealVar(signalName + "_vslope1",
"Crystal Ball slope 1", 13., 10.,
20.) # slope of the power tail
sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0",
RooArgList(vslope1[m]))
valpha2[m] = RooRealVar(signalName + "_valpha2",
"Crystal Ball alpha 2", 1.)
valpha2[m].setConstant(True)
salpha2[m] = RooFormulaVar(signalName + "_alpha2", "@0",
RooArgList(valpha2[m]))
#vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", 6., 2.5, 15.) # slope of the higher power tail
## FIXME test FIXME
vslope2_estimation = -5.88111436852 + m * 0.00728809389442 + m * m * (
-1.65059568762e-06) + m * m * m * (1.25128996309e-10)
vslope2[m] = RooRealVar(signalName + "_vslope2",
"Crystal Ball slope 2", vslope2_estimation,
vslope2_estimation * 0.9, vslope2_estimation *
1.1) # slope of the higher power tail
## FIXME end FIXME
sslope2[m] = RooFormulaVar(
signalName + "_slope2", "@0",
RooArgList(vslope2[m])) # slope of the higher power tail
signal[m] = RooDoubleCrystalBall(signalName,
"m_{%s'} = %d GeV" % ('X', m), X_mass,
smean[m], ssigma[m], salpha1[m],
sslope1[m], salpha2[m], sslope2[m])
# extend the PDF with the yield to perform an extended likelihood fit
signalYield[m] = RooRealVar(signalName + "_yield", "signalYield", 50,
0., 1.e15)
signalNorm[m] = RooRealVar(signalName + "_norm", "signalNorm", 1., 0.,
1.e15)
signalXS[m] = RooRealVar(signalName + "_xs", "signalXS", 1., 0., 1.e15)
signalExt[m] = RooExtendPdf(signalName + "_ext", "extended p.d.f",
signal[m], signalYield[m])
# ---------- if there is no simulated signal, skip this mass point ----------
if m in genPoints:
if VERBOSE: print " - Mass point", m
# define the dataset for the signal applying the SR cuts
treeSign[m] = TChain("tree")
if YEAR == 'run2':
pd = sample[sampleName]['files']
if len(pd) > 3:
print "multiple files given than years for a single masspoint:", pd
sys.exit()
for ss in pd:
if not '2016' in ss and not '2017' in ss and not '2018' in ss:
print "unknown year given in:", ss
sys.exit()
else:
pd = [x for x in sample[sampleName]['files'] if YEAR in x]
if len(pd) > 1:
print "multiple files given for a single masspoint/year:", pd
sys.exit()
for ss in pd:
if options.unskimmed:
j = 0
while True:
if os.path.exists(NTUPLEDIR + ss + "/" + ss +
"_flatTuple_{}.root".format(j)):
treeSign[m].Add(NTUPLEDIR + ss + "/" + ss +
"_flatTuple_{}.root".format(j))
j += 1
else:
print "found {} files for sample:".format(j), ss
break
else:
if os.path.exists(NTUPLEDIR + ss + ".root"):
treeSign[m].Add(NTUPLEDIR + ss + ".root")
else:
print "found no file for sample:", ss
if treeSign[m].GetEntries() <= 0.:
if VERBOSE:
print " - 0 events available for mass", m, "skipping mass point..."
signalNorm[m].setVal(-1)
vmean[m].setConstant(True)
vsigma[m].setConstant(True)
salpha1[m].setConstant(True)
sslope1[m].setConstant(True)
salpha2[m].setConstant(True)
sslope2[m].setConstant(True)
signalNorm[m].setConstant(True)
signalXS[m].setConstant(True)
continue
#setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar("eventWeightLumi*BTagAK4Weight_deepJet"), RooFit.Import(treeSign[m]))
setSignal[m] = RooDataSet("setSignal_" + signalName, "setSignal",
variables, RooFit.Cut(SRcut),
RooFit.WeightVar(weight),
RooFit.Import(treeSign[m]))
if VERBOSE:
print " - Dataset with", setSignal[m].sumEntries(
), "events loaded"
# FIT
entries = setSignal[m].sumEntries()
if entries < 0. or entries != entries: entries = 0
signalYield[m].setVal(entries)
# Instead of eventWeightLumi
#signalYield[m].setVal(entries * LUMI / (300000 if YEAR=='run2' else 100000) )
if treeSign[m].GetEntries(SRcut) > 5:
if VERBOSE: print " - Running fit"
frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1),
RooFit.Extended(True),
RooFit.SumW2Error(True),
RooFit.PrintLevel(-1))
if VERBOSE:
print "********** Fit result [", m, "] **", category, "*" * 40, "\n", frSignal[
m].Print(), "\n", "*" * 80
if VERBOSE: frSignal[m].correlationMatrix().Print()
drawPlot(signalMass + "_" + category, stype + category, X_mass,
signal[m], setSignal[m], frSignal[m])
else:
print " WARNING: signal", stype, "and mass point", m, "in category", category, "has 0 entries or does not exist"
# Remove HVT cross sections
#xs = getCrossSection(stype, channel, m)
xs = 1.
signalXS[m].setVal(xs * 1000.)
signalIntegral[m] = signalExt[m].createIntegral(
massArg, RooFit.NormSet(massArg),
RooFit.Range("X_integration_range"))
boundaryFactor = signalIntegral[m].getVal()
if boundaryFactor < 0. or boundaryFactor != boundaryFactor:
boundaryFactor = 0
if VERBOSE:
print " - Fit normalization vs integral:", signalYield[
m].getVal(), "/", boundaryFactor, "events"
signalNorm[m].setVal(boundaryFactor * signalYield[m].getVal() /
signalXS[m].getVal()
) # here normalize to sigma(X) x Br = 1 [fb]
vmean[m].setConstant(True)
vsigma[m].setConstant(True)
valpha1[m].setConstant(True)
vslope1[m].setConstant(True)
valpha2[m].setConstant(True)
vslope2[m].setConstant(True)
signalNorm[m].setConstant(True)
signalXS[m].setConstant(True)
#*******************************************************#
# #
# Signal interpolation #
# #
#*******************************************************#
### FIXME FIXME just for a test FIXME FIXME
#print
#print
#print "slope2 fit results:"
#print
#y_vals = []
#for m in genPoints:
# y_vals.append(vslope2[m].getVal())
#print "m =", genPoints
#print "y =", y_vals
#sys.exit()
### FIXME FIXME test end FIXME FIXME
# ====== CONTROL PLOT ======
color_scheme = [
636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635,
634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633,
632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633
]
c_signal = TCanvas("c_signal", "c_signal", 800, 600)
c_signal.cd()
frame_signal = X_mass.frame()
for j, m in enumerate(genPoints):
if m in signalExt.keys():
#print "color:",(j%9)+1
#print "signalNorm[m].getVal() =", signalNorm[m].getVal()
#print "RooAbsReal.NumEvent =", RooAbsReal.NumEvent
signal[m].plotOn(
frame_signal, RooFit.LineColor(color_scheme[j]),
RooFit.Normalization(signalNorm[m].getVal(),
RooAbsReal.NumEvent),
RooFit.Range("X_reasonable_range"))
frame_signal.GetXaxis().SetRangeUser(0, 10000)
frame_signal.Draw()
drawCMS(-1, "Simulation Preliminary", year=YEAR)
#drawCMS(-1, "Work in Progress", year=YEAR, suppressCMS=True)
#drawCMS(-1, "", year=YEAR, suppressCMS=True)
drawAnalysis(category)
drawRegion(category)
c_signal.SaveAs(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" +
category + "_Signal.pdf")
c_signal.SaveAs(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" +
category + "_Signal.png")
#if VERBOSE: raw_input("Press Enter to continue...")
# ====== CONTROL PLOT ======
# Normalization
gnorm = TGraphErrors()
gnorm.SetTitle(";m_{X} (GeV);integral (GeV)")
gnorm.SetMarkerStyle(20)
gnorm.SetMarkerColor(1)
gnorm.SetMaximum(0)
inorm = TGraphErrors()
inorm.SetMarkerStyle(24)
fnorm = TF1("fnorm", "pol9", 700, 3000)
fnorm.SetLineColor(920)
fnorm.SetLineStyle(7)
fnorm.SetFillColor(2)
fnorm.SetLineColor(cColor)
# Mean
gmean = TGraphErrors()
gmean.SetTitle(";m_{X} (GeV);gaussian mean (GeV)")
gmean.SetMarkerStyle(20)
gmean.SetMarkerColor(cColor)
gmean.SetLineColor(cColor)
imean = TGraphErrors()
imean.SetMarkerStyle(24)
fmean = TF1("fmean", "pol1", 0, 10000)
fmean.SetLineColor(2)
fmean.SetFillColor(2)
# Width
gsigma = TGraphErrors()
gsigma.SetTitle(";m_{X} (GeV);gaussian width (GeV)")
gsigma.SetMarkerStyle(20)
gsigma.SetMarkerColor(cColor)
gsigma.SetLineColor(cColor)
isigma = TGraphErrors()
isigma.SetMarkerStyle(24)
fsigma = TF1("fsigma", "pol1", 0, 10000)
fsigma.SetLineColor(2)
fsigma.SetFillColor(2)
# Alpha1
galpha1 = TGraphErrors()
galpha1.SetTitle(";m_{X} (GeV);crystal ball lower alpha")
galpha1.SetMarkerStyle(20)
galpha1.SetMarkerColor(cColor)
galpha1.SetLineColor(cColor)
ialpha1 = TGraphErrors()
ialpha1.SetMarkerStyle(24)
falpha1 = TF1("falpha", "pol1", 0, 10000) #pol0
falpha1.SetLineColor(2)
falpha1.SetFillColor(2)
# Slope1
gslope1 = TGraphErrors()
gslope1.SetTitle(";m_{X} (GeV);exponential lower slope (1/Gev)")
gslope1.SetMarkerStyle(20)
gslope1.SetMarkerColor(cColor)
gslope1.SetLineColor(cColor)
islope1 = TGraphErrors()
islope1.SetMarkerStyle(24)
fslope1 = TF1("fslope", "pol1", 0, 10000) #pol0
fslope1.SetLineColor(2)
fslope1.SetFillColor(2)
# Alpha2
galpha2 = TGraphErrors()
galpha2.SetTitle(";m_{X} (GeV);crystal ball upper alpha")
galpha2.SetMarkerStyle(20)
galpha2.SetMarkerColor(cColor)
galpha2.SetLineColor(cColor)
ialpha2 = TGraphErrors()
ialpha2.SetMarkerStyle(24)
falpha2 = TF1("falpha", "pol1", 0, 10000) #pol0
falpha2.SetLineColor(2)
falpha2.SetFillColor(2)
# Slope2
gslope2 = TGraphErrors()
gslope2.SetTitle(";m_{X} (GeV);exponential upper slope (1/Gev)")
gslope2.SetMarkerStyle(20)
gslope2.SetMarkerColor(cColor)
gslope2.SetLineColor(cColor)
islope2 = TGraphErrors()
islope2.SetMarkerStyle(24)
fslope2 = TF1("fslope", "pol1", 0, 10000) #pol0
fslope2.SetLineColor(2)
fslope2.SetFillColor(2)
n = 0
for i, m in enumerate(genPoints):
if not m in signalNorm.keys(): continue
if signalNorm[m].getVal() < 1.e-6: continue
if gnorm.GetMaximum() < signalNorm[m].getVal():
gnorm.SetMaximum(signalNorm[m].getVal())
gnorm.SetPoint(n, m, signalNorm[m].getVal())
#gnorm.SetPointError(i, 0, signalNorm[m].getVal()/math.sqrt(treeSign[m].GetEntriesFast()))
gmean.SetPoint(n, m, vmean[m].getVal())
gmean.SetPointError(n, 0,
min(vmean[m].getError(), vmean[m].getVal() * 0.02))
gsigma.SetPoint(n, m, vsigma[m].getVal())
gsigma.SetPointError(
n, 0, min(vsigma[m].getError(), vsigma[m].getVal() * 0.05))
galpha1.SetPoint(n, m, valpha1[m].getVal())
galpha1.SetPointError(
n, 0, min(valpha1[m].getError(), valpha1[m].getVal() * 0.10))
gslope1.SetPoint(n, m, vslope1[m].getVal())
gslope1.SetPointError(
n, 0, min(vslope1[m].getError(), vslope1[m].getVal() * 0.10))
galpha2.SetPoint(n, m, salpha2[m].getVal())
galpha2.SetPointError(
n, 0, min(valpha2[m].getError(), valpha2[m].getVal() * 0.10))
gslope2.SetPoint(n, m, sslope2[m].getVal())
gslope2.SetPointError(
n, 0, min(vslope2[m].getError(), vslope2[m].getVal() * 0.10))
#tmpVar = w.var(var+"_"+signalString)
#print m, tmpVar.getVal(), tmpVar.getError()
n = n + 1
gmean.Fit(fmean, "Q0", "SAME")
gsigma.Fit(fsigma, "Q0", "SAME")
galpha1.Fit(falpha1, "Q0", "SAME")
gslope1.Fit(fslope1, "Q0", "SAME")
galpha2.Fit(falpha2, "Q0", "SAME")
gslope2.Fit(fslope2, "Q0", "SAME")
# gnorm.Fit(fnorm, "Q0", "", 700, 5000)
#for m in [5000, 5500]: gnorm.SetPoint(gnorm.GetN(), m, gnorm.Eval(m, 0, "S"))
#gnorm.Fit(fnorm, "Q", "SAME", 700, 6000)
gnorm.Fit(fnorm, "Q", "SAME", 1800, 8000) ## adjusted recently
for m in massPoints:
if vsigma[m].getVal() < 10.: vsigma[m].setVal(10.)
# Interpolation method
syield = gnorm.Eval(m)
spline = gnorm.Eval(m, 0, "S")
sfunct = fnorm.Eval(m)
#delta = min(abs(1.-spline/sfunct), abs(1.-spline/syield))
delta = abs(1. - spline / sfunct) if sfunct > 0 else 0
syield = spline
if interPar:
#jmean = gmean.Eval(m)
#jsigma = gsigma.Eval(m)
#jalpha1 = galpha1.Eval(m)
#jslope1 = gslope1.Eval(m)
#jalpha2 = galpha2.Eval(m)
#jslope2 = gslope2.Eval(m)
jmean = gmean.Eval(m, 0, "S")
jsigma = gsigma.Eval(m, 0, "S")
jalpha1 = galpha1.Eval(m, 0, "S")
jslope1 = gslope1.Eval(m, 0, "S")
jalpha2 = galpha2.Eval(m, 0, "S")
jslope2 = gslope2.Eval(m, 0, "S")
else:
jmean = fmean.GetParameter(
0) + fmean.GetParameter(1) * m + fmean.GetParameter(2) * m * m
jsigma = fsigma.GetParameter(0) + fsigma.GetParameter(
1) * m + fsigma.GetParameter(2) * m * m
jalpha1 = falpha1.GetParameter(0) + falpha1.GetParameter(
1) * m + falpha1.GetParameter(2) * m * m
jslope1 = fslope1.GetParameter(0) + fslope1.GetParameter(
1) * m + fslope1.GetParameter(2) * m * m
jalpha2 = falpha2.GetParameter(0) + falpha2.GetParameter(
1) * m + falpha2.GetParameter(2) * m * m
jslope2 = fslope2.GetParameter(0) + fslope2.GetParameter(
1) * m + fslope2.GetParameter(2) * m * m
inorm.SetPoint(inorm.GetN(), m, syield)
signalNorm[m].setVal(max(0., syield))
imean.SetPoint(imean.GetN(), m, jmean)
if jmean > 0: vmean[m].setVal(jmean)
isigma.SetPoint(isigma.GetN(), m, jsigma)
if jsigma > 0: vsigma[m].setVal(jsigma)
ialpha1.SetPoint(ialpha1.GetN(), m, jalpha1)
if not jalpha1 == 0: valpha1[m].setVal(jalpha1)
islope1.SetPoint(islope1.GetN(), m, jslope1)
if jslope1 > 0: vslope1[m].setVal(jslope1)
ialpha2.SetPoint(ialpha2.GetN(), m, jalpha2)
if not jalpha2 == 0: valpha2[m].setVal(jalpha2)
islope2.SetPoint(islope2.GetN(), m, jslope2)
if jslope2 > 0: vslope2[m].setVal(jslope2)
#### newly introduced, not yet sure if helpful:
vmean[m].removeError()
vsigma[m].removeError()
valpha1[m].removeError()
valpha2[m].removeError()
vslope1[m].removeError()
vslope2[m].removeError()
#signalNorm[m].setConstant(False) ## newly put here to ensure it's freely floating in the combine fit
#c1 = TCanvas("c1", "Crystal Ball", 1200, 1200) #if not isAH else 1200
#c1.Divide(2, 3)
c1 = TCanvas("c1", "Crystal Ball", 1800, 800)
c1.Divide(3, 2)
c1.cd(1)
gmean.SetMinimum(0.)
gmean.Draw("APL")
imean.Draw("P, SAME")
drawRegion(category)
drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME
c1.cd(2)
gsigma.SetMinimum(0.)
gsigma.Draw("APL")
isigma.Draw("P, SAME")
drawRegion(category)
drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME
c1.cd(3)
galpha1.Draw("APL")
ialpha1.Draw("P, SAME")
drawRegion(category)
drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME
galpha1.GetYaxis().SetRangeUser(0., 1.1) #adjusted upper limit from 5 to 2
c1.cd(4)
gslope1.Draw("APL")
islope1.Draw("P, SAME")
drawRegion(category)
drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME
gslope1.GetYaxis().SetRangeUser(0.,
150.) #adjusted upper limit from 125 to 60
if True: #isAH:
c1.cd(5)
galpha2.Draw("APL")
ialpha2.Draw("P, SAME")
drawRegion(category)
drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME
galpha2.GetYaxis().SetRangeUser(0., 2.)
c1.cd(6)
gslope2.Draw("APL")
islope2.Draw("P, SAME")
drawRegion(category)
drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME
gslope2.GetYaxis().SetRangeUser(0., 20.)
c1.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category +
"_SignalShape.pdf")
c1.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category +
"_SignalShape.png")
c2 = TCanvas("c2", "Signal Efficiency", 800, 600)
c2.cd(1)
gnorm.SetMarkerColor(cColor)
gnorm.SetMarkerStyle(20)
gnorm.SetLineColor(cColor)
gnorm.SetLineWidth(2)
gnorm.Draw("APL")
inorm.Draw("P, SAME")
gnorm.GetXaxis().SetRangeUser(genPoints[0] - 100, genPoints[-1] + 100)
gnorm.GetYaxis().SetRangeUser(0., gnorm.GetMaximum() * 1.25)
drawCMS(-1, "Simulation Preliminary", year=YEAR)
#drawCMS(-1, "Work in Progress", year=YEAR, suppressCMS=True)
#drawCMS(-1, "", year=YEAR, suppressCMS=True)
drawAnalysis(category)
drawRegion(category)
c2.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category +
"_SignalNorm.pdf")
c2.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category +
"_SignalNorm.png")
#*******************************************************#
# #
# Generate workspace #
# #
#*******************************************************#
# create workspace
w = RooWorkspace("Zprime_" + YEAR, "workspace")
for m in massPoints:
getattr(w, "import")(signal[m], RooFit.Rename(signal[m].GetName()))
getattr(w, "import")(signalNorm[m],
RooFit.Rename(signalNorm[m].GetName()))
getattr(w, "import")(signalXS[m], RooFit.Rename(signalXS[m].GetName()))
w.writeToFile(WORKDIR + "MC_signal_%s_%s.root" % (YEAR, category), True)
print "Workspace", WORKDIR + "MC_signal_%s_%s.root" % (
YEAR, category), "saved successfully"
def fitData(fulldata, ibin, n_bkg, w):
cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)' % (
q2binning[ibin], q2binning[ibin + 1])
fulldata_v2 = fulldata.reduce(
RooArgSet(tagged_mass, mumuMass, mumuMassE, randVar), cut)
## reduce to data-like statistics
nDataEntries = fulldata_v2.sumEntries()
nDesired = n_bin[ibin] / nDataEntries
cut = 'rand < %f' % nDesired
signaldata = fulldata_v2.reduce(
RooArgSet(tagged_mass, mumuMass, mumuMassE), cut)
n_realsignal = signaldata.sumEntries()
nrt_mc = _getFittedVar("nRT_%s" % ibin, w)
nwt_mc = _getFittedVar("nWT_%s" % ibin, w)
fraction = nrt_mc / (nrt_mc + nwt_mc)
### creating RT component
w.loadSnapshot("reference_fit_RT_%s" % ibin)
meanrt = w.var("mean^{RT%s}" % ibin)
sigmart = RooRealVar()
sigmart1 = RooRealVar()
sigmart2 = RooRealVar()
alphart1 = RooRealVar()
alphart2 = RooRealVar()
nrt1 = RooRealVar()
nrt2 = RooRealVar()
## double cb fast
if ibin < 5:
sigmart = w.var("#sigma_{CB}^{RT%s}" % ibin)
alphart1 = w.var("#alpha_{1}^{RT%s}" % ibin)
alphart2 = w.var("#alpha_{2}^{RT%s}" % ibin)
nrt1 = w.var("n_{1}^{RT%s}" % ibin)
nrt2 = w.var("n_{2}^{RT%s}" % ibin)
## double cb old
else:
sigmart1 = w.var("#sigma_{CBRT0}^{%s}" % ibin)
sigmart2 = w.var("#sigma_{CBRT1}^{%s}" % ibin)
alphart1 = w.var("#alpha_{RT0}^{%s}" % ibin)
alphart2 = w.var("#alpha_{RT1}^{%s}" % ibin)
nrt1 = w.var("n_{RT0}^{%s}" % ibin)
nrt2 = w.var("n_{RT1}^{%s}" % ibin)
pars_init_vals = {}
theRTgauss = w.pdf("doublecb_RT%s" % ibin)
if ibin < 5:
c_sigma_rt = _constrainVar(sigmart, 1, pars_init_vals)
else:
c_sigma_rt1 = _constrainVar(sigmart1, 1, pars_init_vals)
c_sigma_rt2 = _constrainVar(sigmart2, 1, pars_init_vals)
c_alpha_rt1 = _constrainVar(alphart1, 1, pars_init_vals)
c_alpha_rt2 = _constrainVar(alphart2, 1, pars_init_vals)
c_n_rt1 = _constrainVar(nrt1, 1, pars_init_vals)
c_n_rt2 = _constrainVar(nrt2, 1, pars_init_vals)
### creating WT component
w.loadSnapshot("reference_fit_WT_%s" % ibin)
meanwt = w.var("mean^{WT%s}" % ibin)
sigmawt = w.var("#sigma_{CB}^{WT%s}" % ibin)
alphawt1 = w.var("#alpha_{1}^{WT%s}" % ibin)
alphawt2 = w.var("#alpha_{2}^{WT%s}" % ibin)
nwt1 = w.var("n_{1}^{WT%s}" % ibin)
nwt2 = w.var("n_{2}^{WT%s}" % ibin)
theWTgauss = w.pdf("doublecb_%s" % ibin)
c_sigma_wt = _constrainVar(sigmawt, 1, pars_init_vals)
c_alpha_wt1 = _constrainVar(alphawt1, 1, pars_init_vals)
c_alpha_wt2 = _constrainVar(alphawt2, 1, pars_init_vals)
c_n_wt1 = _constrainVar(nwt1, 1, pars_init_vals)
c_n_wt2 = _constrainVar(nwt2, 1, pars_init_vals)
### creating constraints for the RT component
c_vars = RooArgSet()
if ibin < 5:
c_RTgauss = RooProdPdf(
"c_RTgauss", "c_RTgauss",
RooArgList(theRTgauss, c_alpha_rt1, c_n_rt1, c_sigma_rt,
c_alpha_rt2, c_n_rt2))
c_vars = RooArgSet(c_sigma_rt, c_alpha_rt1, c_alpha_rt2, c_n_rt1,
c_n_rt2)
else:
c_RTgauss = RooProdPdf(
"c_RTgauss", "c_RTgauss",
RooArgList(theRTgauss, c_alpha_rt1, c_n_rt1, c_sigma_rt1,
c_sigma_rt2, c_alpha_rt2, c_n_rt2))
c_vars = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_alpha_rt1, c_alpha_rt2,
c_n_rt1, c_n_rt2)
### creating constraints for the WT component
c_WTgauss = RooProdPdf(
"c_WTgauss", "c_WTgauss",
RooArgList(theWTgauss, c_alpha_wt1, c_n_wt1, c_sigma_wt, c_alpha_wt2,
c_n_wt2))
c_vars.add(c_sigma_wt)
c_vars.add(c_alpha_wt1)
c_vars.add(c_alpha_wt2)
c_vars.add(c_n_wt1)
c_vars.add(c_n_wt2)
frt = RooRealVar("F_{RT}", "frt", fraction.n, 0, 1)
signalFunction = RooAddPdf("sumgaus", "rt+wt",
RooArgList(c_RTgauss, c_WTgauss),
RooArgList(frt))
c_frt = RooGaussian("c_frt", "c_frt", frt,
ROOT.RooFit.RooConst(fraction.n),
ROOT.RooFit.RooConst(fraction.s))
### creating constraints for the difference between the two peaks
deltaPeaks = RooFormulaVar("deltaPeaks", "@0 - @1",
RooArgList(meanrt, meanwt))
c_deltaPeaks = RooGaussian(
"c_deltaPeaks",
"c_deltaPeaks",
deltaPeaks,
ROOT.RooFit.RooConst(deltaPeaks.getVal()),
ROOT.RooFit.RooConst(0.0005) ## value to be checked
)
c_signalFunction = RooProdPdf(
"c_signalFunction", "c_signalFunction",
RooArgList(signalFunction, c_frt, c_deltaPeaks))
c_vars.add(frt)
c_vars.add(deltaPeaks)
### now create background parametrization
slope = RooRealVar("slope", "slope", 0.5, -10, 10)
bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass)
pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10)
pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10)
bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass,
RooArgList(pol_c1, pol_c2))
nsig = RooRealVar("Yield", "signal frac", nrt_mc.n + nwt_mc.n, 0, 1000000)
nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000)
print nsig.getVal()
fitFunction = RooAddPdf("fitfunction", "fit function",
RooArgList(c_signalFunction, bkg_pol),
RooArgList(nsig, nbkg))
pars_to_tune = [
sigmawt, alphawt1, alphawt2, nwt1, nwt2, alphart1, alphart2, nrt1, nrt2
]
if ibin < 5:
pars_to_tune.append(sigmart)
else:
pars_to_tune.append(sigmart1)
pars_to_tune.append(sigmart2)
## add toy bkg
for itoy in range(args.ntoys):
data = deepcopy(signaldata)
toy_bkg = generateBkg(tagged_mass, ibin, n_bkg)
data.append(toy_bkg)
print 'toy number', itoy
for ipar in pars_to_tune:
ipar.setVal(pars_init_vals[ipar.GetName()])
# r = fitFunction.fitTo(data,
# RooFit.Extended(True),
# RooFit.Range("full"),
# ROOT.RooFit.Constrain(c_vars),
# # ROOT.RooFit.Minimizer("Minuit2","migrad"),
# ROOT.RooFit.Hesse(True),
# ROOT.RooFit.Strategy(2),
# ROOT.RooFit.Minos(False),
# )
# # print 'fit with Hesse strategy 2 done, now Minos'
r = fitFunction.fitTo(
data,
RooFit.Extended(True),
RooFit.Save(),
RooFit.Range("full"),
RooFit.Verbose(False),
ROOT.RooFit.Constrain(c_vars),
# ROOT.RooFit.Minimizer("Minuit2","migrad"),
# ROOT.RooFit.Hesse(True),
ROOT.RooFit.Strategy(2),
ROOT.RooFit.Minos(True),
)
# # r.Print()
# # r.correlationMatrix().Print()
fitStats['data%s_itoy%s' % (ibin, itoy)] = r.status()
covStats['data%s_itoy%s' % (ibin, itoy)] = r.covQual()
frame = tagged_mass.frame(RooFit.Range("full"))
data.plotOn(frame, RooFit.Binning(nbins), RooFit.MarkerSize(.7))
fitFunction.plotOn(frame, RooFit.NormRange("full"),
RooFit.Range("full"))
## evaluate sort of chi2 and save number of RT/WT events
observables = RooArgSet(tagged_mass)
flparams = fitFunction.getParameters(observables)
nparam = int(
flparams.selectByAttrib("Constant", ROOT.kFALSE).getSize())
pdfstring = "fitfunction_Norm[tagged_mass]_Range[full]_NormRange[full]"
chi2s['data%s_itoy%s' % (ibin, itoy)] = frame.chiSquare(
pdfstring, "h_fulldata", nparam)
frame.addObject(_writeChi2(chi2s['data%s_itoy%s' % (ibin, itoy)]))
## save plot only if 1 toy is run
if args.ntoys == 1:
drawPdfComponents(fitFunction,
frame,
ROOT.kAzure,
RooFit.NormRange("full"),
RooFit.Range("full"),
isData=True)
fitFunction.paramOn(frame, RooFit.Layout(0.62, 0.86, 0.89))
# parList = RooArgSet (nsig, nbkg, meanrt, meanwt, alphart1, alphart2, meanwt, sigmawt)
# if ibin < 5 :
# parList.add(sigmart)
# else:
# parList.add(sigmart1)
# parList.add(sigmart2)
# parList.add(alphawt1)
# parList.add(alphawt2)
# parList.add(nwt1)
# parList.add(nwt2)
# parList.add(frt)
# fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62,0.86,0.89))
frame.Draw()
niceFrame(frame, '')
frame.addObject(_writeFitStatus(r))
c1 = ROOT.TCanvas()
upperPad = ROOT.TPad('upperPad', 'upperPad', 0., 0.35, 1., 1.)
lowerPad = ROOT.TPad('lowerPad', 'lowerPad', 0., 0.0, 1., 0.345)
upperPad.SetBottomMargin(0.012)
lowerPad.SetTopMargin(0)
lowerPad.SetBottomMargin(0.2)
upperPad.Draw()
lowerPad.Draw()
upperPad.cd()
frame.Draw()
if not args.year == 'test':
writeCMS(frame, args.year,
[q2binning[ibin], q2binning[ibin + 1]], 1)
frame.Draw()
## add plot of pulls
lowerPad.cd()
hpull = frame.pullHist("h_fulldata", pdfstring)
frame2 = tagged_mass.frame(RooFit.Range("full"), RooFit.Title(''))
frame2.addPlotable(hpull, "P")
niceFrameLowerPad(frame2, 'pull')
frame2.Draw()
line = ROOT.TLine(5.0, 1, 5.6, 1)
line.SetLineColor(ROOT.kGreen + 3)
line.Draw()
for ilog in [True, False]:
upperPad.SetLogy(ilog)
c1.SaveAs(
'fit_results_mass_checkOnMC/toybkg/save_fit_data_%s_%s_nbkg%s_LMNR_Final%s_%s_update_pol2bkg.pdf'
% (ibin, args.year, n_bkg, '_logScale' * ilog, itoy))
out_f.cd()
# r.Write('results_data_%s_ntoy%s'%(ibin,itoy))
## compare nkbg fitted w/ original value
nbkgs['data%s_itoy%s' %
(ibin, itoy)] = (toy_bkg.sumEntries() -
nbkg.getVal()) / toy_bkg.sumEntries()
nsigs['data%s_itoy%s' %
(ibin, itoy)] = (n_realsignal - nsig.getVal()) / n_realsignal
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)
if not 'Optimize' in fitOpts or fitOpts['Optimize'] < 2 :
# unset cache-and-track
for par in pdfBuild['taggingParams'].parameters() : par.setAttribute( 'CacheAndTrack', False )
###########################################################################################################################################
## generate data ##
###################
## Read data to use protodata
from P2VV.Utilities.DataHandling import readData
proto_data = pdfBuild['data']
from ROOT import RooArgSet
conditionals = RooArgSet()
for c in pdf.ConditionalObservables():
r = conditionals.add(c._target_())
proto_data = proto_data.reduce(conditionals)
# read parameters from file
pdfConfig.readParametersFromFile( filePath = parameterFile )
pdfConfig.setParametersInPdf(pdf)
# Hack to set maximum value
pdf.setMaxVal(0.15)
# Wrong PV shape
from P2VV.Parameterizations.WrongPV import ShapeBuilder
from P2VV.RooFitWrappers import Component, Projection
wpv = ShapeBuilder(time, {'B' : BMass}, UseKeysPdf = True, Weights = 'B',
InputFile = "/bfys/raaij/p2vv/data/Bs2JpsiPhiPrescaled_2011.root")
wpv_signal = wpv.shape('B')
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 dijet(category):
channel = 'bb'
stype = channel
isSB = True # relict from using Alberto's more complex script
isData = not ISMC
nTupleDir = NTUPLEDIR
samples = data if isData else back
pd = []
for sample_name in samples:
if YEAR == 'run2':
pd += sample[sample_name]['files']
else:
pd += [x for x in sample[sample_name]['files'] if YEAR in x]
print "datasets:", pd
if not os.path.exists(PLOTDIR): os.makedirs(PLOTDIR)
if BIAS: print "Running in BIAS mode"
order = 0
RSS = {}
X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV")
weight = RooRealVar("MANtag_weight", "", -1.e9, 1.e9)
variables = RooArgSet(X_mass)
variables.add(RooArgSet(weight))
if VARBINS:
binsXmass = RooBinning(len(abins) - 1, abins)
X_mass.setBinning(RooBinning(len(abins_narrow) - 1, abins_narrow))
plot_binning = RooBinning(
int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(),
X_mass.getMax())
else:
X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10))
binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100),
X_mass.getMin(), X_mass.getMax())
plot_binning = binsXmass
baseCut = ""
print stype, "|", baseCut
print " - Reading from Tree"
treeBkg = TChain("tree")
for ss in pd:
if os.path.exists(nTupleDir + ss + "_" + BTAGGING + ".root"):
treeBkg.Add(nTupleDir + ss + "_" + BTAGGING + ".root")
else:
print "found no file for sample:", ss
setData = RooDataSet("setData", "Data (QCD+TTbar MC)", variables,
RooFit.Cut(baseCut), RooFit.WeightVar(weight),
RooFit.Import(treeBkg))
nevents = setData.sumEntries()
dataMin, dataMax = array('d', [0.]), array('d', [0.])
setData.getRange(X_mass, dataMin, dataMax)
xmin, xmax = dataMin[0], dataMax[0]
lastBin = X_mass.getMax()
if VARBINS:
for b in narrow_bins:
if b > xmax:
lastBin = b
break
print "Imported", (
"data" if isData else "MC"
), "RooDataSet with", nevents, "events between [%.1f, %.1f]" % (xmin, xmax)
#xmax = xmax+binsXmass.averageBinWidth() # start form next bin
# 1 parameter
print "fitting 1 parameter model"
p1_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p1_1", "p1", 7.0, 0.,
2000.)
modelBkg1 = RooGenericPdf("Bkg1", "Bkg. fit (2 par.)",
"1./pow(@0/13000, @1)", RooArgList(X_mass, p1_1))
normzBkg1 = RooRealVar(
modelBkg1.GetName() + "_norm", "Number of background events", nevents,
0., 5. * nevents) #range dependent of actual number of events!
modelExt1 = RooExtendPdf(modelBkg1.GetName() + "_ext",
modelBkg1.GetTitle(), modelBkg1, normzBkg1)
fitRes1 = modelExt1.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes1.Print()
RSS[1] = drawFit("Bkg1", category, X_mass, modelBkg1, setData, binsXmass,
[fitRes1], normzBkg1.getVal())
# 2 parameters
print "fitting 2 parameter model"
p2_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_1", "p1", 0., -100.,
1000.)
p2_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_2", "p2",
p1_1.getVal(), -100., 600.)
modelBkg2 = RooGenericPdf("Bkg2", "Bkg. fit (3 par.)",
"pow(1-@0/13000, @1) / pow(@0/13000, @2)",
RooArgList(X_mass, p2_1, p2_2))
normzBkg2 = RooRealVar(modelBkg2.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt2 = RooExtendPdf(modelBkg2.GetName() + "_ext",
modelBkg2.GetTitle(), modelBkg2, normzBkg2)
fitRes2 = modelExt2.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes2.Print()
RSS[2] = drawFit("Bkg2", category, X_mass, modelBkg2, setData, binsXmass,
[fitRes2], normzBkg2.getVal())
# 3 parameters
print "fitting 3 parameter model"
p3_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_1", "p1",
p2_1.getVal(), -2000., 2000.)
p3_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_2", "p2",
p2_2.getVal(), -400., 2000.)
p3_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_3", "p3", -2.5,
-500., 500.)
modelBkg3 = RooGenericPdf(
"Bkg3", "Bkg. fit (4 par.)",
"pow(1-@0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))",
RooArgList(X_mass, p3_1, p3_2, p3_3))
normzBkg3 = RooRealVar(modelBkg3.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt3 = RooExtendPdf(modelBkg3.GetName() + "_ext",
modelBkg3.GetTitle(), modelBkg3, normzBkg3)
fitRes3 = modelExt3.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes3.Print()
RSS[3] = drawFit("Bkg3", category, X_mass, modelBkg3, setData, binsXmass,
[fitRes3], normzBkg3.getVal())
# 4 parameters
print "fitting 4 parameter model"
p4_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_1", "p1",
p3_1.getVal(), -2000., 2000.)
p4_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_2", "p2",
p3_2.getVal(), -2000., 2000.)
p4_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_3", "p3",
p3_3.getVal(), -50., 50.)
p4_4 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_4", "p4", 0.1, -50.,
50.)
modelBkg4 = RooGenericPdf(
"Bkg4", "Bkg. fit (5 par.)",
"pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000)+@4*pow(log(@0/13000), 2))",
RooArgList(X_mass, p4_1, p4_2, p4_3, p4_4))
normzBkg4 = RooRealVar(modelBkg4.GetName() + "_norm",
"Number of background events", nevents, 0.,
5. * nevents)
modelExt4 = RooExtendPdf(modelBkg4.GetName() + "_ext",
modelBkg4.GetTitle(), modelBkg4, normzBkg4)
fitRes4 = modelExt4.fitTo(setData, RooFit.Extended(True), RooFit.Save(1),
RooFit.SumW2Error(not isData),
RooFit.Strategy(2), RooFit.Minimizer("Minuit2"),
RooFit.PrintLevel(1 if VERBOSE else -1))
fitRes4.Print()
RSS[4] = drawFit("Bkg4", category, X_mass, modelBkg4, setData, binsXmass,
[fitRes4], normzBkg4.getVal())
# Normalization parameters are should be set constant, but shape ones should not
# if BIAS:
# p1_1.setConstant(True)
# p2_1.setConstant(True)
# p2_2.setConstant(True)
# p3_1.setConstant(True)
# p3_2.setConstant(True)
# p3_3.setConstant(True)
# p4_1.setConstant(True)
# p4_2.setConstant(True)
# p4_3.setConstant(True)
# p4_4.setConstant(True)
normzBkg1.setConstant(True)
normzBkg2.setConstant(True)
normzBkg3.setConstant(True)
normzBkg4.setConstant(True)
#*******************************************************#
# #
# Fisher #
# #
#*******************************************************#
# Fisher test
with open(PLOTDIR + "/Fisher_" + category + ".tex", 'w') as fout:
fout.write(r"\begin{tabular}{c|c|c|c|c}")
fout.write("\n")
fout.write(r"function & $\chi^2$ & RSS & ndof & F-test \\")
fout.write("\n")
fout.write("\hline")
fout.write("\n")
CL_high = False
for o1 in range(1, 5):
o2 = min(o1 + 1, 5)
fout.write("%d par & %.2f & %.2f & %d & " %
(o1 + 1, RSS[o1]["chi2"], RSS[o1]["rss"],
RSS[o1]["nbins"] - RSS[o1]["npar"]))
if o2 > len(RSS):
fout.write(r"\\")
fout.write("\n")
continue #order==0 and
CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1 + 1., o2 + 1.,
RSS[o1]["nbins"])
fout.write("CL=%.3f " % (CL))
if CL > 0.10: # The function with less parameters is enough
if not CL_high:
order = o1
#fout.write( "%d par are sufficient " % (o1+1))
CL_high = True
else:
#fout.write( "%d par are needed " % (o2+1))
if not CL_high:
order = o2
fout.write(r"\\")
fout.write("\n")
fout.write("\hline")
fout.write("\n")
fout.write(r"\end{tabular}")
print "saved F-test table as", PLOTDIR + "/Fisher_" + category + ".tex"
#print "-"*25
#print "function & $\\chi^2$ & RSS & ndof & F-test & result \\\\"
#print "\\multicolumn{6}{c}{", "Zprime_to_bb", "} \\\\"
#print "\\hline"
#CL_high = False
#for o1 in range(1, 5):
# o2 = min(o1 + 1, 5)
# print "%d par & %.2f & %.2f & %d & " % (o1+1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"]-RSS[o1]["npar"]),
# if o2 > len(RSS):
# print "\\\\"
# continue #order==0 and
# CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1+1., o2+1., RSS[o1]["nbins"])
# print "%d par vs %d par CL=%f & " % (o1+1, o2+1, CL),
# if CL > 0.10: # The function with less parameters is enough
# if not CL_high:
# order = o1
# print "%d par are sufficient" % (o1+1),
# CL_high=True
# else:
# print "%d par are needed" % (o2+1),
# if not CL_high:
# order = o2
# print "\\\\"
#print "\\hline"
#print "-"*25
#print "@ Order is", order, "("+category+")"
#order = min(3, order)
#order = 2
if order == 1:
modelBkg = modelBkg1 #.Clone("Bkg")
modelAlt = modelBkg2 #.Clone("BkgAlt")
normzBkg = normzBkg1 #.Clone("Bkg_norm")
fitRes = fitRes1
elif order == 2:
modelBkg = modelBkg2 #.Clone("Bkg")
modelAlt = modelBkg3 #.Clone("BkgAlt")
normzBkg = normzBkg2 #.Clone("Bkg_norm")
fitRes = fitRes2
elif order == 3:
modelBkg = modelBkg3 #.Clone("Bkg")
modelAlt = modelBkg4 #.Clone("BkgAlt")
normzBkg = normzBkg3 #.Clone("Bkg_norm")
fitRes = fitRes3
elif order == 4:
modelBkg = modelBkg4 #.Clone("Bkg")
modelAlt = modelBkg3 #.Clone("BkgAlt")
normzBkg = normzBkg4 #.Clone("Bkg_norm")
fitRes = fitRes4
else:
print "Functions with", order + 1, "or more parameters are needed to fit the background"
exit()
modelBkg.SetName("Bkg_" + YEAR + "_" + category)
modelAlt.SetName("Alt_" + YEAR + "_" + category)
normzBkg.SetName("Bkg_" + YEAR + "_" + category + "_norm")
print "-" * 25
# Generate pseudo data
setToys = RooDataSet()
setToys.SetName("data_toys")
setToys.SetTitle("Data (toys)")
if not isData:
print " - Generating", nevents, "events for toy data"
setToys = modelBkg.generate(RooArgSet(X_mass), nevents)
#setToys = modelAlt.generate(RooArgSet(X_mass), nevents)
print "toy data generated"
if VERBOSE: raw_input("Press Enter to continue...")
#*******************************************************#
# #
# Plot #
# #
#*******************************************************#
print "starting to plot"
c = TCanvas("c_" + category, category, 800, 800)
c.Divide(1, 2)
setTopPad(c.GetPad(1), RATIO)
setBotPad(c.GetPad(2), RATIO)
c.cd(1)
frame = X_mass.frame()
setPadStyle(frame, 1.25, True)
if VARBINS: frame.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin)
signal = getSignal(
category, stype,
2000) #replacing Alberto's getSignal by own dummy function
graphData = setData.plotOn(frame, RooFit.Binning(plot_binning),
RooFit.Scaling(False), RooFit.Invisible())
modelBkg.plotOn(frame, RooFit.VisualizeError(fitRes, 1, False),
RooFit.LineColor(602), RooFit.FillColor(590),
RooFit.FillStyle(1001), RooFit.DrawOption("FL"),
RooFit.Name("1sigma"))
modelBkg.plotOn(frame, RooFit.LineColor(602), RooFit.FillColor(590),
RooFit.FillStyle(1001), RooFit.DrawOption("L"),
RooFit.Name(modelBkg.GetName()))
modelAlt.plotOn(frame, RooFit.LineStyle(7), RooFit.LineColor(613),
RooFit.FillColor(609), RooFit.FillStyle(1001),
RooFit.DrawOption("L"), RooFit.Name(modelAlt.GetName()))
if not isSB and signal[0] is not None: # FIXME remove /(2./3.)
signal[0].plotOn(
frame,
RooFit.Normalization(signal[1] * signal[2], RooAbsReal.NumEvent),
RooFit.LineStyle(3), RooFit.LineWidth(6), RooFit.LineColor(629),
RooFit.DrawOption("L"), RooFit.Name("Signal"))
graphData = setData.plotOn(
frame, RooFit.Binning(plot_binning), RooFit.Scaling(False),
RooFit.XErrorSize(0 if not VARBINS else 1),
RooFit.DataError(RooAbsData.Poisson if isData else RooAbsData.SumW2),
RooFit.DrawOption("PE0"), RooFit.Name(setData.GetName()))
fixData(graphData.getHist(), True, True, not isData)
pulls = frame.pullHist(setData.GetName(), modelBkg.GetName(), True)
chi = frame.chiSquare(setData.GetName(), modelBkg.GetName(), True)
#setToys.plotOn(frame, RooFit.DataError(RooAbsData.Poisson), RooFit.DrawOption("PE0"), RooFit.MarkerColor(2))
frame.GetYaxis().SetTitle("Events / ( 100 GeV )")
frame.GetYaxis().SetTitleOffset(1.05)
frame.Draw()
#print "frame drawn"
# Get Chi2
# chi2[1] = frame.chiSquare(modelBkg1.GetName(), setData.GetName())
# chi2[2] = frame.chiSquare(modelBkg2.GetName(), setData.GetName())
# chi2[3] = frame.chiSquare(modelBkg3.GetName(), setData.GetName())
# chi2[4] = frame.chiSquare(modelBkg4.GetName(), setData.GetName())
frame.SetMaximum(frame.GetMaximum() * 10)
frame.SetMinimum(max(frame.GetMinimum(), 1.e-1))
c.GetPad(1).SetLogy()
drawAnalysis(category)
drawRegion(category, True)
#drawCMS(LUMI, "Simulation Preliminary")
drawCMS(LUMI, "Work in Progress", suppressCMS=True)
leg = TLegend(0.575, 0.6, 0.95, 0.9)
leg.SetBorderSize(0)
leg.SetFillStyle(0) #1001
leg.SetFillColor(0)
leg.AddEntry(setData.GetName(),
setData.GetTitle() + " (%d events)" % nevents, "PEL")
leg.AddEntry(modelBkg.GetName(), modelBkg.GetTitle(),
"FL") #.SetTextColor(629)
leg.AddEntry(modelAlt.GetName(), modelAlt.GetTitle(), "L")
if not isSB and signal[0] is not None:
leg.AddEntry("Signal", signal[0].GetTitle(), "L")
leg.SetY1(0.9 - leg.GetNRows() * 0.05)
leg.Draw()
latex = TLatex()
latex.SetNDC()
latex.SetTextSize(0.04)
latex.SetTextFont(42)
if not isSB:
latex.DrawLatex(leg.GetX1() * 1.16,
leg.GetY1() - 0.04, "HVT model B (g_{V}=3)")
# latex.DrawLatex(0.67, leg.GetY1()-0.045, "#sigma_{X} = 1.0 pb")
c.cd(2)
frame_res = X_mass.frame()
setPadStyle(frame_res, 1.25)
frame_res.addPlotable(pulls, "P")
setBotStyle(frame_res, RATIO, False)
if VARBINS: frame_res.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin)
frame_res.GetYaxis().SetRangeUser(-5, 5)
frame_res.GetYaxis().SetTitle("pulls(#sigma)")
frame_res.GetYaxis().SetTitleOffset(0.3)
frame_res.Draw()
fixData(pulls, False, True, False)
drawChi2(RSS[order]["chi2"], RSS[order]["nbins"] - (order + 1), True)
line = drawLine(X_mass.getMin(), 0, lastBin, 0)
if VARBINS:
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf")
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png")
else:
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf")
c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png")
#*******************************************************#
# #
# Generate workspace #
# #
#*******************************************************#
if BIAS:
gSystem.Load("libHiggsAnalysisCombinedLimit.so")
from ROOT import RooMultiPdf
cat = RooCategory("pdf_index", "Index of Pdf which is active")
pdfs = RooArgList(modelBkg, modelAlt)
roomultipdf = RooMultiPdf("roomultipdf", "All Pdfs", cat, pdfs)
normulti = RooRealVar("roomultipdf_norm",
"Number of background events", nevents, 0., 1.e6)
normzBkg.setConstant(
False
) ## newly put here to ensure it's freely floating in the combine fit
# create workspace
w = RooWorkspace("Zprime_" + YEAR, "workspace")
# Dataset
if isData: getattr(w, "import")(setData, RooFit.Rename("data_obs"))
else: getattr(w, "import")(setToys, RooFit.Rename("data_obs"))
#getattr(w, "import")(setData, RooFit.Rename("data_obs"))
if BIAS:
getattr(w, "import")(cat, RooFit.Rename(cat.GetName()))
getattr(w, "import")(normulti, RooFit.Rename(normulti.GetName()))
getattr(w, "import")(roomultipdf, RooFit.Rename(roomultipdf.GetName()))
getattr(w, "import")(modelBkg, RooFit.Rename(modelBkg.GetName()))
getattr(w, "import")(modelAlt, RooFit.Rename(modelAlt.GetName()))
getattr(w, "import")(normzBkg, RooFit.Rename(normzBkg.GetName()))
w.writeToFile(WORKDIR + "%s_%s.root" % (DATA_TYPE + "_" + YEAR, category),
True)
print "Workspace", WORKDIR + "%s_%s.root" % (
DATA_TYPE + "_" + YEAR, category), "saved successfully"
if VERBOSE: raw_input("Press Enter to continue...")
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 get_fitted_normalisation_from_ROOT(channel, input_files, variable,
met_type, b_tag_bin):
results = {}
initial_values = {}
templates = {}
for variable_bin in variable_bins_ROOT[variable]:
histograms = get_histograms(channel,
input_files,
variable=variable,
met_type=met_type,
variable_bin=variable_bin,
b_tag_bin=b_tag_bin,
rebin=measurement_config.rebin)
# create signal histograms
h_eta_signal = histograms['TTJet'] + histograms['SingleTop']
N_ttbar_before_fit = histograms['TTJet'].Integral()
N_SingleTop_before_fit = histograms['SingleTop'].Integral()
N_vjets_before_fit = histograms['V+Jets'].Integral()
N_qcd_before_fit = histograms['QCD'].Integral()
N_signal_before_fit = N_ttbar_before_fit + N_SingleTop_before_fit
N_ttbar_error_before_fit = sum(histograms['TTJet'].errors())
N_SingleTop_error_before_fit = sum(histograms['SingleTop'].errors())
N_vjets_error_before_fit = sum(histograms['V+Jets'].errors())
N_QCD_error_before_fit = sum(histograms['QCD'].errors())
if (N_SingleTop_before_fit != 0):
TTJet_SingleTop_ratio = N_ttbar_before_fit / N_SingleTop_before_fit
else:
print 'Bin ', variable_bin, ': ttbar/singleTop ratio undefined for %s channel! Setting to 0.' % channel
TTJet_SingleTop_ratio = 0
leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 2.4)
# this has to move to dps.utils.Fitting.py
vars = RooArgList()
vars.add(leptonAbsEta)
vars_set = RooArgSet()
vars_set.add(leptonAbsEta)
n_event_obs = histograms['data'].Integral()
lowerBound = 0.
upperBound = n_event_obs + 10 * sqrt(n_event_obs)
n_init = n_event_obs / 2.
data = RooDataHist("data", "dataset with leptonAbsEta", vars,
histograms['data'])
rh_vj = RooDataHist("rh_vj", "vj", vars, histograms['V+Jets'])
rh_qcd = RooDataHist("rh_qcd", "qcd", vars, histograms['QCD'])
rh_signal = RooDataHist("rh_signal", "signal", vars, h_eta_signal)
pdf_vj = RooHistPdf("pdf_vj", "V+Jets pdf", vars_set, rh_vj, 0)
pdf_qcd = RooHistPdf("pdf_qcd", "QCD pdf ", vars_set, rh_qcd, 0)
pdf_signal = RooHistPdf("pdf_signal", "single top pdf", vars_set,
rh_signal, 0)
# RooRealVar(const char *name, const char *title, Double_t value, Double_t minValue, Double_t maxValue, const char *unit) :
nSignal = RooRealVar("nSignal", "number of single top + ttbar events",
N_signal_before_fit, lowerBound, upperBound,
"event")
nvj = RooRealVar("nvj", "number of V+Jets bgnd events",
N_vjets_before_fit, lowerBound, upperBound, "event")
nqcd = RooRealVar("nqcd", "number of QCD bgnd events",
N_QCD_error_before_fit, lowerBound, upperBound,
"event")
model = RooAddPdf("model", "sig+vj+qcd",
RooArgList(pdf_signal, pdf_vj, pdf_qcd),
RooArgList(nSignal, nvj, nqcd))
vj_constraint = RooGaussian("nvj_constraint", "nvj_constraint", nvj,
RooFit.RooConst(N_vjets_before_fit),
RooFit.RooConst(0.5 * N_vjets_before_fit))
qcd_constraint = RooGaussian("nqcd_constraint", "nqcd_constraint",
nqcd, RooFit.RooConst(N_qcd_before_fit),
RooFit.RooConst(2 * N_qcd_before_fit))
model_with_constraints = RooProdPdf(
"model_with_constraints", "model with gaussian constraints",
RooArgSet(model, vj_constraint, qcd_constraint), RooLinkedList())
model_with_constraints.fitTo(data, RooFit.Minimizer(
"Minuit2",
"Migrad")) #WARNING: number of cores changes the results!!!
# nll = model.createNLL(data, RooFit.NumCPU(2))
# RooMinuit(nll).migrad()
# frame1 = nSignal.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nSignal"))
# nll.plotOn(frame1, RooFit.ShiftToZero())
# frame2 = nvj.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nvj"))
# nll.plotOn(frame2, RooFit.ShiftToZero())
# frame3 = nqcd.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nqcd"))
# nll.plotOn(frame3, RooFit.ShiftToZero())
#
# pll_nSignal = nll.createProfile(nSignal)
# pll_nSignal.plotOn(frame1, RooFit.LineColor(2))
# frame1.SetMinimum(0)
# frame1.SetMaximum(3)
#
# pll_nvj = nll.createProfile(nvj)
# pll_nvj.plotOn(frame2, RooFit.LineColor(2))
# frame2.SetMinimum(0)
# frame2.SetMaximum(3)
#
# pll_nqcd = nll.createProfile(nqcd)
# pll_nqcd.plotOn(frame3, RooFit.LineColor(2))
# frame3.SetMinimum(0)
# frame3.SetMaximum(3)
# c = TCanvas("profilell","profilell",1200, 400)
# c.Divide(3)
# c.cd(1)
# frame1.Draw()
# c.cd(2)
# frame2.Draw()
# c.cd(3)
# frame3.Draw()
# c.SaveAs('profileLL.png')
# model.fitTo(data, RooFit.Minimizer("Minuit2", "Migrad"), RooFit.NumCPU(1))#WARNING: number of cores changes the results!!!
fit_results = {}
fit_results['signal'] = (nSignal.getVal(), nSignal.getError())
fit_results['QCD'] = ufloat(nqcd.getVal(), nqcd.getError())
fit_results['V+Jets'] = ufloat(nvj.getVal(), nvj.getError())
N_ttbar, N_SingleTop = decombine_result(fit_results['signal'],
TTJet_SingleTop_ratio)
fit_results['signal'] = ufloat(nSignal.getVal(), nSignal.getError())
fit_results['TTJet'] = ufloat(N_ttbar)
fit_results['SingleTop'] = ufloat(N_SingleTop)
if results == {}: # empty
for sample in fit_results.keys():
results[sample] = [fit_results[sample]]
else:
for sample in fit_results.keys():
results[sample].append(fit_results[sample])
return results, None, None
def signal(channel, stype):
if 'VBF' in channel:
stype = 'XZHVBF'
else:
stype = 'XZH'
# HVT model
if stype.startswith('X'):
signalType = 'HVT'
genPoints = [800, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500, 4000, 4500, 5000]
massPoints = [x for x in range(800, 5000+1, 100)]
interPar = True
else:
print "Signal type", stype, "not recognized"
return
n = len(genPoints)
category = channel
cColor = color[category] if category in color else 1
nElec = channel.count('e')
nMuon = channel.count('m')
nLept = nElec + nMuon
nBtag = channel.count('b')
if '0b' in channel:
nBtag = 0
X_name = "VH_mass"
if not os.path.exists(PLOTDIR+stype+category): os.makedirs(PLOTDIR+stype+category)
#*******************************************************#
# #
# Variables and selections #
# #
#*******************************************************#
X_mass = RooRealVar( "X_mass", "m_{ZH}", XBINMIN, XBINMAX, "GeV")
J_mass = RooRealVar( "H_mass", "jet mass", LOWMIN, HIGMAX, "GeV")
V_mass = RooRealVar( "V_mass", "V jet mass", -9., 1.e6, "GeV")
CSV1 = RooRealVar( "H_csv1", "", -999., 2. )
CSV2 = RooRealVar( "H_csv2", "", -999., 2. )
DeepCSV1= RooRealVar( "H_deepcsv1", "", -999., 2. )
DeepCSV2= RooRealVar( "H_deepcsv2", "", -999., 2. )
H_ntag = RooRealVar( "H_ntag", "", -9., 9. )
H_dbt = RooRealVar( "H_dbt", "", -2., 2. )
H_tau21 = RooRealVar( "H_tau21", "", -9., 2. )
H_eta = RooRealVar( "H_eta", "", -9., 9. )
H_tau21_ddt = RooRealVar( "H_ddt", "", -9., 2. )
MaxBTag = RooRealVar( "MaxBTag", "", -10., 2. )
H_chf = RooRealVar( "H_chf", "", -1., 2. )
MinDPhi = RooRealVar( "MinDPhi", "", -1., 99. )
DPhi = RooRealVar( "DPhi", "", -1., 99. )
DEta = RooRealVar( "DEta", "", -1., 99. )
Mu1_relIso = RooRealVar( "Mu1_relIso", "", -1., 99. )
Mu2_relIso = RooRealVar( "Mu2_relIso", "", -1., 99. )
nTaus = RooRealVar( "nTaus", "", -1., 99. )
Vpt = RooRealVar( "V.Pt()", "", -1., 1.e6 )
V_pt = RooRealVar( "V_pt", "", -1., 1.e6 )
H_pt = RooRealVar( "H_pt", "", -1., 1.e6 )
VH_deltaR=RooRealVar( "VH_deltaR", "", -1., 99. )
isZtoNN = RooRealVar( "isZtoNN", "", 0., 2. )
isZtoEE = RooRealVar( "isZtoEE", "", 0., 2. )
isZtoMM = RooRealVar( "isZtoMM", "", 0., 2. )
isHtobb = RooRealVar( "isHtobb", "", 0., 2. )
isVBF = RooRealVar( "isVBF", "", 0., 2. )
isMaxBTag_loose = RooRealVar( "isMaxBTag_loose", "", 0., 2. )
weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1.e9 )
Xmin = XBINMIN
Xmax = XBINMAX
# Define the RooArgSet which will include all the variables defined before
# there is a maximum of 9 variables in the declaration, so the others need to be added with 'add'
variables = RooArgSet(X_mass, J_mass, V_mass, CSV1, CSV2, H_ntag, H_dbt, H_tau21)
variables.add(RooArgSet(DEta, DPhi, MaxBTag, MinDPhi, nTaus, Vpt))
variables.add(RooArgSet(DeepCSV1, DeepCSV2,VH_deltaR, H_tau21_ddt))
variables.add(RooArgSet(isZtoNN, isZtoEE, isZtoMM, isHtobb, isMaxBTag_loose, weight))
variables.add(RooArgSet(isVBF, Mu1_relIso, Mu2_relIso, H_chf, H_pt, V_pt,H_eta))
#X_mass.setRange("X_extended_range", X_mass.getMin(), X_mass.getMax())
X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax())
X_mass.setRange("X_integration_range", Xmin, Xmax)
X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/100))
binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax())
X_mass.setBinning(binsXmass, "PLOT")
massArg = RooArgSet(X_mass)
# Cuts
SRcut = selection[category]+selection['SR']
print " Cut:\t", SRcut
#*******************************************************#
# #
# Signal fits #
# #
#*******************************************************#
treeSign = {}
setSignal = {}
vmean = {}
vsigma = {}
valpha1 = {}
vslope1 = {}
smean = {}
ssigma = {}
salpha1 = {}
sslope1 = {}
salpha2 = {}
sslope2 = {}
a1 = {}
a2 = {}
sbrwig = {}
signal = {}
signalExt = {}
signalYield = {}
signalIntegral = {}
signalNorm = {}
signalXS = {}
frSignal = {}
frSignal1 = {}
frSignal2 = {}
frSignal3 = {}
# Signal shape uncertainties (common amongst all mass points)
xmean_fit = RooRealVar("sig_p1_fit", "Variation of the resonance position with the fit uncertainty", 0.005, -1., 1.)
smean_fit = RooRealVar("CMSRunII_sig_p1_fit", "Change of the resonance position with the fit uncertainty", 0., -10, 10)
xmean_jes = RooRealVar("sig_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.010, -1., 1.) #0.001
smean_jes = RooRealVar("CMSRunII_sig_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10)
xmean_e = RooRealVar("sig_p1_scale_e", "Variation of the resonance position with the electron energy scale", 0.001, -1., 1.)
smean_e = RooRealVar("CMSRunII_sig_p1_scale_e", "Change of the resonance position with the electron energy scale", 0., -10, 10)
xmean_m = RooRealVar("sig_p1_scale_m", "Variation of the resonance position with the muon energy scale", 0.001, -1., 1.)
smean_m = RooRealVar("CMSRunII_sig_p1_scale_m", "Change of the resonance position with the muon energy scale", 0., -10, 10)
xsigma_fit = RooRealVar("sig_p2_fit", "Variation of the resonance width with the fit uncertainty", 0.02, -1., 1.)
ssigma_fit = RooRealVar("CMSRunII_sig_p2_fit", "Change of the resonance width with the fit uncertainty", 0., -10, 10)
xsigma_jes = RooRealVar("sig_p2_scale_jes", "Variation of the resonance width with the jet energy scale", 0.010, -1., 1.) #0.001
ssigma_jes = RooRealVar("CMSRunII_sig_p2_jes", "Change of the resonance width with the jet energy scale", 0., -10, 10)
xsigma_jer = RooRealVar("sig_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.020, -1., 1.)
ssigma_jer = RooRealVar("CMSRunII_sig_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10)
xsigma_e = RooRealVar("sig_p2_scale_e", "Variation of the resonance width with the electron energy scale", 0.001, -1., 1.)
ssigma_e = RooRealVar("CMSRunII_sig_p2_scale_e", "Change of the resonance width with the electron energy scale", 0., -10, 10)
xsigma_m = RooRealVar("sig_p2_scale_m", "Variation of the resonance width with the muon energy scale", 0.040, -1., 1.)
ssigma_m = RooRealVar("CMSRunII_sig_p2_scale_m", "Change of the resonance width with the muon energy scale", 0., -10, 10)
xalpha1_fit = RooRealVar("sig_p3_fit", "Variation of the resonance alpha with the fit uncertainty", 0.03, -1., 1.)
salpha1_fit = RooRealVar("CMSRunII_sig_p3_fit", "Change of the resonance alpha with the fit uncertainty", 0., -10, 10)
xslope1_fit = RooRealVar("sig_p4_fit", "Variation of the resonance slope with the fit uncertainty", 0.10, -1., 1.)
sslope1_fit = RooRealVar("CMSRunII_sig_p4_fit", "Change of the resonance slope with the fit uncertainty", 0., -10, 10)
xmean_fit.setConstant(True)
smean_fit.setConstant(True)
xmean_jes.setConstant(True)
smean_jes.setConstant(True)
xmean_e.setConstant(True)
smean_e.setConstant(True)
xmean_m.setConstant(True)
smean_m.setConstant(True)
xsigma_fit.setConstant(True)
ssigma_fit.setConstant(True)
xsigma_jes.setConstant(True)
ssigma_jes.setConstant(True)
xsigma_jer.setConstant(True)
ssigma_jer.setConstant(True)
xsigma_e.setConstant(True)
ssigma_e.setConstant(True)
xsigma_m.setConstant(True)
ssigma_m.setConstant(True)
xalpha1_fit.setConstant(True)
salpha1_fit.setConstant(True)
xslope1_fit.setConstant(True)
sslope1_fit.setConstant(True)
# the alpha method is now done.
for m in massPoints:
signalString = "M%d" % m
signalMass = "%s_M%d" % (stype, m)
signalName = "%s%s_M%d" % (stype, category, m)
signalColor = sample[signalMass]['linecolor'] if signalName in sample else 1
# define the signal PDF
vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m*0.5, m*1.25)
smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)", RooArgList(vmean[m], xmean_e, smean_e, xmean_m, smean_m, xmean_jes, smean_jes, xmean_fit, smean_fit))
vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m*0.035, m*0.01, m*0.4)
sigmaList = RooArgList(vsigma[m], xsigma_e, ssigma_e, xsigma_m, ssigma_m, xsigma_jes, ssigma_jes, xsigma_jer, ssigma_jer)
sigmaList.add(RooArgList(xsigma_fit, ssigma_fit))
ssigma[m] = RooFormulaVar(signalName + "_sigma", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)*(1+@9*@10)", sigmaList)
valpha1[m] = RooRealVar(signalName + "_valpha1", "Crystal Ball alpha", 1., 0., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right
salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0*(1+@1*@2)", RooArgList(valpha1[m], xalpha1_fit, salpha1_fit))
vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope", 10., 1., 60.) # slope of the power tail #10 1 60
sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0*(1+@1*@2)", RooArgList(vslope1[m], xslope1_fit, sslope1_fit))
salpha2[m] = RooRealVar(signalName + "_alpha2", "Crystal Ball alpha", 2, 1., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right
sslope2[m] = RooRealVar(signalName + "_slope2", "Crystal Ball slope", 10, 1.e-1, 115.) # slope of the power tail
#define polynomial
#a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", m, 0.5*m, 2*m)
a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", 0.001*m, 0.0005*m, 0.01*m)
a2[m] = RooRealVar(signalName + "_a2", "par 2 for polynomial", 0.05, -1.,1.)
#if channel=='nnbbVBF' or channel=='nn0bVBF':
# signal[m] = RooPolynomial(signalName,"m_{%s'} = %d GeV" % (stype[1], m) , X_mass, RooArgList(a1[m],a2[m]))
#else:
# signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel
signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel
# extend the PDF with the yield to perform an extended likelihood fit
signalYield[m] = RooRealVar(signalName+"_yield", "signalYield", 100, 0., 1.e6)
signalNorm[m] = RooRealVar(signalName+"_norm", "signalNorm", 1., 0., 1.e6)
signalXS[m] = RooRealVar(signalName+"_xs", "signalXS", 1., 0., 1.e6)
signalExt[m] = RooExtendPdf(signalName+"_ext", "extended p.d.f", signal[m], signalYield[m])
vslope1[m].setMax(50.)
vslope1[m].setVal(20.)
#valpha1[m].setVal(1.0)
#valpha1[m].setConstant(True)
if 'bb' in channel and 'VBF' not in channel:
if 'nn' in channel:
valpha1[m].setVal(0.5)
elif '0b' in channel and 'VBF' not in channel:
if 'nn' in channel:
if m==800:
valpha1[m].setVal(2.)
vsigma[m].setVal(m*0.04)
elif 'ee' in channel:
valpha1[m].setVal(0.8)
if m==800:
#valpha1[m].setVal(1.2)
valpha1[m].setVal(2.5)
vslope1[m].setVal(50.)
elif 'mm' in channel:
if m==800:
valpha1[m].setVal(2.)
vsigma[m].setVal(m*0.03)
else:
vmean[m].setVal(m*0.9)
vsigma[m].setVal(m*0.08)
elif 'bb' in channel and 'VBF' in channel:
if 'nn' in channel:
if m!=1800:
vmean[m].setVal(m*0.8)
vsigma[m].setVal(m*0.08)
valpha1[m].setMin(1.)
elif 'ee' in channel:
valpha1[m].setVal(0.7)
elif 'mm' in channel:
if m==800:
vslope1[m].setVal(50.)
valpha1[m].setVal(0.7)
elif '0b' in channel and 'VBF' in channel:
if 'nn' in channel:
valpha1[m].setVal(3.)
vmean[m].setVal(m*0.8)
vsigma[m].setVal(m*0.08)
valpha1[m].setMin(1.)
elif 'ee' in channel:
if m<2500:
valpha1[m].setVal(2.)
if m==800:
vsigma[m].setVal(m*0.05)
elif m==1000:
vsigma[m].setVal(m*0.03)
elif m>1000 and m<1800:
vsigma[m].setVal(m*0.04)
elif 'mm' in channel:
if m<2000:
valpha1[m].setVal(2.)
if m==1000 or m==1800:
vsigma[m].setVal(m*0.03)
elif m==1200 or m==1600:
vsigma[m].setVal(m*0.04)
#if m < 1000: vsigma[m].setVal(m*0.06)
# If it's not the proper channel, make it a gaussian
#if nLept==0 and 'VBF' in channel:
# valpha1[m].setVal(5)
# valpha1[m].setConstant(True)
# vslope1[m].setConstant(True)
# salpha2[m].setConstant(True)
# sslope2[m].setConstant(True)
# ---------- if there is no simulated signal, skip this mass point ----------
if m in genPoints:
if VERBOSE: print " - Mass point", m
# define the dataset for the signal applying the SR cuts
treeSign[m] = TChain("tree")
for j, ss in enumerate(sample[signalMass]['files']):
treeSign[m].Add(NTUPLEDIR + ss + ".root")
if treeSign[m].GetEntries() <= 0.:
if VERBOSE: print " - 0 events available for mass", m, "skipping mass point..."
signalNorm[m].setVal(-1)
vmean[m].setConstant(True)
vsigma[m].setConstant(True)
salpha1[m].setConstant(True)
sslope1[m].setConstant(True)
salpha2[m].setConstant(True)
sslope2[m].setConstant(True)
signalNorm[m].setConstant(True)
signalXS[m].setConstant(True)
continue
setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeSign[m]))
if VERBOSE: print " - Dataset with", setSignal[m].sumEntries(), "events loaded"
# FIT
signalYield[m].setVal(setSignal[m].sumEntries())
if treeSign[m].GetEntries(SRcut) > 5:
if VERBOSE: print " - Running fit"
frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1), RooFit.Extended(True), RooFit.SumW2Error(True), RooFit.PrintLevel(-1))
if VERBOSE: print "********** Fit result [", m, "] **", category, "*"*40, "\n", frSignal[m].Print(), "\n", "*"*80
if VERBOSE: frSignal[m].correlationMatrix().Print()
drawPlot(signalMass, stype+channel, X_mass, signal[m], setSignal[m], frSignal[m])
else:
print " WARNING: signal", stype, "and mass point", m, "in channel", channel, "has 0 entries or does not exist"
# Remove HVT cross section (which is the same for Zlep and Zinv)
if stype == "XZHVBF":
sample_name = 'Zprime_VBF_Zh_Zlephinc_narrow_M-%d' % m
else:
sample_name = 'ZprimeToZHToZlepHinc_narrow_M%d' % m
xs = xsection[sample_name]['xsec']
signalXS[m].setVal(xs * 1000.)
signalIntegral[m] = signalExt[m].createIntegral(massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range"))
boundaryFactor = signalIntegral[m].getVal()
if VERBOSE:
print " - Fit normalization vs integral:", signalYield[m].getVal(), "/", boundaryFactor, "events"
if channel=='nnbb' and m==5000:
signalNorm[m].setVal(2.5)
elif channel=='nn0b' and m==5000:
signalNorm[m].setVal(6.7)
else:
signalNorm[m].setVal( boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal()) # here normalize to sigma(X) x Br(X->VH) = 1 [fb]
a1[m].setConstant(True)
a2[m].setConstant(True)
vmean[m].setConstant(True)
vsigma[m].setConstant(True)
valpha1[m].setConstant(True)
vslope1[m].setConstant(True)
salpha2[m].setConstant(True)
sslope2[m].setConstant(True)
signalNorm[m].setConstant(True)
signalXS[m].setConstant(True)
#*******************************************************#
# #
# Signal interpolation #
# #
#*******************************************************#
# ====== CONTROL PLOT ======
c_signal = TCanvas("c_signal", "c_signal", 800, 600)
c_signal.cd()
frame_signal = X_mass.frame()
for m in genPoints[:-2]:
if m in signalExt.keys():
signal[m].plotOn(frame_signal, RooFit.LineColor(sample["%s_M%d" % (stype, m)]['linecolor']), RooFit.Normalization(signalNorm[m].getVal(), RooAbsReal.NumEvent), RooFit.Range("X_reasonable_range"))
frame_signal.GetXaxis().SetRangeUser(0, 6500)
frame_signal.Draw()
drawCMS(-1, YEAR, "Simulation")
drawAnalysis(channel)
drawRegion(channel)
c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.pdf")
c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.png")
#if VERBOSE: raw_input("Press Enter to continue...")
# ====== CONTROL PLOT ======
# Normalization
gnorm = TGraphErrors()
gnorm.SetTitle(";m_{X} (GeV);integral (GeV)")
gnorm.SetMarkerStyle(20)
gnorm.SetMarkerColor(1)
gnorm.SetMaximum(0)
inorm = TGraphErrors()
inorm.SetMarkerStyle(24)
fnorm = TF1("fnorm", "pol9", 800, 5000) #"pol5" if not channel=="XZHnnbb" else "pol6" #pol5*TMath::Floor(x-1800) + ([5]*x + [6]*x*x)*(1-TMath::Floor(x-1800))
fnorm.SetLineColor(920)
fnorm.SetLineStyle(7)
fnorm.SetFillColor(2)
fnorm.SetLineColor(cColor)
# Mean
gmean = TGraphErrors()
gmean.SetTitle(";m_{X} (GeV);gaussian mean (GeV)")
gmean.SetMarkerStyle(20)
gmean.SetMarkerColor(cColor)
gmean.SetLineColor(cColor)
imean = TGraphErrors()
imean.SetMarkerStyle(24)
fmean = TF1("fmean", "pol1", 0, 5000)
fmean.SetLineColor(2)
fmean.SetFillColor(2)
# Width
gsigma = TGraphErrors()
gsigma.SetTitle(";m_{X} (GeV);gaussian width (GeV)")
gsigma.SetMarkerStyle(20)
gsigma.SetMarkerColor(cColor)
gsigma.SetLineColor(cColor)
isigma = TGraphErrors()
isigma.SetMarkerStyle(24)
fsigma = TF1("fsigma", "pol1", 0, 5000)
fsigma.SetLineColor(2)
fsigma.SetFillColor(2)
# Alpha1
galpha1 = TGraphErrors()
galpha1.SetTitle(";m_{X} (GeV);crystal ball lower alpha")
galpha1.SetMarkerStyle(20)
galpha1.SetMarkerColor(cColor)
galpha1.SetLineColor(cColor)
ialpha1 = TGraphErrors()
ialpha1.SetMarkerStyle(24)
falpha1 = TF1("falpha", "pol0", 0, 5000)
falpha1.SetLineColor(2)
falpha1.SetFillColor(2)
# Slope1
gslope1 = TGraphErrors()
gslope1.SetTitle(";m_{X} (GeV);exponential lower slope (1/Gev)")
gslope1.SetMarkerStyle(20)
gslope1.SetMarkerColor(cColor)
gslope1.SetLineColor(cColor)
islope1 = TGraphErrors()
islope1.SetMarkerStyle(24)
fslope1 = TF1("fslope", "pol0", 0, 5000)
fslope1.SetLineColor(2)
fslope1.SetFillColor(2)
# Alpha2
galpha2 = TGraphErrors()
galpha2.SetTitle(";m_{X} (GeV);crystal ball upper alpha")
galpha2.SetMarkerStyle(20)
galpha2.SetMarkerColor(cColor)
galpha2.SetLineColor(cColor)
ialpha2 = TGraphErrors()
ialpha2.SetMarkerStyle(24)
falpha2 = TF1("falpha", "pol0", 0, 5000)
falpha2.SetLineColor(2)
falpha2.SetFillColor(2)
# Slope2
gslope2 = TGraphErrors()
gslope2.SetTitle(";m_{X} (GeV);exponential upper slope (1/Gev)")
gslope2.SetMarkerStyle(20)
gslope2.SetMarkerColor(cColor)
gslope2.SetLineColor(cColor)
islope2 = TGraphErrors()
islope2.SetMarkerStyle(24)
fslope2 = TF1("fslope", "pol0", 0, 5000)
fslope2.SetLineColor(2)
fslope2.SetFillColor(2)
n = 0
for i, m in enumerate(genPoints):
if not m in signalNorm.keys(): continue
if signalNorm[m].getVal() < 1.e-6: continue
signalString = "M%d" % m
signalName = "%s_M%d" % (stype, m)
if gnorm.GetMaximum() < signalNorm[m].getVal(): gnorm.SetMaximum(signalNorm[m].getVal())
gnorm.SetPoint(n, m, signalNorm[m].getVal())
gmean.SetPoint(n, m, vmean[m].getVal())
gmean.SetPointError(n, 0, min(vmean[m].getError(), vmean[m].getVal()*0.02))
gsigma.SetPoint(n, m, vsigma[m].getVal())
gsigma.SetPointError(n, 0, min(vsigma[m].getError(), vsigma[m].getVal()*0.05))
galpha1.SetPoint(n, m, valpha1[m].getVal())
galpha1.SetPointError(n, 0, min(valpha1[m].getError(), valpha1[m].getVal()*0.10))
gslope1.SetPoint(n, m, vslope1[m].getVal())
gslope1.SetPointError(n, 0, min(vslope1[m].getError(), vslope1[m].getVal()*0.10))
galpha2.SetPoint(n, m, salpha2[m].getVal())
galpha2.SetPointError(n, 0, min(salpha2[m].getError(), salpha2[m].getVal()*0.10))
gslope2.SetPoint(n, m, sslope2[m].getVal())
gslope2.SetPointError(n, 0, min(sslope2[m].getError(), sslope2[m].getVal()*0.10))
n = n + 1
print "fit on gmean:"
gmean.Fit(fmean, "Q0", "SAME")
print "fit on gsigma:"
gsigma.Fit(fsigma, "Q0", "SAME")
print "fit on galpha:"
galpha1.Fit(falpha1, "Q0", "SAME")
print "fit on gslope:"
gslope1.Fit(fslope1, "Q0", "SAME")
galpha2.Fit(falpha2, "Q0", "SAME")
gslope2.Fit(fslope2, "Q0", "SAME")
#for m in [5000, 5500]: gnorm.SetPoint(gnorm.GetN(), m, gnorm.Eval(m, 0, "S"))
gnorm.Fit(fnorm, "Q", "SAME", 700, 5000)
for m in massPoints:
signalName = "%s_M%d" % (stype, m)
if vsigma[m].getVal() < 10.: vsigma[m].setVal(10.)
# Interpolation method
syield = gnorm.Eval(m)
spline = gnorm.Eval(m, 0, "S")
sfunct = fnorm.Eval(m)
#delta = min(abs(1.-spline/sfunct), abs(1.-spline/syield))
delta = abs(1.-spline/sfunct) if sfunct > 0 else 0
syield = spline
if interPar:
jmean = gmean.Eval(m)
jsigma = gsigma.Eval(m)
jalpha1 = galpha1.Eval(m)
jslope1 = gslope1.Eval(m)
else:
jmean = fmean.GetParameter(0) + fmean.GetParameter(1)*m + fmean.GetParameter(2)*m*m
jsigma = fsigma.GetParameter(0) + fsigma.GetParameter(1)*m + fsigma.GetParameter(2)*m*m
jalpha1 = falpha1.GetParameter(0) + falpha1.GetParameter(1)*m + falpha1.GetParameter(2)*m*m
jslope1 = fslope1.GetParameter(0) + fslope1.GetParameter(1)*m + fslope1.GetParameter(2)*m*m
inorm.SetPoint(inorm.GetN(), m, syield)
signalNorm[m].setVal(syield)
imean.SetPoint(imean.GetN(), m, jmean)
if jmean > 0: vmean[m].setVal(jmean)
isigma.SetPoint(isigma.GetN(), m, jsigma)
if jsigma > 0: vsigma[m].setVal(jsigma)
ialpha1.SetPoint(ialpha1.GetN(), m, jalpha1)
if not jalpha1==0: valpha1[m].setVal(jalpha1)
islope1.SetPoint(islope1.GetN(), m, jslope1)
if jslope1 > 0: vslope1[m].setVal(jslope1)
c1 = TCanvas("c1", "Crystal Ball", 1200, 800)
c1.Divide(2, 2)
c1.cd(1)
gmean.SetMinimum(0.)
gmean.Draw("APL")
imean.Draw("P, SAME")
drawRegion(channel)
c1.cd(2)
gsigma.SetMinimum(0.)
gsigma.Draw("APL")
isigma.Draw("P, SAME")
drawRegion(channel)
c1.cd(3)
galpha1.Draw("APL")
ialpha1.Draw("P, SAME")
drawRegion(channel)
galpha1.GetYaxis().SetRangeUser(0., 5.)
c1.cd(4)
gslope1.Draw("APL")
islope1.Draw("P, SAME")
drawRegion(channel)
gslope1.GetYaxis().SetRangeUser(0., 125.)
if False:
c1.cd(5)
galpha2.Draw("APL")
ialpha2.Draw("P, SAME")
drawRegion(channel)
c1.cd(6)
gslope2.Draw("APL")
islope2.Draw("P, SAME")
drawRegion(channel)
gslope2.GetYaxis().SetRangeUser(0., 10.)
c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.pdf")
c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.png")
c2 = TCanvas("c2", "Signal Efficiency", 800, 600)
c2.cd(1)
gnorm.SetMarkerColor(cColor)
gnorm.SetMarkerStyle(20)
gnorm.SetLineColor(cColor)
gnorm.SetLineWidth(2)
gnorm.Draw("APL")
inorm.Draw("P, SAME")
gnorm.GetXaxis().SetRangeUser(genPoints[0]-100, genPoints[-1]+100)
gnorm.GetYaxis().SetRangeUser(0., gnorm.GetMaximum()*1.25)
drawCMS(-1,YEAR , "Simulation")
drawAnalysis(channel)
drawRegion(channel)
c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.pdf")
c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.png")
#*******************************************************#
# #
# Generate workspace #
# #
#*******************************************************#
# create workspace
w = RooWorkspace("ZH_RunII", "workspace")
for m in massPoints:
getattr(w, "import")(signal[m], RooFit.Rename(signal[m].GetName()))
getattr(w, "import")(signalNorm[m], RooFit.Rename(signalNorm[m].GetName()))
getattr(w, "import")(signalXS[m], RooFit.Rename(signalXS[m].GetName()))
w.writeToFile("%s%s.root" % (WORKDIR, stype+channel), True)
print "Workspace", "%s%s.root" % (WORKDIR, stype+channel), "saved successfully"
sys.exit()
def bookHistos():
global argSet
argSet = RooArgSet()
argSet.add(invm1S)
argSet.add(invm2S)
argSet.add(invm3S)
argSet.add(jpsipt)
argSet.add(jpsieta)
argSet.add(jpsimass)
argSet.add(gammapt)
argSet.add(deltaRJpsig)
argSet.add(deltaRChiJpsi)
argSet.add(ctpv)
argSet.add(ctpverr)
argSet.add(ctpvsig)
argSet.add(ctbs)
argSet.add(ctbserr)
argSet.add(ctbssig)
argSet.add(Rconv)
argSet.add(jpsiVprob)
argSet.add(Y1Smass_nSigma)
argSet.add(Y2Smass_nSigma)
argSet.add(Y3Smass_nSigma)
argSet.add(jpsipx)
argSet.add(jpsipy)
argSet.add(jpsipz)
argSet.add(gammapx)
argSet.add(gammapy)
argSet.add(gammapz)
argSet.add(gammaeta)
argSet.add(vertexChi2ProbGamma)
argSet.add(Q)
argSet.add(ndofConv)
argSet.add(chi2Conv)
argSet.add(Pi0Mass)
argSet.add(vtxdz)
argSet.add(vtxerrdz)
argSet.add(vtxNsigmadz)
argSet.add(UpsIndex)
argSet.add(GammaIndex)
global rds
rds = RooDataSet("d","d",argSet,"weight")
global hlist
hlist = []
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
KKBinsArray = array( 'd', KKMassBins )
from ROOT import RooBinning
KKBinning = RooBinning( len(KKMassBins) - 1, KKBinsArray, 'KKMassBinning' )
obsSet.find('mdau2').setBinning( KKBinning, 'KKMassBinning' )
if removeVars :
def alpha(channel):
nElec = channel.count('e')
nMuon = channel.count('m')
nLept = nElec + nMuon
nBtag = channel.count('b')
# Channel-dependent settings
# Background function. Semi-working options are: EXP, EXP2, EXPN, EXPTAIL
if nLept == 0:
treeName = 'SR'
signName = 'XZh'
colorVjet = sample['DYJetsToNuNu']['linecolor']
triName = "HLT_PFMET"
leptCut = "0==0"
topVeto = selection["TopVetocut"]
massVar = "X_cmass"
binFact = 1
#fitFunc = "EXP"
#fitFunc = "EXP2"
#fitFunc = "EXPN"
#fitFunc = "EXPTAIL"
fitFunc = "EXPN" if nBtag < 2 else "EXP"
fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP"
fitFuncVV = "EXPGAUS"
fitFuncTop = "GAUS2"
elif nLept == 1:
treeName = 'WCR'
signName = 'XWh'
colorVjet = sample['WJetsToLNu']['linecolor']
triName = "HLT_Ele" if nElec > 0 else "HLT_Mu"
leptCut = "isWtoEN" if nElec > 0 else "isWtoMN"
topVeto = selection["TopVetocut"]
massVar = "X_mass"
binFact = 2
if nElec > 0:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL"
else:
fitFunc = "EXPTAIL" if nBtag < 2 else "EXP"
fitAltFunc = "EXPN" if nBtag < 2 else "EXPTAIL"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP"
fitFuncVV = "EXPGAUS"
fitFuncTop = "GAUS3" if nBtag < 2 else "GAUS2"
else:
treeName = 'XZh'
signName = 'XZh'
colorVjet = sample['DYJetsToLL']['linecolor']
triName = "HLT_Ele" if nElec > 0 else "HLT_Mu"
leptCut = "isZtoEE" if nElec > 0 else "isZtoMM"
topVeto = "0==0"
massVar = "X_mass"
binFact = 5
if nElec > 0:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "POW" if nBtag < 2 else "POW"
else:
fitFunc = "EXP" if nBtag < 2 else "EXP"
fitAltFunc = "POW" if nBtag < 2 else "POW"
fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP"
fitFuncVV = "EXPGAUS2"
fitFuncTop = "GAUS"
btagCut = selection["2Btag"] if nBtag == 2 else selection["1Btag"]
print "--- Channel", channel, "---"
print " number of electrons:", nElec, " muons:", nMuon, " b-tags:", nBtag
print " read tree:", treeName, "and trigger:", triName
if ALTERNATIVE: print " using ALTERNATIVE fit functions"
print "-"*11*2
# Silent RooFit
RooMsgService.instance().setGlobalKillBelow(RooFit.FATAL)
#*******************************************************#
# #
# Variables and selections #
# #
#*******************************************************#
# Define all the variables from the trees that will be used in the cuts and fits
# this steps actually perform a "projection" of the entire tree on the variables in thei ranges, so be careful once setting the limits
X_mass = RooRealVar( massVar, "m_{X}" if nLept > 0 else "m_{T}^{X}", XBINMIN, XBINMAX, "GeV")
J_mass = RooRealVar( "fatjet1_prunedMassCorr", "corrected pruned mass", HBINMIN, HBINMAX, "GeV")
CSV1 = RooRealVar( "fatjet1_CSVR1", "", -1.e99, 1.e4 )
CSV2 = RooRealVar( "fatjet1_CSVR2", "", -1.e99, 1.e4 )
nBtag = RooRealVar( "fatjet1_nBtag", "", 0., 4 )
CSVTop = RooRealVar( "bjet1_CSVR", "", -1.e99, 1.e4 )
isZtoEE = RooRealVar("isZtoEE", "", 0., 2 )
isZtoMM = RooRealVar("isZtoMM", "", 0., 2 )
isWtoEN = RooRealVar("isWtoEN", "", 0., 2 )
isWtoMN = RooRealVar("isWtoMN", "", 0., 2 )
weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1. )
# Define the RooArgSet which will include all the variables defined before
# there is a maximum of 9 variables in the declaration, so the others need to be added with 'add'
variables = RooArgSet(X_mass, J_mass, CSV1, CSV2, nBtag, CSVTop)
variables.add(RooArgSet(isZtoEE, isZtoMM, isWtoEN, isWtoMN, weight))
# Define the ranges in fatJetMass - these will be used to define SB and SR
J_mass.setRange("LSBrange", LOWMIN, LOWMAX)
J_mass.setRange("HSBrange", HIGMIN, HIGMAX)
J_mass.setRange("VRrange", LOWMAX, SIGMIN)
J_mass.setRange("SRrange", SIGMIN, SIGMAX)
J_mass.setBins(54)
# Define the selection for the various categories (base + SR / LSBcut / HSBcut )
baseCut = leptCut + " && " + btagCut + "&&" + topVeto
massCut = massVar + ">%d" % XBINMIN
baseCut += " && " + massCut
# Cuts
SRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), SIGMIN, J_mass.GetName(), SIGMAX)
LSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX)
HSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX)
SBcut = baseCut + " && ((%s>%d && %s<%d) || (%s>%d && %s<%d))" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX, J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX)
VRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMAX, J_mass.GetName(), SIGMIN)
# Binning
binsJmass = RooBinning(HBINMIN, HBINMAX)
binsJmass.addUniform(HBINS, HBINMIN, HBINMAX)
binsXmass = RooBinning(XBINMIN, XBINMAX)
binsXmass.addUniform(binFact*XBINS, XBINMIN, XBINMAX)
#*******************************************************#
# #
# Input files #
# #
#*******************************************************#
# Import the files using TChains (separately for the bkg "classes" that we want to describe: here DY and VV+ST+TT)
treeData = TChain(treeName)
treeMC = TChain(treeName)
treeVjet = TChain(treeName)
treeVV = TChain(treeName)
treeTop = TChain(treeName)
# treeSign = {}
# nevtSign = {}
# Read data
pd = getPrimaryDataset(triName)
if len(pd)==0: raw_input("Warning: Primary Dataset not recognized, continue?")
for i, s in enumerate(pd): treeData.Add(NTUPLEDIR + s + ".root")
# Read V+jets backgrounds
for i, s in enumerate(["WJetsToLNu_HT", "DYJetsToNuNu_HT", "DYJetsToLL_HT"]):
for j, ss in enumerate(sample[s]['files']): treeVjet.Add(NTUPLEDIR + ss + ".root")
# Read VV backgrounds
for i, s in enumerate(["VV"]):
for j, ss in enumerate(sample[s]['files']): treeVV.Add(NTUPLEDIR + ss + ".root")
# Read Top backgrounds
for i, s in enumerate(["ST", "TTbar"]):
for j, ss in enumerate(sample[s]['files']): treeTop.Add(NTUPLEDIR + ss + ".root")
# Sum all background MC
treeMC.Add(treeVjet)
treeMC.Add(treeVV)
treeMC.Add(treeTop)
# create a dataset to host data in sideband (using this dataset we are automatically blind in the SR!)
setDataSB = RooDataSet("setDataSB", "setDataSB", variables, RooFit.Cut(SBcut), RooFit.WeightVar(weight), RooFit.Import(treeData))
setDataLSB = RooDataSet("setDataLSB", "setDataLSB", variables, RooFit.Import(setDataSB), RooFit.Cut(LSBcut), RooFit.WeightVar(weight))
setDataHSB = RooDataSet("setDataHSB", "setDataHSB", variables, RooFit.Import(setDataSB), RooFit.Cut(HSBcut), RooFit.WeightVar(weight))
# Observed data (WARNING, BLIND!)
setDataSR = RooDataSet("setDataSR", "setDataSR", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeData))
setDataVR = RooDataSet("setDataVR", "setDataVR", variables, RooFit.Cut(VRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) # Observed in the VV mass, just for plotting purposes
# same for the bkg datasets from MC, where we just apply the base selections (not blind)
setVjet = RooDataSet("setVjet", "setVjet", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVjet))
setVjetSB = RooDataSet("setVjetSB", "setVjetSB", variables, RooFit.Import(setVjet), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
setVjetSR = RooDataSet("setVjetSR", "setVjetSR", variables, RooFit.Import(setVjet), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
setVV = RooDataSet("setVV", "setVV", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVV))
setVVSB = RooDataSet("setVVSB", "setVVSB", variables, RooFit.Import(setVV), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
setVVSR = RooDataSet("setVVSR", "setVVSR", variables, RooFit.Import(setVV), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
setTop = RooDataSet("setTop", "setTop", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeTop))
setTopSB = RooDataSet("setTopSB", "setTopSB", variables, RooFit.Import(setTop), RooFit.Cut(SBcut), RooFit.WeightVar(weight))
setTopSR = RooDataSet("setTopSR", "setTopSR", variables, RooFit.Import(setTop), RooFit.Cut(SRcut), RooFit.WeightVar(weight))
print " Data events SB: %.2f" % setDataSB.sumEntries()
print " V+jets entries: %.2f" % setVjet.sumEntries()
print " VV, VH entries: %.2f" % setVV.sumEntries()
print " Top,ST entries: %.2f" % setTop.sumEntries()
# the relative normalization of the varius bkg is taken from MC by counting all the events in the full fatJetMass range
#coef = RooRealVar("coef", "coef", setVV.sumEntries()/setVjet.sumEntries(),0.,1.)
coef_VV_Vjet = RooRealVar("coef2_1", "coef2_1", setVV.sumEntries()/setVjet.sumEntries(), 0., 1.)
coef_Top_VVVjet = RooRealVar("coef3_21", "coef3_21", setTop.sumEntries()/(setVjet.sumEntries()+setVV.sumEntries()),0.,1.);
coef_VV_Vjet.setConstant(True)
coef_Top_VVVjet.setConstant(True)
# Define entries
entryVjet = RooRealVar("entryVjets", "V+jets normalization", setVjet.sumEntries(), 0., 1.e6)
entryVV = RooRealVar("entryVV", "VV normalization", setVV.sumEntries(), 0., 1.e6)
entryTop = RooRealVar("entryTop", "Top normalization", setTop.sumEntries(), 0., 1.e6)
entrySB = RooRealVar("entrySB", "Data SB normalization", setDataSB.sumEntries(SBcut), 0., 1.e6)
entrySB.setError(math.sqrt(entrySB.getVal()))
entryLSB = RooRealVar("entryLSB", "Data LSB normalization", setDataSB.sumEntries(LSBcut), 0., 1.e6)
entryLSB.setError(math.sqrt(entryLSB.getVal()))
entryHSB = RooRealVar("entryHSB", "Data HSB normalization", setDataSB.sumEntries(HSBcut), 0., 1.e6)
entryHSB.setError(math.sqrt(entryHSB.getVal()))
#*******************************************************#
# #
# NORMALIZATION #
# #
#*******************************************************#
# set reasonable ranges for J_mass and X_mass
# these are used in the fit in order to avoid ROOFIT to look in regions very far away from where we are fitting
J_mass.setRange("h_reasonable_range", LOWMIN, HIGMAX)
X_mass.setRange("X_reasonable_range", XBINMIN, XBINMAX)
# Set RooArgSets once for all, see https://root.cern.ch/phpBB3/viewtopic.php?t=11758
jetMassArg = RooArgSet(J_mass)
#*******************************************************#
# #
# V+jets normalization #
# #
#*******************************************************#
# Variables for V+jets
constVjet = RooRealVar("constVjet", "slope of the exp", -0.020, -1., 0.)
offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 30., -50., 200.)
widthVjet = RooRealVar("widthVjet", "width of the erf", 100., 1., 200.)
offsetVjet.setConstant(True)
a0Vjet = RooRealVar("a0Vjet", "width of the erf", -0.1, -5, 0)
a1Vjet = RooRealVar("a1Vjet", "width of the erf", 0.6, 0, 5)
a2Vjet = RooRealVar("a2Vjet", "width of the erf", -0.1, -1, 1)
# Define V+jets model
if fitFuncVjet == "ERFEXP": modelVjet = RooErfExpPdf("modelVjet", "error function for V+jets mass", J_mass, constVjet, offsetVjet, widthVjet)
elif fitFuncVjet == "EXP": modelVjet = RooExponential("modelVjet", "exp for V+jets mass", J_mass, constVjet)
elif fitFuncVjet == "POL": modelVjet = RooChebychev("modelVjet", "polynomial for V+jets mass", J_mass, RooArgList(a0Vjet, a1Vjet, a2Vjet))
elif fitFuncVjet == "POW": modelVjet = RooGenericPdf("modelVjet", "powerlaw for X mass", "@0^@1", RooArgList(J_mass, a0Vjet))
else:
print " ERROR! Pdf", fitFuncVjet, "is not implemented for Vjets"
exit()
# fit to main bkg in MC (whole range)
frVjet = modelVjet.fitTo(setVjet, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# integrals and number of events
iSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
iLSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange"))
iHSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange"))
iSRVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
iVRVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# Do not remove the following lines, integrals are computed here
iALVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg))
nSBVjet = iSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(SBcut)
nLSBVjet = iLSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(LSBcut)
nHSBVjet = iHSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(HSBcut)
nSRVjet = iSRVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(SRcut)
drawPlot("JetMass_Vjet", channel, J_mass, modelVjet, setVjet, binsJmass, frVjet)
if VERBOSE: print "********** Fit result [JET MASS Vjets] *"+"*"*40, "\n", frVjet.Print(), "\n", "*"*80
#*******************************************************#
# #
# VV, VH normalization #
# #
#*******************************************************#
# Variables for VV
# Error function and exponential to model the bulk
constVV = RooRealVar("constVV", "slope of the exp", -0.030, -0.1, 0.)
offsetVV = RooRealVar("offsetVV", "offset of the erf", 90., 1., 300.)
widthVV = RooRealVar("widthVV", "width of the erf", 50., 1., 100.)
erfrVV = RooErfExpPdf("baseVV", "error function for VV jet mass", J_mass, constVV, offsetVV, widthVV)
expoVV = RooExponential("baseVV", "error function for VV jet mass", J_mass, constVV)
# gaussian for the V mass peak
meanVV = RooRealVar("meanVV", "mean of the gaussian", 90., 60., 100.)
sigmaVV = RooRealVar("sigmaVV", "sigma of the gaussian", 10., 6., 30.)
fracVV = RooRealVar("fracVV", "fraction of gaussian wrt erfexp", 3.2e-1, 0., 1.)
gausVV = RooGaussian("gausVV", "gaus for VV jet mass", J_mass, meanVV, sigmaVV)
# gaussian for the H mass peak
meanVH = RooRealVar("meanVH", "mean of the gaussian", 125., 100., 150.)
sigmaVH = RooRealVar("sigmaVH", "sigma of the gaussian", 30., 5., 40.)
fracVH = RooRealVar("fracVH", "fraction of gaussian wrt erfexp", 1.5e-2, 0., 1.)
gausVH = RooGaussian("gausVH", "gaus for VH jet mass", J_mass, meanVH, sigmaVH)
# Define VV model
if fitFuncVV == "ERFEXPGAUS": modelVV = RooAddPdf("modelVV", "error function + gaus for VV jet mass", RooArgList(gausVV, erfrVV), RooArgList(fracVV))
elif fitFuncVV == "ERFEXPGAUS2": modelVV = RooAddPdf("modelVV", "error function + gaus + gaus for VV jet mass", RooArgList(gausVH, gausVV, erfrVV), RooArgList(fracVH, fracVV))
elif fitFuncVV == "EXPGAUS": modelVV = RooAddPdf("modelVV", "error function + gaus for VV jet mass", RooArgList(gausVV, expoVV), RooArgList(fracVV))
elif fitFuncVV == "EXPGAUS2": modelVV = RooAddPdf("modelVV", "error function + gaus + gaus for VV jet mass", RooArgList(gausVH, gausVV, expoVV), RooArgList(fracVH, fracVV))
else:
print " ERROR! Pdf", fitFuncVV, "is not implemented for VV"
exit()
# fit to secondary bkg in MC (whole range)
frVV = modelVV.fitTo(setVV, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# integrals and number of events
iSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
iLSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange"))
iHSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange"))
iSRVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
iVRVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# Do not remove the following lines, integrals are computed here
iALVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg))
nSBVV = iSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(SBcut)
nLSBVV = iLSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(LSBcut)
nHSBVV = iHSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(HSBcut)
nSRVV = iSRVV.getVal()/iALVV.getVal()*setVV.sumEntries(SRcut)
rSBSRVV = nSRVV/nSBVV
drawPlot("JetMass_VV", channel, J_mass, modelVV, setVV, binsJmass, frVV)
if VERBOSE: print "********** Fit result [JET MASS VV] ****"+"*"*40, "\n", frVV.Print(), "\n", "*"*80
#*******************************************************#
# #
# Top, ST normalization #
# #
#*******************************************************#
# Variables for Top
# Error Function * Exponential to model the bulk
constTop = RooRealVar("constTop", "slope of the exp", -0.030, -1., 0.)
offsetTop = RooRealVar("offsetTop", "offset of the erf", 175.0, 50., 250.)
widthTop = RooRealVar("widthTop", "width of the erf", 100.0, 1., 300.)
gausTop = RooGaussian("baseTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop)
erfrTop = RooErfExpPdf("baseTop", "error function for Top jet mass", J_mass, constTop, offsetTop, widthTop)
# gaussian for the W mass peak
meanW = RooRealVar("meanW", "mean of the gaussian", 80., 70., 90.)
sigmaW = RooRealVar("sigmaW", "sigma of the gaussian", 10., 2., 20.)
fracW = RooRealVar("fracW", "fraction of gaussian wrt erfexp", 0.1, 0., 1.)
gausW = RooGaussian("gausW", "gaus for W jet mass", J_mass, meanW, sigmaW)
# gaussian for the Top mass peak
meanT = RooRealVar("meanT", "mean of the gaussian", 175., 150., 200.)
sigmaT = RooRealVar("sigmaT", "sigma of the gaussian", 12., 5., 50.)
fracT = RooRealVar("fracT", "fraction of gaussian wrt erfexp", 0.1, 0., 1.)
gausT = RooGaussian("gausT", "gaus for T jet mass", J_mass, meanT, sigmaT)
# Define Top model
if fitFuncTop == "ERFEXPGAUS2": modelTop = RooAddPdf("modelTop", "error function + gaus + gaus for Top jet mass", RooArgList(gausW, gausT, erfrTop), RooArgList(fracW, fracT))
elif fitFuncTop == "ERFEXPGAUS": modelTop = RooAddPdf("modelTop", "error function + gaus for Top jet mass", RooArgList(gausT, erfrTop), RooArgList(fracT))
elif fitFuncTop == "GAUS3": modelTop = RooAddPdf("modelTop", "gaus + gaus + gaus for Top jet mass", RooArgList(gausW, gausT, gausTop), RooArgList(fracW, fracT))
elif fitFuncTop == "GAUS2": modelTop = RooAddPdf("modelTop", "gaus + gaus for Top jet mass", RooArgList(gausT, gausTop), RooArgList(fracT))
elif fitFuncTop == "GAUS": modelTop = RooGaussian("modelTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop)
else:
print " ERROR! Pdf", fitFuncTop, "is not implemented for Top"
exit()
# fit to secondary bkg in MC (whole range)
frTop = modelTop.fitTo(setTop, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1))
# integrals and number of events
iSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
iLSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange"))
iHSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange"))
iSRTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
iVRTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# Do not remove the following lines, integrals are computed here
iALTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg))
nSBTop = iSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(SBcut)
nLSBTop = iLSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(LSBcut)
nHSBTop = iHSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(HSBcut)
nSRTop = iSRTop.getVal()/iALTop.getVal()*setTop.sumEntries(SRcut)
drawPlot("JetMass_Top", channel, J_mass, modelTop, setTop, binsJmass, frTop)
if VERBOSE: print "********** Fit result [JET MASS TOP] ***"+"*"*40, "\n", frTop.Print(), "\n", "*"*80
#*******************************************************#
# #
# All bkg normalization #
# #
#*******************************************************#
constVjet.setConstant(True)
offsetVjet.setConstant(True)
widthVjet.setConstant(True)
a0Vjet.setConstant(True)
a1Vjet.setConstant(True)
a2Vjet.setConstant(True)
constVV.setConstant(True)
offsetVV.setConstant(True)
widthVV.setConstant(True)
meanVV.setConstant(True)
sigmaVV.setConstant(True)
fracVV.setConstant(True)
meanVH.setConstant(True)
sigmaVH.setConstant(True)
fracVH.setConstant(True)
constTop.setConstant(True)
offsetTop.setConstant(True)
widthTop.setConstant(True)
meanW.setConstant(True)
sigmaW.setConstant(True)
fracW.setConstant(True)
meanT.setConstant(True)
sigmaT.setConstant(True)
fracT.setConstant(True)
# Final background model by adding the main+secondary pdfs (using 'coef': ratio of the secondary/main, from MC)
model = RooAddPdf("model", "model", RooArgList(modelTop, modelVV, modelVjet), RooArgList(coef_Top_VVVjet, coef_VV_Vjet))#FIXME
model.fixAddCoefRange("h_reasonable_range")
# Extended fit model to data in SB
# all the 3 sidebands (Low / High / the 2 combined) could be used
# currently using the LOW+HIGH (the others are commented out)
yieldLSB = RooRealVar("yieldLSB", "Lower SB normalization", 10, 0., 1.e6)
yieldHSB = RooRealVar("yieldHSB", "Higher SB normalization", 10, 0., 1.e6)
yieldSB = RooRealVar("yieldSB", "All SB normalization", 10, 0., 1.e6)
#model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldLSB)
#model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldHSB)
model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldSB)
#frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)),RooFit.SumW2Error(True),RooFit.Extended(True),RooFit.Range("LSBrange"),RooFit.PrintLevel(-1))
#frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)),RooFit.SumW2Error(True),RooFit.Extended(True),RooFit.Range("HSBrange"),RooFit.PrintLevel(-1))
#frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)), RooFit.SumW2Error(True), RooFit.Extended(True), RooFit.Range("LSBrange,HSBrange"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1))
#print "********** Fit result [JET MASS DATA] **"+"*"*40
#print frMass.Print()
#print "*"*80
# Calculate integral of the model obtained from the fit to data (fraction of PDF that is within a given region)
#nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange"))
#nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange"))
#nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange"))
#nSR = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))
#nVR = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange"))
# scale the yieldSB from SB to SR using the ratio of the PDFs defined by the two integrals
SRyield = RooFormulaVar("SRyield", "extrapolation to SR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entrySB, entryVV, entryTop, iSBVV, iSBTop, iSRVjet, iSBVjet, iSRVV, iSRTop))
VRyield = RooFormulaVar("VRyield", "extrapolation to VR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entrySB, entryVV, entryTop, iSBVV, iSBTop, iVRVjet, iSBVjet, iVRVV, iVRTop))
HSByield = RooFormulaVar("SRyield", "extrapolation to SR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entryLSB, entryVV, entryTop, iLSBVV, iLSBTop, iHSBVjet, iLSBVjet, iHSBVV, iHSBTop))
# RooFormulaVar SRyield("SRyield","extrapolation to SR","(@0/@1)*@2",RooArgList(*nSR,*nSB,yieldLowerSB))
# RooFormulaVar SRyield("SRyield","extrapolation to SR","(@0/@1)*@2",RooArgList(*nSR,*nSB,yieldHigherSB))
#SRyield = RooFormulaVar("SRyield", "extrapolation to SR","(@0/@1)*@2", RooArgList(nSR, nSB, entrySB))
bkgYield = SRyield.getVal()
bkgYield_error = math.sqrt(SRyield.getPropagatedError(frVjet)**2 + SRyield.getPropagatedError(frVV)**2 + SRyield.getPropagatedError(frTop)**2 + (entrySB.getError()*rSBSRVV)**2)
bkgNorm = entrySB.getVal() + SRyield.getVal() + VRyield.getVal()
bkgYield_eig_norm = RooRealVar("predSR_eig_norm", "expected yield in SR", bkgYield, 0., 1.e6)
bkgYieldExt = HSByield.getVal()
drawPlot("JetMass", channel, J_mass, model, setDataSB, binsJmass, None, None, "", bkgNorm, True)
print channel, "normalization = %.3f +/- %.3f, observed = %.0f" % (bkgYield, bkgYield_error, setDataSR.sumEntries() if not BLIND else -1)
if VERBOSE: raw_input("Press Enter to continue...")
