def plot( delta_scores_1, delta_rms_1, delta_scores_2, delta_rms_2,
feps ):
"""
"""
p = B.FramedPlot()
p.xlabel = r"Interface rmsd to bound relative to free"
p.ylabel = r"Docking performance relative to free"
points_1 = B.Points( delta_rms_1, delta_scores_1, type='circle',
symbolsize=1)
points_1.label = 'MD'
points_2 = B.Points( delta_rms_2, delta_scores_2, type='diamond',
symbolsize=1)
points_2.label = 'PCR-MD'
a = concatenate( (delta_rms_1, delta_rms_2) )
h = density( a, 20 )
scale = max( h[:,1] ) / max( a )
histogram = B.Curve( h[:,0], h[:,1] * scale )
histogram.label = "distribution"
p.add( points_1 )
p.add( points_2 )
p.add( histogram )
p.add( B.PlotKey( 0.73, 0.95, [ points_1, points_2, histogram ] ) )
p.show()
p.write_eps( feps )
def test_example2(self):
p = biggles.FramedPlot()
p.xrange = 0, 100
p.yrange = 0, 100
p.aspect_ratio = 1
x = numpy.arange(0, 100, 5)
yA = numpy.random.normal(40, 10, size=len(x))
yB = x + numpy.random.normal(0, 5, size=len(x))
a = biggles.Points(x, yA, type="circle")
a.label = "a points"
b = biggles.Points(x, yB)
b.label = "b points"
b.style(type="filled circle")
l = biggles.Slope(1, type="dotted")
l.label = "slope"
k = biggles.PlotKey(.1, .9)
k += a
k += b, l
p.add(l, a, b, k)
_write_example(2, p)
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 dothatplot(whatphi):
p = biggles.FramedArray(2, 1)
x, y = makeplot(phi=whatphi, show="chi")
x = list(x)
y = list(y)
x.append(0.)
y.append(240.4)
p[0, 0].add(biggles.Points(x, y, symboltype="filled circle"))
p[0, 0].add(biggles.LineY(240.4))
p[0, 0].add(biggles.LineY(240.4 + 1.))
x, y = makeplot(phi=whatphi, show="area")
x = list(x)
y = list(y)
x.append(0.)
y.append(324.13)
p[1, 0].add(biggles.Points(x, y, symboltype="filled circle"))
# p[1,0].add(biggles.LineY(324.13))
# p[1,0].add(biggles.LineY(324.13*0.99))
p.xrange = 0., 3.
p.ylabel = r"Area (MeV nb) $\chi^2$"
p.xlabel = r"$y_{ggg} / y_{qq} = sqrt(f B_{ggg} / B_{qq}$)"
p[0, 0].yrange = 230., 330.
p[1, 0].yrange = 310., 339.999
p.title = r"Fit results with $\phi_g$ = " + str(whatphi) + r"$\degree$"
p.write_eps("interference_nowwithphi_" + str(whatphi) + ".eps")
p.show()
def plot_fofs(m, fof, plotfile, minsize=2):
"""
make an ra,dec plot of the FOF groups
Only groups with at least two members ares shown
"""
try:
import biggles
import esutil as eu
have_biggles=True
except ImportError:
have_biggles=False
if not have_biggles:
print("skipping FOF plot because biggles is not "
"available")
return
hd=eu.stat.histogram(fof['fofid'], more=True)
wlarge,=numpy.where(hd['hist'] >= minsize)
ngroup=wlarge.size
colors=rainbow(ngroup)
ffront=os.path.basename(plotfile)
name=ffront.split('-mof-')[0]
title='%s FOF groups' % name
aratio = (m['dec'].max()-m['dec'].min())/(m['ra'].max()-m['ra'].min())
plt=biggles.FramedPlot(
xlabel='RA',
ylabel='DEC',
title=title,
aspect_ratio=aratio,
)
allpts=biggles.Points(
m['ra'], m['dec'],
type='dot',
)
plt.add(allpts)
rev=hd['rev']
icolor=0
for i in xrange(hd['hist'].size):
if rev[i] != rev[i+1]:
w=rev[ rev[i]:rev[i+1] ]
if w.size >= minsize:
indices=fof['number'][w]-1
color=colors[icolor]
pts = biggles.Points(
m['ra'][indices], m['dec'][indices],
type='circle',
size=1,
color=color,
)
plt.add(pts)
icolor += 1
print("writing:",plotfile)
plt.write_img(1500,int(1500*aratio),plotfile)
def _add_symbols(self):
self['symboltype'] = self.get('symboltype', DEFAULT_SYMBOL)
indices = self.indices
if indices is None:
self.plt.add(biggles.Points(self.x, self.y, **self))
else:
self.plt.add(
biggles.Points(self.x[indices], self.y[indices], **self))
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 view_peaks(*,
image,
noise,
objects,
show=False,
color='red',
type='filled circle',
width=800,
plt=None):
"""
view the image with peak positions overplotted
"""
import biggles
import images
tim = image.copy()
if plt is None:
aim = images.asinh_scale(image, noise=noise)
plt = images.view(aim, show=False)
# the viewer transposes the image
points = biggles.Points(
objects['col'],
objects['row'],
color=color,
type=type,
)
plt.add(points)
if show:
arat = image.shape[0] / image.shape[1]
plt.show(width=width, height=width * arat)
return plt
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 generarSalida(self, valoresFitness, numGeneracion):
filename = "%stxtGraph_%s.txt" % (self.OUTPUT_PATH, str(numGeneracion))
if (self.TIPO_SALIDA == "TEXT"):
to_print = []
to_print.append("#Generado por GenErik (c) 2008 Erik Giron")
to_print.append("#Generacion %d\n" % numGeneracion)
to_print.append("#Total Poblacion " + str(len(valoresFitness)) +
"\n\n")
to_print.append("#Peso:\tBeneficio:\n")
for (x, y) in valoresFitness:
to_print.append(" %f\t%f\n" % (x, y))
FILE = open(filename, "w")
FILE.writelines(to_print)
FILE.close()
if (self.TIPO_SALIDA == "MOVIE"):
x = [] #biggles.read_column ( 0, filename, float, '#' )
y = [] #biggles.read_column ( 1, filename, float, '#' )
for i, j in valoresFitness:
x.append(i)
y.append(j)
g = biggles.FramedPlot()
g.xrange = (0, self.MAX_PESO * self.MAX_GENES)
g.yrange = (0, self.MAX_BENEFICIO * self.MAX_GENES)
pts = biggles.Points(x, y) #biggles.Points( x, y)
#line = biggles.Curve(x, y)
g.add(pts)
g.xlabel = "Peso total"
g.ylabel = "Beneficio total"
g.title = "Grafo para Generacion %d\n Por GenErik (c) 2008 Erik Giron" % numGeneracion
g.write_img(
512, 384,
"%sgenGraph%03d.png" % (self.OUTPUT_PATH, numGeneracion))
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 plotKey(data, name, key):
## plot the cluster rmsd dist.
plot = biggles.FramedPlot()
plot.add(biggles.PlotLabel(0.5, 0.90, name, size=4))
## customize plot appearence
#plot.x1.label = 'cluster'
plot.y2.label = 'size'
plot.y1.label = key
plot.x2.draw_ticks = 0
plot.y2.draw_ticks = 0
## Plot
plot.add(
biggles.ErrorBarsY(clst_range, data[key][1], data[key][2], width=1))
plot.add(biggles.Points(clst_range, data[key][0], type='cross', size=1))
plot.add(biggles.LineY(0.25, type='dot'))
## add label with info about 'good' solutions
good = []
for clst in clst_range:
if data[key][0][clst - 1] > 0.25:
good += [clst]
plot.add(biggles.PlotLabel(0.5, 0.80, str(good), size=1))
return plot
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 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 adddata_pull(p, data, shift, f):
x = []
y = []
for (e, h, herr) in data:
x.append((e * 2000. + shift) / 1000.)
y.append((h - f(e * 2000. + shift)) / herr)
p.add(biggles.Points(x, y, symboltype="filled circle", symbolsize=0.8))
return y
def plot(complex_lst):
## plot the cluster rmsd dist.
plot = biggles.FramedPlot()
inset = biggles.FramedPlot()
## plot title
plot.title = '/'.join(string.split(absfile(options['o']), '/')[-5:-1])
## customize plot appearence
plot.x1.label = 'cluster'
plot.y2.label = 'size'
plot.y1.label = 'rmsd'
plot.x2.draw_ticks = 0
plot.y2.draw_ticks = 0
inset.frame.draw_ticks = 0
inset.x1.draw_ticklabels = 0
inset.y1.draw_ticklabels = 0
inset.y2.draw_ticklabels = 1
inset.y2.draw_ticks = 1
inset.y2.ticks_style['color'] = 'red'
## get cluter and rmsd lists
clst_list = []
rms_list = []
for compl in complex_lst:
clst_list += [compl.info['hex_clst']]
rms_list += [compl.info['rms']]
## get average, max, min and size of cluster
data = []
clst_range = range(1, max(clst_list) + 1)
for clst in clst_range:
rms = compress(equal(clst_list, clst), rms_list)
data += [[average(rms), max(rms), min(rms), len(rms)]]
data = transpose(data)
## Inset
inset.add(biggles.Curve(clst_range, data[3], color='red'))
## Plot
plot.add(biggles.ErrorBarsY(clst_range, data[1], data[2]))
plot.add(biggles.Points(clst_range, data[0], type='cross', size=1))
plot.add(biggles.Inset((0.0, 0.0), (1.0, 1.0), inset))
plot.add(biggles.LineY(10, type='dot'))
## add label with info about 'good' solutions (average rmsd < 10A)
good = []
for clst in clst_range:
if data[0][clst - 1] < 10:
good += [clst]
plot.add(biggles.PlotLabel(0.5, 0.98, 'Solutions with rmsd < 10A', size=1))
plot.add(biggles.PlotLabel(0.5, 0.95, str(good), size=1))
## plot and save
plot.show()
plot.write_eps(string.split(options['o'], '.')[0] + '.eps')
def plotCOV(self, cells, COV):
self.cov = biggles.FramedPlot()
self.cov.xrange = self.startIdx, self.endIdx + 1
self.cov.yrange = 0, max(COV)
self.cov.xlabel = "Cell Index"
self.cov.ylabel = "COV"
self.cov.add(biggles.Points(cells, COV, type="filled circle"))
self.rows += 1
self.bPlotCOV = True
def plotRasterNewCells(self, times, spikes, startIdx, endIdx):
r = biggles.FramedPlot()
r.xrange = self.startTime, self.endTime + 10
r.yrange = startIdx, endIdx
r.xlabel = "Time (ms)"
r.ylabel = "Cell Index"
r.add(biggles.Points(times, spikes, type="filled circle"))
self.r.append(r)
self.rows += 1
self.bPlotRaster = True
def plot(self, xkey, *ykey, **arg):
"""
Plot pairs of item values. The additional arg arguments are handed
over to biggles.Points(). The special xkey value 'index' uses the
position of each item as x-axis. If only one key is given,
it is taken as ykey and the x-axis is the index of each item
(xkey='index').
C{ EXAMPLE: plot( xkey, [ykey1, ykey2..],[arg1=x, arg2=y]) }
C{ -> biggles.FramedPlot }
@param xkey: key for x-values
@type xkey: any
@param ykey: key for y-values
@type ykey: any
@param arg: arguments handed over to biggles.Points()
@type arg: any
@return: Biggles.FramedPlot, display with show() !
@rtype: Biggles.FramedPlot
"""
if not biggles:
raise ImportError, 'biggles module could not be imported.'
if len(ykey) == 0:
xkey, ykey = 'index', [xkey]
plot = biggles.FramedPlot()
plot.xlabel = xkey
colors = C.colorRange(len(ykey))
if not 'size' in arg:
arg['size'] = 1
for i in range(len(ykey)):
x = range(len(self))
if xkey != 'index':
x = self.valuesOf(xkey)
y = self.valuesOf(ykey[i])
x, y = self.__maskNone(x, y)
plot.add(biggles.Points(x, y, color=colors[i], **arg))
plot.add(
biggles.PlotLabel(0.2,
0.95 - i / 8.0,
ykey[i],
color=colors[i]))
return plot
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 plot(tuning, frametest, lockflags, plot_file=None, format='png'):
import biggles
pl = biggles.FramedPlot()
f = lockflags['flag']
for m, s in [(f, 'filled circle'),
(~f, 'diamond')]:
j, i = m.nonzero()
b = biggles.Points(i,j)
b.style(type=s)
pl.add(b)
pl.x.label = 'Column'
pl.y.label = 'Row'
pl.save(plot_file)
def checklooksokay(f):
import biggles, hist
cont = []
scan = []
peak = []
high = []
conten = []
scanen = []
peaken = []
highen = []
for r in initialrunlist:
if f(r):
if runsummary[r].kind == 'c':
cont.append(r)
conten.append(runsummary[r].energy)
if runsummary[r].kind == 's':
scan.append(r)
scanen.append(runsummary[r].energy)
if runsummary[r].kind == 'p':
peak.append(r)
peaken.append(runsummary[r].energy)
if runsummary[r].kind == 'h':
high.append(r)
highen.append(runsummary[r].energy)
p = biggles.FramedPlot()
if len(cont) > 0:
p.add(biggles.Points(cont, conten, symbolstyle="dot", color="green"))
if len(scan) > 0:
p.add(biggles.Points(scan, scanen, symbolstyle="dot", color="red"))
if len(peak) > 0:
p.add(biggles.Points(peak, peaken, symbolstyle="dot", color="blue"))
if len(high) > 0:
p.add(biggles.Points(high, highen, symbolstyle="dot", color="red"))
p.x1.label = "Run number"
p.y1.label = "Beam energy in GeV"
p.x2.label = "Red is scan/high, blue is peak, green is continuum"
p.show()
p.write_eps("initialrunlist_checklooksokay.eps")
def makeplot(args):
import sys
import biggles
from biggles.libplot import renderer
#import math, Numeric
x = range(10)
y = range(10)
g = biggles.FramedPlot()
pts = biggles.Points( x, y)
g.add( pts )
# render to response
device = renderer.ImageRenderer( "PNG", 640, 480, sys.stdout)
g.page_compose(device)
device.delete()
def plotArray(self, xkey, *ykey, **arg):
"""
Plot pairs of item values.
C{ EXAMPLE: plot( xkey, [ykey1, ykey2..],[arg1=x, arg2=y]) }
C{ -> biggles.FramedPlot }
@param xkey: key for x-values
@type xkey: any
@param ykey: key for y-values
@type ykey: any
@param arg: arguments handed over to biggles.Points()
@type arg: any
@return: Biggles.FramedArray, display with show()
@rtype: Biggles.FramedArray
"""
if not biggles:
raise ImportError, 'biggles module could not be imported.'
if len(ykey) == 0:
xkey, ykey = 'index', [xkey]
plot = biggles.FramedArray(len(ykey), 1)
plot.xlabel = xkey
colors = C.colorRange(len(ykey))
if not 'size' in arg:
arg['size'] = 1
for i in range(len(ykey)):
x = range(len(self))
if xkey != 'index':
x = self.valuesOf(xkey)
y = self.valuesOf(ykey[i])
x, y = self.__maskNone(x, y)
plot[i, 0].add(biggles.Points(x, y, color=colors[i], **arg))
plot[i,
0].add(biggles.PlotLabel(0.2, 0.95, ykey[i], color=colors[i]))
return plot
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 plot_ens(self, keys, member=None, firstBold=0, yrange=None):
"""
Plot the different entropy components versus variable parameter.
keys - [str], keys from R.calculate()
member - int OR None, member index or None for ensemble
"""
colors = ['black', 'red', 'blue', 'green', 'cyan', 'grey54', 'brown']
colors.reverse()
## axis dimensions and labels
p = B.FramedPlot()
p.xlabel = self.var
p.ylabel = 'bound-free entropy [cal/(mol K)]'
if yrange: p.yrange = yrange
d = self.calculate(member)
sz = firstBold * 3 or 1
curves = []
points = []
for k in keys:
c = colors.pop()
curve = B.Curve(self.vrange, d[k], color=c, width=sz)
curve.label = k
pts = B.Points(self.vrange, d[k], color=c, type='filled circle')
curves.append(curve)
points.append(pts)
sz = 1
## add first item last (to have it on top)
curves.reverse()
points.reverse()
for i in range(len(curves)):
p.add(curves[i])
p.add(points[i])
## Legend
curves.reverse()
p.add(B.PlotKey(.70, .85, curves))
return p
def plot(x=None, y=None, style=None, show=None, p=None):
global _matlab
p = _matlab.get_plot(p)
lstyle, color, mstyle = _matlab.get_style(p, style)
if y is None:
y = x
x = range(len(y))
if mstyle is not None:
p.add(biggles.Points(x, y, color=color, symboltype=mstyle))
if lstyle is not None:
p.add(biggles.Curve(x, y, color=color, linetype=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 plot(self, xkey, *ykey, **arg):
"""
Plot pairs of info values. The additional arg arguments are handed
over to biggles.Points().::
plot( xkey, [ykey1, ykey2..],[arg1=x, arg2=y]) -> biggles.FramedPlot
@param xkey: key specifying x-values
@type xkey: str
@param ykey: key specifying y-values
@type ykey: str OR [str]
@param arg: additional biggles arguments
@type arg: key=value
@return: biggles plot object
@rtype: biggles.FramedPlot()
"""
if not biggles:
raise ImportError('biggles module could not be imported.')
plot = biggles.FramedPlot()
plot.xlabel = xkey
colors = t.colorSpectrum(len(ykey))
if not 'size' in arg:
arg['size'] = 1
for i in range(len(ykey)):
x = self.valuesOf(xkey)
y = self.valuesOf(ykey[i])
x, y = self.__maskNone(x, y)
plot.add(biggles.Points(x, y, color=colors[i], **arg))
plot.add(
biggles.PlotLabel(0.2,
0.95 - i / 8.0,
ykey[i],
color=colors[i]))
return plot
