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 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 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]
