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 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 _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 _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, 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 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 _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 _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*"])
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))
