def addHistData(self,
ws,
ds_name,
item_title,
var_set_name,
var_set_type,
ds_object,
sets=None):
legend = '[exostConfig::addHistData]:'
arg_list = RooArgList()
if (var_set_type == 'set'):
#arg_list.add(ws.set(var_set_name))
arg_list.add(sets[var_set_name])
elif (var_set_type == 'var'):
arg_list.add(ws.var(var_set_name))
else:
print legend, 'error: unknown var_set_type, cannot create dataset', ds_name
return -1
#create the hist dataset
ds = RooDataHist(ds_name, item_title, arg_list, ds_object, 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_arglist(args):
"""Return and arglist of the RooFit objects."""
arglist = RooArgList()
for arg in args:
if arg.InheritsFrom(RooAbsArg.Class()): arglist.add(arg)
else: TypeError('%s should inherit from RooAbsArg' % arg.GetName())
return arglist
def _make_underlying_model(self):
self.pdfs = {}
self.yields = {} # yields are plain floats
self.ryields = {} # keep track of roofit objects for memory management
nbins, xmin, xmax = self.plot.histos[0].GetBinning()
self.xvar = RooRealVar("x", "x", xmin, xmax)
self.xvar.setBins(nbins)
self.pdfs = {}
self.hists = []
pdfs = RooArgList()
yields = RooArgList()
for compname, comp in self.plot.histosDict.iteritems():
if comp.weighted.Integral() == 0:
continue
assert (isinstance(comp, Histogram))
hist = RooDataHist(compname, compname, RooArgList(self.xvar),
comp.weighted)
SetOwnership(hist, False)
# self.hists.append(hist)
pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist)
self.pdfs[compname] = pdf
# self.pdfs[compname].Print()
pdfs.add(pdf)
nevts = comp.Integral(xmin=xmin, xmax=xmax)
nmin = min(0, nevts * (1 - comp.uncertainty))
nmax = nevts * (1 + comp.uncertainty)
theyield = RooRealVar('n{}'.format(compname),
'n{}'.format(compname), nevts, nmin, nmax)
self.ryields[compname] = theyield
self.yields[compname] = nevts
yields.add(theyield)
self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def getInitialFitRes(cfg, ws):
""" Create a prefit RooExpandedFitResult for this workspace """
mc = ws.obj("ModelConfig")
force_mu, mu_val = cfg.force_mu_value()
if force_mu:
mc.GetParametersOfInterest().first().setVal(mu_val)
np = RooArgList(mc.GetNuisanceParameters())
np.add(mc.GetParametersOfInterest())
ws.loadSnapshot("snapshot_paramsVals_initial")
#removeGamma(np)
it = np.createIterator()
n = it.Next()
while n:
if "alpha" in n.GetName():
n.setError(1)
else:
n.setError(1.e-4)
#if "alpha_SysJetEResol" in n.GetName():
#n.setVal(-1)
n = it.Next()
ws.saveSnapshot("vars_initial", RooArgSet(np))
re = ROOT.RooExpandedFitResult(np)
cfg._muhat = mc.GetParametersOfInterest().first().getVal()
if logging.getLogger().isEnabledFor(logging.DEBUG):
logging.debug("Expanded RooFit results")
re.Print("v")
return re
def createWidthDeviation(self):
'''Compute the width deviation (denoted \kappa_H^2 by M.Peskin in arxiv 1312.4974).
Note that we fit an additive modification of the coupling: (1 + dx)
is therefore equal to kappa_x
'''
expr = '0'
sumBR = sum(self.BR.values())
pwidths = []
for dcoupling, br in self.BR.iteritems():
pwidth = None
if dcoupling in self.poi:
pwidth = str(
br /
sumBR) + "*(1+" + dcoupling + ")*(1+" + dcoupling + ")"
else:
# using sm partial width
pwidth = str(br / sumBR)
pwidths.append(pwidth)
expr = '+'.join(pwidths)
if 'inv' in self.poi:
expr = '(' + expr + ')/(1.0-inv)'
else:
# setting invisible width to 0.
expr = '(' + expr + ')'
dependentlist = RooArgList()
for dep in self.poi.values():
dependentlist.add(dep)
self.width = RooGenericPdf('width', 'width', expr, dependentlist)
def main ():
N_bkg1 = 9000
N_signal = 1000
N_bkg1_obs = 10000
N_signal_obs = 2000
N_data = N_bkg1_obs + N_signal_obs
mu1, mu2, sigma1, sigma2 = 100, 140, 15, 5
x1 = mu1 + sigma1 * np.random.randn( N_bkg1 )
x2 = mu2 + sigma2 * np.random.randn( N_signal )
x1_obs = mu1 + sigma1 * np.random.randn( N_bkg1_obs )
x2_obs = mu2 + sigma2 * np.random.randn( N_signal_obs )
h1 = Hist( 100, 40, 200, title = 'Background' )
h2 = h1.Clone( title = 'Signal' )
h3 = h1.Clone( title = 'Data' )
h3.markersize = 1.2
# fill the histograms with our distributions
map( h1.Fill, x1 )
map( h2.Fill, x2 )
map( h3.Fill, x1_obs )
map( h3.Fill, x2_obs )
histograms_1 = {'signal': h2,
'bkg1': h1,
'data': h3}
histograms_2 = {'signal': h2,
'bkg1': h1,
'data': h3}
# roofit_histograms contains RooDataHist
# model = RooAddPdf
model1, roofit_histograms_1,fit_variable_1 = get_roofit_model( histograms_1, fit_boundaries = ( 40, 200 ), name = 'm1' )
model2, roofit_histograms_2, fit_variable_2 = get_roofit_model( histograms_2, fit_boundaries = ( 40, 200 ), name = 'm2' )
sample = RooCategory( 'sample', 'sample' )
sample.defineType( 'm1', 1 )
sample.defineType( 'm2', 2 )
combined_data = deepcopy( roofit_histograms_1['data'] )
combined_data.add( roofit_histograms_2['data'] )
# RooDataHist(const char* name, const char* title, const RooArgList& vars, RooCategory& indexCat, map<std::string,TH1*> histMap, Double_t initWgt = 1.0)
sim_pdf = RooSimultaneous( "simPdf", "simultaneous pdf", sample )
sim_pdf.addPdf( model1, 'm1' )
sim_pdf.addPdf( model2, 'm2' )
variables = RooArgList()
variables.add(fit_variable_1)
variables.add(fit_variable_2)
# combined_data = RooDataHist('combined_data', 'combined_data',
# variables, RooFit.Index(sample),
# RooFit.Import('m1', roofit_histograms_1['data']),
# RooFit.Import('m2', roofit_histograms_2['data']))
fitResult = sim_pdf.fitTo( combined_data,
# RooFit.Minimizer( "Minuit2", "Migrad" ),
# RooFit.NumCPU( 1 ),
# RooFit.Extended(),
RooFit.Save(),
)
def removeGamma(arglist):
to_remove = RooArgList()
it = arglist.createIterator()
n = it.Next()
while n:
if n.GetName().startswith("gamma"):
to_remove.add(n)
n = it.Next()
print("Will remove")
to_remove.Print()
arglist.remove(to_remove)
def __init__(self, name, expr, deps):
self.name = name
self.expr = expr
self.deps = deps
dependentlist = RooArgList()
for dep in deps:
dependentlist.add(dep)
self.pdf_yield = RooGenericPdf(name, name, expr, dependentlist)
pname = name + "Constraint"
self.pdf_constraint = RooUniform(pname, pname,
RooArgSet(self.pdf_yield))
self.pulls = ROOT.TH1F('pulls_' + name, name, 1000, -10, 10)
def getPdfInRegions(w,sample,region):
if isinstance(sample,list):
sampleArgList = RooArgList()
sample_str="group"
for s in sample:
componentTmp = Util.GetComponent(w,s,region,True)
sample_str=sample_str+"_"+s
sampleArgList.add(componentTmp)
pass
pdfInRegion = RooAddition(sample_str,sample_str,sampleArgList)
else:
pdfInRegion = Util.GetComponent(w,sample,region)
pass
return pdfInRegion
def PlotSignalShapes(Selection):
f__ = TFile.Open( "datacards/22June/2dPlots.root")
signal_fname_1 = ("signals/22June/out_{sample:s}_syst.root", "cms_hgg_13TeV" )
signal_fname_2 = ("signals/22June/out_ctcv_{sample:s}_syst.root" , "ctcv" )
samples = {"thw":signal_fname_2, "thq":signal_fname_2, "tth":signal_fname_1 , "vh":signal_fname_1 }
purity_h_name = "{sample:s}/"+Selection+"/h{sample:s}_"+Selection+"_purity_CtCv"
purities = RooArgList()
signalshapes = RooArgList()
ctOverCvs = []
mVar = None
ctovercv_vals = None
for sample in samples :
purity = CtCvCpInfo("purity_" + sample)
ctovercv_vals = sorted(purity.AllCtOverCVs.keys())
purity.FillFrom2DHisto( f__.Get( purity_h_name.format( sample=sample ) ) )
purity.GetCtOverCv()
purities.add( purity.CtOverCvDataHistFunc )
objsToKeep.append( purity )
sFile = TFile.Open( samples[sample][0].format( sample=sample ) )
ws = sFile.Get( samples[sample][1] )
pdf = ws.pdf("RV{sample:s}_mh125".format( sample=sample) )
objsToKeep.append(sFile)
objsToKeep.append(ws)
objsToKeep.append(pdf)
signalshapes.add( pdf )
ctOverCvs.append( ws.var( "CtOverCv" ) )
mVar = ws.var("CMS_hgg_mass")
ret = RooAddPdf("signal" , "signal" , signalshapes , purities )
objsToKeep.append( ret )
plot = mVar.frame()
options = ""
for ctovercv in ctovercv_vals :
for var in ctOverCvs:
var.setVal( ctovercv )
name = "name%g" % ctovercv
ret.plotOn( plot , RooFit.DrawOption(options) , RooFit.Name(name) )
c = TCanvas()
plot.Draw()
c.SaveAs("a.gif+")
if not "same" in options :
options += " same"
return c
def addTrackMomenta( dataSet ):
""" add K+, K-, mu+ and mu- momentum magnitudes to data set
"""
# get observables from data set
from ROOT import RooArgList, RooFormulaVar
KplusList = RooArgList('KplusList')
KminusList = RooArgList('KminusList')
muplusList = RooArgList('muplusList')
muminusList = RooArgList('muminusList')
for suf in [ 'X','Y','Z' ] :
KplusList.add( dataSet.get().find('Kplus_P' + suf) )
KminusList.add( dataSet.get().find('Kminus_P' + suf) )
muplusList.add( dataSet.get().find('muplus_P' + suf) )
muminusList.add( dataSet.get().find('muminus_P' + suf) )
# create formulas
KplusMomFunc = RooFormulaVar( 'Kplus_P', 'Kplus_P', 'TMath::Sqrt(Kplus_PX**2 + Kplus_PY**2 + Kplus_PZ**2)', KplusList )
KminusMomFunc = RooFormulaVar( 'Kminus_P', 'Kminus_P', 'TMath::Sqrt(Kminus_PX**2 + Kminus_PY**2 + Kminus_PZ**2)', KminusList )
muplusMomFunc = RooFormulaVar( 'muplus_P', 'muplus_P', 'TMath::Sqrt(muplus_PX**2 + muplus_PY**2 + muplus_PZ**2)', muplusList )
muminusMomFunc = RooFormulaVar( 'muminus_P','muminus_P', 'TMath::Sqrt(muminus_PX**2 + muminus_PY**2 + muminus_PZ**2)', muminusList )
# create new columns in data set
dataSet.addColumn(KplusMomFunc)
dataSet.addColumn(KminusMomFunc)
dataSet.addColumn(muplusMomFunc)
dataSet.addColumn(muminusMomFunc)
def getPdfInRegionsWithRangeName(w,sample,region,rangeName):
"""
Should be moved to $HF/src/Utils.h -- FIXME
"""
if isinstance(sample,list):
sampleArgList = RooArgList()
sample_str="group"
for s in sample:
componentTmp = Util.GetComponent(w,s,region,True,rangeName)
sample_str=sample_str+"_"+s
sampleArgList.add(componentTmp)
pass
pdfInRegion = RooAddition(sample_str,sample_str,sampleArgList)
else:
pdfInRegion = Util.GetComponent(w,sample,region,False,rangeName)
pass
return pdfInRegion
def addHistData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_object, sets = None):
legend = '[exostConfig::addHistData]:'
arg_list = RooArgList()
if (var_set_type == 'set'):
#arg_list.add(ws.set(var_set_name))
arg_list.add(sets[var_set_name])
elif (var_set_type == 'var'):
arg_list.add(ws.var(var_set_name))
else:
print legend, 'error: unknown var_set_type, cannot create dataset', ds_name
return -1
#create the hist dataset
ds = RooDataHist(ds_name, item_title, arg_list, ds_object, 1)
# import the datahist. Note workaround 'import' being a reserved word
getattr(ws, 'import')(ds)
def fit(self):
pdfs = RooArgList()
obsvars = RooArgSet('set')
for constraint in self.constraint.values():
pdfs.add(constraint.pdf_constraint)
if hasattr(constraint, 'var_obs'):
obsvars.add(constraint.var_obs)
self.model = RooProdPdf('model', 'model', pdfs)
self.data = RooDataSet('data', 'data', obsvars)
self.data.add(obsvars)
self.data.Print()
self.fit_result = self.model.fitTo(self.data,
ROOT.RooFit.PrintLevel(3),
ROOT.RooFit.Optimize(1),
ROOT.RooFit.Hesse(1),
ROOT.RooFit.Minos(1),
ROOT.RooFit.Strategy(2),
ROOT.RooFit.Save(1))
def Hist2Pdf(self, hist, pdfName, ws, order = 0):
if ws.pdf(pdfName):
return ws.pdf(pdfName)
try:
obs = [ self.pars.varNames[x] for x in self.pars.var ]
except AttributeError:
obs = self.pars.var
varList = RooArgList()
for v in obs:
varList.add(ws.var(v))
newHist = RooDataHist(pdfName + '_hist', pdfName + '_hist',
varList, hist)
thePdf = RooHistPdf(pdfName, pdfName, RooArgSet(varList),
newHist, order)
getattr(ws, 'import')(thePdf)
return ws.pdf(pdfName)
def Hist2Pdf(self, hist, pdfName, ws, order=0):
if ws.pdf(pdfName):
return ws.pdf(pdfName)
try:
obs = [self.pars.varNames[x] for x in self.pars.var]
except AttributeError:
obs = self.pars.var
varList = RooArgList()
for v in obs:
varList.add(ws.var(v))
newHist = RooDataHist(pdfName + '_hist', pdfName + '_hist', varList,
hist)
thePdf = RooHistPdf(pdfName, pdfName, RooArgSet(varList), newHist,
order)
getattr(ws, 'import')(thePdf)
return ws.pdf(pdfName)
def getPdfInRegions(w,sample,region):
"""
Return the PDF in a region for a sample
Should be moved to $HF/src/Utils.h -- FIXME
@param sample The sample to find
@param region The region to use
"""
if isinstance(sample,list):
sampleArgList = RooArgList()
sample_str="group"
for s in sample:
componentTmp = Util.GetComponent(w,s,region,True)
sample_str=sample_str+"_"+s
sampleArgList.add(componentTmp)
pass
pdfInRegion = RooAddition(sample_str,sample_str,sampleArgList)
else:
pdfInRegion = Util.GetComponent(w,sample,region)
pass
return pdfInRegion
def getSumAndError(list_comps, rfr, window=None):
""" list_comps: list of tuples (obs, bwidth, comp)
"""
complist = RooArgList()
widthlist = RooArgList()
logging.debug("{}".format(list_comps))
for l in list_comps:
if window:
l[0].setRange("myrange", window[0], window[1])
inte = l[2].createIntegral(RooArgSet(l[0]), RF.Range("myrange"))
else:
inte = l[2].createIntegral(RooArgSet(l[0]))
complist.add(inte)
widthlist.add(RF.RooConst(l[1]))
roosum = RooAddition("sum", "sum", complist, widthlist)
val = roosum.getVal()
if rfr is not None:
error = ROOT.RU.getPropagatedError(roosum, rfr)
else:
error = -1
return [val, error]
def 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_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 __init__(self, name, expr, deps, mean, sigma):
self.name = name
self.expr = expr
self.deps = deps
self.mean = mean
self.sigma = sigma
# pdf of yield vs coupling modificators
dependentlist = RooArgList()
for dep in deps:
dependentlist.add(dep)
self.pdf_yield = RooGenericPdf(name, name, expr, dependentlist)
# observable (measurement)
obsname = name + 'Obs'
self.var_obs = RooRealVar(obsname, obsname, mean)
# width of Gaussian pdf
sname = name + 'Sigma'
self.var_sigma = RooRealVar(sname, sname, sigma)
# Gaussian pdf
gname = name + "Constraint"
self.pdf_constraint = RooGaussian(gname, gname, self.var_obs,
self.pdf_yield, self.var_sigma)
self.pulls = ROOT.TH1F('pulls_' + name, name, 1000, -10, 10)
def _make_underlying_model(self):
self.pdfs = {}
self.yields = {} # yields are plain floats
self.ryields = {} # keep track of roofit objects for memory management
h = self._histos[0]
nbins = h.GetXaxis().GetNbins()
xmin = h.GetXaxis().GetXmin()
xmax = h.GetXaxis().GetXmax()
self.xvar = RooRealVar("x", "x", xmin, xmax)
self.xvar.setBins(nbins)
self.pdfs = {}
self.hists = []
pdfs = RooArgList()
yields = RooArgList()
for histo in self._histos:
if histo.Integral() == 0:
continue
compname = histo.GetName()
hist = RooDataHist(compname, compname, RooArgList(self.xvar),
histo)
SetOwnership(hist, False)
# self.hists.append(hist)
pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist)
self.pdfs[compname] = pdf
# self.pdfs[compname].Print()
pdfs.add(pdf)
nevts = histo.Integral()
uncertainty = self._uncertainty
nmin = min(0, nevts * (1 - uncertainty))
nmax = nevts * (1 + uncertainty)
theyield = RooRealVar('n{}'.format(compname),
'n{}'.format(compname), nevts, nmin, nmax)
self.ryields[compname] = theyield
self.yields[compname] = nevts
yields.add(theyield)
self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def plotFitModel(model, frame, wksp, myconfigfile, log) :
if debug :
model.Print('t')
frame.Print('v')
dataset = w.data(dataSetToPlot)
# plot model itself
fr = model.plotOn(frame,
RooFit.LineColor(kBlue+3),RooFit.Name("FullPdf"))
var = []
tacc_list = RooArgList()
numKnots = myconfigfile["Acceptance"]["knots"].__len__()
for i in range(0,numKnots+1):
varName = "var%d"%(int(i+1))
var.append(wksp.var(varName))
print "[INFO] Load %s with value %0.3lf"%(var[i].GetName(),var[i].getValV())
tacc_list.add(var[i])
varAdd = RooAddition(wksp.obj("var%d"%(numKnots+2)))
#varAdd = RooRealVar(wksp.obj("var%d"%(numKnots+2)))
print "[INFO] Load %s with value %0.3lf"%(varAdd.GetName(),varAdd.getValV())
tacc_list.add(varAdd)
#len = var.__len__()
#tacc_list.add(var[len])
spl = RooCubicSplineFun("splinePdf", "splinePdf", time, "splineBinning", tacc_list)
if log:
rel = 200
else:
rel = 1000
rel = 40
fr = spl.plotOn(frame, RooFit.LineColor(kRed), RooFit.Normalization(rel, RooAbsReal.Relative),RooFit.Name("sPline"))
fr = model.plotOn(frame,
RooFit.LineColor(kBlue+3), RooFit.Name("FullPdf"))
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 createMorph(obs, nuis_var, norm, up, down):
pdf_list = RooArgList()
pdf_list.add(down)
pdf_list.add(up)
pdf_list.add(norm) # nominal pdf
nref_points = std.vector('double')()
nref_points.push_back(-1)
nref_points.push_back(1)
nnuis_points = std.vector('int')()
nnuis_points.push_back(2)
par_list = RooArgList()
par_list.add(nuis_var)
morph = ROOT.RooStarMomentMorph("morph", "morph", par_list, obs, pdf_list,
nnuis_points, nref_points,
ROOT.RooStarMomentMorph.Linear)
return morph
def getBinByBinErrorBand(mc_comps, observables, binWidths, rfr, weights=None):
if rfr is None:
return None
bins = []
binning = observables[0].getBinning()
stepsize = binning.averageBinWidth()
low = binning.lowBound()
high = binning.highBound()
real_weights = RooArgList()
if weights is not None:
for bw, w in zip(binWidths, weights):
real_weights.add(RF.RooConst(bw.getVal() * w))
else:
for bw in binWidths:
real_weights.add(RF.RooConst(bw.getVal()))
m = low
while m < high - 1e-6:
rname = "bin" + str(m)
intes = RooArgList()
for obs, mc in zip(observables, mc_comps):
intes.add(mc.createIntegral(RooArgSet(obs), RF.Range(rname)))
totbin = RooAddition("sumbin", "sumbin", intes, real_weights)
val = totbin.getVal()
err = ROOT.RU.getPropagatedError(totbin, rfr)
bins.append((val, err))
logging.debug("Found error of {}".format(err))
m += stepsize
yvals = []
xvals = []
for i, b in enumerate(bins):
yvals.extend([b[0] + b[1], b[0] + b[1]])
xvals.extend([binning.binLow(i), binning.binLow(i)])
xvals.append(high)
xvals = xvals[1:]
xvals.extend(reversed(xvals))
for b in reversed(bins):
yvals.extend([b[0] - b[1], b[0] - b[1]])
# # FIXME JWH
# for x,y in zip(xvals,yvals):
# print "(x,y) = ({},{})".format(x,y)
yvals_a = array('d', yvals)
xvals_a = array('d', xvals)
curve = TGraph(len(xvals), xvals_a, yvals_a)
return curve
pyroot_logon.cmsPrelim(c4, fitterPars.intLumi/1000)
c4.Print('H{2}_Mjj_{0}_{1}jets_Pull.pdf'.format(modeString, opts.Nj, opts.mH))
c4.Print('H{2}_Mjj_{0}_{1}jets_Pull.png'.format(modeString, opts.Nj, opts.mH))
if (TMath.Prob(chi2Raw, ndf2) < 0.05):
print '**DANGER** The fit probability is low **DANGER**'
if opts.debug:
assert(False)
#assert(False)
mass.setRange('signal', fitterPars.minTrunc, fitterPars.maxTrunc)
#yields = theFitter.makeFitter().coefList()
finalPars = fr.floatParsFinal()
yields = RooArgList(finalPars)
yields.add(fr.constPars())
sigInt = theFitter.makeFitter().createIntegral(iset,iset,'signal')
sigFullInt = theFitter.makeFitter().createIntegral(iset,iset)
print "allBkg","sigInt",sigInt.getVal(),"fullInt",sigFullInt.getVal(),\
"ratio",sigInt.getVal()/sigFullInt.getVal()
dibosonInt = theFitter.makeDibosonPdf().createIntegral(iset,iset,'signal')
dibosonFullInt = theFitter.makeDibosonPdf().createIntegral(iset,iset)
WpJPdf = theFitter.makeWpJPdf()
WpJInt = WpJPdf.createIntegral(iset, iset, 'signal')
WpJFullInt = WpJPdf.createIntegral(iset, iset)
#WpJPdf.Print("v")
print "WpJ","sigInt",WpJInt.getVal(),"fullInt",WpJFullInt.getVal(),\
"ratio",WpJInt.getVal()/WpJFullInt.getVal()
ttbarInt = theFitter.makettbarPdf().createIntegral(iset, iset, 'signal')
ttbarFullInt = theFitter.makettbarPdf().createIntegral(iset, iset)
SingleTopInt = theFitter.makeSingleTopPdf().createIntegral(iset, iset, 'signal')
def fit_gau2_che(var,
dataset,
title='',
print_pars=False,
test=False,
mean_=None,
sigma_=None,
sigma1_=None,
sigmaFraction_=None):
# define background
c0 = RooRealVar('c0', 'constant', 0.1, -1, 1)
c1 = RooRealVar('c1', 'linear', 0.6, -1, 1)
c2 = RooRealVar('c2', 'quadratic', 0.1, -1, 1)
c3 = RooRealVar('c3', 'c3', 0.1, -1, 1)
bkg = RooChebychev('bkg', 'background pdf', var,
RooArgList(c0, c1, c2, c3))
# define signal
val = 5.28
dmean = 0.05
valL = val - dmean
valR = val + dmean
if mean_ is None:
mean = RooRealVar("mean", "mean", val, valL, valR)
else:
mean = RooRealVar("mean", "mean", mean_)
val = 0.05
dmean = 0.02
valL = val - dmean
valR = val + dmean
if sigma_ is None:
sigma = RooRealVar('sigma', 'sigma', val, valL, valR)
else:
sigma = RooRealVar('sigma', 'sigma', sigma_)
if sigma1_ is None:
sigma1 = RooRealVar('sigma1', 'sigma1', val, valL, valR)
else:
sigma1 = RooRealVar('sigma1', 'sigma1', sigma1_)
peakGaus = RooGaussian("peakGaus", "peakGaus", var, mean, sigma)
peakGaus1 = RooGaussian("peakGaus1", "peakGaus1", var, mean, sigma1)
if sigmaFraction_ is None:
sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", 0.5, 0.,
1.)
else:
sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction",
sigmaFraction_)
glist = RooArgList(peakGaus, peakGaus1)
peakG = RooAddPdf("peakG", "peakG", glist, RooArgList(sigmaFraction))
listPeak = RooArgList("listPeak")
listPeak.add(peakG)
listPeak.add(bkg)
fbkg = 0.45
nEntries = dataset.numEntries()
val = (1 - fbkg) * nEntries
listArea = RooArgList("listArea")
areaPeak = RooRealVar("areaPeak", "areaPeak", val, 0., nEntries)
listArea.add(areaPeak)
nBkg = fbkg * nEntries
areaBkg = RooRealVar("areaBkg", "areaBkg", nBkg, 0., nEntries)
listArea.add(areaBkg)
model = RooAddPdf("model", "fit model", listPeak, listArea)
if not test:
fitres = model.fitTo(dataset, RooFit.Extended(kTRUE),
RooFit.Minos(kTRUE), RooFit.Save(kTRUE))
nbins = 35
frame = var.frame(nbins)
frame.GetXaxis().SetTitle("B^{0} mass (GeV/c^{2})")
frame.GetXaxis().CenterTitle()
frame.GetYaxis().CenterTitle()
frame.SetTitle(title)
mk_size = RooFit.MarkerSize(0.3)
mk_style = RooFit.MarkerStyle(kFullCircle)
dataset.plotOn(frame, mk_size, mk_style)
model.plotOn(frame)
as_bkg = RooArgSet(bkg)
cp_bkg = RooFit.Components(as_bkg)
line_style = RooFit.LineStyle(kDashed)
model.plotOn(frame, cp_bkg, line_style)
if print_pars:
fmt = RooFit.Format('NEU')
lyt = RooFit.Layout(0.65, 0.95, 0.92)
param = model.paramOn(frame, fmt, lyt)
param.getAttText().SetTextSize(0.02)
param.getAttText().SetTextFont(60)
frame.Draw()
pars = [
areaBkg, areaPeak, c0, c1, c2, c3, mean, sigma, sigma1, sigmaFraction
]
return pars
acceptance.SetMinimum(0.5)
acceptance.SetMaximum(1.5)
# (1) DsK, (2) DsPi
accfns = []
accfnerrs = []
xbincs = numpy.linspace(tfloor + 0.05, tceil - 0.05, nbins)
for mode, fitresult in enumerate(fitresults):
parlist = fitresult.floatParsFinal()
cmatrix = fitresult.covarianceMatrix()
veclist = RooArgList()
for i in range(parlist.getSize()):
name = "%s_%d" % (parlist[i].GetName(), i)
veclist.add(parlist[i].clone(name))
multigauss = RooMultiVarGaussian("multigauss", "multigauss", veclist, parlist, cmatrix)
dset = multigauss.generate(RooArgSet(veclist), 1000)
fns = []
for entry in range(dset.numEntries()):
vecset = dset.get(entry)
veclist = RooArgList(vecset)
for pars in range(veclist.getSize()):
acceptance.SetParameter(pars, veclist[pars].getVal())
fns += [acceptance.Clone("%s_%d" % (acceptance.GetName(), entry))]
avgfn = BinnedAvgFunction(fns, xbincs)
avgfn.calculate()
accfns += [avgfn.get_avg_fn()]
def getComponents(cfg, w):
""" Fetch all components (data, MC pdfs...) for a given workspace
Organize all of this in a map
"""
iscomb = cfg.dataname == 'combData' # SKC
mc = w.obj("ModelConfig")
data = w.data(cfg.dataname)
simPdf = w.pdf('combPdf' if iscomb else "simPdf")
channelCat = simPdf.indexCat()
chanName = channelCat.GetName()
comps = {}
for tt in categories(channelCat):
ttname = tt.GetName()
pdftmp = simPdf.getPdf(ttname)
datatmp = data.reduce("{0}=={1}::{2}".format(chanName, chanName,
ttname))
obs = pdftmp.getObservables(mc.GetObservables()).first()
obs_set = RooArgSet(obs)
sure, yup = ttname_mod(cfg, ttname)
binWidth = pdftmp.getVariables().find("binWidth_obs_x_{0}_0{1}".format(
ttname, sure + yup))
if not binWidth:
it = pdftmp.getVariables().createIterator()
print('---------ttname is-------{}'.format(ttname))
var = it.Next()
while var:
if 'binWidth' in var.GetName(): print(var.GetName())
var = it.Next()
logging.debug(" Bin Width : {}".format(binWidth.getVal()))
comps[ttname] = [obs, binWidth, datatmp, {}, pdftmp]
binning = obs.getBinning()
stepsize = binning.averageBinWidth()
low = binning.lowBound()
high = binning.highBound()
m = low
while m < (high - 1e-6):
obs.setRange("bin" + str(m), m, m + stepsize)
m += stepsize
bkgList = RooArgList()
sigList = RooArgList()
totList = RooArgList()
for c in components(pdftmp, ttname, iscomb):
compname = c.GetName()
has_mass, res = cfg.is_signal(compname)
if has_mass:
sigList.add(c)
else:
bkgList.add(c)
totList.add(c)
comps[ttname][3][compname] = c
sigSum = RooAddition("Signal", "sig_Sum", sigList)
comps[ttname][3]["Signal"] = sigSum
bkgSum = RooAddition("Bkg", "bkg_Sum", bkgList)
comps[ttname][3]["Bkg"] = bkgSum
totSum = RooAddition("MC", "tot_Sum", totList)
comps[ttname][3]["MC"] = totSum
try:
cfg.combineComps(comps)
except AttributeError:
continue
return comps
def getFrame(cat,
obsData,
simPdf,
mc,
fit_res,
error_band_strategy=1,
compute_yields=False):
"""
Build a frame with the different fit components and their uncertainties
Parameters
----------
cat : RooCategory
Category of the simultaneous PDF we are interested in
obsData: RooDataHist object (either real data or asimov or PE)
simPdf : RooSimultaneous PDF
mc : ModelConfig object
fit_res: RooFitResult
Result of the fit (covariance matrix, NLL value, ...)
error_band_strategy : True/False
True: Use the linear approximation to extract the error band
False: Use a sampling method
See http://root.cern.ch/root/html/RooAbsReal.html#RooAbsReal:plotOnWithErrorBand
verbose: True/False
TODO: implement a more generic way to retrieve the binning.
Currently it has to be put in the workspace with the name binWidth_obs_x_{channel}_0
"""
hlist = []
if compute_yields:
yields = {}
# --> Get the total (signal+bkg) model pdf
pdftmp = simPdf.getPdf(cat.GetName())
if not pdftmp:
raise RuntimeError('Could not retrieve the total pdf ')
# --> Get the list of observables
obstmp = pdftmp.getObservables(mc.GetObservables())
if not obstmp:
raise RuntimeError('Could not retrieve the list of observable')
# --> Get the first (and only) observable (mmc mass for cut based)
obs = obstmp.first()
log.info('Observable: {0}'.format(obs.GetName()))
# --> Get the RooDataHist of the given category
datatmp = obsData.reduce("{0}=={1}::{2}".format(
simPdf.indexCat().GetName(),
simPdf.indexCat().GetName(), cat.GetName()))
datatmp.__class__ = ROOT.RooAbsData # --> Ugly fix !!!
# --> Get the binning width of the category (stored as a workspace variable)
binWidth = pdftmp.getVariables().find('binWidth_obs_x_{0}_0'.format(
cat.GetName()))
if not binWidth:
raise RuntimeError('Could not retrieve the binWidth')
# --> parameter of interest (mu=sigma/sigma_sm)
poi = mc.GetParametersOfInterest().first()
poi_fitted_val = poi.getVal()
log.info('POI: {0} = {1} +/- {2}'.format(poi.GetName(), poi.getVal(),
poi.getError()))
# --> Create the data histogram
hist_data = asrootpy(datatmp.createHistogram("hdata_" + cat.GetName(),
obs))
hist_data.name = "hdata_{0}".format(cat.GetName())
hist_data.title = ""
hlist.append(hist_data)
#--> compute the data yields
if compute_yields:
Yield_data = hist_data.Integral()
yields['Data'] = (Yield_data, 0)
# --> Create the frame structure from the observable
frame = obs.frame()
frame.SetName(cat.GetName())
datatmp.plotOn(frame, ROOT.RooFit.DataError(ROOT.RooAbsData.Poisson),
ROOT.RooFit.Name("Data"), ROOT.RooFit.MarkerSize(1))
# --> Create the signal histogram template
hist_sig = hist_data.Clone('h_TotalSignal_{0}'.format(cat.GetName()))
hist_sig.Reset()
signal_comps = RooArgList()
bkg_comps = RooArgList()
# --> get the list of components (hadhad HSG4: QCD,Other,Ztautau, Signal_Z, Signal_W, Signal_gg, Signal_VBF)
# --> and iterate over
pdfmodel = pdftmp.getComponents().find(cat.GetName() + '_model')
funcListIter = pdfmodel.funcList().iterator()
while True:
comp = funcListIter.Next()
if not comp:
break
name = comp.GetName().replace('L_x_', '').split('_')[0]
log.info('Scan component {0}'.format(comp.GetName()))
hist_comp = asrootpy(
comp.createHistogram(cat.GetName() + "_" + comp.GetName(), obs,
ROOT.RooFit.Extended(False)))
hist_comp.name = 'h_{0}_{1}'.format(name, cat.GetName())
hist_comp.title = ''
hlist.append(hist_comp)
if 'Signal' in comp.GetName():
signal_comps.add(comp)
hist_sig.Add(hist_comp)
else:
bkg_comps.add(comp)
Integral_comp = comp.createIntegral(RooArgSet(obs))
Yield_comp = Integral_comp.getVal() * binWidth.getVal()
log.info('Integral = {0}'.format(Yield_comp))
# if Yield_comp==0:
# raise RuntimeError('Yield integral is wrong !!')
# --> Add the components to the frame but in an invisible way
pdfmodel.plotOn(
frame, ROOT.RooFit.Components(comp.GetName()),
ROOT.RooFit.Normalization(Yield_comp, ROOT.RooAbsReal.NumEvent),
ROOT.RooFit.Name("NoStacked_" + comp.GetName()),
ROOT.RooFit.Invisible())
if fit_res:
# --> Add the components uncertainty band
comp.plotOn(
frame,
ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected),
ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy),
ROOT.RooFit.Name("FitError_AfterFit_" + comp.GetName()),
ROOT.RooFit.Invisible())
if compute_yields:
if Yield_comp == 0:
Yield_comp_err = 0.
else:
Yield_comp_err = Integral_comp.getPropagatedError(
fit_res) * binWidth.getVal()
yields[comp.GetName()] = (Yield_comp, Yield_comp_err)
hlist.append(hist_sig)
# --> total signal yields
if compute_yields:
signal_tot_comp = RooAddition('pdf_sum_sig', 'pdf_sum_sig',
signal_comps)
Integral_signal = signal_tot_comp.createIntegral(RooArgSet(obs))
yields_sig_tot = Integral_signal.getVal() * binWidth.getVal()
yields_sig_tot_err = Integral_signal.getPropagatedError(
fit_res) * binWidth.getVal()
yields['TotalSignal'] = (yields_sig_tot, yields_sig_tot_err)
bkg_tot_comp = RooAddition('pdf_sum_bkg', 'pdf_sum_bkg', bkg_comps)
Integral_bkg = bkg_tot_comp.createIntegral(RooArgSet(obs))
yields_bkg_tot = Integral_bkg.getVal() * binWidth.getVal()
yields_bkg_tot_err = Integral_bkg.getPropagatedError(
fit_res) * binWidth.getVal()
yields['bkg'] = (yields_bkg_tot, yields_bkg_tot_err)
log.info('Bkg Total Yield: {0}'.format(yields_bkg_tot))
# --> bkg+signal PDF central value and error
Integral_total = pdfmodel.createIntegral(RooArgSet(obs))
Yield_total = Integral_total.getVal() * binWidth.getVal()
log.info('Postfit Total Yield: {0}'.format(Yield_total))
hist_bkg_plus_sig = asrootpy(
pdfmodel.createHistogram("hbkg_plus_sig_" + cat.GetName(), obs,
ROOT.RooFit.Extended(False)))
hist_bkg_plus_sig.name = 'hbkg_plus_sig_' + cat.GetName()
hist_bkg_plus_sig.title = ''
hist_bkg_plus_sig.Scale(Yield_total)
hlist.append(hist_bkg_plus_sig)
# --> Add the components to the frame but in an invisible way
pdftmp.plotOn(
frame, ROOT.RooFit.Normalization(Yield_total,
ROOT.RooAbsReal.NumEvent),
ROOT.RooFit.Name("Bkg_plus_sig"))
if fit_res:
pdftmp.plotOn(
frame, ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy),
ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected),
ROOT.RooFit.Name("FitError_AfterFit"),
ROOT.RooFit.FillColor(ROOT.kOrange), ROOT.RooFit.LineWidth(2),
ROOT.RooFit.LineColor(ROOT.kBlue))
# --> bkg only PDF central value and error
poi.setVal(0.)
Integral_bkg_total = pdfmodel.createIntegral(RooArgSet(obs))
Yield_bkg_total = Integral_bkg_total.getVal() * binWidth.getVal()
hist_bkg = pdfmodel.createHistogram("hbkg_" + cat.GetName(), obs,
ROOT.RooFit.Extended(False))
hist_bkg.Scale(Yield_bkg_total)
hist_bkg.SetName("hbkg_" + cat.GetName())
hist_bkg.SetTitle("")
hlist.append(hist_bkg)
pdftmp.plotOn(
frame,
ROOT.RooFit.Normalization(Yield_bkg_total, ROOT.RooAbsReal.NumEvent),
ROOT.RooFit.Name("Bkg"), ROOT.RooFit.LineStyle(ROOT.kDashed))
if fit_res:
pdftmp.plotOn(
frame, ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy),
ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected),
ROOT.RooFit.Name("FitError_AfterFit_Mu0"),
ROOT.RooFit.FillColor(ROOT.kOrange), ROOT.RooFit.LineWidth(2),
ROOT.RooFit.LineColor(ROOT.kBlue))
#if compute_yields:
# Yield_bkg_total_err = Integral_bkg_total.getPropagatedError(fit_res)*binWidth.getVal()
# yields['bkg'] = (Yield_bkg_total, Yield_bkg_total_err)
poi.setVal(poi_fitted_val)
if compute_yields:
return frame, hlist, yields
else:
return frame, hlist
def buildMassAndLifetimePDF(ws):
#define mass shape
ws.factory('RooCBShape::massCBShape(JpsiMass,CBmass[3.1,3.05,3.15],CBsigma[0.02,0.0001,1],CBalpha[1,.0001,5],CBn[10,.0001,50])')
#ws.factory('RooGaussian::massCBShape(JpsiMass,CBmass[3.1,3.05,3.15],CBsigma[0.02,0.0001,1])')
ws.factory('RooExponential::bkgMassShape(JpsiMass,bkgLambda[0,-5,5])')
#ws.factory('RooChebychev::bkgMassShape(JpsiMass,{p0[1,-10,10],p1[1,-10,10],p2[1,-10,10]})')
#lifetime
ws.factory('RooGaussModel::promptLifetimeRaw(Jpsict,promptMean[0,-1,1],ctResolution[1,.001,5],1,JpsictErr)')
ws.pdf('promptLifetimeRaw').advertiseFlatScaleFactorIntegral(True)
ws.factory('RooDecay::nonPromptSSDRaw(Jpsict,nonPromptTau[.3,.01,3],promptLifetimeRaw,RooDecay::SingleSided)')
ws.factory('RooDecay::backgroundSSDRawL(Jpsict,bkgTauSSDL[.3,0,3],promptLifetimeRaw,RooDecay::SingleSided)')
#ws.factory('RooDecay::backgroundFDRaw(Jpsict,bkgTauFD[.3,.0001,3],promptLifetimeRaw,RooDecay::Flipped)')
ws.factory('RooDecay::backgroundDSDRawL(Jpsict,bkgTauDSDL[.3,0,3],promptLifetimeRaw,RooDecay::DoubleSided)')
ws.factory('SUM::backgroundRawL(fBkgSSDL[.5,0,1]*backgroundSSDRawL,backgroundDSDRawL)')
ws.factory('RooDecay::backgroundSSDRawR(Jpsict,bkgTauSSDR[.3,0,3],promptLifetimeRaw,RooDecay::SingleSided)')
#ws.factory('RooDecay::backgroundFDRaw(Jpsict,bkgTauFD[.3,.0001,3],promptLifetimeRaw,RooDecay::Flipped)')
ws.factory('RooDecay::backgroundDSDRawR(Jpsict,bkgTauDSDR[.3,0,3],promptLifetimeRaw,RooDecay::DoubleSided)')
ws.factory('SUM::backgroundRawR(fBkgSSDR[.5,0,1]*backgroundSSDRawR,backgroundDSDRawR)')
ws.factory('SUM::backgroundRaw(fBkgLR[.5]*backgroundRawL,backgroundDSDRawR)')
ws.factory('PROD::promptRawMass(massCBShape)') #,promptLifetimeRaw|JpsictErr
ws.factory('PROD::nonpromptRawMass(massCBShape)') #,nonPromptSSDRaw|JpsictErr
ws.factory('PROD::backgroundRawMass(bkgMassShape)') #,backgroundDSDRaw|JpsictErr
ws.factory('PROD::promptRawCTau(promptLifetimeRaw|JpsictErr)')
ws.factory('PROD::nonpromptRawCTau(nonPromptSSDRaw|JpsictErr)')
ws.factory('PROD::backgroundRawCTauL(backgroundRawL|JpsictErr)')
ws.factory('PROD::backgroundRawCTauR(backgroundRawR|JpsictErr)')
ws.factory('PROD::backgroundRawCTau(backgroundRaw|JpsictErr)')
#extended pdfs
ws.factory('RooExtendPdf::promptExtMass(promptRawMass,sum::nPrompt(nPromptSignal[1000,0,1000000]))') #,nPromptL[1000,0,1000000],nPromptR[1000,0,1000000]
ws.factory('RooExtendPdf::nonpromptExtMass(nonpromptRawMass,sum::nNonPrompt(nNonPromptSignal[500,0,1000000]))')
#[500,0,1000000],,nNonPromptL[500,0,1000000],nNonPromptR[500,0,1000000]
ws.factory('RooExtendPdf::backgroundExtMass(backgroundRawMass,sum::nBackground(nBackgroundSignal[100,0,1000000],nBackgroundL[100,0,1000000],nBackgroundR[100,0,1000000]))') #
ws.factory('RooExtendPdf::promptExtCTauL(promptRawCTau,0)') #nPromptL[1,0,1000000]
ws.factory('RooExtendPdf::promptExtCTauR(promptRawCTau,0)')#nPromptR[1,0,1000000]
ws.factory('RooExtendPdf::nonpromptExtCTauL(nonpromptRawCTau,0)') #nNonPromptL[1,0,1000000]
ws.factory('RooExtendPdf::nonpromptExtCTauR(nonpromptRawCTau,0)') #nNonPromptR[1,0,1000000]
ws.factory('RooExtendPdf::backgroundExtCTauL(backgroundRawCTauL,nBackgroundL)')
ws.factory('RooExtendPdf::backgroundExtCTauR(backgroundRawCTauR,nBackgroundR)')
ws.factory('RooExtendPdf::promptExtCTau(promptRawCTau,nPromptSignal)')
ws.factory('RooExtendPdf::nonpromptExtCTau(nonpromptRawCTau,nNonPromptSignal)')
ws.factory('RooExtendPdf::backgroundExtCTau(backgroundRawCTau,nBackgroundSignal)')
#final AddPdfs
promptMArgList = RooArgList(ws.pdf('promptExtMass'))
nonPromptMArgList = RooArgList(ws.pdf('promptExtMass'),
ws.pdf('nonpromptExtMass'))
if options.doNonPrompt:
promptMArgList.add(ws.pdf('nonpromptExtMass'))
if options.doBackground:
promptMArgList.add(ws.pdf('backgroundExtMass'))
nonPromptMArgList.add(ws.pdf('backgroundExtMass'))
promptM = RooAddPdf('promptMass','prompt',promptMArgList)
nonpromptM = RooAddPdf('nonpromptMass','nonprompt',nonPromptMArgList)
backgroundM = RooAddPdf('backgroundMass','background',RooArgList(ws.pdf('promptExtMass'),
ws.pdf('nonpromptExtMass'),
ws.pdf('backgroundExtMass')))
promptCTArgList = RooArgList(ws.pdf('promptExtCTau'))
nonPromptCTArgList = RooArgList(ws.pdf('promptExtCTau'),
ws.pdf('nonpromptExtCTau'))
if options.doNonPrompt:
promptCTArgList.add(ws.pdf('nonpromptExtCTau'))
if options.doBackground:
promptCTArgList.add(ws.pdf('backgroundExtCTau'))
nonPromptCTArgList.add(ws.pdf('backgroundExtCTau'))
promptCT = RooAddPdf('promptCTau','prompt',promptCTArgList)
nonpromptCT = RooAddPdf('nonpromptCTau','nonprompt',nonPromptCTArgList)
backgroundCT = RooAddPdf('backgroundCTau','background',RooArgList(ws.pdf('promptExtCTau'),
ws.pdf('nonpromptExtCTau'),
ws.pdf('backgroundExtCTau')))
#playing around with signal in left sideband
backgroundCTL = RooAddPdf('backgroundCTauL','background',RooArgList(ws.pdf('promptExtCTauL'),
ws.pdf('nonpromptExtCTauL'),
ws.pdf('backgroundExtCTauL')))
backgroundCTR = RooAddPdf('backgroundCTauR','background',RooArgList(ws.pdf('promptExtCTauR'),
ws.pdf('nonpromptExtCTauR'),
ws.pdf('backgroundExtCTauR')))
getattr(ws,'import')(promptM)
getattr(ws,'import')(nonpromptM)
getattr(ws,'import')(backgroundM)
getattr(ws,'import')(promptCT)
getattr(ws,'import')(nonpromptCT)
getattr(ws,'import')(backgroundCT)
getattr(ws,'import')(backgroundCTL)
getattr(ws,'import')(backgroundCTR)
massConfig = 'SIMUL::MPdf(ctauRegion,'
ctConfig = 'SIMUL::LPdf(massRegion,'
if options.doPrompt:
massConfig += 'prompt=promptMass,'
ctConfig += 'signal=promptCTau,'
if options.doNonPrompt:
massConfig += 'nonPrompt=promptMass'
if options.doBackground:
ctConfig += 'leftMassSideBand=backgroundCTauL,rightMassSideBand=backgroundCTauR'
massConfig += ')'
ctConfig += ')'
#simultaneous
ws.factory(massConfig)
ws.factory(ctConfig)
def findOnePe(hist, ws, name='x', Npe = 1):
fitPed(hist, ws, name)
x = ws.var(name)
ped = ws.pdf('ped')
pedWidth = ws.var('pedWidth')
pdfs = RooArgList(ped)
pdfList = []
fped = RooRealVar('fped', 'f_{ped}', 0.8, 0., 1.)
fractions = RooArgList(fped)
fList = []
peList = []
peMean = RooRealVar('peMean', 'mean_{pe}', 6., 0., 20.)
peWidth = RooRealVar('peWidth', 'width_{pe}', pedWidth.getVal(), 0., 10.)
for i in range(0, Npe):
pem = RooFormulaVar('pem{0}'.format(i+1), '@0+{0}*@1'.format(i+1),
RooArgList(ws.var('pedMean'), peMean))
peList.append(pem)
npepdf = RooGaussian('pe{0}pdf'.format(i+1), 'pe{0}pdf'.format(i+1),
x, pem, pedWidth)
pdfs.add(npepdf)
pdfList.append(npepdf)
fnpe = RooRealVar('fpe{0}'.format(i+1), 'fpe{0}'.format(i+1),
0.5, -0.1, 1.0)
fractions.add(fnpe)
fList.append(fnpe)
#bgMean = RooRealVar("bgMean", "bgMean", 6.0, x.getMin(), x.getMax())
bgScale = RooRealVar("bgScale", "bgScale", 0.5, -1.0, Npe + 1.0)
bgMean = RooFormulaVar("bgMean", "@1+@0*@2",
RooArgList(peMean, ws.var('pedMean'), bgScale))
bgWidthL = RooRealVar("bgWidthL", "bgWidthL", pedWidth.getVal()*2,
0., 25.)
bgWidthR = RooRealVar("bgWidthR", "bgWidthR", pedWidth.getVal()*7,
0., 25.)
bgGauss = RooBifurGauss("bgGauss", "bgGauss", x, bgMean,
bgWidthR, bgWidthR)
if (Npe > 1):
pdfs.add(bgGauss)
else:
fractions.remove(fractions.at(fractions.getSize()-1))
## pem = RooFormulaVar('pem', '@0+@1', RooArgList(peMean, ws.var('pedMean')))
## firstPe = RooGaussian('firstPe', 'firstPe', x, pem, peWidth)
## pdfs.Print("v")
## fractions.Print("v")
pedPlusOne = RooAddPdf('pedPlusOne', 'pedPlusOne', pdfs, fractions, True)
## pedWidth = ped.GetParameter(2)
## pedMean = ped.GetParameter(1)
## pedA = ped.GetParameter(0)
secondMax = hist.GetMaximumBin() + 1
goingDown = True
maxVal = hist.GetBinContent(secondMax)
foundMax = False
while (not foundMax) and (secondMax < hist.GetNbinsX()):
tmpVal = hist.GetBinContent(secondMax+1)
if (tmpVal < maxVal):
if not goingDown:
foundMax = True
else:
goingDown = True
maxVal = tmpVal
secondMax += 1
elif (tmpVal > maxVal):
goingDown = False
maxVal = tmpVal
secondMax += 1
else:
maxVal = tmpVal
secondMax += 1
secondMaxx = hist.GetBinCenter(secondMax)
print 'found 2nd maximum in bin',secondMax,'value',secondMaxx
## peMean.setVal(secondMaxx)
## bgMean.setVal(secondMaxx*0.6)
x.setRange('pedPlus_fit', x.getMin(), ws.var('pedMean').getVal()+pedWidth.getVal()*6.*(Npe+0))
pedPlusOne.fitTo(ws.data('ds'), RooFit.Minos(False),
RooFit.Range('pedPlus_fit'),
RooFit.PrintLevel(1))
getattr(ws, 'import')(pedPlusOne)
temp_tt.Rebin(20)
temp_wj.Rebin(20)
temp_zj.Rebin(20)
temp_stop.Rebin(20)
temp_qcd.Rebin(20)
temp_qcd.Scale(800/temp_qcd.Integral())
temp_signal = temp_tt.Clone('signal')
temp_signal.Add(temp_stop)
#temp_tt.Scale(1/temp_tt.Integral())
#temp_wj.Scale(1/temp_wj.Integral())
#temp_zj.Scale(1/temp_zj.Integral())
#temp_stop.Scale(1/temp_stop.Integral())
#temp_qcd.Scale(1/temp_qcd.Integral())
leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.)
vars = RooArgList()
vars.add(leptonAbsEta)
vars_set = RooArgSet()
vars_set.add(leptonAbsEta)
n_event_obs = h_m3_data.GetEntries();
lowerBound = -10 * sqrt(n_event_obs);
upperBound = n_event_obs + 10 * sqrt(n_event_obs);
n_init = n_event_obs / 2.;
data = RooDataHist("data", "dataset with leptonAbsEta", vars, h_m3_data)
rh_tt = RooDataHist("rh_tt", "tt", vars, temp_tt);
rh_wj = RooDataHist("rh_wj", "wj", vars, temp_wj);
rh_zj = RooDataHist("rh_zj", "zj", vars, temp_zj);
rh_qcd = RooDataHist("rh_qcd", "qcd", vars, temp_qcd);
rh_stop = RooDataHist("rh_stop", "singletop", vars, temp_stop);
rh_signal = RooDataHist("rh_signal", "signal", vars, temp_signal);
pdf_tt = RooHistPdf("pdf_tt", "Signal pdf", vars_set, rh_tt, 0);
def buildMassAndLifetimePDF(ws):
#define mass shape
ws.factory(
'RooCBShape::massCBShape(JpsiMass,CBmass[3.1,3.05,3.15],CBsigma[0.02,0.0001,1],CBalpha[1,.0001,5],CBn[10,.0001,50])'
)
#ws.factory('RooGaussian::massCBShape(JpsiMass,CBmass[3.1,3.05,3.15],CBsigma[0.02,0.0001,1])')
ws.factory('RooExponential::bkgMassShape(JpsiMass,bkgLambda[0,-5,5])')
#ws.factory('RooChebychev::bkgMassShape(JpsiMass,{p0[1,-10,10],p1[1,-10,10],p2[1,-10,10]})')
#lifetime
ws.factory(
'RooGaussModel::promptLifetimeRaw(Jpsict,promptMean[0,-1,1],ctResolution[1,.001,5],1,JpsictErr)'
)
ws.pdf('promptLifetimeRaw').advertiseFlatScaleFactorIntegral(True)
ws.factory(
'RooDecay::nonPromptSSDRaw(Jpsict,nonPromptTau[.3,.01,3],promptLifetimeRaw,RooDecay::SingleSided)'
)
ws.factory(
'RooDecay::backgroundSSDRawL(Jpsict,bkgTauSSDL[.3,0,3],promptLifetimeRaw,RooDecay::SingleSided)'
)
#ws.factory('RooDecay::backgroundFDRaw(Jpsict,bkgTauFD[.3,.0001,3],promptLifetimeRaw,RooDecay::Flipped)')
ws.factory(
'RooDecay::backgroundDSDRawL(Jpsict,bkgTauDSDL[.3,0,3],promptLifetimeRaw,RooDecay::DoubleSided)'
)
ws.factory(
'SUM::backgroundRawL(fBkgSSDL[.5,0,1]*backgroundSSDRawL,backgroundDSDRawL)'
)
ws.factory(
'RooDecay::backgroundSSDRawR(Jpsict,bkgTauSSDR[.3,0,3],promptLifetimeRaw,RooDecay::SingleSided)'
)
#ws.factory('RooDecay::backgroundFDRaw(Jpsict,bkgTauFD[.3,.0001,3],promptLifetimeRaw,RooDecay::Flipped)')
ws.factory(
'RooDecay::backgroundDSDRawR(Jpsict,bkgTauDSDR[.3,0,3],promptLifetimeRaw,RooDecay::DoubleSided)'
)
ws.factory(
'SUM::backgroundRawR(fBkgSSDR[.5,0,1]*backgroundSSDRawR,backgroundDSDRawR)'
)
ws.factory(
'SUM::backgroundRaw(fBkgLR[.5]*backgroundRawL,backgroundDSDRawR)')
ws.factory(
'PROD::promptRawMass(massCBShape)') #,promptLifetimeRaw|JpsictErr
ws.factory(
'PROD::nonpromptRawMass(massCBShape)') #,nonPromptSSDRaw|JpsictErr
ws.factory(
'PROD::backgroundRawMass(bkgMassShape)') #,backgroundDSDRaw|JpsictErr
ws.factory('PROD::promptRawCTau(promptLifetimeRaw|JpsictErr)')
ws.factory('PROD::nonpromptRawCTau(nonPromptSSDRaw|JpsictErr)')
ws.factory('PROD::backgroundRawCTauL(backgroundRawL|JpsictErr)')
ws.factory('PROD::backgroundRawCTauR(backgroundRawR|JpsictErr)')
ws.factory('PROD::backgroundRawCTau(backgroundRaw|JpsictErr)')
#extended pdfs
ws.factory(
'RooExtendPdf::promptExtMass(promptRawMass,sum::nPrompt(nPromptSignal[1000,0,1000000]))'
) #,nPromptL[1000,0,1000000],nPromptR[1000,0,1000000]
ws.factory(
'RooExtendPdf::nonpromptExtMass(nonpromptRawMass,sum::nNonPrompt(nNonPromptSignal[500,0,1000000]))'
)
#[500,0,1000000],,nNonPromptL[500,0,1000000],nNonPromptR[500,0,1000000]
ws.factory(
'RooExtendPdf::backgroundExtMass(backgroundRawMass,sum::nBackground(nBackgroundSignal[100,0,1000000],nBackgroundL[100,0,1000000],nBackgroundR[100,0,1000000]))'
) #
ws.factory('RooExtendPdf::promptExtCTauL(promptRawCTau,0)'
) #nPromptL[1,0,1000000]
ws.factory('RooExtendPdf::promptExtCTauR(promptRawCTau,0)'
) #nPromptR[1,0,1000000]
ws.factory('RooExtendPdf::nonpromptExtCTauL(nonpromptRawCTau,0)'
) #nNonPromptL[1,0,1000000]
ws.factory('RooExtendPdf::nonpromptExtCTauR(nonpromptRawCTau,0)'
) #nNonPromptR[1,0,1000000]
ws.factory(
'RooExtendPdf::backgroundExtCTauL(backgroundRawCTauL,nBackgroundL)')
ws.factory(
'RooExtendPdf::backgroundExtCTauR(backgroundRawCTauR,nBackgroundR)')
ws.factory('RooExtendPdf::promptExtCTau(promptRawCTau,nPromptSignal)')
ws.factory(
'RooExtendPdf::nonpromptExtCTau(nonpromptRawCTau,nNonPromptSignal)')
ws.factory(
'RooExtendPdf::backgroundExtCTau(backgroundRawCTau,nBackgroundSignal)')
#final AddPdfs
promptMArgList = RooArgList(ws.pdf('promptExtMass'))
nonPromptMArgList = RooArgList(ws.pdf('promptExtMass'),
ws.pdf('nonpromptExtMass'))
if options.doNonPrompt:
promptMArgList.add(ws.pdf('nonpromptExtMass'))
if options.doBackground:
promptMArgList.add(ws.pdf('backgroundExtMass'))
nonPromptMArgList.add(ws.pdf('backgroundExtMass'))
promptM = RooAddPdf('promptMass', 'prompt', promptMArgList)
nonpromptM = RooAddPdf('nonpromptMass', 'nonprompt', nonPromptMArgList)
backgroundM = RooAddPdf(
'backgroundMass', 'background',
RooArgList(ws.pdf('promptExtMass'), ws.pdf('nonpromptExtMass'),
ws.pdf('backgroundExtMass')))
promptCTArgList = RooArgList(ws.pdf('promptExtCTau'))
nonPromptCTArgList = RooArgList(ws.pdf('promptExtCTau'),
ws.pdf('nonpromptExtCTau'))
if options.doNonPrompt:
promptCTArgList.add(ws.pdf('nonpromptExtCTau'))
if options.doBackground:
promptCTArgList.add(ws.pdf('backgroundExtCTau'))
nonPromptCTArgList.add(ws.pdf('backgroundExtCTau'))
promptCT = RooAddPdf('promptCTau', 'prompt', promptCTArgList)
nonpromptCT = RooAddPdf('nonpromptCTau', 'nonprompt', nonPromptCTArgList)
backgroundCT = RooAddPdf(
'backgroundCTau', 'background',
RooArgList(ws.pdf('promptExtCTau'), ws.pdf('nonpromptExtCTau'),
ws.pdf('backgroundExtCTau')))
#playing around with signal in left sideband
backgroundCTL = RooAddPdf(
'backgroundCTauL', 'background',
RooArgList(ws.pdf('promptExtCTauL'), ws.pdf('nonpromptExtCTauL'),
ws.pdf('backgroundExtCTauL')))
backgroundCTR = RooAddPdf(
'backgroundCTauR', 'background',
RooArgList(ws.pdf('promptExtCTauR'), ws.pdf('nonpromptExtCTauR'),
ws.pdf('backgroundExtCTauR')))
getattr(ws, 'import')(promptM)
getattr(ws, 'import')(nonpromptM)
getattr(ws, 'import')(backgroundM)
getattr(ws, 'import')(promptCT)
getattr(ws, 'import')(nonpromptCT)
getattr(ws, 'import')(backgroundCT)
getattr(ws, 'import')(backgroundCTL)
getattr(ws, 'import')(backgroundCTR)
massConfig = 'SIMUL::MPdf(ctauRegion,'
ctConfig = 'SIMUL::LPdf(massRegion,'
if options.doPrompt:
massConfig += 'prompt=promptMass,'
ctConfig += 'signal=promptCTau,'
if options.doNonPrompt:
massConfig += 'nonPrompt=promptMass'
if options.doBackground:
ctConfig += 'leftMassSideBand=backgroundCTauL,rightMassSideBand=backgroundCTauR'
massConfig += ')'
ctConfig += ')'
#simultaneous
ws.factory(massConfig)
ws.factory(ctConfig)
RooFit.Normalization(hist1_events))
# Z = 175 GeV
data_hist2 = RooDataHist('dhist2', 'dhist2', RooArgList(x), hist2)
pdf2 = RooHistPdf('phist2', 'phist2', RooArgSet(x), data_hist2)
pdf2.plotOn(frame, RooFit.LineColor(R.kGreen),
RooFit.Normalization(hist2_events))
# Not to be included in the Moment Morphing (just a check)
data_hist3 = RooDataHist('dhist3', 'dhist3', RooArgList(x), hist3)
pdf3 = RooHistPdf('phist3', 'phist3', RooArgSet(x), data_hist3)
pdf3.plotOn(frame, RooFit.LineColor(R.kBlue),
RooFit.Normalization(hist3_events))
data_hist3.plotOn(frame)
# Create a RooArgList to store pdfs and fill it
pdfs = RooArgList()
pdfs.add(pdf1)
pdfs.add(pdf2)
# Create a TVector and store model mass values in it
masses = [125, 175]
paramVec = R.TVectorD(len(masses))
paramVec[0] = masses[0]
paramVec[1] = masses[1]
# Set up morphing
m = w.factory('m[70,230]')
setting = R.RooMomentMorph.Linear
morph = R.RooMomentMorph('morph', 'morph', m, RooArgList(x), pdfs, paramVec,
setting)
getattr(w, 'import')(morph)
def accbuilder(time, knots, coeffs):
# build acceptance function
from copy import deepcopy
myknots = deepcopy(knots)
mycoeffs = deepcopy(coeffs)
from ROOT import (RooBinning, RooArgList, RooPolyVar,
RooCubicSplineFun)
if (len(myknots) != len(mycoeffs) or 0 >= min(len(myknots), len(mycoeffs))):
raise ValueError('ERROR: Spline knot position list and/or coefficient'
'list mismatch')
# create the knot binning
knotbinning = WS(ws, RooBinning(time.getMin(), time.getMax(), 'knotbinning'))
for v in myknots:
knotbinning.addBoundary(v)
knotbinning.removeBoundary(time.getMin())
knotbinning.removeBoundary(time.getMax())
knotbinning.removeBoundary(time.getMin())
knotbinning.removeBoundary(time.getMax())
oldbinning, lo, hi = time.getBinning(), time.getMin(), time.getMax()
time.setBinning(knotbinning, 'knotbinning')
time.setBinning(oldbinning)
time.setRange(lo, hi)
del knotbinning
del oldbinning
del lo
del hi
# create the knot coefficients
coefflist = RooArgList()
i = 0
for v in mycoeffs:
coefflist.add(WS(ws, RooRealVar('SplineAccCoeff%u' % i,
'SplineAccCoeff%u' % i, v)))
i = i + 1
del mycoeffs
coefflist.add(one)
i = i + 1
myknots.append(time.getMax())
myknots.reverse()
fudge = (myknots[0] - myknots[1]) / (myknots[2] - myknots[1])
lastmycoeffs = RooArgList(
WS(ws, RooConstVar('SplineAccCoeff%u_coeff0' % i,
'SplineAccCoeff%u_coeff0' % i, 1. - fudge)),
WS(ws, RooConstVar('SplineAccCoeff%u_coeff1' % i,
'SplineAccCoeff%u_coeff1' % i, fudge)))
del myknots
coefflist.add(WS(ws, RooPolyVar(
'SplineAccCoeff%u' % i, 'SplineAccCoeff%u' % i,
coefflist.at(coefflist.getSize() - 2), lastmycoeffs)))
del i
# create the spline itself
tacc = WS(ws, RooCubicSplineFun('SplineAcceptance', 'SplineAcceptance', time,
'knotbinning', coefflist))
del lastmycoeffs
# make sure the acceptance is <= 1 for generation
m = max([coefflist.at(j).getVal() for j in
xrange(0, coefflist.getSize())])
from ROOT import RooProduct
c = WS(ws, RooConstVar('SplineAccNormCoeff', 'SplineAccNormCoeff', 0.99 / m))
tacc_norm = WS(ws, RooProduct('SplineAcceptanceNormalised',
'SplineAcceptanceNormalised', RooArgList(tacc, c)))
del c
del m
del coefflist
return tacc, tacc_norm
var = iter.Next()
data = ws.allData()
for var in data:
# iter = data.createIterator()
# var = iter.Next()
# while var :
getattr( newws , "import")( var.Clone() , RooFit.RecycleConflictNodes())
var = iter.Next()
a = RooArgList("pdfs")
cat = RooCategory("pdfindex_THQLeptonicTag_inverted_13TeV" , "title")
cat.Print()
pdfs = ws.allPdfs()
iter = pdfs.createIterator()
var = iter.Next()
while var :
getattr( newws , "import")( var.Clone() , RooFit.RecycleConflictNodes())
if var.GetName() in ["env_pdf_0_13TeV_bern1","env_pdf_0_13TeV_exp1","env_pdf_0_13TeV_pow1","env_pdf_0_13TeV_lau1"]:
a.add( var )
var = iter.Next()
multipdf = RooMultiPdf("CMS_hgg_THQLeptonicTag_inverted_13TeV_bkgshape" , "title" , cat , a )
getattr( newws , "import")( multipdf, RooFit.RecycleConflictNodes() )
f.Close()
fnew = TFile.Open("new.root" , "recreate")
newws.Write()
fnew.Close()
print "done"
varList = r.floatParsFinal()
it = varList.createIterator()
setconst=[]
while True:
var = it.Next()
if not var:
break
if var.isConstant():
continue
setconst.append(var.GetName())
var.setConstant(True)
splot_vars = RooArgList()
for v in config["splot_vars"]:
splot_vars.add(w.obj(v))
#normTree
sData = RooStats.SPlot("sData","An SPlot", fullUnbDataSet, Final_PDF, splot_vars )
sData.Print()
for v in config["splot_vars"]:
print v,"Fitted value: %.2f sPlot value: %.2f"%(w.obj(v).getVal(), sData.GetYieldFromSWeight(v))
for v in setconst:
w.obj(v).setConstant(False)
fullUnbDataSet.Print("v")
save_file = TFile.Open(config['outFileName'],"RECREATE")
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)
def plotFitModel(model, frame, wksp, myconfigfile, log, debug) :
if debug :
model.Print('t')
frame.Print('v')
fr = model.plotOn(frame,
RooFit.LineColor(kBlue+3),RooFit.Name("FullPdf"))
if "Acceptance" in myconfigfile.keys():
var = []
tacc_list = RooArgList()
numKnots = myconfigfile["Acceptance"]["knots"].__len__()
for i in range(0,numKnots+1):
varName = "var%d"%(int(i+1))
var.append(wksp.var(varName))
print "[INFO] Load %s with value %0.3lf"%(var[i].GetName(),var[i].getValV())
tacc_list.add(var[i])
varAdd = RooAddition(wksp.obj("var%d"%(numKnots+2)))
print "[INFO] Load %s with value %0.3lf"%(varAdd.GetName(),varAdd.getValV())
tacc_list.add(varAdd)
elif "ResolutionAcceptance" in myconfigfile.keys():
#Create acceptance
var = []
tacc_list = RooArgList()
numKnots = myconfigfile["ResolutionAcceptance"]["Signal"]["Acceptance"]["KnotPositions"].__len__()
print "[INFO] Number of knots: "+str(numKnots)
for i in range(0,numKnots+1):
if i!=6:
varName = "Acceptance_SplineAccCoeff%d"%(int(i))
var.append(wksp.obj(varName))
print "[INFO] Load %s with value %0.3lf"%(var[i].GetName(),var[i].getValV())
else:
var.append( RooConstVar("one","one",1.0) )
print "[INFO] Load one as coefficient no. 6"
tacc_list.add(var[i])
varName = "Acceptance_SplineAccCoeff%d"%(int(numKnots+1))
var.append(wksp.obj(varName))
print "[INFO] Load %s with value %0.3lf"%(var[numKnots+1].GetName(),var[numKnots+1].getValV())
tacc_list.add(var[numKnots+1])
#Create binning
binning = RooBinning(time.getMin(), time.getMax(), 'splineBinning')
for kn in myconfigfile["ResolutionAcceptance"]["Signal"]["Acceptance"]["KnotPositions"]:
binning.addBoundary(kn)
binning.removeBoundary(time.getMin())
binning.removeBoundary(time.getMax())
binning.removeBoundary(time.getMin())
binning.removeBoundary(time.getMax())
oldBinning, lo, hi = time.getBinning(), time.getMin(), time.getMax()
time.setBinning(binning, 'splineBinning')
time.setBinning(oldBinning)
time.setRange(lo, hi)
spl = RooCubicSplineFun("splinePdf", "splinePdf", time, "splineBinning", tacc_list)
if log:
rel = 200
else:
#rel = 1000
rel = 2000
fr = spl.plotOn(frame, RooFit.LineColor(kRed), RooFit.Normalization(rel, RooAbsReal.Relative),RooFit.Name("sPline"))
fr = model.plotOn(frame,
RooFit.LineColor(kBlue+3), RooFit.Name("FullPdf"))
def buildPolarizationPDF(ws, options):
foldname = ''
if not options.folded:
foldname = ''
accMaps = TFile.Open(options.acceptanceMap)
#effMaps = TFile.Open(options.efficiencyMap)
ws.factory('lambda_theta_' + options.fitFrame + '_p[0,-1,1]')
ws.factory('lambda_phi_' + options.fitFrame + '_p[0,-1,1]')
ws.factory('lambda_thetaphi_' + options.fitFrame + '_p[0,-1,1]')
ws.factory('lambda_theta_' + options.fitFrame + '_np[0,-1,1]')
ws.factory('lambda_phi_' + options.fitFrame + '_np[0,-1,1]')
ws.factory('lambda_thetaphi_' + options.fitFrame + '_np[0,-1,1]')
ws.factory('nPromptinP[500,0,1000000]')
ws.factory('sum::nPromptinNP(1*nPromptSignal,-1*nPromptinP)')
ws.factory('nNonPromptinNP[100,0,1000000]')
ws.factory('sum::nNonPromptinP(1*nNonPromptSignal,-1*nNonPromptinNP)')
ws.factory('nBackgroundinP[50,0,1000000]')
ws.factory('sum::nBackgroundinNP(1*nBackgroundSignal,-1*nBackgroundinP)')
ws.factory('RooPolarizationConstraint::promptConstr(' + 'lambda_theta_' +
options.fitFrame + '_p,' + 'lambda_phi_' + options.fitFrame +
'_p,' + 'lambda_thetaphi_' + options.fitFrame + '_p)')
ws.factory('RooPolarizationConstraint::nonPromptConstr(' +
'lambda_theta_' + options.fitFrame + '_np,' + 'lambda_phi_' +
options.fitFrame + '_np,' + 'lambda_thetaphi_' +
options.fitFrame + '_np)')
#for each rap/pt cell make a unique simultaneous fit of prompt,non-prompt, background
for rap_bin in range(1, len(jpsi.pTRange)):
for pt_bin in range(len(jpsi.pTRange[rap_bin])):
accMapHist = accMaps.Get('hAcc2D_' + options.fitFrame + '_pT' +
str(pt_bin + 1) + '_rap' + str(rap_bin))
for effMap in options.efficiencyMap.split(','):
effMaps = TFile.Open(effMap)
effMapHist = effMaps.Get('hAcc2D_' + options.fitFrame + '_pT' +
str(pt_bin + 1) + '_rap' +
str(rap_bin))
accMapHist.Multiply(effMapHist)
effMaps.Close()
getattr(ws, 'import')(accMapHist)
accMap = RooDataHist(
'accMap' + options.fitFrame + 'Data_' + str(rap_bin) + '_' +
str(pt_bin + 1), 'acceptance map',
RooArgList(ws.var('costh_' + options.fitFrame + foldname),
ws.var('phi_' + options.fitFrame + foldname)),
ROOT.RooFit.Import(accMapHist, False))
getattr(ws, 'import')(accMap)
accMapFunc = RooHistFunc(
'accMapFunc' + options.fitFrame + '_' + str(rap_bin) + '_' +
str(pt_bin + 1), 'acceptance map',
RooArgSet(ws.var('costh_' + options.fitFrame + foldname),
ws.var('phi_' + options.fitFrame + foldname)),
ws.data('accMap' + options.fitFrame + 'Data_' + str(rap_bin) +
'_' + str(pt_bin + 1)), 1)
getattr(ws, 'import')(accMapFunc)
#make a *real* hist pdf :-)
ws.factory('RooGenericPdf::accMap' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1) +
'("@0",{accMapFunc' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1) + '})')
#create datahist for L and R sidebands
getattr(ws, 'import')(
accMap.Clone('bkgShape' + options.fitFrame + 'DataL_' +
str(rap_bin) + '_' + str(pt_bin + 1)))
getattr(ws, 'import')(
accMap.Clone('bkgShape' + options.fitFrame + 'DataR_' +
str(rap_bin) + '_' + str(pt_bin + 1)))
ws.data('bkgShape' + options.fitFrame + 'DataL_' + str(rap_bin) +
'_' + str(pt_bin + 1)).reset()
ws.data('bkgShape' + options.fitFrame + 'DataR_' + str(rap_bin) +
'_' + str(pt_bin + 1)).reset()
#fill them
ws.data('bkgShape' + options.fitFrame + 'DataL_' + str(rap_bin) +
'_' + str(pt_bin + 1)).add(
ws.data('data_rap' + str(rap_bin) + '_pt' +
str(pt_bin + 1)),
'massRegion == massRegion::leftMassSideBand')
ws.data('bkgShape' + options.fitFrame + 'DataR_' + str(rap_bin) +
'_' + str(pt_bin + 1)).add(
ws.data('data_rap' + str(rap_bin) + '_pt' +
str(pt_bin + 1)),
'massRegion == massRegion::rightMassSideBand')
#make histpdfs and combination
ws.factory('RooHistPdf::bkgShape' + options.fitFrame + 'L_' +
str(rap_bin) + '_' + str(pt_bin + 1) + '({costh_' +
options.fitFrame + foldname + ',phi_' +
options.fitFrame + foldname + '},' + 'bkgShape' +
options.fitFrame + 'DataL_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ')')
ws.factory('RooHistPdf::bkgShape' + options.fitFrame + 'R_' +
str(rap_bin) + '_' + str(pt_bin + 1) + '({costh_' +
options.fitFrame + foldname + ',phi_' +
options.fitFrame + foldname + '},' + 'bkgShape' +
options.fitFrame + 'DataR_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ')')
ws.factory('SUM::bkgShape' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1) +
'(fBkgLR*bkgShape' + options.fitFrame + 'L_' +
str(rap_bin) + '_' + str(pt_bin + 1) + ',bkgShape' +
options.fitFrame + 'R_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ')')
#test new polarization pdf
ws.factory('RooPolarizationPdf::basePolPdf' + options.fitFrame +
'Prompt_' + str(rap_bin) + '_' + str(pt_bin + 1) +
'(costh_' + options.fitFrame + foldname + ',phi_' +
options.fitFrame + foldname + ',lambda_theta_' +
options.fitFrame + '_p,lambda_phi_' + options.fitFrame +
'_p,lambda_thetaphi_' + options.fitFrame + '_p)')
ws.factory('RooPolarizationPdf::basePolPdf' + options.fitFrame +
'NonPrompt_' + str(rap_bin) + '_' + str(pt_bin + 1) +
'(costh_' + options.fitFrame + foldname + ',phi_' +
options.fitFrame + foldname + ',lambda_theta_' +
options.fitFrame + '_np,lambda_phi_' +
options.fitFrame + '_np,lambda_thetaphi_' +
options.fitFrame + '_np)')
#should add back *(3+@2) ?
#sin(2theta) = 2sin(theta)cos(theta) = 2*sqrt(1 - cos(theta)*cos(theta))*cos(theta)
#ws.factory('RooGenericPdf::basePolPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+
# '("1+@2*pow(@0,2.)+@3*(1-pow(@0,2.))*cos(2*@1*pi/180)+@4*sin(2*acos(@0))*cos(@1*pi/180)"'+
# ',{costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+',lambda_theta_'+options.fitFrame+
# '_p,lambda_phi_'+options.fitFrame+'_p,lambda_thetaphi_'+options.fitFrame+'_p})')
#ws.factory('RooGenericPdf::basePolPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+
# '("1+@2*@0*@0+@3*(1-@0*@0)*cos(2*@1*pi/180)+@4*sin(2*acos(@0))*cos(@1*pi/180)"'+
# ',{costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+',lambda_theta_'+options.fitFrame+
# '_np,lambda_phi_'+options.fitFrame+'_np,lambda_thetaphi_'+options.fitFrame+'_np})')
ws.factory('PROD::polPdf' + options.fitFrame + 'Prompt_' +
str(rap_bin) + '_' + str(pt_bin + 1) + '(basePolPdf' +
options.fitFrame + 'Prompt_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ',accMap' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1) + ')')
ws.factory('PROD::polPdf' + options.fitFrame + 'NonPrompt_' +
str(rap_bin) + '_' + str(pt_bin + 1) + '(basePolPdf' +
options.fitFrame + 'NonPrompt_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ',accMap' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1) + ')')
ws.factory('RooExtendPdf::promptPolExtinP' + options.fitFrame +
'_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(polPdf' +
options.fitFrame + 'Prompt_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ',nPromptinP)')
ws.factory('RooExtendPdf::promptPolExtinNP' + options.fitFrame +
'_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(polPdf' +
options.fitFrame + 'Prompt_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ',nPromptinNP)')
ws.factory('RooExtendPdf::nonPromptPolExtinNP' + options.fitFrame +
'_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(polPdf' +
options.fitFrame + 'NonPrompt_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ',nNonPromptinNP)')
ws.factory('RooExtendPdf::nonPromptPolExtinP' + options.fitFrame +
'_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(polPdf' +
options.fitFrame + 'NonPrompt_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ',nNonPromptinP)')
ws.factory('RooExtendPdf::bkgPolExtinP' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1) + '(bkgShape' +
options.fitFrame + '_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ',nBackgroundinP)')
ws.factory('RooExtendPdf::bkgPolExtinNP' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1) + '(bkgShape' +
options.fitFrame + '_' + str(rap_bin) + '_' +
str(pt_bin + 1) + ',nBackgroundinNP)')
promptPOLArgList = RooArgList(
ws.pdf('promptPolExtinP' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1)))
nonPromptPOLArgList = RooArgList(
ws.pdf('promptPolExtinNP' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1)),
ws.pdf('nonPromptPolExtinNP' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1)))
if options.doNonPrompt:
promptPOLArgList.add(
ws.pdf('nonPromptPolExtinP' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1)))
if options.doBackground:
promptPOLArgList.add(
ws.pdf('bkgPolExtinP' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1)))
nonPromptPOLArgList.add(
ws.pdf('bkgPolExtinNP' + options.fitFrame + '_' +
str(rap_bin) + '_' + str(pt_bin + 1)))
promptP = RooAddPdf(
'promptPol' + options.fitFrame + '_' + str(rap_bin) + '_' +
str(pt_bin + 1), 'prompt', promptPOLArgList)
nonpromptP = RooAddPdf(
'nonpromptPol' + options.fitFrame + '_' + str(rap_bin) + '_' +
str(pt_bin + 1), 'nonprompt', nonPromptPOLArgList)
getattr(ws, 'import')(promptP)
getattr(ws, 'import')(nonpromptP)
polConfig = 'SIMUL::PPdf' + options.fitFrame + '_' + str(
rap_bin) + '_' + str(pt_bin + 1) + '(mlRegion,'
if options.doPrompt:
polConfig += 'promptSignal=promptPol' + options.fitFrame + '_' + str(
rap_bin) + '_' + str(pt_bin + 1) + ','
if options.doNonPrompt:
polConfig += 'nonPromptSignal=nonpromptPol' + options.fitFrame + '_' + str(
rap_bin) + '_' + str(pt_bin + 1) + ','
#if options.doBackground:
# polConfig += ('prompt;leftMassSideBand=bkgPolExtL'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+','
# 'prompt;rightMassSideBand=bkgPolExtR'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))
# polConfig += ('nonPrompt;leftMassSideBand=bkgPolExtL'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+','
# 'nonPrompt;rightMassSideBand=bkgPolExtR'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))
polConfig += ')'
#simultaneous
ws.factory(polConfig)
accMaps.Close()
def fit_gau2_che(var, dataset, title='', print_pars=False, test=False,
mean_=None, sigma_=None, sigma1_=None, sigmaFraction_=None):
# define background
c0 = RooRealVar('c0', 'constant', 0.1, -1, 1)
c1 = RooRealVar('c1', 'linear', 0.6, -1, 1)
c2 = RooRealVar('c2', 'quadratic', 0.1, -1, 1)
c3 = RooRealVar('c3', 'c3', 0.1, -1, 1)
bkg = RooChebychev('bkg', 'background pdf', var,
RooArgList(c0, c1, c2, c3))
# define signal
val = 5.28
dmean = 0.05
valL = val - dmean
valR = val + dmean
if mean_ is None:
mean = RooRealVar("mean", "mean", val, valL, valR)
else:
mean = RooRealVar("mean", "mean", mean_)
val = 0.05
dmean = 0.02
valL = val - dmean
valR = val + dmean
if sigma_ is None:
sigma = RooRealVar('sigma', 'sigma', val, valL, valR)
else:
sigma = RooRealVar('sigma', 'sigma', sigma_)
if sigma1_ is None:
sigma1 = RooRealVar('sigma1', 'sigma1', val, valL, valR)
else:
sigma1 = RooRealVar('sigma1', 'sigma1', sigma1_)
peakGaus = RooGaussian("peakGaus", "peakGaus", var, mean, sigma)
peakGaus1 = RooGaussian("peakGaus1", "peakGaus1", var, mean, sigma1)
if sigmaFraction_ is None:
sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", 0.5, 0., 1.)
else:
sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", sigmaFraction_)
glist = RooArgList(peakGaus, peakGaus1)
peakG = RooAddPdf("peakG","peakG", glist, RooArgList(sigmaFraction))
listPeak = RooArgList("listPeak")
listPeak.add(peakG)
listPeak.add(bkg)
fbkg = 0.45
nEntries = dataset.numEntries()
val=(1-fbkg)* nEntries
listArea = RooArgList("listArea")
areaPeak = RooRealVar("areaPeak", "areaPeak", val, 0.,nEntries)
listArea.add(areaPeak)
nBkg = fbkg*nEntries
areaBkg = RooRealVar("areaBkg","areaBkg", nBkg, 0.,nEntries)
listArea.add(areaBkg)
model = RooAddPdf("model", "fit model", listPeak, listArea)
if not test:
fitres = model.fitTo(dataset, RooFit.Extended(kTRUE),
RooFit.Minos(kTRUE),RooFit.Save(kTRUE))
nbins = 35
frame = var.frame(nbins)
frame.GetXaxis().SetTitle("B^{0} mass (GeV/c^{2})")
frame.GetXaxis().CenterTitle()
frame.GetYaxis().CenterTitle()
frame.SetTitle(title)
mk_size = RooFit.MarkerSize(0.3)
mk_style = RooFit.MarkerStyle(kFullCircle)
dataset.plotOn(frame, mk_size, mk_style)
model.plotOn(frame)
as_bkg = RooArgSet(bkg)
cp_bkg = RooFit.Components(as_bkg)
line_style = RooFit.LineStyle(kDashed)
model.plotOn(frame, cp_bkg, line_style)
if print_pars:
fmt = RooFit.Format('NEU')
lyt = RooFit.Layout(0.65, 0.95, 0.92)
param = model.paramOn(frame, fmt, lyt)
param.getAttText().SetTextSize(0.02)
param.getAttText().SetTextFont(60)
frame.Draw()
pars = [areaBkg, areaPeak, c0, c1, c2, c3, mean, sigma, sigma1, sigmaFraction]
return pars
n_signal = n_ttbar + n_stop
temp_VPlusJets.Rebin(REBIN)
temp_tt.Rebin(REBIN)
temp_wj.Rebin(REBIN)
temp_zj.Rebin(REBIN)
temp_stop.Rebin(REBIN)
temp_qcd.Rebin(REBIN)
temp_qcd2.Rebin(REBIN)
temp_qcd.Scale(n_qcd / temp_qcd.Integral())
temp_qcd2.Scale(n_qcd/temp_qcd2.Integral())
temp_signal = temp_tt.Clone('signal')
temp_signal.Add(temp_stop)
leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.)
variables = RooArgList()
variables.add(leptonAbsEta)
vars_set = RooArgSet()
vars_set.add(leptonAbsEta)
n_event_obs = h_data.Integral();
lowerBound = -10 * sqrt(n_event_obs);
lowerBound = 0
upperBound = n_event_obs + 10 * sqrt(n_event_obs);
upperBound = n_event_obs
n_init = n_event_obs / 2.;
data = RooDataHist("data", "dataset with leptonAbsEta", variables, h_data)
rh_tt = RooDataHist("rh_tt", "tt", variables, temp_tt);
rh_wj = RooDataHist("rh_wj", "wj", variables, temp_wj);
rh_zj = RooDataHist("rh_zj", "zj", variables, temp_zj);
rh_VJ = RooDataHist("rh_VJ", "VJ", variables, temp_VPlusJets);
rh_qcd = RooDataHist("rh_qcd", "qcd", variables, temp_qcd);
rh_qcd2 = RooDataHist("rh_qcd", "qcd", variables, temp_qcd2);
fOut = TFile.Open("out.root" , "recreate")
for kvkt in AllCtOverCVs:
infile = TFile.Open( "ctcv%g/input.root" % (kvkt) )
ws = infile.Get( "WS%s" % (BinToPlot) )
mass = ws.var( "CMS_hgg_mass" )
allPdfs = RooArgList()
allNorms = RooArgList()
finalNorm = 0.
norms_ = {}
for signal in signals :
pdf = ws.pdf( "RV%s_mh125" % (signal) )
norm = ws.var( "RV%s_mh125_norm" % (signal) )
allPdfs.add( pdf )
allNorms.add( norm )
signals[signal]["pdf%g" % kvkt ] = pdf
signals[signal]["norm%g" % kvkt ] = norm
signals[signal]["extendedpdf%g" % kvkt ] = RooExtendPdf( "extended_%s_%g" % ( signal, kvkt ) , "extended_%s_%g" % ( signal, kvkt ) , pdf , norm )
finalNorm += norm.getValV()
norms_[signal] = norm.getValV()
signal = RooAddPdf("signal_%g" % (kvkt) , "signal_%g" % (kvkt) , allPdfs , allNorms )
AllCtOverCVs[ kvkt ]["norm"] = RooRealVar( "norm%g" % (kvkt) , "norm%g" % (kvkt) , finalNorm )
AllCtOverCVs[ kvkt ]["signalnormed"] = signal
AllCtOverCVs[ kvkt ]["signal"] = RooExtendPdf( "signal_%g_extended" % (kvkt) , "" , signal , AllCtOverCVs[ kvkt ]["norm"] )
#AllCtOverCVs[ kvkt ]["hist_norm"] = TH1D("hist_norm%g" % (kvkt) , "" , 1000 , 115 , 135 )
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 mbc_single_3s(evtfile,
mc,
setMres,
setGamma,
setR,
sp1,
sp2,
sp3,
fa,
fb,
setmd,
setp,
setxi,
setN1,
setN2,
setNbkgd1,
setNbkgd2,
title1,
title2,
epsfile,
txtfile,
ymin=0.5,
cuts=None,
err_type='SYMM',
test=False):
from ROOT import (gROOT, RooRealVar, RooCategory, RooArgSet, RooDataSet,
RooFit, RooGaussian, RooArgList, RooAddPdf,
RooSimultaneous, RooArgusBG, RooFormulaVar,
RooDLineShape, RooAbsData, RooDataHist, TCanvas, kRed,
kBlue, kGreen, kMagenta, TPaveText)
set_root_style(stat=1, grid=0)
# // sp1 = sigma of signal
# // sp2 = ratio of sigmas betwwen sigma2 sigma 1
# // sp3 = ratio of sigmas betwwen sigma3 sigma 2
# // fa, fb, - fractions
# // xi_side - slope of argus
# // p_side - power of argus
# mc = 1 Monte Carlo Model: EvtGenModels/Class/EvtVPHOtoVISR.cc
# mc = 3 Data Model: with BES 2007 paper (BES2006 lineshape hepex/0612056)
mbc = RooRealVar('mbc', 'Beam constrained mass', 1.83, 1.89, 'GeV')
ebeam = RooRealVar('ebeam', 'Ebeam', 1.8815, 1.892, 'GeV')
dflav = RooCategory('dflav', 'D flavor')
dflav.defineType('dflav', 1)
dflav.defineType('dbarflav', -1)
if cuts != None:
if 'kkmass' in cuts:
kkmass = RooRealVar('kkmass', 'KK invariant mass', 0.97, 1.90,
'GeV')
ras = RooArgSet(mbc, ebeam, kkmass, dflav)
dataset = RooDataSet.read(evtfile, ras)
elif 'kpimass' in cuts:
kpimass = RooRealVar('kpimass', 'Kpi invariant mass', 0.6, 1.4,
'GeV')
ras = RooArgSet(mbc, ebeam, kpimass, dflav)
dataset = RooDataSet.read(evtfile, ras)
else:
raise NameError(cuts)
sys.stdout.write('Using cuts: %s...' % cuts)
dataset = dataset.reduce(cuts)
sys.stdout.write(' selected %s events.\n' % dataset.numEntries())
else:
ras = RooArgSet(mbc, ebeam, dflav)
dataset = RooDataSet.read(evtfile, ras)
res = RooRealVar("datares", "datares", mc)
mres = RooRealVar("mres", "mres", setMres)
gamma = RooRealVar('gamma', 'gamma', setGamma)
r = RooRealVar('r', 'r', setR)
sigmaE = RooRealVar("sigmaE", "sigmaE", 0.0021)
sigmap1 = RooRealVar("sigmap1", "sigmap1", sp1, 0.002, 0.040)
scalep2 = RooRealVar("scalep2", "scalep2", 2.00, 1.500, 5.500)
scalep3 = RooRealVar("scalep3", "scalep3", 5.00, 3.00, 10.000)
scalep2.setVal(sp2)
scalep2.setConstant(1)
scalep3.setVal(sp3)
scalep3.setConstant(1)
as12 = RooArgList(sigmap1, scalep2)
sigmap2 = RooFormulaVar("sigmap2", "sigma2", "sigmap1*scalep2", as12)
as123 = RooArgList(sigmap1, scalep2, scalep3)
sigmap3 = RooFormulaVar("sigmap3", "sigma3", "sigmap1*scalep2*scalep3",
as123)
md = RooRealVar("md", "md", setmd, 1.863, 1.875)
f2 = RooRealVar("f2", "f2", fa)
f3 = RooRealVar("f3", "f3", fb)
al23 = RooArgList(f2, f3)
f1 = RooFormulaVar("f1", "f1", "1.0-f2-f3", al23)
# Construct signal shape
fcn1_1 = RooDLineShape("DLineshape1_1", "DLineShape1_1", 4, mbc, ebeam,
mres, gamma, r, sigmaE, sigmap1, md, res)
fcn1_2 = RooDLineShape("DLineshape1_2", "DLineShape1_2", 4, mbc, ebeam,
mres, gamma, r, sigmaE, sigmap2, md, res)
fcn1_3 = RooDLineShape("DLineshape1_3", "DLineShape1_3", 4, mbc, ebeam,
mres, gamma, r, sigmaE, sigmap3, md, res)
fcn2_1 = RooDLineShape("DLineshape2_1", "DLineShape2_1", 4, mbc, ebeam,
mres, gamma, r, sigmaE, sigmap1, md, res)
fcn2_2 = RooDLineShape("DLineshape2_2", "DLineShape2_2", 4, mbc, ebeam,
mres, gamma, r, sigmaE, sigmap2, md, res)
fcn2_3 = RooDLineShape("DLineshape2_3", "DLineShape2_3", 4, mbc, ebeam,
mres, gamma, r, sigmaE, sigmap3, md, res)
alf1_123 = RooArgList(fcn1_1, fcn1_2, fcn1_3)
af12 = RooArgList(f1, f2)
signal1_3 = RooAddPdf("signal1_3", "signal1_3", alf1_123, af12)
alf2_123 = RooArgList(fcn2_1, fcn2_2, fcn2_3)
signal2_3 = RooAddPdf("signal2_3", "signal2_3", alf2_123, af12)
p = RooRealVar("p", "p", setp, 0.1, 1.5)
xi = RooRealVar("xi", "xi", setxi, -100.0, -0.1)
Bkgd1 = RooArgusBG("argus1", "argus1", mbc, ebeam, xi, p)
Bkgd2 = RooArgusBG("argus2", "argus2", mbc, ebeam, xi, p)
shapes1 = RooArgList(signal1_3)
shapes1.add(signal1_3)
shapes1.add(Bkgd1)
shapes2 = RooArgList(signal2_3)
shapes2.add(signal2_3)
shapes2.add(Bkgd2)
N1 = RooRealVar("N1", "N1", setN1, 0.0, 200000000.0)
N2 = RooRealVar("N2", "N2", setN2, 0.0, 200000000.0)
Nbkgd1 = RooRealVar("Nbkgd1", "Nbkgd1", setNbkgd1, 0.0, 200000000.0)
Nbkgd2 = RooRealVar("Nbkgd2", "Nbkgd2", setNbkgd2, 0.0, 200000000.0)
yields1 = RooArgList(N1)
yields1.add(N1)
yields1.add(Nbkgd1)
yields2 = RooArgList(N2)
yields2.add(N2)
yields2.add(Nbkgd2)
totalPdf1 = RooAddPdf("totalPdf1", "totalPdf1", shapes1, yields1)
totalPdf2 = RooAddPdf("totalPdf2", "totalPdf2", shapes2, yields2)
totalPdf = RooSimultaneous("totalPdf", "totalPdf", dflav)
totalPdf.addPdf(totalPdf1, "dflav")
totalPdf.addPdf(totalPdf2, "dbarflav")
# Check fitTo options at:
# http://root.cern.ch/root/html512/RooAbsPdf.html#RooAbsPdf:fitTo
#
# Available fit options:
# "m" = MIGRAD only, i.e. no MINOS
# "s" = estimate step size with HESSE before starting MIGRAD
# "h" = run HESSE after MIGRAD
# "e" = Perform extended MLL fit
# "0" = Run MIGRAD with strategy MINUIT 0
# (no correlation matrix calculation at end)
# Does not apply to HESSE or MINOS, if run afterwards.
# "q" = Switch off verbose mode
# "l" = Save log file with parameter values at each MINUIT step
# "v" = Show changed parameters at each MINUIT step
# "t" = Time fit
# "r" = Save fit output in RooFitResult object
# Available optimizer options
# "c" = Cache and precalculate components of PDF that exclusively
# depend on constant parameters
# "2" = Do NLL calculation in multi-processor mode on 2 processors
# "3" = Do NLL calculation in multi-processor mode on 3 processors
# "4" = Do NLL calculation in multi-processor mode on 4 processors
MINUIT = 'ermh4'
if err_type == 'ASYM':
MINUIT = 'erh4'
if test:
sys.stdout.write('Will save epsfile as: %s \n' % epsfile)
sys.stdout.write('Will save txtfile as: %s \n' % txtfile)
return
if dataset.numEntries() == 0:
N1.setVal(0)
N2.setVal(0)
else:
# Start Fitting
fitres = totalPdf.fitTo(dataset, MINUIT)
fitres.Print('v')
# Save plots
canvas = TCanvas('canvas', 'mbc', 1200, 400)
canvas.Divide(3, 1)
canvas_1 = canvas.GetListOfPrimitives().FindObject('canvas_1')
canvas_2 = canvas.GetListOfPrimitives().FindObject('canvas_2')
canvas_1.SetLogy(1)
canvas_2.SetLogy(1)
LineColorRed = RooFit.LineColor(kRed)
LineColorBlue = RooFit.LineColor(kBlue)
LineWidth = RooFit.LineWidth(1) #0.6)
# Plot the D
canvas.cd(1)
mbcFrame = mbc.frame()
mbcFrame = mbc.frame(60)
dflav.setLabel('dflav')
ebas = RooArgSet(ebeam, dflav)
ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset)
dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dflav"))
mbcFrame.getAttMarker().SetMarkerSize(0.6)
mbcFrame.Draw()
Slice = RooFit.Slice(dflav)
ProjWData = RooFit.ProjWData(ebas, ebeamdata)
totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData)
chisq1 = mbcFrame.chiSquare() * mbcFrame.GetNbinsX()
mbcFrame.Draw()
as_bkg1 = RooArgSet(Bkgd1)
cp_bkg1 = RooFit.Components(as_bkg1)
totalPdf.plotOn(mbcFrame, cp_bkg1, Slice, LineColorBlue, LineWidth,
ProjWData)
mbcFrame.SetTitle(title1)
mbcFrame.SetMinimum(ymin)
mbcFrame.Draw()
# Plot the D bar
canvas.cd(2)
mbcFrame = mbc.frame()
mbcFrame = mbc.frame(60)
dflav.setLabel('dbarflav')
ebas = RooArgSet(ebeam, dflav)
ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset)
dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dbarflav"))
mbcFrame.getAttMarker().SetMarkerSize(0.6)
mbcFrame.Draw()
Slice = RooFit.Slice(dflav)
ProjWData = RooFit.ProjWData(ebas, ebeamdata)
totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData)
chisq2 = mbcFrame.chiSquare() * mbcFrame.GetNbinsX()
mbcFrame.Draw()
as_bkg2 = RooArgSet(Bkgd2)
cp_bkg2 = RooFit.Components(as_bkg2)
totalPdf.plotOn(mbcFrame, cp_bkg2, Slice, LineColorBlue, LineWidth,
ProjWData)
mbcFrame.SetTitle(title2)
mbcFrame.SetMinimum(ymin)
mbcFrame.Draw()
# Plot Statistics Box
canvas.cd(3)
mbcFrame = mbc.frame()
paramWin1 = totalPdf.paramOn(mbcFrame, dataset, "", 2, "NELU", 0.1, 0.9,
0.9)
mbcFrame.GetXaxis().SetLabelSize(0)
mbcFrame.GetXaxis().SetTickLength(0)
mbcFrame.GetXaxis().SetLabelSize(0)
mbcFrame.GetXaxis().SetTitle("")
mbcFrame.GetXaxis().CenterTitle()
mbcFrame.GetYaxis().SetLabelSize(0)
mbcFrame.GetYaxis().SetTitleSize(0.03)
mbcFrame.GetYaxis().SetTickLength(0)
paramWin1.getAttText().SetTextSize(0.06)
mbcFrame.Draw()
mbcFrame.SetTitle("Fit Parameters")
ATextBox = TPaveText(.1, .1, .8, .2, "BRNDC")
tempString = "#chi^{2}_{1} = %.1f, #chi^{2}_{2} = %.1f" % (chisq1, chisq2)
ATextBox.AddText(tempString)
ATextBox.SetFillColor(0)
ATextBox.SetBorderSize(1)
mbcFrame.addObject(ATextBox)
mbcFrame.Draw()
canvas.Print(epsfile)
rootfile = epsfile.replace('.eps', '.root')
canvas.Print(rootfile)
# Save fitting parameters
pars = [N1, N2, Nbkgd1, Nbkgd2, md, p, sigmap1, xi]
save_fit_result(pars, txtfile, err_type=err_type, verbose=1)
]
if pdfConfig['parameterizeKKMass'] :
numKKMassBins = pdfBuild['KKMassBinning'].numBins() if pdfConfig['parameterizeKKMass'] == 'functions'\
else pdfBuild['KKMassCat'].numTypes()
for bin in range( numKKMassBins ) :
ampPhys += [ RooRealVar( 'f_S_phys_bin%d' % bin, 'f_S_phys_bin%d' % bin, f_S, 0., 1. ) # 4 + 2*bin
, RooRealVar( 'ASPhase_phys_bin%d' % bin, 'ASPhase_phys_bin%d' % bin, deltaS, -2. * pi, 2. * pi ) # 5 + 2*bin
]
else :
ampPhys += [ RooRealVar( 'f_S_phys', 'f_S_phys', f_S, 0., 1. ) # 4
, RooRealVar( 'ASPhase_phys', 'ASPhase_phys', deltaS, -2. * pi, 2. * pi ) # 5
]
ampPhysList = RooArgList()
for amp in ampPhys : ampPhysList.add(amp)
# names of parameters in likelihood fit
ampMeasNames = [ 'AparMag2' # 0
, 'ReApar' # 1
, 'ImApar' # 2
, 'AperpMag2' # 3
, 'AperpPhase' # 4
]
if pdfConfig['parameterizeKKMass'] :
for bin in range( numKKMassBins ) :
ampMeasNames += [ 'ASOddMag2_bin%d' % bin # 5 + 2 * bin
, 'ASOddPhase_bin%d' % bin # 6 + 2 * bin
]
else :
def mbc_single_3s(evtfile, mc, setMres, setGamma, setR, sp1, sp2, sp3, fa,
fb, setmd, setp, setxi, setN1, setN2, setNbkgd1, setNbkgd2,
title1, title2, epsfile, txtfile, ymin=0.5,
cuts=None, err_type='SYMM', test=False):
from ROOT import (gROOT, RooRealVar, RooCategory, RooArgSet, RooDataSet,
RooFit, RooGaussian, RooArgList, RooAddPdf, RooSimultaneous,
RooArgusBG, RooFormulaVar, RooDLineShape, RooAbsData,
RooDataHist, TCanvas, kRed, kBlue, kGreen, kMagenta,
TPaveText)
set_root_style(stat=1, grid=0)
# // sp1 = sigma of signal
# // sp2 = ratio of sigmas betwwen sigma2 sigma 1
# // sp3 = ratio of sigmas betwwen sigma3 sigma 2
# // fa, fb, - fractions
# // xi_side - slope of argus
# // p_side - power of argus
# mc = 1 Monte Carlo Model: EvtGenModels/Class/EvtVPHOtoVISR.cc
# mc = 3 Data Model: with BES 2007 paper (BES2006 lineshape hepex/0612056)
mbc = RooRealVar('mbc', 'Beam constrained mass', 1.83, 1.89, 'GeV')
ebeam = RooRealVar('ebeam', 'Ebeam', 1.8815, 1.892, 'GeV')
dflav = RooCategory('dflav','D flavor')
dflav.defineType('dflav', 1)
dflav.defineType('dbarflav', -1)
if cuts != None:
if 'kkmass' in cuts:
kkmass = RooRealVar('kkmass', 'KK invariant mass', 0.97, 1.90, 'GeV')
ras = RooArgSet(mbc, ebeam, kkmass, dflav)
dataset = RooDataSet.read(evtfile, ras)
elif 'kpimass' in cuts:
kpimass = RooRealVar('kpimass', 'Kpi invariant mass', 0.6, 1.4, 'GeV')
ras = RooArgSet(mbc, ebeam, kpimass, dflav)
dataset = RooDataSet.read(evtfile, ras)
else:
raise NameError(cuts)
sys.stdout.write('Using cuts: %s...' %cuts)
dataset = dataset.reduce(cuts)
sys.stdout.write(' selected %s events.\n' % dataset.numEntries())
else:
ras = RooArgSet(mbc, ebeam, dflav)
dataset = RooDataSet.read(evtfile, ras)
res = RooRealVar("datares", "datares", mc)
mres = RooRealVar("mres","mres", setMres)
gamma = RooRealVar('gamma', 'gamma', setGamma)
r = RooRealVar('r', 'r', setR)
sigmaE = RooRealVar("sigmaE","sigmaE", 0.0021)
sigmap1 = RooRealVar("sigmap1","sigmap1", sp1, 0.002, 0.040)
scalep2 = RooRealVar("scalep2","scalep2",2.00,1.500,5.500)
scalep3 = RooRealVar("scalep3","scalep3",5.00,3.00,10.000)
scalep2.setVal(sp2)
scalep2.setConstant(1)
scalep3.setVal(sp3)
scalep3.setConstant(1)
as12 = RooArgList(sigmap1,scalep2)
sigmap2 = RooFormulaVar("sigmap2","sigma2","sigmap1*scalep2", as12)
as123 = RooArgList(sigmap1,scalep2,scalep3)
sigmap3 = RooFormulaVar("sigmap3","sigma3","sigmap1*scalep2*scalep3",
as123)
md = RooRealVar("md","md", setmd,1.863,1.875)
f2 = RooRealVar("f2","f2", fa)
f3 = RooRealVar("f3","f3", fb)
al23 = RooArgList(f2,f3)
f1 = RooFormulaVar("f1","f1","1.0-f2-f3", al23)
# Construct signal shape
fcn1_1 = RooDLineShape("DLineshape1_1","DLineShape1_1",4,mbc,ebeam,
mres,gamma,r,sigmaE,sigmap1,md,res)
fcn1_2 = RooDLineShape("DLineshape1_2","DLineShape1_2",4,mbc,ebeam,
mres,gamma,r,sigmaE,sigmap2,md,res)
fcn1_3 = RooDLineShape("DLineshape1_3","DLineShape1_3",4,mbc,ebeam,
mres,gamma,r,sigmaE,sigmap3,md,res)
fcn2_1 = RooDLineShape("DLineshape2_1","DLineShape2_1",4,mbc,ebeam,
mres,gamma,r,sigmaE,sigmap1,md,res)
fcn2_2 = RooDLineShape("DLineshape2_2","DLineShape2_2",4,mbc,ebeam,
mres,gamma,r,sigmaE,sigmap2,md,res)
fcn2_3 = RooDLineShape("DLineshape2_3","DLineShape2_3",4,mbc,ebeam,
mres,gamma,r,sigmaE,sigmap3,md,res)
alf1_123 = RooArgList(fcn1_1,fcn1_2,fcn1_3)
af12 = RooArgList(f1,f2)
signal1_3 = RooAddPdf("signal1_3","signal1_3", alf1_123, af12)
alf2_123 = RooArgList(fcn2_1,fcn2_2,fcn2_3)
signal2_3 = RooAddPdf("signal2_3","signal2_3", alf2_123, af12)
p = RooRealVar("p","p", setp, 0.1, 1.5)
xi= RooRealVar("xi","xi",setxi,-100.0,-0.1)
Bkgd1 = RooArgusBG("argus1","argus1",mbc,ebeam,xi,p)
Bkgd2 = RooArgusBG("argus2","argus2",mbc,ebeam,xi,p)
shapes1 = RooArgList(signal1_3)
shapes1.add(signal1_3)
shapes1.add(Bkgd1)
shapes2 = RooArgList(signal2_3)
shapes2.add(signal2_3)
shapes2.add(Bkgd2)
N1 = RooRealVar("N1","N1",setN1,0.0,200000000.0)
N2 = RooRealVar("N2","N2",setN2,0.0,200000000.0)
Nbkgd1 = RooRealVar("Nbkgd1","Nbkgd1",setNbkgd1, 0.0, 200000000.0)
Nbkgd2 = RooRealVar("Nbkgd2","Nbkgd2",setNbkgd2, 0.0, 200000000.0)
yields1 = RooArgList(N1)
yields1.add(N1)
yields1.add(Nbkgd1)
yields2 = RooArgList(N2)
yields2.add(N2)
yields2.add(Nbkgd2)
totalPdf1 = RooAddPdf("totalPdf1","totalPdf1", shapes1,yields1)
totalPdf2 = RooAddPdf("totalPdf2","totalPdf2", shapes2,yields2)
totalPdf = RooSimultaneous("totalPdf","totalPdf",dflav)
totalPdf.addPdf(totalPdf1,"dflav")
totalPdf.addPdf(totalPdf2,"dbarflav")
# Check fitTo options at:
# http://root.cern.ch/root/html512/RooAbsPdf.html#RooAbsPdf:fitTo
#
# Available fit options:
# "m" = MIGRAD only, i.e. no MINOS
# "s" = estimate step size with HESSE before starting MIGRAD
# "h" = run HESSE after MIGRAD
# "e" = Perform extended MLL fit
# "0" = Run MIGRAD with strategy MINUIT 0
# (no correlation matrix calculation at end)
# Does not apply to HESSE or MINOS, if run afterwards.
# "q" = Switch off verbose mode
# "l" = Save log file with parameter values at each MINUIT step
# "v" = Show changed parameters at each MINUIT step
# "t" = Time fit
# "r" = Save fit output in RooFitResult object
# Available optimizer options
# "c" = Cache and precalculate components of PDF that exclusively
# depend on constant parameters
# "2" = Do NLL calculation in multi-processor mode on 2 processors
# "3" = Do NLL calculation in multi-processor mode on 3 processors
# "4" = Do NLL calculation in multi-processor mode on 4 processors
MINUIT = 'ermh4'
if err_type == 'ASYM':
MINUIT = 'erh4'
if test:
sys.stdout.write('Will save epsfile as: %s \n' %epsfile)
sys.stdout.write('Will save txtfile as: %s \n' %txtfile)
return
if dataset.numEntries() == 0:
N1.setVal(0)
N2.setVal(0)
else:
# Start Fitting
fitres = totalPdf.fitTo(dataset, MINUIT)
fitres.Print('v')
# Save plots
canvas = TCanvas('canvas','mbc', 1200, 400);
canvas.Divide(3,1)
canvas_1 = canvas.GetListOfPrimitives().FindObject('canvas_1')
canvas_2 = canvas.GetListOfPrimitives().FindObject('canvas_2')
canvas_1.SetLogy(1)
canvas_2.SetLogy(1)
LineColorRed = RooFit.LineColor(kRed)
LineColorBlue = RooFit.LineColor(kBlue)
LineWidth = RooFit.LineWidth(1) #0.6)
# Plot the D
canvas.cd(1)
mbcFrame=mbc.frame()
mbcFrame=mbc.frame(60)
dflav.setLabel('dflav')
ebas = RooArgSet(ebeam, dflav)
ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset)
dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dflav"))
mbcFrame.getAttMarker().SetMarkerSize(0.6)
mbcFrame.Draw()
Slice = RooFit.Slice(dflav)
ProjWData = RooFit.ProjWData(ebas, ebeamdata)
totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData)
chisq1 = mbcFrame.chiSquare()*mbcFrame.GetNbinsX()
mbcFrame.Draw()
as_bkg1 = RooArgSet(Bkgd1)
cp_bkg1 = RooFit.Components(as_bkg1)
totalPdf.plotOn(mbcFrame, cp_bkg1, Slice, LineColorBlue, LineWidth, ProjWData)
mbcFrame.SetTitle(title1)
mbcFrame.SetMinimum(ymin)
mbcFrame.Draw()
# Plot the D bar
canvas.cd(2)
mbcFrame=mbc.frame()
mbcFrame=mbc.frame(60)
dflav.setLabel('dbarflav')
ebas = RooArgSet(ebeam, dflav)
ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset)
dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dbarflav"))
mbcFrame.getAttMarker().SetMarkerSize(0.6)
mbcFrame.Draw()
Slice = RooFit.Slice(dflav)
ProjWData = RooFit.ProjWData(ebas, ebeamdata)
totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData)
chisq2 = mbcFrame.chiSquare()*mbcFrame.GetNbinsX()
mbcFrame.Draw()
as_bkg2 = RooArgSet(Bkgd2)
cp_bkg2 = RooFit.Components(as_bkg2)
totalPdf.plotOn(mbcFrame, cp_bkg2, Slice, LineColorBlue, LineWidth, ProjWData)
mbcFrame.SetTitle(title2)
mbcFrame.SetMinimum(ymin)
mbcFrame.Draw()
# Plot Statistics Box
canvas.cd(3)
mbcFrame = mbc.frame()
paramWin1 = totalPdf.paramOn(mbcFrame,dataset, "",2,"NELU",0.1,0.9,0.9)
mbcFrame.GetXaxis().SetLabelSize(0)
mbcFrame.GetXaxis().SetTickLength(0)
mbcFrame.GetXaxis().SetLabelSize(0)
mbcFrame.GetXaxis().SetTitle("")
mbcFrame.GetXaxis().CenterTitle()
mbcFrame.GetYaxis().SetLabelSize(0)
mbcFrame.GetYaxis().SetTitleSize(0.03)
mbcFrame.GetYaxis().SetTickLength(0)
paramWin1.getAttText().SetTextSize(0.06)
mbcFrame.Draw()
mbcFrame.SetTitle("Fit Parameters")
ATextBox = TPaveText(.1, .1, .8, .2,"BRNDC")
tempString = "#chi^{2}_{1} = %.1f, #chi^{2}_{2} = %.1f" % (chisq1,chisq2)
ATextBox.AddText(tempString)
ATextBox.SetFillColor(0)
ATextBox.SetBorderSize(1)
mbcFrame.addObject(ATextBox)
mbcFrame.Draw()
canvas.Print(epsfile)
rootfile = epsfile.replace('.eps', '.root')
canvas.Print(rootfile)
# Save fitting parameters
pars = [N1, N2, Nbkgd1, Nbkgd2, md, p, sigmap1, xi]
save_fit_result(pars, txtfile, err_type=err_type, verbose=1)
knotbinning = RooBinning(time.getMin(), time.getMax(),
'{}_knotbinning'.format(mode))
for v in spline_knots:
knotbinning.addBoundary(v)
knotbinning.removeBoundary(time.getMin())
knotbinning.removeBoundary(time.getMax())
oldbinning, lo, hi = time.getBinning(), time.getMin(), time.getMax()
time.setBinning(knotbinning, '{}_knotbinning'.format(mode))
time.setBinning(oldbinning)
time.setRange(lo, hi)
del knotbinning, oldbinning, lo, hi
# knot coefficients
coefflist = RooArgList()
for i, v in enumerate(spline_coeffs):
coefflist.add(const(v))
i = len(spline_coeffs)
coefflist.add(one)
spline_knots.append(time.getMax())
spline_knots.reverse()
fudge = (spline_knots[0] - spline_knots[1]) / (spline_knots[2] - spline_knots[1])
lastmycoeffs = RooArgList()
lastmycoeffs.add(const(1. - fudge))
lastmycoeffs.add(const(fudge))
polyvar = RooPolyVar('{}_SplineAccCoeff{}'.format(mode, i), '',
coefflist.at(coefflist.getSize() - 2), lastmycoeffs)
coefflist.add(polyvar)
del i
# create the spline itself
tacc = RooCubicSplineFun('{}_SplineAcceptance'.format(mode), '', time,
pyroot_logon.cmsPrelim(c4, fitterPars.intLumi/1000)
c4.Print('H{2}_Mjj_{0}_{1}jets_Pull.pdf'.format(modeString, opts.Nj, opts.mH))
c4.Print('H{2}_Mjj_{0}_{1}jets_Pull.png'.format(modeString, opts.Nj, opts.mH))
if (TMath.Prob(chi2Raw, ndf2) < 0.05):
print '**DANGER** The fit probability is low **DANGER**'
if opts.debug:
assert(False)
#assert(False)
mass.setRange('signal', fitterPars.minTrunc, fitterPars.maxTrunc)
#yields = theFitter.makeFitter().coefList()
finalPars = fr.floatParsFinal()
yields = RooArgList(finalPars)
yields.add(fr.constPars())
sigInt = theFitter.makeFitter().createIntegral(iset,iset,'signal')
sigFullInt = theFitter.makeFitter().createIntegral(iset,iset)
print "allBkg","sigInt",sigInt.getVal(),"fullInt",sigFullInt.getVal(),\
"ratio",sigInt.getVal()/sigFullInt.getVal()
dibosonInt = theFitter.makeDibosonPdf().createIntegral(iset,iset,'signal')
dibosonFullInt = theFitter.makeDibosonPdf().createIntegral(iset,iset)
WpJPdf = theFitter.makeWpJPdf()
WpJInt = WpJPdf.createIntegral(iset, iset, 'signal')
WpJFullInt = WpJPdf.createIntegral(iset, iset)
#WpJPdf.Print("v")
print "WpJ","sigInt",WpJInt.getVal(),"fullInt",WpJFullInt.getVal(),\
"ratio",WpJInt.getVal()/WpJFullInt.getVal()
ttbarInt = theFitter.makettbarPdf().createIntegral(iset, iset, 'signal')
ttbarFullInt = theFitter.makettbarPdf().createIntegral(iset, iset)
SingleTopInt = theFitter.makeSingleTopPdf().createIntegral(iset, iset, 'signal')
def buildPolarizationPDF(ws,options):
foldname = ''
if not options.folded:
foldname=''
accMaps = TFile.Open(options.acceptanceMap)
#effMaps = TFile.Open(options.efficiencyMap)
ws.factory('lambda_theta_'+options.fitFrame+'_p[0,-1,1]')
ws.factory('lambda_phi_'+options.fitFrame+'_p[0,-1,1]')
ws.factory('lambda_thetaphi_'+options.fitFrame+'_p[0,-1,1]')
ws.factory('lambda_theta_'+options.fitFrame+'_np[0,-1,1]')
ws.factory('lambda_phi_'+options.fitFrame+'_np[0,-1,1]')
ws.factory('lambda_thetaphi_'+options.fitFrame+'_np[0,-1,1]')
ws.factory('nPromptinP[500,0,1000000]')
ws.factory('sum::nPromptinNP(1*nPromptSignal,-1*nPromptinP)')
ws.factory('nNonPromptinNP[100,0,1000000]')
ws.factory('sum::nNonPromptinP(1*nNonPromptSignal,-1*nNonPromptinNP)')
ws.factory('nBackgroundinP[50,0,1000000]')
ws.factory('sum::nBackgroundinNP(1*nBackgroundSignal,-1*nBackgroundinP)')
ws.factory('RooPolarizationConstraint::promptConstr('+
'lambda_theta_'+options.fitFrame+'_p,'+
'lambda_phi_'+options.fitFrame+'_p,'+
'lambda_thetaphi_'+options.fitFrame+'_p)')
ws.factory('RooPolarizationConstraint::nonPromptConstr('+
'lambda_theta_'+options.fitFrame+'_np,'+
'lambda_phi_'+options.fitFrame+'_np,'+
'lambda_thetaphi_'+options.fitFrame+'_np)')
#for each rap/pt cell make a unique simultaneous fit of prompt,non-prompt, background
for rap_bin in range(1,len(jpsi.pTRange)):
for pt_bin in range(len(jpsi.pTRange[rap_bin])):
accMapHist = accMaps.Get('hAcc2D_'+options.fitFrame+'_pT'+str(pt_bin+1)+'_rap'+str(rap_bin))
for effMap in options.efficiencyMap.split(','):
effMaps = TFile.Open(effMap)
effMapHist = effMaps.Get('hAcc2D_'+options.fitFrame+'_pT'+str(pt_bin+1)+'_rap'+str(rap_bin))
accMapHist.Multiply(effMapHist)
effMaps.Close()
getattr(ws,'import')(accMapHist)
accMap = RooDataHist('accMap'+options.fitFrame+'Data_'+str(rap_bin)+'_'+str(pt_bin+1),
'acceptance map',
RooArgList(ws.var('costh_'+options.fitFrame+foldname),ws.var('phi_'+options.fitFrame+foldname)),
ROOT.RooFit.Import(accMapHist,False))
getattr(ws,'import')(accMap)
accMapFunc = RooHistFunc('accMapFunc'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1),
'acceptance map',
RooArgSet(ws.var('costh_'+options.fitFrame+foldname),ws.var('phi_'+options.fitFrame+foldname)),
ws.data('accMap'+options.fitFrame+'Data_'+str(rap_bin)+'_'+str(pt_bin+1)),1)
getattr(ws,'import')(accMapFunc)
#make a *real* hist pdf :-)
ws.factory('RooGenericPdf::accMap'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+
'("@0",{accMapFunc'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+'})')
#create datahist for L and R sidebands
getattr(ws,'import')(accMap.Clone('bkgShape'+options.fitFrame+'DataL_'+str(rap_bin)+'_'+str(pt_bin+1)))
getattr(ws,'import')(accMap.Clone('bkgShape'+options.fitFrame+'DataR_'+str(rap_bin)+'_'+str(pt_bin+1)))
ws.data('bkgShape'+options.fitFrame+'DataL_'+str(rap_bin)+'_'+str(pt_bin+1)).reset()
ws.data('bkgShape'+options.fitFrame+'DataR_'+str(rap_bin)+'_'+str(pt_bin+1)).reset()
#fill them
ws.data('bkgShape'+options.fitFrame+'DataL_'+str(rap_bin)+'_'+str(pt_bin+1)).add(ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)),
'massRegion == massRegion::leftMassSideBand')
ws.data('bkgShape'+options.fitFrame+'DataR_'+str(rap_bin)+'_'+str(pt_bin+1)).add(ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)),
'massRegion == massRegion::rightMassSideBand')
#make histpdfs and combination
ws.factory('RooHistPdf::bkgShape'+options.fitFrame+'L_'+str(rap_bin)+'_'+str(pt_bin+1)+
'({costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+'},'+
'bkgShape'+options.fitFrame+'DataL_'+str(rap_bin)+'_'+str(pt_bin+1)+')')
ws.factory('RooHistPdf::bkgShape'+options.fitFrame+'R_'+str(rap_bin)+'_'+str(pt_bin+1)+
'({costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+'},'+
'bkgShape'+options.fitFrame+'DataR_'+str(rap_bin)+'_'+str(pt_bin+1)+')')
ws.factory('SUM::bkgShape'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(fBkgLR*bkgShape'+options.fitFrame+'L_'+str(rap_bin)+'_'+str(pt_bin+1)+
',bkgShape'+options.fitFrame+'R_'+str(rap_bin)+'_'+str(pt_bin+1)+')')
#test new polarization pdf
ws.factory('RooPolarizationPdf::basePolPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+
',lambda_theta_'+options.fitFrame+'_p,lambda_phi_'+options.fitFrame+'_p,lambda_thetaphi_'+options.fitFrame+'_p)')
ws.factory('RooPolarizationPdf::basePolPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+
',lambda_theta_'+options.fitFrame+'_np,lambda_phi_'+options.fitFrame+'_np,lambda_thetaphi_'+options.fitFrame+'_np)')
#should add back *(3+@2) ?
#sin(2theta) = 2sin(theta)cos(theta) = 2*sqrt(1 - cos(theta)*cos(theta))*cos(theta)
#ws.factory('RooGenericPdf::basePolPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+
# '("1+@2*pow(@0,2.)+@3*(1-pow(@0,2.))*cos(2*@1*pi/180)+@4*sin(2*acos(@0))*cos(@1*pi/180)"'+
# ',{costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+',lambda_theta_'+options.fitFrame+
# '_p,lambda_phi_'+options.fitFrame+'_p,lambda_thetaphi_'+options.fitFrame+'_p})')
#ws.factory('RooGenericPdf::basePolPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+
# '("1+@2*@0*@0+@3*(1-@0*@0)*cos(2*@1*pi/180)+@4*sin(2*acos(@0))*cos(@1*pi/180)"'+
# ',{costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+',lambda_theta_'+options.fitFrame+
# '_np,lambda_phi_'+options.fitFrame+'_np,lambda_thetaphi_'+options.fitFrame+'_np})')
ws.factory('PROD::polPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)
+'(basePolPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)
+',accMap'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+')')
ws.factory('PROD::polPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)
+'(basePolPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)
+',accMap'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+')')
ws.factory('RooExtendPdf::promptPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(polPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+',nPromptinP)')
ws.factory('RooExtendPdf::promptPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(polPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+',nPromptinNP)')
ws.factory('RooExtendPdf::nonPromptPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(polPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+',nNonPromptinNP)')
ws.factory('RooExtendPdf::nonPromptPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(polPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+',nNonPromptinP)')
ws.factory('RooExtendPdf::bkgPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(bkgShape'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',nBackgroundinP)')
ws.factory('RooExtendPdf::bkgPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+
'(bkgShape'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',nBackgroundinNP)')
promptPOLArgList = RooArgList(ws.pdf('promptPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)))
nonPromptPOLArgList = RooArgList(ws.pdf('promptPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)),
ws.pdf('nonPromptPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))
)
if options.doNonPrompt:
promptPOLArgList.add(ws.pdf('nonPromptPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)))
if options.doBackground:
promptPOLArgList.add(ws.pdf('bkgPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)))
nonPromptPOLArgList.add(ws.pdf('bkgPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)))
promptP = RooAddPdf('promptPol'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1),
'prompt',
promptPOLArgList
)
nonpromptP = RooAddPdf('nonpromptPol'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1),
'nonprompt',
nonPromptPOLArgList
)
getattr(ws,'import')(promptP)
getattr(ws,'import')(nonpromptP)
polConfig = 'SIMUL::PPdf'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+'(mlRegion,'
if options.doPrompt:
polConfig += 'promptSignal=promptPol'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+','
if options.doNonPrompt:
polConfig += 'nonPromptSignal=nonpromptPol'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+','
#if options.doBackground:
# polConfig += ('prompt;leftMassSideBand=bkgPolExtL'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+','
# 'prompt;rightMassSideBand=bkgPolExtR'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))
# polConfig += ('nonPrompt;leftMassSideBand=bkgPolExtL'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+','
# 'nonPrompt;rightMassSideBand=bkgPolExtR'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))
polConfig += ')'
#simultaneous
ws.factory(polConfig)
accMaps.Close()
def findOnePe(hist, ws, name='x', Npe=1):
fitPed(hist, ws, name)
x = ws.var(name)
ped = ws.pdf('ped')
pedWidth = ws.var('pedWidth')
pdfs = RooArgList(ped)
pdfList = []
fped = RooRealVar('fped', 'f_{ped}', 0.8, 0., 1.)
fractions = RooArgList(fped)
fList = []
peList = []
peMean = RooRealVar('peMean', 'mean_{pe}', 6., 0., 20.)
peWidth = RooRealVar('peWidth', 'width_{pe}', pedWidth.getVal(), 0., 10.)
for i in range(0, Npe):
pem = RooFormulaVar('pem{0}'.format(i + 1), '@0+{0}*@1'.format(i + 1),
RooArgList(ws.var('pedMean'), peMean))
peList.append(pem)
npepdf = RooGaussian('pe{0}pdf'.format(i + 1),
'pe{0}pdf'.format(i + 1), x, pem, pedWidth)
pdfs.add(npepdf)
pdfList.append(npepdf)
fnpe = RooRealVar('fpe{0}'.format(i + 1), 'fpe{0}'.format(i + 1), 0.5,
-0.1, 1.0)
fractions.add(fnpe)
fList.append(fnpe)
#bgMean = RooRealVar("bgMean", "bgMean", 6.0, x.getMin(), x.getMax())
bgScale = RooRealVar("bgScale", "bgScale", 0.5, -1.0, Npe + 1.0)
bgMean = RooFormulaVar("bgMean", "@1+@0*@2",
RooArgList(peMean, ws.var('pedMean'), bgScale))
bgWidthL = RooRealVar("bgWidthL", "bgWidthL",
pedWidth.getVal() * 2, 0., 25.)
bgWidthR = RooRealVar("bgWidthR", "bgWidthR",
pedWidth.getVal() * 7, 0., 25.)
bgGauss = RooBifurGauss("bgGauss", "bgGauss", x, bgMean, bgWidthR,
bgWidthR)
if (Npe > 1):
pdfs.add(bgGauss)
else:
fractions.remove(fractions.at(fractions.getSize() - 1))
## pem = RooFormulaVar('pem', '@0+@1', RooArgList(peMean, ws.var('pedMean')))
## firstPe = RooGaussian('firstPe', 'firstPe', x, pem, peWidth)
## pdfs.Print("v")
## fractions.Print("v")
pedPlusOne = RooAddPdf('pedPlusOne', 'pedPlusOne', pdfs, fractions, True)
## pedWidth = ped.GetParameter(2)
## pedMean = ped.GetParameter(1)
## pedA = ped.GetParameter(0)
secondMax = hist.GetMaximumBin() + 1
goingDown = True
maxVal = hist.GetBinContent(secondMax)
foundMax = False
while (not foundMax) and (secondMax < hist.GetNbinsX()):
tmpVal = hist.GetBinContent(secondMax + 1)
if (tmpVal < maxVal):
if not goingDown:
foundMax = True
else:
goingDown = True
maxVal = tmpVal
secondMax += 1
elif (tmpVal > maxVal):
goingDown = False
maxVal = tmpVal
secondMax += 1
else:
maxVal = tmpVal
secondMax += 1
secondMaxx = hist.GetBinCenter(secondMax)
print 'found 2nd maximum in bin', secondMax, 'value', secondMaxx
## peMean.setVal(secondMaxx)
## bgMean.setVal(secondMaxx*0.6)
x.setRange('pedPlus_fit', x.getMin(),
ws.var('pedMean').getVal() + pedWidth.getVal() * 6. * (Npe + 0))
pedPlusOne.fitTo(ws.data('ds'), RooFit.Minos(False),
RooFit.Range('pedPlus_fit'), RooFit.PrintLevel(1))
getattr(ws, 'import')(pedPlusOne)
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 getFrame(cat, obsData, simPdf, mc, fit_res, error_band_strategy=1, compute_yields=False):
"""
Build a frame with the different fit components and their uncertainties
Parameters
----------
cat : RooCategory
Category of the simultaneous PDF we are interested in
obsData: RooDataHist object (either real data or asimov or PE)
simPdf : RooSimultaneous PDF
mc : ModelConfig object
fit_res: RooFitResult
Result of the fit (covariance matrix, NLL value, ...)
error_band_strategy : True/False
True: Use the linear approximation to extract the error band
False: Use a sampling method
See http://root.cern.ch/root/html/RooAbsReal.html#RooAbsReal:plotOnWithErrorBand
verbose: True/False
TODO: implement a more generic way to retrieve the binning.
Currently it has to be put in the workspace with the name binWidth_obs_x_{channel}_0
"""
hlist = []
if compute_yields:
yields = {}
# --> Get the total (signal+bkg) model pdf
pdftmp = simPdf.getPdf(cat.GetName())
if not pdftmp:
raise RuntimeError('Could not retrieve the total pdf ')
# --> Get the list of observables
obstmp = pdftmp.getObservables(mc.GetObservables())
if not obstmp:
raise RuntimeError('Could not retrieve the list of observable')
# --> Get the first (and only) observable (mmc mass for cut based)
obs = obstmp.first()
log.info('Observable: {0}'.format(obs.GetName()))
# --> Get the RooDataHist of the given category
datatmp = obsData.reduce("{0}=={1}::{2}".format(simPdf.indexCat().GetName(), simPdf.indexCat().GetName(), cat.GetName()))
datatmp.__class__=ROOT.RooAbsData # --> Ugly fix !!!
# --> Get the binning width of the category (stored as a workspace variable)
binWidth = pdftmp.getVariables().find('binWidth_obs_x_{0}_0'.format(cat.GetName()))
if not binWidth:
raise RuntimeError('Could not retrieve the binWidth')
# --> parameter of interest (mu=sigma/sigma_sm)
poi = mc.GetParametersOfInterest().first()
poi_fitted_val = poi.getVal()
log.info('POI: {0} = {1} +/- {2}'.format(poi.GetName(), poi.getVal(), poi.getError()))
# --> Create the data histogram
hist_data = asrootpy(datatmp.createHistogram("hdata_"+cat.GetName(), obs))
hist_data.name = "hdata_{0}".format(cat.GetName())
hist_data.title = ""
hlist.append(hist_data)
#--> compute the data yields
if compute_yields:
Yield_data = hist_data.Integral()
yields['Data'] = (Yield_data, 0)
# --> Create the frame structure from the observable
frame = obs.frame()
frame.SetName(cat.GetName())
datatmp.plotOn(frame,
ROOT.RooFit.DataError(ROOT.RooAbsData.Poisson),
ROOT.RooFit.Name("Data"),
ROOT.RooFit.MarkerSize(1))
# --> Create the signal histogram template
hist_sig = hist_data.Clone('h_TotalSignal_{0}'.format(cat.GetName()))
hist_sig.Reset()
signal_comps = RooArgList()
bkg_comps = RooArgList()
# --> get the list of components (hadhad HSG4: QCD,Other,Ztautau, Signal_Z, Signal_W, Signal_gg, Signal_VBF)
# --> and iterate over
pdfmodel = pdftmp.getComponents().find(cat.GetName()+'_model')
funcListIter = pdfmodel.funcList().iterator()
while True:
comp = funcListIter.Next()
if not comp:
break
name = comp.GetName().replace('L_x_', '').split('_')[0]
log.info('Scan component {0}'.format(comp.GetName()))
hist_comp = asrootpy(comp.createHistogram(cat.GetName()+"_"+comp.GetName(), obs, ROOT.RooFit.Extended(False)))
hist_comp.name = 'h_{0}_{1}'.format(name, cat.GetName())
hist_comp.title = ''
hlist.append(hist_comp)
if 'Signal' in comp.GetName():
signal_comps.add(comp)
hist_sig.Add(hist_comp)
else:
bkg_comps.add(comp)
Integral_comp = comp.createIntegral(RooArgSet(obs))
Yield_comp = Integral_comp.getVal() * binWidth.getVal()
log.info('Integral = {0}'.format(Yield_comp))
# if Yield_comp==0:
# raise RuntimeError('Yield integral is wrong !!')
# --> Add the components to the frame but in an invisible way
pdfmodel.plotOn(frame,
ROOT.RooFit.Components(comp.GetName()),
ROOT.RooFit.Normalization(Yield_comp, ROOT.RooAbsReal.NumEvent),
ROOT.RooFit.Name("NoStacked_"+comp.GetName()),
ROOT.RooFit.Invisible())
if fit_res:
# --> Add the components uncertainty band
comp.plotOn(frame,
ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected),
ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy),
ROOT.RooFit.Name("FitError_AfterFit_"+comp.GetName()),
ROOT.RooFit.Invisible())
if compute_yields:
if Yield_comp==0:
Yield_comp_err=0.
else:
Yield_comp_err = Integral_comp.getPropagatedError(fit_res)* binWidth.getVal()
yields[comp.GetName()] = (Yield_comp, Yield_comp_err)
hlist.append(hist_sig)
# --> total signal yields
if compute_yields:
signal_tot_comp = RooAddition('pdf_sum_sig', 'pdf_sum_sig', signal_comps)
Integral_signal = signal_tot_comp.createIntegral(RooArgSet(obs))
yields_sig_tot = Integral_signal.getVal()*binWidth.getVal()
yields_sig_tot_err = Integral_signal.getPropagatedError(fit_res)* binWidth.getVal()
yields['TotalSignal'] = (yields_sig_tot, yields_sig_tot_err)
bkg_tot_comp = RooAddition('pdf_sum_bkg', 'pdf_sum_bkg', bkg_comps)
Integral_bkg = bkg_tot_comp.createIntegral(RooArgSet(obs))
yields_bkg_tot = Integral_bkg.getVal()*binWidth.getVal()
yields_bkg_tot_err = Integral_bkg.getPropagatedError(fit_res)* binWidth.getVal()
yields['bkg'] = (yields_bkg_tot, yields_bkg_tot_err)
log.info('Bkg Total Yield: {0}'.format(yields_bkg_tot))
# --> bkg+signal PDF central value and error
Integral_total = pdfmodel.createIntegral(RooArgSet(obs))
Yield_total = Integral_total.getVal() * binWidth.getVal()
log.info('Postfit Total Yield: {0}'.format(Yield_total))
hist_bkg_plus_sig = asrootpy(pdfmodel.createHistogram("hbkg_plus_sig_"+cat.GetName(), obs, ROOT.RooFit.Extended(False)))
hist_bkg_plus_sig.name = 'hbkg_plus_sig_'+cat.GetName()
hist_bkg_plus_sig.title = ''
hist_bkg_plus_sig.Scale(Yield_total)
hlist.append(hist_bkg_plus_sig)
# --> Add the components to the frame but in an invisible way
pdftmp.plotOn(frame,
ROOT.RooFit.Normalization(Yield_total, ROOT.RooAbsReal.NumEvent),
ROOT.RooFit.Name("Bkg_plus_sig"))
if fit_res:
pdftmp.plotOn(frame,
ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy),
ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected),
ROOT.RooFit.Name("FitError_AfterFit"),
ROOT.RooFit.FillColor(ROOT.kOrange),
ROOT.RooFit.LineWidth(2),
ROOT.RooFit.LineColor(ROOT.kBlue))
# --> bkg only PDF central value and error
poi.setVal(0.)
Integral_bkg_total = pdfmodel.createIntegral(RooArgSet(obs))
Yield_bkg_total = Integral_bkg_total.getVal() * binWidth.getVal()
hist_bkg = pdfmodel.createHistogram("hbkg_"+cat.GetName(), obs, ROOT.RooFit.Extended(False))
hist_bkg.Scale(Yield_bkg_total)
hist_bkg.SetName("hbkg_"+cat.GetName())
hist_bkg.SetTitle("")
hlist.append(hist_bkg)
pdftmp.plotOn(frame,
ROOT.RooFit.Normalization(Yield_bkg_total, ROOT.RooAbsReal.NumEvent),
ROOT.RooFit.Name("Bkg"),
ROOT.RooFit.LineStyle(ROOT.kDashed))
if fit_res:
pdftmp.plotOn(frame,
ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy),
ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected),
ROOT.RooFit.Name("FitError_AfterFit_Mu0"),
ROOT.RooFit.FillColor(ROOT.kOrange),
ROOT.RooFit.LineWidth(2),
ROOT.RooFit.LineColor(ROOT.kBlue))
#if compute_yields:
# Yield_bkg_total_err = Integral_bkg_total.getPropagatedError(fit_res)*binWidth.getVal()
# yields['bkg'] = (Yield_bkg_total, Yield_bkg_total_err)
poi.setVal(poi_fitted_val)
if compute_yields:
return frame, hlist, yields
else:
return frame, hlist
