def doFit(hist,output,rap="BB",flavour="DATA",trackType="TunePNew",funct="doubleCB"):
sig = []
sige = []
meanList = []
meanListe = []
nChi2 = []
gSystem.Load("./RooCruijff_cxx.so")
gSystem.Load("./RooDCBShape_cxx.so")
for i,h in enumerate(hist):
ws = RooWorkspace("tempWS")
mass = RooRealVar('mass','mass',91, xLow, xHigh )
getattr(ws,'import')(mass,RooCmdArg())
dataHist = RooDataHist("hist","hist",RooArgList(ws.var("mass")),h)
getattr(ws,'import')(dataHist,RooCmdArg())
ws.writeToFile("tmpWorkspace.root")
subprocess.call(["python","fitCapsule.py",output,rap,flavour,trackType,funct,"%d"%xLow,"%d"%xHigh,"%d"%rebinFactor,"%d"%i])
returnFile = TFile("tmpWorkspaceReturn.root","OPEN")
wsReturn = returnFile.Get("tempWS")
sig.append(wsReturn.var("Sig").getVal())
sige.append(wsReturn.var("Sige").getVal())
meanList.append(wsReturn.var("Mean").getVal())
meanListe.append(wsReturn.var("Meane").getVal())
nChi2.append(wsReturn.var("chi2").getVal()/wsReturn.var("nDOF").getVal())
return meanList,meanListe,sig,sige, nChi2
def fit(self, keepParameterValues = False, overrideRangeCmd = False):
print 'construct fit pdf ...'
fitter = self.makeFitter()
print 'load data ...'
data = self.loadData()
self.resetYields()
constraintSet = self.makeConstraints()
if not keepParameterValues:
self.readParametersFromFile()
self.resetYields()
# print constraints, self.pars.yieldConstraints
constraintCmd = RooCmdArg.none()
if constraintSet.getSize() > 0:
fitter = self.makeConstrainedFitter()
constraintCmd = RooFit.Constrained()
# constraintCmd = RooFit.ExternalConstraints(self.ws.set('constraintSet'))
if self.useImportPars:
self.ws.loadSnapshot('importParams')
self.ws.Print()
# for constraint in pars.constraints:
# self.ws.pdf(constraint).Print()
# print
rangeCmd = RooCmdArg.none()
if self.rangeString and self.pars.doExclude and not overrideRangeCmd:
rangeCmd = RooFit.Range(self.rangeString)
# print 'scanning parameter values...'
# fitter.fitTo(data, RooFit.Minos(False),
# RooFit.PrintEvalErrors(-1),
# RooFit.Warnings(False),
# RooFit.Minimizer("Minuit2", "scan"),
# RooFit.PrintLevel(0),
# constraintCmd,
# rangeCmd)
print 'fitting ...'
fr = fitter.fitTo(data, RooFit.Save(True),
# RooFit.Extended(True),
RooFit.Minos(False),
RooFit.PrintEvalErrors(-1),
RooFit.Warnings(False),
RooFit.Minimizer("Minuit2", "minimize"),
constraintCmd,
rangeCmd
)
fr.Print('v')
return fr
def fit(self, keepParameterValues=False):
print "construct fit pdf ..."
fitter = self.makeFitter()
print "load data ..."
data = self.loadData()
self.resetYields()
constraintSet = self.makeConstraints()
if not keepParameterValues:
self.readParametersFromFile()
self.resetYields()
# print constraints, self.pars.yieldConstraints
constraintCmd = RooCmdArg.none()
if constraintSet.getSize() > 0:
fitter = self.makeConstrainedFitter()
constraintCmd = RooFit.Constrained()
# constraintCmd = RooFit.ExternalConstraints(self.ws.set('constraintSet'))
if self.useImportPars:
self.ws.loadSnapshot("importParams")
self.ws.Print()
# for constraint in pars.constraints:
# self.ws.pdf(constraint).Print()
# print
rangeCmd = RooCmdArg.none()
if self.rangeString and self.pars.doExclude:
rangeCmd = RooFit.Range(self.rangeString)
print "fitting ..."
fr = fitter.fitTo(
data,
RooFit.Save(True),
RooFit.Extended(True),
RooFit.Minos(False),
RooFit.PrintEvalErrors(-1),
RooFit.Warnings(False),
constraintCmd,
rangeCmd,
)
fr.Print()
return fr
def stackedPlot(self, var, logy = False, pdfName = None, Silent = False):
if not pdfName:
pdfName = 'total'
xvar = self.ws.var(var)
nbins = xvar.getBins()
# if hasattr(self.pars, 'plotRanges') and not xvar.hasRange('plotRange'):
# xvar.setRange('plotRange', self.pars.plotRanges[var][1],
# self.pars.plotRanges[var][2])
# xvar.setBins(self.pars.plotRanges[var][0], 'plotBins')
# elif not xvar.hasRange('plotRange'):
# xvar.setRange('plotRange', xvar.getMin(), xvar.getMax())
# xvar.setBins(nbins, 'plotBins')
sframe = xvar.frame(RooFit.Range('plotRange'),
RooFit.Bins(xvar.getBins('plotBins')))
sframe.SetName("%s_stacked" % var)
pdf = self.ws.pdf(pdfName)
if isinstance(pdf, RooAddPdf):
compList = RooArgList(pdf.pdfList())
else:
compList = None
data = self.ws.data('data_obs')
nexp = pdf.expectedEvents(self.ws.set('obsSet'))
if not Silent:
print pdf.GetName(),'expected: %.0f' % (nexp)
print 'data events: %.0f' % (data.sumEntries())
if nexp < 1:
nexp = data.sumEntries()
theComponents = []
if self.pars.includeSignal:
theComponents += self.pars.signals
theComponents += self.pars.backgrounds
data.plotOn(sframe, RooFit.Invisible(),
RooFit.Binning('plotBins'))
# dataHist = RooAbsData.createHistogram(data,'dataHist_%s' % var, xvar,
# RooFit.Binning('%sBinning' % var))
# #dataHist.Scale(1., 'width')
# invData = RooHist(dataHist, 1., 1, RooAbsData.SumW2, 1.0, False)
# #invData.Print('v')
# sframe.addPlotable(invData, 'pe', True, True)
for (idx,component) in enumerate(theComponents):
if not Silent:
print 'plotting',component,'...',
if hasattr(self.pars, '%sPlotting' % (component)):
plotCharacteristics = getattr(self.pars, '%sPlotting' % \
(component))
else:
plotCharacteristics = {'color' : colorwheel[idx%6],
'title' : component }
compCmd = RooCmdArg.none()
if compList:
compSet = RooArgSet(compList)
if compSet.getSize() > 0:
compCmd = RooFit.Components(compSet)
removals = compList.selectByName('%s*' % component)
compList.remove(removals)
if not Silent:
print 'events', self.ws.function('f_%s_norm' % component).getVal()
sys.stdout.flush()
if abs(self.ws.function('f_%s_norm' % component).getVal()) >= 1.:
pdf.plotOn(sframe, #RooFit.ProjWData(data),
RooFit.DrawOption('LF'), RooFit.FillStyle(1001),
RooFit.FillColor(plotCharacteristics['color']),
RooFit.LineColor(plotCharacteristics['color']),
RooFit.VLines(),
RooFit.Range('plotRange'),
RooFit.NormRange('plotRange'),
RooFit.Normalization(nexp, RooAbsReal.NumEvent),
compCmd
)
tmpCurve = sframe.getCurve()
tmpCurve.SetName(component)
tmpCurve.SetTitle(plotCharacteristics['title'])
if 'visible' in plotCharacteristics:
sframe.setInvisible(component,
plotCharacteristics['visible'])
data.plotOn(sframe, RooFit.Name('theData'),
RooFit.Binning('plotBins'))
sframe.getHist('theData').SetTitle('data')
# theData = RooHist(dataHist, 1., 1, RooAbsData.SumW2, 1.0, True)
# theData.SetName('theData')
# theData.SetTitle('data')
# sframe.addPlotable(theData, 'pe')
if (logy):
sframe.SetMinimum(0.01)
sframe.SetMaximum(1.0e6)
else:
sframe.SetMaximum(sframe.GetMaximum()*1.35)
pass
excluded = (var in self.pars.exclude)
bname = var
if not excluded:
for v in self.pars.exclude:
if hasattr(self.pars, 'varNames') and \
(self.pars.varNames[v] == var):
excluded = True
bname = v
if excluded:
blinder = TBox(self.pars.exclude[bname][0], sframe.GetMinimum(),
self.pars.exclude[bname][1], sframe.GetMaximum())
# blinder.SetName('blinder')
# blinder.SetTitle('signal region')
blinder.SetFillColor(kBlack)
if self.pars.blind:
blinder.SetFillStyle(1001)
else:
blinder.SetFillStyle(0)
blinder.SetLineStyle(2)
sframe.addObject(blinder)
elif self.pars.blind:
if not Silent:
print "blind but can't find exclusion region for", var
print 'excluded',excluded,self.pars.exclude
print 'hiding data points'
sframe.setInvisible('theData', True)
else:
sframe.setInvisible('theData', False)
#sframe.GetYaxis().SetTitle('Events / GeV')
# dataHist.IsA().Destructor(dataHist)
if not Silent:
print
xvar.setBins(nbins)
return sframe
def fit(self, keepParameterValues = False):
print 'construct fit pdf ...'
fitter = self.makeFitter()
print 'load data ...'
data = self.loadData()
self.resetYields()
constraintSet = self.makeConstraints()
if not keepParameterValues:
self.readParametersFromFile()
self.resetYields()
# print constraints, self.pars.yieldConstraints
print '\nfit constraints'
constIter = constraintSet.createIterator()
constraint = constIter.Next()
constraints = []
while constraint:
constraint.Print()
constraints.append(constraint.GetName())
constraint = constIter.Next()
constraintCmd = RooCmdArg.none()
if constraintSet.getSize() > 0:
constraints.append(fitter.GetName())
fitter = self.ws.pdf('totalFit_const')
if not fitter:
fitter = self.ws.factory('PROD::totalFit_const(%s)' % \
(','.join(constraints))
)
constraintCmd = RooFit.Constrained()
# constraintCmd = RooFit.ExternalConstraints(self.ws.set('constraintSet'))
if self.useImportPars:
self.ws.loadSnapshot('importParams')
self.ws.Print()
# for constraint in pars.constraints:
# self.ws.pdf(constraint).Print()
# print
rangeCmd = RooCmdArg.none()
if self.rangeString and self.pars.doExclude:
rangeCmd = RooFit.Range(self.rangeString)
print 'fitting ...'
fr = fitter.fitTo(data, RooFit.Save(True),
RooFit.Extended(True),
RooFit.Minos(False),
RooFit.PrintEvalErrors(-1),
RooFit.Warnings(False),
constraintCmd,
rangeCmd)
fr.Print()
return fr
def main():
output = argv[1]
rap = argv[2]
flavour = argv[3]
trackType = argv[4]
funct = argv[5]
fit_min = int(argv[6])
fit_max = int(argv[7])
rebinFactor = int(argv[8])
i = int(argv[9])
if funct == "CB":
DOCRYSTALBALL = True
DOCRUIJFF = False
DODOUBLECB = False
elif funct == "cruijff":
DOCRUIJFF = True
DOCRYSTALBALL = False
DODOUBLECB = False
elif funct == "doubleCB":
DODOUBLECB = True
DOCRYSTALBALL = False
DOCRUIJFF = False
print("+++++++++++++++++++++++++++++++++++++++++")
print("Fitting histogram for %d < pt_{l} <%d" % (ptbins[i], ptbins[i + 1]))
print("+++++++++++++++++++++++++++++++++++++++++\n")
wsFile = TFile("tmpWorkspace.root")
ws = wsFile.Get("tempWS")
# fit with a gaussian
if DOCRYSTALBALL:
funct = TF1("crystal", "crystalball", fit_min, fit_max)
funct.SetLineColor(kRed)
if ws.data("hist").sum(False) < 1500:
nDOF = (fit_max - fit_min) * 2 / (rebinFactor * 4) - 3
else:
nDOF = (fit_max - fit_min) * 2 / rebinFactor - 3
ws.factory(
"RooCBShape::cb(mass, mean[0.0], sigma[2,0,10], alphaL[3,-25,25], nL[5,-25,25])"
)
ws.factory("BreitWigner::bw(mass,meanZ[91.187], width[2.495])")
bw = ws.pdf("bw")
cb = ws.pdf("cb")
ws.var("mass").setBins(2000, "cache")
ws.var("mass").setMin("cache", 0)
ws.var("mass").setMax("cache", 1000)
## need to be adjusted to be higher than limit setting
sigpdf = RooFFTConvPdf("sig", "sig", ws.var("mass"), bw, cb)
getattr(ws, 'import')(sigpdf, RooCmdArg())
fitResult = ws.pdf("sig").fitTo(ws.data("hist"), RooFit.Save(),
RooFit.SumW2Error(kFALSE),
RooFit.Minos(kFALSE))
elif DOCRUIJFF:
gSystem.Load("./RooCruijff_cxx.so")
ws.factory(
"RooCruijff::cb(mass, mean[0.0], sigma[2,0,20], sigma, alphaL[1,0,25], alphaR[1,0,25])"
)
if ws.data("hist").sum(False) < 1500:
nDOF = (fit_max - fit_min) * 2 / (6) - 3
elif ws.data("hist").sum(False) < 2500:
nDOF = (fit_max - fit_min) * 2 / (4) - 3
else:
nDOF = (fit_max - fit_min) * 2 / rebinFactor - 3
ws.factory("BreitWigner::bw(mass,meanZ[91.187], width[2.495])")
bw = ws.pdf("bw")
cb = ws.pdf("cb")
ws.var("mass").setBins(2000, "cache")
ws.var("mass").setMin("cache", 0)
ws.var("mass").setMax("cache", 1000)
## need to be adjusted to be higher than limit setting
sigpdf = RooFFTConvPdf("sig", "sig", ws.var("mass"), bw, cb)
getattr(ws, 'import')(sigpdf, RooCmdArg())
fitResult = ws.pdf("sig").fitTo(ws.data("hist"), RooFit.Save(),
RooFit.SumW2Error(kFALSE),
RooFit.Minos(kFALSE))
elif DODOUBLECB:
gSystem.Load("./RooDCBShape_cxx.so")
ws.factory(
"RooDCBShape::cb(mass, mean[0.0,-1.5,1.5], sigma[2,0,20], alphaL[2,0,25] , alphaR[2,0,25], nL[1.5,0,25], nR[1.5,0,25])"
)
if i == 0:
ws.var("nL").setVal(1)
ws.var("nR").setVal(1)
ws.factory("BreitWigner::bw(mass,meanZ[91.187], width[2.495])")
bw = ws.pdf("bw")
cb = ws.pdf("cb")
ws.var("mass").setBins(2000, "cache")
ws.var("mass").setMin("cache", 0)
ws.var("mass").setMax("cache", 1000)
## need to be adjusted to be higher than limit setting
sigpdf = RooFFTConvPdf("sig", "sig", ws.var("mass"), bw, cb)
getattr(ws, 'import')(sigpdf, RooCmdArg())
fitResult = ws.pdf("sig").fitTo(ws.data("hist"), RooFit.Save(),
RooFit.SumW2Error(kFALSE),
RooFit.Minos(kFALSE))
chi2 = RooChi2Var("bla", "blubb", ws.pdf("sig"),
ws.data("hist")).getVal()
if ws.data("hist").sum(False) < 1500:
nDOF = (fit_max - fit_min) * 2 / (6) - 5
elif ws.data("hist").sum(False) < 2500:
nDOF = (fit_max - fit_min) * 2 / (4) - 5
else:
nDOF = (fit_max - fit_min) * 2 / rebinFactor - 5
chi2 = RooChi2Var("bla", "blubb", ws.pdf("sig"), ws.data("hist")).getVal()
nDOFforWS = RooRealVar('nDOF', 'nDOF', nDOF)
getattr(ws, 'import')(nDOFforWS, RooCmdArg())
chi2forWS = RooRealVar('chi2', 'chi2', chi2)
getattr(ws, 'import')(chi2forWS, RooCmdArg())
mean = RooRealVar('Mean', 'Mean', ws.var("meanZ").getVal())
getattr(ws, 'import')(mean, RooCmdArg())
meane = RooRealVar('Meane', 'Meane', ws.var("meanZ").getError())
getattr(ws, 'import')(meane, RooCmdArg())
sig = RooRealVar('Sig', 'Sig', ws.var("sigma").getVal())
getattr(ws, 'import')(sig, RooCmdArg())
sige = RooRealVar('Sige', 'Sige', ws.var("sigma").getError())
getattr(ws, 'import')(sige, RooCmdArg())
c1 = TCanvas("c1", "c1", 700, 700)
c1.cd()
plotPad = TPad("plotPad", "plotPad", 0, 0, 1, 1)
style = setTDRStyle()
gStyle.SetOptStat(0)
gStyle.SetTitleXOffset(1.45)
gStyle.SetPadLeftMargin(0.2)
gStyle.SetTitleYOffset(2)
plotPad.UseCurrentStyle()
plotPad.Draw()
plotPad.cd()
if DODOUBLECB or DOCRYSTALBALL or DOCRUIJFF:
ws.var("mass").setBins(30)
frame = ws.var('mass').frame(
RooFit.Title('Invariant mass of dimuon pairs'))
frame.GetXaxis().SetTitle('m_{#mu#mu} [GeV]')
frame.GetYaxis().SetTitle("Events / 2 GeV")
RooAbsData.plotOn(ws.data('hist'), frame, RooFit.Name("hist"))
ws.pdf('sig').plotOn(frame, RooFit.Name("sig"))
frame.Draw()
#chi2 = frame.chiSquare("sig","hist",nDOF)
else:
h.GetXaxis().SetTitle("m_{ll} [GeV]")
h.SetLineColor(kBlack)
h.GetXaxis().SetRangeUser(fit_min, fit_max)
h.SetMarkerStyle(20)
h.SetMarkerSize(0.7)
h.Draw("E")
if DOCRYSTALBALL or DOCRUIJFF or DODOUBLECB:
funct.Draw("SAME")
else:
gaus.Draw("SAME")
latex = TLatex()
latex.SetTextFont(42)
latex.SetTextAlign(31)
latex.SetTextSize(0.04)
latex.SetNDC(True)
latexCMS = TLatex()
latexCMS.SetTextFont(61)
latexCMS.SetTextSize(0.055)
latexCMS.SetNDC(True)
latexCMSExtra = TLatex()
latexCMSExtra.SetTextFont(52)
latexCMSExtra.SetTextSize(0.03)
latexCMSExtra.SetNDC(True)
latex.DrawLatex(0.95, 0.96, "(13 TeV)")
cmsExtra = "Preliminary"
latexCMS.DrawLatex(0.78, 0.88, "CMS")
yLabelPos = 0.84
latexCMSExtra.DrawLatex(0.78, yLabelPos, "%s" % (cmsExtra))
latexFit1 = TLatex()
latexFit1.SetTextFont(42)
latexFit1.SetTextSize(0.035)
latexFit1.SetNDC(True)
latexFit1.DrawLatex(0.25, 0.84,
"%d GeV < p_{T} < %d GeV" % (ptbins[i], ptbins[i + 1]))
latexFit = TLatex()
latexFit.SetTextFont(42)
latexFit.SetTextSize(0.030)
latexFit.SetNDC(True)
latexFit.DrawLatex(
0.25, 0.74, "%s = %5.3g #pm %5.3g GeV" %
("mean bias", ws.var("mean").getVal(), ws.var("mean").getError()))
if funct == "CB":
latexFit.DrawLatex(
0.25, 0.7, "%s = %5.3g #pm %5.3g GeV" %
("#sigma", ws.var("sigma").getVal(), ws.var("sigma").getError()))
latexFit.DrawLatex(
0.25, 0.66, "%s = %5.3g #pm %5.3g" %
("alphaL", ws.var("alphaL").getVal(), ws.var("alphaL").getError()))
latexFit.DrawLatex(
0.25, 0.62, "%s = %5.3g #pm %5.3g" %
("nL", ws.var("nL").getVal(), ws.var("nL").getError()))
if funct == "cruijff":
latexFit.DrawLatex(
0.25, 0.7, "%s = %5.3g #pm %5.3g GeV" %
("#sigma", ws.var("sigma").getVal(), ws.var("sigma").getError()))
latexFit.DrawLatex(
0.25, 0.66, "%s = %5.3g #pm %5.3g" %
("alphaL", ws.var("alphaL").getVal(), ws.var("alphaL").getError()))
latexFit.DrawLatex(
0.25, 0.62, "%s = %5.3g #pm %5.3g" %
("alphaR", ws.var("alphaR").getVal(), ws.var("alphaR").getError()))
if funct == "doubleCB":
latexFit.DrawLatex(
0.25, 0.7, "%s = %5.3g #pm %5.3g GeV" %
("#sigma", ws.var("sigma").getVal(), ws.var("sigma").getError()))
latexFit.DrawLatex(
0.25, 0.66, "%s = %5.3g #pm %5.3g" %
("alphaL", ws.var("alphaL").getVal(), ws.var("alphaL").getError()))
latexFit.DrawLatex(
0.25, 0.62, "%s = %5.3g #pm %5.3g" %
("alphaR", ws.var("alphaR").getVal(), ws.var("alphaR").getError()))
latexFit.DrawLatex(
0.25, 0.58, "%s = %5.3g #pm %5.3g" %
("nL", ws.var("nL").getVal(), ws.var("nL").getError()))
latexFit.DrawLatex(
0.25, 0.54, "%s = %5.3g #pm %5.3g" %
("nR", ws.var("nR").getVal(), ws.var("nR").getError()))
latexFit.DrawLatex(
0.25, 0.5,
"#chi^{2}/ndf = %5.1f / %2.0f = %4.2f" % (chi2, nDOF, chi2 / nDOF))
saveas = "/MassRes_%s_%s_Pt%d_%d_%s" % (trackType, flavour, ptbins[i],
ptbins[i + 1], rap)
c1.SaveAs(output + saveas + ".root")
c1.SaveAs(output + saveas + ".C")
c1.SaveAs(output + saveas + ".png")
c1.SaveAs(output + saveas + ".pdf")
print("DONE Fitting...")
ws.writeToFile("tmpWorkspaceReturn.root")
def ueberPlot(w,plotName,plotVar,cpus,mixState,massCat,cut,dataArr,varMax=-1,asym=False,numBins=False):
frame = False
if numBins!=False:
frame = plotVar.frame(plotVar.getMin(),varMax if varMax != -1 else plotVar.getMax(),numBins)
else:
frame = plotVar.frame(plotVar.getMin(),varMax if varMax != -1 else plotVar.getMax())
dsName = "dsBinnedMassCat-"+cut
dataRedArr = []
i=0
for data in dataArr:
dataRedArr.append((getattr(data,"reduce")(RooFit.CutRange(cut)),i))
i += 1
visRooCmdArg = RooCmdArg.none()
if config['visError'] and (config['doFit'] or config['loadFit']):
if r.covQual() == 3:
visRooCmdArg = RooFit.VisualizeError(r)
if massCat != "":
massCat = massCat + "_"
asymVar = asym
if mixState == "":
oscSlice = RooCmdArg.none()
elif mixState == "Mixed":
oscSlice = RooFit.Slice(B0_OSCIL,"Oscil")
elif mixState == "Unmixed":
oscSlice = RooFit.Slice(B0_OSCIL,"NonOscil")
#elif mixState == "Pos":
#oscSlice = RooFit.Slice(w.obj("Mu_CHARGE_CAT"),"positive")
#elif mixState == "Neg":
#oscSlice = RooFit.Slice(w.obj("Mu_CHARGE_CAT"),"negitive")
if config["mode"] is "mc":
pdfName = "Sig"
if config["mode"] is "mcpipi":
pdfName = "PiPi"
elif config["mode"] is "datapretoy":
pdfName = "Comb_Blind"
else:
pdfName = "Final_PDF"
cpus = 1
#dataB.Print()
if not asym:
print "Plotting:" ,plotName
sys.stdout.flush()
for data,icolour in dataRedArr:
binning = ROOT.RooCmdArg.none()
if bins != False:
binning = RooFit.Binning(bins, frame.GetMinimum(), frame.GetMaximum())
data.plotOn(frame, RooFit.MarkerColor(colours[icolour]), RooFit.MarkerSize(0.8))
#for component, lineColour in [ ["*TM_Side1", ROOT.kRed], ["*TM_Side2", ROOT.kGreen], ["*TM_Peak_*", ROOT.kOrange], ["*TM_Sig_Bs", ROOT.kMagenta], ["*TM_Sig_Bd,*TM_Sig_Bd_in_Bs", ROOT.kMagenta+2], ["*TM_Bplus*",ROOT.kGray+1], ["*TM_Sig_BdDStar", ROOT.kCyan], ["*", ROOT.kBlue] ]:
for component, lineColour, lineStyle, fillColour, fillStyle, lineWidth in componantColours:
arguments = RooLinkedList()
for arg in [RooFit.Components(component), RooFit.LineColor(lineColour), RooFit.LineStyle(lineStyle), RooFit.LineWidth(lineWidth), RooFit.FillColor(fillColour), RooFit.FillStyle(fillStyle), RooFit.Precision(1e-4)]:
arguments.Add(arg)
if fillStyle is not 0:
arguments.Add(RooFit.DrawOption("F"))
if mixState == "Mixed":
arguments.Add(RooFit.Slice(B0_OSCIL,"Oscil"))
elif mixState == "Unmixed":
arguments.Add(RooFit.Slice(B0_OSCIL,"NonOscil"))
if config['visError'] and (config['doFit'] or config['loadFit']):
if r.covQual() == 3:
arguments.Add(RooFit.VisualizeError(r))
#print("+")
if massCat == "":
dataB = RooDataHist(dsName, dsName, RooArgSet(w.obj("DataSet")), dataRedArr[-1][0], 1.0)
arguments.Add(RooFit.ProjWData(dataB))
#arguments.Add(RooFit.NumCPU(nCPUs,kTRUE))
if cut != "":
arguments.Add(RooFit.ProjectionRange(cut))
arguments.Add(RooFit.NormRange(cut))
#largePlotOn(TM_Total, frame, RooFit.ProjectionRange(cut), RooFit.NormRange(cut), RooFit.ProjWData(dataB), RooFit.NumCPU(nCPUs,kTRUE), RooFit.Components(component), RooFit.LineColor(lineColour), RooFit.LineStyle(lineStyle), RooFit.FillColor(fillColour), RooFit.FillStyle(fillStyle), RooFit.Precision(1e-4), visRooCmdArg, oscSlice)
#TM_Total.plotOn(frame, RooFit.ProjectionRange(cut), RooFit.NormRange(cut), RooFit.ProjWData(dataB), RooFit.NumCPU(nCPUs,kTRUE), RooFit.Components(component), RooFit.LineColor(lineColour), RooFit.LineStyle(lineStyle), RooFit.FillColor(fillColour), RooFit.FillStyle(fillStyle), RooFit.DrawOption("F"), RooFit.Precision(1e-4), visRooCmdArg, oscSlice) #12 args
Final_PDF.plotOn(frame, arguments)
else:
#TM_Total.plotOn(frame, RooFit.ProjWData(dataB), RooFit.NumCPU(nCPUs,kTRUE), RooFit.Components(component), RooFit.LineColor(lineColour), RooFit.LineStyle(lineStyle), RooFit.FillColor(fillColour), RooFit.FillStyle(fillStyle), RooFit.Precision(1e-4), visRooCmdArg, oscSlice) #10 args
Final_PDF.plotOn(frame, arguments)
dataB.Delete()
else:
if config['visError'] and (config['doFit'] or config['loadFit']):
if r.covQual() == 3:
arguments.Add(RooFit.VisualizeError(r))
if cut != "":
arguments.Add(RooFit.ProjectionRange(cut))
arguments.Add(RooFit.NormRange(cut))
#w.obj(massCat+"Final_PDF").plotOn(frame, RooFit.ProjectionRange(cut), RooFit.NormRange(cut), RooFit.Components(component), RooFit.LineColor(lineColour), RooFit.LineStyle(lineStyle), RooFit.FillColor(fillColour), RooFit.FillStyle(fillStyle), RooFit.Precision(1e-4), visRooCmdArg, oscSlice) #10 args
w.obj(massCat+pdfName).plotOn(frame, arguments)
else:
#w.obj(massCat+"Final_PDF").plotOn(frame, RooFit.Components(component), RooFit.LineColor(lineColour), RooFit.LineStyle(lineStyle), RooFit.FillColor(fillColour), RooFit.FillStyle(fillStyle), RooFit.Precision(1e-4), visRooCmdArg, oscSlice) #8 args
w.obj(massCat+pdfName).plotOn(frame, arguments)
for data,icolour in dataRedArr:
data.plotOn(frame, RooFit.MarkerColor(colours[icolour]), RooFit.MarkerSize(0.8))
else: # its an asym plot
print "Plotting:" ,plotName
sys.stdout.flush()
timeThisBit = TStopwatch()
timeThisBit.Start()
for data,icolour in dataRedArr:
data.plotOn(frame, RooFit.Asymmetry(asymVar), RooFit.MarkerColor(coloursAsym[icolour]),RooFit.Binning(numBins))
arguments = RooLinkedList()
for arg in [RooFit.Asymmetry(asymVar), RooFit.LineColor(ROOT.kRed), RooFit.Precision(1e-4)]:
arguments.Add(arg)
if massCat == "":
dataB = RooDataHist(dsName, dsName, RooArgSet(w.obj("DataSet")), dataRedArr[-1][0], 1.0)
dataB.Print()
print "nCPUs:",nCPUs
if visRooCmdArg != RooCmdArg.none():
print "Ignoring the visualise errors command when creating asymmetry plots over multiple categories"
if cut != "":
arguments.Add(RooFit.ProjectionRange(cut))
arguments.Add(RooFit.NormRange(cut))
arguments.Add(RooFit.ProjWData(dataB))
#TM_Total.plotOn(frame, RooFit.Asymmetry(asymVar), RooFit.ProjectionRange(cut), RooFit.NormRange(cut), RooFit.ProjWData(dataB), RooFit.NumCPU(nCPUs,kTRUE), RooFit.LineColor(ROOT.kRed), RooFit.Precision(1e-4))
Final_PDF.plotOn(frame, arguments)
else:
#TM_Total.plotOn(frame, RooFit.Asymmetry(asymVar), RooFit.ProjWData(dataB), RooFit.NumCPU(nCPUs,kTRUE), RooFit.LineColor(ROOT.kRed), RooFit.Precision(1e-4))
Final_PDF.plotOn(frame, arguments)
dataB.Delete()
else:
if cut != "":
arguments.Add(RooFit.ProjectionRange(cut))
arguments.Add(RooFit.NormRange(cut))
#w.obj(massCat+"Final_PDF").plotOn(frame, RooFit.Asymmetry(asymVar), RooFit.ProjectionRange(cut), RooFit.NormRange(cut), RooFit.NumCPU(1), RooFit.LineColor(ROOT.kRed), RooFit.Precision(1e-4), visRooCmdArg)
w.obj(massCat+pdfName).plotOn(frame, arguments)
else:
#w.obj(massCat+"Final_PDF").plotOn(frame, RooFit.Asymmetry(asymVar), RooFit.NumCPU(1), RooFit.LineColor(ROOT.kRed), RooFit.Precision(1e-4), visRooCmdArg)
w.obj(massCat+pdfName).plotOn(frame, arguments)
frame.SetAxisRange(-.4,.4,"y")
timeThisBit.Stop()
timeThisBit.Print()
for data,icolour in dataRedArr:
data.Delete()
sys.stdout.flush()
return frame
def stackedPlot(self, var, logy = False, pdfName = None, Silent = False):
if not pdfName:
pdfName = 'total'
xvar = self.ws.var(var)
nbins = xvar.getBins()
if hasattr(self.pars, 'plotRanges'):
xvar.setRange('plotRange', self.pars.plotRanges[var][1],
self.pars.plotRanges[var][2])
xvar.setBins(self.pars.plotRanges[var][0], 'plotBins')
else:
xvar.setRange('plotRange', xvar.getMin(), xvar.getMax())
xvar.setBins(nbins, 'plotBins')
sframe = xvar.frame()
sframe.SetName("%s_stacked" % var)
pdf = self.ws.pdf(pdfName)
if isinstance(pdf, RooAddPdf):
compList = RooArgList(pdf.pdfList())
else:
compList = None
data = self.ws.data('data_obs')
nexp = pdf.expectedEvents(self.ws.set('obsSet'))
if not Silent:
print pdf.GetName(),'expected: %.0f' % (nexp)
print 'data events: %.0f' % (data.sumEntries())
if nexp < 1:
nexp = data.sumEntries()
theComponents = []
if self.pars.includeSignal:
theComponents += self.pars.signals
theComponents += self.pars.backgrounds
data.plotOn(sframe, RooFit.Invisible(),
RooFit.Binning('plotBins'))
# dataHist = RooAbsData.createHistogram(data,'dataHist_%s' % var, xvar,
# RooFit.Binning('%sBinning' % var))
# #dataHist.Scale(1., 'width')
# invData = RooHist(dataHist, 1., 1, RooAbsData.SumW2, 1.0, False)
# #invData.Print('v')
# sframe.addPlotable(invData, 'pe', True, True)
for (idx,component) in enumerate(theComponents):
if not Silent:
print 'plotting',component,'...',
if hasattr(self.pars, '%sPlotting' % (component)):
plotCharacteristics = getattr(self.pars, '%sPlotting' % \
(component))
else:
plotCharacteristics = {'color' : colorwheel[idx%6],
'title' : component }
compCmd = RooCmdArg.none()
if compList:
compSet = RooArgSet(compList)
if compSet.getSize() > 0:
compCmd = RooFit.Components(compSet)
removals = compList.selectByName('%s*' % component)
compList.remove(removals)
if not Silent:
print 'events', self.ws.function('f_%s_norm' % component).getVal()
sys.stdout.flush()
if abs(self.ws.function('f_%s_norm' % component).getVal()) >= 1.:
pdf.plotOn(sframe, #RooFit.ProjWData(data),
RooFit.DrawOption('LF'), RooFit.FillStyle(1001),
RooFit.FillColor(plotCharacteristics['color']),
RooFit.LineColor(plotCharacteristics['color']),
RooFit.VLines(),
RooFit.Range('plotRange'),
RooFit.NormRange('plotRange'),
RooFit.Normalization(nexp, RooAbsReal.NumEvent),
compCmd
)
tmpCurve = sframe.getCurve()
tmpCurve.SetName(component)
tmpCurve.SetTitle(plotCharacteristics['title'])
if 'visible' in plotCharacteristics:
sframe.setInvisible(component,
plotCharacteristics['visible'])
data.plotOn(sframe, RooFit.Name('theData'),
RooFit.Binning('plotBins'))
sframe.getHist('theData').SetTitle('data')
# theData = RooHist(dataHist, 1., 1, RooAbsData.SumW2, 1.0, True)
# theData.SetName('theData')
# theData.SetTitle('data')
# sframe.addPlotable(theData, 'pe')
if (logy):
sframe.SetMinimum(0.01)
sframe.SetMaximum(1.0e6)
else:
sframe.SetMaximum(sframe.GetMaximum()*1.35)
pass
excluded = (var in self.pars.exclude)
bname = var
if not excluded:
for v in self.pars.exclude:
if hasattr(self.pars, 'varNames') and \
(self.pars.varNames[v] == var):
excluded = True
bname = v
if excluded:
blinder = TBox(self.pars.exclude[bname][0], sframe.GetMinimum(),
self.pars.exclude[bname][1], sframe.GetMaximum())
# blinder.SetName('blinder')
# blinder.SetTitle('signal region')
blinder.SetFillColor(kBlack)
if self.pars.blind:
blinder.SetFillStyle(1001)
else:
blinder.SetFillStyle(0)
blinder.SetLineStyle(2)
sframe.addObject(blinder)
elif self.pars.blind:
if not Silent:
print "blind but can't find exclusion region for", var
print 'excluded',excluded,self.pars.exclude
print 'hiding data points'
sframe.setInvisible('theData', True)
#sframe.GetYaxis().SetTitle('Events / GeV')
# dataHist.IsA().Destructor(dataHist)
if not Silent:
print
xvar.setBins(nbins)
return sframe
def fit(self, keepParameterValues = False):
print 'construct fit pdf ...'
fitter = self.makeFitter()
print 'load data ...'
data = self.loadData()
self.resetYields()
constraintSet = self.makeConstraints()
if not keepParameterValues:
self.readParametersFromFile()
self.resetYields()
# print constraints, self.pars.yieldConstraints
print '\nfit constraints'
constIter = constraintSet.createIterator()
constraint = constIter.Next()
constraints = []
while constraint:
constraint.Print()
constraints.append(constraint.GetName())
constraint = constIter.Next()
constraintCmd = RooCmdArg.none()
if constraintSet.getSize() > 0:
constraints.append(fitter.GetName())
fitter = self.ws.pdf('totalFit_const')
if not fitter:
fitter = self.ws.factory('PROD::totalFit_const(%s)' % \
(','.join(constraints))
)
constraintCmd = RooFit.Constrained()
# constraintCmd = RooFit.ExternalConstraints(self.ws.set('constraintSet'))
if self.useImportPars:
self.ws.loadSnapshot('importParams')
self.ws.Print()
# for constraint in pars.constraints:
# self.ws.pdf(constraint).Print()
# print
rangeCmd = RooCmdArg.none()
if self.rangeString and self.pars.doExclude:
rangeCmd = RooFit.Range(self.rangeString)
print 'fitting ...'
fr = fitter.fitTo(data, RooFit.Save(True),
RooFit.Extended(True),
RooFit.Minos(False),
RooFit.PrintEvalErrors(-1),
RooFit.Warnings(False),
constraintCmd,
rangeCmd)
fr.Print()
return fr
def main():
c1 = ROOT.TCanvas("Data", "Data", 600, 600)
c1.Divide(1, 1)
c2 = ROOT.TCanvas("MC", "MC", 600, 600)
c2.Divide(2, 2)
c3 = ROOT.TCanvas("MC RooHistPdfs", "MC RooHistPdfs", 600, 600)
c3.Divide(2, 2)
lo = 0
hi = 10
x = ROOT.RooRealVar("x", "x", lo, hi)
frame = x.frame()
############################################################################
# Generate a fake dataset
# This is where you would read in the "real" data
############################################################################
data = []
# Signal
data += np.random.normal(2, 0.5, 500).tolist()
# Background
data += np.random.normal(7, 1.5, 800).tolist()
data += ((hi - lo) * np.random.random(3000) + lo).tolist()
roodataset = ROOT.RooDataSet("roodataset", "roodataset", RooArgSet(x))
for d in data:
if d > lo and d < hi:
x.setVal(d)
roodataset.add(RooArgSet(x))
roodataset.plotOn(frame)
dhdata = RooDataHist("dhdata", "dhdata", RooArgSet(x), roodataset)
############################################################################
# Generate the fake MC samples
# This is where you would read in the "real" MC samples
############################################################################
MC_samples = []
nbins = 50
hmc0 = ROOT.TH1F("hmc0", "hmc0", nbins, lo, hi)
hmc1 = ROOT.TH1F("hmc1", "hmc1", nbins, lo, hi)
hmc2 = ROOT.TH1F("hmc2", "hmc2", nbins, lo, hi)
#xmc0 = ROOT.RooRealVar("xmc0","xmc0",lo,hi);
#xmc1 = ROOT.RooRealVar("xmc1","xmc1",lo,hi);
#xmc2 = ROOT.RooRealVar("xmc2","xmc2",lo,hi);
mcdataset0 = ROOT.RooDataSet("roodatasetmc0", "roodatasetmc0",
RooArgSet(x))
mcdataset1 = ROOT.RooDataSet("roodatasetmc1", "roodatasetmc1",
RooArgSet(x))
mcdataset2 = ROOT.RooDataSet("roodatasetmc2", "roodatasetmc2",
RooArgSet(x))
# Sample 0 - Signal
mc = np.random.normal(2, 0.5, 10000)
for m in mc:
if m > lo and m < hi:
hmc0.Fill(m)
x.setVal(m)
mcdataset0.add(RooArgSet(x))
# Sample 1 - Background
mc = np.random.normal(7, 1.5, 10000)
for m in mc:
if m > lo and m < hi:
hmc1.Fill(m)
x.setVal(m)
mcdataset1.add(RooArgSet(x))
# Sample 2 - Background
mc = ((hi - lo) * np.random.random(10000) + lo)
for m in mc:
if m > lo and m < hi:
hmc2.Fill(m)
x.setVal(m)
mcdataset2.add(RooArgSet(x))
c2.cd(1)
hmc0.SetMinimum(0)
hmc0.Draw()
c2.cd(2)
hmc1.SetMinimum(0)
hmc1.Draw()
c2.cd(3)
hmc2.SetMinimum(0)
hmc2.Draw()
framemc0 = x.frame()
framemc1 = x.frame()
framemc2 = x.frame()
c3.cd(1)
x.setBins(nbins)
mcdataset0.plotOn(framemc0)
framemc0.Draw()
c3.cd(2)
x.setBins(nbins)
mcdataset1.plotOn(framemc1)
framemc1.Draw()
c3.cd(3)
x.setBins(nbins)
mcdataset2.plotOn(framemc2)
framemc2.Draw()
# Now make the RooHistPdfs and construct the model
dhmc0 = RooDataHist("hdmc0", "hdmc0", RooArgSet(x), mcdataset0)
mcpdf0 = RooHistPdf("mcpdf0", "mcpdf0", RooArgSet(x), dhmc0)
dhmc1 = RooDataHist("hdmc1", "hdmc1", RooArgSet(x), mcdataset1)
mcpdf1 = RooHistPdf("mcpdf1", "mcpdf1", RooArgSet(x), dhmc1)
dhmc2 = RooDataHist("hdmc2", "hdmc2", RooArgSet(x), mcdataset2)
mcpdf2 = RooHistPdf("mcpdf2", "mcpdf2", RooArgSet(x), dhmc2)
a0 = RooRealVar("a0", "a0", 500, 100, 1500)
a1 = RooRealVar("a1", "a1", 800, 100, 1500)
a2 = RooRealVar("a2", "a2", 3000, 1000, 10000)
model = RooAddPdf("model", "Three HistPdfs",
RooArgList(mcpdf0, mcpdf1, mcpdf2),
RooArgList(a0, a1, a2))
#model.fitTo(dhdata,RooCmdArg("mhe"))
model.fitTo(roodataset, RooCmdArg("mhe"))
model.plotOn(frame)
c1.cd(1)
frame.Draw()
c1.Draw()
rep = ''
while not rep in ['q', 'Q']:
rep = input('enter "q" to quit: ')
if 1 < len(rep):
rep = rep[0]
