def test_example10(self):
from numpy import log10, logspace, random
# set up some data
x = logspace(log10(0.1), log10(10.0), 10)
model = 1.0 / x
yerr = 0.1 * model
y = model + yerr * random.normal(size=x.size)
yratio = y / model
yratio_err = yerr / model
# build the FramedArray. Note the x axis
# is set to log for all plots
a = biggles.FramedArray(
2,
1,
xlog=True,
aspect_ratio=1.2,
xlabel=r'$R [h^{-1} Mpc]$',
row_fractions=[0.75, 0.25],
)
color = 'blue'
sym = 'filled circle'
mcurve = biggles.Curve(x, model)
pts = biggles.Points(x, y, type=sym, color=color)
epts = biggles.SymmetricErrorBarsY(x, y, yerr, color=color)
pts.label = 'data'
mcurve.label = '1/x'
key = biggles.PlotKey(0.9, 0.9, [pts, mcurve], halign='right')
a[0, 0] += pts, epts, mcurve, key
a[0, 0].ytitle = r'$\Delta\Sigma [M_{\odot} pc^{-2}]$'
a[0, 0].yrange = [0.05, 20.0]
a[0, 0].xrange = [0.05, 20.0]
a[0, 0].ylog = True # log y axis only for the top plot
a[1, 0] += biggles.Points(x, yratio, type=sym, color=color, size=3)
a[1, 0] += biggles.SymmetricErrorBarsY(x,
yratio,
yratio_err,
color=color)
a[1, 0] += biggles.Curve(x, x * 0 + 1)
a[1, 0].ytitle = r'$ratio$'
a[1, 0].yrange = [0.5, 1.5]
_write_example(10, a)
def adddata(p, runs, data, shift):
x = []
y = []
yerr = []
allpeak = []
themap = {}
for r, (e, h, herr) in zip(runs, data):
if r != None and runsummary[r].kind == "p":
allpeak.append((e, h, herr))
else:
thetag = int(round(e * 2000. * 10.))
if thetag not in themap:
themap[thetag] = []
themap[thetag].append((e, h, herr))
for thetag, thelist in themap.items():
some_energy = mean(map(lambda
(e, h, herr): e, thelist)) * 2. + shift / 1000.
some_h, some_herr = wmean(map(lambda (e, h, herr): (h, herr), thelist))
x.append(some_energy)
y.append(some_h)
yerr.append(some_herr)
if allpeak != []:
allpeak_energy = mean(map(lambda (e, h, herr): e,
allpeak)) * 2. + shift / 1000.
allpeak_h, allpeak_herr = wmean(
map(lambda (e, h, herr): (h, herr), allpeak))
x.append(allpeak_energy)
y.append(allpeak_h)
yerr.append(allpeak_herr)
p.add(biggles.Points(x, y, symboltype="filled circle", symbolsize=0.8))
p.add(biggles.SymmetricErrorBarsY(x, y, yerr))
return None
def make_points(shears, biases, bias_errors, color, res):
pts = biggles.Points(shears,
biases,
type='filled diamond',
color=color,
size=2.5)
ptsc = biggles.Points(shears,
biases,
type='diamond',
color='black',
size=2.5)
ptserr = biggles.SymmetricErrorBarsY(simshears,
simbiases,
simerrs,
color=simcolor)
if res is not None:
xp = numpy.linspace(0, shears[-1])
fitc = biggles.Curve(
xp,
res['m'] + res['alpha'] / units * xp**2,
color=color,
)
fitc.label = r'$%.1f \gamma^2$' % res['alpha']
else:
fitc = None
return pts, ptsc, ptserr, fitc
def addtogroupsplot(p, csfunc, offset, color, kind):
combinemap = {}
combinemap[0] = []
combinemap[1] = []
combinemap[2] = []
combinemap[3] = []
combinemap[4] = []
combinemap[5] = []
combinemap[6] = []
combinemap[7] = []
combinemap[8] = []
combinemap[9] = []
for r in testsample:
combinemap[0].append(csfunc(r))
combinemap[groupify(r)].append(csfunc(r))
groups = range(1, 10)
hadgroup = [0] * 9
hadgroup_err = [0] * 9
for g in groups:
hadgroup[g - 1], hadgroup_err[g - 1] = jt.wmean(combinemap[g])
center_of_groups = jt.wmean(combinemap[0])[0]
tmp = biggles.Points(Numeric.array(groups) + offset,
Numeric.array(hadgroup) / center_of_groups,
type=kind,
color=color)
p.add(tmp)
p.add(
biggles.SymmetricErrorBarsY(Numeric.array(groups) + offset,
Numeric.array(hadgroup) / center_of_groups,
Numeric.array(hadgroup_err) /
center_of_groups,
color=color))
p.add(biggles.LineY(1., type="longdashed"))
return tmp
def use_cross_section(csfunc, filename):
hads = []
hads_err = []
for r in testsample:
c, e = csfunc(r)
hads.append(c)
hads_err.append(e)
hads_center = jt.wmean(zip(hads, hads_err))[0]
p = biggles.FramedPlot()
p.add(
biggles.Points(range(len(testsample)),
Numeric.array(hads) / hads_center,
type="filled circle"))
p.add(
biggles.SymmetricErrorBarsY(range(len(testsample)),
Numeric.array(hads) / hads_center,
Numeric.array(hads_err) / hads_center))
p.x1.draw_ticklabels = 0
p.x1.label = "Runs by index"
p.y1.label = "Normalized hadronic cross-section"
p.add(biggles.LineY(1.))
p.add(biggles.LineX(41.5, type="dashed"))
l, r = 0.8, 1.2
p.yrange = l, r + 0.001
p.add(biggles.DataLabel(41.5 - 10, l + 0.15 * (r - l), "db16"))
p.add(biggles.DataLabel(41.5 + 10, l + 0.15 * (r - l), "db17"))
p.aspect_ratio = 8.5 / 11.
p.show()
p.write_eps(filename)
def compare(pseudohist, realhist, title, filetitle):
x, y, dy = xydy(pseudohist)
p = biggles.FramedPlot()
p.add(biggles.Points(x, y, symboltype="filled circle", symbolsize=0.8))
p.add(biggles.SymmetricErrorBarsY(x, y, dy))
x, y, dy = xydy(realhist)
p.add(
biggles.Points(x,
y,
symboltype="filled circle",
symbolsize=0.8,
color="red"))
p.add(biggles.SymmetricErrorBarsY(x, y, dy, color="red"))
p.x1.label = "black=mocked up cuts, red=analysis cuts: " + title
p.aspect_ratio = 1
p.show()
p.write_eps("rootstab8_pseudoreal_" + filetitle + ".eps")
def plotoverlay(histhigh, histlow, histhoff, histloff, p):
global numbha_high, numbha_low, numbha_hoff, numbha_loff
histhigh.rootn()
histlow.rootn()
histhoff.rootn()
histloff.rootn()
upshigh = histhigh / float(numbha_high) - histhoff / float(numbha_hoff)
upslow = histlow / float(numbha_low) - histloff / float(numbha_loff)
x, y, dy = upshigh.bin_centers(), upshigh.values, upshigh.errors
p.add(biggles.Points(x, y, symboltype="filled triangle", symbolsize=0.8))
p.add(biggles.SymmetricErrorBarsY(x, y, dy))
x, y, dy = upslow.bin_centers(), upslow.values, upslow.errors
p.add(biggles.Points(x, y, symboltype="inverted triangle", symbolsize=0.8))
p.add(biggles.SymmetricErrorBarsY(x, y, dy))
return p
def addtoplot(p, hist, color="black"):
x = hist.bin_centers()
y = hist.values
dy = hist.errors
p.add(
biggles.Points(x,
y,
symboltype="filled circle",
symbolsize=1,
color=color))
p.add(biggles.SymmetricErrorBarsY(x, y, dy, color=color))
return p
def errorbar(x, y, e, style='ko-', show=None, p=None):
global _matlab
p = _matlab.get_plot(p)
lstyle, color, mstyle = _matlab.get_style(p, style)
p.add(biggles.SymmetricErrorBarsY(x, y, e, color=color))
if mstyle is not None:
p.add(biggles.Points(x, y, color=color, type=mstyle))
if lstyle is not None:
p.add(biggles.Curve(x, y, color=color, type=lstyle))
if show:
p.show()
_matlab.LAST = p
return p
def plotfrac(histhigh, histlow, histhoff, histloff, p):
global numbha_high, numbha_low, numbha_hoff, numbha_loff
histhigh.rootn()
histlow.rootn()
histhoff.rootn()
histloff.rootn()
upshigh = histhigh / float(numbha_high) - histhoff / float(numbha_hoff)
upslow = histlow / float(numbha_low) - histloff / float(numbha_loff)
frac = upshigh / upslow
x, y, dy = frac.bin_centers(), frac.values, frac.errors
ave = jt.wmean(zip(y, dy))[0]
print ave
p.add(biggles.Points(x, y, symboltype="filled circle", symbolsize=0.8))
p.add(biggles.SymmetricErrorBarsY(x, y, dy))
p.add(biggles.LineY(ave))
return p
def test_example4():
x = numpy.arange(0, 2 * numpy.pi, numpy.pi / 20)
s = numpy.sin(x)
inset = biggles.FramedPlot()
inset.title = "inset"
inset.frame.draw_ticks = 0
inset.add(biggles.Curve(x, s, type="dashed"))
p = biggles.FramedPlot()
p.aspect_ratio = 1.
p.frame.tickdir = +1
p.frame.draw_spine = 0
p.add(biggles.SymmetricErrorBarsY(x, s, [0.2] * len(x)))
p.add(biggles.Points(x, s, color="red"))
p.add(biggles.Inset((.6, .6), (.95, .95), inset))
_write_example(4, p)
def plotoverlay(f, s, area, mass, wide, back, label=True, title=None):
p = biggles.FramedPlot()
p.add(biggles.Points(Numeric.array(scanen[s])*2000., scancs[s], symboltype="filled circle", symbolsize=0.7))
p.add(biggles.SymmetricErrorBarsY(Numeric.array(scanen[s])*2000., scancs[s], scancs_err[s]))
xlow = min(scanen[s])*2000. - 5.
xhigh = max(scanen[s])*2000. + 5.
thex = Numeric.arange(xlow, xhigh, (xhigh - xlow)/100.)
they = Numeric.arange(xlow, xhigh, (xhigh - xlow)/100.)
for i, x in enumerate(thex):
they[i] = f(area, mass, wide, back, x/2000.)
p.add(biggles.Curve(thex, they))
p.xrange = xlow, xhigh
p.yrange = 0., max(scancs[s]) * 1.2
if label:
p.x1.label = r"$E_{COM}$ in MeV"
p.y1.label = "Relative Hadronic Cross-section"
else:
p.x1.draw_ticklabels = 0
p.y1.draw_ticklabels = 0
if title != None:
p.x2.label = title
return p
math.sqrt((float(b4) / float(n4)) * (1. - float(b4) / float(n4)) /
float(n4)))
block5.append(float(b5) / float(n5))
block5err.append(
math.sqrt((float(b5) / float(n5)) * (1. - float(b5) / float(n5)) /
float(n5)))
block6.append(float(b6) / float(n6))
block6err.append(
math.sqrt((float(b6) / float(n6)) * (1. - float(b6) / float(n6)) /
float(n6)))
p1 = biggles.FramedArray(2, 1)
p1[0,
0].add(biggles.Points(rnum, eff, symboltype="filled circle",
symbolsize=0.2))
p1[0, 0].add(biggles.SymmetricErrorBarsY(rnum, eff, efferr))
p1[0, 0].add(biggles.LineY(1., linetype="dotted"))
p1[0, 0].yrange = (0.987, 1.005)
p1[0, 0].xrange = (min(rnum) - 100, max(rnum) + 100)
p1[1,
0].add(biggles.Points(rnum, eff, symboltype="filled circle",
symbolsize=0.2))
p1[1, 0].add(biggles.SymmetricErrorBarsY(rnum, eff, efferr))
p1[1, 0].add(biggles.LineY(1., linetype="dotted"))
p1[1, 0].yrange = (0.8, 1.1)
p1[1, 0].xrange = (min(rnum) - 100, max(rnum) + 100)
p1.xlabel = "Run number"
p1.ylabel = "BarrelBhabha trigger efficiency"
p1[1, 0].add(biggles.PlotLabel(0.25, 0.25, "same outliers as last time"))
p1.show()
p1.write_eps("plottrig3_p1.eps")
p = biggles.FramedPlot() xf = Numeric.arange(9460-5, 9460+5, 0.025) yf = map(lambda xi: u1func(318.5185, 3.78739, 0.40577*nbish2nb, 0.053, 0.01864, 0., 0.0267, 0.2, 0., 0.0792, xi), xf) p.add(biggles.Curve(xf, yf)) x = []; y = []; dy = []; dx = []; lab = [] for s in u1runs: x.append(ggdata[s][0]*2000. + u1shifts[s][0]) y.append(ggdata[s][1]) dy.append(ggdata[s][2]) dx.append(u1shifts[s][1]) lab.append(s) p.add(biggles.Points(x, y, symboltype="filled circle", symbolsize=1)) p.add(biggles.SymmetricErrorBarsX(x, y, dx)) p.add(biggles.SymmetricErrorBarsY(x, y, dy)) # x = []; y = []; dy = []; dx = []; lab = [] # for s in u1runs: # x.append(bbindata[s][0]*2000. + u1shifts[s][0]) # y.append(bbindata[s][1]) # dy.append(bbindata[s][2]) # dx.append(u1shifts[s][1]) # lab.append(s) # p.add(biggles.Points(x, y, symboltype="filled circle", symbolsize=1, color="blue")) # p.add(biggles.SymmetricErrorBarsX(x, y, dx, color="blue")) # p.add(biggles.SymmetricErrorBarsY(x, y, dy, color="blue")) x = []; y = []; dy = []; dx = []; lab = [] for s in u1runs: x.append(bboutdata[s][0]*2000. + u1shifts[s][0])
c.text(
0, 0,
r"\sf \#$e^+e^-$ to subtract $=$ $\sigma_\Upsilon(E)$ ${\cal B}_{\mu\mu}$ $\frac{\stackrel{\displaystyle \int_{0.6}^{0.8} \cos^2\theta_+ \mbox{ } d(\cos\theta_+)}{\mbox{ }}}{\stackrel{\mbox{ }}{\displaystyle \int_{-1}^{+1} \cos^2\theta_+ \mbox{ } d(\cos\theta_+)}}$ ${\cal L}_{\gamma\gamma}$",
[text.halign.boxcenter, text.halign.flushcenter])
c.writeEPSfile("equation.eps")
import biggles
p = biggles.Table(1, 3)
p[0, 0] = biggles.FramedPlot()
p[0, 0].add(
biggles.Points([0, 1, 2], [317.8 / 317.8, 324.00 / 317.8, 323.16 / 317.8],
symboltype="filled circle",
symbolsize=2.))
p[0, 0].add(
biggles.SymmetricErrorBarsY(
[0, 1, 2], [317.8 / 317.8, 324.00 / 317.8, 323.16 / 317.8],
[2.2 / 317.8, 1.2 / 317.8, 0.95 / 317.8]))
p[0, 0].x.ticks = [0, 1, 2]
p[0, 0].x.draw_subticks = 0
p[0, 0].x1.ticklabels = [
r"$\gamma\gamma$", r"${e^+e^-}_{in}$", r"${e^+e^-}_{out}$"
]
p[0, 0].x1.range = [-0.5, 2.5]
p[0, 0].y1.label = r"$\Gamma_{ee}$ (normalized)"
p[0, 0].y1.range = 0.97, 1.05
p[0, 0].title = r"$\Upsilon(1S)$"
p[0, 1] = biggles.FramedPlot()
p[0, 1].add(
biggles.Points([0, 1, 2], [133.2 / 133.2, 134.4 / 133.2, 134.02 / 133.2],
symboltype="filled circle",
x = []
y = []
yerr = []
n = []
for r, ru in run.iteritems():
x.append(r)
frac = float(ru.numer_region) / float(ru.denom_region)
y.append(frac)
yerr.append(math.sqrt(frac * (1. - frac) / float(ru.denom_region)))
n.append(float(ru.denom_region))
fracerrs = biggles.FramedArray(2, 1)
fracerrs.uniform_limits = 0
fracerrs[0, 0].add(
biggles.Points(x, y, symboltype="filled circle", symbolsize=0.5))
fracerrs[0, 0].add(biggles.SymmetricErrorBarsY(x, y, yerr))
fracerrs[0, 0].yrange = (0.99, 1.0)
fracerrs[1, 0].add(
biggles.Points(x, y, symboltype="filled circle", symbolsize=0.5))
fracerrs[1, 0].add(biggles.SymmetricErrorBarsY(x, y, yerr))
fracerrs[1, 0].yrange = (0.8, 1.02)
fracerrs.xlabel = "Run numbers"
fracerrs.ylabel = "BhabhaBarrel trigger efficiency"
fracerrs.show()
fracerrs.write_eps("plottrig_1.eps")
ylow, nlow = zip(*filter(lambda (yi, ni): yi < 0.99, zip(y, n)))
context = biggles.FramedArray(2, 1)
context[0, 0].add(hist.h1(100, 0, 20000).fill(n).steps(True))
context[1, 0].add(biggles.Points(n, y, symboltype="dot"))
context[1, 0].add(
1.21218927998725,
1.21731192153008,
5.11646554504093,
2.40220723315513,
5.23830942533408,
14.1491181418469,
12.767438367915,
57.6641809947519,
]
p = biggles.FramedPlot()
p.add(biggles.Points(area1s, chi21s, symboltype="filled circle", symbolsize=1))
p.add(
biggles.SymmetricErrorBarsY(area1s,
chi21s,
chi21s_err,
symboltype="filled circle",
symbolsize=1))
p.add(
biggles.SymmetricErrorBarsX(area1s,
chi21s,
area1s_err,
symboltype="filled circle",
symbolsize=1))
for a, c, j in zip(area1s, chi21s, jit1s):
a += 0.0005
c += 0.002
if j == 0.01:
p.add(
biggles.DataLabel(a,
c,
simshears = array([0.02, 0.06, 0.10])
simbiases = array([0.03, 2.064e-3 / units, 0.00581 / units], )
simerrs = array([0.31, 3.210e-04 / units, 0.000280 / units], )
simpts = biggles.Points(simshears,
simbiases,
type='filled diamond',
color=simcolor,
size=2.5)
simptsc = biggles.Points(simshears,
simbiases,
type='diamond',
color='black',
size=2.5)
simerr = biggles.SymmetricErrorBarsY(simshears,
simbiases,
simerrs,
color=simcolor)
#simerr2=biggles.SymmetricErrorBarsY([0.02+0.00005], [0.03+0.03], [0.31], color='black')
simfitter = Fitter(simshears, simbiases * units, simerrs * units)
simfitter.go()
sim_m, sim_alpha = simfitter.result['pars']
sim_merr, sim_alphaerr = numpy.sqrt(numpy.diag(fitter.result['pars_cov']))
print("sim m + alpha g^2")
print("sim m: %g +/- %g alpha: %g +/- %g" %
(sim_m, sim_merr, sim_alpha, sim_alphaerr))
simpts.label = 'image simulation'
#perr = biggles.SymmetricErrorBarsY(shears, m, merr)
def doplot(self, show=False):
"""
plot m,c vs s2n
"""
import biggles
xrng = [0.5 * self.s2n.min(), 1.5 * self.s2n.max()]
mplt = biggles.FramedPlot()
cplt = biggles.FramedPlot()
mplt.xlabel = 'S/N'
mplt.ylabel = 'm'
mplt.xlog = True
mplt.xrange = xrng
cplt.xlabel = 'S/N'
cplt.ylabel = 'c'
cplt.xlog = True
cplt.xrange = xrng
color1 = 'blue'
color2 = 'red'
mcurve1 = biggles.Curve(self.s2n,
self.m[:, 0],
type='solid',
color=color1)
merr1 = biggles.SymmetricErrorBarsY(self.s2n,
self.m[:, 0],
self.merr[:, 0],
color=color1)
mcurve2 = biggles.Curve(self.s2n,
self.m[:, 1],
type='dashed',
color=color2)
merr2 = biggles.SymmetricErrorBarsY(self.s2n,
self.m[:, 1],
self.merr[:, 1],
color=color2)
ccurve1 = biggles.Curve(self.s2n,
self.c[:, 0],
type='solid',
color=color1)
cerr1 = biggles.SymmetricErrorBarsY(self.s2n,
self.c[:, 0],
self.cerr[:, 0],
color=color1)
ccurve2 = biggles.Curve(self.s2n,
self.c[:, 1],
type='dashed',
color=color2)
cerr2 = biggles.SymmetricErrorBarsY(self.s2n,
self.c[:, 1],
self.cerr[:, 1],
color=color2)
key = biggles.PlotKey(0.1, 0.9, [mcurve1, mcurve2], halign='left')
mcurve1.label = r'$g_1$'
mcurve2.label = r'$g_2$'
ccurve1.label = r'$g_1$'
ccurve2.label = r'$g_2$'
zc = biggles.Curve(self.s2n, self.s2n * 0)
mplt.add(mcurve1, merr1, mcurve2, merr2, zc, key)
cplt.add(ccurve1, cerr1, ccurve2, cerr2, zc, key)
if show:
mplt.show()
cplt.show()
return mplt, cplt
def bscatter(xin, yin, show=True, plt=None, **keywords):
"""
Name:
bscatter
Purpose:
A wrapper to perform a quick scatter plot with biggles. For anything
more complex, it is better to use the object oriented interface.
Calling Sequence:
bscatter(x, y,
xerr=None,
yerr=None,
xrange=None,
yrange=None,
type='filled circle',
color=None,
xlabel=None,
ylabel=None,
label=None,
title=None,
file=None,
xsize=None,
ysize=None,
aspect_ratio=None,
show=True,
plt=None)
Return value is the used biggles plot object.
For overplotting, send an existing biggles plot object in the plt= keyword
"""
import biggles
if plt is None:
plt = biggles.FramedPlot()
xlog = keywords.get("xlog", False)
ylog = keywords.get("ylog", False)
else:
xlog = plt.xlog
ylog = plt.ylog
pdict = {}
# plot symbol or line type
type = keywords.get("type", "filled circle")
xerr = keywords.get("xerr", None)
yerr = keywords.get("yerr", None)
x = xin
y = yin
xrng = keywords.get("xrange", None)
yrng = keywords.get("yrange", None)
# For log, Don't plot points less than zero
w = None
if xlog and ylog:
xrng = get_log_plot_range(x, err=xerr, input_range=xrng)
yrng = get_log_plot_range(y, err=yerr, input_range=yrng)
(w, ) = np.where((x > xrng[0]) & (y > yrng[0]))
elif xlog:
xrng = get_log_plot_range(x, err=xerr, input_range=xrng)
(w, ) = np.where(x > xrng[0])
elif ylog:
yrng = get_log_plot_range(y, err=yerr, input_range=yrng)
(w, ) = np.where(y > yrng[0])
if w is not None:
if w.size == 0:
raise ValueError("no points > 0 for log plot")
x = x[w]
y = y[w]
pkeywords = {}
if "color" in keywords:
pkeywords["color"] = keywords["color"]
if "width" in keywords:
pkeywords["width"] = keywords["width"]
if type in [
"solid",
"dotted",
"dotdashed",
"shortdashed",
"longdashed",
"dotdotdashed",
"dotdotdotdashed",
]:
if "width" in keywords:
pkeywords["width"] = keywords["width"]
p = biggles.Curve(x, y, type=type, **pkeywords)
else:
size = keywords.get("size", 1)
p = biggles.Points(x, y, type=type, size=size, **pkeywords)
label = keywords.get("label", None)
if label is not None:
p.label = label
plt.add(p)
pdict["p"] = p
# note for log error bars, we start with original points since
# the bars may extend above zero even for negative points
if yerr is not None:
if ylog:
pdict["p_yerr"] = add_log_error_bars(plt, "y", xin, yin, yerr,
yrng, **pkeywords)
else:
p_yerr = biggles.SymmetricErrorBarsY(x, y, yerr, **pkeywords)
plt.add(p_yerr)
pdict["p_yerr"] = p_yerr
if xerr is not None:
if xlog:
pdict["p_xerr"] = add_log_error_bars(plt, "y", xin, yin, xerr,
xrng, **pkeywords)
else:
p_xerr = biggles.SymmetricErrorBarsX(x, y, xerr, **pkeywords)
plt.add(p_xerr)
pdict["p_xerr"] = p_xerr
plt.xlog = xlog
plt.ylog = ylog
if xrng is not None:
plt.xrange = xrng
if yrng is not None:
plt.yrange = yrng
if "xlabel" in keywords:
plt.xlabel = keywords["xlabel"]
if "ylabel" in keywords:
plt.ylabel = keywords["ylabel"]
if "title" in keywords:
plt.title = keywords["title"]
if "aspect_ratio" in keywords:
plt.aspect_ratio = keywords["aspect_ratio"]
if "file" in keywords:
fname = keywords["file"]
if fname.find(".eps") != -1 or fname.find(".ps") != -1:
plt.write_eps(fname)
else:
xsize = keywords.get("xsize", 512)
ysize = keywords.get("ysize", 512)
plt.write_img(xsize, ysize, fname)
else:
if show:
plt.show()
pdict["plt"] = plt
if "dict" in keywords:
if keywords["dict"]:
return pdict
return plt
wles_frac_err = []
for r, w in zip(runnums, wles):
if w > 0:
wles_frac.append(1.*w/bbinr[r])
wles_frac_err.append(1.*w/bbinr[r]*sqrt(1./w + 1./bbinr[r]))
else:
wles_frac.append(0.)
wles_frac_err.append(0.)
import biggles
p = biggles.FramedPlot()
x = map(run_date, runnums)
y = wles_frac
dy = wles_frac_err
p.add(biggles.Points(x, y, symboltype="filled circle", symbolsize=0.8))
p.add(biggles.SymmetricErrorBarsY(x, y, dy))
subticks = []
sublabels = []
for t, l in zip(dticks, dlabels):
if min(x)-7.*24.*60.*60. < t < max(x)+7.*24.*60.*60.:
subticks.append(t)
sublabels.append(l)
subsubticks = []
for t in dsubticks:
if min(x)-7.*24.*60.*60. < t < max(x)+7.*24.*60.*60.:
subsubticks.append(t)
p.x1.ticks = subticks
p.x1.subticks = subsubticks
p.x1.ticklabels = sublabels
p.x2.ticks = subticks
def plot_m_c_vs(self,
res,
name,
xlog=True,
show=False,
combine=False,
xrng=None):
"""
result from fit_m_c_vs
parameters
----------
res: dict
result from running fit_m_c_vs
name: string
Name for the variable binned against, e.g. s/n or whatever
This is used for the x axis
xlog: bool, optional
If True, use a log x axis
show: bool, optional
If True, show the plot on the screen
returns
-------
biggles plot object
"""
import biggles
biggles.configure('default', 'fontsize_min', 2.0)
tab = biggles.Table(2, 1)
xvals = res['mean']
if xrng is None:
if xlog:
xrng = [0.5 * xvals.min(), 1.5 * xvals.max()]
else:
xrng = [0.9 * xvals.min(), 1.1 * xvals.max()]
mplt = biggles.FramedPlot()
mplt.xlabel = name
mplt.ylabel = 'm'
mplt.xrange = xrng
mplt.yrange = [-0.01, 0.01]
mplt.xlog = xlog
cplt = biggles.FramedPlot()
cplt.xlabel = name
cplt.ylabel = 'c'
cplt.xrange = xrng
cplt.yrange = [-0.0015, 0.0015]
cplt.xlog = xlog
if combine:
m = 0.5 * (res['m1'] + res['m2'])
c = 0.5 * (res['c1'] + res['c2'])
merr = array([
min(m1err, m2err)
for m1err, m2err in zip(res['m1err'], res['m2err'])
])
cerr = array([
min(c1err, c2err)
for c1err, c2err in zip(res['c1err'], res['c2err'])
])
merr /= sqrt(2)
cerr /= sqrt(2)
mc = biggles.Points(xvals, m, type='filled circle', color='blue')
merrc = biggles.SymmetricErrorBarsY(xvals, m, merr, color='blue')
cc = biggles.Points(xvals, c, type='filled circle', color='blue')
cerrc = biggles.SymmetricErrorBarsY(xvals, c, cerr, color='blue')
zc = biggles.Curve(xrng, [0, 0])
mplt.add(zc, mc, merrc)
cplt.add(zc, cc, cerrc)
else:
m1c = biggles.Points(xvals,
res['m1'],
type='filled circle',
color='blue')
m1c.label = 'm1'
m1errc = biggles.SymmetricErrorBarsY(xvals,
res['m1'],
res['m1err'],
color='blue')
m2c = biggles.Points(xvals,
res['m2'],
type='filled circle',
color='red')
m2c.label = 'm2'
m2errc = biggles.SymmetricErrorBarsY(xvals,
res['m2'],
res['m2err'],
color='red')
mkey = biggles.PlotKey(0.9, 0.9, [m1c, m2c], halign='right')
c1c = biggles.Points(xvals,
res['c1'],
type='filled circle',
color='blue')
c1c.label = 'c1'
c1errc = biggles.SymmetricErrorBarsY(xvals,
res['c1'],
res['c1err'],
color='blue')
c2c = biggles.Points(xvals,
res['c2'],
type='filled circle',
color='red')
c2c.label = 'c2'
c2errc = biggles.SymmetricErrorBarsY(xvals,
res['c2'],
res['c2err'],
color='red')
ckey = biggles.PlotKey(0.9, 0.9, [c1c, c2c], halign='right')
zc = biggles.Curve(xvals, xvals * 0)
mplt.add(zc, m1c, m1errc, m2c, m2errc, mkey)
cplt.add(zc, c1c, c1errc, c2c, c2errc, ckey)
tab[0, 0] = mplt
tab[1, 0] = cplt
if show:
tab.show()
return tab
b.append(tmp)
berr.append(math.sqrt(tmp*(1.-tmp)/float(den)))
num = 0
den = 0
for i in range(76, 82):
for j in range(59, 62):
num += run[r].numer[i,j]
den += run[r].denom[i,j]
tmp = float(num)/float(den)
c.append(tmp)
cerr.append(math.sqrt(tmp*(1.-tmp)/float(den)))
p = biggles.FramedArray(3,1)
p[0,0].add(biggles.Points(runnumbers, a, symboltype="filled circle", symbolsize=0.5))
p[0,0].add(biggles.SymmetricErrorBarsY(runnumbers, a, aerr))
p[0,0].yrange = (0., 1.1)
p[1,0].add(biggles.Points(runnumbers, b, symboltype="filled circle", symbolsize=0.5))
p[1,0].add(biggles.SymmetricErrorBarsY(runnumbers, b, berr))
p[1,0].yrange = (0., 1.1)
p[2,0].add(biggles.Points(runnumbers, c, symboltype="filled circle", symbolsize=0.5))
p[2,0].add(biggles.SymmetricErrorBarsY(runnumbers, c, cerr))
p[2,0].yrange = (0., 1.1)
p.xlabel = r"$\epsilon$ of blocks A, B, C versus run"
p[0,0].add(biggles.LineX(122354, linetype="longdashed"))
p[1,0].add(biggles.LineX(122354, linetype="longdashed"))
p[2,0].add(biggles.LineX(122354, linetype="longdashed"))
p[2,0].add(biggles.DataLabel(122354+70, 0.2, "122354 (in 3S db17)", texthalign="left"))
p[0,0].add(biggles.LineX(123490, linetype="longdashed"))
#!/usr/bin/env python import sys sys.path.insert(1,'..') import biggles import math, numpy x = numpy.arange( 0, 2*math.pi, math.pi/20 ) s = numpy.sin(x) c = numpy.cos(x) inset = biggles.FramedPlot() inset.title = "inset" inset.frame.draw_ticks = 0 inset.add( biggles.Curve(x, s, type="dashed") ) p = biggles.FramedPlot() p.aspect_ratio = 1. p.frame.tickdir = +1 p.frame.draw_spine = 0 p.add( biggles.SymmetricErrorBarsY(x, s, [0.2]*len(x)) ) p.add( biggles.Points(x, s, color="red") ) p.add( biggles.Inset((.6,.6), (.95,.95), inset) ) #p.write_img( 400, 400, "example4.png" ) #p.write_eps( "example4.eps" ) p.show()
frac = float(num) / float(den)
correction_factor_err.append(math.sqrt(frac * (1. - frac) / float(den)))
corhist = (runrec[r].gamgam_cotT /
runrec[r].bhabha_cotTnumer.divide_by_superset(
runrec[r].bhabha_cotTdenom))
den = corhist.sum(0.1, 1.23)
num = runrec[r].gamgam_cotT.sum(0.1, 1.23)
frac = float(num) / float(den)
correction_factor.append(frac)
p = biggles.FramedArray(1, 2)
p[0, 0].add(biggles.Points(testsample, correction_factor,
type="filled circle"))
p[0, 0].add(
biggles.SymmetricErrorBarsY(testsample, correction_factor,
correction_factor_err))
p[0, 0].yrange = 0.98, 1.
p[0, 0].xrange = 121400, 123200
p[0, 0].add(biggles.LineX(122226, type="longdashed"))
p[0, 1].add(biggles.Points(testsample, correction_factor,
type="filled circle"))
p[0, 1].add(
biggles.SymmetricErrorBarsY(testsample, correction_factor,
correction_factor_err))
p[0, 1].yrange = 0.98, 1.
p[0, 1].xrange = 128102, 128164
p.aspect_ratio = 8.5 / 11. / 2.
p.xlabel = "Run Number"
p.ylabel = "BhabhaBarrel trigger efficiency"
p[0, 0].add(biggles.PlotLabel(0.25, 0.1, "db16"))
p[0, 0].add(biggles.PlotLabel(0.75, 0.1, "db17"))
# is set to log for all plots
a = biggles.FramedArray(
2,
1,
xlog=True,
aspect_ratio=1.2,
xlabel=r'$R [h^{-1} Mpc]$',
row_fractions=[0.75, 0.25],
)
color = 'blue'
sym = 'filled circle'
mcurve = biggles.Curve(x, model)
pts = biggles.Points(x, y, type=sym, color=color)
epts = biggles.SymmetricErrorBarsY(x, y, yerr, color=color)
pts.label = 'data'
mcurve.label = '1/x'
key = biggles.PlotKey(0.9, 0.9, [pts, mcurve], halign='right')
a[0, 0] += pts, epts, mcurve, key
a[0, 0].ytitle = r'$\Delta\Sigma [M_{\odot} pc^{-2}]$'
a[0, 0].yrange = [0.05, 20.0]
a[0, 0].xrange = [0.05, 20.0]
a[0, 0].ylog = True # log y axis only for the top plot
a[1, 0] += biggles.Points(x, yratio, type=sym, color=color, size=3)
a[1, 0] += biggles.SymmetricErrorBarsY(x, yratio, yratio_err, color=color)
a[1, 0] += biggles.Curve(x, x * 0 + 1)
a[1, 0].ytitle = r'$ratio$'
def bscatter(xin, yin, show=True, plt=None, **keywords):
"""
Name:
bscatter
Purpose:
A wrapper to perform a quick scatter plot with biggles. For anything
more complex, it is better to use the object oriented interface.
Calling Sequence:
bscatter(x, y,
xerr=None,
yerr=None,
xrange=None,
yrange=None,
type='filled circle',
color=None,
xlabel=None,
ylabel=None,
label=None,
title=None,
file=None,
xsize=None,
ysize=None,
aspect_ratio=None,
show=True,
plt=None)
Return value is the used biggles plot object.
For overplotting, send an existing biggles plot object in the plt= keyword
"""
import biggles
if plt is None:
plt = biggles.FramedPlot()
xlog = keywords.get('xlog', False)
ylog = keywords.get('ylog', False)
else:
xlog = plt.xlog
ylog = plt.ylog
pdict = {}
# plot symbol or line type
type = keywords.get('type', 'filled circle')
xerr = keywords.get('xerr', None)
yerr = keywords.get('yerr', None)
x = xin
y = yin
xrng = keywords.get('xrange', None)
yrng = keywords.get('yrange', None)
# For log, Don't plot points less than zero
w = None
if xlog and ylog:
xrng = get_log_plot_range(x, err=xerr, input_range=xrng)
yrng = get_log_plot_range(y, err=yerr, input_range=yrng)
w, = numpy.where((x > xrng[0]) & (y > yrng[0]))
elif xlog:
xrng = get_log_plot_range(x, err=xerr, input_range=xrng)
w, = numpy.where(x > xrng[0])
elif ylog:
yrng = get_log_plot_range(y, err=yerr, input_range=yrng)
w, = numpy.where(y > yrng[0])
if w is not None:
if w.size == 0:
raise ValueError("no points > 0 for log plot")
x = x[w]
y = y[w]
pkeywords = {}
if 'color' in keywords:
pkeywords['color'] = keywords['color']
if 'width' in keywords:
pkeywords['width'] = keywords['width']
if type in [
"solid", "dotted", "dotdashed", "shortdashed", "longdashed",
"dotdotdashed", "dotdotdotdashed"
]:
if 'width' in keywords:
pkeywords['width'] = keywords['width']
p = biggles.Curve(x, y, type=type, **pkeywords)
else:
size = keywords.get('size', 1)
p = biggles.Points(x, y, type=type, size=size, **pkeywords)
label = keywords.get('label', None)
if label is not None:
p.label = label
plt.add(p)
pdict['p'] = p
# note for log error bars, we start with original points since
# the bars may extend above zero even for negative points
if yerr is not None:
if ylog:
pdict['p_yerr'] = add_log_error_bars(plt, 'y', xin, yin, yerr,
yrng, **pkeywords)
#p_yerr = add_log_error_bars(plt, 'y', xin, yin, yerr, yrng, **pkeywords)
else:
p_yerr = biggles.SymmetricErrorBarsY(x, y, yerr, **pkeywords)
plt.add(p_yerr)
pdict['p_yerr'] = p_yerr
if xerr is not None:
if xlog:
pdict['p_xerr'] = add_log_error_bars(plt, 'y', xin, yin, xerr,
xrng, **pkeywords)
#p_xerr = add_log_error_bars(plt, 'y', xin, yin, xerr, xrng, **pkeywords)
else:
p_xerr = biggles.SymmetricErrorBarsX(x, y, xerr, **pkeywords)
plt.add(p_xerr)
pdict['p_xerr'] = p_xerr
plt.xlog = xlog
plt.ylog = ylog
if xrng is not None:
plt.xrange = xrng
if yrng is not None:
plt.yrange = yrng
if 'xlabel' in keywords:
plt.xlabel = keywords['xlabel']
if 'ylabel' in keywords:
plt.ylabel = keywords['ylabel']
if 'title' in keywords:
plt.title = keywords['title']
if 'aspect_ratio' in keywords:
plt.aspect_ratio = keywords['aspect_ratio']
if 'file' in keywords:
fname = keywords['file']
if fname.find('.eps') != -1 or fname.find('.ps') != -1:
plt.write_eps(fname)
else:
xsize = keywords.get('xsize', 512)
ysize = keywords.get('ysize', 512)
plt.write_image(xsize, ysize, fname)
else:
if show:
plt.show()
pdict['plt'] = plt
if 'dict' in keywords:
if keywords['dict']:
return pdict
return plt
def test_labels(self):
import numpy
from numpy import linspace
key = biggles.PlotKey(0.1, 0.9, halign='left')
plt = biggles.FramedPlot(key=key, aspect_ratio=1)
err = 0.1
x = numpy.arange(10)
y = numpy.arange(10)**2
err = numpy.zeros(x.size) + 2
ydata = y + numpy.random.normal(size=x.size) * err
color = 'red'
pts = biggles.Points(x,
ydata,
color=color,
type='filled diamond',
label='data')
errpts = biggles.SymmetricErrorBarsY(x,
ydata,
err,
color=color,
label='data')
model = biggles.Curve(x, y, label='model')
plt += biggles.Polygon([0, 8, 4], [0, 0, 30],
color='grey20',
label='triangle')
plt += [model, pts, errpts]
plt += biggles.Point(4,
4,
type='filled circle',
color='cyan',
label='other')
# Go from light blue to intense red.
np = 30
xp = linspace(0.5, 4, np)
yp = 20 + 5 * xp.copy()
minColor = [0.6, 0.9, 1.0]
maxColor = [1.0, 0.2, 0.2]
colors = numpy.zeros((np, 3))
colors[:, 0] = numpy.interp(xp, xp,
linspace(minColor[0], maxColor[0], np))
colors[:, 1] = numpy.interp(xp, xp,
linspace(minColor[1], maxColor[1], np))
colors[:, 2] = numpy.interp(xp, xp,
linspace(minColor[2], maxColor[2], np))
plt += biggles.ColoredPoints(
xp,
yp,
colors,
type='cross',
size=1,
label='grad',
)
plt += biggles.LineX(5, color='green', label='lineY')
plt += biggles.LineY(5, color='magenta', type='dashed', label='lineX')
plt += biggles.Slope(-3, (0, 40), color='Hot Pink', label='slope')
plt += biggles.DataBox([5.5, 70], [6.5, 80],
color='Dodger Blue',
label='box')
# label doesn't work, nor does ellipses. fundamental perhaps
#plt += Circle(6.0, 75.0, 1, color='yellow', label='circle')
# not even sure how DataArc works
#plt += DataArc(6.0, 75.0, 1, color='yellow', label='circle')
_write_example('labels', plt)
m.minos()
print m
xx = Numeric.arange(4.6, 5.3, 0.1)
yy = Numeric.arange(4.6, 5.3, 0.1)
for i, xi in enumerate(xx):
yy[i] = 762.4 * xi / (10355.2 / 2000.)
xxx = Numeric.arange(4.6, 5.3, 0.1)
yyy = Numeric.arange(4.6, 5.3, 0.1)
for i, xi in enumerate(xxx):
yyy[i] = line(xi, m.values[0], m.values[1])
p = biggles.FramedPlot()
p.add(biggles.Points(x, y, symboltype="filled circle", symbolsize=2.))
p.add(biggles.SymmetricErrorBarsY(x, y, yerr))
p.add(biggles.Curve(xx, yy))
p.add(biggles.Curve(xxx, yyy, linetype="longdashed"))
p.xrange = 4.6, 5.3
p.x.ticks = [4.6, 4.7, 4.8, 4.9, 5.0, 5.1, 5.2, 5.3]
p.x2.draw_ticklabels = 0
p.yrange = 500., 800.
p.aspect_ratio = 1.
p.x1.label = r"Single-beam energy in GeV"
p.y1.label = r"$\sigma_E/E$ $\times$ 10$^{6}$"
p.show()
p.write_eps("/home/mccann/antithesis/clns/beamenergyspread.eps")
#######################################################
# print jt.stdev([0.12, 0.27, 0.12, 0.03, 0.08, 0.06, 0.11, 0.28, 0.45, 0.39, 0.22, 0.37])*sqrt(12./11.)
