def interp(startgrid):
num_depths = 30 # to avoid problems with seafloor depth
z_step = 10
depth_list = [10, 20, 30, 50, 75, 100, 125, 150, 200, 250, 300, 400]
new_depth = np.arange(z_step, (num_depths + 1) * z_step, z_step)
new_depth_index = []
left = 0
right = 1
for i in range(0, len(new_depth)):
target_value = new_depth[i]
if target_value > depth_list[right]:
right += 1
left += 1
left_value = depth_list[left]
right_value = depth_list[right]
a = target_value - left_value
b = right_value - left_value
new_index = a / b + left
new_depth_index.append(new_index)
#start grid is shape lat,lon,depth
lat = startgrid.shape[1]
lon = startgrid.shape[2]
depth = startgrid.shape[0]
interp_grid = np.zeros((len(new_depth_index), lat, lon))
ip = tricubic.tricubic(list(startgrid), [depth, lat, lon])
for i in range(0, lat):
for j in range(0, lon):
for k in range(0, len(new_depth_index)):
res = ip.ip([new_depth_index[k], i, j])
interp_grid[k, i, j] = res
return interp_grid
def interpolateOnArbitraryGrid(input_vector, N=3, gridOrder=1):
"""
On a NxNxN grid where each 'point' is indexed by 3 integers (i,j,k), the measurement values
(which are 3 dimensional w/ components (f1,f2,f3)) are each associated with one grid point. Between any two grid points,
tricubic interpolation determines the behaviour of the function.
Args:
input_vector (ndarray): a vector containing any number of scalar measurements.
N (int, optional): Size of grid. Defaults to 3.
gridOrder (int, optional): Order in which the grid is set up. default means we start at the bottom left
corner and increase the third component(vertical), then the second and finally
the first.
Returns:
3 Interpolator objects: ip_1, ip_2, ip_3
and 3 ndarrays f1, f2, f3
"""
f1 = np.zeros((N, N, N), dtype='float')
f2 = np.zeros((N, N, N), dtype='float')
f3 = np.zeros((N, N, N), dtype='float')
gridSize = N**3 - 1
m = 0
for i in range(N):
for j in range(N):
for k in range(N):
# some function f(x,y,z) is given on a cubic grid indexed by i,j,k
if gridOrder == -1:
f1[i][j][k] = input_vector[gridSize - m, 0]
f2[i][j][k] = input_vector[gridSize - m, 1]
f3[i][j][k] = input_vector[gridSize - m, 2]
elif gridOrder == 1:
f1[i][j][k] = input_vector[m, 0]
f2[i][j][k] = input_vector[m, 1]
f3[i][j][k] = input_vector[m, 2]
m = m + 1
# initialize interpolator with input data on cubic grid
ip_1 = tricubic.tricubic(list(f1), [N, N, N])
ip_2 = tricubic.tricubic(list(f2), [N, N, N])
ip_3 = tricubic.tricubic(list(f3), [N, N, N])
return ip_1, ip_2, ip_3, f1, f2, f3
def test_constant(self):
n = 4
c = 1
a = [[[c for k in range(n)] for j in range(n)] for i in range(n)]
ip = tricubic(a, [n, n, n])
for i in range(2 * n):
for j in range(2 * n):
for k in range(2 * n):
v = ip.ip([0.5 * i, 0.5 * j, 0.5 * k])
self.assertEqual(v, c)
def test_linear(self):
f = lambda x, y, z: (x + 1.2) + (0.2 * y - 0.1) + z * 4
n = 5
a = [[[f(i, j, k) for k in range(n)] for j in range(n)]
for i in range(n)]
ip = tricubic(a, [n, n, n])
x = 1.6
y = 2.3
z = 3.7
v = ip.ip([x, y, z])
self.assertEqual(v, 19.43)
def test_linear_trivial(self):
f = lambda x, y, z: (x + 1.2) + (0.2 * y - 0.1) + z * 4
n = 5
a = [[[f(i, j, k) for k in range(n)] for j in range(n)]
for i in range(n)]
ip = tricubic(a, [n, n, n])
for i in range(n):
for j in range(n):
for k in range(n):
v = ip.ip([i, j, k])
fv = f(i, j, k)
self.assertEqual(v, fv)
def get_density(samplegrid, wfvalues, atompos_rel, nx, ny, nz, samplex,
sampley, samplez):
shift = +0.5 * np.ones(3, dtype=float)
sampledens = np.zeros(len(samplegrid), dtype=float)
for w, p in zip(wfvalues, atompos_rel):
#initialize interpolator for this partial density
ip = tricubic.tricubic(list(w), [nx, ny, nz])
for i, vec in enumerate(samplegrid):
transformedvec = vec + shift + p[::-1]
transformedvec = np.remainder(
transformedvec,
1) #transform coordinates and fold back to range 0 ... 1
transformedvec = list(
np.multiply(transformedvec,
np.array([nx - 1, ny - 1, nz - 1], dtype=float))
) #multiply by n-1, because tricubic interpolator has fixed spacing of one between data points
sampledens[i] += (
ip.ip(transformedvec))**2 #square to get density from WF
return sampledens
def _interpolate_spher_mms(vdf0, speed, theta, phi, grid_s, interp_schem):
"""Interpolates particles' VDF, tailored for MMS data."""
vdf_interp_shape = grid_s.shape[1:]
# Preparing the interpoplation.
phi_period = np.zeros(34)
phi_period[1:-1] = phi
phi_period[0] = phi[-1] - 2 * np.pi
phi_period[-1] = phi[0] + 2 * np.pi
theta_period = np.zeros(18)
theta_period[1:-1] = theta
theta_period[0] = theta[-1] - np.pi
theta_period[-1] = theta[0] + np.pi
vdf_period = np.zeros((32, 18, 34))
vdf_period[:, 1:-1, 1:-1] = vdf0
vdf_period[:, 1:-1, 0] = vdf0[:, :, -1]
vdf_period[:, 1:-1, -1] = vdf0[:, :, 0]
vdf_period[:, 0] = vdf_period[:, 1]
vdf_period[:, 17] = vdf_period[:, 16]
itkR = ~np.isnan(speed)
if 0: ## For "partial" moments.
itkRtmp = speed < 4e6
vdf_period[itkRtmp] = 0.
# INTERPOLATION!
if interp_schem in ['near', 'lin']:
if interp_schem == 'near':
interp_schem_str = 'nearest'
elif interp_schem == 'lin':
interp_schem_str = 'linear'
interp_func = RegularGridInterpolator(
(speed[itkR], theta_period, phi_period), (vdf_period[itkR]),
bounds_error=False,
method=interp_schem_str,
fill_value=np.nan)
d = interp_func(grid_s.reshape(3, -1).T)
d = d.T.reshape(vdf_interp_shape) # (res,res,res)
elif interp_schem == 'cub':
if not tricubic_imported:
raise NotImplementedError('The tricubic module was not found. '
'Try: pip install tricubic')
d = np.zeros(vdf_interp_shape).flatten()
ip = tricubic.tricubic(list(vdf_period), [
vdf_period.shape[0], vdf_period.shape[1], vdf_period.shape[2]
])
ds = speed[1:] - speed[:-1]
delta_theta = theta[1] - theta[0]
delta_phi = phi[1] - phi[0]
vMin_theta = 0.
vMin_phi = 0.
#
bi = np.digitize(grid_s[0], speed) - 1
grid_s[0] = bi + (grid_s[0] - speed[bi]) / ds[bi]
grid_s[1] = (grid_s[1] - vMin_theta) / delta_theta + .5
grid_s[2] = (grid_s[2] - vMin_phi) / delta_phi + .5
for j, node in enumerate(grid_s.reshape((3, -1)).T):
d[j] = ip.ip(list(node))
d = d.reshape(vdf_interp_shape)
# "fill_value". Should also be done for values larger than,
# and not only smaller than.
d[grid_s[0] < 0] = np.nan
return d
def cgstki3(velp, zplan, tt, dt, nx, ny, nz, dim, domain, simtstep):
# x = np.arange(tt)
ttt = int(tt / dt)
ttt = np.arange(ttt)
# print ttt[0], ttt[-1]
n = len(ttt)
N = 25 # rk45 int step
integrator = 'dopri5' # ou dopri5 pour du dormant-prince rk45a-
rrk45 = 2 # 0=rk45, 1=heun, 2= euler
# small (so is your dick) vector d1(d1 0 0) d2(0 d2 0) d3(0 0 d3)
d1 = np.float(ConfigSectionMap('cauchygreen')['dx'])
d2 = d1
d3 = d2
# tranche = zplan # index de la tranche evaluee
integ = 'rk45'
# if doublegyre
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print 'WARING DOMAIN CUT FOR TEST PURPOSE'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# velp = velp[:, :60, :, :, :]
# ny = velp.shape[1]
#
# print 'velp shape'
# print velp.shape
# ptlist = np.indices((nx, ny, nz))
# ptlist = ptlist.astype(float)
domain = domain.astype(float)
dx = abs(domain[1] - domain[0]) / nx
dy = abs(domain[3] - domain[2]) / ny
dz = abs(domain[5] - domain[4]) / ny
print 'dx', dx
print 'dy', dy
print 'dz', dz
rr = 1
nnx = nx * rr
nny = ny * rr
nnz = nz * rr # pas de sous divisions sur z
ddx = dx / rr
ddy = dy / rr
ddz = dz / rr
zzplan = zplan * rr
print "domain:", domain
print 'zplan =', zplan # * ddz + domain[4]
tranche = int((zplan - domain[4]) / ((domain[5] - domain[4]) / nz))
print 'tranche evaluee %i' % tranche
print 'dt', dt, 't physique', tt, '# time steps', ttt
# interp spatiale sur une grille r fois plus fine
grid = np.indices((nnx, nny, nnz))
grid = grid.astype(float)
grid_i = np.empty((dim, nnx, nny, nnz))
grid_i[0, :, :] = grid[0]
grid_i[1, :, :] = grid[1]
grid_i[2, :, :] = grid[2]
# print grid_i
# grid_iini = np.zeros((dim, nnx, nny, nnz))
grid_iini = np.empty((dim, nnx, nny, nnz))
grid_iini[0, :, :] = grid[0]
grid_iini[1, :, :] = grid[1]
grid_iini[2, :, :] = grid[2]
print 'grind ini shape'
print grid_iini.shape
print 'interpolation over space, dx/ %i' % rr
if np.int(ver.full_version[2:4] < 14):
print 'scipy version %s 2 low. plz upgrade to 0.14.xx' % ver.full_version
quit()
else:
print 'scipy version %s is high, so am I' % ver.full_version
# x = np.linspace(0, nnx - 1, nnx, dtype=int16)
# y = np.linspace(0, nny - 1, nny, dtype=int16)
# z = np.linspace(0, nnz - 1, nnz, dtype=int16)
# t = np.linspace(0, len(ttt) - 1, len(ttt), dtype=int16)
velpu = velp[:, :, :, 0, :]
velpv = velp[:, :, :, 1, :]
velpw = velp[:, :, :, 2, :]
interpU_i = velp
stamp = time.time()
# def fu(x, y, z, t):
# return velpu[x, y, z, t]
#
# def fv(x, y, z, t):
# return velpv[x, y, z, t]
#
# def fw(x, y, z, t):
# return velpw[x, y, z, t]
#
# datau = fu(*np.meshgrid(x, y, z, t, indexing='ij', sparse=False))
# datav = fv(*np.meshgrid(x, y, z, t, indexing='ij', sparse=False))
# dataw = fw(*np.meshgrid(x, y, z, t, indexing='ij', sparse=False))
#
# interpu = RegularGridInterpolator((x, y, z, t), datau, method='nearest', bounds_error=False, fill_value=0)
# interpv = RegularGridInterpolator((x, y, z, t), datav, method='nearest', bounds_error=False, fill_value=0)
# interpw = RegularGridInterpolator((x, y, z, t), dataw, method='nearest', bounds_error=False, fill_value=0)
# quit()
print 'linear interp NOT from Scientific python'
print 'avection time !'
# eq dif => x point = v(x,t)
# ou: y point = f(x,t)
# fonction f:
nn = np.array([nnx, nny, nnz])
invddx = 1 / ddx
invddy = 1 / ddy
invddz = 1 / ddz
def f_u(yy, t):
coord = np.array([yy[0], yy[1], yy[2], t])
# a = np.array(
# [interpu(coord) * invddx, interpv(coord) * invddy, interpw(coord) * invddz])
u = ndimage.map_coordinates(velpu, [[yy[0]], [yy[1]], [yy[2]], [t]],
order=3,
mode='constant',
cval=0.0,
prefilter=False) * invddx
v = ndimage.map_coordinates(velpv, [[yy[0]], [yy[1]], [yy[2]], [t]],
order=3,
mode='constant',
cval=0.0,
prefilter=False) * invddy
w = ndimage.map_coordinates(velpw, [[yy[0]], [yy[1]], [yy[2]], [t]],
order=3,
mode='constant',
cval=0.0,
prefilter=False) * invddz
return np.array([u, v, w])[:, 0]
# print 'fu'. f_u()
solver = ode(f_u)
solver.set_integrator('dopri5', rtol=0.001, atol=1e-3)
t = np.linspace(0, tt, N)
bobol = np.zeros((nnx, nny))
if rrk45 == 0:
print 'rk45 intregration method, a checker'
toto = 0
quit()
for i in xrange(nnx):
for j in xrange(nny):
y0 = grid_iini[:, i, j, tranche]
# if np.all(np.abs(f_u(grid_i[:, i, j, tranche],0)) > np.array([1e-7,1e-7,1e-7])):
if np.all(
np.abs(velp[i, j, tranche, :]) > np.array(
[1e-7, 1e-7, 1e-7])):
bobol[i, j] = True
grid_i[:, i, j, tranche], err = rk45(f_u, y0, t)[-1]
if np.max(err) > 1e-5:
print err, 'erreur d integ trop grande, my n***a'
else:
grid_i[:, i, j, k] = [0, 0,
0] # grid_i[:, i, j, tranche] = y0
# on en profite pour faire le mask!!!
toto += 1
print '%i point skipped, ie. %f percents of total points of the slice' % (
toto, 100 * toto / (ny * nx))
elif rrk45 == 1:
print 'heun intregration method'
toto = 0
for i in xrange(nnx):
for j in xrange(nny):
for k in range(tranche - 2, tranche + 3):
y0 = grid_iini[:, i, j, k]
if np.all(
np.abs(velp[i, j, k, :,
0]) > np.array([1e-7, 1e-7, 1e-7])):
bobol[i, j] = True
grid_i[:, i, j, k] = heun(f_u, y0, t, nx, ny)[-1]
else:
grid_i[:, i, j, k] = [0, 0, 0]
toto += 1
print '%i point skipped, ie. %f percents of total points of the slice' % (
toto, 100 * toto / (ny * nx))
elif rrk45 == 2:
print 'euler intregration method'
toto = a = 0
print('0 50 100%')
for i in xrange(nnx):
for j in xrange(nny):
for k in range(tranche - 0, tranche + 1):
y0 = grid_iini[:, i, j, k]
if np.all(
np.abs(velp[i, j, k, :,
0]) > np.array([1e-7, 1e-7, 1e-7])):
bobol[i, j] = True
grid_i[:, i, j, k] = euler(f_u, y0, t)[-1]
else:
# grid_i[:, i, j, k] = [0, 0, 0]
toto += 1
a = 1. * i / nnx
if (100 * a) % 10 < 1e-3:
rpog()
print '\n %i point skipped, ie. %f percents of total points of the domain' % (
toto, 100 * toto / (ny * nx * 5))
else:
print 'wut ?'
quit()
# else:
# print grid_i[:,35,24,37]
# print 'totototot'
# t = ttt
# t0 = t[0]
# t1 = 0.001#t[-1]
# i = j = 0
# for i in xrange(nnx):
# for j in xrange(nny):
# y0 = grid_i[:, i, j, tranche]
# solver.set_initial_value(y0, t0)
# sol = np.empty((N, 3))
# sol[0] = y0
# k = 1
# dt=1e-3
# while solver.successful() and solver.t < t1:
# solver.integrate(t[k])
# sol[k] = solver.y
# k += 1
# grid_i[:, i, j, tranche] = sol[-1, :]
print '-----------------------------------------------------'
print 'Velocity advected in %f s ' % (time.time() - stamp)
print '-----------------------------------------------------'
FTF = True
if FTF:
stamp = time.time()
# gradient of the flow map
# shadden method
# (u, v, w) sur (x, y)
dphi = np.empty((nnx, nny, 3, 3))
tricu = True
if tricu:
print 'tricubic interp'
du = tricubic.tricubic(
list(grid_i[0, :, :, :]),
[nnx, nny, nnz
]) # initialize interpolator with input data on cubic grid
dv = tricubic.tricubic(
list(grid_i[1, :, :, :]),
[nnx, nny, nnz
]) # initialize interpolator with input data on cubic grid
dw = tricubic.tricubic(
list(grid_i[2, :, :, :]),
[nnx, nny, nnz
]) # initialize interpolator with input data on cubic grid
tata = 0
print('0 50 100%')
# 3d version haller ann. rev. fluid 2015
for i in range(1, nnx - 1):
for j in range(1, nny - 1):
# if np.all(np.abs(velp[i, j, k, :, 0]) > np.array([1e-7, 1e-7, 1e-7])):
if bobol[i, j]:
dphi[i, j, 0,
0] = (du.ip(list(np.array([i + d1, j, tranche])))
- du.ip(list(np.array([i - d1, j, tranche
])))) / (2 * d1)
dphi[i, j, 0,
1] = (du.ip(list(np.array([i, j + d2, tranche])))
- du.ip(list(np.array([i, j - d2, tranche
])))) / (2 * d2)
dphi[i, j, 0,
2] = (du.ip(list(np.array([i, j, tranche + d3])))
- du.ip(list(np.array([i, j, tranche - d3
])))) / (2 * d3)
dphi[i, j, 1,
0] = (dv.ip(list(np.array([i + d1, j, tranche])))
- dv.ip(list(np.array([i - d1, j, tranche
])))) / (2 * d1)
dphi[i, j, 1,
1] = (dv.ip(list(np.array([i, j + d2, tranche])))
- dv.ip(list(np.array([i, j - d2, tranche
])))) / (2 * d2)
dphi[i, j, 1,
2] = (dv.ip(list(np.array([i, j, tranche + d3])))
- dv.ip(list(np.array([i, j, tranche - d3
])))) / (2 * d3)
dphi[i, j, 2,
0] = (dw.ip(list(np.array([i + d1, j, tranche])))
- dw.ip(list(np.array([i - d1, j, tranche
])))) / (2 * d1)
dphi[i, j, 2,
1] = (dw.ip(list(np.array([i, j + d2, tranche])))
- dw.ip(list(np.array([i, j - d2, tranche
])))) / (2 * d2)
dphi[i, j, 2,
2] = (dw.ip(list(np.array([i, j, tranche + d3])))
- dw.ip(list(np.array([i, j, tranche - d3
])))) / (2 * d3)
else:
dphi[i, j, :, :] = np.zeros((3, 3))
tata += 1
a = 1. * i / nnx
if (100 * a) % 10 < 1e-3:
rpog()
print '\n', tata, ' skipped of,', nnx * nny
# bords a l arrache;
dphi[0, :, 0, 0] = dphi[1, :, 0, 0]
dphi[nnx - 1, :, 0, 0] = dphi[nnx - 2, :, 0, 0]
dphi[:, 0, 0, 0] = dphi[:, 1, 0, 0]
dphi[:, nny - 1, 0, 0] = dphi[:, nny - 2, 0, 0]
dphi[0, :, 0, 1] = dphi[1, :, 0, 1]
dphi[nnx - 1, :, 0, 1] = dphi[nnx - 2, :, 0, 1]
dphi[:, 0, 0, 1] = dphi[:, 1, 0, 0]
dphi[:, nny - 1, 0, 1] = dphi[:, nny - 2, 0, 1]
dphi[0, :, 1, 0] = dphi[1, :, 1, 0]
dphi[nnx - 1, :, 1, 0] = dphi[nnx - 2, :, 1, 0]
dphi[:, 0, 1, 0] = dphi[:, 1, 1, 0]
dphi[:, nny - 1, 1, 0] = dphi[:, nny - 2, 1, 0]
dphi[0, :, 1, 1] = dphi[1, :, 1, 1]
dphi[nnx - 1, :, 1, 1] = dphi[nnx - 2, :, 1, 1]
dphi[:, 0, 1, 1] = dphi[:, 1, 1, 1]
dphi[:, nny - 1, 1, 1] = dphi[:, nny - 2, 1, 1]
gdphi = np.empty((nnx, nny, 3, 3))
for i in xrange(nnx):
for j in xrange(nny):
gdphi[i, j, :, :] = np.dot(dphi[i, j, :, :].T,
dphi[i, j, :, :])
else:
quit()
# axes = (xx, yy, zz)
# du = IF(axes, dispu)
# dv = IF(axes, dispv)
# dw = IF(axes, dispw)
#
# d1 = dx / 3
# d2 = dy / 3
# d3 = dz / 3
#
# # 3d version haller ann. rev. fluid 2015
# for i in range(1, nnx - 1):
# for j in range(1, nny - 1):
# # for k in range(1, nnz - 1):
# # ACHTUNG CALCUL 3D MAIS SEED 2D
# ii = i * ddx + domain[0]
# jj = j * ddy + domain[2]
# zzzplan = zplan * dz + domain[4]
# # print ii,jj,zzzplan
# # print
# # print ii, jj, zzzplan
#
# dphi[i, j, 0, 0] = (du(ii + d1, jj, zzzplan) - du(ii - d1, jj, zzzplan)) / (2 * d1)
# print dphi[i, j, 0, 0]
# dphi[i, j, 0, 1] = (du(ii, jj + d2, zzzplan) - du(ii, jj - d2, zzzplan)) / (2 * d2)
# dphi[i, j, 0, 2] = (du(ii, jj, zzzplan + d3) - du(ii, jj, zzzplan - d3)) / (2 * d3)
#
# dphi[i, j, 1, 0] = (dv(ii + d1, jj, zzzplan) - dv(ii - d1, jj, zzzplan)) / (2 * d1)
# dphi[i, j, 1, 1] = (dv(ii, jj + d2, zzzplan) - dv(ii, jj - d2, zzzplan)) / (2 * d2)
# dphi[i, j, 1, 2] = (dv(ii, jj, zzzplan + d3) - dv(ii, jj, zzzplan - d3)) / (2 * d3)
#
# dphi[i, j, 2, 0] = (dw(ii + d1, jj, zzzplan) - dw(ii - d1, jj, zzzplan)) / (2 * d1)
# dphi[i, j, 2, 1] = (dw(ii, jj + d2, zzzplan) - dw(ii, jj - d2, zzzplan)) / (2 * d2)
# dphi[i, j, 2, 2] = (dw(ii, jj, zzzplan + d3) - dw(ii, jj, zzzplan - d3)) / (2 * d3)
#
# print 'dphi[50,50,1,1]'
# print dphi[50, 50, 1, 1]
# # bords a l arrache;
# dphi[0, :, 0, 0] = dphi[1, :, 0, 0]
# dphi[nnx - 1, :, 0, 0] = dphi[nnx - 2, :, 0, 0]
# dphi[:, 0, 0, 0] = dphi[:, 1, 0, 0]
# dphi[:, nny - 1, 0, 0] = dphi[:, nny - 2, 0, 0]
#
# dphi[0, :, 0, 1] = dphi[1, :, 0, 1]
# dphi[nnx - 1, :, 0, 1] = dphi[nnx - 2, :, 0, 1]
# dphi[:, 0, 0, 1] = dphi[:, 1, 0, 0]
# dphi[:, nny - 1, 0, 1] = dphi[:, nny - 2, 0, 1]
#
# dphi[0, :, 1, 0] = dphi[1, :, 1, 0]
# dphi[nnx - 1, :, 1, 0] = dphi[nnx - 2, :, 1, 0]
# dphi[:, 0, 1, 0] = dphi[:, 1, 1, 0]
# dphi[:, nny - 1, 1, 0] = dphi[:, nny - 2, 1, 0]
#
# dphi[0, :, 1, 1] = dphi[1, :, 1, 1]
# dphi[nnx - 1, :, 1, 1] = dphi[nnx - 2, :, 1, 1]
# dphi[:, 0, 1, 1] = dphi[:, 1, 1, 1]
# dphi[:, nny - 1, 1, 1] = dphi[:, nny - 2, 1, 1]
#
# gdphi = np.empty((nnx, nny, 3, 3))
# for i in xrange(nnx):
# for j in xrange(nny):
# gdphi[i, j, :, :] = np.dot(dphi[i, j, :, :].T, dphi[i, j, :, :])
# print dphi.shape, dphi.T.shape,gdphi.shape
# toto=np.inner(dphi.T, dphi)
# print np.array_equal(gdphi,toto)
# print '------------------------'
eigenValues, eigenVectors = LA.eig(gdphi)
eigvec1 = np.empty((nnx, nny, 3))
eigvec3 = np.empty((nnx, nny, 3))
eigval1 = np.empty((nnx, nny))
eigval3 = np.empty((nnx, nny))
# print 'min,max,avg,stdev'
# a = eigenValues[:, :, 0] * eigenValues[:, :, 1] * eigenValues[:, :, 2]
# # print np.min(a)
# # print np.max(a)
# # print np.average(a)
# # print np.std(a)
# # print '{{{{{{'
for i in xrange(eigenValues.shape[0]):
for j in xrange(eigenValues.shape[1]):
eigval1[i, j] = np.min(eigenValues[i, j, :])
eigval3[i, j] = np.max(eigenValues[i, j, :])
eigvec1[i, j, :] = eigenVectors[i, j, :,
np.argmin(eigenValues[i,
j, :])]
eigvec3[i, j, :] = eigenVectors[i, j, :,
np.argmax(eigenValues[i,
j, :])]
# print eigvec3[i, j, :]
# toto = eigval3.astype(short)
# juliaStacked = np.dstack([toto])
# x = np.arange(0, nnx)
# y = np.arange(0, nny)
# z = np.arange(0, 2)
# gridToVTK("./julia", x, y, z, cellData = {'julia': juliaStacked})
print '-----------------------------------------------------'
print 'Flow map and eigval/eigvec computed in %f s ' % (time.time() -
stamp)
print '-----------------------------------------------------'
# p1 = win.addPlot(title="Basic array plotting", y=np.random.normal(size=100))
f, ((ax1, ax2, ax3), (ax4, ax5, ax6),
(ax7, ax8, ax9)) = plt.subplots(3, 3, sharex=True, sharey=True)
# print didx.shape
# Y, X = np.mgrid[0:nx * dx:rr * nx * 1j, 0:ny * dy:rr * ny * 1j]
uu = grid_i[0, :, :, zzplan] - grid_iini[0, :, :,
zzplan] # -grid_iini[0,:,:]
vv = grid_i[1, :, :, zzplan] - grid_iini[1, :, :,
zzplan] # -grid_iini[1,:,:]
ww = grid_i[2, :, :, zzplan] - grid_iini[2, :, :,
zzplan] # -grid_iini[1,:,:]
magx = np.sqrt(uu * uu + vv * vv + ww * ww)
# U = interpU_i[:, :, 0, 0]
# V = interpU_i[:, :, 1, 0]
# magu = np.sqrt(U * U + V * V)
# print grid_i[0, 5, :]- grid_iini[0, 5, :]
ax4.imshow(velpu[:, :, tranche, 0],
vmin=-0.05,
vmax=0.05,
cmap='jet',
aspect='auto')
ax5.imshow(velpv[:, :, tranche, 0],
vmin=-0.05,
vmax=0.05,
cmap='jet',
aspect='auto')
ax6.imshow(velpw[:, :, tranche, 0],
vmin=-0.05,
vmax=0.05,
cmap='jet',
aspect='auto')
# ax2.imshow(dispu[:,:,tranche-1]-dispu[:,:,tranche+1])
# ax3.imshow(dispu[:,:,tranche+1]-grid_iini[0,:,:,tranche+1])
# ax3.imshow(grid_i[2, :, :,zzplan])
# ax2.imshow(magx)
ax1.imshow(grid_i[0, :, :, tranche])
ax2.imshow(grid_i[1, :, :, tranche])
ax3.imshow(grid_i[2, :, :, tranche])
ax7.imshow(dphi[:, :, 0, 0])
# with file('test.txt', 'w') as outfile:
# np.savetxt(outfile, dphi[:, :, 0, 0])
ax8.imshow(dphi[:, :, 0, 1])
ax9.imshow(dphi[:, :, 1, 1])
# ax2.imshow(didy)
# ax3.quiver(X, Y, U, V, color=magu)
# ax4.streamplot(X, Y, uu, vv, density=0.6, color='k', linewidth=magx)
plt.show()
print '-------------------------'
print 'error', np.random.random_integers(0, 100)
print '-------------------------'
return eigval1, eigval3, eigvec1, eigvec3, interpU_i, bobol
import numpy as np
import tricubic
n = 3
f = np.zeros((n,n,n), dtype='float')
for i in range(n):
for j in range(n):
for k in range(n):
f[i][j][k] = i+j+k #some function f(x,y,z) is given on a cubic grid indexed by i,j,k
ip = tricubic.tricubic(list(f), [n,n,n]) #initialize interpolator with input data on cubic grid
for i in range(100000):
res = ip.ip(list(np.random.rand(3)*(n-1))) #interpolate the function f at a random point in space
#print res
def cgstki3(velp, zplan, tt, dt, nx, ny, nz, dim, domain, simtstep):
# x = np.arange(tt)
ttt = int(tt / dt)
ttt = np.arange(ttt)
# print ttt[0], ttt[-1]
n = len(ttt)
N = 25 # rk45 int step
integrator = 'dopri5' # ou dopri5 pour du dormant-prince rk45a-
rrk45 = 2 # 0=rk45, 1=heun, 2= euler
# small (so is your dick) vector d1(d1 0 0) d2(0 d2 0) d3(0 0 d3)
d1 = np.float(ConfigSectionMap('cauchygreen')['dx'])
d2 = d1
d3 = d2
# tranche = zplan # index de la tranche evaluee
integ = 'rk45'
# if doublegyre
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print 'WARING DOMAIN CUT FOR TEST PURPOSE'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'
# velp = velp[:, :60, :, :, :]
# ny = velp.shape[1]
#
# print 'velp shape'
# print velp.shape
# ptlist = np.indices((nx, ny, nz))
# ptlist = ptlist.astype(float)
domain = domain.astype(float)
dx = abs(domain[1] - domain[0]) / nx
dy = abs(domain[3] - domain[2]) / ny
dz = abs(domain[5] - domain[4]) / ny
print 'dx', dx
print 'dy', dy
print 'dz', dz
rr = 1
nnx = nx * rr
nny = ny * rr
nnz = nz * rr # pas de sous divisions sur z
ddx = dx / rr
ddy = dy / rr
ddz = dz / rr
zzplan = zplan * rr
print "domain:", domain
print 'zplan =', zplan # * ddz + domain[4]
tranche = int((zplan - domain[4]) / ((domain[5] - domain[4]) / nz))
print 'tranche evaluee %i' % tranche
print 'dt', dt, 't physique', tt, '# time steps', ttt
# interp spatiale sur une grille r fois plus fine
grid = np.indices((nnx, nny, nnz))
grid = grid.astype(float)
grid_i = np.empty((dim, nnx, nny, nnz))
grid_i[0, :, :] = grid[0]
grid_i[1, :, :] = grid[1]
grid_i[2, :, :] = grid[2]
# print grid_i
# grid_iini = np.zeros((dim, nnx, nny, nnz))
grid_iini = np.empty((dim, nnx, nny, nnz))
grid_iini[0, :, :] = grid[0]
grid_iini[1, :, :] = grid[1]
grid_iini[2, :, :] = grid[2]
print 'grind ini shape'
print grid_iini.shape
print 'interpolation over space, dx/ %i' % rr
if np.int(ver.full_version[2:4] < 14):
print 'scipy version %s 2 low. plz upgrade to 0.14.xx' % ver.full_version
quit()
else:
print 'scipy version %s is high, so am I' % ver.full_version
# x = np.linspace(0, nnx - 1, nnx, dtype=int16)
# y = np.linspace(0, nny - 1, nny, dtype=int16)
# z = np.linspace(0, nnz - 1, nnz, dtype=int16)
# t = np.linspace(0, len(ttt) - 1, len(ttt), dtype=int16)
velpu = velp[:, :, :, 0, :]
velpv = velp[:, :, :, 1, :]
velpw = velp[:, :, :, 2, :]
interpU_i = velp
stamp = time.time()
# def fu(x, y, z, t):
# return velpu[x, y, z, t]
#
# def fv(x, y, z, t):
# return velpv[x, y, z, t]
#
# def fw(x, y, z, t):
# return velpw[x, y, z, t]
#
# datau = fu(*np.meshgrid(x, y, z, t, indexing='ij', sparse=False))
# datav = fv(*np.meshgrid(x, y, z, t, indexing='ij', sparse=False))
# dataw = fw(*np.meshgrid(x, y, z, t, indexing='ij', sparse=False))
#
# interpu = RegularGridInterpolator((x, y, z, t), datau, method='nearest', bounds_error=False, fill_value=0)
# interpv = RegularGridInterpolator((x, y, z, t), datav, method='nearest', bounds_error=False, fill_value=0)
# interpw = RegularGridInterpolator((x, y, z, t), dataw, method='nearest', bounds_error=False, fill_value=0)
# quit()
print 'linear interp NOT from Scientific python'
print 'avection time !'
# eq dif => x point = v(x,t)
# ou: y point = f(x,t)
# fonction f:
nn = np.array([nnx, nny, nnz])
invddx = 1 / ddx
invddy = 1 / ddy
invddz = 1 / ddz
def f_u(yy, t):
coord = np.array([yy[0], yy[1], yy[2], t])
# a = np.array(
# [interpu(coord) * invddx, interpv(coord) * invddy, interpw(coord) * invddz])
u = ndimage.map_coordinates(velpu, [[yy[0]], [yy[1]], [yy[2]], [t]], order=3, mode='constant', cval=0.0, prefilter=False) * invddx
v = ndimage.map_coordinates(velpv, [[yy[0]], [yy[1]], [yy[2]], [t]], order=3, mode='constant', cval=0.0,
prefilter=False) * invddy
w = ndimage.map_coordinates(velpw, [[yy[0]], [yy[1]], [yy[2]], [t]], order=3, mode='constant', cval=0.0,
prefilter=False) * invddz
return np.array([u, v, w])[:, 0]
# print 'fu'. f_u()
solver = ode(f_u)
solver.set_integrator('dopri5', rtol=0.001, atol=1e-3)
t = np.linspace(0, tt, N)
bobol = np.zeros((nnx, nny))
if rrk45 == 0:
print 'rk45 intregration method, a checker'
toto = 0
quit()
for i in xrange(nnx):
for j in xrange(nny):
y0 = grid_iini[:, i, j, tranche]
# if np.all(np.abs(f_u(grid_i[:, i, j, tranche],0)) > np.array([1e-7,1e-7,1e-7])):
if np.all(np.abs(velp[i, j, tranche, :]) > np.array([1e-7, 1e-7, 1e-7])):
bobol[i, j] = True
grid_i[:, i, j, tranche], err = rk45(f_u, y0, t)[-1]
if np.max(err) > 1e-5:
print err, 'erreur d integ trop grande, my n***a'
else:
grid_i[:, i, j, k] = [0, 0, 0] # grid_i[:, i, j, tranche] = y0
# on en profite pour faire le mask!!!
toto += 1
print '%i point skipped, ie. %f percents of total points of the slice' % (toto, 100 * toto / (ny * nx))
elif rrk45 == 1:
print 'heun intregration method'
toto = 0
for i in xrange(nnx):
for j in xrange(nny):
for k in range(tranche - 2, tranche + 3):
y0 = grid_iini[:, i, j, k]
if np.all(np.abs(velp[i, j, k, :, 0]) > np.array([1e-7, 1e-7, 1e-7])):
bobol[i, j] = True
grid_i[:, i, j, k] = heun(f_u, y0, t, nx, ny)[-1]
else:
grid_i[:, i, j, k] = [0, 0, 0]
toto += 1
print '%i point skipped, ie. %f percents of total points of the slice' % (toto, 100 * toto / (ny * nx))
elif rrk45 == 2:
print 'euler intregration method'
toto = a = 0
print ('0 50 100%')
for i in xrange(nnx):
for j in xrange(nny):
for k in range(tranche - 0, tranche + 1):
y0 = grid_iini[:, i, j, k]
if np.all(np.abs(velp[i, j, k, :, 0]) > np.array([1e-7, 1e-7, 1e-7])):
bobol[i, j] = True
grid_i[:, i, j, k] = euler(f_u, y0, t)[-1]
else:
# grid_i[:, i, j, k] = [0, 0, 0]
toto += 1
a = 1. * i / nnx
if (100 * a) % 10 < 1e-3:
rpog()
print '\n %i point skipped, ie. %f percents of total points of the domain' % (toto, 100 * toto / (ny * nx * 5))
else:
print 'wut ?'
quit()
# else:
# print grid_i[:,35,24,37]
# print 'totototot'
# t = ttt
# t0 = t[0]
# t1 = 0.001#t[-1]
# i = j = 0
# for i in xrange(nnx):
# for j in xrange(nny):
# y0 = grid_i[:, i, j, tranche]
# solver.set_initial_value(y0, t0)
# sol = np.empty((N, 3))
# sol[0] = y0
# k = 1
# dt=1e-3
# while solver.successful() and solver.t < t1:
# solver.integrate(t[k])
# sol[k] = solver.y
# k += 1
# grid_i[:, i, j, tranche] = sol[-1, :]
print '-----------------------------------------------------'
print 'Velocity advected in %f s ' % (time.time() - stamp)
print '-----------------------------------------------------'
FTF = True
if FTF:
stamp = time.time()
# gradient of the flow map
# shadden method
# (u, v, w) sur (x, y)
dphi = np.empty((nnx, nny, 3, 3))
tricu = True
if tricu:
print 'tricubic interp'
du = tricubic.tricubic(list(grid_i[0, :, :, :]),
[nnx, nny, nnz]) # initialize interpolator with input data on cubic grid
dv = tricubic.tricubic(list(grid_i[1, :, :, :]),
[nnx, nny, nnz]) # initialize interpolator with input data on cubic grid
dw = tricubic.tricubic(list(grid_i[2, :, :, :]),
[nnx, nny, nnz]) # initialize interpolator with input data on cubic grid
tata = 0
print ('0 50 100%')
# 3d version haller ann. rev. fluid 2015
for i in range(1, nnx - 1):
for j in range(1, nny - 1):
# if np.all(np.abs(velp[i, j, k, :, 0]) > np.array([1e-7, 1e-7, 1e-7])):
if bobol[i, j]:
dphi[i, j, 0, 0] = (du.ip(list(np.array([i + d1, j, tranche]))) - du.ip(
list(np.array([i - d1, j, tranche])))) / (2 * d1)
dphi[i, j, 0, 1] = (du.ip(list(np.array([i, j + d2, tranche]))) - du.ip(
list(np.array([i, j - d2, tranche])))) / (2 * d2)
dphi[i, j, 0, 2] = (du.ip(list(np.array([i, j, tranche + d3]))) - du.ip(
list(np.array([i, j, tranche - d3])))) / (2 * d3)
dphi[i, j, 1, 0] = (dv.ip(list(np.array([i + d1, j, tranche]))) - dv.ip(
list(np.array([i - d1, j, tranche])))) / (2 * d1)
dphi[i, j, 1, 1] = (dv.ip(list(np.array([i, j + d2, tranche]))) - dv.ip(
list(np.array([i, j - d2, tranche])))) / (2 * d2)
dphi[i, j, 1, 2] = (dv.ip(list(np.array([i, j, tranche + d3]))) - dv.ip(
list(np.array([i, j, tranche - d3])))) / (2 * d3)
dphi[i, j, 2, 0] = (dw.ip(list(np.array([i + d1, j, tranche]))) - dw.ip(
list(np.array([i - d1, j, tranche])))) / (2 * d1)
dphi[i, j, 2, 1] = (dw.ip(list(np.array([i, j + d2, tranche]))) - dw.ip(
list(np.array([i, j - d2, tranche])))) / (2 * d2)
dphi[i, j, 2, 2] = (dw.ip(list(np.array([i, j, tranche + d3]))) - dw.ip(
list(np.array([i, j, tranche - d3])))) / (2 * d3)
else:
dphi[i, j, :, :] = np.zeros((3, 3))
tata += 1
a = 1. * i / nnx
if (100 * a) % 10 < 1e-3:
rpog()
print '\n', tata, ' skipped of,', nnx * nny
# bords a l arrache;
dphi[0, :, 0, 0] = dphi[1, :, 0, 0]
dphi[nnx - 1, :, 0, 0] = dphi[nnx - 2, :, 0, 0]
dphi[:, 0, 0, 0] = dphi[:, 1, 0, 0]
dphi[:, nny - 1, 0, 0] = dphi[:, nny - 2, 0, 0]
dphi[0, :, 0, 1] = dphi[1, :, 0, 1]
dphi[nnx - 1, :, 0, 1] = dphi[nnx - 2, :, 0, 1]
dphi[:, 0, 0, 1] = dphi[:, 1, 0, 0]
dphi[:, nny - 1, 0, 1] = dphi[:, nny - 2, 0, 1]
dphi[0, :, 1, 0] = dphi[1, :, 1, 0]
dphi[nnx - 1, :, 1, 0] = dphi[nnx - 2, :, 1, 0]
dphi[:, 0, 1, 0] = dphi[:, 1, 1, 0]
dphi[:, nny - 1, 1, 0] = dphi[:, nny - 2, 1, 0]
dphi[0, :, 1, 1] = dphi[1, :, 1, 1]
dphi[nnx - 1, :, 1, 1] = dphi[nnx - 2, :, 1, 1]
dphi[:, 0, 1, 1] = dphi[:, 1, 1, 1]
dphi[:, nny - 1, 1, 1] = dphi[:, nny - 2, 1, 1]
gdphi = np.empty((nnx, nny, 3, 3))
for i in xrange(nnx):
for j in xrange(nny):
gdphi[i, j, :, :] = np.dot(dphi[i, j, :, :].T, dphi[i, j, :, :])
else:
quit()
# axes = (xx, yy, zz)
# du = IF(axes, dispu)
# dv = IF(axes, dispv)
# dw = IF(axes, dispw)
#
# d1 = dx / 3
# d2 = dy / 3
# d3 = dz / 3
#
# # 3d version haller ann. rev. fluid 2015
# for i in range(1, nnx - 1):
# for j in range(1, nny - 1):
# # for k in range(1, nnz - 1):
# # ACHTUNG CALCUL 3D MAIS SEED 2D
# ii = i * ddx + domain[0]
# jj = j * ddy + domain[2]
# zzzplan = zplan * dz + domain[4]
# # print ii,jj,zzzplan
# # print
# # print ii, jj, zzzplan
#
# dphi[i, j, 0, 0] = (du(ii + d1, jj, zzzplan) - du(ii - d1, jj, zzzplan)) / (2 * d1)
# print dphi[i, j, 0, 0]
# dphi[i, j, 0, 1] = (du(ii, jj + d2, zzzplan) - du(ii, jj - d2, zzzplan)) / (2 * d2)
# dphi[i, j, 0, 2] = (du(ii, jj, zzzplan + d3) - du(ii, jj, zzzplan - d3)) / (2 * d3)
#
# dphi[i, j, 1, 0] = (dv(ii + d1, jj, zzzplan) - dv(ii - d1, jj, zzzplan)) / (2 * d1)
# dphi[i, j, 1, 1] = (dv(ii, jj + d2, zzzplan) - dv(ii, jj - d2, zzzplan)) / (2 * d2)
# dphi[i, j, 1, 2] = (dv(ii, jj, zzzplan + d3) - dv(ii, jj, zzzplan - d3)) / (2 * d3)
#
# dphi[i, j, 2, 0] = (dw(ii + d1, jj, zzzplan) - dw(ii - d1, jj, zzzplan)) / (2 * d1)
# dphi[i, j, 2, 1] = (dw(ii, jj + d2, zzzplan) - dw(ii, jj - d2, zzzplan)) / (2 * d2)
# dphi[i, j, 2, 2] = (dw(ii, jj, zzzplan + d3) - dw(ii, jj, zzzplan - d3)) / (2 * d3)
#
# print 'dphi[50,50,1,1]'
# print dphi[50, 50, 1, 1]
# # bords a l arrache;
# dphi[0, :, 0, 0] = dphi[1, :, 0, 0]
# dphi[nnx - 1, :, 0, 0] = dphi[nnx - 2, :, 0, 0]
# dphi[:, 0, 0, 0] = dphi[:, 1, 0, 0]
# dphi[:, nny - 1, 0, 0] = dphi[:, nny - 2, 0, 0]
#
# dphi[0, :, 0, 1] = dphi[1, :, 0, 1]
# dphi[nnx - 1, :, 0, 1] = dphi[nnx - 2, :, 0, 1]
# dphi[:, 0, 0, 1] = dphi[:, 1, 0, 0]
# dphi[:, nny - 1, 0, 1] = dphi[:, nny - 2, 0, 1]
#
# dphi[0, :, 1, 0] = dphi[1, :, 1, 0]
# dphi[nnx - 1, :, 1, 0] = dphi[nnx - 2, :, 1, 0]
# dphi[:, 0, 1, 0] = dphi[:, 1, 1, 0]
# dphi[:, nny - 1, 1, 0] = dphi[:, nny - 2, 1, 0]
#
# dphi[0, :, 1, 1] = dphi[1, :, 1, 1]
# dphi[nnx - 1, :, 1, 1] = dphi[nnx - 2, :, 1, 1]
# dphi[:, 0, 1, 1] = dphi[:, 1, 1, 1]
# dphi[:, nny - 1, 1, 1] = dphi[:, nny - 2, 1, 1]
#
# gdphi = np.empty((nnx, nny, 3, 3))
# for i in xrange(nnx):
# for j in xrange(nny):
# gdphi[i, j, :, :] = np.dot(dphi[i, j, :, :].T, dphi[i, j, :, :])
# print dphi.shape, dphi.T.shape,gdphi.shape
# toto=np.inner(dphi.T, dphi)
# print np.array_equal(gdphi,toto)
# print '------------------------'
eigenValues, eigenVectors = LA.eig(gdphi)
eigvec1 = np.empty((nnx, nny, 3))
eigvec3 = np.empty((nnx, nny, 3))
eigval1 = np.empty((nnx, nny))
eigval3 = np.empty((nnx, nny))
# print 'min,max,avg,stdev'
# a = eigenValues[:, :, 0] * eigenValues[:, :, 1] * eigenValues[:, :, 2]
# # print np.min(a)
# # print np.max(a)
# # print np.average(a)
# # print np.std(a)
# # print '{{{{{{'
for i in xrange(eigenValues.shape[0]):
for j in xrange(eigenValues.shape[1]):
eigval1[i, j] = np.min(eigenValues[i, j, :])
eigval3[i, j] = np.max(eigenValues[i, j, :])
eigvec1[i, j, :] = eigenVectors[i, j, :, np.argmin(eigenValues[i, j, :])]
eigvec3[i, j, :] = eigenVectors[i, j, :, np.argmax(eigenValues[i, j, :])]
# print eigvec3[i, j, :]
# toto = eigval3.astype(short)
# juliaStacked = np.dstack([toto])
# x = np.arange(0, nnx)
# y = np.arange(0, nny)
# z = np.arange(0, 2)
# gridToVTK("./julia", x, y, z, cellData = {'julia': juliaStacked})
print '-----------------------------------------------------'
print 'Flow map and eigval/eigvec computed in %f s ' % (time.time() - stamp)
print '-----------------------------------------------------'
# p1 = win.addPlot(title="Basic array plotting", y=np.random.normal(size=100))
f, ((ax1, ax2, ax3), (ax4, ax5, ax6), (ax7, ax8, ax9)) = plt.subplots(3, 3, sharex=True, sharey=True)
# print didx.shape
# Y, X = np.mgrid[0:nx * dx:rr * nx * 1j, 0:ny * dy:rr * ny * 1j]
uu = grid_i[0, :, :, zzplan] - grid_iini[0, :, :, zzplan] # -grid_iini[0,:,:]
vv = grid_i[1, :, :, zzplan] - grid_iini[1, :, :, zzplan] # -grid_iini[1,:,:]
ww = grid_i[2, :, :, zzplan] - grid_iini[2, :, :, zzplan] # -grid_iini[1,:,:]
magx = np.sqrt(uu * uu + vv * vv + ww * ww)
# U = interpU_i[:, :, 0, 0]
# V = interpU_i[:, :, 1, 0]
# magu = np.sqrt(U * U + V * V)
# print grid_i[0, 5, :]- grid_iini[0, 5, :]
ax4.imshow(velpu[:, :, tranche, 0], vmin=-0.05, vmax=0.05, cmap='jet', aspect='auto')
ax5.imshow(velpv[:, :, tranche, 0], vmin=-0.05, vmax=0.05, cmap='jet', aspect='auto')
ax6.imshow(velpw[:, :, tranche, 0], vmin=-0.05, vmax=0.05, cmap='jet', aspect='auto')
# ax2.imshow(dispu[:,:,tranche-1]-dispu[:,:,tranche+1])
# ax3.imshow(dispu[:,:,tranche+1]-grid_iini[0,:,:,tranche+1])
# ax3.imshow(grid_i[2, :, :,zzplan])
# ax2.imshow(magx)
ax1.imshow(grid_i[0, :, :, tranche])
ax2.imshow(grid_i[1, :, :, tranche])
ax3.imshow(grid_i[2, :, :, tranche])
ax7.imshow(dphi[:, :, 0, 0])
# with file('test.txt', 'w') as outfile:
# np.savetxt(outfile, dphi[:, :, 0, 0])
ax8.imshow(dphi[:, :, 0, 1])
ax9.imshow(dphi[:, :, 1, 1])
# ax2.imshow(didy)
# ax3.quiver(X, Y, U, V, color=magu)
# ax4.streamplot(X, Y, uu, vv, density=0.6, color='k', linewidth=magx)
plt.show()
print '-------------------------'
print 'error', np.random.random_integers(0, 100)
print '-------------------------'
return eigval1, eigval3, eigvec1, eigvec3, interpU_i, bobol
