def plot_figs():
pylab.subplot(221, aspect="equal")
X, Y = pylab.meshgrid(list(range(ins.num_atoms)), list(range(ins.num_atoms)))
pylab.pcolor(X, Y, ins.norm_cross_correlation)
pylab.colorbar()
pylab.clim(-0.15, 0.15)
pylab.title("Cross Correlations")
pylab.subplot(222)
pylab.plot(pdb_Bfactors, "bo-", label="ex.")
pylab.plot(ins.Bfactors, "ro-", label="calc.")
pylab.legend()
pylab.xlabel("Residue")
# pylab.ylabel("a.u.")
pylab.title("B factors")
pylab.grid()
pylab.subplot(223, aspect="equal")
X, Y = pylab.meshgrid(list(range(ins.num_atoms)), list(range(ins.num_atoms)))
pylab.pcolor(X, Y, ins.adj_mat)
pylab.colorbar()
pylab.title("Adjacency Mat.")
pylab.subplot(224)
pylab.plot(ins.graph_eigvec[:, 1], "go-")
pylab.xlabel("Residue")
pylab.grid()
pylab.show()
def main():
zf = np.vectorize(z_function)
find_extremum(1)
x, y = np.arange(0.1, 7.0, 0.1), np.arange(0.1, 7.0, 0.1)
X, Y = pl.meshgrid(x, y)
Z = zf(X, Y, 1)
im = pl.imshow(Z, cmap=pl.cm.RdBu)
cset = pl.contour(Z, np.arange(21, 100, 10), linewidths=2, cmap=pl.cm.Set2)
pl.clabel(cset, inline=True, fmt='%1.1f', fontsize=15)
pl.colorbar(im)
pl.title('z = x*y + 50/x + 20/y')
pl.show()
print()
find_extremum(2)
x, y = np.arange(0.1, 5.0, 0.1), np.arange(0.1, 5.0, 0.1)
X, Y = pl.meshgrid(x, y)
Z = zf(X, Y, 2)
im = pl.imshow(Z, cmap=pl.cm.RdBu)
cset = pl.contour(Z, np.arange(-10, 0, 1), linewidths=3, cmap=pl.cm.Set2)
pl.clabel(cset, inline=True, fmt='%1.1f', fontsize=10)
pl.colorbar(im)
pl.title('z = x^2 + y^2 - 2*log(x) - 18*log(y)')
pl.show()
print()
find_extremum(3)
def main():
# Create the grid
x = arange(-100, 101)
y = arange(-100, 101)
# Create the meshgrid
Y, X = meshgrid(x, y)
A = 1
B = 2
V = 6*pi / 201
W = 4*pi / 201
F = A*sin(V*X) + B*cos(W*Y)
Fx = V*A*cos(V*X)
Fy = W*B*-sin(W*Y)
# Show the images
show_image(F)
show_image(Fx)
show_image(Fy)
# Create the grid for the quivers
xs = arange(-100, 101, 10)
ys = arange(-100, 101, 10)
# Here we determine the direction of the quivers
Ys, Xs = meshgrid(ys, xs)
FFx = V*A*cos(V*Xs)
FFy = W*B*-sin(W*Ys)
# Draw the quivers and the image
clf()
imshow(F, cmap=cm.gray, extent=(-100, 100, -100, 100))
quiver(ys, xs, -FFy, FFx, color='red')
show()
def computeKOPgrid():
#compute KOP grid
KOPgrid = pb.zeros((len(noise2),len(noise3),len(x0s)))
i,j,k=0,0,0
for i in range(len(noise2)):
for j in range(len(noise3)):
for k in range(len(x0s)):
radical="_%i_HMR_%i_ML_CpES1_100_CpES2_100_x0_%i_noise3_%i_noise2_%i_noise1_%i_15s" %(nbn1, nbn2, int(x0s[k]*10), int(noise3[j]), int(noise2[i]*100), int(noise2[i]*200),)
KOP1 = np.load('traces_may22/KOP1'+radical+".npy")
KOP2 = np.load('traces_may22/KOP2'+radical+".npy")
KOPgrid[i,j,k] = KOP1[0,:].mean() + KOP2[0,:].mean()
kopmin = KOPgrid.min()
kopmax = KOPgrid.max()
print KOPgrid
#plot
fig = pb.figure()
ax = fig.add_subplot(311, projection='3d')
#k=0
X,Y = pb.meshgrid(noise2,noise3)
for k in range(len(x0s)):
#img = ax.contourf(KOPgrid[:,:,k], vmin=kopmin, vmax=kopmax), offset=x0s[k])
img = ax.contourf(X, Y, KOPgrid[:,:,k].T, zdir='z', levels=pb.linspace(kopmin, kopmax, 50), vmin=kopmin, vmax=kopmax, offset=x0s[k])
#cbar = pb.colorbar(img)
#fig.savefig("param3Dspace_CpES1_%i_CpES2_%i_x0_%i.png" %(int(CpES1s[i]*100), int(CpES2s[j]*100), int(x0s[k]*10)))
ax.set_xlabel("noise2")
ax.set_xticks(pb.linspace(min(noise2),max(noise2),5))
ax.set_ylabel("noise3")
ax.set_yticks(pb.linspace(min(noise3),max(noise3),5))
ax.set_zlabel("x0")
ax.set_zticks(pb.linspace(min(x0s),max(x0s),5))
ax.set_zlim(min(x0s), max(x0s))
ax2=fig.add_subplot(312)
index_noise3=0;
X2,Y2=pb.meshgrid(x0s, noise2)
img2 = ax2.contourf(X2, Y2,KOPgrid[:,index_noise3,:],levels=pb.linspace(kopmin, kopmax, 50), vmin=kopmin, vmax=kopmax)
# img = ax2.imshow(KOPgrid[index_noise2,:,:].T, interpolation="nearest", origin="lower")
ax2.set_xlabel("|x0|")
ax2.set_ylabel("noise_1_2")
cbar=pb.colorbar(img2)
noiseGrid=pb.zeros((len(noise2),len(x0s)))
for n in range(len(noise2)):
noiseGrid[n,:] = KOPgrid[n,0,:]
ngmin=noiseGrid.min()
ngmax=noiseGrid.max()
ax3=fig.add_subplot(313)
X3,Y3=pb.meshgrid(x0s, range(len(noise2)))
img3 = ax3.contourf(X3, Y3, noiseGrid, levels=pb.linspace(ngmin, ngmax, 50), vmin=ngmin, vmax=ngmax)
#img2 = ax3.imshow(noiseGrid.T, interpolation="nearest", origin="lower")
cbar2=pb.colorbar(img3)
ax3.set_xlabel("|x0|")
ax3.set_ylabel("noise_1_2_3")
print noiseGrid.T
pb.show()
def boundary_layer(self):
self.dpi3 = 102
self.fig2 = Figure((3.0, 3.0), dpi=self.dpi3)
self.axes3 = self.fig2.add_subplot(111)
self.axes3.set_axis_bgcolor('white')
self.x = arange(0,10,.5)
self.y = arange(0,10,.5)
self.X, self.Y = pylab.meshgrid(self.x,self.y)
self.Z, self.Zt = pylab.meshgrid(self.x,self.y)
if not self.update:
self.axes3.contourf(self.X,self.Y,self.Z)
def __init__( self, t, x, y, A=[1., 0.85], a=[0.25, 0.85] ):
'''
Initializing generalized thalamo-cortical loop. Full
functionality is only obtained in the subclasses, like DOG,
full_eDOG, etc.
Parameters
----------
t : array
1D Time vector
x : np.array
1D vector for x-axis sampling points
y : np.array
1D vector for y-axis sampling points
Keyword arguments
-----------------
A : sequence (default A = [1., 0.85])
Amplitudes for DOG receptive field for center and surround,
respectively
a : sequence (default a = [0.25, 0.85])
Width parameter for DOG receptive field for center and surround,
respectively
Usage
-----
Look at subclasses for example usage
'''
# Set parameteres as attributes
self.name = 'pyDOG Toolbox'
self.t = t
self.A = A
self.a = a
self.x = x
self.y = y
# Find sampling rates and sampling freqs and
self.nu_xs = 1./(x[1]-x[0])
self.nu_ys = 1./(y[1]-y[0])
self.fs = 1./(t[1]-t[0])
self.f = fft.fftfreq(pl.asarray(t).size, t[1]-t[0])
# fftshift spatial frequency,
self.nu_x = fft.fftfreq(pl.asarray(x).size, x[1]-x[0])
self.nu_y = fft.fftfreq(pl.asarray(y).size, y[1]-y[0])
# Make meshgrids, may come in handy
self._xx, self._yy = pl.meshgrid(self.x, self.y)
self._nu_xx, self._nu_yy = pl.meshgrid(self.nu_x, self.nu_y)
# r is needed for all circular rfs
self.r = pl.sqrt(self._xx**2 + self._yy**2)
self.k = 2 * pl.pi * pl.sqrt(self._nu_xx**2 + self._nu_yy**2)
def resize_ncollev(lat, lon, lev):
"""
For 3d variables (ie including a height coordinate) with a ncol dim instead of separate
lat/lon dims (i.e. for native rather than regridded data), this function makes lat and lon
be copied over the vertical dimension so they have the same size as var.
"""
if np.isscalar(lev) or len(lev.shape) != 2:
raise Exception('resize_ncollev only works with 2 dim lev array')
junk, LAT = pl.meshgrid(lev[:, 0], lat)
junk, LON = pl.meshgrid(lev[:, 0], lon)
return LAT, LON
def init_contour(self):
self.data2 = []
self.x = arange(0,10,.5)
self.y = arange(0,10,.5)
self.X, self.Y = pylab.meshgrid(self.x,self.y)
self.Z, self.Zt = pylab.meshgrid(self.x,self.y)
self.dpi2 = 101
self.fig1 = Figure((3.0, 3.0), dpi=self.dpi2)
self.axes2 = self.fig1.add_subplot(111)
self.axes2.set_axis_bgcolor('white')
if not self.update:
initplot = self.plot_data2 = self.axes2.contourf(self.X,self.Y,self.Z)
self.cb = self.fig1.colorbar(initplot)
def vecPlot(self, row, col, mWx, mWy, frmSize, winSize):
pl.clf()
pl.ion()
#pWy = mWy[row][col]
#まずはx方向のWx
pWx = mWx[row,col:(frmSize-winSize+1)+row,0,:]
#print "pWx sum:",np.sum(pWx[0,:])
print np.mean(pWx*pWx, axis=0)
pWx = np.sqrt(pWx * pWx)
r,c = pWx.shape
x = pl.arange(c+1)
y = pl.arange(r+1)
X, Y = pl.meshgrid(x, y)
pl.subplot2grid((2,2),(0,0))
pl.pcolor(X, Y, pWx)
pl.xlim(0,c)
pl.ylim(0,r)
pl.colorbar()
pl.title("user_1 (t:"+str(row)+")")
pl.gray()
#いまだけ
pWy = mWy[row,col:(frmSize-winSize+1)+row,0,:]
#print "pWy sum:",np.sum(pWy[0,:],axis=1)
#print np.sum(pWy*pWy,axis=1)
#print np.mean(pWy*pWy, axis=0)
pWy = np.sqrt(pWy * pWy)
r,c = pWx.shape
x = pl.arange(c+1)
y = pl.arange(r+1)
X, Y = pl.meshgrid(x, y)
pl.subplot2grid((2,2),(0,1))
pl.pcolor(X, Y, pWy)
pl.xlim(0,c)
pl.ylim(0,r)
pl.colorbar()
pl.title("user_2 (t:"+str(col)+")")
pl.gray()
pl.subplot2grid((2,2),(1,0),colspan=2)
pl.plot(np.mean(pWx*pWx, axis=0),color="r")
pl.plot(np.mean(pWy*pWy, axis=0),color="b")
pl.draw()
print "pWx shape:",pWx.shape
def updateColorTable(self, cItem):
print "now viz!"+str(cItem.row())+","+str(cItem.column())
row = cItem.row()
col = cItem.column()
pl.clf()
#pl.ion()
x = pl.arange(self.dataDimen+1)
y = pl.arange(self.dataDimen+1)
X, Y = pl.meshgrid(x, y)
pl.subplot(1,2,1)
pl.pcolor(X, Y, self.mWx[row*self.dataMaxRange+col])
pl.gca().set_aspect('equal')
pl.colorbar()
pl.gray()
pl.title("user 1")
pl.subplot(1,2,2)
pl.pcolor(X, Y, self.mWy[row*self.dataMaxRange+col])
pl.gca().set_aspect('equal')
pl.colorbar()
pl.gray()
pl.title("user 2")
#pl.tight_layout()
pl.draw()
#pl.show()
pl.show(block=False)
def plot_layered_images(fig):
def func3(x,y):
return (1- x/2 + x**5 + y**3)*exp(-x**2-y**2)
# make these smaller to increase the resolution
dx, dy = 0.05, 0.05
x = arange(-3.0, 3.0, dx)
y = arange(-3.0, 3.0, dy)
X,Y = meshgrid(x, y)
# when layering multiple images, the images need to have the same
# extent. This does not mean they need to have the same shape, but
# they both need to render to the same coordinate system determined by
# xmin, xmax, ymin, ymax
xmin, xmax, ymin, ymax = min(x), max(x), min(y), max(y)
extent = xmin, xmax, ymin, ymax
Z1 = array(([0,1]*4 + [1,0]*4)*4); Z1.shape = 8,8 # chessboard
Z2 = func3(X, Y)
axes = fig.gca()
axes.imshow(Z1, cmap=cm.gray, interpolation='nearest',
extent=extent)
axes.hold(True)
axes.imshow(Z2, cmap=cm.jet, alpha=.9, interpolation='bilinear',
extent=extent)
def projectOnFinerGrid_f29(self, Xc, Yc, q):
dx = Xc[1] - Xc[0]
dy = Yc[1] - Yc[0]
nx = Xc.shape[0]
ny = Yc.shape[0]
# mesh coordinates
Xn = pylab.linspace(Xc[0] - 0.5 * dx, Xc[-1] + 0.5 * dx,
3 * nx + 1) # one more
Yn = pylab.linspace(Yc[0] - 0.5 * dy, Yc[-1] + 0.5 * dy,
3 * ny + 1) # one more
XXn, YYn = pylab.meshgrid(Xn, Yn)
# data
qn = pylab.zeros((3 * Xc.shape[0], 3 * Yc.shape[0]), float)
v1 = q[:, :, 0]
v2 = q[:, :, 1]
v3 = q[:, :, 2]
v4 = q[:, :, 3]
vList = [v1, v2, v3, v4]
# node 1
c1 = [25.0 / 36.0, 5.0 / 36.0, 1.0 / 36.0, 5.0 / 36.0]
qn[0:3 * nx:3, 0:3 * ny:3] = self.evalSum(c1, vList)
# node 2
c2 = [5.0 / 12.0, 5.0 / 12.0, 1.0 / 12.0, 1.0 / 12.0]
qn[1:3 * nx:3, 0:3 * ny:3] = self.evalSum(c2, vList)
# node 3
c3 = [5.0 / 36.0, 25.0 / 36.0, 5.0 / 36.0, 1.0 / 36.0]
qn[2:3 * nx:3, 0:3 * ny:3] = self.evalSum(c3, vList)
# node 4
c4 = [5.0 / 12.0, 1.0 / 12.0, 1.0 / 12.0, 5.0 / 12.0]
qn[0:3 * nx:3, 1:3 * ny:3] = self.evalSum(c4, vList)
# node 5
c5 = [1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0, 1.0 / 4.0]
qn[1:3 * nx:3, 1:3 * ny:3] = self.evalSum(c5, vList)
# node 6
c6 = [1.0 / 12.0, 5.0 / 12.0, 5.0 / 12.0, 1.0 / 12.0]
qn[2:3 * nx:3, 1:3 * ny:3] = self.evalSum(c6, vList)
# node 7
c7 = [5.0 / 36.0, 1.0 / 36.0, 5.0 / 36.0, 25.0 / 36.0]
qn[0:3 * nx:3, 2:3 * ny:3] = self.evalSum(c7, vList)
# node 8
c8 = [1.0 / 12.0, 1.0 / 12.0, 5.0 / 12.0, 5.0 / 12.0]
qn[1:3 * nx:3, 2:3 * ny:3] = self.evalSum(c8, vList)
# node 9
c9 = [1.0 / 36.0, 5.0 / 36.0, 25.0 / 36.0, 5.0 / 36.0]
qn[2:3 * nx:3, 2:3 * ny:3] = self.evalSum(c9, vList)
return XXn, YYn, qn
def plot_function_countur3D(min, max, action, episode):
x = np.arange(min, max, 0.025)
y = np.arange(min, max, 0.025)
# meshgrid create a matrix von min to max with 0.1 as distance
# the output is 2 matrix where one is the transport of the other one
X, Y = pyl.meshgrid(x, y)
#Z=z_function(X,np.transpose(X))
Z = action
print Y
#==========
# 3D
#==========
fig = plt.figure()
#plt.ion()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(Y,
X,
Z,
rstride=1,
cstride=1,
cmap=plt.cm.RdBu,
linewidth=0,
antialiased=False)
ax.set_xlim([min, max])
ax.set_ylim([min, max])
ax.zaxis.set_major_locator(plt.LinearLocator(3))
ax.zaxis.set_major_formatter(plt.FormatStrFormatter('%.02f'))
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show(False)
plt.draw()
name_file = 'exp/episode3D' + str(episode) + '.png'
print name_file.__str__()
plt.savefig(name_file.__str__())
plt.close()
def plot_wt_layout(wt_layout, borders=None, depth=None):
fig = plt.figure(figsize=(6, 6), dpi=2000)
fs = 14
ax = plt.subplot(111)
if depth is not None:
N = 100
X, Y = plt.meshgrid(
plt.linspace(depth[:, 0].min(), depth[:, 0].max(), N),
plt.linspace(depth[:, 1].min(), depth[:, 1].max(), N))
Z = plt.griddata(depth[:, 0],
depth[:, 1],
depth[:, 2],
X,
Y,
interp='linear')
plt.contourf(X, Y, Z, label='depth [m]')
plt.colorbar().set_label('water depth [m]')
#ax.plot(wt_layout.wt_positions[:,0], wt_layout.wt_positions[:,1], 'or', label='baseline position')
ax.scatter(wt_layout.wt_positions[:, 0],
wt_layout.wt_positions[:, 1],
wt_layout._wt_list('rotor_diameter'),
label='baseline position')
if borders is not None:
ax.plot(borders[:, 0], borders[:, 1], 'r--', label='border')
ax.set_xlabel('x [m]')
ax.set_ylabel('y [m]')
ax.axis('equal')
ax.legend(loc='lower left')
def exactSol(a, b, X, Y):
c1, d0 = 0, 0
c0 = a/12.0 - 1.0/2.0
d1 = b/12.0 - 1.0/2.0
XX, YY = pylab.meshgrid(X, Y)
return (XX**2/2 - a*XX**4/12 + c0*XX + c1)*(YY**2/2 - b*YY**4/12 + d0*YY + d1)
def plot_variance(plot, head, num_classes):
# make these smaller to increase the resolution
x = np.arange(0.0, 1.05, 0.05)
x_1, x_2 = np.array(meshgrid(x, x))
grid = np.stack((x_1, x_2))
grid = grid.T.reshape(-1, 2)
num_samples = 50
outs = []
for i in range(num_samples):
outs.append(head.predict(grid))
outs = np.array(outs)
stds = np.mean(np.std(outs, axis=0), axis=-1)
# vgp = head.layers[0]
# outs = tf.nn.softmax(vgp(grid).sample(100))
# stds = np.mean(np.std(outs, axis=0), axis=-1)
std_plot = stds.reshape(x.shape[0], x.shape[0])
plot.contourf(x, x, std_plot, cmap='Greys', vmin=0.0, vmax=0.3,
alpha=0.7) # norm=Normalize(),
thresholds = [0.9, 1.1]
colours = [
'tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple',
'tab:brown', 'tab:pink', 'tab:gray', 'tab:olive', 'tab:cyan'
]
for class_id in range(num_classes):
class_pred = np.mean(outs, axis=0)[:, class_id]
class_pred = class_pred.reshape(x.shape[0], x.shape[0])
plot.contourf(x,
x,
class_pred,
colors=[colours[class_id]],
levels=thresholds,
alpha=0.2)
def _plot_bar3d(self):
logging.debug('')
if self.dimension > 0:
return
array = self._data_to_array()
# width, depth, and height of the bars (array == height values == dz)
dx = list(numpy.array([1.0/len(array[0]) for x in range(0, array.shape[1])]))
dy = list(numpy.array([1.0/len(array) for x in range(0, array.shape[0])]))
dx *= len(array)
dy *= len(array[0])
dz = array.flatten()+0.00000001 # dirty hack to cirumvent ValueError
# x,y,z position of each bar
x = pylab.linspace(0.0, 1.0, len(array[0]), endpoint=False)
y = pylab.linspace(0.0, 1.0, len(array), endpoint=False)
xpos, ypos = pylab.meshgrid(x, y)
xpos = xpos.flatten()
ypos = ypos.flatten()
zpos = numpy.zeros(array.shape).flatten()
fig = MyFig(self.options, xlabel='Probability p', ylabel='Fraction of Nodes', zlabel='Fraction of Executions', ThreeD=True)
fig.ax.set_zlim3d(0.0, 1.01)
fig.ax.set_xlim3d(0.0, 1.01)
fig.ax.set_ylim3d(0.0, 1.01)
fig.ax.set_autoscale_on(False)
assert(len(dx) == len(dy) == len(array.flatten()) == len(xpos) == len(ypos) == len(zpos))
fig.ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color=['#CCBBDD'])
try:
self.figures['bar3d'] = fig.save('bar3d' + str(self.data_filter))
except ValueError, err:
logging.warning('%s', err)
def fresnelConvolutionTransform(self, d):
# make intensity distribution
i2 = Intensity2D(self.nx, self.startx, self.endx, self.ny, self.starty,
self.endy, self.wl)
# FT on inital distribution
u1ft = pl.fft2(self.i)
# 2d convolution kernel
k = 2 * pl.pi / i2.wl
# make spatial frequency matrix
maxsfx = 2 * pl.pi / self.dx
maxsfy = 2 * pl.pi / self.dy
dsfx = 2 * maxsfx / (self.nx)
dsfy = 2 * maxsfy / (self.ny)
self.sfx = pl.arange(-maxsfx / 2, maxsfx / 2 + 1e-15, dsfx / 2)
self.sfy = pl.arange(-maxsfy / 2, maxsfy / 2 + 1e-15, dsfy / 2)
[self.sfxgrid,
self.sfygrid] = pl.fftshift(pl.meshgrid(self.sfx, self.sfy))
# make convolution kernel
kern = pl.exp(1j * d * (self.sfxgrid**2 + self.sfygrid**2) / (2 * k))
# apply convolution kernel and invert
i2.i = pl.ifft2(kern * u1ft)
return i2
def fresnelConvolutionTransform(self,d) :
# make intensity distribution
i2 = Intensity2D(self.nx,self.startx,self.endx,
self.ny,self.starty,self.endy,
self.wl)
# FT on inital distribution
u1ft = pl.fft2(self.i)
# 2d convolution kernel
k = 2*pl.pi/i2.wl
# make spatial frequency matrix
maxsfx = 2*pl.pi/self.dx
maxsfy = 2*pl.pi/self.dy
dsfx = 2*maxsfx/(self.nx)
dsfy = 2*maxsfy/(self.ny)
self.sfx = pl.arange(-maxsfx/2,maxsfx/2+1e-15,dsfx/2)
self.sfy = pl.arange(-maxsfy/2,maxsfy/2+1e-15,dsfy/2)
[self.sfxgrid, self.sfygrid] = pl.fftshift(pl.meshgrid(self.sfx,self.sfy))
# make convolution kernel
kern = pl.exp(1j*d*(self.sfxgrid**2+self.sfygrid**2)/(2*k))
# apply convolution kernel and invert
i2.i = pl.ifft2(kern*u1ft)
return i2
def main():
nx = floor(roh[0]/(box[1]/N))
ny = floor(roh[1]/(box[1]/N))
# print nx, ny
field=zeros([N,N])
#field[nx][ny] = 1./(dx*dx)
field[nx+9][ny+9] = 1./(dx*dx)
field[nx-9][ny-9] = 1./(dx*dx)
field[nx-9][ny+9] = 1./(dx*dx)
field[nx+9][ny-9] = 1./(dx*dx)
#plot the initial field;
initFig=p.figure()
gx,gy=p.meshgrid(gridpnts,gridpnts)
ax = p3.Axes3D(initFig)
ax.scatter3D(ravel(gy),ravel(gx),ravel(field))
ax.set_xlabel('$x$')
ax.set_ylabel('$y$')
ax.set_zlabel('$\psi(x,y)$')
plt.savefig("ROHxySP3.png")
jacobi(field)
gauss_seidel(field)
def gaussian2d(data, nxw, nyw=None, sxw=1 / 3., syw=1 / 3., rmax=3., **kwargs):
"""Gaussian 2D filter
- **data**: Data array
- **nxw**: Size of gaussian weights array along X (and Y if nyw not given)
- *nyw*: Size of gaussian weights array along Y [default: nxw]
- *sxw*: Standard deviation of the gaussian distribution along X.
If <1, its size is relative to nxw. If > 1, it is directly expressed in grid
steps.
- *syw*: Same as sxw for Y direction.
- *rmax*: Distance relative to sqrt(sxw**2+syw**2) after with weights are
nullified.
- Other keywords are passed to :func:`generic2d`
"""
if nyw is None: nyw = nxw
assert nxw % 2 == 1 and nyw % 2 == 1, 'nxw and nyw must be odd numbers'
assert sxw > 0 and syw > 0, 'sxw and syw must be positive'
xx, yy = meshgrid(N.arange(nxw) - nxw / 2, N.arange(nyw) - nxw / 2)
if sxw < 1:
sxw *= nxw / 2
if syw < 1:
syw *= nyw / 2
weights = N.exp(-(xx**2 / sxw**2 + yy**2 / syw**2))
weights[weights < N.exp(-rmax**2)] = 0.
return generic2d(data, weights, **kwargs)
def init(self, img, box):
img_now = ops.read_image(img)
self.target_sz = np.array([box[3], box[2]])
self.pos = np.array([box[1], box[0]]) + self.target_sz / 2
# print(self.pos)
# ground_truth =
# window size, taking padding into account
self.sz = pylab.floor(self.target_sz * (1 + self.padding))
# desired output (gaussian shaped), bandwidth proportional to target size
self.output_sigma = pylab.sqrt(pylab.prod(
self.target_sz)) * self.output_sigma_factor
grid_y = pylab.arange(self.sz[0]) - pylab.floor(self.sz[0] / 2)
grid_x = pylab.arange(self.sz[1]) - pylab.floor(self.sz[1] / 2)
#[rs, cs] = ndgrid(grid_x, grid_y)
rs, cs = pylab.meshgrid(grid_x, grid_y)
y = pylab.exp(-0.5 / self.output_sigma**2 * (rs**2 + cs**2))
self.yf = pylab.fft2(y)
# print(self.yf)
#print("yf.shape ==", yf.shape)
#print("y.shape ==", y.shape)
# store pre-computed cosine window
self.cos_window = pylab.outer(pylab.hanning(self.sz[0]),
pylab.hanning(self.sz[1]))
if img_now.ndim == 3:
img_now = ops.rgb2gray(img_now)
x = ops.get_subwindow(img_now, self.pos, self.sz, self.cos_window)
k = ops.dense_gauss_kernel(self.sigma, x)
self.alphaf = pylab.divide(
self.yf, (pylab.fft2(k) + self.lambda_value)) # Eq. 7
self.z = x
def demo1():
theta = RiemannTheta_Function()
Omega = np.array([[1.j, .5], [.5, 1.j]])
print
print "Calculating 3,600 points of the Riemann Theta Function in C..."
print
print "Omega = [i .5]"
print " [.5 i]"
print
print "z = (x + iy, 0) where (0 < x < 1) and (0 < y < 5)"
SIZE = 60
x = np.linspace(0,1,SIZE)
y = np.linspace(0,5,SIZE)
X,Y = p.meshgrid(x,y)
Z = X + Y*1.0j
Z = Z.flatten()
start = time.clock()
U,V = theta.exp_and_osc_at_point([[z,0] for z in Z], Omega, gpu=False, batch=True)
done = time.clock() - start
print "Time to perform the calculation: " + str(done)
print
Z = (V.reshape(60,60)).imag
print "\Plotting the imaginary part of the function..."
plt.contourf(X,Y,Z,7,antialiased=True)
plt.show()
def demo3():
theta = RiemannTheta_Function()
Omega = np.array([[1.j, .5], [.5, 1.j]])
print
print "Calculating 1,000,000 points of the Riemann Theta Function on GPU..."
print
print "Omega = [i .5]"
print " [.5 i]"
print
print "z = (x + iy, 0) where (0 < x < 1) and (0 < y < 5)"
SIZE = 1000
x = np.linspace(0,1,SIZE)
y = np.linspace(0,5,SIZE)
X,Y = p.meshgrid(x,y)
Z = X + Y*1.0j
Z = Z.flatten()
Z = [[z,0] for z in Z]
print "Starting computation on the GPU"
start = time.clock()
U,V = theta.exp_and_osc_at_point(Z, Omega, batch=True)
done = time.clock() - start
print "Time to perform the calculation: " + str(done)
print
print "Starting computation on the CPU"
start = time.clock()
U,V = theta.exp_and_osc_at_point(Z, Omega, batch=True, gpu=False)
done = time.clock() - start
print "Time to perform the calculation: " + str(done)
print
def dist2(x):
R, GSIGMAS = pylab.meshgrid(r[r < fit_rcutoff], gsigmas)
g = pylab.zeros_like(GSIGMAS)
g = evalg(x, GSIGMAS, R)
gfit = pylab.reshape(g, len(eta) * len(r[r < fit_rcutoff]))
return gfit - pylab.reshape([g[r < fit_rcutoff] for g in ghs],
len(gsigmas) * len(r[r < fit_rcutoff]))
def showSF( N, label = '' ):
fig = P.figure()
ax1 = fig.add_subplot(1, 2, 1, projection='3d')
ax2 = fig.add_subplot(1, 2, 2)
Nx = 21
Ny = 21
nLevels = 12
tix = P.linspace( 0.0, 1.0, Nx )
tiy = P.linspace( 0.0, 1.0, Ny )
(X,Y) = P.meshgrid( tix, tiy )
z = g.RVector( len( X.flat ) )
for i, x in enumerate( X.flat ):
p = g.RVector3( X.flat[ i ], Y.flat[ i ] )
z[ i ] = N(p)
Z = P.ma.masked_where( z == -99., z )
Z = Z.reshape( Ny, Nx )
ax2.contourf( X, Y, Z )
ax2.set_aspect( 'equal' )
surf = ax1.plot_surface( X, Y, Z, rstride = 1, cstride = 1, cmap=P.cm.jet,linewidth=0 )
ax2.set_title( label + N.__str__() )
fig.colorbar( surf )
def plot_risk():
"""
plot a two dimensional slack surface
"""
mua, vra, pra = pgen.get_pdf(plot=False, write=False)
deadline = ptsl.D
a1 = range(1, 17)
a2 = range(1, 17)
shape = (len(a1), len(a2))
X, Y = meshgrid(a1, a2)
Z1 = np.full(shape, -1.0) # Risk Power Surface
Z2 = np.full(shape, -1.0) # Peak Power Surface
for x in a1:
for y in a2:
mu = mua[x - 1] + mua[y - 1]
vr = vra[x - 1] + vra[y - 1]
dist = stats.norm(loc=mu, scale=np.sqrt(vr))
risk = dist.sf(deadline)
Z1[x - 1, y - 1] = risk
Z2[x - 1, y - 1] = np.max([pra[x - 1], pra[y - 1]])
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(X,
Y,
Z1,
rstride=1,
cstride=1,
cmap=cm.Greys,
linewidth=0,
antialiased=False)
ax.set_xlabel("alloc ph1")
ax.set_ylabel("alloc ph2")
ax.set_zlabel("Risk")
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.savefig("risk-surface.pdf", bbox_inches='tight')
plt.close()
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(X,
Y,
Z2,
rstride=1,
cstride=1,
cmap=cm.Greys_r,
linewidth=0,
antialiased=False)
ax.set_xlabel("alloc ph1")
ax.set_ylabel("alloc ph2")
ax.set_zlabel("peak power")
# print(ax.azim)
ax.view_init(azim=-30)
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.savefig("pkp-surface.pdf", bbox_inches='tight')
plt.close()
def graph_func(self):
plt.style.use('seaborn-paper')
x = arange(-3.0, 3.0, 0.1)
y = arange(-3.0, 3.0, 0.1)
X, Y = meshgrid(x, y) # grid of point
Z = self.function(X, Y) # evaluation of the function on the grid
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(X,
Y,
Z,
rstride=1,
cstride=1,
cmap=cm.RdBu,
linewidth=0,
antialiased=False)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
fig.colorbar(surf, shrink=0.5, aspect=5)
title('$z=3x^2 - 3xy + 4y^2 - 2x + y $')
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
def plot_ppi(self,index):
data = self.ppis[index]
fig = pylab.figure()
ax = pylab.axes(axisbg = 'k', polar=True)
chan = self.channels[self.ppis_header[index].Description.channel]
start_range = chan.cell_lenght/2.
stop_range = start_range + chan.cell_lenght*chan.number_of_cells
ranges = pylab.linspace(start_range, stop_range, chan.number_of_cells)
start_ang = self.ppis_header[index].Description.start_az
stop_ang = self.ppis_header[index].Description.finish_az
angles = pylab.linspace(start_ang, stop_ang,
self.ppis_header[index].Description.sectorCount)
rad, theta = pylab.meshgrid(ranges/1000., (90-angles)*pylab.pi/180)
X = theta
Y = rad
ax.pcolormesh(X, Y, data)
pylab.title('pulse: %s, elev: %.2f, unit: %s' % (chan.pulse,
self.ppis_header[index].Description.angle,
self.ppis_header[index].Description.meassurement))
pylab.savefig('../ppis/ppi_%i.png' % index)
def dist2(x):
R, ETA = pylab.meshgrid(r[r<fit_rcutoff], eta)
g = pylab.zeros_like(ETA)
g = evalg(x, ETA, R)
gfit = pylab.reshape(g, len(eta)*len(r[r<fit_rcutoff]))
return gfit - pylab.reshape([g[r<fit_rcutoff] for g in ghs],
len(eta)*len(r[r<fit_rcutoff]))
def dist2(x):
R, ETA = pylab.meshgrid(r[r<fit_rcutoff], eta)
g = pylab.zeros_like(ETA)
g = evalg(x, ETA, R)
gfit = pylab.reshape(g, len(eta)*len(r[r<fit_rcutoff]))
return gfit - pylab.reshape([g[r<fit_rcutoff] for g in ghs],
len(eta)*len(r[r<fit_rcutoff]))
def plot_traj_by_vec_strength(self, ax, mn_drxn, vec_strength, **kwargs):
ax.plot(mn_drxn, vec_strength)
ax.get_yaxis().set_ticks([])
ax.title.set_visible(False)
ax.get_xaxis().set_ticklabels([])
ax.spines['polar'].set_color('none')
cr_mn = mn_drxn
cr_ln = vec_strength
binvls = [72, 20]
rangevls = [[0, 2 * np.pi], [0, 1]]
if cr_mn.size:
heatmap, xedges, yedges = np.histogram2d(cr_mn,
cr_ln,
bins=binvls,
range=rangevls)
xbins = np.linspace(0, 2 * np.pi, binvls[0])
ybins = np.linspace(0, 1, binvls[1])
theta, r = pylab.meshgrid(ybins, xbins)
heatmap_norm = self.norm_heat_map(heatmap)
heat_map_data = self.save_heat_map_data(heatmap_norm, xedges,
yedges, r, theta)
def dist2(x):
R, GSIGMAS = pylab.meshgrid(r[r<fit_rcutoff], gsigmas)
g = pylab.zeros_like(GSIGMAS)
g = evalg(x, GSIGMAS, R)
gfit = pylab.reshape(g, len(eta)*len(r[r<fit_rcutoff]))
return gfit - pylab.reshape([g[r<fit_rcutoff] for g in ghs],
len(gsigmas)*len(r[r<fit_rcutoff]))
def plot_skin_temp(file_name, cntr_lvl=None, save_frames=False):
file, vars = peek(file_name, show_vars=False)
lon = vars['lon'].get_value()
lat = vars['lat'].get_value()
skin_temp = vars['skin_temp']
skin_temp = skin_temp_var.get_value()[0]
valid_date = str(vars['valid_date'].get_value()[0])
valid_time = zfill(str(vars['valid_time'].get_value()[0]), 4)
valid_when = valid_date[6:] + ' ' \
+ cardinal_2_month(int(valid_date[4:6])) + ' ' \
+ valid_date[0:4] \
+ ' ' + valid_time[:2] + ':' \
+ valid_time[2:] + ' UTC'
m = set_default_basemap(lon,lat)
# must plot using 2d lon and lat
LON, LAT = p.meshgrid(lon,lat)
p.figure()
if cntr_lvl is not None:
m.contourf(LON,LAT,skin_temp, cntr_lvl)
else:
m.contourf(LON,LAT,skin_temp)
m.drawcoastlines()
m.drawmeridians(n.array(n.arange(lon.min(), lon.max() + a_small_number, 15.)), labels=[1,0,0,1])
m.drawparallels(n.array(n.arange(lat.min(), lat.max() + a_small_number, 15.)), labels=[1,0,0,1])
p.colorbar(orientation='horizontal', shrink=0.7, fraction=0.02, pad=0.07, aspect=70)
title_string = 'Surface pressure (K) valid at' \
+ '\n' + valid_when + ' ' \
+ ' from LAPS'
p.title(title_string)
if save_frames:
p.savefig('frames/frame_' + zfill(str(frame_number),3) +'_skin_temp_' + str(int(lvl[lvl_idx])) + '.png')
return
def explore_cont(fun,
bounds,
x1resolution,
x2resolution,
V,
ax=None,
points=None):
x1range = bounds[0]
x2range = bounds[1]
if ax is None:
ax = pylab.gca()
xx, yy = pylab.meshgrid(
pylab.linspace(x1range[0], x1range[1], x1resolution),
pylab.linspace(x2range[0], x2range[1], x2resolution))
zz = np.zeros(xx.shape)
for i in range(xx.shape[0]):
for j in range(xx.shape[1]):
zz[i, j] = fun([xx[i, j], yy[i, j]])
# plot the calculated function values
#ax.pcolor(xx, yy, zz)
im = ax.contourf(xx, yy, zz, V)
if points is not None:
ax.plot(points[:, 0], points[:, 1], 'rx')
return im
def gaussian2d(data, nxw, nyw=None, sxw=1/3., syw=1/3., rmax=3., **kwargs):
"""Gaussian 2D filter
- **data**: Data array
- **nxw**: Size of gaussian weights array along X (and Y if nyw not given)
- *nyw*: Size of gaussian weights array along Y [default: nxw]
- *sxw*: Standard deviation of the gaussian distribution along X.
If <1, its size is relative to nxw. If > 1, it is directly expressed in grid
steps.
- *syw*: Same as sxw for Y direction.
- *rmax*: Distance relative to sqrt(sxw**2+syw**2) after with weights are
nullified.
- Other keywords are passed to :func:`generic2d`
"""
if nyw is None: nyw = nxw
assert nxw % 2 == 1 and nyw % 2 == 1, 'nxw and nyw must be odd numbers'
assert sxw > 0 and syw > 0, 'sxw and syw must be positive'
xx,yy = meshgrid(N.arange(nxw)-nxw/2, N.arange(nyw)-nxw/2)
if sxw < 1:
sxw *= nxw/2
if syw < 1:
syw *= nyw/2
weights = N.exp(-(xx**2/sxw**2 + yy**2/syw**2))
weights[weights<N.exp(-rmax**2)] = 0.
return generic2d(data, weights, **kwargs)
def explore_EI(fun,
x1range,
x2range,
x1resolution,
x2resolution,
title,
ax=None,
*args):
if ax is None:
ax = pylab.gca()
X, Y, model, method = args
#print(args)
xx, yy = pylab.meshgrid(
pylab.linspace(x1range[0], x1range[1], x1resolution),
pylab.linspace(x2range[0], x2range[1], x2resolution))
zz = np.zeros(xx.shape)
for i in range(xx.shape[0]):
for j in range(xx.shape[1]):
zz[i, j] = fun(np.array([xx[i, j], yy[i, j]]), X, Y, model, method)
# plot the calculated function values
ax = ax.pcolor(xx, yy, zz)
# if points is not None:
# pylab.plot(points[:, 0], points[:, 1], 'rx')
#pylab.colorbar()
# ax.title(title)
#pylab.show()
return ax
def grid(x, y, z , resX=90, resY=90):
"Convert 3 column data to matplotlib grid"
xi = pl.linspace(min(x), max(x), resX)
yi = pl.linspace(min(y), max(y), resY)
Z = pl.griddata(x, y, z, xi, yi , interp='linear')
X, Y = pl.meshgrid(xi, yi )
return X, Y, Z
def plot_thresholds(rawdata, scan_values, plane='horizontal',
xlabel='turns', ylabel='intensity [particles]', zlabel='normalized emittance',
xlimits=((0.,8192)), ylimits=((0.,7.1e11)), zlimits=((0., 10.))):
# Prepare input data.
# x axis
t = rawdata[0,:,:]
turns = plt.ones(t.shape).T * plt.arange(len(t))
turns = turns.T
# z axis
epsn_abs = {}
epsn_abs['horizontal'] = plt.absolute(rawdata[11,:,:])
epsn_abs['vertical'] = plt.absolute(rawdata[12,:,:])
# Prepare plot environment.
ax11, ax13 = _create_axes(xlabel, ylabel, zlabel, xlimits, ylimits, zlimits)
cmap = plt.cm.get_cmap('jet', 2)
ax11.patch.set_facecolor(cmap(range(2))[-1])
cmap = plt.cm.get_cmap('jet')
x, y = plt.meshgrid(turns[:,0], scan_values)
z = epsn_abs[plane]
threshold_plot = ax11.contourf(x, y, z.T, levels=plt.linspace(zlimits[0], zlimits[1], 201),
vmin=zlimits[0], vmax=zlimits[1], cmap=cmap)
cb = plt.colorbar(threshold_plot, ax13, orientation='vertical')
cb.set_label(zlabel)
plt.tight_layout()
def plotAngleGrid(self):
self.plotter.clearFigure()
val = self.angleGridMatrix[0, : , : ]
y = range(0, self.yAngleDim-1, 1)
z = range(0, self.zAngleDim-1, 1)
Z,Y = meshgrid( z, y)
valRange = [ 0 , self.yAngleDim, 0, self.zAngleDim ]
title="Travel Angle Grid"
colorBar=True
print "Plotting"
axis = self.plotter.getAxis()
axis.set_xlabel("Y")
axis.set_ylabel("Z")
self.plotter.setAspectRatioEven(even=True)
self.plotter.applyAspectRatio()
self.plotter.plotXYZData( Y, Z, val, title,colorBar, valRange)
# flip the axis
lims = self.plotter.getAxisLimits()
self.plotter.limitAxis(lims[0], lims[1], lims[3], lims[2])
self.plotter.drawFigure()
print "Done"
self.lastPlot = self.LAST_PLOT_TRAVEL_ANGLE
return True
def test_operation_approx():
def flux_qubit_potential(phi_m, phi_p):
return 2 + alpha - 2 * pl.cos(phi_p)*pl.cos(phi_m) - alpha * pl.cos(phi_ext - 2*phi_p)
alpha = 0.7
phi_ext = 2 * np.pi * 0.5
phi_m = pl.linspace(0, 2*np.pi, 100)
phi_p = pl.linspace(0, 2*np.pi, 100)
X,Y = pl.meshgrid(phi_p, phi_m)
Z = flux_qubit_potential(X, Y).T
# the diagram creatinos
from diagram.operations.computations import multiply
from diagram.ternary import AEV3DD
aevdd = AEV3DD()
diagram3 = aevdd.create(Z, 0, True)
diagram4 = aevdd.create(Z, 0, True)
aevdd_mat = multiply(diagram3, diagram4, 9).to_matrix(77, True)
aevdd_mat_approx = multiply(diagram3, diagram4, 9, approximation_precision=1, in_place='1').to_matrix(27, True)
pl.plt.figure()
fig, ax = pl.plt.subplots()
p = ax.pcolor(X/(2*pl.pi), Y/(2*pl.pi), Z, cmap=pl.cm.RdBu, vmin=abs(Z).min(), vmax=abs(Z).max())
cb = fig.colorbar(p, ax=ax)
p = ax.pcolor(X/(2*pl.pi), Y/(2*pl.pi), Z, cmap=pl.cm.RdBu, vmin=abs(Z).min(), vmax=abs(Z).max())
cb = fig.colorbar(p, ax=ax)
# cnt = ax.contour(Z, cmap=pl.cm.RdBu, vmin=abs(Z).min(), vmax=abs(Z).max(), extent=[0, 1, 0, 1])
pl.show()
def surface(self) :
x = pl.arange(-self.dimension[0],self.dimension[0]+1e-8,self.dimension[0]/5)
y = pl.arange(-self.dimension[1],self.dimension[1]+1e-8,self.dimension[1]/5)
xx,yy = pl.meshgrid(x,y)
zz = 1/self.placement.orientation[2]*(pl.linalg.dot(self.placement.orientation,self.placement.location)-self.placement.orientation[0]*xx-self.placement.orientation[1]*yy)
return [xx,yy,zz]
def LeapFrog(func, eps=0.0001, bounds=3 , delay=0.01, iterations=3000, printV=False, draw=True):
plt.figure()
players = (2*np.random.rand(20,2)-1)*bounds
x= np.arange(-bounds, bounds, 0.01)
y= np.arange(-bounds, bounds, 0.01)
X,Y = meshgrid(x, -y)
Z = func(X, Y)
im = plt.imshow(Z,cmap=cm.RdBu,extent=[-bounds, bounds, -bounds, bounds])
points, =plt.plot(players[:,0],players[:,1],'yo', marker='x')
colorbar(im)
for i in range(1,iterations):
z=func(players[:,0], players[:,1])
maxZ=np.argmax(z)
minZ = np.argmin(z)
r = np.random.rand(1,2)
players[maxZ, :]=players[minZ, :]-r*(players[maxZ, :]-players[minZ, :])
if(abs(z[maxZ]-z[minZ])<eps):
if(printV):
print("Minimum at: {0}".format(players[minZ,:]))
return players[minZ,:];
if(printV):
print([z[minZ], players[minZ,:]])
points.set_xdata(players[:,0])
points.set_ydata(players[:,1])
if(draw):
plt.pause(delay)
plt.draw()
def plotInit(Plotting, Elements): if (Plotting == 2): loc = [i.xy for i in Elements] x = [i.real for i in loc] y = [i.imag for i in loc] x = list(sorted(set(x))) x.remove(-10) y = list(sorted(set(y))) X, Y = pylab.meshgrid(x, y) U = pylab.ones(shape(X)) V = pylab.ones(shape(Y)) pylab.ion() fig, ax = pylab.subplots(1,1) graph = ax.quiver(X, Y, U, V) pylab.draw() else: pylab.ion() graph, = pylab.plot(1, 'ro', markersize = 2) x = 2 pylab.axis([-x,x,x,-x]) graph.set_xdata(0) graph.set_ydata(0) pylab.draw() return graph
def __init__( self, t, x, y, contrast=1 ):
self.t = t
self.x = x
self.y = y
self.contrast = float(contrast)
self._xx, self._yy = pl.meshgrid(self.x, self.y)
self.make_frames()
def griddata( X, Y, Z, xl, yl, xr, yr, dx):
# define grid.
xi, yi = p.meshgrid( p.linspace(xl,xr, int((xr-xl)/dx)+1), p.linspace(yl,yr, int((yr-yl)/dx)+1))
# grid the data.
zi = mgriddata(X,Y,Z,xi,yi)
New = grid( zi, xl, yl, dx)
return New
def showSF(N, label=''):
fig = P.figure()
ax1 = fig.add_subplot(1, 2, 1, projection='3d')
ax2 = fig.add_subplot(1, 2, 2)
Nx = 21
Ny = 21
nLevels = 12
tix = P.linspace(0.0, 1.0, Nx)
tiy = P.linspace(0.0, 1.0, Ny)
(X, Y) = P.meshgrid(tix, tiy)
z = g.RVector(len(X.flat))
for i, x in enumerate(X.flat):
p = g.RVector3(X.flat[i], Y.flat[i])
z[i] = N(p)
Z = P.ma.masked_where(z == -99., z)
Z = Z.reshape(Ny, Nx)
ax2.contourf(X, Y, Z)
ax2.set_aspect('equal')
surf = ax1.plot_surface(X,
Y,
Z,
rstride=1,
cstride=1,
cmap=P.cm.jet,
linewidth=0)
ax2.set_title(label + N.__str__())
fig.colorbar(surf)
def plot_wire_surface_pcolor(self):
"""
Plot the fraction of executions as a function of the fraction of nodes for
each source. Three plots are created: wireframe, surface, and pseudocolor.
"""
logging.debug('')
if self.dimension > 0:
return
array = self._data_to_array()
x = pylab.linspace(0.0, 1.0, len(array[0])+1)
y = pylab.linspace(0.0, 1.0, len(array)+1)
X, Y = pylab.meshgrid(x, y)
#fig_wire = MyFig(self.options, xlabel='Probability p', ylabel='Fraction of Nodes', ThreeD=True)
#fig_surf = MyFig(self.options, xlabel='Probability p', ylabel='Fraction of Nodes', ThreeD=True)
fig_pcol = MyFig(self.options, xlabel='Probability p', ylabel='Fraction of Nodes')
#fig_wire.ax.plot_wireframe(X, Y, array)
#fig_surf.ax.plot_surface(X, Y, array, rstride=1, cstride=1, linewidth=1, antialiased=True)
pcolor = fig_pcol.ax.pcolor(X, Y, array, cmap=cm.jet, vmin=0.0, vmax=1.0)
cbar = fig_pcol.fig.colorbar(pcolor, shrink=0.8, aspect=10)
cbar.ax.set_yticklabels(pylab.linspace(0.0, 1.0, 11), fontsize=0.8*self.options['fontsize'])
#for ax in [fig_wire.ax, fig_surf.ax]:
#ax.set_zlim3d(0.0, 1.01)
#ax.set_xlim3d(0.0, 1.01)
#ax.set_ylim3d(0.0, 1.01)
#self.figures['wireframe'] = fig_wire.save('wireframe_' + str(self.data_filter))
#self.figures['surface'] = fig_surf.save('surface_' + str(self.data_filter))
self.figures['pcolor'] = fig_pcol.save('pcolor_' + str(self.data_filter))
def plotField(x, F, titleStr, filename):
import pylab as p
import griddata as g
import numpy
p.ion()
p.clf()
xhat = Vector3d(1, 0, 0)
yhat = Vector3d(0, 1, 0)
numInternalNodes = len(x.internalValues())
indices = [i for i in xrange(numInternalNodes) if abs(x[i].z) < 1e-8]
xs = numpy.array([x[i].dot(xhat) for i in indices])
ys = numpy.array([x[i].dot(yhat) for i in indices])
x1 = p.linspace(-0.5, 1.5, 50)
y1 = p.linspace(-0.5, 1.5, 50)
xg, yg = p.meshgrid(x1, y1)
if isinstance(F, VectorField3d) or isinstance(F[0], Vector3d):
Fxs = numpy.array([F[i].dot(xhat) for i in indices])
Fys = numpy.array([F[i].dot(yhat) for i in indices])
Fxg = g.griddata(xs, ys, Fxs, xg, yg)
Fyg = g.griddata(xs, ys, Fys, xg, yg)
p.quiver(xg, yg, Fxg, Fyg)
else:
# levels = [0.1*i for i in xrange(32)]
Fs = numpy.array([F[i] for i in indices])
Fg = g.griddata(xs, ys, Fs, xg, yg)
p.contour(xg, yg, Fg, 30)
p.colorbar()
p.title(titleStr)
p.savefig(filename)
def plot_ratio(df,
bins=[np.linspace(0, .25, 100),
np.linspace(0, 1, 100)],
alpha=1,
cmap=None,
mc_field='mc',
stdc_field='stdc',
response_field='response'):
C, M = plt.meshgrid(*bins)
resp1 = plt.histogram2d(
df[df.loc[:, response_field] == 1].loc[:, stdc_field].values,
df[df.loc[:, response_field] == 1].loc[:, mc_field].values,
bins=bins)[0] + 1
#resp1[resp1==1] = np.nan
resp2 = plt.histogram2d(
df[df.loc[:, response_field] == -1].loc[:, stdc_field].values,
df[df.loc[:, response_field] == -1].loc[:, mc_field].values,
bins=bins)[0] + 1
#resp2[resp2==1] = np.nan
resp1 = resp1.astype(float) / np.nansum(resp1)
resp2 = resp2.astype(float) / np.nansum(resp2)
plane = np.log(resp1 / resp2)
#plane[plane==1] = np.nan
plt.pcolormesh(bins[1],
bins[0],
np.ma.masked_invalid(plane),
cmap=cmap,
vmin=-2.4,
vmax=2.4)
def gabor_patch(
sigma_deg=2,
radius_deg=6,
px_deg=50,
sf_cyc_deg=2,
phase_deg=0, #phase of cosine in degrees
contrast=1.0):
"""Return a gabor patch texture of the given dimensions and parameters."""
height = width = radius_deg * px_deg
x = pylab.linspace(-radius_deg, radius_deg, width)
X, Y = pylab.meshgrid(x, x)
L = pylab.exp(-(X**2 + Y**2) / sigma_deg**2) #gaussian envelope
#use around to round towards zero, otherwise you will get banding artifacts
#dtype must be int for proper conversion to int and init of image data
#I = pylab.array(-pylab.zeros(X.size)*max_range + neutral_gray, dtype='int')
I = pylab.array(pylab.around(
contrast * pylab.cos(2 * pylab.pi *
(sf_cyc_deg) * X + phase_deg * pylab.pi / 180.) *
L * max_range) + neutral_gray,
dtype='int').ravel()
IA = pylab.ones(I.size * 2, dtype='int') * 255
IA[:-1:2] = I #Need alpha=255 otherwise image is mixed with background
#Data format for image http://www.pyglet.org/doc/programming_guide/accessing_or_providing_pixel_data.html
data = array.array('B', IA)
gabor = pyglet.image.ImageData(width, height, 'IA', data.tostring())
return gabor
def prepare_sensors(sensor_locations, resolution=51):
"""
Common method, to pre-process sensors before display (project them in 2D).
"""
def sphere_fit(params):
"""Function to fit the sensor locations to a sphere"""
return ((sensor_locations[:, 0] - params[1]) ** 2 + (sensor_locations[:, 1] - params[2]) ** 2
+ (sensor_locations[:, 2] - params[3]) ** 2 - params[0] ** 2)
(radius, circle_x, circle_y, circle_z) = leastsq(sphere_fit, (1, 0, 0, 0))[0]
# size of each square
ssh = float(radius) / resolution # half-size
# Generate a grid and interpolate using the gridData module
x_arr = numpy.arange(circle_x - radius, circle_x + radius, ssh * 2.0) + ssh
y_arr = numpy.arange(circle_y - radius, circle_y + radius, ssh * 2.0) + ssh
x_arr, y_arr = pylab.meshgrid(x_arr, y_arr)
# project the sensor locations onto the sphere
sproj = sensor_locations - numpy.array((circle_x, circle_y, circle_z))
sproj = radius * sproj / numpy.c_[numpy.sqrt(numpy.sum(sproj ** 2, axis=1))]
sproj += numpy.array((circle_x, circle_y, circle_z))
return dict(sproj=sproj, x_arr=x_arr, y_arr=y_arr,
circle_x=circle_x, circle_y=circle_y, rad=radius)
def prepare_sensors(sensor_locations, resolution=51):
"""
Common method, to pre-process sensors before display (project them in 2D).
"""
def sphere_fit(params):
"""Function to fit the sensor locations to a sphere"""
return ((sensor_locations[:, 0] - params[1])**2 +
(sensor_locations[:, 1] - params[2])**2 +
(sensor_locations[:, 2] - params[3])**2 - params[0]**2)
(radius, circle_x, circle_y,
circle_z) = leastsq(sphere_fit, (1, 0, 0, 0))[0]
# size of each square
ssh = float(radius) / resolution # half-size
# Generate a grid and interpolate using the gridData module
x_arr = numpy.arange(circle_x - radius, circle_x + radius,
ssh * 2.0) + ssh
y_arr = numpy.arange(circle_y - radius, circle_y + radius,
ssh * 2.0) + ssh
x_arr, y_arr = pylab.meshgrid(x_arr, y_arr)
# project the sensor locations onto the sphere
sproj = sensor_locations - numpy.array((circle_x, circle_y, circle_z))
sproj = radius * sproj / numpy.c_[numpy.sqrt(
numpy.sum(sproj**2, axis=1))]
sproj += numpy.array((circle_x, circle_y, circle_z))
return dict(sproj=sproj,
x_arr=x_arr,
y_arr=y_arr,
circle_x=circle_x,
circle_y=circle_y,
rad=radius)
def plot_solution(self, T, X, u):
# The surface plot
Xm, Tm = pylab.meshgrid(X, linspace(T, 0.0, u.shape[0]))
fig_surface = pylab.figure()
ax = ax3d.Axes3D(fig_surface)
ax.plot_surface(Xm, Tm, u)
ax.set_ylabel('Time $t$')
ax.set_xlabel('Stock price $x$')
ax.set_zlabel('Option value $f(t,x)$')
# The color temperature plot
fig_color = pylab.figure()
ax = pylab.gca()
ax.set_xlabel('Time $t$')
ax.set_ylabel('Stock price $x$')
ax.imshow(u.T,
interpolation='bilinear',
origin='lower',
cmap=matplot.cm.hot,
aspect='auto',
extent=(T, 0.0, X[0], X[-1]))
# Plot of price function at time 0
fig_zero = pylab.figure()
pylab.plot(X, u[m - 1, :])
ax = pylab.gca()
ax.set_xlabel('Stock price $x$')
ax.set_ylabel('Option value $f(0,x)$')
return fig_surface, fig_color, fig_zero
def vecPlot2(self, row, col, r_m, mWx, mWy, data1, data2, dmr, frmSize, winSize):
pl.clf()
pl.ion()
pWx = []
l = dmr - row - col
for f in range(l):
pWx.append(mWx[row + f, col + f, :, 0])
pWx = np.array(pWx)
sqWx = np.sqrt(pWx * pWx)
print sqWx
r, c = sqWx.shape
x = pl.arange(c + 1)
y = pl.arange(r + 1)
X, Y = pl.meshgrid(x, y)
pl.subplot2grid((1, 2), (0, 0))
pl.pcolor(X, Y, sqWx, vmin=0, vmax=1)
pl.xlim(0, c)
pl.ylim(0, r)
pl.colorbar()
pl.title("user_1 (t:" + str(row) + ")")
pl.gray()
pWy = []
l = dmr - row - col
for f in range(l):
pWy.append(mWy[row + f, col + f, :, 0])
pWy = np.array(pWy)
sqWy = np.sqrt(pWy * pWy)
print sqWy
r, c = sqWy.shape
x = pl.arange(c + 1)
y = pl.arange(r + 1)
X, Y = pl.meshgrid(x, y)
pl.subplot2grid((1, 2), (0, 1))
pl.pcolor(X, Y, sqWy, vmin=0, vmax=1)
pl.xlim(0, c)
pl.ylim(0, r)
pl.colorbar()
pl.title("user_2 (t:" + str(col) + ")")
pl.gray()
pl.tight_layout()
pl.draw()
def gen_ssmodel(self):
"""
generates full neural model
Attributes:
----------
K: matrix
matrix of connectivity kernel evaluated over the spatial domain of the kernel
Sigma_e: matrix
field disturbance covariance matrix
Sigma_e_c: matrix
cholesky decomposiotion of field disturbance covariance matrix
Sigma_varepsilon_c: matrix
cholesky decomposiotion of observation noise covariance matrix
C: matrix
matrix of sensors evaluated at each spatial location, it's not the same as C in the IDE model
"""
print "generating full neural model"
#Generate field meshgrid
simulation_field_space_x,simulation_field_space_y=pb.meshgrid(self.simulation_space_x_y,self.simulation_space_x_y)
K=0
for i in range(len(self.kernel.Psi)):
K+=self.kernel.weights[i]*self.kernel.Psi[i](simulation_field_space_x,simulation_field_space_y)
self.K=K
#calculate field disturbance covariance matrix and its Cholesky decomposition
gamma_space=pb.array(zip(simulation_field_space_x.flatten(),simulation_field_space_y.flatten()))
N1,D1 = gamma_space.shape
diff = gamma_space.reshape(N1,1,D1) - gamma_space.reshape(1,N1,D1)
Sigma_e_temp=self.gamma_weight*np.exp(-np.sum(np.square(diff),-1)*(1./self.gamma.width))
self.Sigma_e=Sigma_e_temp
if hasattr(self,'Sigma_e_c'):
pass
else:
self.Sigma_e_c=sp.linalg.cholesky(self.Sigma_e,lower=1)
#calculate Cholesky decomposition of observation noise covariance matrix
Sigma_varepsilon_c=sp.linalg.cholesky(self.Sigma_varepsilon,lower=1)
self.Sigma_varepsilon_c=Sigma_varepsilon_c
#Calculate sensors at each spatial locations, it's not the same as C in the IDE model
t0=time.time()
sensor_space=self.obs_locns
N2,D2 = sensor_space.shape
diff = sensor_space.reshape(N2,1,D2) - gamma_space.reshape(1,N1,D1)
C=np.exp(-np.sum(np.square(diff),-1)*(1./self.sensor_kernel.width))
self.C=C
def surface(self) :
x = pl.arange(-self.dimension[0],self.dimension[0]+1e-8,self.dimension[0]/5)
y = pl.arange(-self.dimension[1],self.dimension[1]+1e-8,self.dimension[1]/5)
xx,yy = pl.meshgrid(x,y)
cv = self.placement.location+self.placement.orientation*self.radcurv
zz = -pl.sign(self.radcurv)*pl.sqrt(self.radcurv**2-(xx-cv[0])**2-(yy-cv[1])**2)+cv[2]
return [xx,yy,zz]
