def add_curves(ax,
x,
y,
lp,
i,
set_points=True,
lock_levels=True,
intervals=True,
slopes=True,
insets=True):
if set_points and lp.haskey('lock_x'):
ax.add(biggles.LineX(lp['lock_x'][i] * scale))
if lock_levels and lp.haskey('lock_y'):
ax.add(biggles.LineY(lp['lock_y'][i] * scale))
if intervals and lp.haskey('left_x'):
ax.add(biggles.LineX(lp['left_x'][i] * scale, type='dashed'))
if intervals and lp.haskey('right_x'):
ax.add(biggles.LineX(lp['right_x'][i] * scale, type='dashed'))
if slopes:
for d in ['up', 'dn']:
if not lp.haskey('lock_%s_sl' % d): continue
m, x0, y0 = [
lp['lock_%s' % (e)][i]
for e in ['%s_sl' % d, '%s_x' % d, 'y']
]
ax.add(biggles.Slope(m, (x0 * scale, y0 * scale), type='dashed'))
def plot_all(self, plot_file=None, format=None, data_attr=None):
if plot_file is None:
plot_file = os.path.join(self.tuning.plot_dir, '%s_summary' % \
(self.data_origin['basename']))
if format is None:
format = self.tuning.get_exp_param('tuning_plot_format',
default='png')
if data_attr is None:
data_attr = 'y_span'
data = self.data[data_attr]
_, nrow, ncol, nbias = self.data_shape
# This code block seems totally wrong. I have tried to
# maintain compatibility but I cared about the rowcol
# implementation (SWH).
transpose_row_col = (self.bias_assoc not in ['row', 'rowcol'])
if self.bias_assoc in ['row', 'rowcol']:
plot_shape = (nrow, ncol)
data = data.reshape(nrow, ncol, nbias)
ok = self.data['ok'].reshape(nrow, ncol, nbias)
else: # this particularly seems wrong
plot_shape = (nrow, ncol) # why not (ncol,nrow)?
data = data.reshape(nrow, ncol, nbias).transpose(1, 0, 2)
ok = self.data['ok'] # why not transpose this too?
pl = util.plotGridder(plot_shape,
plot_file,
title=self.data_origin['basename'],
xlabel=self.xlabel,
ylabel=self.ylabels[data_attr],
target_shape=(4, 2),
rowcol_labels=True,
format=format)
an = self.analysis
for r, c, ax in pl:
if r >= plot_shape[(1 if transpose_row_col else 0)]:
continue
x = self.fb / 1000.
#for i in xrange(ncurves):
ax.add(biggles.Curve(x, data[r, c] / 1000.))
if 'lock_x' in an:
if self.bias_assoc == 'rowcol':
ax.add(
biggles.LineX(
(an['lock_x'].reshape(nrow, ncol))[r, c] / 1000.,
type='dashed'))
else:
ax.add(
biggles.LineX(an['lock_x'][r] / 1000., type='dashed'))
return {
'plot_files': pl.plot_files,
}
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 plotLines(nr, style='dot', col='black', ref=None):
"""
Greate a plot grid
-> list of biggles objects
"""
l = []
for i in range(1, nr + 1):
l += [biggles.LineY(i, type=style, color=col)]
l += [biggles.LineX(i, type=style, color=col)]
if ref:
l += [biggles.LineY(ref[0], color='grey')]
l += [biggles.LineX(ref[1], color='grey')]
return l
def plot_voltages(fs, vecs):
import biggles
all_values = np.concatenate( vecs )
hi = all_values.max()
lo = all_values.min()
plot = biggles.Table(len(vecs), 1)
plot.cellpadding = 0
plot.cellspacing = 0
for i,vec in enumerate(vecs):
p = biggles.Plot()
p.add( biggles.Curve(wv.t(fs, vec), vec) )
p.yrange = (lo, hi)
plot[i,0] = p
p.add( biggles.LineX(0) )
p.add( biggles.Label(0, (hi+lo)/2, "%.2f mV" % (hi-lo), halign='left') )
p.add( biggles.LineY(lo) )
p.add( biggles.Label((len(vec)/fs/2), lo, "%.1f ms" % (1000*len(vec)/fs), valign='bottom') )
return plot
def test_example11(self):
p = biggles.FramedPlot()
p.title = "title"
p.xlabel = r"$x$"
p.ylabel = r"$\Theta$"
p.ylog = 1
p.xlog = 1
p.add(biggles.LineX(0.5))
p.add(biggles.LineY(0.5))
_write_example(11, p)
def plot(self, plot_file=None, format=None, data_attr=None):
if plot_file is None:
plot_file = os.path.join(self.tuning.plot_dir, '%s_summary' % \
(self.data_origin['basename']))
if format is None:
format = self.tuning.get_exp_param('tuning_plot_format',
default='png')
if data_attr is None:
data_attr = 'y_span'
data = self.data[data_attr]
_, nrow, ncol, nbias = self.data_shape
if self.bias_assoc == 'row':
plot_shape = (1, nrow)
ncurves = ncol
data = data.reshape(nrow, ncol, nbias)
ok = self.data['ok'].reshape(nrow, ncol, nbias)
else:
plot_shape = (1, ncol)
data = data.reshape(nrow, ncol, nbias).transpose(1, 0, 2)
ncurves = nrow
ok = self.data['ok']
pl = util.plotGridder(plot_shape,
plot_file,
title=self.data_origin['basename'],
xlabel=self.xlabel,
ylabel=self.ylabels[data_attr],
target_shape=(4, 2),
row_labels=True,
format=format)
an = self.analysis
for _, r, ax in pl:
if r >= plot_shape[1]:
continue
x = self.fb / 1000.
for i in xrange(ncurves):
ax.add(biggles.Curve(x, data[r, i] / 1000.))
if 'lock_x' in an:
ax.add(biggles.LineX(an['lock_x'][r] / 1000., type='dashed'))
return {
'plot_files': pl.plot_files,
}
print putitin(cont3[i]) - 1
rehad3[putitin(cont3[i]) - 1] += had3[i]
rehad3err[putitin(cont3[i]) - 1] += had3err[i]**2
reenn3[putitin(cont3[i]) - 1] += 1
for i in range(len(rehad3err)):
rehad3[i] = float(rehad3[i]) / float(reenn3[i])
rehad3err[i] = float(math.sqrt(rehad3err[i])) / float(reenn3[i])
print zip(recont3, rehad3, rehad3err)
p4 = biggles.Table(2, 1)
p4[0, 0] = biggles.FramedPlot()
p4[0, 0].add(
biggles.Points(cont3, had3, symboltype="filled circle", symbolsize=0.2))
p4[0, 0].add(biggles.SymmetricErrorBarsY(cont3, had3, had3err))
p4[0, 0].add(biggles.LineX(122000, linetype="longdashed"))
p4[0, 0].add(biggles.LineX(122200, linetype="longdashed"))
p4[0, 0].add(biggles.LineX(122350, linetype="longdashed"))
p4[0, 0].add(biggles.LineX(122500, linetype="longdashed"))
p4[0, 0].add(biggles.LineX(122700, linetype="longdashed"))
p4[0, 0].add(biggles.LineX(122900, linetype="longdashed"))
p4[0, 0].yrange = 5.5, 7
p4[0, 0].y1.label = r"below $\Upsilon(3S)$ hadronic $\sigma$, arb. units"
p4[0, 0].xlabel = "Run number"
p4[1, 0] = biggles.FramedPlot()
p4[1, 0].add(
biggles.Points(recont3, rehad3, symboltype="filled circle", symbolsize=1))
p4[1, 0].add(biggles.SymmetricErrorBarsY(recont3, rehad3, rehad3err))
rec3mean, rec3stdev = jt.wmean(zip(had3, had3err))
p4[1, 0].add(biggles.LineY(rec3mean + rec3stdev, linetype="dotted"))
p4[1, 0].add(biggles.LineY(rec3mean, linetype="longdashed"))
angle=90,
halign="left"))
sigsplot.show()
sigsplot.write_eps("plottrig_3.eps")
newplot = biggles.FramedArray(5, 1)
num = hist.h1(100, 0, 1)
den = hist.h1(100, 0, 1)
num.vals = 0. + Numeric.array(run[121928].numer)
den.vals = 0. + Numeric.array(run[121928].denom)
newplot[0, 0].add((num / den).points(True,
symboltype="filled circle",
symbolsize=1))
newplot[0, 0].add((num / den).errorbars(True))
newplot[0, 0].add(biggles.LineY(1, linetype="dotted"))
newplot[0, 0].add(biggles.LineX(0.45, linetype="longdashed"))
newplot[0, 0].add(biggles.LineX(0.70, linetype="longdashed"))
newplot[0, 0].add(biggles.PlotLabel(0.1, 0.85, "121928"))
newplot[0, 0].add(biggles.PlotLabel(0.675, 0.2, "accepted region"))
num = hist.h1(100, 0, 1)
den = hist.h1(100, 0, 1)
num.vals = 0. + Numeric.array(run[121929].numer)
den.vals = 0. + Numeric.array(run[121929].denom)
newplot[1, 0].add((num / den).points(True,
symboltype="filled circle",
symbolsize=1))
newplot[1, 0].add((num / den).errorbars(True))
newplot[1, 0].add(biggles.LineY(1, linetype="dotted"))
newplot[1, 0].add(biggles.LineX(0.45, linetype="longdashed"))
newplot[1, 0].add(biggles.LineX(0.70, linetype="longdashed"))
newplot[1, 0].add(biggles.PlotLabel(0.1, 0.85, "121929"))
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]
hads_sigs = []
for r, c, e in zip(testsample, hads, hads_err):
hads_sigs.append((c - hads_center) / e)
hads_hist = hist.h1(50, -5, 5).fill(hads_sigs).rootn()
def gauss(x, a, m, s):
return a * math.exp(-(x - m)**2 / 2. / s**2) / math.sqrt(
2. * math.pi) / s
chipoints = hads_hist.frame + (hads_hist.frame[1] -
hads_hist.frame[0]) / 2.
def chi2(a, m, s):
c = 0.
for i, x in zip(range(len(hads_hist.frame)), chipoints):
if hads_hist.errs[i] > 0:
c += (hads_hist.vals[i] -
gauss(x, a, m, s))**2 / hads_hist.errs[i]**2
return c
# def hist_look(a, m, s):
# p = hads_hist.plot()
# values = []
# for x in chipoints:
# values.append(gauss(x, a, m, s))
# p.add(biggles.Curve(chipoints, values))
# p.show()
# hist_look(len(testsample)/5., 0, 1)
m = Minuit(chi2, start=[len(testsample) / 5., 0, 1])
m.migrad()
hist_chi2, hist_params, hist_errors = m.fval, m.values, m.errors
ndf = len(filter(lambda x: x > 0, hads_hist.errs))
values = []
for x in chipoints:
values.append(gauss(x, *hist_params))
hist_info = [["$\chi^2/ndf$", hist_chi2, "/", ndf], \
["RMS", hist_params[2], "$\pm$", hist_errors[2]]]
p = biggles.Table(2, 1)
p[0, 0] = biggles.FramedPlot()
p[0, 0].add(
biggles.Points(Numeric.array(hads) / hads_center,
range(len(testsample)),
type="filled circle"))
p[0, 0].add(
biggles.SymmetricErrorBarsX(
Numeric.array(hads) / hads_center, range(len(testsample)),
Numeric.array(hads_err) / hads_center))
p[0, 0].y1.draw_ticklabels = 0
p[0, 0].x1.label = "$\propto$ hadronic cross-section"
p[0, 0].add(biggles.LineX(1.))
p[0, 0].add(biggles.LineY(41.5, type="dashed"))
l, r = 0.8, 1.2
p[0, 0].xrange = l, r
p[0, 0].add(biggles.DataLabel(l + 0.15 * (r - l), 41.5 - 7, "db16"))
p[0, 0].add(biggles.DataLabel(l + 0.15 * (r - l), 41.5 + 7, "db17"))
p[0, 1] = hads_hist.plot()
p[0, 1].add(biggles.Curve(chipoints, values))
hist.addinfobox(p[0, 1],
hist_info,
width=0.8,
colwidth=[0.2, 0.09, 0.23],
corner=1,
numformat="%.2g")
p[0, 1].x1.label = "sigmas away from weighted mean"
p[0, 1].yrange = 0, 17
p.aspect_ratio = 8.5 / 11. * 4
p.show()
p.write_eps(filename)
#!/usr/bin/env python
import biggles
p = biggles.FramedPlot()
p.title = "title"
p.xlabel = r"$x$"
p.ylabel = r"$\Theta$"
p.ylog = 1
p.xlog = 1
p.add(biggles.LineX(0.5))
p.add(biggles.LineY(0.5))
p.write("example11.png", dpi=55)
p.write("example11.eps")
p.write("example11.pdf")
p.show()
def __init__(self,
matrix,
mesh=0,
palette="plasma",
legend=0,
step=1,
vmin=None,
vmax=None):
"""
@param matrix: the 2-D array to plot
@type matrix: array
@param mesh: create a plot with a dotted mesh
@type mesh: 1|0
@param palette: color palette name see L{Biskit.ColorSpectrum}
@type palette: str
@param legend: create a legend (scale) showing the walues of the
different colors in the plot.
@type legend: 1|0
@param step: reduce matrix -- take only each step position in x and y
@type step: int
@param vmin: override minimal value, all values below will revert
to default color
@return: biggles plot object, view with biggles.FramedPlot.show() or
save with biggles.FramedPlot.write_eps(file_name).
@rtype: biggles.FramedPlot
"""
if not biggles:
raise ImportError, 'biggles module could not be imported.'
FramedPlot.__init__(self)
if step != 1:
matrix = self.__thinarray(matrix, step)
if vmin is None:
vmin = N0.amin(matrix)
if vmax is None:
vmax = N0.amax(matrix)
self.palette = ColorSpectrum(palette, vmin=vmin, vmax=vmax)
self.matrix = self.palette.color_array(matrix, resetLimits=0)
s = N0.shape(self.matrix)
for i in range(s[0]):
for j in range(s[1]):
col = self.matrix[i, j]
x1 = (j, j + 1)
y1 = (i, i)
y2 = (i + 1, i + 1)
cell = biggles.FillBetween(x1, y1, x1, y2, color=col)
self.add(cell)
if mesh:
for i in range(s[0] + 1):
self.add(biggles.LineY(i, linetype='dotted'))
for i in range(s[1] + 1):
self.add(biggles.LineX(i, linetype='dotted'))
if legend:
legend = self.__make_legend()
self.add(legend)
self.add(biggles.PlotBox((-0.17, -0.1), (1.25, 1.1)))
self.aspect_ratio = 1.0
def plot(
x,
y,
y_rc,
lock_points,
plot_file,
shape=(4, 2),
img_size=None,
scale=1. / 1000,
title=None,
xlabel=None,
ylabel=None,
titles=None,
rows=None,
cols=None,
insets=None,
lock_levels=True,
set_points=False,
intervals=False,
slopes=False,
scale_style='tight',
label_style='row_col',
format=None,
):
nr, nc = y_rc
cl, rl, rcl = False, False, False
if label_style == 'col_only':
cl = True
elif label_style == 'row_col':
rcl = True
if slopes == True:
def get(key, param):
return lock_points.get('lock_%s%s' % (key, param), None)
slopes = []
for d in ['', 'up_', 'dn_']:
m, x0, y0 = [get(d, p) for p in ['slope', 'x', 'y']]
if m is not None:
if y0 is None:
# Use default y-target if separate up/dn aren't there.
y0 = get('', 'y')
slopes.append(zip(m, x0, y0))
pl = util.plotGridder(y_rc,
plot_file,
title=title,
xlabel=xlabel,
ylabel=ylabel,
target_shape=shape,
img_size=img_size,
col_labels=cl,
rowcol_labels=rcl,
format=format)
for r, c, ax in pl:
if r >= nr or c >= nc: continue
i = c + r * nc
if set_points:
ax.add(biggles.LineX(lock_points['lock_x'][i] * scale))
if lock_levels:
ax.add(biggles.LineY(lock_points['lock_y'][i] * scale))
if intervals:
ax.add(
biggles.LineX(lock_points['left_x'][i] * scale, type='dashed'))
ax.add(
biggles.LineX(lock_points['right_x'][i] * scale,
type='dashed'))
if slopes != False:
for s in slopes:
m, x0, y0 = s[i]
ax.add(
biggles.Slope(m, (x0 * scale, y0 * scale), type='dashed'))
if insets is not None:
ax.add(
biggles.PlotLabel(0.,
0.,
insets[i],
halign='left',
valign='bottom'))
if x.shape == y.shape:
ax.add(biggles.Curve(x[i] / 1000., y[i] / 1000.))
else:
ax.add(biggles.Curve(x / 1000., y[i] / 1000.))
if scale_style == 'roll-off':
# Prevent small signals from causing large tick labels
hi, lo = amax(y[i]) / 1000, amin(y[i]) / 1000
if hi - lo < 4:
mid = (hi + lo) / 2
ax.yrange = (mid - 2, mid + 2)
elif scale_style == 'tight':
hi, lo = amax(y[i]) / 1000., amin(y[i]) / 1000.
dx = (hi - lo) * .1
if dx <= 0: # Never set a 0-size yrange.
dx = 0.5
ax.yrange = lo - dx, hi + dx
if x.shape == y.shape:
ax.xrange = x[i][0] / 1000., x[i][-1] / 1000.
else:
ax.xrange = x[0] / 1000., x[-1] / 1000.
pl.cleanup()
return {
'plot_files': pl.plot_files,
}
if __name__ == '__main__':
from random import random
# Get some fake data
N = 100
x = arange(N)
y = []
F = [2.2, 1.3, 0., 10.]
for f in F:
a, b, p = random() * 1000, (random() - .5) * 10000, random() * N
y.append(a * sin(2 * pi * x * f / N + p) + b)
y = array(y)
print 'Periods: ', period(y)
print 'Expected: ', N / array(F)
lp = get_lock_points(y, slope=array([1, 1, 1, -1]))
print 'Lock-x: ', lp['lock_idx']
reg = []
for yy in y:
reg.append(get_curve_regions(yy, slopes=True))
print 'Crossings: ', reg[-1]
print 'Plotting...'
fp = biggles.Table(2, 2)
for i in range(4):
p = biggles.FramedPlot()
p.add(biggles.Curve(x, y[i]))
p.add(biggles.LineX(x[lp['lock_idx'][i]], type='dashed'))
p.add(biggles.LineY(lp['lock_y'][i], type='dashed'))
p.yrange = y[i].min() - 10, y[i].max() + 10
fp[i % 2, i / 2] = p
fp.write_img(500, 500, 'check_servo.png')
def dividify(p):
p.add(biggles.LineX(121400, type="longdashed"))
p.add(biggles.LineX(121700, type="longdashed"))
p.add(biggles.LineX(121850, type="longdashed"))
p.add(biggles.LineX(122000, type="longdashed"))
p.add(biggles.LineX(122200, type="longdashed"))
p.add(biggles.LineX(122350, type="longdashed"))
p.add(biggles.LineX(122500, type="longdashed"))
p.add(biggles.LineX(122700, type="longdashed"))
p.add(biggles.LineX(123200, type="longdashed"))
p.add(biggles.LineX(128000, type="longdashed"))
p.add(biggles.LineX(128300, type="longdashed"))
x = []
y = []
yerr1 = []
yerr2 = []
for i, n in enumerate(names):
if n == "CLEO-III '05":
x.append(i)
y.append(gwhich[n][0])
yerr1.append(gwhich[n][1])
yerr2.append(sqrt(gwhich[n][1]**2 + gwhich[n][2]**2))
return x, y, yerr1, yerr2
p = biggles.Table(1, 3)
p[0, 0] = biggles.FramedPlot()
p[0, 0].add(biggles.LineX(1.216, linetype="longdashed", linecolor="black"))
p[0, 0].add(biggles.LineX(1.216 + 0.027, linetype="dotted", linecolor="black"))
p[0, 0].add(biggles.LineX(1.216 - 0.027, linetype="dotted", linecolor="black"))
p[0, 0].add(biggles.LineY(0.5))
p[0, 0].add(
biggles.PlotLabel(0.1,
0.95,
r"$\Upsilon(1S)$",
texthalign="left",
textvalign="top",
fontsize=5.))
x, y, yerr1, yerr2 = fillemup(g1)
p[0, 0].add(biggles.Points(y, x, symboltype="filled circle", symbolsize=1.5))
p[0, 0].add(biggles.SymmetricErrorBarsX(y, x, yerr1))
p[0, 0].add(biggles.SymmetricErrorBarsX(y, x, yerr2))
x, y, yerr1, yerr2 = fillemup_mine(g1)
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"))
p[1,0].add(biggles.LineX(123490, linetype="longdashed"))
p[2,0].add(biggles.LineX(123490, linetype="longdashed"))
p[2,0].add(biggles.DataLabel(123490+70, 0.4, "123490 (in 1S db18)", texthalign="left"))
p[0,0].add(biggles.LineX(128821, linetype="longdashed"))
p[1,0].add(biggles.LineX(128821, linetype="longdashed"))
p[2,0].add(biggles.LineX(128821, linetype="longdashed"))
p[2,0].add(biggles.DataLabel(128821+70, 0.2, "128821 (in 2S db23)", texthalign="left"))
p.show()
p.write_eps("plottrig2_3.eps")
p.yrange = Numeric.array([24.482067285271594, 26.736764571284123])*8.735/25.
p.show()
#################################################
execfile("/home/mccann/antithesis/utilities.py")
import biggles, Numeric
x = Numeric.arange(-1, 1, 0.05)
y = map(lambda xi: 200*(1+xi**2), x)
p = getdb(123369).bhabha_cosp.plot()
p.aspect_ratio = 0.5
p.x1.label = r"cos$\theta_+$"
p.add(getdb(123369).bhabha_cosp.stepsfill(0., 0.6))
p.add(biggles.LineX(0., linetype="dashed"))
p.add(biggles.LineX(0.6, linetype="dashed"))
p.add(getdb(123369).bhabha_cosp.steps())
p.add(biggles.Curve(x, y, linetype="dotted"))
p.y1.draw_ticklabels = 0
p.x1.ticklabels_style["fontsize"] = 5.
p.x1.label_style["fontsize"] = 5.
p.show()
p.write_eps("plots/draw_innerbb.eps")
p = getdb(123369).bhabha_cosp.plot()
p.aspect_ratio = 0.5
p.x1.label = r"cos$\theta_+$"
p.add(getdb(123369).bhabha_cosp.stepsfill(0.6, 0.8))
p.add(biggles.LineX(0.6, linetype="dashed"))
p.add(biggles.LineX(0.8, linetype="dashed"))
y = Numeric.arange(0., 0.07, 0.0001)
for i in range(len(x)):
y[i] = fitme(m.values[0], m.values[1], m.values[2], x[i])
inrange = []
themin = None
for xi, yi in zip(x, y):
if yi < min(y) + 1.:
inrange.append(xi)
if yi == min(y):
themin = xi
x = Numeric.arange(0., 0.07, 0.001)
y = Numeric.arange(0., 0.07, 0.001)
for i in range(len(x)):
y[i] = fitme(m.values[0], m.values[1], m.values[2], x[i])
p = biggles.FramedPlot()
p.add(biggles.Points(yint, chi2, symboltype="filled circle"))
p.add(biggles.Points([0.0174], [240.2], symboltype="circle", symbolsize=5.))
p.add(biggles.Curve(x, y))
p.add(biggles.LineX(themin, linetype="dashed"))
p.add(biggles.LineX(min(inrange), linetype="dotted"))
p.add(biggles.LineX(max(inrange), linetype="dotted"))
p.x1.range = 0., 0.065
p.y1.range = 200., 400.
p.x1.label = r"Interference parameter $y_{int}$"
p.y1.label = r"$\chi^2$ for $\Upsilon(1S)$ fit"
p.show()
p.write_eps("interferencescan.eps")
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)
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"))
p[0, 1].add(biggles.PlotLabel(0.5, 0.1, "Extra 3S in db22"))
# p.show()
p.write_eps("ptatalk/prepforpta2.eps")
