def _preFitSteps(self):
"""Prefit uncorrelated term"""
args = self.pdf.getParameters(self.data)
FitDBPlayer.initFromDB(self.process.dbplayer.odbfile, args)
self.ToggleConstVar(args, isConst=True)
# Disable xTerm correction and fit to 1-D
args.find('hasXTerm').setVal(0)
h_accXrec_fine_ProjectionX = self.process.sourcemanager.get(
self.cfg['dataX'])
h_accXrec_fine_ProjectionY = self.process.sourcemanager.get(
self.cfg['dataY'])
effi_cosl = self.process.sourcemanager.get(self.cfg['pdfX'])
effi_cosK = self.process.sourcemanager.get(self.cfg['pdfY'])
for proj, pdf, var, argPats in [
(h_accXrec_fine_ProjectionX, effi_cosl, CosThetaL, [r"^l\d+$"]),
(h_accXrec_fine_ProjectionY, effi_cosK, CosThetaK, [r"^k\d+$"])
]:
hdata = ROOT.RooDataHist("hdata", "", ROOT.RooArgList(var),
ROOT.RooFit.Import(proj))
self.ToggleConstVar(args, isConst=False, targetArgs=argPats)
pdf.chi2FitTo(hdata, ROOT.RooLinkedList())
self.ToggleConstVar(args, isConst=True, targetArgs=argPats)
args.find('effi_norm').setConstant(False)
self.pdf.chi2FitTo(self.data, ROOT.RooFit.Minos(True))
args.find('effi_norm').setVal(args.find('effi_norm').getVal() / 4.)
args.find('effi_norm').setConstant(True)
# Fix uncorrelated term and for later update with xTerms in main fit step
args.find('hasXTerm').setVal(1)
self.ToggleConstVar(args, isConst=False, targetArgs=[r"^x\d+$"])
def initPdfPlotCfg(self, p):
""" [Name, plotOnOpt, argAliasInDB, LegendName] """
pdfPlotTemplate = ["", plotterCfg_styles['allStyle'], None, None]
p = p + pdfPlotTemplate[len(p):]
if isinstance(p[0], str):
self.logger.logDEBUG("Initialize pdfPlot {0}".format(p[0]))
p[0] = self.process.sourcemanager.get(p[0])
if p[0] == None:
errorMsg = "pdfPlot not found in source manager."
self.logger.logERROR(errorMsg)
raise RuntimeError("pdfPlot not found in source manager.")
args = p[0].getParameters(
ROOT.RooArgSet(Bmass, CosThetaK, CosThetaL, Mumumass, Phimass))
if not self.process.cfg['args'].Function_name in ['submit', 'run']:
FitterCore.ArgLooper(args, lambda p: p.Print())
if type(
p[2]
) is str: # In case ArgAlias is to be defined with string at the end for all args
tag = p[2]
p[2] = {}
arglist = []
FitterCore.ArgLooper(args, lambda p: arglist.append(p.GetName()))
for var in arglist:
p[2].update({var: var + tag})
if self.process.cfg['args'].NoFit:
self.process.cfg['args'].NoImport = True
if (not self.process.cfg['args'].NoImport):
FitDBPlayer.initFromDB(self.process.dbplayer.odbfile, args, p[2])
if not self.process.cfg['args'].Function_name in ['submit']:
FitterCore.ArgLooper(args, lambda p: p.Print())
return p
def wrapped_f(self):
self.pdf = self.process.sourcemanager.get(self.cfg['pdf'])
self.argset = self.cfg['argset']
self.params = self.pdf.getParameters(self.argset)
FitDBPlayer.initFromDB(self.cfg['db'].format(binLabel=q2bins[self.process.cfg['binKey']]['label']), self.params, self.cfg.get('argAliasInDB', []))
func(self)
def _preFitSteps_initFromDB(self):
"""Initialize from DB"""
if not self.process.cfg['args'].NoImport:
#FitDBPlayer.initFromDB(self.process.dbplayer.odbfile, self.args, self.cfg['argAliasInDB'], exclude=['nBkgComb', 'nSig', 'nBkgPeak', 'PeakFrac', 'unboundFl', 'unboundAfb'])
FitDBPlayer.initFromDB(self.process.dbplayer.odbfile, self.args,
self.cfg['argAliasInDB'])
self.ToggleConstVar(self.args, True)
self.ToggleConstVar(self.args, False, self.cfg.get('argPattern'))
def wrapped_f(self):
func(self)
targetParams = ROOT.RooArgSet()
def setParamsToFluc(arg):
if arg.GetName() in parList:
targetParams.add(arg)
FitterCore.ArgLooper(self.params, setParamsToFluc)
FitDBPlayer.fluctuateFromDB(self.cfg['db'].format(binLabel=q2bins[self.process.cfg['binKey']]['label']), targetParams, self.cfg.get('argAliasInDB', []))
def wrapped_f(self, expYield, Year):
self.pdf = self.process.sourcemanager.get(self.cfg['pdf'])
self.argset = self.cfg['argset']
self.params = self.pdf.getParameters(self.argset)
dbfile = os.path.join(
self.process.cwd, "plots_{0}".format(Year), self.cfg['db'].format(
binLabel=q2bins[self.process.cfg['binKey']]['label']))
FitDBPlayer.initFromDB(dbfile, self.params,
self.cfg.get('argAliasInDB', []))
func(self, expYield, Year)
def _postFitSteps(self):
"""Post-processing"""
# FitterCore.ArgLooper(self.args, lambda arg: arg.Print())
self.ToggleConstVar(self.args, True)
if self.cfg['saveToDB']:
FitDBPlayer.UpdateToDB(
self.process.dbplayer.odbfile, self.args,
self.cfg['argAliasInDB']
if self.cfg['argAliasSaveToDB'] else None)
FitDBPlayer.UpdateToDB(self.process.dbplayer.odbfile,
self.fitResult)
def preFitSteps_randEffi(self):
self.args = self.pdf.getParameters(self.data)
self._preFitSteps_initFromDB()
# Fluctuate cross-term correction
effiArgs = ROOT.RooArgSet()
FitterCore.ArgLooper(self.args, lambda iArg: effiArgs.add(iArg), targetArgs=[r"x\d{1,2}"])
FitDBPlayer.fluctuateFromDB(self.process.dbplayer.odbfile, effiArgs, self.cfg['argAliasInDB'])
self._preFitSteps_vetoSmallFs()
self._preFitSteps_preFit()
def initPdfPlotCfg(self, p):
""" [Name, plotOnOpt, argAliasInDB, LegendName] """
pdfPlotTemplate = ["", plotterCfg_allStyle, None, None]
p = p + pdfPlotTemplate[len(p):]
if isinstance(p[0], str):
self.logger.logDEBUG("Initialize pdfPlot {0}".format(p[0]))
p[0] = self.process.sourcemanager.get(p[0])
if p[0] == None:
self.logger.logERROR("pdfPlot not found in source manager.")
raise RuntimeError
args = p[0].getParameters(
ROOT.RooArgSet(Bmass, CosThetaK, CosThetaL, Mumumass, Phimass))
FitDBPlayer.initFromDB(self.process.dbplayer.odbfile, args, p[2])
return p
def func_simMismodel(args):
p.setSequence([])
try:
p.beginSeq()
db = shelve.open(p.dbplayer.odbfile)
fl_GEN = unboundFlToFl(db['unboundFl_GEN']['getVal'])
fl_RECO = unboundFlToFl(db['unboundFl_RECO']['getVal'])
afb_GEN = unboundAfbToAfb(db['unboundAfb_GEN']['getVal'], fl_GEN)
afb_RECO = unboundAfbToAfb(db['unboundAfb_RECO']['getVal'], fl_RECO)
db.close()
syst_simMismodel = {
'syst_simMismodel_fl': {
'getError': math.fabs(fl_GEN - fl_RECO),
'getErrorHi': math.fabs(fl_GEN - fl_RECO),
'getErrorLo': -math.fabs(fl_GEN - fl_RECO),
},
'syst_simMismodel_afb': {
'getError': math.fabs(afb_GEN - afb_RECO),
'getErrorHi': math.fabs(afb_GEN - afb_RECO),
'getErrorLo': -math.fabs(afb_GEN - afb_RECO),
}
}
print(syst_simMismodel)
if args.updateDB:
FitDBPlayer.UpdateToDB(p.dbplayer.odbfile, syst_simMismodel)
finally:
p.endSeq()
def _preFitSteps(self):
"""Rename parameter names and import values from database"""
for pdf, data, Year in zip(self.pdf, self.data, self.Years):
args = pdf.getParameters(
ROOT.RooArgSet(CosThetaK, CosThetaL, Bmass))
odbfile = os.path.join(self.process.cwd, "plots_{0}".format(Year),
self.process.dbplayer.odbfile)
if not self.process.cfg['args'].NoImport:
FitDBPlayer.initFromDB(odbfile,
args,
aliasDict=self.cfg['argAliasInDB'])
self.ToggleConstVar(args, True)
self.ToggleConstVar(args, False, self.cfg['argPattern'])
# Rename parameter names
FitterCore.ArgLooper(
args,
lambda p: p.SetName(p.GetName() + "_{0}".format(Year)),
targetArgs=self.cfg['argPattern'],
inverseSel=True)
def GetPDFlist(binkey):
from BsToPhiMuMuFitter.FitDBPlayer import FitDBPlayer
cwd = os.getcwd()
os.chdir("../input/")
mfile = "wspace_{}_{}.root".format(args.Year, binkey)
ifile = ROOT.TFile.Open(mfile, 'READ')
wspace = ifile.Get("wspace.{}.{}".format(args.Year, binkey))
pdf = {
'pdfL': wspace.obj("effi_cosl"),
'pdfK': wspace.obj("effi_cosK"),
'pdfL_ts': wspace.obj("effi_cosl_ts"),
'pdfK_ts': wspace.obj("effi_cosK_ts")
}
os.chdir(cwd)
os.chdir('../plots_{}/'.format(args.Year))
odbfile = 'fitResults_{}.db'.format(binkey)
for key in pdf.keys():
arguments = pdf[key].getParameters(ROOT.RooArgSet(
CosThetaL, CosThetaK))
FitDBPlayer.initFromDB(odbfile, arguments)
os.chdir(cwd)
return pdf
def beginSeq_registerServices(self):
"""Initialize all services."""
if not 'dbplayer' in self._services.keys():
dbplayer = FitDBPlayer(
absInputDir=os.path.join(modulePath, self.work_dir))
self.addService("dbplayer", dbplayer)
self.addService('logger', Logger("runtime.log", 999))
self.addService('filemanager', FileManager())
self.addService('sourcemanager', SourceManager())
for seq_obj in self._sequence:
if seq_obj.logger is None: setattr(seq_obj, "logger", self.logger)
for key, s in self._services.items():
setattr(s, "process", self)
if s.logger is None:
setattr(s, "logger", self.logger)
s._beginSeq()
def updateToDB_altShape(args, tag):
""" Template db entry maker for syst """
db = shelve.open(p.dbplayer.odbfile)
nominal_fl = unboundFlToFl(db['unboundFl']['getVal'])
nominal_afb = unboundAfbToAfb(db['unboundAfb']['getVal'], nominal_fl)
db.close()
afb = p.sourcemanager.get('afb').getVal()
fl = p.sourcemanager.get('fl').getVal()
syst_altShape = {}
syst_altShape['syst_{0}_afb'.format(tag)] = {
'getError': math.fabs(afb - nominal_afb),
'getErrorHi': math.fabs(afb - nominal_afb),
'getErrorLo': -1 * math.fabs(afb - nominal_afb),
}
syst_altShape['syst_{0}_fl'.format(tag)] = {
'getError': math.fabs(fl - nominal_fl),
'getErrorHi': math.fabs(fl - nominal_fl),
'getErrorLo': -1 * math.fabs(fl - nominal_fl),
}
print(syst_altShape)
if args.updateDB:
FitDBPlayer.UpdateToDB(p.dbplayer.odbfile, syst_altShape)
def func_postproc(args):
""" Fit to fit result and make plots """
GenResult = []
RecoResult = []
os.chdir(args.wrapper.task_dir)
args.process.addService(
"dbplayer",
FitDBPlayer(absInputDir=os.path.join(modulePath, "plots_{}".format(
args.Year))))
binKeys = args.process.cfg['allBins'] if args.process.cfg[
'args'].forall else args.process.cfg[
'bins'] #Run over all bins if no binkey arg is supplied
for binKey in binKeys:
ifilename = "setSummary_{}_{}.root".format(
"Simult" if args.SimFit else args.Year, q2bins[binKey]['label'])
if not os.path.exists(ifilename) or args.forceHadd:
call(["hadd", "-f", ifilename] +
glob.glob('*/setSummary_{}_{}.root'.format(
"Simult" if args.SimFit else args.Year, q2bins[binKey]
['label'])))
ifile = ROOT.TFile(ifilename)
tree = ifile.Get("tree")
binWidth = 0.01
h_setSummary_afb = ROOT.TH1F("h_setSummary_afb", "",
int(1.5 / binWidth), -0.75, 0.75)
h_setSummary_fl = ROOT.TH1F("h_setSummary_fl", "", int(1. / binWidth),
0., 1.)
tree.Draw("afb>>h_setSummary_afb", "status==0")
tree.Draw("fl>>h_setSummary_fl", "status==0")
f_setSummary_afb = ROOT.TF1("f_setSummary_afb", "gaus",
-0.75 + binWidth, 0.75 - binWidth)
#f_setSummary_afb.SetLineColor(ROOT.kBlue)
h_setSummary_afb.Fit("f_setSummary_afb")
h_setSummary_afb.GetFunction("f_setSummary_afb").SetLineColor(4)
f_setSummary_fl = ROOT.TF1("f_setSummary_fl", "gaus", binWidth,
1 - binWidth)
#f_setSummary_fl.SetLineColor(ROOT.kBlue)
h_setSummary_fl.Fit("f_setSummary_fl")
h_setSummary_fl.GetFunction("f_setSummary_fl").SetLineColor(4)
# Draw
db = shelve.open(
os.path.join(args.process.dbplayer.absInputDir,
"fitResults_{0}.db".format(q2bins[binKey]['label'])),
'r')
fl_GEN = StdFitter.unboundFlToFl(db['unboundFl_GEN']['getVal'])
afb_GEN = StdFitter.unboundAfbToAfb(db['unboundAfb_GEN']['getVal'],
fl_GEN)
line = ROOT.TLine()
line.SetLineWidth(2)
line.SetLineColor(2)
line.SetLineStyle(9)
plotCollection.Plotter.canvas.cd()
h_setSummary_afb.SetXTitle("A_{6}")
h_setSummary_afb.SetYTitle("Number of test samples")
h_setSummary_afb.SetFillColor(ROOT.kGreen - 10)
h_setSummary_afb.GetYaxis().SetRangeUser(
0., 1.5 * h_setSummary_afb.GetMaximum())
h_setSummary_afb.Draw()
GetParams(f_setSummary_afb, h_setSummary_afb, binKey, afb_GEN, "a6")
if args.drawGEN:
line.DrawLine(afb_GEN, 0, afb_GEN, h_setSummary_afb.GetMaximum())
plotCollection.Plotter.latexDataMarks(['sim'])
plotCollection.Plotter.canvas.Print(
"h_setSummary_sigMCValidation_a6_{}_{}.pdf".format(
"Simult" if args.SimFit else args.Year,
q2bins[binKey]['label']))
h_setSummary_fl.SetXTitle("F_{L}")
h_setSummary_fl.SetYTitle("Number of test samples")
h_setSummary_fl.SetFillColor(ROOT.kGreen - 10)
h_setSummary_fl.GetYaxis().SetRangeUser(
0., 1.5 * h_setSummary_fl.GetMaximum())
h_setSummary_fl.Draw()
GetParams(f_setSummary_fl, h_setSummary_fl, binKey, fl_GEN, "fl")
if args.drawGEN:
line.DrawLine(fl_GEN, 0, fl_GEN, h_setSummary_fl.GetMaximum())
plotCollection.Plotter.latexDataMarks(['sim'])
plotCollection.Plotter.canvas.Print(
"h_setSummary_sigMCValidation_fl_{}_{}.pdf".format(
"Simult" if args.SimFit else args.Year,
q2bins[binKey]['label']))
Fl_GENErr = abs(
StdFitter.unboundFlToFl(db['unboundFl_GEN']['getVal'] +
db['unboundFl_GEN']['getError']) - fl_GEN)
A6_GENErr = abs(
StdFitter.unboundAfbToAfb(
db['unboundAfb_GEN']['getVal'] +
db['unboundAfb_GEN']['getError'], fl_GEN) - afb_GEN)
GenResult.append((fl_GEN, Fl_GENErr, afb_GEN, A6_GENErr))
RecoResult.append(
(f_setSummary_fl.GetParameter(1), f_setSummary_fl.GetParameter(2),
f_setSummary_afb.GetParameter(1),
f_setSummary_afb.GetParameter(2)))
db.close()
if args.process.cfg['args'].forall:
from BsToPhiMuMuFitter.script.batchTask_mixedToyValidation import GetSummaryGraph as SummaryGraph
SummaryGraph(binKeys,
RecoResult,
GenResult,
args,
pltName="sigMCSubsample")
def _preFitSteps_initFromDB(self):
"""Initialize from DB"""
FitDBPlayer.initFromDB(self.process.dbplayer.odbfile, self.args,
self.cfg['argAliasInDB'])
self.ToggleConstVar(self.args, True)
self.ToggleConstVar(self.args, False, self.cfg.get('argPattern'))
def _preFitSteps(self):
"""Prefit uncorrelated term"""
args = self.pdf.getParameters(self.data)
if not self.process.cfg['args'].NoImport:
FitDBPlayer.initFromDB(self.process.dbplayer.odbfile, args)
self.ToggleConstVar(args, isConst=True)
# Disable xTerm correction and fit to 1-D
args.find('hasXTerm{}'.format(self.cfg['label'])).setVal(0)
h_accXrec_fine_ProjectionX = self.process.sourcemanager.get(
self.cfg['dataX'])
h_accXrec_fine_ProjectionY = self.process.sourcemanager.get(
self.cfg['dataY'])
effi_cosl = self.process.sourcemanager.get(self.cfg['pdfX'])
effi_cosK = self.process.sourcemanager.get(self.cfg['pdfY'])
for proj, pdf, var, argPats in [
(h_accXrec_fine_ProjectionX, effi_cosl, CosThetaL, [r"^l\d+\w*"]),
(h_accXrec_fine_ProjectionY, effi_cosK, CosThetaK, [r"^k\d+\w*"])
]:
hdata = ROOT.RooDataHist("hdata", "", ROOT.RooArgList(var),
ROOT.RooFit.Import(proj))
self.ToggleConstVar(args, isConst=False, targetArgs=argPats)
theList = ROOT.RooLinkedList()
Err = ROOT.RooFit.Minos(True)
theSave = ROOT.RooFit.Save() #Python discards temporary objects
Verbose = ROOT.RooFit.Verbose(0)
Strategy = ROOT.RooFit.Strategy(2)
PrintLevel = ROOT.RooFit.PrintLevel(-1)
theList.Add(theSave)
theList.Add(Verbose)
theList.Add(PrintLevel)
theList.Add(Err)
theList.Add(Strategy)
Res = pdf.chi2FitTo(hdata, theList)
Res = pdf.chi2FitTo(hdata, theList)
Res.Print("v")
FitDBPlayer.UpdateToDB(
self.process.dbplayer.odbfile,
FitterCore.GetFitResult(self.name, var.GetName(), Res))
################## AlTernatively #######################
#chi2 = pdf.createChi2(hdata, ROOT.RooFit.Save(1))
#m=ROOT.RooMinuit(chi2)
#m.setPrintLevel(3)
#m.migrad()
#m.hesse()
#m.minos()
#RooRes=m.save()
self.ToggleConstVar(args, isConst=True, targetArgs=argPats)
effi_norm = 'effi_norm{}'.format(self.cfg['label'])
args.find('hasXTerm{}'.format(self.cfg['label'])).setVal(1)
args.find(effi_norm).setConstant(False)
Res2D = self.pdf.chi2FitTo(self.data, ROOT.RooFit.Minos(True),
ROOT.RooFit.Save(), ROOT.RooFit.Strategy(2),
ROOT.RooFit.PrintLevel(-1))
Res2D.Print()
#args.find(effi_norm).setVal(args.find(effi_norm).getVal() / 4.)
args.find(effi_norm).setConstant(True)
# Fix uncorrelated term and for later update with xTerms in main fit step
self.ToggleConstVar(args, isConst=False, targetArgs=[r"^x\d+\w*"])
def _runFitSteps(self):
h2_accXrec = self.process.sourcemanager.get(self.cfg['datahist'])
args = self.pdf.getParameters(self.data)
nPar = 0
floaters = {} #Saving indices for cross terms
def GetTFunction():
nonlocal nPar
args_it = args.createIterator()
arg = args_it.Next()
effi_sigA_formula = self.pdf.formula().formulaString()
paramDict = {}
for p in range(self.pdf.formula().actualDependents().getSize()):
paramDict[self.pdf.formula().getParameter(p).GetName()] = p
effi_sigA_formula = effi_sigA_formula.replace(
"x[{0}]".format(paramDict['CosThetaL']), "x")
effi_sigA_formula = effi_sigA_formula.replace(
"x[{0}]".format(paramDict['CosThetaK']), "y")
while arg:
if any(
re.match(pat, arg.GetName()) for pat in
["effi_norm", "hasXTerm", r"^l\d+\w*", r"^k\d+\w*"]):
effi_sigA_formula = effi_sigA_formula.replace(
'x[{0}]'.format(paramDict[arg.GetName()]),
"({0})".format(arg.getVal()))
elif re.match(r"^x\d+\w*$", arg.GetName()):
effi_sigA_formula = effi_sigA_formula.replace(
'x[{0}]'.format(paramDict[arg.GetName()]),
"[{0}]".format(nPar))
floaters[nPar] = arg.GetName()
nPar = nPar + 1
arg = args_it.Next()
f2_effi_sigA = ROOT.TF2("f2_effi_sigA", effi_sigA_formula, -1, 1,
-1, 1)
return f2_effi_sigA
if True: #Using RooMinuit
if False: #Using {} optimization
fitter = ROOT.StdFitter()
minuit = fitter.Init(self.pdf, self.data)
minuit.setStrategy(2)
minuit.optimizeConst(1)
minuit.setPrintLevel(0)
self._nll = fitter.GetNLL()
self.fitter = fitter.FitMigrad()
self.fitter = fitter.FitHesse()
self.fitter = fitter.FitMinos(
self.pdf.getParameters(self.data).selectByAttrib(
"Constant", 0))
else: #Using chi2 optimization
self.fitter = self.pdf.chi2FitTo(self.data,
ROOT.RooFit.Minos(1),
ROOT.RooFit.Strategy(2),
ROOT.RooFit.Save(1),
ROOT.RooFit.PrintLevel(-1))
self.fitter = self.pdf.chi2FitTo(self.data,
ROOT.RooFit.Minos(1),
ROOT.RooFit.Strategy(2),
ROOT.RooFit.Save(1),
ROOT.RooFit.PrintLevel(-1))
self.fitter.Print("v")
FitDBPlayer.UpdateToDB(
self.process.dbplayer.odbfile,
FitterCore.GetFitResult(self.name, "XTerm", self.fitter))
setStyle()
canvas = ROOT.TCanvas()
latex = ROOT.TLatex()
h2_effi_2D_comp = h2_accXrec.Clone("h2_effi_2D_comp")
h2_effi_2D_comp.Reset("ICESM")
pdfhist = h2_accXrec.Clone("pdfhist")
pdfhist.Reset("ICESM")
self.pdf.fillHistogram(pdfhist,
ROOT.RooArgList(CosThetaL, CosThetaK))
#Text plot comparison
canvas2 = ROOT.TCanvas()
for lBin, KBin in itertools.product(
list(range(1,
h2_effi_2D_comp.GetNbinsX() + 1)),
list(range(1,
h2_effi_2D_comp.GetNbinsY() + 1))):
if h2_accXrec.GetBinContent(lBin, KBin) == 0:
h2_effi_2D_comp.SetBinContent(lBin, KBin, 0)
print(">> ** Warning ** Empty bins: (l, k)", lBin, KBin)
else:
h2_effi_2D_comp.SetBinContent(
lBin, KBin,
pdfhist.GetBinContent(lBin, KBin) /
h2_accXrec.GetBinContent(lBin, KBin))
ROOT.gStyle.SetPalette(
ROOT.kLightTemperature) #kColorPrintableOnGrey)
h2_effi_2D_text = h2_effi_2D_comp.Clone(
"h2_effi_2D_text") #; h2_effi_2D_text.Reset("ICESM")
h2_effi_2D_text.Draw("COLZ")
h2_effi_2D_text.GetYaxis().SetTitleOffset(1)
ROOT.gStyle.SetPaintTextFormat("6.4g")
pdfhist.SetBarOffset(0.25)
pdfhist.Draw("TEXT SAME")
canvas2.SetRightMargin(0.115)
canvas2.SetLeftMargin(0.1)
h2_accXrec.SetBarOffset(0.)
h2_accXrec.Draw("TEXT SAME")
h2_effi_2D_comp.SetBarOffset(-0.25)
h2_effi_2D_comp.Draw("TEXT SAME")
ROOT.TLatex().DrawLatexNDC(
0.12, 0.96,
r"#scale[0.8]{{{latexLabel}}}".format(latexLabel=q2bins[
self.process.cfg['binKey']]['latexLabel']))
canvas.cd()
h2_effi_2D_comp.SetMinimum(0)
h2_effi_2D_comp.SetMaximum(1.5)
h2_effi_2D_comp.SetTitleOffset(1.6, "X")
h2_effi_2D_comp.SetTitleOffset(1.8, "Y")
h2_effi_2D_comp.SetTitleOffset(1.5, "Z")
h2_effi_2D_comp.SetZTitle(
"#varepsilon_{fit}/#varepsilon_{measured}")
h2_effi_2D_comp.Draw("LEGO2")
latex.DrawLatexNDC(
.08, .93, "#font[61]{CMS} #font[52]{#scale[0.8]{Simulation}}")
chi2ndf = self.fitter.minNll() / (
h2_effi_2D_comp.GetNbinsX() * h2_effi_2D_comp.GetNbinsY() -
self.pdf.getParameters(self.data).selectByAttrib(
"Constant", 0).getSize())
latex.DrawLatexNDC(.08, .89,
"#chi^{{2}}/ndf={0:.2f}".format(chi2ndf))
print("2D Efficiency Chi^2/ndf: ", chi2ndf)
else: #Using TMinuit (This section can be used only if pdf is defined in terms of expression (e.g. RooFormulaVar). Does not work for RooProdPdf or RooProduct)
f2_effi_sigA = GetTFunction()
fitter = ROOT.EfficiencyFitter()
self.minimizer = fitter.Init(nPar, h2_accXrec, f2_effi_sigA)
self.minimizer.SetPrintLevel(0) #Pritam
self.minimizer.mnexcm("SET STR", ctypes.c_double(2.), 1,
ctypes.c_int(0))
for xIdx in range(nPar):
self.minimizer.DefineParameter(xIdx, floaters[xIdx], 0., 1E-4,
-1E+2, 1E+2)
MigStatus = self.minimizer.Migrad()
MigStatus = self.minimizer.Migrad()
MinosStatus = self.minimizer.Command("MINOS")
# Check if efficiency is positive definite
f2_max_x, f2_max_y = ctypes.c_double(0.), ctypes.c_double(.0)
f2_min_x, f2_min_y = ctypes.c_double(0.), ctypes.c_double(.0)
f2_effi_sigA.GetMaximumXY(f2_max_x, f2_max_y)
f2_effi_sigA.GetMinimumXY(f2_min_x, f2_min_y)
print("Sanitary check: Efficiency ranges from {0:.2e} to {1:.2e}".
format(f2_effi_sigA.Eval(f2_min_x, f2_min_y),
f2_effi_sigA.Eval(f2_max_x, f2_max_y)))
EfficiencyFitter.isPosiDef(f2_effi_sigA)
#Update parameter values
parVal, parErr = ctypes.c_double(.0), ctypes.c_double(.0)
eplus, eminus, eparab, gcc = ctypes.c_double(0.), ctypes.c_double(
0.), ctypes.c_double(.0), ctypes.c_double(0.)
for xIdx in range(nPar):
self.minimizer.GetParameter(xIdx, parVal, parErr)
self.minimizer.mnerrs(xIdx, eplus, eminus, eparab, gcc)
arg = args.find(floaters[xIdx])
arg.setVal(parVal.value)
arg.setError(parErr.value)
arg.setAsymError(eplus.value, eminus.value)
# Plot comparison between fitting result to data
setStyle()
canvas = ROOT.TCanvas()
latex = ROOT.TLatex()
h2_effi_2D_comp = h2_accXrec.Clone("h2_effi_2D_comp")
h2_effi_2D_comp.Reset("ICESM")
pdfhist = h2_accXrec.Clone("pdfhist")
pdfhist.Reset("ICESM")
self.pdf.fillHistogram(pdfhist,
ROOT.RooArgList(CosThetaL, CosThetaK))
print(
"2D Efficiency Chi^2/ndf: ",
fitter.GetChi2() /
(h2_effi_2D_comp.GetNbinsX() * h2_effi_2D_comp.GetNbinsY() -
nPar))
print("TMinuit Status: ", self.minimizer.GetStatus(), MigStatus,
MinosStatus)
#Text plot comparison
canvas2 = ROOT.TCanvas()
for lBin, KBin in itertools.product(
list(range(1,
h2_effi_2D_comp.GetNbinsX() + 1)),
list(range(1,
h2_effi_2D_comp.GetNbinsY() + 1))):
if h2_accXrec.GetBinContent(lBin, KBin) == 0:
h2_effi_2D_comp.SetBinContent(lBin, KBin, 0)
print(">> ** Warning ** Empty bins: (l, k)", lBin, KBin)
else:
h2_effi_2D_comp.SetBinContent(
lBin, KBin,
f2_effi_sigA.Eval(
h2_accXrec.GetXaxis().GetBinCenter(lBin),
h2_accXrec.GetYaxis().GetBinCenter(KBin)) /
h2_accXrec.GetBinContent(lBin, KBin))
ROOT.gStyle.SetPalette(
ROOT.kLightTemperature) #kColorPrintableOnGrey)
h2_effi_2D_text = h2_effi_2D_comp.Clone(
"h2_effi_2D_text") #; h2_effi_2D_text.Reset("ICESM")
h2_effi_2D_text.Draw("COLZ")
h2_effi_2D_text.GetYaxis().SetTitleOffset(1)
ROOT.gStyle.SetPaintTextFormat("6.4g")
pdfhist.SetBarOffset(0.25)
pdfhist.Draw("TEXT SAME")
canvas2.SetRightMargin(0.115)
canvas2.SetLeftMargin(0.1)
h2_accXrec.SetBarOffset(0.)
h2_accXrec.Draw("TEXT SAME")
h2_effi_2D_comp.SetBarOffset(-0.25)
h2_effi_2D_comp.Draw("TEXT SAME")
ROOT.TLatex().DrawLatexNDC(
0.12, 0.96,
r"#scale[0.8]{{{latexLabel}}}".format(latexLabel=q2bins[
self.process.cfg['binKey']]['latexLabel']))
canvas.cd()
h2_effi_2D_comp.SetMinimum(0)
h2_effi_2D_comp.SetMaximum(1.5)
h2_effi_2D_comp.SetTitleOffset(1.6, "X")
h2_effi_2D_comp.SetTitleOffset(1.8, "Y")
h2_effi_2D_comp.SetTitleOffset(1.5, "Z")
h2_effi_2D_comp.SetZTitle(
"#varepsilon_{fit}/#varepsilon_{measured}")
h2_effi_2D_comp.Draw("LEGO2")
latex.DrawLatexNDC(
.08, .93, "#font[61]{CMS} #font[52]{#scale[0.8]{Simulation}}")
latex.DrawLatexNDC(
.08, .89, "#chi^{{2}}/ndf={0:.2f}".format(
fitter.GetChi2() / (h2_effi_2D_comp.GetNbinsX() *
h2_effi_2D_comp.GetNbinsY() - nPar)))
FitterCore.ArgLooper(args, lambda p: p.Print())
####################################
path = os.path.join(modulePath, self.process.work_dir, "Efficiency")
if not os.path.exists(path):
os.mkdir(path)
os.chdir(path)
####################################
canvas.Print("effi_2D_comp{}_{}.pdf".format(
self.cfg['label'], q2bins[self.process.cfg['binKey']]['label']))
canvas2.cd()
canvas2.Print("effi_2D_TEXT{}_{}.pdf".format(
self.cfg['label'], q2bins[self.process.cfg['binKey']]['label']))
os.chdir(os.path.join(modulePath, self.process.work_dir))
def _postFitSteps(self):
"""Post-processing"""
args = self.pdf.getParameters(self.data)
self.ToggleConstVar(args, True)
FitDBPlayer.UpdateToDB(self.process.dbplayer.odbfile, args)
from __future__ import print_function
import os, sys, re, math, glob, shelve, pdb
from subprocess import call
from argparse import ArgumentParser
from multiprocessing import Pool
import ROOT
from BsToPhiMuMuFitter.anaSetup import modulePath, q2bins
from BsToPhiMuMuFitter.StdFitter import unboundFlToFl, unboundAfbToAfb
from BsToPhiMuMuFitter.plotCollection import Plotter
from BsToPhiMuMuFitter.python.datainput import allBins
from BsToPhiMuMuFitter.FitDBPlayer import FitDBPlayer
dbplayer = FitDBPlayer(
absInputDir=os.path.join(modulePath, "input", "selected"))
targetBinKeys = [
'summary'
] #allBins #["belowJpsi", "betweenPeaks", "abovePsi2s", "summary"]
targetCoverage = 0.683
def worker_mergeToys(task_dir):
print("INFO\t: Merge toys from {0}".format(task_dir))
for binKey in targetBinKeys:
for fileKey, wspaceKey in [("sigToyGenerator", "f_sig3DData"),
("bkgCombToyGenerator", "f_bkgCombData")]:
files = glob.glob(
args.batchDir + "/" + task_dir +
"/*/{0}_{1}.root".format(fileKey, q2bins[binKey]['label']))
merged_file = args.batchDir + "/" + task_dir + "/{0}_{1}.root".format(
def func_postproc(args):
""" Fit to fit result and make plots """
GenResult = []
RecoResult = []
os.chdir(args.wrapper.task_dir)
args.process.addService(
"dbplayer",
FitDBPlayer(absInputDir=os.path.join(modulePath, "plots_{}".format(
args.Year))))
binKeys = args.process.cfg['allBins'] if args.process.cfg[
'args'].forall else args.process.cfg[
'bins'] #Run over all bins if no binkey arg is supplied
for binKey in binKeys:
ifilename = "setSummary_{}_{}.root".format(
"Simult" if args.SimFit else args.Year, q2bins[binKey]['label'])
if not os.path.exists(ifilename) or args.forceHadd:
call(["hadd", "-f", ifilename] +
glob.glob('*/setSummary_{}_{}.root'.format(
"Simult" if args.SimFit else args.Year, q2bins[binKey]
['label'])))
ifile = ROOT.TFile(ifilename)
tree = ifile.Get("tree")
Cuts = "covQual==3&&status==0&&hesse==0"
binWidth = 0.01
h_setSummary_afb = ROOT.TH1F("h_setSummary_afb", "",
int(1.5 / binWidth), -0.75, 0.75)
h_setSummary_fl = ROOT.TH1F("h_setSummary_fl", "", int(1. / binWidth),
0., 1.)
tree.Draw("afb>>h_setSummary_afb", Cuts)
tree.Draw("fl>>h_setSummary_fl", Cuts)
f_setSummary_afb = ROOT.TF1("f_setSummary_afb", "gaus",
-0.75 + binWidth, 0.75 - binWidth)
h_setSummary_afb.Fit("f_setSummary_afb")
h_setSummary_afb.GetFunction("f_setSummary_afb").SetLineColor(4)
f_setSummary_fl = ROOT.TF1("f_setSummary_fl", "gaus", binWidth,
1 - binWidth)
if binKey == "betweenPeaks":
r = h_setSummary_fl.Fit("f_setSummary_fl", "S", "", 0.39, .8)
else:
r = h_setSummary_fl.Fit("f_setSummary_fl", "S")
h_setSummary_fl.GetFunction("f_setSummary_fl").SetLineColor(4)
# Draw
db = shelve.open(
os.path.join(args.process.dbplayer.absInputDir,
"fitResults_{0}.db".format(q2bins[binKey]['label'])),
'r')
fl_GEN = StdFitter.unboundFlToFl(db['unboundFl_GEN']['getVal'])
afb_GEN = StdFitter.unboundAfbToAfb(db['unboundAfb_GEN']['getVal'],
fl_GEN)
line = ROOT.TLine()
line.SetLineWidth(2)
line.SetLineColor(2)
line.SetLineStyle(9)
plotCollection.Plotter.canvas.cd()
h_setSummary_afb.SetXTitle("A_{6}")
h_setSummary_afb.SetYTitle("Number of test samples")
h_setSummary_afb.SetFillColor(ROOT.kGreen - 10)
h_setSummary_afb.GetYaxis().SetRangeUser(
0., 1.5 * h_setSummary_afb.GetMaximum())
h_setSummary_afb.Draw()
GetParams(f_setSummary_afb, h_setSummary_afb, binKey, afb_GEN, "a6")
if args.drawGEN:
line.DrawLine(afb_GEN, 0, afb_GEN, h_setSummary_afb.GetMaximum())
plotCollection.Plotter.latexDataMarks(['mix'])
plotCollection.Plotter.canvas.Print(
"h_setSummary_mixedToyValidation_a6_{}_{}.pdf".format(
"Simult" if args.SimFit else args.Year,
q2bins[binKey]['label']))
h_setSummary_fl.SetXTitle("F_{L}")
h_setSummary_fl.SetYTitle("Number of test samples")
h_setSummary_fl.SetFillColor(ROOT.kGreen - 10)
h_setSummary_fl.GetYaxis().SetRangeUser(
0., 1.5 * h_setSummary_fl.GetMaximum())
h_setSummary_fl.Draw()
GetParams(f_setSummary_fl, h_setSummary_fl, binKey, fl_GEN, "fl")
if args.drawGEN:
line.DrawLine(fl_GEN, 0, fl_GEN, h_setSummary_fl.GetMaximum())
plotCollection.Plotter.latexDataMarks(['mix'])
plotCollection.Plotter.canvas.Print(
"h_setSummary_mixedToyValidation_fl_{}_{}.pdf".format(
"Simult" if args.SimFit else args.Year,
q2bins[binKey]['label']))
Fl_GENErr = abs(
StdFitter.unboundFlToFl(db['unboundFl_GEN']['getVal'] +
db['unboundFl_GEN']['getError']) - fl_GEN)
A6_GENErr = abs(
StdFitter.unboundAfbToAfb(
db['unboundAfb_GEN']['getVal'] +
db['unboundAfb_GEN']['getError'], fl_GEN) - afb_GEN)
GenResult.append((fl_GEN, Fl_GENErr, afb_GEN, A6_GENErr))
RecoResult.append(
(f_setSummary_fl.GetParameter(1), f_setSummary_fl.GetParameter(2),
f_setSummary_afb.GetParameter(1),
f_setSummary_afb.GetParameter(2)))
if not args.process.cfg['args'].SimFit:
from copy import deepcopy
tree.Draw("nSig", Cuts)
nSigHist = deepcopy(ROOT.gPad.GetPrimitive("htemp"))
tree.Draw("nBkgComb", Cuts)
nBkgCombHist = deepcopy(ROOT.gPad.GetPrimitive("htemp"))
tree.Draw("nBkgPeak", Cuts)
nBkgPeakHist = deepcopy(ROOT.gPad.GetPrimitive("htemp"))
tree.Draw("entries", Cuts)
nTotalHist = deepcopy(ROOT.gPad.GetPrimitive("htemp"))
# Signal Event Distributions
nSigHist.Draw()
nSigHist.SetFillColor(ROOT.kBlue - 10)
#nSigHist.SetLineColor(ROOT.kBlue)
ROOT.TLatex().DrawLatexNDC(
.73, .77,
r"#scale[0.7]{{#color[4]{{Mean}} : {param}}}".format(
param=round(nSigHist.GetMean(), 5)))
ROOT.TLatex().DrawLatexNDC(
.73, .73,
r"#scale[0.7]{{#color[1]{{Samples}} : {param}}}".format(
param=round(nSigHist.GetEntries(), 0)))
ROOT.TLatex().DrawLatexNDC(
.73, .82, r"#scale[0.7]{{#color[2]{{nSig}} : {param}}}".format(
param=round(db['nSig']['getVal'], 0)))
plotCollection.Plotter.canvas.Update()
line.DrawLine(db['nSig']['getVal'], 0, db['nSig']['getVal'],
ROOT.gPad.GetUymax())
ROOT.TLatex().DrawLatexNDC(
.45, .89, r"#scale[0.8]{{{latexLabel}}}".format(
latexLabel=q2bins[binKey]['latexLabel']))
plotCollection.Plotter.canvas.Print("h_nSig_{}_{}.pdf".format(
args.Year, q2bins[binKey]['label']))
#Bkg yield distribution
nBkgCombHist.Draw()
nBkgCombHist.SetFillColor(ROOT.kRed - 10)
#nBkgCombHist.SetLineColor(ROOT.kRed)
ROOT.TLatex().DrawLatexNDC(
.73, .77,
r"#scale[0.7]{{#color[2]{{Mean}} : {param}}}".format(
param=round(nBkgCombHist.GetMean(), 5)))
ROOT.TLatex().DrawLatexNDC(
.73, .73,
r"#scale[0.7]{{#color[1]{{Samples}} : {param}}}".format(
param=round(nBkgCombHist.GetEntries(), 0)))
ROOT.TLatex().DrawLatexNDC(
.73, .82, r"#scale[0.7]{{#color[2]{{nBkg}} : {param}}}".format(
param=round(db['nBkgComb']['getVal'], 0)))
plotCollection.Plotter.canvas.Update()
line.DrawLine(db['nBkgComb']['getVal'], 0,
db['nBkgComb']['getVal'], ROOT.gPad.GetUymax())
ROOT.TLatex().DrawLatexNDC(
.45, .89, r"#scale[0.8]{{{latexLabel}}}".format(
latexLabel=q2bins[binKey]['latexLabel']))
plotCollection.Plotter.canvas.Print("h_nBkgComb_{}_{}.pdf".format(
args.Year, q2bins[binKey]['label']))
#Peaking Bkg yield distribution
nBkgPeakHist.Draw()
nBkgPeakHist.SetFillColor(ROOT.kGreen - 10)
#nBkgPeakHist.SetLineColor(ROOT.kGreen)
ROOT.TLatex().DrawLatexNDC(
.73, .77,
r"#scale[0.7]{{#color[3]{{Mean}} : {param}}}".format(
param=round(nBkgPeakHist.GetMean(), 5)))
ROOT.TLatex().DrawLatexNDC(
.73, .73,
r"#scale[0.7]{{#color[1]{{Samples}} : {param}}}".format(
param=round(nBkgPeakHist.GetEntries(), 0)))
nPeak = db['PeakFrac']['getVal'] * db['nSig']['getVal']
ROOT.TLatex().DrawLatexNDC(
.73, .82,
r"#scale[0.7]{{#color[2]{{nPeak}} : {param}}}".format(
param=round(nPeak, 0)))
plotCollection.Plotter.canvas.Update()
line.DrawLine(nPeak, 0, nPeak, ROOT.gPad.GetUymax())
ROOT.TLatex().DrawLatexNDC(
.45, .89, r"#scale[0.8]{{{latexLabel}}}".format(
latexLabel=q2bins[binKey]['latexLabel']))
plotCollection.Plotter.canvas.Print("h_nBkgPeak_{}_{}.pdf".format(
args.Year, q2bins[binKey]['label']))
# Total yield distributions
nTotalHist.Draw()
nTotalHist.SetFillColor(ROOT.kBlue - 10)
#nTotalHist.SetLineColor(ROOT.kBlue)
ROOT.TLatex().DrawLatexNDC(
.73, .77,
r"#scale[0.7]{{#color[4]{{Mean}} : {param}}}".format(
param=round(nTotalHist.GetMean(), 5)))
ROOT.TLatex().DrawLatexNDC(
.73, .73,
r"#scale[0.7]{{#color[1]{{Samples}} : {param}}}".format(
param=round(nTotalHist.GetEntries(), 0)))
nTotal = db['nBkgComb']['getVal'] + db['nSig']['getVal'] + nPeak
ROOT.TLatex().DrawLatexNDC(
.73, .82,
r"#scale[0.7]{{#color[2]{{nTotal}} : {param}}}".format(
param=round(nTotal, 0)))
plotCollection.Plotter.canvas.Update()
line.DrawLine(nTotal, 0, nTotal, ROOT.gPad.GetUymax())
ROOT.TLatex().DrawLatexNDC(
.45, .89, r"#scale[0.8]{{{latexLabel}}}".format(
latexLabel=q2bins[binKey]['latexLabel']))
plotCollection.Plotter.canvas.Print("h_nTotal_{}_{}.pdf".format(
args.Year, q2bins[binKey]['label']))
Hist2D = ROOT.TH2F("Hist2D", "title", 100, -1, 1, 100, 0., 1.05)
tree.Draw("fl:afb>>Hist2D", Cuts) #+"&&(fl-abs(afb))<=0.95")
Hist2D.Draw("COLZ")
Hist2D.GetXaxis().SetTitle("A_{6}")
Hist2D.GetYaxis().SetTitle("F_{L}")
ROOT.gPad.SetRightMargin(0.115)
#ROOT.TColor.InvertPalette()
#ROOT.TLine().DrawLine(-1, 0, 0, 1); ROOT.TLine().DrawLine(0, 1, 1, 0); ROOT.TLine().DrawLine(-1, 0, 1, 0)
plotCollection.Plotter.canvas.Print("h2_{}_{}.pdf".format(
"Simult" if args.SimFit else args.Year, q2bins[binKey]['label']))
db.close()
if args.process.cfg['args'].forall:
GetSummaryGraph(binKeys,
RecoResult,
GenResult,
args,
pltName="mixedToy")
pfile = ROOT.TFile.Open(modulePath + "/input/wspace_bin0.root")
wspace = pfile.Get('wspace.bin0')
pdf = wspace.obj('f_final')
#----------------------------
# Assemble TMinuit Minimizer
#----------------------------
#----------------------------
# Plot Post-Fit Distributions
#----------------------------
pdb.set_trace()
odbfile = modulePath + "/Plots/fitResults_bin0.db"
args = pdf.getParameters(
ROOT.RooArgSet(Bmass, CosThetaK, CosThetaL, Mumumass, Phimass))
FitDBPlayer.initFromDB(odbfile, args)
args = pdf.getParameters(ROOT.RooArgSet(Bmass, CosThetaK, CosThetaL))
nSigDB = args.find('nSig').getVal()
nSigErrorDB = args.find('nSig').getError()
nBkgCombDB = args.find('nBkgComb').getVal()
nBkgCombErrorDB = args.find('nBkgComb').getError()
#flDB = unboundFlToFl(args.find('unboundFl').getVal())
#afbDB = unboundAfbToAfb(args.find('unboundAfb').getVal(), flDB)
###
obs = pdf.getObservables(data)
obs.find('Bmass').setRange("sigRegion", 5.2, 5.6)
Bmass.setRange("sigRegion")
sigFrac = pdf.createIntegral(obs, ROOT.RooFit.NormSet(obs),
def plotEfficiency(self, data_name, pdf_name):
pltName = "effi"
data = self.process.sourcemanager.get(data_name)
pdf = self.process.sourcemanager.get(pdf_name)
if data == None or pdf == None:
self.logger.logWARNING("Skip plotEfficiency. pdf or data not found")
return
args = pdf.getParameters(data)
FitDBPlayer.initFromDB(self.process.dbplayer.odbfile, args)
binningL = ROOT.RooBinning(
len(dataCollection.accXEffThetaLBins) - 1,
dataCollection.accXEffThetaLBins)
binningK = ROOT.RooBinning(
len(dataCollection.accXEffThetaKBins) - 1,
dataCollection.accXEffThetaKBins)
data_accXrec = self.process.sourcemanager.get("effiHistReader.h2_accXrec")
data_accXrec.Scale(100)
data_accXrec.SetMinimum(0)
#data_accXrec.SetMaximum(100 * 0.00015) # Z axis in percentage
data_accXrec.SetTitleOffset(1.6, "X")
data_accXrec.SetTitleOffset(1.8, "Y")
data_accXrec.SetTitleOffset(1.8, "Z")
data_accXrec.SetZTitle("Efficiency [%]")
data_accXrec.Draw("LEGO2")
h2_effi_sigA_fine = pdf.createHistogram(
"h2_effi_sigA_fine", CosThetaL, ROOT.RooFit.Binning(20),
ROOT.RooFit.YVar(CosThetaK, ROOT.RooFit.Binning(20)))
h2_effi_sigA_fine.Scale(100)
h2_effi_sigA_fine.SetLineColor(2)
h2_effi_sigA_fine.Draw("SURF SAME")
Plotter.latexCMSSim(.08, .93)
Plotter.latexCMSExtra(.08, .89)
self.latexQ2(.40, .93)
self.canvasPrint(pltName + "_2D")
data_accXrec.Scale(0.01)
cloned_frameL = Plotter.frameL.emptyClone("cloned_frameL")
h_accXrec_fine_ProjectionX = self.process.sourcemanager.get(
"effiHistReader.h_accXrec_fine_ProjectionX")
data_accXrec_fine_ProjectionX = ROOT.RooDataHist(
"data_accXrec_fine_ProjectionX", "", ROOT.RooArgList(CosThetaL),
ROOT.RooFit.Import(h_accXrec_fine_ProjectionX))
data_accXrec_fine_ProjectionX.plotOn(cloned_frameL,
ROOT.RooFit.Rescale(100))
pdfL = self.process.sourcemanager.get("effi_cosl")
pdfL.plotOn(cloned_frameL,
ROOT.RooFit.Normalization(100, ROOT.RooAbsReal.Relative),
*plotterCfg_sigStyleNoFill)
cloned_frameL.GetYaxis().SetTitle("Efficiency [%]")
cloned_frameL.SetMaximum(1.5 * cloned_frameL.GetMaximum())
cloned_frameL.Draw()
Plotter.latexCMSSim()
Plotter.latexCMSExtra()
self.latexQ2()
# Plotter.latex.DrawLatexNDC(.85, .89, "#chi^{{2}}={0:.2f}".format(cloned_frameL.chiSquare()))
self.canvasPrint(pltName + "_cosl")
cloned_frameK = Plotter.frameK.emptyClone("cloned_frameK")
h_accXrec_fine_ProjectionY = self.process.sourcemanager.get(
"effiHistReader.h_accXrec_fine_ProjectionY")
data_accXrec_fine_ProjectionY = ROOT.RooDataHist(
"data_accXrec_fine_ProjectionY", "", ROOT.RooArgList(CosThetaK),
ROOT.RooFit.Import(h_accXrec_fine_ProjectionY))
data_accXrec_fine_ProjectionY.plotOn(cloned_frameK,
ROOT.RooFit.Rescale(100))
pdfK = self.process.sourcemanager.get("effi_cosK")
pdfK.plotOn(cloned_frameK,
ROOT.RooFit.Normalization(100, ROOT.RooAbsReal.Relative),
*plotterCfg_sigStyleNoFill)
cloned_frameK.GetYaxis().SetTitle("Efficiency [%]")
cloned_frameK.SetMaximum(1.5 * cloned_frameK.GetMaximum())
cloned_frameK.Draw()
Plotter.latexCMSSim()
Plotter.latexCMSExtra()
self.latexQ2()
# Plotter.latex.DrawLatexNDC(.85, .89, "#chi^{{2}}={0:.2f}".format(cloned_frameK.chiSquare()))
self.canvasPrint(pltName + "_cosK")
def _postFitSteps(self):
""" Abstract: Do something after main fit loop"""
for pdf, data in zip(self.pdf, self.data):
self.ToggleConstVar(pdf.getParameters(data), True)
cwd = os.getcwd()
if self.process.cfg['args'].seqKey == 'fitBkgCombA':
os.chdir(
os.path.join(self.process.cwd, "plots_{0}".format(
self.process.cfg['args'].Year)))
if self.cfg['saveToDB']: #Update parameters to db file
FitDBPlayer.UpdateToDB(
self.process.dbplayer.odbfile,
self.minimizer.getParameters(self.dataWithCategories),
self.cfg['argAliasInDB']
if self.cfg['argAliasSaveToDB'] else None)
for pdf, data in zip(self.pdf,
self.data): #Get parameter values from db file
FitDBPlayer.initFromDB(self.process.dbplayer.odbfile,
pdf.getParameters(data),
aliasDict=self.cfg['argAliasInDB']
if self.cfg['argAliasSaveToDB'] else None,
exclude=None)
os.chdir(cwd)
"""ofile = ROOT.TFile("../input/Simultaneous_{0}.root".format(q2bins[self.process.cfg['binKey']]['label']), "RECREATE")
self.minimizer.Write()
self.dataWithCategories.Write()
self.category.Write()
ofile.Close()"""
self.cfg['source']["{0}.dataWithCategories".format(
self.name)] = self.dataWithCategories
self.cfg['source'][self.name] = self.minimizer
self.cfg['source']["{0}.category".format(self.name)] = self.category
sampleSet = ROOT.RooArgSet(self.category)
self.cfg['source']['ProjWData'] = ROOT.RooFit.ProjWData(
sampleSet, self.dataWithCategories)
#Attach ProjWData Argument to plotter for getting combined fit
#self.process._sequence[1].cfg['plots'][self.process._sequence[1].cfg['switchPlots'][0]]['kwargs']['pdfPlots'][0][1]=(ROOT.RooFit.ProjWData(sampleSet, self.dataWithCategories), ROOT.RooFit.LineColor(2), ROOT.RooFit.LineStyle(9))
frameL = CosThetaL.frame(ROOT.RooFit.Bins(20))
frameK = CosThetaK.frame(ROOT.RooFit.Bins(20))
legendInstance = Plotter.legend
c1 = ROOT.TCanvas()
binKey = q2bins[self.process.cfg['binKey']]['label']
if self.process.cfg['args'].seqKey in [
'fitBkgCombA', 'fitFinal3D_WithKStar'
]:
marks = None
else:
marks = ['sim']
for ID, Category, Year in zip(range(len(self.Years)),
self.cfg['category'], self.Years):
CopyFrameL = frameL.Clone()
self.category.setIndex(ID)
sampleSet = ROOT.RooArgSet(self.category)
self.dataWithCategories.plotOn(
CopyFrameL,
ROOT.RooFit.Cut("({0}==({0}::{1}))".format(
self.category.GetName(), Category)))
self.minimizer.plotOn(
CopyFrameL, ROOT.RooFit.Slice(self.category, Category),
ROOT.RooFit.Components(self.pdf[ID].GetName()),
ROOT.RooFit.ProjWData(sampleSet, self.dataWithCategories),
ROOT.RooFit.LineStyle(ROOT.kSolid),
ROOT.RooFit.LineColor(2 if self.process.cfg['args'].seqKey ==
'fitBkgCombA' else 4)
) # ROOT.RooFit.Components( self.pdf[ID].GetName())
CopyFrameL.SetMaximum(1.5 * CopyFrameL.GetMaximum())
c1.Clear()
CopyFrameL.Draw(
) if self.process.cfg['args'].NoPull else Plotter.DrawWithResidue(
CopyFrameL)
Plotter.latexQ2(self.process.cfg['binKey'])
Plotter.latex.DrawLatexNDC(
.45, .84, r"#scale[0.8]{{Events = {0:.2f}}}".format(
self.dataWithCategories.sumEntries("{0}=={0}::{1}".format(
self.category.GetName(), Category))))
Plotter.latexDataMarks(marks=marks)
legendInstance.Clear()
legendInstance.AddEntry(
CopyFrameL.getObject(0).GetName(), self.cfg['LegName'], "LPFE")
legendInstance.Draw()
c1.SaveAs("Simultaneous_Cosl_{0}_{1}_{2}.pdf".format(
Category, self.process.cfg['args'].seqKey, binKey))
CopyFrameK = frameK.Clone()
self.dataWithCategories.plotOn(
CopyFrameK,
ROOT.RooFit.Cut("{0}=={0}::{1}".format(self.category.GetName(),
Category)))
self.minimizer.plotOn(
CopyFrameK, ROOT.RooFit.Slice(self.category, Category),
ROOT.RooFit.Components(self.pdf[ID].GetName()),
ROOT.RooFit.ProjWData(sampleSet, self.dataWithCategories),
ROOT.RooFit.LineStyle(ROOT.kSolid),
ROOT.RooFit.LineColor(2 if self.process.cfg['args'].seqKey ==
'fitBkgCombA' else 4)
) #, ROOT.RooFit.Components(self.pdf[ID].GetName())
CopyFrameK.SetMaximum(1.5 * CopyFrameK.GetMaximum())
c1.Clear()
CopyFrameK.Draw(
) if self.process.cfg['args'].NoPull else Plotter.DrawWithResidue(
CopyFrameK)
Plotter.latexQ2(self.process.cfg['binKey'])
Plotter.latex.DrawLatexNDC(
.45, .84, r"#scale[0.8]{{Events = {0:.2f}}}".format(
self.dataWithCategories.sumEntries("{0}=={0}::{1}".format(
self.category.GetName(), Category))))
Plotter.latexDataMarks(marks=marks)
legendInstance.Clear()
legendInstance.AddEntry(
CopyFrameK.getObject(0).GetName(), self.cfg['LegName'], "LPFE")
legendInstance.Draw()
c1.SaveAs("Simultaneous_CosK_{0}_{1}_{2}.pdf".format(
Category, self.process.cfg['args'].seqKey, binKey))
def func_randEffi(args):
""" Typically less than 5% """
setupFinalRandEffiFitter = deepcopy(fitCollection.setupFinalFitter)
setupFinalRandEffiFitter.update({
'FitMinos': [False, ()],
'argAliasInDB': {'afb': 'afb_randEffi', 'fl': 'fl_randEffi', 'fs': 'fs_randEffi', 'as': 'as_randEffi'},
'saveToDB': False,
})
finalRandEffiFitter = StdFitter(setupFinalRandEffiFitter)
def preFitSteps_randEffi(self):
self.args = self.pdf.getParameters(self.data)
self._preFitSteps_initFromDB()
# Fluctuate cross-term correction
effiArgs = ROOT.RooArgSet()
FitterCore.ArgLooper(self.args, lambda iArg: effiArgs.add(iArg), targetArgs=[r"x\d{1,2}"])
FitDBPlayer.fluctuateFromDB(self.process.dbplayer.odbfile, effiArgs, self.cfg['argAliasInDB'])
self._preFitSteps_vetoSmallFs()
self._preFitSteps_preFit()
finalRandEffiFitter._preFitSteps = types.MethodType(preFitSteps_randEffi, finalRandEffiFitter)
foutName = "syst_randEffi_{0}.root".format(q2bins[args.binKey]['label'])
class effiStudier(AbsToyStudier):
def _preSetsLoop(self):
self.hist_afb = ROOT.TH1F("hist_afb", "", 300, -0.75, 0.75)
self.hist_afb.GetXaxis().SetTitle("A_{{FB}}")
self.hist_fl = ROOT.TH1F("hist_fl", "", 200, 0., 1.)
self.hist_fl.GetXaxis().SetTitle("F_{{L}}")
def _preRunFitSteps(self, setIndex):
pass
def _postRunFitSteps(self, setIndex):
if self.fitter.fitResult["{0}.migrad".format(self.fitter.name)]['status'] == 0:
afb = self.process.sourcemanager.get('afb')
fl = self.process.sourcemanager.get('fl')
self.hist_afb.Fill(afb.getVal())
self.hist_fl.Fill(fl.getVal())
def _postSetsLoop(self):
fout = ROOT.TFile(foutName, "RECREATE")
fout.cd()
self.hist_afb.Write()
self.hist_fl.Write()
fout.Close()
def getSubDataEntries(self, setIndex):
return 1
def getSubData(self):
while True:
yield self.data
setupStudier = deepcopy(effiStudier.templateConfig())
setupStudier.update({
'name': "effiStudier",
'data': "dataReader.Fit",
'fitter': finalRandEffiFitter,
'nSetOfToys': 200,
})
studier = effiStudier(setupStudier)
p.setSequence([
pdfCollection.stdWspaceReader,
dataCollection.dataReader,
studier,
])
try:
p.beginSeq()
if os.path.exists("{0}".format(foutName)):
print("{0} exists, skip fitting procedure".format(foutName))
else:
p.runSeq()
fin = ROOT.TFile("{0}".format(foutName))
hist_fl = fin.Get("hist_fl")
gaus_fl = ROOT.TF1("gaus_fl", "gaus(0)", 0, 1)
hist_fl.Fit(gaus_fl, "WI")
hist_afb = fin.Get("hist_afb")
gaus_afb = ROOT.TF1("gaus_afb", "gaus(0)", -0.75, 0.75)
hist_afb.Fit(gaus_afb, "WI")
syst_randEffi = {
'syst_randEffi_fl': {
'getError': gaus_fl.GetParameter(2),
'getErrorHi': gaus_fl.GetParameter(2),
'getErrorLo': -gaus_fl.GetParameter(2),
},
'syst_randEffi_afb': {
'getError': gaus_afb.GetParameter(2),
'getErrorHi': gaus_afb.GetParameter(2),
'getErrorLo': -gaus_afb.GetParameter(2),
}
}
print(syst_randEffi)
if args.updatePlot:
canvas = Plotter.canvas.cd()
hist_afb.Draw("HIST")
Plotter.latexCMSMark()
Plotter.latexCMSExtra()
Plotter.latexCMSSim()
canvas.Print("syst_randEffi_afb_{0}.pdf".format(q2bins[args.binKey]['label']))
hist_fl.GetXaxis().SetTitle("F_{{L}}")
hist_fl.Draw("HIST")
Plotter.latexCMSMark()
Plotter.latexCMSExtra()
Plotter.latexCMSSim()
canvas.Print("syst_randEffi_fl_{0}.pdf".format(q2bins[args.binKey]['label']))
if args.updateDB:
FitDBPlayer.UpdateToDB(p.dbplayer.odbfile, syst_randEffi)
finally:
p.endSeq()
