def plot(self, gD01, gDbar01, repeat=False):
N = gD01.GetN()
xD01 = gD01.GetX()
yD01 = gD01.GetY()
zD01 = gD01.GetZ()
xDbar01 = gDbar01.GetX()
yDbar01 = gDbar01.GetY()
zDbar01 = gDbar01.GetZ()
gr1 = TGraph2D(N)
gr1.SetName("delta" + self.obj)
for i in range(N):
x1 = xD01[i]
y1 = yD01[i]
if self.obj=="gAbs":
z1 = gDbar01.Interpolate(y1,x1) / zD01[i] * 100
else:
z1 = gDbar01.Interpolate(y1, x1) - zD01[i] * 100
if (z1 < 0):
z1 += 2 * pi
#z1 *= 1/(2*pi)
#z1 = zDbar01[i] - gD01.Interpolate(y1,x1)
gr1.SetPoint(i, x1, y1, z1)
xD1 = gr1.GetX()
yD1 = gr1.GetY()
zD1 = gr1.GetZ()
#set_palette()
theta = 89.9
phi=0.1
c1 = TCanvas("c1", "c1", 4000, 4000)
gPad.SetLeftMargin(0.1)
c1.cd()
titles = {
"gArg":"#delta_{D}",
"gAbs": "|A_{#bar{D}^{0}}|/|A_{D^{0}}|"
}
title = titles[self.obj]
if (repeat):
title = "#Delta" + title
gr1.SetTitle("%s ; m^{2}_{K_{S}^{0} #pi^{+}} ; m^{2}_{K_{S}^{0} #pi^{-}}" % (title))
gr1.GetXaxis().SetLabelOffset(15)
gr1.GetYaxis().SetLabelOffset(15)
gr1.GetZaxis().SetLabelOffset(15)
gr1.SetMargin(0.02)
gr1.Draw(self.draw2D)
gPad.SetTheta(theta)
gPad.SetPhi(phi)
gPad.SetLeftMargin(0.15)
gStyle.SetPalette(55)
gPad.Update()
c1.SaveAs("%s/Delta_%s.%s" % (self.output, self.obj, self.imgtype))
return gr1
def rooFit103():
print ">>> construct generic pdf from interpreted expression..."
# To construct a proper p.d.f, the formula expression is explicitly normalized internally
# by dividing it by a numeric integral of the expresssion over x in the range [-20,20]
x = RooRealVar("x", "x", -20, 20)
alpha = RooRealVar("alpha", "alpha", 5, 0.1, 10)
genpdf = RooGenericPdf("genpdf", "genpdf",
"(1+0.1*abs(x)+sin(sqrt(abs(x*alpha+0.1))))",
RooArgList(x, alpha))
print ">>> generate and fit toy data...\n"
data = genpdf.generate(RooArgSet(x), 10000) # RooDataSet
genpdf.fitTo(data)
frame1 = x.frame(Title("Interpreted expression pdf")) # RooPlot
data.plotOn(frame1, Binning(40))
genpdf.plotOn(frame1)
print "\n>>> construct standard pdf with formula replacing parameter..."
mean2 = RooRealVar("mean2", "mean^2", 10, 0, 200)
sigma = RooRealVar("sigma", "sigma", 3, 0.1, 10)
mean = RooFormulaVar("mean", "mean", "sqrt(mean2)", RooArgList(mean2))
gaus2 = RooGaussian("gaus2", "gaus2", x, mean, sigma)
print ">>> generate and fit toy data...\n"
gaus1 = RooGaussian("gaus1", "gaus1", x, RooConst(10), RooConst(3))
data2 = gaus1.generate(RooArgSet(x), 1000) # RooDataSet
result = gaus2.fitTo(data2, Save()) # RooFitResult
result.Print()
frame2 = x.frame(Title("Tailored Gaussian pdf")) # RooPlot
data2.plotOn(frame2, Binning(40))
gaus2.plotOn(frame2)
print "\n>>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600)
canvas.Divide(2)
canvas.cd(1)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
canvas.cd(2)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame2.GetYaxis().SetLabelOffset(0.008)
frame2.GetYaxis().SetTitleOffset(1.6)
frame2.GetYaxis().SetTitleSize(0.045)
frame2.GetXaxis().SetTitleSize(0.045)
frame2.Draw()
canvas.SaveAs("rooFit103.png")
def rooFit101():
print ">>> build gaussian pdf..."
x = RooRealVar("x", "x", -10, 10)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, sigma)
print ">>> plot pdf..."
frame1 = x.frame(Title("Gaussian pdf")) # RooPlot
#xframe.SetTitle("Gaussian pdf")
gauss.plotOn(frame1)
print ">>> change parameter value and plot..."
sigma.setVal(3)
gauss.plotOn(frame1, LineColor(kRed))
print ">>> generate events..."
data = gauss.generate(RooArgSet(x), 10000) # RooDataSet
frame2 = x.frame()
data.plotOn(frame2, Binning(40))
gauss.plotOn(frame2)
print ">>> fit gaussian...\n"
gauss.fitTo(data)
mean.Print()
sigma.Print()
print "\n>>> draw pdfs and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600)
canvas.Divide(2)
canvas.cd(1)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.6)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
canvas.cd(2)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame2.GetYaxis().SetLabelOffset(0.008)
frame2.GetYaxis().SetTitleOffset(1.6)
frame2.GetYaxis().SetTitleSize(0.045)
frame2.GetXaxis().SetTitleSize(0.045)
frame2.Draw()
canvas.SaveAs("rooFit101.png")
def plot_theta():
#polar angle of generated photons
tbin = 0.01
tmax = 3
can = ut.box_canvas()
ht = ut.prepare_TH1D("ht", tbin, 0, tmax)
tree.Draw("(TMath::Pi()-phot_theta)*1000 >> ht")
ht.SetYTitle("Events / ({0:.3f}".format(tbin) + " mrad)")
ht.SetXTitle("#vartheta (mrad)")
ht.SetTitleOffset(1.5, "Y")
ht.SetTitleOffset(1.3, "X")
gPad.SetTopMargin(0.02)
gPad.SetRightMargin(0.025)
gPad.SetBottomMargin(0.1)
gPad.SetLeftMargin(0.11)
ht.Draw()
leg = ut.prepare_leg(0.2, 0.87, 0.18, 0.08, 0.035)
leg.AddEntry(None, "Angular distribution of Bethe-Heitler photons", "")
#leg.Draw("same")
gPad.SetLogy()
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def plotGroomed( obs="grthrust", filenames=[ "sjm136_test.root" ], ecm="136", logy=1, canv=None ):
thplotoptions= { "xmin": 0.0, "xmax": 0.5, "ymin": 0.005, "ymax": 50.0, "markerStyle": 20, "markerSize": 0.5, "title": "groomed Thrust", "xlabel": "1-T_{gr}", "ylabel": "1/\sigma d\sigma/d(1-T_{gr})", "logy":logy }
cpplotoptions= { "xmin": 0.0, "xmax": 1.0, "ymin": 0.03, "ymax": 30.0, "markerStyle": 20, "markerSize": 0.5, "title": "groomed C-parameter", "xlabel": "C_{gr}", "ylabel": "1/\sigma d\sigma/d(C_{gr})", "logy":logy }
plotopts= { "grthrust": thplotoptions, "grcpar": cpplotoptions }
if canv == None:
canv= TCanvas( "canv", obs+" "+ecm, 1200, 800 )
icanv= 0
for beta in [ "0.0", "1.0" ]:
for zcut in [ "0.05", "0.10", "0.15" ]:
icanv= icanv+1
canv.cd( icanv )
gPad.SetLeftMargin( 0.15 )
gPad.SetRightMargin( 0.025 )
key= obs + "_" + beta + "_" + zcut
print key
aogr= createCombineAnalysisObservables( filenames, key )
aogr.plot( plotopts[obs] )
tl= TLegend( 0.4, 0.8, 0.85, 0.85 )
tl.SetTextSize( 0.05 )
tl.SetBorderSize( 0 )
tl.AddEntry( key, "OPAL "+ecm+" GeV", "ep" )
tl.Draw( "same" )
txt= TLatex( 0.6, 0.7, "#beta="+beta+ " z_{cut}="+zcut )
txt.SetNDC( True )
txt.SetTextSize( 0.035 )
txt.Draw()
return
def rooFit106():
print ">>> setup model..."
x = RooRealVar("x", "x", -3, 3)
mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10)
sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10)
gauss = RooGaussian("gauss", "gauss", x, mean, sigma)
data = gauss.generate(RooArgSet(x), 10000) # RooDataSet
gauss.fitTo(data)
print ">>> plot pdf and data..."
frame = x.frame(Name("frame"), Title("RooPlot with decorations"),
Bins(40)) # RooPlot
data.plotOn(frame)
gauss.plotOn(frame)
print ">>> RooGaussian::paramOn - add box with pdf parameters..."
# https://root.cern.ch/doc/master/classRooAbsPdf.html#aa43b2556a1b419bad2b020ba9b808c1b
# Layout(Double_t xmin, Double_t xmax, Double_t ymax)
# left edge of box starts at 20% of x-axis
gauss.paramOn(frame, Layout(0.55))
print ">>> RooDataSet::statOn - add box with data statistics..."
# https://root.cern.ch/doc/master/classRooAbsData.html#a538d58020b296a1623323a84d2bb8acb
# x size of box is from 55% to 99% of x-axis range, top of box is at 80% of y-axis range)
data.statOn(frame, Layout(0.20, 0.55, 0.8))
print ">>> add text and arrow..."
text = TText(2, 100, "Signal")
text.SetTextSize(0.04)
text.SetTextColor(kRed)
frame.addObject(text)
arrow = TArrow(2, 100, -1, 50, 0.01, "|>")
arrow.SetLineColor(kRed)
arrow.SetFillColor(kRed)
arrow.SetLineWidth(3)
frame.addObject(arrow)
print ">>> persist frame with all decorations in ROOT file..."
file = TFile("rooFit106.root", "RECREATE")
frame.Write()
file.Close()
# To read back and plot frame with all decorations in clean root session do
# [0] TFile f("rooFit106.root")
# [1] xframe->Draw()
print ">>> draw functions and toy data on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.05)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit106.png")
def plot(obj, plot_name, plot_notes=[]):
canvas = TCanvas('canvas' + plot_name, "Canvas", 450, 450)
gPad.SetLeftMargin(.13)
gPad.SetTopMargin(.05)
gStyle.SetOptStat(11)
gStyle.SetOptFit(1111)
if 'TH2' in obj.ClassName():
gPad.SetRightMargin(.13)
draw_options = 'COLZ'
if 'profile' in obj.GetName():
gPad.SetRightMargin(.05)
draw_options = ''
if 'graph' in obj.GetName():
gPad.SetRightMargin(.05)
draw_options = 'APE'
obj.SetMarkerSize(.7)
obj.SetMarkerStyle(21)
note = TPaveText(.2, .7, .5, .9, "brNDC")
note.SetFillStyle(0)
note.SetFillColor(0)
note.SetBorderSize(0)
note.SetTextColor(1)
note.SetTextFont(42)
note.SetTextAlign(11)
for note_text in plot_notes:
note.AddText(note_text)
obj.Draw(draw_options)
note.Draw()
canvas.Print('output/' + plot_name + '.pdf')
def plot_en():
#energy distribution of generated photons
ebin = 0.1
emin = 4
emax = 28
can = ut.box_canvas()
hE = ut.prepare_TH1D("hE", ebin, emin, emax)
tree.Draw("phot_en >> hE")
hE.SetYTitle("Events / ({0:.3f}".format(ebin) + " GeV)")
hE.SetXTitle("#it{E}_{#gamma} (GeV)")
hE.SetTitleOffset(1.9, "Y")
hE.SetTitleOffset(1.3, "X")
gPad.SetTopMargin(0.02)
gPad.SetRightMargin(0.01)
gPad.SetBottomMargin(0.1)
gPad.SetLeftMargin(0.14)
hE.GetYaxis().SetMoreLogLabels()
hE.Draw()
gPad.SetLogy()
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def phot_xy():
#photon detector first point in xy
xbin = 0.1
xmin = -12
xmax = 12
can = ut.box_canvas()
hX = ut.prepare_TH2D("hX", xbin, xmin, xmax, xbin, xmin, xmax)
#tree.Draw("phot_y/10:phot_x/10 >> hX")#, "phot_en<1000")
tree.Draw("phot_hy/10:phot_hx/10 >> hX") #, "phot_en<1000")
hX.SetXTitle("Horizontal #it{x} (cm)")
hX.SetYTitle("Vertical #it{y} (cm)")
hX.GetXaxis().CenterTitle()
hX.GetYaxis().CenterTitle()
hX.SetTitleOffset(1.2, "Y")
hX.SetTitleOffset(1.2, "X")
gPad.SetTopMargin(0.01)
gPad.SetRightMargin(0.11)
gPad.SetBottomMargin(0.09)
gPad.SetLeftMargin(0.09)
hX.Draw()
gPad.SetLogz()
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def setPadStyle():
gPad.SetLeftMargin(0.05)
gPad.SetRightMargin(0.08)
gPad.SetTopMargin(0.10)
gPad.SetBottomMargin(0.10)
gPad.SetLogz(plots[plot].zLog)
gPad.SetFillColor(kWhite)
gPad.SetBorderMode(0)
def gPadSet():
gPad.SetTickx(1)
gPad.SetTicky(1)
gPad.SetLeftMargin(0.12)
gPad.SetRightMargin(1.4)
gPad.SetBottomMargin(0.10)
gPad.SetFrameLineWidth(2)
gPad.RedrawAxis()
def rooFit203():
print ">>> setup model..."
x = RooRealVar("x", "x", -10, 10)
mean = RooRealVar("mean", "mean of gaussian", 0, -10, 10)
gauss = RooGaussian("gauss", "gaussian PDF", x, mean, RooConst(1))
# Construct px = 1 (flat in x)
px = RooPolynomial("px", "px", x)
# Construct model = f*gx + (1-f)px
f = RooRealVar("f", "f", 0., 1.)
model = RooAddPdf("model", "model", RooArgList(gauss, px), RooArgList(f))
data = model.generate(RooArgSet(x), 10000) # RooDataSet
print ">>> fit to full data range..."
result_full = model.fitTo(data, Save(kTRUE)) # RooFitResult
print "\n>>> fit \"signal\" range..."
# Define "signal" range in x as [-3,3]
x.setRange("signal", -3, 3)
result_sig = model.fitTo(data, Save(kTRUE),
Range("signal")) # RooFitResult
print "\n>>> plot and print results..."
# Make plot frame in x and add data and fitted model
frame1 = x.frame(Title("Fitting a sub range")) # RooPlot
data.plotOn(frame1, Name("data"))
model.plotOn(frame1, Range("Full"), LineColor(kBlue),
Name("model")) # Add shape in full ranged dashed
model.plotOn(frame1, LineStyle(kDashed), LineColor(kRed),
Name("model2")) # By default only fitted range is shown
print "\n>>> result of fit on all data:"
result_full.Print()
print "\n>>> result of fit in in signal region (note increased error on signal fraction):"
result_sig.Print()
print ">>> draw on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
legend = TLegend(0.2, 0.85, 0.4, 0.65)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
gPad.SetLeftMargin(0.14)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.4)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend.AddEntry("data", "data", 'LEP')
legend.AddEntry("model", "fit (full range)", 'L')
legend.AddEntry("model2", "fit (signal range)", 'L')
legend.Draw()
canvas.SaveAs("rooFit203.png")
def draw(self):
self.canvas = TCanvas('can' + self.name, self.name, 1000, 800)
if self.histo == None:
self.bookCorrelationHisto()
self.histo.Draw('boxtext')
gPad.SetBottomMargin(0.3)
gPad.SetLeftMargin(0.3)
gPad.SetRightMargin(0.2)
gPad.SaveAs('cutCorr_' + self.name + '_' +
varStringToFileName(self.addtlCut) + '.png')
def rooFit105():
print ">>> bind TMath::Erf C function..."
x = RooRealVar("x", "x", -3, 3)
#print ">>> type(%s) = %s" % ("TMath.Erf",type(TMath.Erf))
fa1 = TF1("fa2", "TMath::Erf(x)", 0, 10)
erf = bindFunction(fa1, x) # RooAbsReal
#erf = bindFunction("erf",TMath.Erf,RooArgList(x)) # RooAbsReal
erf.Print()
frame1 = x.frame(Title("TMath::Erf bound as RooFit function")) # RooPlot
erf.plotOn(frame1)
print ">>> bind ROOT::Math::beta_pdf C pdf..."
x2 = RooRealVar("x2", "x2", 0, 0.999)
a = RooRealVar("a", "a", 5, 0, 10)
b = RooRealVar("b", "b", 2, 0, 10)
print ">>> type(%s) = %s" % ("Math.beta_pdf", type(Math.beta_pdf))
#beta = bindPdf("beta",Math.beta_pdf,RooArgList(x2,a,b)) # RooAbsPdf
beta = bindPdf("beta", Math.beta_pdf, x2, a, b) # RooAbsPdf
beta.Print()
print ">>> generate and fit data...\n"
data = beta.generate(x2, 10000) # RooDataSet
beta.fitTo(data)
frame2 = x2.frame(Title("ROOT::Math::Beta bound as RooFit pdf")) # RooPlot
data.plotOn(frame2)
beta.plotOn(frame2)
print ">>> bind ROOT::TF1 as RooFit function..."
fa3 = TF1("fa3", "sin(x)/x", 0, 10)
x3 = RooRealVar("x3", "x3", 0.01, 20)
rfa1 = bindFunction(fa3, RooArgList(x3)) # RooAbsReal
rfa1.Print()
frame3 = x3.frame(Title("TF1 bound as RooFit function")) # RooPlot
rfa1.plotOn(frame3)
print ">>> draw functions and toy data on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 1800, 600)
canvas.Divide(3)
for i, frame in enumerate([frame1, frame2, frame3], 1):
canvas.cd(i)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.05)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit105.png")
def plot_zdc_vtx():
#ZDC vertex from selected events and from all triggered events
vbin = 0.1
vmin = -5.
vmax = 7.
mmin = 1.5
mmax = 5.
can = ut.box_canvas()
#selection string
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
#make the histograms
hZdcVtx = ut.prepare_TH1D("hZdcVtx", vbin, vmin, vmax)
hZdcVtxAll = ut.prepare_TH1D("hZdcVtxAll", vbin / 10., vmin, vmax)
#convert to meters for plot
tree.Draw("jZDCVtxZ/100. >> hZdcVtx", strsel)
treeAll = inp.Get("jAllTree")
treeAll.Draw("jZDCVtxZ/100. >> hZdcVtxAll")
ut.norm_to_data(hZdcVtxAll, hZdcVtx, rt.kRed)
hZdcVtx.SetYTitle("Events / {0:.0f} cm".format(vbin * 100.))
hZdcVtx.SetXTitle("ZDC vertex along #it{z} (meters)")
hZdcVtx.SetTitleOffset(1.5, "Y")
hZdcVtx.SetTitleOffset(1.1, "X")
gPad.SetTopMargin(0.01)
gPad.SetRightMargin(0.04)
gPad.SetBottomMargin(0.08)
gPad.SetLeftMargin(0.1)
leg = ut.prepare_leg(0.67, 0.8, 0.28, 0.14, 0.025)
leg.SetMargin(0.17)
ut.add_leg_mass(leg, mmin, mmax)
leg.AddEntry(hZdcVtx, "Selected events")
leg.AddEntry(hZdcVtxAll, "All UPC-JpsiB triggers", "l")
#gPad.SetLogy()
hZdcVtx.Draw()
hZdcVtxAll.Draw("same")
leg.Draw("same")
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def rooFit510():
print ">>> create and fill workspace..."
workspace = RooWorkspace("workspace") # RooWorkspace
fillWorkspace(workspace)
print ">>>\n>>> retrieve model from workspace..."
# Exploit convention encoded in named set "parameters" and "observables"
# to use workspace contents w/o need for introspected
model = workspace.pdf("model") # RooAbsPdf
print ">>> generate and fit data in given observables"
data = model.generate(workspace.set("observables"), 1000) # RooDataSet
model.fitTo(data)
print ">>> plot model and data of first observables..."
frame1 = workspace.set("observables").first().frame() # RooPlot
data.plotOn(frame1, Name("data"), Binning(50))
model.plotOn(frame1, Name("model"))
print ">>> overlay plots with reference parameters as stored in snapshots..."
workspace.loadSnapshot("reference_fit")
model.plotOn(frame1, LineColor(kRed), Name("model_ref"))
workspace.loadSnapshot("reference_fit_bkgonly")
model.plotOn(frame1, LineColor(kRed), LineStyle(kDashed), Name("bkg_ref"))
print "\n>>> draw on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
legend = TLegend(0.2, 0.8, 0.4, 0.6)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.5)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend.AddEntry("data", "data", 'LEP')
legend.AddEntry("model", "model", 'L')
legend.AddEntry("model_ref", "model fit", 'L')
legend.AddEntry("bkg_ref", "background only fit", 'L')
legend.Draw()
canvas.SaveAs("rooFit510.png")
# Print workspace contents
workspace.Print()
# Workspace will remain in memory after macro finishes
gDirectory.Add(workspace)
def phot_theta():
#polar angle of generated photons
tbin = 0.01
tmax = 4
gdir = "/home/jaroslav/sim/GETaLM/cards/"
inp = "bg.root"
infile = TFile.Open(gdir + inp)
tree = infile.Get("ltree")
can = ut.box_canvas()
ht1 = ut.prepare_TH1D("ht1", tbin, 0, tmax)
ht2 = ut.prepare_TH1D("ht2", tbin, 0, tmax)
ht2.SetMarkerColor(rt.kRed)
ht2.SetLineColor(rt.kRed)
#tree.Draw("(TMath::Pi()-true_phot_theta)*1000 >> ht")
tree.Draw("(TMath::Pi()-phot_theta)*1000 >> ht1",
"vtx_z>5000 && vtx_z<12000")
tree.Draw("(TMath::Pi()-phot_theta)*1000 >> ht2",
"vtx_z>-5000 && vtx_z<5000")
#ht.SetYTitle("Events / ({0:.3f}".format(tbin)+" mrad)")
#ht.SetYTitle("Counts")
#ht.SetXTitle("Photon #it{#theta} (mrad)")
#ht.SetTitleOffset(1.5, "Y")
#ht.SetTitleOffset(1.3, "X")
gPad.SetTopMargin(0.02)
gPad.SetRightMargin(0.025)
gPad.SetBottomMargin(0.1)
gPad.SetLeftMargin(0.11)
gPad.SetGrid()
ht1.Draw()
ht2.Draw("e1same")
#leg = ut.prepare_leg(0.2, 0.87, 0.18, 0.08, 0.035)
#leg.AddEntry(None, "Angular distribution of Bethe-Heitler photons", "")
#leg.Draw("same")
gPad.SetLogy()
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def plot_vtx_z():
#primary vertex position along z from data and MC
vbin = 4.
vmax = 120.
mmin = 1.5
mmax = 5
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
can = ut.box_canvas()
hVtx = ut.prepare_TH1D("hVtx", vbin, -vmax, vmax)
hVtxMC = ut.prepare_TH1D("hVtxMC", vbin/2., -vmax, vmax)
tree.Draw("jVtxZ >> hVtx", strsel)
mctree.Draw("jVtxZ >> hVtxMC", strsel)
ut.norm_to_data(hVtxMC, hVtx, rt.kBlue, -40, 40)
hVtx.SetYTitle("Counts / {0:.0f} cm".format(vbin));
hVtx.SetXTitle("#it{z} of primary vertex (cm)");
hVtx.SetTitleOffset(1.5, "Y")
hVtx.SetTitleOffset(1.3, "X")
gPad.SetTopMargin(0.02)
gPad.SetRightMargin(0.02)
gPad.SetBottomMargin(0.1)
gPad.SetLeftMargin(0.11)
cut_lo = ut.cut_line(-30, 0.8, hVtx)
cut_hi = ut.cut_line(30, 0.8, hVtx)
leg = ut.prepare_leg(0.16, 0.82, 0.26, 0.12, 0.025)
#leg.SetMargin(0.15)
#leg.SetBorderSize(1)
ut.add_leg_mass(leg, mmin, mmax)
leg.AddEntry(hVtx, "Data")
#leg.AddEntry(hVtxMC, "MC, coherent J/#it{#psi}", "l")
leg.AddEntry(hVtxMC, "MC, #it{#gamma}#it{#gamma} #rightarrow e^{+}e^{-}", "l")
leg.AddEntry(cut_lo, "Cut at #pm30 cm", "l")
hVtx.Draw()
hVtxMC.Draw("same")
leg.Draw("same")
cut_lo.Draw("same")
cut_hi.Draw("same")
#ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def plot_zdc():
#ZDC ADC counts east or west 1D
ew = 0
zbin = 10.
zmin = 0.
zmax = 1300.
znam = ["jZDCUnAttEast", "jZDCUnAttWest"]
xtit = ["ZDC East ADC", "ZDC West ADC"]
lhead = ["East ZDC", "West ZDC"]
#global gPad
can = ut.box_canvas()
hZdc = ut.prepare_TH1D("hZdc", zbin, zmin, zmax)
hZdcAll = ut.prepare_TH1D("hZdcAll", zbin, zmin, zmax)
tree.Draw(znam[ew] + " >> hZdc")
treeAll = inp.Get("jAllTree")
treeAll.Draw(znam[ew] + " >> hZdcAll")
ut.norm_to_data(hZdcAll, hZdc, rt.kRed)
hZdc.SetYTitle("Events / {0:.1f}".format(zbin))
hZdc.SetXTitle(xtit[ew])
hZdc.SetTitleOffset(1.5, "Y")
hZdc.SetTitleOffset(1.1, "X")
gPad.SetTopMargin(0.01)
gPad.SetRightMargin(0.08)
gPad.SetBottomMargin(0.08)
gPad.SetLeftMargin(0.1)
leg = ut.prepare_leg(0.5, 0.76, 0.39, 0.16, 0.035)
leg.SetMargin(0.17)
leg.AddEntry(None, lhead[ew], "")
leg.AddEntry(hZdc, "Selected events")
leg.AddEntry(hZdcAll, "All UPC-JpsiB triggers", "l")
hZdc.Draw()
hZdcAll.Draw("same")
leg.Draw("same")
#ut.print_pad(rt.gPad)
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def setpad(left, right, top, bottom):
gPad.SetFillColor(10)
gPad.SetBorderMode(0)
gPad.SetBorderSize(0)
gPad.SetFrameFillColor(10)
gPad.SetFrameBorderMode(0)
gPad.SetFrameBorderSize(0)
gPad.SetLeftMargin(left)
gPad.SetRightMargin(right)
gPad.SetTopMargin(top)
gPad.SetBottomMargin(bottom)
gPad.SetGridx(0)
gPad.SetGridy(0)
gStyle.SetOptStat(0)
def rooFit208():
print ">>> setup component pdfs..."
t = RooRealVar("t", "t", -10, 30)
ml = RooRealVar("ml", "mean landau", 5., -20, 20)
sl = RooRealVar("sl", "sigma landau", 1, 0.1, 10)
landau = RooLandau("lx", "lx", t, ml, sl)
mg = RooRealVar("mg", "mg", 0)
sg = RooRealVar("sg", "sg", 2, 0.1, 10)
gauss = RooGaussian("gauss", "gauss", t, mg, sg)
print ">>> construct convolution pdf..."
# Set #bins to be used for FFT sampling to 10000
t.setBins(10000, "cache")
# Construct landau (x) gauss
convolution = RooFFTConvPdf("lxg", "landau (X) gauss", t, landau, gauss)
print ">>> sample, fit and plot convoluted pdf..."
data = convolution.generate(RooArgSet(t), 10000) # RooDataSet
convolution.fitTo(data)
print "\n>>> plot everything..."
frame1 = t.frame(Title("landau #otimes gauss convolution")) # RooPlot
data.plotOn(frame1, Binning(50), Name("data"))
convolution.plotOn(frame1, Name("lxg"))
gauss.plotOn(frame1, LineStyle(kDashed), LineColor(kRed), Name("gauss"))
landau.plotOn(frame1, LineStyle(kDashed), LineColor(kGreen),
Name("landau"))
print "\n>>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
legend = TLegend(0.6, 0.8, 0.8, 0.6)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.5)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend.AddEntry("data", "data", 'LEP')
legend.AddEntry("lxg", "convolution", 'L')
legend.AddEntry("landau", "landau", 'L')
legend.AddEntry("gauss", "gauss", 'L')
legend.Draw()
canvas.SaveAs("rooFit208.png")
def plot_zdc_vtx_alltrg():
#ZDC vertex from all triggered events
vbin = 0.01
#vmin = -20.
#vmax = 20.
#vmin = -26
#vmax = -12
vmin = -800
vmax = 800
can = ut.box_canvas()
#make the histogram
hZdcVtx = ut.prepare_TH1D("hZdcVtxAll", vbin, vmin, vmax)
hZdcVtx.SetOption("L")
#convert to meters for plot
treeAll = inp.Get("jAllTree")
print("Number of all trg events:", treeAll.GetEntries())
treeAll.Draw("jZDCVtxZ/100. >> hZdcVtxAll")
hZdcVtx.SetYTitle("Events / {0:.0f} cm".format(vbin * 100.))
hZdcVtx.SetXTitle("ZDC vertex along #it{z} (meters)")
hZdcVtx.SetTitleOffset(1.5, "Y")
hZdcVtx.SetTitleOffset(1.1, "X")
gPad.SetTopMargin(0.04)
gPad.SetRightMargin(0.04)
gPad.SetBottomMargin(0.08)
gPad.SetLeftMargin(0.1)
leg = ut.prepare_leg(0.67, 0.8, 0.28, 0.14, 0.025)
leg.SetMargin(0.17)
#leg.AddEntry(None, "UPC-JpsiB 2014", "")
#leg.AddEntry(None, "UPC-main 2010+2011", "")
#leg.AddEntry(None, "UPC-main 2014", "")
leg.AddEntry(None, "Zero bias 2014", "")
#leg.AddEntry(None, "VPD-ZDC-novtx-mon", "")
#gPad.SetLogy()
hZdcVtx.Draw()
leg.Draw("same")
#ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def plot_2d(plot_pdf):
plot_pdf.pdf.GetXaxis().SetTitleOffset(2.3)
plot_pdf.pdf.GetYaxis().SetTitleOffset(1.9)
plot_pdf.pdf.GetZaxis().SetTitleOffset(1.7)
gPad.SetTopMargin(0.01)
gPad.SetRightMargin(0.05)
gPad.SetBottomMargin(0.11)
gPad.SetLeftMargin(0.12)
plot_pdf.plot()
gPad.SetPhi(-125.)
gPad.Update()
def plot_projection(frame, ew):
xtit = ["ZDC East ADC", "ZDC West ADC"]
frame.SetXTitle(xtit[ew])
frame.GetXaxis().SetTitleOffset(1.2)
frame.GetYaxis().SetTitleOffset(1.4)
gPad.SetTopMargin(0.01)
gPad.SetRightMargin(0.01)
gPad.SetBottomMargin(0.1)
gPad.SetLeftMargin(0.1)
frame.Draw()
def draw_canvas_2d(name):
f_mc = TFile("plots/mc/%s_mcc7.root" % name)
h_mc = gDirectory.Get("h_%s_reco" % name)
f = TFile("plots/data/e_%s_pandoraCosmic.root" % name)
h = gDirectory.Get("h_%s" % name)
h.Divide(h_mc)
h.GetZaxis().SetRangeUser(0.5, 1.5)
#h.GetZaxis().SetTitle("Data/Monte Carlo")
#h.GetZaxis().RotateTitle()
h.SetMarkerSize(2)
x_minbin = h.FindFirstBinAbove(0, 1)
low_x = h.GetXaxis().GetBinLowEdge(x_minbin)
x_maxbin = h.FindLastBinAbove(0, 1)
high_x = h.GetXaxis().GetBinUpEdge(x_maxbin)
y_minbin = h.FindFirstBinAbove(0, 2)
low_y = h.GetYaxis().GetBinLowEdge(y_minbin)
y_maxbin = h.FindLastBinAbove(0, 2)
high_y = h.GetYaxis().GetBinUpEdge(y_maxbin)
h.GetXaxis().SetRangeUser(low_x, high_x)
h.GetYaxis().SetRangeUser(low_y, high_y)
c = TCanvas("c_%s" % name)
h.SetMarkerSize(2.5)
gPad.SetBottomMargin(0.17)
gPad.SetLeftMargin(0.13)
gPad.SetTopMargin(0.15)
gPad.SetRightMargin(0.15)
h.GetYaxis().SetTitleSize(0.07)
h.GetXaxis().SetTitleSize(0.07)
h.GetYaxis().SetTitleOffset(0.8)
pt = TPaveText(0.13, 0.855, 0.42, 0.98, "ndc")
pt.AddText("MicroBooNE")
pt.SetFillColor(0)
pt.SetBorderSize(0)
pt.SetShadowColor(0)
h.Draw("colz texte")
pt.Draw()
c.Update()
c.SaveAs("plots/%s.pdf" % name)
c.SaveAs("plots/%s.p" % name)
return c
def up_down_en():
#up and down spectrometers energy sum
ebin = 0.1
emin = 0
emax = 20
edet = 1
can = ut.box_canvas()
hE = ut.prepare_TH1D("hE", ebin, emin, emax)
sel = "up_en>" + str(edet * 1e3) + " && down_en>" + str(edet * 1e3)
#tree.Draw("(up_en+down_en)/1000. >> hE", sel)
#tree.Draw("up_en/1000. >> hE")#, sel)
#tree.Draw("down_en/1000. >> hE")
#tree.Draw("up_en >> hE")#, sel)
tree.Draw("down_en >> hE")
print "Entries:", hE.GetEntries()
hE.SetYTitle("Events / ({0:.3f}".format(ebin) + " GeV)")
hE.SetXTitle("#it{E}_{#gamma} = #it{E}_{up} + #it{E}_{down} (GeV)")
hE.SetTitleOffset(1.4, "Y")
hE.SetTitleOffset(1.3, "X")
gPad.SetTopMargin(0.01)
gPad.SetRightMargin(0.02)
gPad.SetBottomMargin(0.1)
gPad.SetLeftMargin(0.1)
#hE.GetYaxis().SetMoreLogLabels()
hE.Draw()
gPad.SetLogy()
leg = ut.prepare_leg(0.58, 0.8, 0.2, 0.15, 0.035) # x, y, dx, dy, tsiz
leg.AddEntry(hE, "#it{E}_{up} + #it{E}_{down}", "lp")
leg.AddEntry(None, "#it{E}_{up}>1 #bf{and} #it{E}_{down}>1 GeV", "")
leg.Draw("same")
ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def plot_dSigDe():
# dSigma / dEgamma according to ZEUS parametrization
parse = ConfigParser.RawConfigParser()
parse.add_section("main")
parse.set("main", "emin", "6")
parse.set("main", "Ee", "18")
parse.set("main", "Ep", "275")
gen = gen_zeus(parse)
sig = gen.dSigDe
gStyle.SetPadTickY(1)
can = ut.box_canvas()
#frame = gPad.DrawFrame(6, 0, 29, 6)
frame = gPad.DrawFrame(5, 0, 19, 7.2)
sig.SetLineWidth(3)
sig.SetNpx(1000)
sig.SetTitle("")
sig.Draw("same")
frame.GetXaxis().SetTitle("#it{E}_{#gamma} (GeV)")
frame.GetYaxis().SetTitle("d#sigma / d#it{E}_{#gamma} (mb/GeV)")
frame.GetYaxis().SetTitleOffset(1.1)
frame.GetXaxis().SetTitleOffset(1.3)
frame.SetTickLength(0.015, "X")
frame.SetTickLength(0.015, "Y")
gPad.SetTopMargin(0.02)
gPad.SetRightMargin(0.01)
gPad.SetLeftMargin(0.09)
leg = ut.prepare_leg(0.65, 0.73, 0.24, 0.2, 0.035) # x, y, dx, dy, tsiz
leg.AddEntry(sig, "#frac{d#sigma}{d#it{E}_{#gamma}}", "l")
leg.AddEntry(None, "", "")
#leg.AddEntry(None, "#it{E}_{e} = 27.6 GeV", "")
#leg.AddEntry(None, "#it{E}_{p} = 920 GeV", "")
leg.AddEntry(None, "#it{E}_{e} = 18 GeV", "")
leg.AddEntry(None, "#it{E}_{p} = 275 GeV", "")
leg.Draw("same")
ut.invert_col(gPad)
can.SaveAs("01fig.pdf")
def plot_zdc_tpc_vtx():
#2D ZDC and TPC vertices
zbin = 2.
#zmin = -50.
#zmax = 100.
zmin = -100
zmax = 150
tbin = 2.
#tmin = -55.
#tmax = 55.
tmin = -110
tmax = 110
mmin = 1.5
mmax = 5.
can = ut.box_canvas()
strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax)
hVtx = ut.prepare_TH2D("hVtx", tbin, tmin, tmax, zbin, zmin, zmax)
tree.Draw("jZDCVtxZ:jVtxZ >> hVtx", strsel)
hVtx.SetXTitle("TPC vertex along #it{z} / " + "{0:.0f} cm".format(zbin))
hVtx.SetYTitle("ZDC vertex along #it{z} / " + "{0:.0f} cm".format(zbin))
hVtx.SetTitleOffset(1.5, "Y")
hVtx.SetTitleOffset(1.1, "X")
gPad.SetTopMargin(0.02)
gPad.SetRightMargin(0.09)
gPad.SetBottomMargin(0.08)
gPad.SetLeftMargin(0.11)
leg = ut.prepare_leg(0.16, 0.82, 0.23, 0.05, 0.025)
leg.SetMargin(0.02)
leg.SetBorderSize(1)
ut.add_leg_mass(leg, mmin, mmax)
hVtx.Draw()
leg.Draw("same")
#ut.invert_col(rt.gPad)
can.SaveAs("01fig.pdf")
def rooFit503():
print ">>> open and workspace file, list its contents and get workspace object..."
file = TFile("rooFit502_workspace.root")
file.ls()
workspace = file.Get("workspace") # RooWorkspace
print "\n>>> retrieve pdf, data from workspace..."
x = workspace.var("x") # RooRealVar
model = workspace.pdf("model") # RooAbsPdf
data = workspace.data("modelData")
print ">>> print model tree:..."
model.Print("t")
print "\n>>> fit model to data..."
model.fitTo(data)
frame1 = x.frame(Title("Model and data read from workspace")) # RooPlot
print ">>> plot everything..."
data.plotOn(frame1, Name("data"), Binning(40))
model.plotOn(frame1, Name("model"))
model.plotOn(frame1, Components("bkg"), LineStyle(kDashed), Name("bkg"))
model.plotOn(frame1, Components("bkg,sig2"), LineStyle(kDotted),
Name("bkgsig2"))
print "\n>>> draw on canvas..."
canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600)
legend = TLegend(0.2, 0.8, 0.4, 0.6)
legend.SetTextSize(0.032)
legend.SetBorderSize(0)
legend.SetFillStyle(0)
gPad.SetLeftMargin(0.15)
gPad.SetRightMargin(0.02)
frame1.GetYaxis().SetLabelOffset(0.008)
frame1.GetYaxis().SetTitleOffset(1.5)
frame1.GetYaxis().SetTitleSize(0.045)
frame1.GetXaxis().SetTitleSize(0.045)
frame1.Draw()
legend.AddEntry("data", "data", 'LEP')
legend.AddEntry("model", "model", 'L')
legend.AddEntry("bkg", "background only", 'L')
legend.AddEntry("bkgsig2", "background + signal 2", 'L')
legend.Draw()
canvas.SaveAs("rooFit503.png")
def rooFit107():
print ">>> setup model..."
x = RooRealVar("x","x",-3,3)
mean = RooRealVar("mean","mean of gaussian",1,-10,10)
sigma = RooRealVar("sigma","width of gaussian",1,0.1,10)
gauss = RooGaussian("gauss","gauss",x,mean,sigma)
data = gauss.generate(RooArgSet(x),1000) # RooDataSet
gauss.fitTo(data)
print ">>> plot pdf and data..."
frame1 = x.frame(Name("frame1"),Title("Red Curve / SumW2 Histo errors"),Bins(20)) # RooPlot
frame2 = x.frame(Name("frame2"),Title("Dashed Curve / No XError bars"),Bins(20)) # RooPlot
frame3 = x.frame(Name("frame3"),Title("Filled Curve / Blue Histo"),Bins(20)) # RooPlot
frame4 = x.frame(Name("frame4"),Title("Partial Range / Filled Bar chart"),Bins(20)) # RooPlot
print ">>> data plotting styles..."
data.plotOn(frame1,DataError(RooAbsData.SumW2))
data.plotOn(frame2,XErrorSize(0)) # Remove horizontal error bars
data.plotOn(frame3,MarkerColor(kBlue),LineColor(kBlue)) # Blue markers and error bors
data.plotOn(frame4,DrawOption("B"),DataError(RooAbsData.None),
XErrorSize(0),FillColor(kGray)) # Filled bar chart
print ">>> data plotting styles..."
gauss.plotOn(frame1,LineColor(kRed))
gauss.plotOn(frame2,LineStyle(kDashed)) # Change line style to dashed
gauss.plotOn(frame3,DrawOption("F"),FillColor(kOrange),MoveToBack()) # Filled shapes in green color
gauss.plotOn(frame4,Range(-8,3),LineColor(kMagenta))
print ">>> draw pfds and fits on canvas..."
canvas = TCanvas("canvas","canvas",100,100,1000,1200)
canvas.Divide(2,2)
for i, frame in enumerate([frame1,frame2,frame3,frame4],1):
canvas.cd(i)
gPad.SetLeftMargin(0.15); gPad.SetRightMargin(0.05)
frame.GetYaxis().SetTitleOffset(1.6)
frame.GetYaxis().SetLabelOffset(0.010)
frame.GetYaxis().SetTitleSize(0.045)
frame.GetYaxis().SetLabelSize(0.042)
frame.GetXaxis().SetTitleSize(0.045)
frame.GetXaxis().SetLabelSize(0.042)
frame.Draw()
canvas.SaveAs("rooFit107.png")
