def plot(self):
"""
Plotting function
"""
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(self.radius, self.tcond-self.tcond[0], 'k--', label='Cond. temp.')
xs, ys = mlab.poly_between(self.radius, self.temprmmean-self.temprmstd-self.temprmmean[0],\
self.temprmmean+self.temprmstd-self.temprmmean[0])
ax.fill(xs, ys, facecolor='#aec7e8', edgecolor='None')
ax.plot(self.radius, self.temprmmean-self.temprmmean[0], ls='-', c='#1f77b4',\
lw=2, label='Mean temp.')
xs, ys = mlab.poly_between(self.radius, self.tempEqmean-self.tempEqstd-self.temprmmean[0],\
self.tempEqmean+self.tempEqstd-self.temprmmean[0])
ax.fill(xs, ys, facecolor='#ffbb78', edgecolor='None')
ax.plot(self.radius, self.tempEqmean-self.temprmmean[0],
ls='-.', c='#ff7f0e', lw=2, label='Temp. equat')
xs, ys = mlab.poly_between(self.radius, self.tempPolmean-self.tempPolstd-self.temprmmean[0],\
self.tempPolmean+self.tempPolstd-self.temprmmean[0])
ax.fill(xs, ys, facecolor='#98df8a', edgecolor='None')
ax.plot(self.radius, self.tempPolmean-self.temprmmean[0],
ls='--', c='#2ca02c', lw=2, label='Temp. Pol')
ax.set_xlim(self.ri, self.ro)
ax.set_ylim(0., 1.)
ax.set_ylabel('T')
ax.set_xlabel('r')
ax.legend(loc='upper right', frameon=False)
fig1 = plt.figure()
ax1 = fig1.add_subplot(111)
xs, ys = mlab.poly_between(self.colat*180./np.pi, self.nusstopmean-self.nusstopstd,\
self.nusstopmean+self.nusstopstd)
ax1.fill(xs, ys, facecolor='#aec7e8', edgecolor='None')
ax1.plot(self.colat*180./np.pi, self.nusstopmean, ls='-', color='#1f77b4',\
lw=2, label='Top Nu')
xs, ys = mlab.poly_between(self.colat*180./np.pi, self.nussbotmean-self.nussbotstd,\
self.nussbotmean+self.nussbotstd)
ax1.fill(xs, ys, facecolor='#ffbb78', edgecolor='None')
ax1.plot(self.colat*180./np.pi, self.nussbotmean, ls='--', c='#ff7f0e',\
lw=2, label='Bot Nu')
ax1.set_xlim(0., 180.)
ax1.set_ylabel('Nu')
ax1.set_xlabel('Theta')
ax1.legend(loc='upper right', frameon=False)
ax1.axvline(180./np.pi*np.arcsin(self.ri/self.ro), color='k', linestyle='--')
ax1.axvline(180-180./np.pi*np.arcsin(self.ri/self.ro), color='k', linestyle='--')
def create_snapshot_chart(self, filename: str = '') -> str:
"""
Create chart that depicts the memory allocation over time apportioned
to the tracked classes.
"""
try:
from pylab import (figure, title, xlabel, ylabel, plot, fill,
legend, savefig)
import matplotlib.mlab as mlab
except ImportError:
return self.nopylab_msg % ("memory allocation")
classlist = self.tracked_classes
times = [snapshot.timestamp for snapshot in self.snapshots]
base = [0.0] * len(self.snapshots)
poly_labels = []
polys = []
for cn in classlist:
pct = [
snapshot.classes[cn]['pct'] for snapshot in self.snapshots
if snapshot.classes is not None
]
if pct and max(pct) > 3.0:
sz = [
float(fp.classes[cn]['sum']) / (1024 * 1024)
for fp in self.snapshots if fp.classes is not None
]
sz = [sx + sy for sx, sy in zip(base, sz)]
xp, yp = mlab.poly_between(times, base, sz)
polys.append(((xp, yp), {'label': cn}))
poly_labels.append(cn)
base = sz
figure()
title("Snapshot Memory")
xlabel("Execution Time [s]")
ylabel("Virtual Memory [MiB]")
sizes = [
float(fp.asizeof_total) / (1024 * 1024) for fp in self.snapshots
]
plot(times, sizes, 'r--', label='Total')
sizes = [
float(fp.tracked_total) / (1024 * 1024) for fp in self.snapshots
]
plot(times, sizes, 'b--', label='Tracked total')
for (args, kwds) in polys:
fill(*args, **kwds)
legend(loc=2)
savefig(filename)
return self.chart_tag % (self.relative_path(filename))
def contourf(self, dir, var, **kwargs):
"""
Plot a windrose in filled mode. For each var bins, a line will be
draw on the axes, a segment between each sector (center to center).
Each line can be formated (color, width, ...) like with standard plot
pylab command.
Mandatory:
* dir : 1D array - directions the wind blows from, North centred
* var : 1D array - values of the variable to compute. Typically the wind
speeds
Optional:
* nsector: integer - number of sectors used to compute the windrose
table. If not set, nsectors=16, then each sector will be 360/16=22.5°,
and the resulting computed table will be aligned with the cardinals
points.
* bins : 1D array or integer- number of bins, or a sequence of
bins variable. If not set, bins=6, then
bins=linspace(min(var), max(var), 6)
* blowto : bool. If True, the windrose will be pi rotated,
to show where the wind blow to (usefull for pollutant rose).
* colors : string or tuple - one string color ('k' or 'black'), in this
case all bins will be plotted in this color; a tuple of matplotlib
color args (string, float, rgb, etc), different levels will be plotted
in different colors in the order specified.
* cmap : a cm Colormap instance from matplotlib.cm.
- if cmap == None and colors == None, a default Colormap is used.
others kwargs :
* see help(pylab.plot)
"""
bins, nbins, nsector, colors, angles, kwargs = self._init_plot(dir, var,
**kwargs)
null = kwargs.pop('facecolor', None)
null = kwargs.pop('edgecolor', None)
#closing lines
angles = np.hstack((angles, angles[-1]-2*np.pi/nsector))
vals = np.hstack((self._info['table'],
np.reshape(self._info['table'][:,0],
(self._info['table'].shape[0], 1))))
offset = 0
for i in range(nbins):
val = vals[i,:] + offset
offset += vals[i, :]
zorder = ZBASE + nbins - i
xs, ys = poly_between(angles, 0, val)
patch = self.fill(xs, ys, facecolor=colors[i],
edgecolor=colors[i], zorder=zorder, **kwargs)
self.patches_list.extend(patch)
def create_snapshot_chart(self, filename=''):
"""
Create chart that depicts the memory allocation over time apportioned
to the tracked classes.
"""
try:
from pylab import (figure, title, xlabel, ylabel, plot, fill,
legend, savefig)
import matplotlib.mlab as mlab
except ImportError:
return self.nopylab_msg % ("memory allocation")
classlist = self.tracked_classes
times = [snapshot.timestamp for snapshot in self.snapshots]
base = [0] * len(self.snapshots)
poly_labels = []
polys = []
for cn in classlist:
pct = [snapshot.classes[cn]['pct'] for snapshot in self.snapshots]
if max(pct) > 3.0:
sz = [float(fp.classes[cn]['sum']) / (1024 * 1024)
for fp in self.snapshots]
sz = [sx + sy for sx, sy in zip(base, sz)]
xp, yp = mlab.poly_between(times, base, sz)
polys.append(((xp, yp), {'label': cn}))
poly_labels.append(cn)
base = sz
figure()
title("Snapshot Memory")
xlabel("Execution Time [s]")
ylabel("Virtual Memory [MiB]")
sizes = [float(fp.asizeof_total) / (1024 * 1024)
for fp in self.snapshots]
plot(times, sizes, 'r--', label='Total')
sizes = [float(fp.tracked_total) / (1024 * 1024)
for fp in self.snapshots]
plot(times, sizes, 'b--', label='Tracked total')
for (args, kwds) in polys:
fill(*args, **kwds)
legend(loc=2)
savefig(filename)
return self.chart_tag % (self.relative_path(filename))
from __future__ import division
import numpy as np
import matplotlib as mpl
import matplotlib.mlab as mlab
import pylab as pl
yoffs = np.arange(10)
nplots = len(yoffs)
x = np.arange(0, 1, 0.1)
npoints = len(x)
y = np.zeros((nplots, len(x)))
stdy = np.zeros((nplots, len(x)))
verts = np.zeros((nplots, 2 * npoints, 2)) # each timepoint has a +ve and a -ve value
for ploti, yoff in enumerate(yoffs):
y[ploti] = np.random.random(len(x)) / 2 + 0.25 + yoff
stdy[ploti] = 0.2 + np.random.random(len(x)) * 0.2
vert = mlab.poly_between(x, y[ploti] - stdy[ploti], y[ploti] + stdy[ploti])
vert = np.asarray(vert).T
verts[ploti] = vert
# can also use axes.fill() instead of a poly collection, or directly use axes.fill_between()
pcol = mpl.collections.PolyCollection(verts, facecolors="r", edgecolors="none", alpha=0.2)
a = pl.gca()
# pcol = a.fill_between(x, y+stdy, y-stdy, facecolors='r', edgecolors='none', alpha=0.2)
a.add_collection(pcol)
for ploti in range(nplots):
a.plot(x, y[ploti], "r-")
a.set_xlim((0, 1))
#!/usr/bin/env python
import matplotlib.mlab as mlab
from pylab import figure, show
import numpy as npy
x = npy.arange(0, 2, 0.01)
y1 = npy.sin(2*npy.pi*x)
y2 = npy.sin(4*npy.pi*x) + 2
fig = figure()
ax = fig.add_subplot(311)
ax2 = fig.add_subplot(312)
ax3 = fig.add_subplot(313)
xs, ys = mlab.poly_between(x, 0, y1)
ax.fill(xs, ys)
ax.set_ylabel('between y1 and 0')
xs, ys = mlab.poly_between(x, y1, 1)
ax2.fill(xs, ys)
ax2.set_ylabel('between y1 and 1')
xs, ys = mlab.poly_between(x, y1, y2)
ax3.fill(xs, ys)
ax3.set_ylabel('between y1 and y2')
ax3.set_xlabel('x')
show()
#!/usr/bin/env python
import matplotlib.mlab as mlab
from pylab import figure, show
import numpy as npy
x = npy.arange(0, 2, 0.01)
y1 = npy.sin(2 * npy.pi * x)
y2 = npy.sin(4 * npy.pi * x) + 2
fig = figure()
ax = fig.add_subplot(311)
ax2 = fig.add_subplot(312)
ax3 = fig.add_subplot(313)
xs, ys = mlab.poly_between(x, 0, y1)
ax.fill(xs, ys)
ax.set_ylabel('between y1 and 0')
xs, ys = mlab.poly_between(x, y1, 1)
ax2.fill(xs, ys)
ax2.set_ylabel('between y1 and 1')
xs, ys = mlab.poly_between(x, y1, y2)
ax3.fill(xs, ys)
ax3.set_ylabel('between y1 and y2')
ax3.set_xlabel('x')
show()
def plot(ocd,
calib,
file_name = "test.jpg",
interpolation = False):
fig = plt.figure(figsize=(12,6))
ax1 = plt.subplot(111)
plt.xlabel("{} - Calibrated date (BC)".format(ocd.name), fontsize=18)
plt.ylabel("Radiocarbon determination (BP)", fontsize=18)
plt.text(0., 0.99,"pyC14 v0.1; Xtof; Bellevue 2008-2012",
horizontalalignment='left',
verticalalignment='bottom',
transform = ax1.transAxes,
size=9,
bbox=dict(facecolor='white', alpha=1, lw=0))
# Calendar Age
ax2 = plt.twinx()
calib_0 = (ocd.likelihood.array)
calib_1 = (ocd.posterior.array)
if(interpolation):
calib_0 = interpolate(calib_0)
calib_1 = interpolate(calib_1)
max_prob_ref = max(calib_0[:,1])
min_prob_ref = min(calib_0[:,1])
max_prob_calib = max(calib_1[:,1])
min_prob_calib = min(calib_1[:,1])
beta = ocd.adjust_comparaison()
ax2.fill(
calib_0[:,0],
calib_0[:,1] + max(max_prob_ref, max_prob_calib)*0.3,
'k',
alpha=0.2,
)
ax2.plot(
calib_0[:,0],
calib_0[:,1] + max(max_prob_ref, max_prob_calib)*0.3,
'k:',
alpha=0.5
)
# Calendar Age bis
ax2b = plt.twinx()
ax2b.fill(
calib_1[:,0],
calib_1[:,1]/beta + max(max_prob_ref, max_prob_calib)*0.3,
'k',
alpha=0.5,
)
ax2b.plot(
calib_1[:,0],
calib_1[:,1]/beta + max(max_prob_ref, max_prob_calib)*0.3,
'k',
alpha=0.5
)
#print(min_prob_ref, min_prob_calib)
#print(max_prob_ref, max_prob_calib)
ax2.set_ybound(
min(min_prob_ref, min_prob_calib),
max(max_prob_ref, max_prob_calib)*3)
ax2b.set_ybound(
min(min_prob_ref, min_prob_calib),
max(max_prob_ref, max_prob_calib)*3)
ax2.set_axis_off()
ax2b.set_axis_off()
# Radiocarbon Age
sample_interval = np.arange(ocd.date-4*ocd.error, ocd.date+4*ocd.error,1.)
sample_curve = normpdf(sample_interval, ocd.date, ocd.error)
max_sample_curve = max(sample_curve)
line_x = np.array([0, max_sample_curve*3])
line_y = np.array([ocd.date, ocd.date])
ax3 = plt.twiny(ax1)
for i in range(-1,2,1):
ax3.plot(
line_x,
line_y+i*ocd.error,
'k--',
alpha=0.5-0.2*abs(i),
lw=2-abs(i)
)
ax3.fill(
sample_curve,
sample_interval,
'r',
alpha=0.4
)
ax3.plot(
sample_curve,
sample_interval,
'r',
alpha=0.5
)
ax3.set_xbound(0,max_sample_curve*4)
ax3.set_axis_off()
# Calibration Curve
xs, ys = mlab.poly_between(calib.array[:,0],
calib.array[:,1] - calib.array[:,2],
calib.array[:,1] + calib.array[:,2])
ax1.fill(xs, ys, 'b', alpha=0.3)
ax1.plot(
calib.array[:,0],
calib.array[:,1],
'b',
alpha=0.5,
lw=1
)
# Confidence intervals
ymin=[0.075, 0.05, 0.025]
if(ocd.posterior.used):
calibrated = ocd.posterior
else:
calibrated = ocd.likelihood
for j in range(2,-1,-1):
for i in calibrated.range[j]:
ax1.axvspan(
i[0], i[1],
ymin=ymin[j],
ymax=ymin[j]+0.07,
facecolor='none',
alpha=0.8)
ax1.axvspan(
i[0], i[1],
ymin=ymin[j]+0.02,
ymax=ymin[j]+0.07,
facecolor='w',
edgecolor='w',
lw=2)
comments = ocd.ref + "\n"
comments += calib.ref + "\n"
plt.text(0.55, 0.90,'{}'.format(comments),
horizontalalignment='left',
verticalalignment='center',
transform = ax1.transAxes,
bbox=dict(facecolor='white', alpha=0.9, lw=0))
plt.text(0.745, 0.68,'{}'.format(calibrated.get_meta("",False)),
horizontalalignment='left',
verticalalignment='center',
transform = ax1.transAxes,
bbox=dict(facecolor='white', alpha=0.9, lw=0))
# FIXME the following values 10 and 5 are arbitrary and could be probably
# drawn from the f_m value itself, while preserving their ratio
tl = len(ocd.likelihood.array[:,0])
ax1.set_ybound(ocd.date - ocd.error * 8, ocd.date + ocd.error * 8)
ax1.set_xbound(ocd.likelihood.array[0,0],ocd.likelihood.array[-1,0])
#plt.savefig('image_%d±%d.pdf' %(f_m, sigma_m))
plt.savefig(file_name)
fig = plt.gcf()
fig.clear()
def plot(ocd,
calib,
file_name = "test.jpg",
use_model = True):
fig = plt.figure(figsize=(8,2))
ax1 = plt.subplot(111)
plt.ylabel("C14 age (BP)", fontsize=11)
plt.text(-0.14, -0.11,"Date (BC)",
horizontalalignment='left',
verticalalignment='bottom',
transform = ax1.transAxes,
size=11)
plt.text(0.0, 0.97,"pyC14 v0.1; Xtof; Ard-team",
horizontalalignment='left',
verticalalignment='bottom',
transform = ax1.transAxes,
size=7,
bbox=dict(facecolor='white', alpha=1, lw=0))
comments = ""
comments += ocd.ref + "\n"
comments += calib.ref + "\n"
plt.text(0.55, 0.85,'{}'.format(comments),
horizontalalignment='left',
verticalalignment='center',
transform = ax1.transAxes,
size=8,
bbox=dict(facecolor='white', alpha=0.9, lw=0))
alphaY = 8
if(ocd.posterior.used and use_model):
calibrated = ocd.posterior
alphaY = 6
else:
calibrated = ocd.likelihood
# Calendar Age
# imitate OxCal
ax2 = plt.twinx()
ax2.fill(
calibrated.calibAxis,
calibrated.prob + max(calibrated.prob)*0.3,
'k',
alpha=0.3
)
ax2.plot(
calibrated.calibAxis,
calibrated.prob + max(calibrated.prob)*0.3,
'k',
alpha=0.8
)
ax2.set_ybound(min(calibrated.prob),max(calibrated.prob)*1.7)
tl = len(calibrated.calibAxis)
ax2.set_xbound(calibrated.array[0,0],calibrated.array[-1,0])
ax2.set_axis_off()
# Radiocarbon Age
sample_interval = np.arange(ocd.date-4*ocd.error, ocd.date+4*ocd.error,1.)
sample_curve = normpdf(sample_interval, ocd.date, ocd.error)
line_x = np.array([0, 1])
line_y = np.array([ocd.date, ocd.date])
ax3 = plt.twiny(ax1)
for i in range(-1,2,1):
ax3.plot(
line_x,
line_y+i*ocd.error,
'k--',
alpha=0.5-0.2*abs(i),
lw=1.5-abs(i)
)
ax3.fill(
sample_curve,
sample_interval,
'r',
alpha=0.3
)
ax3.plot(
sample_curve,
sample_interval,
'r',
alpha=0.3,
label='Radiocarbon determination (BP)'
)
ax3.set_xbound(0,max(sample_curve)*4)
ax3.set_axis_off()
# Calibration Curve
xs, ys = mlab.poly_between(calib.array[:,0],
calib.array[:,1] - calib.array[:,2],
calib.array[:,1] + calib.array[:,2])
ax1.fill(xs, ys, 'b', alpha=0.3)
# Confidence intervals
ymin=[0.14, 0.10, 0.06]
for j in range(2,-1,-1):
for i in calibrated.range[j]:
ax1.axvspan(
i[0], i[1],
ymin=ymin[j],
ymax=ymin[j]+0.07,
facecolor='none',
alpha=0.8)
ax1.axvspan(
i[0], i[1],
ymin=ymin[j]+0.03,
ymax=ymin[j]+0.07,
facecolor='w',
edgecolor='w',
lw=2)
# FIXME the following values 10 and 5 are arbitrary and could be probably
# drawn from the f_m value itself, while preserving their ratio
detla_BP = ocd.likelihood.mean - calibrated.mean
ax1.set_ybound(ocd.date - ocd.error*alphaY + detla_BP, ocd.date + ocd.error*alphaY + detla_BP)
ax1.set_xbound(calibrated.array[0,0],calibrated.array[-1,0])
#plt.savefig('image_%d±%d.pdf' %(f_m, sigma_m))
plt.savefig(file_name)
fig = plt.gcf()
fig.clear()
def on_draw(self):
yup = self.ui.sigTop.value()
ydown = self.ui.sigBottom.value()
yrefup = self.ui.ref1Top.value()
yrefdown = self.ui.ref1Bottom.value()
yref2up = self.ui.ref2Top.value()
yref2down = self.ui.ref2Bottom.value()
n = self.ui.NumSignals.value()
if n == 0:
n = 1
dh = self.ui.SigSpacing.value()
self.lup[0].set_data([0, self.data["var"]["nx"]], [yup, yup])
self.ldown[0].set_data([0, self.data["var"]["nx"]], [ydown, ydown])
self.lref1up.set_data([0, self.data["var"]["nx"]], [yrefup, yrefup])
self.lref1down.set_data([0, self.data["var"]["nx"]], [yrefdown, yrefdown])
self.lref2up.set_data([0, self.data["var"]["nx"]], [yref2up, yref2up])
self.lref2down.set_data([0, self.data["var"]["nx"]], [yref2down, yref2down])
self.plt.clear()
self.ref.clear()
self.raw.clear()
self.ref.clear()
# Signals
data = [np.mean(self.data["rawdata"][yup:ydown], 0)]
self.raw.plot(self.data["wavelength"], data[0], color="black")
if self.ui.multisig.checkState() == QtCore.Qt.Checked:
if len(self.lup) > n:
for i in range(n + 1, len(self.lup)):
self.axes.remove(self.lup[i])
self.axes.remove(self.ldown[i])
self.lup = self.lup[:n]
self.ldown = self.ldown[:n]
if n > 1:
if len(self.lup) < n:
for i in range(len(self.lup), n):
self.lup.append(mpl.lines.Line2D([0, self.data["var"]["nx"]], [0, 0], color="red"))
self.ldown.append(mpl.lines.Line2D([0, self.data["var"]["nx"]], [0, 0], color="red"))
self.axes.add_line(self.lup[i])
self.axes.add_line(self.ldown[i])
for i in range(1, n):
data.append(np.mean(self.data["rawdata"][int(yup - dh * i) : int(ydown - dh * i)], 0))
self.raw.plot(self.data["wavelength"], data[i])
self.lup[i].set_data([0, self.data["var"]["nx"]], [int(yup - dh * i), int(yup - dh * i)])
self.ldown[i].set_data([0, self.data["var"]["nx"]], [int(ydown - dh * i), int(ydown - dh * i)])
# Sig StdDev
drs = np.sqrt(np.var(self.data["rawdata"][yup:ydown], 0))
if self.ui.rawsigStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.data["wavelength"], data[0] - drs, data[0] + drs)
self.raw.fill(vx, vy, color="red")
# Reference Signal
if yrefup != yrefdown:
ref = np.mean(self.data["rawdata"][yrefup:yrefdown], 0)
self.ref.plot(self.data["wavelength"], ref, color="black")
# Std Dev
delta = np.sqrt(np.var(self.data["rawdata"][yrefup:yrefdown], 0))
if self.ui.refStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.data["wavelength"], ref - delta, ref + delta)
self.ref.fill(vx, vy, color="blue")
DS = np.sqrt((drs / ref) ** 2 + ((data[0] * delta) / (ref ** 2)) ** 2)
data[0] = data[0] / ref
self.plt.plot(self.data["wavelength"], data[0], color="black")
if self.ui.multisig.checkState() == QtCore.Qt.Checked:
if n > 1:
for i in range(1, n):
data[i] = data[i] - ref
self.plt.plot(self.data["wavelength"], data[i])
if self.ui.sigStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.data["wavelength"], data[0] - DS, data[0] + DS)
self.plt.fill(vx, vy)
self.canvas.draw()
def on_draw(self):
yup = self.ui.sigTop.value()
ydown = self.ui.sigBottom.value()
yrefup = self.ui.ref1Top.value()
yrefdown = self.ui.ref1Bottom.value()
yref2up = self.ui.ref2Top.value()
yref2down = self.ui.ref2Bottom.value()
n = self.ui.NumSignals.value()
if n == 0: n = 1
dh = self.ui.SigSpacing.value()
self.lup[0].set_data([0, self.data["var"]['nx']], [yup, yup])
self.ldown[0].set_data([0, self.data["var"]['nx']], [ydown, ydown])
self.lref1up.set_data([0, self.data["var"]['nx']], [yrefup, yrefup])
self.lref1down.set_data([0, self.data["var"]['nx']],
[yrefdown, yrefdown])
self.lref2up.set_data([0, self.data["var"]['nx']], [yref2up, yref2up])
self.lref2down.set_data([0, self.data["var"]['nx']],
[yref2down, yref2down])
self.plt.clear()
self.ref.clear()
self.raw.clear()
self.ref.clear()
# Signals
data = [np.mean(self.data["rawdata"][yup:ydown], 0)]
self.raw.plot(self.data["wavelength"], data[0], color="black")
if self.ui.multisig.checkState() == QtCore.Qt.Checked:
if len(self.lup) > n:
for i in range(n + 1, len(self.lup)):
self.axes.remove(self.lup[i])
self.axes.remove(self.ldown[i])
self.lup = self.lup[:n]
self.ldown = self.ldown[:n]
if n > 1:
if len(self.lup) < n:
for i in range(len(self.lup), n):
self.lup.append(
mpl.lines.Line2D([0, self.data["var"]['nx']],
[0, 0],
color="red"))
self.ldown.append(
mpl.lines.Line2D([0, self.data["var"]['nx']],
[0, 0],
color="red"))
self.axes.add_line(self.lup[i])
self.axes.add_line(self.ldown[i])
for i in range(1, n):
data.append(
np.mean(
self.data["rawdata"][int(yup -
dh * i):int(ydown -
dh * i)], 0))
self.raw.plot(self.data["wavelength"], data[i])
self.lup[i].set_data(
[0, self.data["var"]['nx']],
[int(yup - dh * i),
int(yup - dh * i)])
self.ldown[i].set_data(
[0, self.data["var"]['nx']],
[int(ydown - dh * i),
int(ydown - dh * i)])
# Sig StdDev
drs = np.sqrt(np.var(self.data["rawdata"][yup:ydown], 0))
if self.ui.rawsigStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.data["wavelength"], data[0] - drs,
data[0] + drs)
self.raw.fill(vx, vy, color="red")
# Reference Signal
if yrefup != yrefdown:
ref = np.mean(self.data["rawdata"][yrefup:yrefdown], 0)
self.ref.plot(self.data["wavelength"], ref, color="black")
# Std Dev
delta = np.sqrt(np.var(self.data["rawdata"][yrefup:yrefdown], 0))
if self.ui.refStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.data["wavelength"],
ref - delta, ref + delta)
self.ref.fill(vx, vy, color="blue")
DS = np.sqrt((drs / ref)**2 + ((data[0] * delta) /
(ref**2))**2)
data[0] = data[0] / ref
self.plt.plot(self.data["wavelength"], data[0], color="black")
if self.ui.multisig.checkState() == QtCore.Qt.Checked:
if n > 1:
for i in range(1, n):
data[i] = data[i] - ref
self.plt.plot(self.data["wavelength"], data[i])
if self.ui.sigStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.data["wavelength"],
data[0] - DS, data[0] + DS)
self.plt.fill(vx, vy)
self.canvas.draw()
def __init__(self, ax, orbit_collection, ensemble_mean=True, calval=True):
# Prepare Input
orbit_ensemble = orbit_collection.orbit_ensemble
orbit_ensemble_mean = orbit_ensemble.get_ensemble_mean()
calval_ensemble = orbit_collection.calval_ensemble
# Plot all datasets
for dataset_id in orbit_ensemble.dataset_ids:
color = DATASET_COLOR[dataset_id]
marker = DATASET_MARKER[dataset_id]
# Get statistics for each dataset
dataset_mean = orbit_ensemble.get_member_mean(dataset_id)
# Plot the mean as lines and symbols
# ax.plot(orbit_ensemble.time[is_valid], dataset_mean[is_valid],
# color=color, **self.datasetl_props)
ax.scatter(orbit_ensemble.time,
dataset_mean,
color=color,
marker=marker,
**self.datasets_props)
# Plot ensemble means
if ensemble_mean:
ax.plot(orbit_ensemble.time,
orbit_ensemble_mean,
label="Ensemble Mean Thickness",
**self.ensemble_mean_props)
# Fill in between ensemble min/max
emin, emax = orbit_ensemble.get_ensemble_minmax()
is_valid = np.where(np.isfinite(dataset_mean))
# Plot standard deviation envelope in the background
is_valid = np.where(np.isfinite(emin))
xs, ys = poly_between(orbit_ensemble.time[is_valid],
emin[is_valid], emax[is_valid])
ax.fill(xs, ys, **self.sdev_fill_props)
# Plot the calval ensembles
if calval:
calval_props = dict(aem=self.calval_props_aem,
oib=self.calval_props_oib)
shadow = [
path_effects.SimpleLineShadow(offset=(1, -1)),
path_effects.Normal()
]
for calval_id in calval_ensemble.dataset_ids:
dataset_mean = calval_ensemble.get_member_mean(calval_id)
source_id = calval_id[-3:]
ax.scatter(calval_ensemble.time,
dataset_mean,
path_effects=shadow,
label=source_id.upper(),
**calval_props[source_id])
ax.set_xlim(orbit_collection.time_range)
leg = ax.legend(**self.legend_props)
leg.set_zorder(300)
def on_draw(self): yup = self.ui.sigTop.value() ydown = self.ui.sigBottom.value() yrefup= self.ui.ref1Top.value() yrefdown = self.ui.ref1Bottom.value() yref2up = self.ui.ref2Top.value() yref2down = self.ui.ref2Bottom.value() n=self.ui.NumSignals.value() if n==0: n=1 dh=self.ui.SigSpacing.value() if self.ui.Smin.value()!=self.lmin or self.ui.Smax.value()!=self.lmax: mmin=np.min(self.data["sig"]) mmax=np.max(self.data["sig"]) md=mmax-mmin dd=(self.ui.Smin.maximum()-self.ui.Smin.minimum()) self.lmin=self.ui.Smin.value() self.lmax=self.ui.Smax.value() cmin=mmin+(md*self.lmin)/dd cmax=mmin+(md*self.lmax)/dd self.axes.imshow(self.data["sig"],vmin=cmin,vmax=cmax) self.lup[0].set_data([0,self.ds[0]],[yup,yup]) self.ldown[0].set_data([0,self.ds[0]],[ydown,ydown]) self.lref1up[0].set_data([0,self.ds[0]],[yrefup,yrefup]) self.lref1down[0].set_data([0,self.ds[0]],[yrefdown,yrefdown]) self.lref2up.set_data([0,self.ds[0]],[yref2up,yref2up]) self.lref2down.set_data([0,self.ds[0]],[yref2down,yref2down]) self.plt.clear() self.ref.clear() self.raw.clear() self.ref.clear() # Signals data=[np.mean(self.data["sig"][yup:ydown],0)] self.raw.plot(self.wavelength,data[0],color="black") if self.ui.multisig.checkState()==QtCore.Qt.Checked: if len(self.lup)>n: for i in range(n+1,len(self.lup)): del self.lup[i] del self.ldown[i] self.lup=self.lup[:n] self.ldown=self.ldown[:n] if n>1: if len(self.lup)>n: for i in range(n,len(self.lup)): del self.lup[i] del self.ldown[i] if len(self.lup)<n: for i in range(len(self.lup),n): self.lup.append(mpl.lines.Line2D([0,self.ds[0]],[0,0],color="red")) self.ldown.append(mpl.lines.Line2D([0,self.ds[0]],[0,0],color="red")) self.axes.add_line(self.lup[i]) self.axes.add_line(self.ldown[i]) for i in range(1,n): data.append(np.mean(self.data["sig"][int(yup-dh*i):int(ydown-dh*i)],0)) self.raw.plot(self.wavelength,data[i]) self.lup[i].set_data([0,self.ds[0]],[int(yup-dh*i),int(yup-dh*i)]) self.ldown[i].set_data([0,self.ds[0]],[int(ydown-dh*i),int(ydown-dh*i)]) # Sig StdDev DS2=0 drs=np.sqrt(np.var(self.data["sig"][yup:ydown],0)) if self.ui.rawsigStdDev.checkState()==QtCore.Qt.Checked: vx,vy = mlab.poly_between(self.wavelength,data[0]-drs,data[0]+drs) self.raw.fill(vx,vy,color="red") DS2+=(drs)**2 # Reference Signal if yrefup!=yrefdown: ref=[np.mean(self.data["sig"][yrefup:yrefdown],0)] self.ref.plot(self.wavelength,ref[0],color="black") # Std Dev delta=np.sqrt(np.var(self.data["sig"][yrefup:yrefdown],0)) if self.ui.refStdDev.checkState()==QtCore.Qt.Checked: vx,vy = mlab.poly_between(self.wavelength,ref[0]-delta,ref[0]+delta) self.ref.fill(vx,vy,color="blue") DS2+=(delta)**2 DS=np.sqrt(DS2) data[0]=data[0]-ref[0] self.plt.plot(self.wavelength,data[0],color="black") if self.ui.multisig.checkState()==QtCore.Qt.Checked: if n>1: if self.ui.MultiRef.checkState()==QtCore.Qt.Checked: if len(self.lref1up)>n: for i in range(n,len(self.lref1up)): del self.lref1up[i] del self.lref1down[i] if len(self.lref1up)<n: for i in range(len(self.lref1up),n): self.lref1up.append(mpl.lines.Line2D([0,self.ds[0]],[0,0],color="green")) self.lref1down.append(mpl.lines.Line2D([0,self.ds[0]],[0,0],color="green")) self.axes.add_line(self.lref1up[i]) self.axes.add_line(self.lref1down[i]) if self.debug: print "++",i for i in range(1,n): ref.append(np.mean(self.data["sig"][int(yrefup-dh*i):int(yrefdown-dh*i)],0)) data[i]=data[i]-ref[i] self.lref1up[i].set_data([0,self.ds[0]],[int(yrefup-dh*i),int(yrefup-dh*i)]) self.lref1down[i].set_data([0,self.ds[0]],[int(yrefdown-dh*i),int(yrefdown-dh*i)]) else: if len(self.lref1up)>1: for i in range(len(self.lref1up)-1,0,-1): if self.debug: print "-",i self.lref1up[i].set_data([0,self.ds[0]],[0,0]) self.lref1down[i].set_data([0,self.ds[0]],[0,0]) del self.lref1up[i] del self.lref1down[i] for i in range(1,n): data[i]=data[i]-ref[0] for i in range(1,n): self.plt.plot(self.wavelength,data[i]) if self.ui.sigStdDev.checkState()==QtCore.Qt.Checked: vx,vy = mlab.poly_between(self.wavelength,data[0]-DS,data[0]+DS) self.plt.fill(vx,vy) self.canvas.draw()
def single_plot(calibrated_age, oxcal=False, output=None, BP=True):
calibrated_age = calibrated_age
f_m = calibrated_age.radiocarbon_sample.date
sigma_m = calibrated_age.radiocarbon_sample.sigma
radiocarbon_sample_id = calibrated_age.radiocarbon_sample.id
calibration_curve = calibrated_age.calibration_curve
calibration_curve_title = calibrated_age.calibration_curve.title
intervals68 = calibrated_age.intervals68
intervals95 = calibrated_age.intervals95
sample_interval = 1950 - calibration_curve[:,0].copy() # for determination plot
min_year, max_year = (50000, -50000)
minx = min(calibrated_age[:,0])
maxx = max(calibrated_age[:,0])
if min_year < minx:
pass
else:
min_year = minx
if max_year > maxx:
pass
else:
max_year = maxx
# do not plot the part of calibration curve that is not visible
# greatly reduces execution time \o/
cutmin = calibration_curve[calibration_curve[:,0]>minx]
cutmax = cutmin[cutmin[:,0]<maxx]
calibration_curve = cutmax
if BP is False:
if min_year < 0 and max_year > 0:
ad_bp_label = "BC/AD"
elif min_year < 0 and max_year < 0:
ad_bp_label = "BC"
elif min_year > 0 and max_year > 0:
ad_bp_label = "AD"
else:
ad_bp_label = "BP"
string68 = "".join(
util.interval_to_string(
itv, calibrated_age, BP
) for itv in intervals68
)
string95 = "".join(
util.interval_to_string(
itv, calibrated_age, BP
) for itv in intervals95
)
fig = plt.figure(figsize=(12,8))
ax1 = plt.subplot(111)
ax1.set_axis_bgcolor(COLORS['bgcolor'])
plt.xlabel("Calibrated age (%s)" % ad_bp_label)
plt.ylabel("Radiocarbon determination (BP)")
plt.text(0.5, 0.95,r'%s: $%d \pm %d BP$' % (radiocarbon_sample_id, f_m, sigma_m),
horizontalalignment='center',
verticalalignment='center',
transform = ax1.transAxes,
bbox=dict(facecolor='white', alpha=0.9, lw=0))
plt.text(0.75, 0.80,'68.2%% probability\n%s\n95.4%% probability\n%s' \
% (string68, string95),
horizontalalignment='left',
verticalalignment='center',
transform = ax1.transAxes,
bbox=dict(facecolor='white', alpha=0.9, lw=0))
plt.text(0.0, 1.0,'IOSACal v0.1; %s' % calibration_curve_title,
horizontalalignment='left',
verticalalignment='bottom',
transform = ax1.transAxes,
size=7,
bbox=dict(facecolor='white', alpha=0.9, lw=0))
# Calendar Age
ax2 = plt.twinx()
if oxcal is True:
# imitate OxCal
ax2.fill(
calibrated_age[:,0],
calibrated_age[:,1] + max(calibrated_age[:,1])*0.3,
'k',
alpha=0.3,
label='Calendar Age'
)
ax2.plot(
calibrated_age[:,0],
calibrated_age[:,1],
'k',
alpha=0
)
else:
ax2.fill(
calibrated_age[:,0],
calibrated_age[:,1],
'k',
alpha=0.3,
label='Calendar Age'
)
ax2.plot(
calibrated_age[:,0],
calibrated_age[:,1],
'k',
alpha=0
)
ax2.set_ybound(min(calibrated_age[:,1]),max(calibrated_age[:,1])*3)
ax2.set_xbound(min(calibrated_age[:,0]),max(calibrated_age[:,0]))
ax2.set_axis_off()
# Radiocarbon Age
sample_curve = normpdf(sample_interval, f_m, sigma_m)
ax3 = plt.twiny(ax1)
ax3.fill(
sample_curve,
sample_interval,
'r',
alpha=0.3
)
ax3.set_xbound(0,max(sample_curve)*4)
ax3.set_axis_off()
# Calibration Curve
mlab_low = calibration_curve[:,1] - calibration_curve[:,2]
mlab_high = calibration_curve[:,1] + calibration_curve[:,2]
xs, ys = mlab.poly_between(calibration_curve[:,0],
mlab_low,
mlab_high)
ax1.fill(xs, ys, fc='#000000', ec='none', alpha=0.15)
ax1.plot(calibration_curve[:,0], calibration_curve[:,1], '#000000', alpha=0.5)
# Confidence intervals
if oxcal is True:
for i in intervals68:
ax1.axvspan(
min(i),
max(i),
ymin=0.05,
ymax=0.07,
facecolor='none',
alpha=0.8)
ax1.axvspan(
min(i),
max(i),
ymin=0.068,
ymax=0.072,
facecolor='w',
edgecolor='w',
lw=2)
for i in intervals95:
ax1.axvspan(
min(i),
max(i),
ymin=0.025,
ymax=0.045,
facecolor='none',
alpha=0.8)
ax1.axvspan(
min(i),
max(i),
ymin=0.043,
ymax=0.047,
facecolor='w',
edgecolor='w',
lw=2)
else:
for i in intervals68:
ax1.axvspan(
min(i),
max(i),
ymin=0,
ymax=0.02,
facecolor='k',
alpha=0.5)
for i in intervals95:
ax1.axvspan(
min(i),
max(i),
ymin=0,
ymax=0.02,
facecolor='k',
alpha=0.5)
# FIXME the following values 10 and 5 are arbitrary and could be probably
# drawn from the f_m value itself, while preserving their ratio
ax1.set_ybound(f_m - sigma_m * 15, f_m + sigma_m * 5)
ax1.set_xbound(min(calibrated_age[:,0]),max(calibrated_age[:,0]))
ax1.invert_xaxis() # if BP == True
#plt.savefig('image_%d±%d.pdf' %(f_m, sigma_m))
if output:
plt.savefig(output)
fig = plt.gcf()
fig.clear()
sensorHalfDiagonal = d/2
X = np.linspace(0, sensorHalfDiagonal, 100)
Xscaled = X/sensorHalfHeight
fig, ax = drawLinePlot(X,
(rd(Xscaled)-Xscaled)/Xscaled*100,
xlim=[0, sensorHalfDiagonal],
xlabel='$h\;(\mathrm{mm})$',
ylabel='distortion $D\;(\%)$',
)
saveFig(os.path.join(plotsPath, 'dist_relative_1d.svg'), fig)
fig, ax = drawLinePlot(X,
rd1(Xscaled)*sensorHalfHeight,
xlim=[0, sensorHalfDiagonal],
xlabel='$h\;(\mathrm{mm})$',
ylabel='$dD/dh\;(\mathrm{mm}^{-1})$',
)
# shade y>0 and y<0 with colors, to indicate pincushion vs. barrel distortion
alpha = 0.3
ymin, ymax = ax.get_ylim()
ax.autoscale(False)
polyPincushion = poly_between([0,sensorHalfDiagonal], 0, ymax)
ax.fill(*polyPincushion, alpha=alpha, facecolor='orange')
polyBarrel = poly_between([0,sensorHalfDiagonal], ymin, 0)
ax.fill(*polyBarrel, alpha=alpha, facecolor='blue')
saveFig(os.path.join(plotsPath, 'dist_derivative_1d.svg'), fig)
def on_draw(self):
yup = self.ui.sigTop.value()
ydown = self.ui.sigBottom.value()
yrefup = self.ui.ref1Top.value()
yrefdown = self.ui.ref1Bottom.value()
yref2up = self.ui.ref2Top.value()
yref2down = self.ui.ref2Bottom.value()
n = self.ui.NumSignals.value()
if n == 0: n = 1
dh = self.ui.SigSpacing.value()
if self.ui.Smin.value() != self.lmin or self.ui.Smax.value(
) != self.lmax:
mmin = np.min(self.data["sig"])
mmax = np.max(self.data["sig"])
md = mmax - mmin
dd = (self.ui.Smin.maximum() - self.ui.Smin.minimum())
self.lmin = self.ui.Smin.value()
self.lmax = self.ui.Smax.value()
cmin = mmin + (md * self.lmin) / dd
cmax = mmin + (md * self.lmax) / dd
self.axes.imshow(self.data["sig"], vmin=cmin, vmax=cmax)
self.lup[0].set_data([0, self.ds[0]], [yup, yup])
self.ldown[0].set_data([0, self.ds[0]], [ydown, ydown])
self.lref1up[0].set_data([0, self.ds[0]], [yrefup, yrefup])
self.lref1down[0].set_data([0, self.ds[0]], [yrefdown, yrefdown])
self.lref2up.set_data([0, self.ds[0]], [yref2up, yref2up])
self.lref2down.set_data([0, self.ds[0]], [yref2down, yref2down])
self.plt.clear()
self.ref.clear()
self.raw.clear()
self.ref.clear()
# Signals
data = [np.mean(self.data["sig"][yup:ydown], 0)]
self.raw.plot(self.wavelength, data[0], color="black")
if self.ui.multisig.checkState() == QtCore.Qt.Checked:
if len(self.lup) > n:
for i in range(n + 1, len(self.lup)):
del self.lup[i]
del self.ldown[i]
self.lup = self.lup[:n]
self.ldown = self.ldown[:n]
if n > 1:
if len(self.lup) > n:
for i in range(n, len(self.lup)):
del self.lup[i]
del self.ldown[i]
if len(self.lup) < n:
for i in range(len(self.lup), n):
self.lup.append(
mpl.lines.Line2D([0, self.ds[0]], [0, 0],
color="red"))
self.ldown.append(
mpl.lines.Line2D([0, self.ds[0]], [0, 0],
color="red"))
self.axes.add_line(self.lup[i])
self.axes.add_line(self.ldown[i])
for i in range(1, n):
data.append(
np.mean(
self.data["sig"][int(yup - dh * i):int(ydown -
dh * i)],
0))
self.raw.plot(self.wavelength, data[i])
self.lup[i].set_data(
[0, self.ds[0]],
[int(yup - dh * i),
int(yup - dh * i)])
self.ldown[i].set_data(
[0, self.ds[0]],
[int(ydown - dh * i),
int(ydown - dh * i)])
# Sig StdDev
DS2 = 0
drs = np.sqrt(np.var(self.data["sig"][yup:ydown], 0))
if self.ui.rawsigStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.wavelength, data[0] - drs,
data[0] + drs)
self.raw.fill(vx, vy, color="red")
DS2 += (drs)**2
# Reference Signal
if yrefup != yrefdown:
ref = [np.mean(self.data["sig"][yrefup:yrefdown], 0)]
self.ref.plot(self.wavelength, ref[0], color="black")
# Std Dev
delta = np.sqrt(np.var(self.data["sig"][yrefup:yrefdown], 0))
if self.ui.refStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.wavelength, ref[0] - delta,
ref[0] + delta)
self.ref.fill(vx, vy, color="blue")
DS2 += (delta)**2
DS = np.sqrt(DS2)
data[0] = data[0] - ref[0]
self.plt.plot(self.wavelength, data[0], color="black")
if self.ui.multisig.checkState() == QtCore.Qt.Checked:
if n > 1:
if self.ui.MultiRef.checkState() == QtCore.Qt.Checked:
if len(self.lref1up) > n:
for i in range(n, len(self.lref1up)):
del self.lref1up[i]
del self.lref1down[i]
if len(self.lref1up) < n:
for i in range(len(self.lref1up), n):
self.lref1up.append(
mpl.lines.Line2D([0, self.ds[0]], [0, 0],
color="green"))
self.lref1down.append(
mpl.lines.Line2D([0, self.ds[0]], [0, 0],
color="green"))
self.axes.add_line(self.lref1up[i])
self.axes.add_line(self.lref1down[i])
if self.debug: print "++", i
for i in range(1, n):
ref.append(
np.mean(
self.data["sig"][int(yrefup -
dh * i):int(yrefdown -
dh * i)],
0))
data[i] = data[i] - ref[i]
self.lref1up[i].set_data(
[0, self.ds[0]],
[int(yrefup - dh * i),
int(yrefup - dh * i)])
self.lref1down[i].set_data([0, self.ds[0]], [
int(yrefdown - dh * i),
int(yrefdown - dh * i)
])
else:
if len(self.lref1up) > 1:
for i in range(len(self.lref1up) - 1, 0, -1):
if self.debug: print "-", i
self.lref1up[i].set_data([0, self.ds[0]],
[0, 0])
self.lref1down[i].set_data([0, self.ds[0]],
[0, 0])
del self.lref1up[i]
del self.lref1down[i]
for i in range(1, n):
data[i] = data[i] - ref[0]
for i in range(1, n):
self.plt.plot(self.wavelength, data[i])
if self.ui.sigStdDev.checkState() == QtCore.Qt.Checked:
vx, vy = mlab.poly_between(self.wavelength, data[0] - DS,
data[0] + DS)
self.plt.fill(vx, vy)
self.canvas.draw()
z = spstats.norm.ppf(0.95)
# our position is 1000 shares of AAPL at the price
# on 2014-22-31
position = 1000 * aapl_closes.ix['2014-12-31'].AAPL
# what is our VaR
VaR = position * (z * returns.AAPL.std())
###### Misc ######
# draw a 99% one-tail confidence interval
x = np.linspace(-4, 4, 101)
y = np.exp(-x**2 / 2) / np.sqrt(2 * np.pi)
x2 = np.linspace(-4, -2.33, 101)
y2 = np.exp(-x2**2 / 2) / np.sqrt(2 * np.pi)
f = plt.figure(figsize=(12, 8))
plt.plot(x, y * 100, linewidth=2)
xf, yf = mlab.poly_between(x2, 0 * x2, y2 * 100)
plt.fill(xf, yf, facecolor='g', alpha=0.5)
plt.gca().set_xlabel('z-score')
plt.gca().set_ylabel('Frequency %')
plt.title("VaR based on the standard normal distribution")
bbox_props = dict(boxstyle="rarrow,pad=0.3", fc="w", ec="b", lw=2)
t = f.text(0.25,
0.35,
"99% VaR confidence level",
ha="center",
va="center",
rotation=270,
size=15,
bbox=bbox_props)
plt.savefig('5104OS_09_21.png', bbox_inches='tight', dpi=300)
from __future__ import division
import numpy as np
import matplotlib as mpl
import matplotlib.mlab as mlab
import pylab as pl
yoffs = np.arange(10)
nplots = len(yoffs)
x = np.arange(0, 1, 0.1)
npoints = len(x)
y = np.zeros((nplots, len(x)))
stdy = np.zeros((nplots, len(x)))
verts = np.zeros((nplots, 2*npoints, 2)) # each timepoint has a +ve and a -ve value
for ploti, yoff in enumerate(yoffs):
y[ploti] = np.random.random(len(x)) / 2 + 0.25 + yoff
stdy[ploti] = 0.2 + np.random.random(len(x)) * 0.2
vert = mlab.poly_between(x, y[ploti]-stdy[ploti], y[ploti]+stdy[ploti])
vert = np.asarray(vert).T
verts[ploti] = vert
# can also use axes.fill() instead of a poly collection, or directly use axes.fill_between()
pcol = mpl.collections.PolyCollection(verts, facecolors='r', edgecolors='none', alpha=0.2)
a = pl.gca()
#pcol = a.fill_between(x, y+stdy, y-stdy, facecolors='r', edgecolors='none', alpha=0.2)
a.add_collection(pcol)
for ploti in range(nplots):
a.plot(x, y[ploti], 'r-')
a.set_xlim((0, 1))
def __init__(self, ensbl, month, output_path):
super(GridRegionEnsembleGraph, self).__init__(self.__class__.__name__)
# Save input parameter
self._ensbl = ensbl
self._month = month
self._output_path = output_path
self.output_filename = os.path.join(
output_path, "%s_%02g.png" % (ensbl.region_id, month))
plt.ioff()
label = "%s - %s" % (REGION_ID_NAME[ensbl.region_id],
MONTH_NAME[month])
# Make the plot
fig = plt.figure(figsize=(8, 5))
ax = plt.gca()
ax.set_position([0.1, 0.1, 0.65, 0.8])
dataset_color = []
for i, dataset_id in enumerate(ensbl.dataset_ids):
color = DATASET_COLOR[dataset_id]
dataset_color.append(color)
marker = DATASET_MARKER.get(dataset_id, "o")
dataset_name = DATASET_ID_NAME[dataset_id]
mean = ensbl.get_dataset_mean(dataset_id)
ax.plot(ensbl.period_dts,
mean,
"-" + marker,
label=dataset_name,
color=color,
**self.dataset_props)
# Plot ensemble mean
ax.plot(ensbl.period_dts,
ensbl.ensemble_mean,
label="Ensemble Mean",
**self.ensemble_mean_props)
# Fill in between ensemble min/max
emin, emax = ensbl.get_ensemble_minmax()
is_valid = np.where(np.isfinite(ensbl.ensemble_mean))
# Plot standard deviation envelope in the background
is_valid = np.where(np.isfinite(emin))
xs, ys = poly_between(ensbl.period_dts[is_valid], emin[is_valid],
emax[is_valid])
ax.fill(xs, ys, **self.sdev_fill_props)
# Plot legend outside the axes and color text
leg = plt.legend(loc="lower left",
bbox_to_anchor=(1.0, 0.0),
fontsize=12)
for i, text in enumerate(leg.get_texts()):
if i < len(dataset_color) - 1:
plt.setp(text, color=dataset_color[i])
# Plot Properties
plt.title(label, fontsize=16)
plt.xticks(ensbl.period_dts)
plt.ylabel("Mean Sea Ice Thickness (m)")
ax.set_ylim(0, 5)
# Plot style
set_axes_style(fig, ax)
# save plot
self._save_to_file()
plt.close(fig)