def constants():
from pencil.files import pdim
npar = pdim.read_pdim().npar
# Get grid dimensions
from pencil.files import dim
nx = dim.read_dim().nx
ny = dim.read_dim().ny
nz = dim.read_dim().nz
# Get parameters:
par = pc.read_param(datadir=datadir)
cs0 = par.cs0
pd = par.dustdensity_powerlaw
pg = par.density_power_law
eps0 = par.eps_dtog
# Box size:
from pencil.files import grid
Lx = grid.read_grid().Lx
Ly = grid.read_grid().Ly
Lz = grid.read_grid().Lz
r_int = round(np.amin(grid.read_grid().x), 1)
r_ext = round(np.amax(grid.read_grid().x), 1)
fname = 'constants'
fsave = np.savez_compressed(os.path.join(path_dir,fname), npar=npar,
nx=nx, ny=ny, nz=nz, cs0=cs0, pd=pd, pg=pg, eps0=eps0,
Lx = Lx, Ly = Ly, Lz = Lz, r_int = r_int, r_ext = r_ext)
xyzname = 'xyz'
fsave = np.savez_compressed(os.path.join(path_dir, xyzname), r=ff.x, phi=ff.y, z=ff.z)
def read_power(file):
"""
29-apr-2009/dintrans: coded
t,dat=read_power(name_power_file)
Read a power spectra file like 'data/poweru.dat'
"""
infile = open(file, 'r')
lines = infile.readlines()
infile.close()
#
# find the number of blocks (t,power) that should be read
#
dim=read_dim()
nblock=len(lines)/(dim.nxgrid/2/8+1)
#
infile = open(file, 'r')
t=N.zeros(1, dtype='Float32')
data=N.zeros(1, dtype='Float32')
for i in range(nblock):
st=infile.readline()
t=N.append(t, float(st))
for ii in range(dim.nxgrid/2/8):
st=infile.readline()
data=N.append(data, N.asarray(st.split()).astype('f'))
infile.close()
t=t[1:] ; data=data[1:]
nt=len(t) ; nk=len(data)/nt
data=data.reshape(nt, nk)
return t, data
def xder_6th(f,dx,x=[],y=[],z=[],param=[],dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if not param:
param=read_param(quiet=True)
if not dim:
dim=read_dim()
if len(x) < 1:
gd = read_grid(quiet=True)
x = gd.x
dx=N.gradient(x)
if (dim.nx!=1):
dx2 = 1./(60.*dx)
dfdx = N.zeros_like(f)
l1 = 3
l2 = f.shape[-1]-3
if (l2 > l1 and dim.nx!=1):
for l in range(l1,l2):
dfdx[...,l] = dx2[l]*( +45.*(f[...,l+1]-f[...,l-1])
-9.*(f[...,l+2]-f[...,l-2])
+ (f[...,l+3]-f[...,l-3]) )
else:
dfdx = 0.
return dfdx
def xder2_6th(f,dx,x=[],y=[],z=[],param=[],dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if not param:
param=read_param(quiet=True)
if not dim:
dim=read_dim()
dx = N.gradient(x)
if (dim.nx!=1):
dx2 = 1./(180.*dx**2.)
dfdx = N.zeros_like(f)
l1 = 3
l2 = f.shape[-1]-3
if (l2 > l1 and dim.nx!=1):
for l in range(l1,l2):
dfdx[...,l] = dx2[l]*(-490.* f[...,l]
+270.*(f[...,l-1]+f[...,l+1])
- 27.*(f[...,l-2]+f[...,l+2])
+ 2.*(f[...,l-3]+f[...,l+3]) )
else:
dfdx = 0.
return dfdx
def read_rmv_par(datadir='data/', dims=[], pdims=[], read_parameters = True):
"""
Read both rmv_ipar.dat and rmv_par.dat to gain information about
particles removed in the simulation.
Keyword arguments:
*datadir*
Directory containing simulation results
*dims*
Object from read_dim()
*pdims*
Object from read_pdim()
*read_parameters*: [ True | False ]
Specify whether dims and pdims should be read or not
"""
# Read parameter files if specified
if(read_parameters):
dims = read_dim()
pdims = read_pdim()
# Read files and return object
return fetch_particle_data(datadir, dims, pdims)
def xder_6th(f, dx, x=[], y=[], z=[], param=[], dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if not param:
param = read_param(quiet=True)
if not dim:
dim = read_dim()
if len(x) < 1:
gd = read_grid(quiet=True)
x = gd.x
dx = N.gradient(x)
if (dim.nx != 1):
dx2 = 1. / (60. * dx)
dfdx = N.zeros_like(f)
l1 = 3
l2 = f.shape[-1] - 3
if (l2 > l1 and dim.nx != 1):
for l in range(l1, l2):
dfdx[...,
l] = dx2[l] * (+45. * (f[..., l + 1] - f[..., l - 1]) - 9. *
(f[..., l + 2] - f[..., l - 2]) +
(f[..., l + 3] - f[..., l - 3]))
else:
dfdx = 0.
return dfdx
def read_power(file, datadir='data/'):
"""
29-apr-2009/dintrans: coded
t,dat=read_power(name_power_file)
Read a power spectra file like 'data/poweru.dat'
"""
filename = path.join(datadir, file)
infile = open(filename, 'r')
lines = infile.readlines()
infile.close()
#
# find the number of blocks (t,power) that should be read
#
dim=read_dim(datadir=datadir)
nblock=int(len(lines)/int(N.ceil(dim.nxgrid/2/8.)+1))
#
with open(filename, 'r') as infile:
t=N.zeros(1, dtype='Float32')
data=N.zeros(1, dtype='Float32')
for i in range(nblock):
st=infile.readline()
t=N.append(t, float(st))
for ii in range(int(N.ceil(dim.nxgrid/2/8.))):
st=infile.readline()
data=N.append(data, N.asarray(st.split()).astype('f'))
t=t[1:] ; data=data[1:]
nt=len(t) ; nk=int(len(data)/nt)
data=data.reshape(nt, nk)
return t, data
def read_power(file):
"""
29-apr-2009/dintrans: coded
t,dat=read_power(name_power_file)
Read a power spectra file like 'data/poweru.dat'
"""
infile = open(file, 'r')
lines = infile.readlines()
infile.close()
#
# find the number of blocks (t,power) that should be read
#
dim = read_dim()
nblock = len(lines) / (dim.nxgrid / 2 / 8 + 1)
#
infile = open(file, 'r')
t = N.zeros(1, dtype='Float32')
data = N.zeros(1, dtype='Float32')
for i in range(nblock):
st = infile.readline()
t = N.append(t, float(st))
for ii in range(dim.nxgrid / 2 / 8):
st = infile.readline()
data = N.append(data, N.asarray(st.split()).astype('f'))
infile.close()
t = t[1:]
data = data[1:]
nt = len(t)
nk = len(data) / nt
data = data.reshape(nt, nk)
return t, data
def yder_6th(f, dy, x=[], y=[], z=[], param=[], dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if not param:
param = read_param(quiet=True)
if not dim:
dim = read_dim()
dy = N.gradient(y)
if (dim.ny != 1):
dy2 = 1. / (60. * dy)
dfdy = N.zeros_like(f)
m1 = 3
m2 = f.shape[-2] - 3
if (m2 > m1 and dim.ny != 1):
for m in range(m1, m2):
dfdy[...,
m, :] = dy2[m] * (+45. *
(f[..., m + 1, :] - f[..., m - 1, :]) - 9. *
(f[..., m + 2, :] - f[..., m - 2, :]) +
(f[..., m + 3, :] - f[..., m - 3, :]))
else:
dfdy = 0.
if param.coord_system == ('cylindric' or 'spherical'):
if len(x) < 1:
gd = read_grid(quiet=True)
x = gd.x
dfdy /= x
return dfdy
def read_rmv_par(datadir='data/', dims=[], pdims=[], read_parameters=True):
"""
Read both rmv_ipar.dat and rmv_par.dat to gain information about
particles removed in the simulation.
Keyword arguments:
*datadir*
Directory containing simulation results
*dims*
Object from read_dim()
*pdims*
Object from read_pdim()
*read_parameters*: [ True | False ]
Specify whether dims and pdims should be read or not
"""
# Read parameter files if specified
if (read_parameters):
dims = read_dim()
pdims = read_pdim()
# Read files and return object
return fetch_particle_data(datadir, dims, pdims)
def div(f,dx,dy,dz,x=[],y=[],z=[],param=[],dim=[]):
"""
take divergence of pencil code vector array
"""
if (f.ndim != 4):
print("div: must have vector 4-D array f[mvar,mz,my,mx] for divergence")
raise ValueError
if not param:
param = read_param(quiet=True)
if not dim:
dim = read_dim()
gd = read_grid(quiet=True, param=param)
if len(x) < 1:
x = gd.x
y = gd.y
z = gd.z
div = xder(f[0,...],dx,x=x,y=y,z=z,param=param,dim=dim) +\
yder(f[1,...],dy,x=x,y=y,z=z,param=param,dim=dim) +\
zder(f[2,...],dz,x=x,y=y,z=z,param=param,dim=dim)
if param.coord_system == 'cylindric':
div += f[0,...]/x
if param.coord_system == 'spherical':
sin_y = N.sin(y)
cos_y = N.cos(y)
i_sin = N.where(N.abs(sin_y) < 1e-5)[0]
if i_sin.size > 0:
cos_y[i_sin] = 0.; sin_y[i_sin] = 1
x_1, cotth = N.meshgrid(1./gd.x, cos_y/sin_y)
div += 2*f[0,...]*x_1 + f[1,...]*x_1*cotth
return div
def read_power(file):
"""
29-apr-2009/dintrans: coded
t,dat=read_power(name_power_file)
Read a power spectra file like 'data/poweru.dat'
"""
infile = open(file, 'r')
lines = infile.readlines()
infile.close()
#
# find the number of blocks (t,power) that should be read
#
dim=read_dim()
#nblock=len(lines)/int(N.ceil(dim.nxgrid/2/8.)+1) # Python 2 integer division
nblock=int(len(lines)/int(N.ceil(int(dim.nxgrid/2)/8.)+1))
#
infile = open(file, 'r')
t=N.zeros(1, dtype='Float32')
data=N.zeros(1, dtype='Float32')
for i in range(nblock):
st=infile.readline()
t=N.append(t, float(st))
#for ii in range(int(N.ceil(dim.nxgrid/2/8.))): # Python 2 integer division
for ii in range(int(N.ceil(int(dim.nxgrid/2)/8.))):
st=infile.readline()
data=N.append(data, N.asarray(st.split()).astype('f'))
infile.close()
t=t[1:] ; data=data[1:]
#nt=len(t) ; nk=len(data)/nt # Python 2 integer division
nt=len(t) ; nk=int(len(data)/nt)
data=data.reshape(nt, nk)
return t, data
def laplacian(f,dx,dy,dz,x=[],y=[],z=[],param=[],dim=[]):
"""
take the laplacian of a pencil code scalar array
"""
if not param:
param = read_param(quiet=True)
if not dim:
dim = read_dim()
if len(x) < 1:
gd = read_grid(quiet=True)
x = gd.x
y = gd.y
z = gd.z
laplacian = N.empty(f.shape)
laplacian = xder2(f,dx,x=x,y=y,z=z,param=param,dim=dim) +\
yder2(f,dy,x=x,y=y,z=z,param=param,dim=dim) +\
zder2(f,dz,x=x,y=y,z=z,param=param,dim=dim)
if param.coord_system == 'cylindric':
laplacian += xder(f,dx,x=x,y=y,z=z,param=param,dim=dim)/x
if param.coord_system == 'spherical':
sin_y = N.sin(y)
cos_y = N.cos(y)
i_sin = N.where(N.abs(sin_y) < 1e-5)[0]
if i_sin.size > 0:
cos_y[i_sin] = 0.; sin_y[i_sin] = 1
x_2, cotth = N.meshgrid(1./x**2, cos_y/sin_y)
laplacian += 2*xder(f,dx,x=x,y=y,z=z,param=param,dim=dim)/x +\
yder(f,dy,x=x,y=y,z=z,param=param,dim=dim)*x_2*cotth
return laplacian
def xder2_6th(f, dx, x=[], y=[], z=[], param=[], dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if not param:
param = read_param(quiet=True)
if not dim:
dim = read_dim()
dx = N.gradient(x)
if (dim.nx != 1):
dx2 = 1. / (180. * dx**2.)
dfdx = N.zeros_like(f)
l1 = 3
l2 = f.shape[-1] - 3
if (l2 > l1 and dim.nx != 1):
for l in range(l1, l2):
dfdx[..., l] = dx2[l] * (-490. * f[..., l] + 270. *
(f[..., l - 1] + f[..., l + 1]) - 27. *
(f[..., l - 2] + f[..., l + 2]) + 2. *
(f[..., l - 3] + f[..., l + 3]))
else:
dfdx = 0.
return dfdx
def yder_6th(f,dy,x=[],y=[],z=[],param=[],dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if not param:
param=read_param(quiet=True)
if not dim:
dim=read_dim()
if len(y) < 1:
gd = read_grid(quiet=True)
y = gd.y
dy=N.gradient(y)
if (dim.ny!=1):
dy2 = 1./(60.*dy)
dfdy = N.zeros_like(f)
m1 = 3
m2 = f.shape[-2]-3
if (m2 > m1 and dim.ny != 1):
for m in range(m1,m2):
dfdy[...,m,:] = dy2[m]*( +45.*(f[...,m+1,:]-f[...,m-1,:])
-9.*(f[...,m+2,:]-f[...,m-2,:])
+ (f[...,m+3,:]-f[...,m-3,:]) )
else:
dfdy = 0.
if param.coord_system == ('cylindric' or 'spherical'):
if len(x) < 1:
gd=read_grid(quiet=True)
x=gd.x
dfdy /= x
return dfdy
def zder_6th(f, dz, x=[], y=[], z=[], run2D=False, param=[], dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if not param:
param = read_param(quiet=True)
if not dim:
dim = read_dim()
if len(z) < 1:
gd = read_grid(quiet=True)
z = gd.z
dz = N.gradient(z)
if (dim.nz != 1):
dz2 = 1. / (60. * dz)
dfdz = N.zeros_like(f)
n1 = 3
if run2D:
n2 = f.shape[1] - 3
else:
n2 = f.shape[-3] - 3
if (n2 > n1 and dim.nz != 1):
if (run2D):
# f[...,z,x] or f[...,z,y]
for n in range(n1, n2):
dfdz[...,
n, :] = dz2[n] * (+45. *
(f[..., n + 1, :] - f[..., n - 1, :]) -
9. *
(f[..., n + 2, :] - f[..., n - 2, :]) +
(f[..., n + 3, :] - f[..., n - 3, :]))
else:
# f[...,z,y,x]
for n in range(n1, n2):
dfdz[..., n, :, :] = dz2[n] * (
+45. * (f[..., n + 1, :, :] - f[..., n - 1, :, :]) - 9. *
(f[..., n + 2, :, :] - f[..., n - 2, :, :]) +
(f[..., n + 3, :, :] - f[..., n - 3, :, :]))
else:
dfdz = 0
if param.coord_system == 'spherical':
if (len(x) or len(y)) < 1:
gd = read_grid(quiet=True)
x = gd.x
y = gd.y
sin_y = N.sin(y)
siny1 = 1. / sin_y
i_sin = N.where(N.abs(sin_y) < 1e-5)[0]
if i_sin.size > 0:
siny1[i_sin] = 0.
x_1, sin1th = N.meshgrid(1. / x, siny1)
dfdz *= x_1 * sin1th
return dfdz
def read_slices(field='uu1',
datadir='data',
proc=-1,
extension='xz',
format='native',
oldfile=False):
"""
Read 2D slice files and return an array of (nslices, vsize, hsize).
"""
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = join(datadir, 'slice_' + field + '.' + extension)
else:
filename = join(datadir, 'proc' + str(proc),
'slice_' + field + '.' + extension)
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension.startswith('xy'):
hsize = dim.nx
vsize = dim.ny
if extension.startswith('xz'):
hsize = dim.nx
vsize = dim.nz
if extension.startswith('yz'):
hsize = dim.ny
vsize = dim.nz
infile = npfile(filename, endian=format)
islice = 0
t = np.zeros(1, dtype=precision)
slices = np.zeros(1, dtype=precision)
while True:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = np.concatenate((t, raw_data[-1:]))
slices = np.concatenate((slices, raw_data[:-1]))
else:
t = np.concatenate((t, raw_data[-2:-1]))
slices = np.concatenate((slices, raw_data[:-2]))
islice += 1
output = slices[1:].reshape(islice, vsize, hsize)
return output, t[1:]
def curl(f,dx,dy,dz,x=[],y=[],z=[],run2D=False,param=[],dim=[]):
"""
take the curl of a pencil code vector array.
23-fev-2009/dintrans+morin: introduced the run2D parameter to deal
with pure 2-D snapshots (solved the (x,z)-plane pb)
"""
if (f.shape[0] != 3):
print("curl: must have vector 4-D array f[3,mz,my,mx] for curl")
raise ValueError
if not param:
param = read_param(quiet=True)
if not dim:
dim = read_dim()
if len(x) < 1:
gd = read_grid(quiet=True, param=param)
x = gd.x
y = gd.y
z = gd.z
curl = N.empty_like(f)
if (not(run2D)):
# 3-D case
curl[0,...] = yder(f[2,...],dy,x=x,y=y,z=z,param=param,dim=dim) -\
zder(f[1,...],dz,x=x,y=y,z=z,param=param,dim=dim)
curl[1,...] = zder(f[0,...],dz,x=x,y=y,z=z,param=param,dim=dim) -\
xder(f[2,...],dx,x=x,y=y,z=z,param=param,dim=dim)
curl[2,...] = xder(f[1,...],dx,x=x,y=y,z=z,param=param,dim=dim) -\
yder(f[0,...],dy,x=x,y=y,z=z,param=param,dim=dim)
elif (dim.ny == 1):
# 2-D case in the (x,z)-plane
# f[...,nz,1,nx] if run2D=False or f[...,nz,nx] if run2D=True
curl[0,...] = zder(f,dz,x=x,y=y,z=z,run2D=run2D,param=param, \
dim=dim)[0,...] - xder(f,dx,x=x,y=y,z=z,param=param,dim=dim)[2,...]
elif (dim.nz ==1):
# 2-D case in the (x,y)-plane
# f[...,1,ny,nx] if run2D=False or f[...,ny,nx] if run2D=True
curl[0,...] = xder(f,dx,x=x,y=y,z=z,param=param,dim=dim)[1,...] -\
yder(f,dy,x=x,y=y,z=z,param=param,dim=dim)[0,...]
if param.coord_system == 'cylindric':
# 2-D case in the (r,theta)-plane
if run2D:
curl[0,...] += f[1,...]/x
else:
# 3-D case
curl[2,...] += f[1,...]/x
if param.coord_system == 'spherical':
sin_y = N.sin(y)
cos_y = N.cos(y)
i_sin = N.where(N.abs(sin_y) < 1e-5)[0]
if i_sin.size > 0:
cos_y[i_sin] = 0.; sin_y[i_sin] = 1
x_1, cotth = N.meshgrid(1./x, cos_y/sin_y)
curl[0,...] += f[2,...]*x_1*cotth
curl[1,...] -= f[2,...]/x
curl[2,...] += f[1,...]/x
return curl
def read_yaver(datadir='data/',format='native',point=(-1,-1)):
"""read 2D yaverage.dat file.
point -- an array of 2-tuples (iz,ix) representing discrete
points to be returned in an output array (not implemented yet)
returns a tuple (yavg, t), yavg has shape (noutputs,nvars,nz,nx)
"""
datadir = os.path.expanduser(datadir)
datatopdir = re.sub('data\/*$','',datadir)
filename = datadir+'/yaverages.dat'
# which variables are averaged?
infile = open(datatopdir+'yaver.in')
variables = [line.strip() for line in infile.readlines()]
infile.close()
# global dim
dim = read_dim(datadir)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
infile = npfile(filename,endian=format)
t = N.zeros(1,dtype=precision)
yaver = []
yaver_shape = (len(variables),dim.nz,dim.nx)
ntime = 0
while 1:
try:
raw_data = infile.fort_read(precision,shape=1)
except ValueError:
break
except TypeError:
break
t = N.concatenate((t,raw_data))
try:
raw_data = infile.fort_read(precision,shape=yaver_shape)
except ValueError:
#print "Problem: seems there is a t without corresponding data. yaverages.dat may be corrupted" # Python 2
print("Problem: seems there is a t without corresponding data. yaverages.dat may be corrupted")
break
except TypeError:
#print "Problem: seems there is a t without corresponding data. yaverages.dat may be corrupted" # Python 2
print("Problem: seems there is a t without corresponding data. yaverages.dat may be corrupted")
break
yaver.append(raw_data)
ntime += 1
output = N.array(yaver)
return output,t[1:]
def read_slices(field='uu1', datadir='data', proc=-1,
extension='xz', format='native', oldfile=False):
"""
Read 2D slice files and return an array of (nslices, vsize, hsize).
"""
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = join(datadir, 'slice_' + field + '.' + extension)
else:
filename = join(datadir, 'proc' + str(proc),
'slice_' + field + '.' + extension)
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension.startswith('xy'):
hsize = dim.nx
vsize = dim.ny
if extension.startswith('xz'):
hsize = dim.nx
vsize = dim.nz
if extension.startswith('yz'):
hsize = dim.ny
vsize = dim.nz
infile = npfile(filename, endian=format)
islice = 0
t = np.zeros(1, dtype=precision)
slices = np.zeros(1, dtype=precision)
while True:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = np.concatenate((t, raw_data[-1:]))
slices = np.concatenate((slices, raw_data[:-1]))
else:
t = np.concatenate((t, raw_data[-2:-1]))
slices = np.concatenate((slices, raw_data[:-2]))
islice += 1
output = slices[1:].reshape(islice, vsize, hsize)
return output, t[1:]
def zder_6th(f,dz,x=[],y=[],z=[],run2D=False,param=[],dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if not param:
param=read_param(quiet=True)
if not dim:
dim=read_dim()
if len(z) < 1:
gd = read_grid(quiet=True)
z = gd.z
dz=N.gradient(z)
if (dim.nz!=1):
dz2 = 1./(60.*dz)
dfdz = N.zeros_like(f)
n1 = 3
if run2D:
n2 = f.shape[1]-3
else:
n2 = f.shape[-3]-3
if (n2 > n1 and dim.nz!=1):
if (run2D):
# f[...,z,x] or f[...,z,y]
for n in range(n1,n2):
dfdz[...,n,:] = dz2[n]*(+45.*(f[...,n+1,:]-f[...,n-1,:])
-9.*(f[...,n+2,:]-f[...,n-2,:])
+(f[...,n+3,:]-f[...,n-3,:]) )
else:
# f[...,z,y,x]
for n in range(n1,n2):
dfdz[...,n,:,:] = dz2[n]*(+45.*(f[...,n+1,:,:]-f[...,n-1,:,:])
-9.*(f[...,n+2,:,:]-f[...,n-2,:,:])
+(f[...,n+3,:,:]-f[...,n-3,:,:]) )
else:
dfdz=0
if param.coord_system == 'spherical':
if (len(x) or len(y)) < 1:
gd=read_grid(quiet=True)
x=gd.x; y=gd.y
sin_y = N.sin(y)
siny1 = 1./sin_y
i_sin = N.where(N.abs(sin_y) < 1e-5)[0]
if i_sin.size > 0:
siny1[i_sin] = 0.
x_1, sin1th = N.meshgrid(1./x, siny1)
dfdz *= x_1*sin1th
return dfdz
def read_xyaver(varfile='xyaverages.dat',datadir='data/', quiet=0):
"""read xy averaged data.
returns a class xyaver containing a 1D time array and a 2D t-z array.
"""
datadir = os.path.expanduser(datadir)
dim = read_dim(datadir=datadir)
nz = dim.nz
datatopdir = re.sub('data\/*$','',datadir)
infile = open(datatopdir+'xyaver.in')
variables = [line.strip() for line in infile.readlines()]
infile.close()
#gotta be a better way to do this...
n_lines = int(check_output('wc '+datadir+'/'+varfile).split()[0])
datafile = open(datadir+'/'+varfile)
n_vars = len(variables)
# each line of data has 8 values
rec_length = 1 + int(n_vars*nz/8) # integer division?
if nz%8:
rec_length += 1
n_data_records = int(n_lines/rec_length) # integer division?
if (not quiet):
#print "%s: reading %i records" % (__name__,n_data_records) # Python 2
print(__name__ + ": reading {0} records".format(n_data_records))
# change the hardcode dtype!
t = []
var_tmp = dict(zip(variables,[[] for var in variables]))
for i in range(n_data_records):
t.extend(N.fromfile(datafile,dtype='float32',count=1,sep=' '))
for var in variables:
var_tmp[var].append(N.fromfile(datafile,
dtype='float32',count=nz,sep=' '))
datafile.close()
#pack data into a class
xyaver = XyAver()
xyaver.t = N.array(t)
for var in variables:
setattr(xyaver,var,N.array(var_tmp[var]))
return xyaver
def read_xyaver(varfile='xyaverages.dat', datadir='data/', quiet=0):
"""read xy averaged data.
returns a class xyaver containing a 1D time array and a 2D t-z array.
"""
datadir = os.path.expanduser(datadir)
dim = read_dim(datadir=datadir)
nz = dim.nz
datatopdir = re.sub('data\/*$', '', datadir)
infile = open(datatopdir + 'xyaver.in')
variables = [line.strip() for line in infile.readlines()]
infile.close()
#gotta be a better way to do this...
n_lines = int(check_output(["wc", datadir + '/' + varfile]).split()[0])
datafile = open(datadir + '/' + varfile)
n_vars = len(variables)
# each line of data has 8 values
rec_length = 1 + int(n_vars * nz / 8) # integer division?
if nz % 8:
rec_length += 1
n_data_records = int(n_lines / rec_length) # integer division?
if (not quiet):
#print "%s: reading %i records" % (__name__,n_data_records) # Python 2
print(__name__ + ": reading {0} records".format(n_data_records))
# change the hardcode dtype!
t = []
var_tmp = dict(zip(variables, [[] for var in variables]))
for i in range(n_data_records):
t.extend(N.fromfile(datafile, dtype='float32', count=1, sep=' '))
for var in variables:
var_tmp[var].append(
N.fromfile(datafile, dtype='float32', count=nz, sep=' '))
datafile.close()
#pack data into a class
xyaver = XyAver()
xyaver.t = N.array(t)
for var in variables:
setattr(xyaver, var, N.array(var_tmp[var]))
return xyaver
def zder2_6th(f, dz, x=[], y=[], z=[], param=[], dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if (len(z) < 1):
gd = read_grid(quiet=True)
z = gd.z
if not param:
param = read_param(quiet=True)
if not dim:
dim = read_dim()
dz = N.gradient(z)
if (dim.nz != 1):
dz2 = 1. / (180. * dz**2.)
dfdz = N.zeros_like(f)
n1 = 3
n2 = f.shape[-3] - 3
if (n2 > n1 and dim.nz != 1):
for n in range(n1, n2):
dfdz[..., n, :, :] = dz2[n] * (
-490. * f[..., n, :, :] + 270. *
(f[..., n - 1, :, :] + f[..., n + 1, :, :]) - 27. *
(f[..., n - 2, :, :] + f[..., n + 2, :, :]) + 2. *
(f[..., n - 3, :, :] + f[..., n + 3, :, :]))
else:
dfdz = 0.
if param.coord_system == 'spherical':
if (len(x) or len(y)) < 1:
gd = read_grid(quiet=True)
x = gd.x
y = gd.y
sin_y = N.sin(y)
siny1 = 1. / sin_y
i_sin = N.where(N.abs(sin_y) < 1e-5)[0]
if i_sin.size > 0:
siny1[i_sin] = 0.
x_2, sin2th = N.meshgrid(1. / x**2, siny1**2)
dfdz *= x_2 * sin2th
return dfdz
def zder2_6th(f,dz,x=[],y=[],z=[],param=[],dim=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
if (len(z) < 1):
gd=read_grid(quiet=True)
z=gd.z
if not param:
param=read_param(quiet=True)
if not dim:
dim=read_dim()
dz = N.gradient(z)
if (dim.nz!=1):
dz2 = 1./(180.*dz**2.)
dfdz = N.zeros_like(f)
n1 = 3
n2 = f.shape[-3]-3
if (n2 > n1 and dim.nz!=1):
for n in range(n1,n2):
dfdz[...,n,:,:] = dz2[n]*(-490.* f[...,n,:,:]
+270.*(f[...,n-1,:,:]+f[...,n+1,:,:])
- 27.*(f[...,n-2,:,:]+f[...,n+2,:,:])
+ 2.*(f[...,n-3,:,:]+f[...,n+3,:,:]) )
else:
dfdz = 0.
if param.coord_system == 'spherical':
if (len(x) or len(y)) < 1:
gd=read_grid(quiet=True)
x=gd.x; y=gd.y
sin_y = N.sin(y)
siny1 = 1./sin_y
i_sin = N.where(N.abs(sin_y) < 1e-5)[0]
if i_sin.size > 0:
siny1[i_sin] = 0.
x_2, sin2th = N.meshgrid(1./x**2, siny1**2)
dfdz *= x_2*sin2th
return dfdz
def xder6_6th(f,dx,x=[],y=[],z=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
l1 = 3
l2 = f.shape[-1] - 3
dx = N.gradient(x)
if (dim.nx!=1):
fac=1/dx**6
d6fdx = N.zeros_like(f)
dim=read_dim()
if (l2 > l1 and dim.nx!=1):
for l in range(l1,l2):
d6fdx[...,l] = fac[l]*( - 20.0* f[...,l]
+ 15.0*(f[...,l+1]+f[...,l-1])
- 6.0*(f[...,l+2]+f[...,l-2])
+ (f[...,l+3]+f[...,l-3]))
return d6fdx
def xder6_6th(f, dx, x=[], y=[], z=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
l1 = 3
l2 = f.shape[-1] - 3
dx = N.gradient(x)
if (dim.nx != 1):
fac = 1 / dx**6
d6fdx = N.zeros_like(f)
dim = read_dim()
if (l2 > l1 and dim.nx != 1):
for l in range(l1, l2):
d6fdx[..., l] = fac[l] * (-20.0 * f[..., l] + 15.0 *
(f[..., l + 1] + f[..., l - 1]) - 6.0 *
(f[..., l + 2] + f[..., l - 2]) +
(f[..., l + 3] + f[..., l - 3]))
return d6fdx
def zder6_6th(f,dz,x=[],y=[],z=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
n1 = 3
n2 = f.shape[-3] - 3
dz = N.gradient(z)
if (dim.nz!=1):
fac=1/dz**6
d6fdz = N.zeros_like(f)
dim = read_dim()
if (n2 > n1 and dim.nz!=1):
for n in range(n1,n2):
d6fdz[...,n,:,:] = fac[n]*(- 20.0* f[...,n,:,:]
+ 15.0*(f[...,n+1,:,:]+f[...,n-1,:,:])
- 6.0*(f[...,n+2,:,:]+f[...,n-2,:,:])
+ (f[...,n+3,:,:]+f[...,n-3,:,:]))
return d6fdz
def yder6_6th(f,dy,x=[],y=[],z=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
m1 = 3
m2 = f.shape[-2] - 3
dy = N.gradient(y)
if (dim.ny!=1):
fac=1/dy**6
d6fdy = N.zeros_like(f)
dim=read_dim()
if (m2 > m1 and dim.ny!=1):
for m in range(m1,m2):
d6fdy[...,m1:m2,:] = fac[m]*(- 20.0* f[...,m,:]
+ 15.0*(f[...,m+1,:]+f[...,m-1,:])
- 6.0*(f[...,m+2,:]+f[...,m-2,:])
+ (f[...,m+3,:]+f[...,m-3,:]))
return d6fdy
def zder6_6th(f, dz, x=[], y=[], z=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
n1 = 3
n2 = f.shape[-3] - 3
dz = N.gradient(z)
if (dim.nz != 1):
fac = 1 / dz**6
d6fdz = N.zeros_like(f)
dim = read_dim()
if (n2 > n1 and dim.nz != 1):
for n in range(n1, n2):
d6fdz[..., n, :, :] = fac[n] * (
-20.0 * f[..., n, :, :] + 15.0 *
(f[..., n + 1, :, :] + f[..., n - 1, :, :]) - 6.0 *
(f[..., n + 2, :, :] + f[..., n - 2, :, :]) +
(f[..., n + 3, :, :] + f[..., n - 3, :, :]))
return d6fdz
def grad(f,dx,dy,dz,x=[],y=[],z=[],param=[],dim=[]):
"""
take the gradient of a pencil code scalar array.
"""
if (f.ndim != 3):
print("grad: must have scalar 3-D array f[mz,my,mx] for gradient")
raise ValueError
if not param:
param=read_param(quiet=True)
if not dim:
dim=read_dim()
if len(x) < 1:
gd = read_grid(quiet=True)
x = gd.x
y = gd.y
z = gd.z
grad = N.empty((3,)+f.shape)
grad[0,...] = xder(f,dx,x=x,y=y,z=z,param=param,dim=dim)
grad[1,...] = yder(f,dy,x=x,y=y,z=z,param=param,dim=dim)
grad[2,...] = zder(f,dz,x=x,y=y,z=z,param=param,dim=dim)
return grad
def yder6_6th(f, dy, x=[], y=[], z=[]):
if (f.ndim != 3 and f.ndim != 4):
print("%s dimension arrays not handled." % (str(f.ndim)))
raise ValueError
m1 = 3
m2 = f.shape[-2] - 3
dy = N.gradient(y)
if (dim.ny != 1):
fac = 1 / dy**6
d6fdy = N.zeros_like(f)
dim = read_dim()
if (m2 > m1 and dim.ny != 1):
for m in range(m1, m2):
d6fdy[...,
m1:m2, :] = fac[m] * (-20.0 * f[..., m, :] + 15.0 *
(f[..., m + 1, :] + f[..., m - 1, :]) -
6.0 *
(f[..., m + 2, :] + f[..., m - 2, :]) +
(f[..., m + 3, :] + f[..., m - 3, :]))
return d6fdy
def read_yaver(datadir='data/', format='native', point=(-1, -1)):
"""read 2D yaverage.dat file.
point -- an array of 2-tuples (iz,ix) representing discrete
points to be returned in an output array (not implemented yet)
returns a tuple (yavg, t), yavg has shape (noutputs,nvars,nz,nx)
"""
datadir = os.path.expanduser(datadir)
datatopdir = re.sub('data\/*$', '', datadir)
filename = datadir + '/yaverages.dat'
# which variables are averaged?
infile = open(datatopdir + 'yaver.in')
variables = [line.strip() for line in infile.readlines()]
infile.close()
# global dim
dim = read_dim(datadir)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
infile = npfile(filename, endian=format)
t = N.zeros(1, dtype=precision)
yaver = []
yaver_shape = (len(variables), dim.nz, dim.nx)
ntime = 0
while 1:
try:
raw_data = infile.fort_read(precision, shape=1)
except ValueError:
break
except TypeError:
break
t = N.concatenate((t, raw_data))
try:
raw_data = infile.fort_read(precision, shape=yaver_shape)
except ValueError:
#print "Problem: seems there is a t without corresponding data. yaverages.dat may be corrupted" # Python 2
print(
"Problem: seems there is a t without corresponding data. yaverages.dat may be corrupted"
)
break
except TypeError:
#print "Problem: seems there is a t without corresponding data. yaverages.dat may be corrupted" # Python 2
print(
"Problem: seems there is a t without corresponding data. yaverages.dat may be corrupted"
)
break
yaver.append(raw_data)
ntime += 1
output = N.array(yaver)
return output, t[1:]
def make_movie(field='uu1', datadir='data/', proc=-1, extension='xz',
format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,
transform='', oldfile=False):
"""
read 2D slice files and assemble an animation in a mpg movie.
Quickly written from the example at
http://matplotlib.sourceforge.net/faq/howto_faq.html
Options:
field --- which variable to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to modify the slice
"""
import pylab as plt
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = datadir + '/slice_' + field + '.' + extension
else:
filename = datadir + '/proc' + \
str(proc) + '/slice_' + field + '.' + extension
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = np.zeros((vsize, hsize), dtype=precision)
infile = npfile(filename, endian=format)
files = []
fig = plt.figure(figsize=(5, 10))
ax = fig.add_subplot(111)
ifirst = True
islice = 0
while True:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[-1]
plane = raw_data[:-1].reshape(vsize, hsize)
else:
t = raw_data[-2]
plane = raw_data[:-2].reshape(vsize, hsize)
if transform:
exec('plane = plane' + transform)
if t > tmin and t < tmax:
ax.cla()
ax.imshow(plane, vmin=amin, vmax=amax)
fname = '_tmp%03d.png' % islice
print('Saving frame' + fname)
fig.savefig(fname)
files.append(fname)
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" % \ # Python 2
#(islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))
ifirst = False
islice += 1
#print 'Making movie animation.mpg - this make take a while'
print('Making movie animation.mpg - this make take a while')
# SC: Not all systems use mencoder. Need to change this into ffmpeg.
os.system("mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg")
os.system("rm _tmp*.png")
infile.close()
def __init__(self,
varfile='',
datadir='data/',
proc=-1,
ivar=-1,
quiet=False,
trimall=False,
format='native',
param=None,
dim=None,
index=None,
run2D=False,
magic=None,
setup=None):
"""
Description:
-----------
Read VAR files from pencil code. if proc < 0, then load all data
and assemble. otherwise, load VAR file from specified processor.
format -- one of (['native', 'n'], ['ieee-le', 'l'],
['ieee-be', 'B']) for byte-ordering
Params:
------
varfile=''
datadir='data/'
proc=-1
ivar=-1
quiet=False
trimall=False
format='native'
param=None
dim=None
index=None
run2D=False
Example of usage
------
ff=pc.read_var(trimall=True,ivar=100,magic=['tt','vort'])
"""
if (setup is not None):
datadir = os.path.expanduser(setup.datadir)
dim = setup.dim
param = setup.param
index = setup.index
run2D = setup.run2D
else:
datadir = os.path.expanduser(datadir)
if dim is None:
ldownsampled = 'VARd' in varfile
dim = read_dim(datadir, proc, down=ldownsampled)
if param is None:
param = read_param(datadir=datadir, quiet=quiet)
if index is None:
index = read_index(datadir=datadir, down=ldownsampled)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
if param.lwrite_aux:
totalvars = dim.mvar + dim.maux
else:
totalvars = dim.mvar
if 'VARd' in varfile:
if param.mvar_down > 0:
totalvars = param.mvar_down
# Read index.pro to get positions and "names"
# of variables in f(mx,my,mz,nvar).
# Thomas: seems useless now ?
#exec(index) # this loads the indicies.
if (not varfile):
if ivar < 0:
varfile = 'var.dat'
else:
varfile = 'VAR' + str(ivar)
if proc < 0:
procdirs = natural_sort(
filter(lambda s: s.startswith('proc'), os.listdir(datadir)))
else:
procdirs = ['proc' + str(proc)]
#global array
if (not run2D):
f = np.zeros((totalvars, dim.mz, dim.my, dim.mx), dtype=precision)
else:
if dim.ny == 1:
f = np.zeros((totalvars, dim.mz, dim.mx), dtype=precision)
else:
f = np.zeros((totalvars, dim.my, dim.mx), dtype=precision)
x = np.zeros(dim.mx, dtype=precision)
y = np.zeros(dim.my, dtype=precision)
z = np.zeros(dim.mz, dtype=precision)
for directory in procdirs:
proc = int(directory[4:])
procdim = read_dim(datadir, proc, down=ldownsampled)
if (not quiet):
#print "reading data from processor %i of %i ..." \ # Python 2
#% (proc, len(procdirs)) # Python 2
print("reading data from processor {0} of {1} ...".format(
proc, len(procdirs)))
mxloc = procdim.mx
myloc = procdim.my
mzloc = procdim.mz
#read data
filename = os.path.join(datadir, directory, varfile)
infile = npfile(filename, endian=format)
if (not run2D):
f_loc = infile.fort_read(precision,
shape=(-1, mzloc, myloc, mxloc))
else:
if dim.ny == 1:
f_loc = infile.fort_read(precision,
shape=(-1, mzloc, mxloc))
else:
f_loc = infile.fort_read(precision,
shape=(-1, myloc, mxloc))
raw_etc = infile.fort_read(precision)
infile.close()
t = raw_etc[0]
x_loc = raw_etc[1:mxloc + 1]
y_loc = raw_etc[mxloc + 1:mxloc + myloc + 1]
z_loc = raw_etc[mxloc + myloc + 1:mxloc + myloc + mzloc + 1]
if (param.lshear):
shear_offset = 1
deltay = raw_etc[-1]
else:
shear_offset = 0
dx = raw_etc[-3 - shear_offset]
dy = raw_etc[-2 - shear_offset]
dz = raw_etc[-1 - shear_offset]
if len(procdirs) > 1:
# Calculate where the local processor will go in
# the global array.
# Don't overwrite ghost zones of processor to the left (and
# accordingly in y and z direction--makes a difference on the
# diagonals).
#
# Recall that in NumPy, slicing is NON-INCLUSIVE on the right end
# ie, x[0:4] will slice all of a 4-digit array, not produce
# an error like in idl.
if procdim.ipx == 0:
i0x = 0
i1x = i0x + procdim.mx
i0xloc = 0
i1xloc = procdim.mx
else:
i0x = procdim.ipx * procdim.nx + procdim.nghostx
i1x = i0x + procdim.mx - procdim.nghostx
i0xloc = procdim.nghostx
i1xloc = procdim.mx
if procdim.ipy == 0:
i0y = 0
i1y = i0y + procdim.my
i0yloc = 0
i1yloc = procdim.my
else:
i0y = procdim.ipy * procdim.ny + procdim.nghosty
i1y = i0y + procdim.my - procdim.nghosty
i0yloc = procdim.nghosty
i1yloc = procdim.my
if procdim.ipz == 0:
i0z = 0
i1z = i0z + procdim.mz
i0zloc = 0
i1zloc = procdim.mz
else:
i0z = procdim.ipz * procdim.nz + procdim.nghostz
i1z = i0z + procdim.mz - procdim.nghostz
i0zloc = procdim.nghostz
i1zloc = procdim.mz
x[i0x:i1x] = x_loc[i0xloc:i1xloc]
y[i0y:i1y] = y_loc[i0yloc:i1yloc]
z[i0z:i1z] = z_loc[i0zloc:i1zloc]
if (not run2D):
f[:, i0z:i1z, i0y:i1y, i0x:i1x] = \
f_loc[:, i0zloc:i1zloc, i0yloc:i1yloc, i0xloc:i1xloc]
else:
if dim.ny == 1:
f[:, i0z:i1z, i0x:i1x] = \
f_loc[:, i0zloc:i1zloc, i0xloc:i1xloc]
else:
f[:, i0y:i1y, i0x:i1x] = \
f_loc[:, i0yloc:i1yloc, i0xloc:i1xloc]
else:
f = f_loc
x = x_loc
y = y_loc
z = z_loc
#endif MPI run
#endfor directories loop
if (magic is not None):
if ('bb' in magic):
# Compute the magnetic field before doing trimall.
aa = f[index['ax'] - 1:index['az'], ...]
self.bb = curl(aa, dx, dy, dz, x, y, z, run2D=param.lwrite_2d)
if (trimall):
self.bb = self.bb[:, dim.n1:dim.n2 + 1, dim.m1:dim.m2 + 1,
dim.l1:dim.l2 + 1]
if ('jj' in magic):
# Compute the electric current field before doing trimall.
aa = f[index['ax'] - 1:index['az'], ...]
self.jj = curl2(aa, dx, dy, dz, x, y, z)
if (trimall):
self.jj = self.jj[:, dim.n1:dim.n2 + 1, dim.m1:dim.m2 + 1,
dim.l1:dim.l2 + 1]
if ('vort' in magic):
# Compute the vorticity field before doing trimall.
uu = f[index['ux'] - 1:index['uz'], ...]
self.vort = curl(uu,
dx,
dy,
dz,
x,
y,
z,
run2D=param.lwrite_2d)
if (trimall):
if (param.lwrite_2d):
if (dim.nz == 1):
self.vort = self.vort[:, dim.m1:dim.m2 + 1,
dim.l1:dim.l2 + 1]
else:
self.vort = self.vort[:, dim.n1:dim.n2 + 1,
dim.l1:dim.l2 + 1]
else:
self.vort = self.vort[:, dim.n1:dim.n2 + 1,
dim.m1:dim.m2 + 1,
dim.l1:dim.l2 + 1]
# Trim the ghost zones of the global f-array if asked.
if trimall:
self.x = x[dim.l1:dim.l2 + 1]
self.y = y[dim.m1:dim.m2 + 1]
self.z = z[dim.n1:dim.n2 + 1]
if (not run2D):
self.f = f[:, dim.n1:dim.n2 + 1, dim.m1:dim.m2 + 1,
dim.l1:dim.l2 + 1]
else:
if dim.ny == 1:
self.f = f[:, dim.n1:dim.n2 + 1, dim.l1:dim.l2 + 1]
else:
self.f = f[:, dim.m1:dim.m2 + 1, dim.l1:dim.l2 + 1]
else:
self.x = x
self.y = y
self.z = z
self.f = f
self.l1 = dim.l1
self.l2 = dim.l2 + 1
self.m1 = dim.m1
self.m2 = dim.m2 + 1
self.n1 = dim.n1
self.n2 = dim.n2 + 1
# Assign an attribute to self for each variable defined in
# 'data/index.pro' so that e.g. self.ux is the x-velocity.
for key, value in index.items():
# print key,value.
if key != 'global_gg':
setattr(self, key, self.f[value - 1, ...])
# special treatment for vector quantities
if 'uu' in index.keys():
self.uu = self.f[index['ux'] - 1:index['uz'], ...]
if 'aa' in index.keys():
self.aa = self.f[index['ax'] - 1:index['az'], ...]
# Also treat Fcr (from cosmicrayflux) as a vector.
if 'fcr' in index.keys():
self.fcr = self.f[index['fcr'] - 1:index['fcr'] + 2, ...]
self.fcrx = self.fcr[0]
self.fcry = self.fcr[1]
self.fcrz = self.fcr[2]
self.t = t
self.dx = dx
self.dy = dy
self.dz = dz
if param.lshear:
self.deltay = deltay
# Do the rest of magic after the trimall (i.e. no additional curl...).
self.magic = magic
if self.magic is not None:
self.__magicAttributes(param)
def __init__(self,
datadir='data/',
proc=-1,
ivar=-1,
quiet=False,
trim=False,
format='native',
param=None,
down=False):
"""
Read grid from pencil code. if proc < 0, then load all data
and assemble. otherwise, load grid from specified processor.
"""
datadir = os.path.expanduser(datadir)
if param is None:
param = read_param(datadir, quiet=quiet)
dim = read_dim(datadir, proc, down=down)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
if proc < 0:
procdirs = list(
filter(lambda s: s.startswith('proc'), os.listdir(datadir)))
if (param.io_strategy == 'MPI-IO|collect'
or param.io_strategy == 'collect'):
procdirs = ['allprocs']
else:
procdirs = ['proc' + str(proc)]
#global array
x = N.zeros(dim.mx, dtype=precision)
y = N.zeros(dim.my, dtype=precision)
z = N.zeros(dim.mz, dtype=precision)
dx_1 = N.zeros(dim.mx, dtype=precision)
dy_1 = N.zeros(dim.my, dtype=precision)
dz_1 = N.zeros(dim.mz, dtype=precision)
dx_tilde = N.zeros(dim.mx, dtype=precision)
dy_tilde = N.zeros(dim.my, dtype=precision)
dz_tilde = N.zeros(dim.mz, dtype=precision)
for directory in procdirs:
if directory != 'allprocs':
proc = int(directory[4:])
procdim = read_dim(datadir, proc, down=down)
if not quiet:
#print "reading data from processor %i of %i ..." \ # Python 2
#% (proc, len(procdirs)) # Python 2
print("reading data from processor {0} of {1} ...".format(
proc, len(procdirs)))
mxloc = procdim.mx
myloc = procdim.my
mzloc = procdim.mz
#read data
if down:
griddat = 'grid_down.dat'
else:
griddat = 'grid.dat'
filename = os.path.join(datadir, directory, griddat)
infile = npfile(filename, endian=format)
grid_raw = infile.fort_read(precision)
dx, dy, dz = tuple(infile.fort_read(precision))
Lx, Ly, Lz = tuple(infile.fort_read(precision))
dx_1_raw = infile.fort_read(precision)
dx_tilde_raw = infile.fort_read(precision)
infile.close()
#reshape
t = grid_raw[0]
x_loc = grid_raw[1:mxloc + 1]
y_loc = grid_raw[mxloc + 1:mxloc + myloc + 1]
z_loc = grid_raw[mxloc + myloc + 1:mxloc + myloc + mzloc + 1]
dx_1_loc = dx_1_raw[0:mxloc]
dy_1_loc = dx_1_raw[mxloc:mxloc + myloc]
dz_1_loc = dx_1_raw[mxloc + myloc:mxloc + myloc + mzloc]
dx_tilde_loc = dx_tilde_raw[0:mxloc]
dy_tilde_loc = dx_tilde_raw[mxloc:mxloc + myloc]
dz_tilde_loc = dx_tilde_raw[mxloc + myloc:mxloc + myloc + mzloc]
if len(procdirs) > 1:
if procdim.ipx == 0:
i0x = 0
i1x = i0x + procdim.mx
i0xloc = 0
i1xloc = procdim.mx
else:
i0x = procdim.ipx * procdim.nx + procdim.nghostx
i1x = i0x + procdim.mx - procdim.nghostx
i0xloc = procdim.nghostx
i1xloc = procdim.mx
if procdim.ipy == 0:
i0y = 0
i1y = i0y + procdim.my
i0yloc = 0
i1yloc = procdim.my
else:
i0y = procdim.ipy * procdim.ny + procdim.nghosty
i1y = i0y + procdim.my - procdim.nghosty
i0yloc = procdim.nghosty
i1yloc = procdim.my
if procdim.ipz == 0:
i0z = 0
i1z = i0z + procdim.mz
i0zloc = 0
i1zloc = procdim.mz
else:
i0z = procdim.ipz * procdim.nz + procdim.nghostz
i1z = i0z + procdim.mz - procdim.nghostz
i0zloc = procdim.nghostz
i1zloc = procdim.mz
x[i0x:i1x] = x_loc[i0xloc:i1xloc]
y[i0y:i1y] = y_loc[i0yloc:i1yloc]
z[i0z:i1z] = z_loc[i0zloc:i1zloc]
dx_1[i0x:i1x] = dx_1_loc[i0xloc:i1xloc]
dy_1[i0y:i1y] = dy_1_loc[i0yloc:i1yloc]
dz_1[i0z:i1z] = dz_1_loc[i0zloc:i1zloc]
dx_tilde[i0x:i1x] = dx_tilde_loc[i0xloc:i1xloc]
dy_tilde[i0y:i1y] = dy_tilde_loc[i0yloc:i1yloc]
dz_tilde[i0z:i1z] = dz_tilde_loc[i0zloc:i1zloc]
else:
x = x_loc
y = y_loc
z = z_loc
dx_1 = dx_1_loc
dy_1 = dy_1_loc
dz_1 = dz_1_loc
dx_tilde = dx_tilde_loc
dy_tilde = dy_tilde_loc
dz_tilde = dz_tilde_loc
#endif MPI run
# end directories loop
if trim:
self.x = x[dim.l1:dim.l2 + 1]
self.y = y[dim.m1:dim.m2 + 1]
self.z = z[dim.n1:dim.n2 + 1]
self.dx_1 = dx_1[dim.l1:dim.l2 + 1]
self.dy_1 = dy_1[dim.m1:dim.m2 + 1]
self.dx_1 = dz_1[dim.n1:dim.n2 + 1]
self.dx_tilde = dx_tilde[dim.l1:dim.l2 + 1]
self.dy_tilde = dy_tilde[dim.m1:dim.m2 + 1]
self.dx_tilde = dz_tilde[dim.n1:dim.n2 + 1]
else:
self.x = x
self.y = y
self.z = z
self.dx_1 = dx_1
self.dy_1 = dy_1
self.dx_1 = dz_1
self.dx_tilde = dx_tilde
self.dy_tilde = dy_tilde
self.dx_tilde = dz_tilde
self.t = t
self.dx = dx
self.dy = dy
self.dz = dz
self.Lx = Lx
self.Ly = Ly
self.Lz = Lz
def time_slices(field=['uu1'], datadir='data/', proc=-1, extension='xz',
format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,
transform='plane[0]', dtstep=1, deltat=0,
oldfile=False, outfile=""):
"""
Read a list of 1D slice files, combine them, and plot the slice in
one dimension, and time in the other one.
Options:
field --- list of variables to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to combine the slices
dtstep --- only plot every dt step
deltat --- if set to nonzero, plot at fixed time interval rather than step
outfile --- if set, write the slice values in the text file
"""
import pylab as plt
datadir = os.path.expanduser(datadir)
if outfile != "":
outslice = open(outfile, "w")
filename = []
if proc < 0:
for i in field:
filename += [datadir + '/slice_' + i + '.' + extension]
else:
for i in field:
filename += [datadir + '/proc' +
str(proc) + '/slice_' + i + '.' + extension]
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = []
infile = []
for i in filename:
plane += [np.zeros((vsize, hsize), dtype=precision)]
infile += [npfile(i, endian=format)]
ifirst = True
islice = 0
plotplane = []
dt = 0
nextt = tmin
while True:
try:
raw_data = []
for i in infile:
raw_data += [i.fort_read(precision)]
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[0][-1]
for i in range(len(raw_data)):
plane[i] = raw_data[i][:-1].reshape(vsize, hsize)
else:
t = raw_data[0][-2]
for i in range(len(raw_data)):
plane[i] = raw_data[i][:-2].reshape(vsize, hsize)
exec('tempplane =' + transform)
if t > tmin and t < tmax:
if dt == 0:
plotplane += tempplane.tolist()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" % \ # Python 2
#(islice, t, tempplane.min(), tempplane.max(), # Python 2
#tempplane.max() - tempplane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, tempplane.min(), tempplane.max(), tempplane.max() - tempplane.min()))
if outfile != "":
outslice.write(
#"%10i %10.3e %10.3e %10.3e %10.3e" % # Python 2
#(islice, # Python 2
#t, # Python 2
#tempplane.min(), # Python 2
#tempplane.max(), # Python 2
#tempplane.max() - # Python 2
#tempplane.min())) # Python 2
"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(
islice,
t,
tempplane.min(),
tempplane.max(),
tempplane.max() -
tempplane.min()))
outslice.write("\n")
ifirst = False
islice += 1
nextt = t + deltat
if deltat == 0:
dt = (dt + 1) % dtstep
elif t >= nextt:
dt = 0
nextt = t + deltat
else:
dt = 1
ax = plt.axes()
ax.set_xlabel('t')
ax.set_ylabel('y')
ax.set_ylim
plt.imshow(np.array(plotplane).reshape(islice, vsize).transpose(),
vmin=amin, vmax=amax)
manager = plt.get_current_fig_manager()
manager.show()
for i in infile:
i.close()
if outfile != "":
outslice.close()
def animate_multislices(field=['uu1'], datadir='data/', proc=-1,
extension='xz', format='native', tmin=0., tmax=1.e38,
amin=0., amax=1., transform='plane[0]',
oldfile=False, outfile=""):
"""
Read a list of 2D slice files, combine them, and assemble an animation.
Options:
field --- list of variables to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to combine the slices
outfile --- if set, write the slice values in the text file
"""
import pylab as plt
datadir = os.path.expanduser(datadir)
if outfile != "":
outslice = open(outfile, "w")
filename = []
if proc < 0:
for i in field:
filename += [datadir + '/slice_' + i + '.' + extension]
else:
for i in field:
filename += [datadir + '/proc' +
str(proc) + '/slice_' + i + '.' + extension]
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = []
infile = []
for i in filename:
plane += [np.zeros((vsize, hsize), dtype=precision)]
infile += [npfile(i, endian=format)]
ax = plt.axes()
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_ylim
exec('plotplane =' + transform)
image = plt.imshow(plotplane, vmin=amin, vmax=amax)
# Get the figure manager for real-time image display.
manager = plt.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
while True:
try:
raw_data = []
for i in infile:
raw_data += [i.fort_read(precision)]
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[0][-1]
for i in range(len(raw_data)):
plane[i] = raw_data[i][:-1].reshape(vsize, hsize)
else:
t = raw_data[0][-2]
for i in range(len(raw_data)):
plane[i] = raw_data[i][:-2].reshape(vsize, hsize)
exec('plotplane =' + transform)
if t > tmin and t < tmax:
title = 't = %11.3e' % t
ax.set_title(title)
image.set_data(plotplane)
manager.canvas.draw()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" % \ # Python 2
#(islice, t, plotplane.min(), plotplane.max(), # Python 2
#plotplane.max() - plotplane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plotplane.min(), plotplane.max(),
plotplane.max() - plotplane.min()))
if outfile != "":
#outslice.write("%10i %10.3e %10.3e %10.3e %10.3e" % # Python 2
#(islice, t, plotplane.min(), plotplane.max(), # Python 2
#plotplane.max() - plotplane.min())) # Python 2
outslice.write("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plotplane.min(), plotplane.max(), plotplane.max() - plotplane.min()))
outslice.write("\n")
ifirst = False
islice += 1
for i in infile:
i.close()
if outfile != "":
outslice.close()
def animate_slices_crossflow(field='uu1', datadir='data/', proc=-1, extension='yz',
format='native', tmin=0., tmax=1.e38, wait=0.,
amin=0., amax=1., transform='', oldfile=False):
"""
read 2D slice files and assemble an animation.
Options:
field --- which variable to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to modify the slice
wait --- pause in seconds between animation slices
"""
import pylab as plt
import matplotlib.patches as ptc
import matplotlib.ticker as ticker
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = join(datadir, 'slice_' + field + '.' + extension)
else:
filename = join(datadir, 'proc' + str(proc),
'slice_' + field + '.' + extension)
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = np.zeros((vsize, hsize), dtype=precision)
infile = npfile(filename, endian=format)
ax = plt.axes()
ax.set_xlabel('y')
ax.set_ylabel('x')
ax.set_ylim
name_list_x = ('0', '2D', '4D', '6D')
#name_list_z = ('12D', '10D', '8D', '6D', '4D','2D','0')
name_list_z = ( '0', '2D', '4D', '6D','8D','10D','12D',)
pos_list_x = np.array([0,80,160,240])
pos_list_z = np.array([0,80,160,240,320,400,480])
name_list_x = ('0', '5D', '10D')
name_list_z = ( '0', '5D', '10D', '15D','20D')
pos_list_x = np.array([0,159,319])
pos_list_z = np.array([0,159,319,479,639])
#pos_list = np.arange(len(name_list))
#ax = plt.axes()
#ax.xaxis.set_major_locator(ticker.FixedLocator((pos_list_x)))
#ax.xaxis.set_major_formatter(ticker.FixedFormatter((name_list_x)))
#ax.yaxis.set_major_locator(ticker.FixedLocator((pos_list_z)))
#ax.yaxis.set_major_formatter(ticker.FixedFormatter((name_list_z)))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
# turbulent particle sim xy-vew, Ddx=40
#r=20
#xy = [120,240]
# art = ptc.Circle(xy,r,color='black')
# ax.add_artist(art)
# uniform flow sim xy-vew, Ddx=64
# r=16
# xy = [160,320]
# Pencil-tests, Re=400, Ddx=96
#r=48
#xy = [480,960]
# Pencil-tests, Re=100, Ddx=64
r=32
xy = [320,640]
art = ptc.Circle(xy,r,color='black')
ax.add_artist(art)
#ax.add_patch(patches.Rectangle(
# (220,0),
# 40,
# 320,
# color='gray'
# )
#)
image = plt.imshow(plane, vmin=amin, vmax=amax)
# Get the figure manager for real-time image display.
manager = plt.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
while True:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[-1]
plane = raw_data[:-1].reshape(vsize, hsize)
else:
t = raw_data[-2]
plane = raw_data[:-2].reshape(vsize, hsize)
if transform:
exec('plane = plane' + transform)
if t > tmin and t < tmax:
#title = 't = %11.3e' % t
#ax.set_title(title)
image.set_data(plane)
manager.canvas.draw()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" \ # Python 2
#% (islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))
ifirst = False
fname = '_tmp%03d.eps' % islice
plt.savefig(fname,fonttype=42,
bbox_inches = 'tight',
# pad_inches = 0,
dpi = 600, transparant=True)
#plt.savefig(fname,fonttype=42)
islice += 1
sleep(wait)
infile.close()
def animate_multislices(field=['uu1'], datadir='data/', proc=-1,
extension='xz', format='native', tmin=0., tmax=1.e38,
amin=0., amax=1., transform='plane[0]',
oldfile=False, outfile=""):
"""
Read a list of 2D slice files, combine them, and assemble an animation.
Options:
field --- list of variables to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to combine the slices
outfile --- if set, write the slice values in the text file
"""
import pylab as plt
datadir = os.path.expanduser(datadir)
if outfile != "":
outslice = open(outfile, "w")
filename = []
if proc < 0:
for i in field:
filename += [datadir + '/slice_' + i + '.' + extension]
else:
for i in field:
filename += [datadir + '/proc' +
str(proc) + '/slice_' + i + '.' + extension]
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = []
infile = []
for i in filename:
plane += [np.zeros((vsize, hsize), dtype=precision)]
infile += [npfile(i, endian=format)]
ax = plt.axes()
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_ylim
exec('plotplane =' + transform)
image = plt.imshow(plotplane, vmin=amin, vmax=amax)
# Get the figure manager for real-time image display.
manager = plt.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
while True:
try:
raw_data = []
for i in infile:
raw_data += [i.fort_read(precision)]
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[0][-1]
for i in range(len(raw_data)):
plane[i] = raw_data[i][:-1].reshape(vsize, hsize)
else:
t = raw_data[0][-2]
for i in range(len(raw_data)):
plane[i] = raw_data[i][:-2].reshape(vsize, hsize)
exec('plotplane =' + transform)
if t > tmin and t < tmax:
title = 't = %11.3e' % t
ax.set_title(title)
image.set_data(plotplane)
manager.canvas.draw()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" % \ # Python 2
#(islice, t, plotplane.min(), plotplane.max(), # Python 2
#plotplane.max() - plotplane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plotplane.min(), plotplane.max(),
plotplane.max() - plotplane.min()))
if outfile != "":
#outslice.write("%10i %10.3e %10.3e %10.3e %10.3e" % # Python 2
#(islice, t, plotplane.min(), plotplane.max(), # Python 2
#plotplane.max() - plotplane.min())) # Python 2
outslice.write("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plotplane.min(), plotplane.max(), plotplane.max() - plotplane.min()))
outslice.write("\n")
ifirst = False
islice += 1
for i in infile:
i.close()
if outfile != "":
outslice.close()
def __init__(self, varfile='', datadir='data/', proc=-1, ivar=-1,
quiet=False, trimall=False, format='native',
param=None, dim=None, index=None, run2D=False,
magic=None, setup=None):
"""
Description:
-----------
Read VAR files from pencil code. if proc < 0, then load all data
and assemble. otherwise, load VAR file from specified processor.
format -- one of (['native', 'n'], ['ieee-le', 'l'],
['ieee-be', 'B']) for byte-ordering
Params:
------
varfile=''
datadir='data/'
proc=-1
ivar=-1
quiet=False
trimall=False
format='native'
param=None
dim=None
index=None
run2D=False
"""
if (setup is not None):
datadir = os.path.expanduser(setup.datadir)
dim = setup.dim
param = setup.param
index = setup.index
run2D = setup.run2D
else:
datadir = os.path.expanduser(datadir)
if dim is None:
dim = read_dim(datadir,proc)
if param is None:
param = read_param(datadir=datadir, quiet=quiet)
if index is None:
index = read_index(datadir=datadir)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
if param.lwrite_aux:
totalvars = dim.mvar+dim.maux
else:
totalvars = dim.mvar
# Read index.pro to get positions and "names"
# of variables in f(mx,my,mz,nvar).
# Thomas: seems useless now ?
#exec(index) # this loads the indicies.
if (not varfile):
if ivar < 0:
varfile = 'var.dat'
else:
varfile = 'VAR'+str(ivar)
if proc < 0:
procdirs = natural_sort(filter(lambda s:s.startswith('proc'),
os.listdir(datadir)))
else:
procdirs = ['proc'+str(proc)]
#global array
if (not run2D):
f = np.zeros((totalvars, dim.mz, dim.my, dim.mx),
dtype=precision)
else:
if dim.ny == 1:
f = np.zeros((totalvars, dim.mz, dim.mx), dtype=precision)
else:
f = np.zeros((totalvars, dim.my, dim.mx), dtype=precision)
x = np.zeros(dim.mx, dtype=precision)
y = np.zeros(dim.my, dtype=precision)
z = np.zeros(dim.mz, dtype=precision)
for directory in procdirs:
proc = int(directory[4:])
procdim = read_dim(datadir, proc)
if (not quiet):
#print "reading data from processor %i of %i ..." \ # Python 2
#% (proc, len(procdirs)) # Python 2
print("reading data from processor {0} of {1} ...".format(proc, len(procdirs)))
mxloc = procdim.mx
myloc = procdim.my
mzloc = procdim.mz
#read data
filename = os.path.join(datadir,directory,varfile)
infile = npfile(filename, endian=format)
if (not run2D):
f_loc = infile.fort_read(precision,
shape=(-1, mzloc, myloc, mxloc))
else:
if dim.ny == 1:
f_loc = infile.fort_read(precision, shape=(-1, mzloc, mxloc))
else:
f_loc = infile.fort_read(precision, shape=(-1, myloc, mxloc))
raw_etc = infile.fort_read(precision)
infile.close()
t = raw_etc[0]
x_loc = raw_etc[1:mxloc+1]
y_loc = raw_etc[mxloc+1:mxloc+myloc+1]
z_loc = raw_etc[mxloc+myloc+1:mxloc+myloc+mzloc+1]
if (param.lshear):
shear_offset = 1
deltay = raw_etc[-1]
else:
shear_offset = 0
dx = raw_etc[-3-shear_offset]
dy = raw_etc[-2-shear_offset]
dz = raw_etc[-1-shear_offset]
if len(procdirs) > 1:
# Calculate where the local processor will go in
# the global array.
# Don't overwrite ghost zones of processor to the left (and
# accordingly in y and z direction--makes a difference on the
# diagonals).
#
# Recall that in NumPy, slicing is NON-INCLUSIVE on the right end
# ie, x[0:4] will slice all of a 4-digit array, not produce
# an error like in idl.
if procdim.ipx == 0:
i0x = 0
i1x = i0x+procdim.mx
i0xloc = 0
i1xloc = procdim.mx
else:
i0x = procdim.ipx*procdim.nx+procdim.nghostx
i1x = i0x+procdim.mx-procdim.nghostx
i0xloc = procdim.nghostx
i1xloc = procdim.mx
if procdim.ipy == 0:
i0y = 0
i1y = i0y+procdim.my
i0yloc = 0
i1yloc = procdim.my
else:
i0y = procdim.ipy*procdim.ny+procdim.nghosty
i1y = i0y+procdim.my-procdim.nghosty
i0yloc = procdim.nghosty
i1yloc = procdim.my
if procdim.ipz == 0:
i0z = 0
i1z = i0z+procdim.mz
i0zloc = 0
i1zloc = procdim.mz
else:
i0z = procdim.ipz*procdim.nz+procdim.nghostz
i1z = i0z+procdim.mz-procdim.nghostz
i0zloc = procdim.nghostz
i1zloc = procdim.mz
x[i0x:i1x] = x_loc[i0xloc:i1xloc]
y[i0y:i1y] = y_loc[i0yloc:i1yloc]
z[i0z:i1z] = z_loc[i0zloc:i1zloc]
if (not run2D):
f[:, i0z:i1z, i0y:i1y, i0x:i1x] = \
f_loc[:, i0zloc:i1zloc, i0yloc:i1yloc, i0xloc:i1xloc]
else:
if dim.ny == 1:
f[:, i0z:i1z, i0x:i1x] = \
f_loc[:, i0zloc:i1zloc, i0xloc:i1xloc]
else:
f[:, i0y:i1y, i0x:i1x] = \
f_loc[:, i0yloc:i1yloc, i0xloc:i1xloc]
else:
f = f_loc
x = x_loc
y = y_loc
z = z_loc
#endif MPI run
#endfor directories loop
if (magic is not None):
if ('bb' in magic):
# Compute the magnetic field before doing trimall.
aa = f[index['ax']-1:index['az'],...]
self.bb = curl(aa,dx,dy,dz,run2D=param.lwrite_2d)
if (trimall): self.bb=self.bb[:, dim.n1:dim.n2+1,
dim.m1:dim.m2+1, dim.l1:dim.l2+1]
if ('jj' in magic):
# Compute the electric current field before doing trimall.
aa = f[index['ax']-1:index['az'],...]
self.jj = curl2(aa,dx,dy,dz)
if (trimall): self.jj=self.jj[:, dim.n1:dim.n2+1,
dim.m1:dim.m2+1, dim.l1:dim.l2+1]
if ('vort' in magic):
# Compute the vorticity field before doing trimall.
uu = f[index['ux']-1:index['uz'],...]
self.vort = curl(uu,dx,dy,dz,run2D=param.lwrite_2d)
if (trimall):
if (param.lwrite_2d):
if (dim.nz == 1):
self.vort=self.vort[:, dim.m1:dim.m2+1,
dim.l1:dim.l2+1]
else:
self.vort=self.vort[:, dim.n1:dim.n2+1,
dim.l1:dim.l2+1]
else:
self.vort=self.vort[:, dim.n1:dim.n2+1,
dim.m1:dim.m2+1, dim.l1:dim.l2+1]
# Trim the ghost zones of the global f-array if asked.
if trimall:
self.x = x[dim.l1:dim.l2+1]
self.y = y[dim.m1:dim.m2+1]
self.z = z[dim.n1:dim.n2+1]
if (not run2D):
self.f = f[:, dim.n1:dim.n2+1, dim.m1:dim.m2+1, dim.l1:dim.l2+1]
else:
if dim.ny == 1:
self.f = f[:, dim.n1:dim.n2+1, dim.l1:dim.l2+1]
else:
self.f = f[:, dim.m1:dim.m2+1, dim.l1:dim.l2+1]
else:
self.x = x
self.y = y
self.z = z
self.f = f
self.l1 = dim.l1
self.l2 = dim.l2+1
self.m1 = dim.m1
self.m2 = dim.m2+1
self.n1 = dim.n1
self.n2 = dim.n2+1
# Assign an attribute to self for each variable defined in
# 'data/index.pro' so that e.g. self.ux is the x-velocity.
for key,value in index.items():
# print key,value.
if key != 'global_gg':
setattr(self,key,self.f[value-1,...])
# special treatment for vector quantities
if 'uu' in index.keys():
self.uu = self.f[index['ux']-1:index['uz'],...]
if 'aa' in index.keys():
self.aa = self.f[index['ax']-1:index['az'],...]
# Also treat Fcr (from cosmicrayflux) as a vector.
if 'fcr' in index.keys():
self.fcr = self.f[index['fcr']-1:index['fcr']+2,...]
self.fcrx = self.fcr[0]
self.fcry = self.fcr[1]
self.fcrz = self.fcr[2]
self.t = t
self.dx = dx
self.dy = dy
self.dz = dz
if param.lshear:
self.deltay = deltay
# Do the rest of magic after the trimall (i.e. no additional curl...).
self.magic = magic
if self.magic is not None:
self.__magicAttributes(param)
def read_zaver(datadir='data/',
format='native',
point=(-1, -1),
proc=-1,
trange=(0, None),
tindex=(0, None, 1)):
"""read 2D zaverage.dat file. If proc < 0, then load all data
and assemble. Otherwise, load VAR file from specified processor.
point -- an array of 2-tuples (iy,ix) representing discrete
points to be returned in an output array (not implemented yet)
proc -- Read data from proc if proc > -1, otherwise load all and assemble.
trange -- read subset of data between time.min(), time.max() (0,None)
tindex -- read every 1 data between indices 0 and None
returns a tuple (zavg, t), zavg has shape (noutputs,nvars,ny,nx)
"""
datadir = os.path.expanduser(datadir)
datatopdir = re.sub('data\/*$', '', datadir)
if len(trange) != 2:
print("Warning: trange must be a real/integer tuple of length 2 with" +
" start and end time specified")
if len(tindex) != 3:
print("Warning: tindex must be an integer tuple of length 3 with" +
" start and end indices and step specified")
# which variables are averaged?
infile = open(datatopdir + 'zaver.in')
variables = [line.strip() for line in infile.readlines()]
infile.close()
# global dim
dim = read_dim(datadir, proc=proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
if proc < 0:
procdirs = list(
filter(lambda s: s.startswith('proc'), os.listdir(datadir)))
else:
procdirs = ['proc' + str(proc)]
for directory in procdirs:
ntime, ndx = 0, 0
# local dimensions
core = int(
directory[4:]
) # SC: needed to rename proc to core to keep function argument
procdim = read_dim(datadir, core)
nxloc = procdim.nx
nyloc = procdim.ny
zaver_local = []
zaver_loc_shape = (len(variables), procdim.ny, procdim.nx)
#read data
filename = os.path.join(datadir, directory, 'zaverages.dat')
try:
infile = npfile(filename, endian=format)
t = N.zeros(1, dtype=precision)
except:
continue
while 1:
try:
raw_data = infile.fort_read(precision, shape=1)
except ValueError:
break
except TypeError:
break
if ndx >= tindex[0] and N.mod(ndx, tindex[2]) == 0:
if raw_data >= trange[0]:
t = N.concatenate((t, raw_data))
try:
raw_data = infile.fort_read(precision, shape=zaver_loc_shape)
except ValueError:
#print "Problem: seems there is a t without corresponding data. zaverages.dat may be corrupted" # Python 2
print(
"Problem: seems there is a t without corresponding data. zaverages.dat may be corrupted"
)
break
except TypeError:
#print "Problem: seems there is a t without corresponding data. zaverages.dat may be corrupted" # Python
print(
"Problem: seems there is a t without corresponding data. zaverages.dat may be corrupted"
)
break
if t.size - 1 > ntime and t[-1] >= trange[0]:
zaver_local.append(raw_data)
ntime += 1
ndx += 1
if tindex[1] is not None and ndx > tindex[1]:
break
if trange[1] is not None and t[-1] > trange[1]:
break
try:
zaver
pass
except:
zaver = N.zeros((ntime, len(variables), dim.ny, dim.nx))
if (proc < 0):
# append to the global zaver
for i in range(ntime):
zaver[i, :,
procdim.ipy * procdim.ny:(procdim.ipy + 1) * procdim.ny,
procdim.ipx * procdim.nx:(procdim.ipx + 1) *
procdim.nx] = zaver_local[i]
else:
for i in range(ntime):
zaver[i, :, :, :] = zaver_local[i]
return zaver, t[1:]
def particles_to_density(xxp, yyp, zzp, x, y, z):
dim = read_dim()
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
nnp = np.zeros([dim.mz, dim.my, dim.mx])
npar = len(xxp)
for k in range(npar):
xp = xxp[k]
yp = yyp[k]
zp = zzp[k]
ix0 = find_index_bisect(xp, x)
iy0 = find_index_bisect(yp, y)
iz0 = find_index_bisect(zp, z)
ixx0 = ix0 - 1
ixx1 = ix0 + 1
iyy0 = iy0 - 1
iyy1 = iy0 + 1
izz0 = iz0 - 1
izz1 = iz0 + 1
if (dim.nx > 1):
dx = x[ix0] - x[ixx0]
else:
dx = 1.0
if (dim.ny > 1):
dy = y[iy0] - y[iyy0]
else:
dy = 1.0
if (dim.nz > 1):
dz = z[iz0] - z[izz0]
else:
dz = 1.0
dx_1 = 1.0 / dx
dy_1 = 1.0 / dy
dz_1 = 1.0 / dz
#
dx_2 = 1.0 / dx**2
dy_2 = 1.0 / dy**2
dz_2 = 1.0 / dz**2
#if (not ghost) then begin
# mx=nx+6 & l1=3 & l2=l1+nx-1
# x2=fltarr(mx)*one
# x2[l1:l2]=x
# for l=l1-1, 0,-1 do x2[l]=x2[l+1]-dx
# for l=l2+1,mx-1,+1 do x2[l]=x2[l-1]+dx
# x=x2
# my=ny+6 & m1=3 & m2=m1+ny-1
# y2=fltarr(my)*one
# y2[m1:m2]=y
# for m=m1-1, 0,-1 do y2[m]=y2[m+1]-dy
# for m=m2+1,my-1,+1 do y2[m]=y2[m-1]+dy
# y=y2
#;
# if (dim.nz == 1):
# for n in np.arange(3):
# nn=n+1
# z[dim.n1-nn]=z[dim.n1]-nn*dz
# z[dim.n2+nn]=z[dim.n2]+nn*dz
for ixx in np.arange(ixx0, ixx1 + 1):
for iyy in np.arange(iyy0, iyy1 + 1):
for izz in np.arange(izz0, izz1 + 1):
if (((ixx - ix0) == -1) or ((ixx - ix0) == +1)):
weight_x = 1.125 - 1.5 * abs(
xp - x[ixx]) * dx_1 + 0.5 * abs(xp -
x[ixx])**2 * dx_2
else:
if (dim.nx != 1):
weight_x = 0.75 - (xp - x[ixx])**2 * dx_2
if (((iyy - iy0) == -1) or ((iyy - iy0) == +1)):
weight_y = 1.125 - 1.5 * abs(
yp - y[iyy]) * dy_1 + 0.5 * abs(yp -
y[iyy])**2 * dy_2
else:
if (dim.ny != 1):
weight_y = 0.75 - (yp - y[iyy])**2 * dy_2
if (((izz - iz0) == -1) or ((izz - iz0) == +1)):
weight_z = 1.125 - 1.5 * abs(
zp - z[izz]) * dz_1 + 0.5 * abs(zp -
z[izz])**2 * dz_2
else:
if (dim.nz != 1):
weight_z = 0.75 - (zp - z[izz])**2 * dz_2
weight = 1.0
if (dim.nx != 1): weight = weight * weight_x
if (dim.ny != 1): weight = weight * weight_y
if (dim.nz != 1): weight = weight * weight_z
#
nnp[izz, iyy, ixx] = nnp[izz, iyy, ixx] + weight
return nnp
def make_movie(field='uu1', datadir='data/', proc=-1, extension='xz',
format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,
transform='', oldfile=False):
"""
read 2D slice files and assemble an animation in a mpg movie.
Quickly written from the example at
http://matplotlib.sourceforge.net/faq/howto_faq.html
Options:
field --- which variable to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to modify the slice
"""
import pylab as plt
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = datadir + '/slice_' + field + '.' + extension
else:
filename = datadir + '/proc' + \
str(proc) + '/slice_' + field + '.' + extension
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = np.zeros((vsize, hsize), dtype=precision)
infile = npfile(filename, endian=format)
files = []
fig = plt.figure(figsize=(5, 10))
ax = fig.add_subplot(111)
ifirst = True
islice = 0
while True:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[-1]
plane = raw_data[:-1].reshape(vsize, hsize)
else:
t = raw_data[-2]
plane = raw_data[:-2].reshape(vsize, hsize)
if transform:
exec('plane = plane' + transform)
if t > tmin and t < tmax:
ax.cla()
ax.imshow(plane, vmin=amin, vmax=amax)
fname = '_tmp%03d.png' % islice
print('Saving frame' + fname)
fig.savefig(fname)
files.append(fname)
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" % \ # Python 2
#(islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))
ifirst = False
islice += 1
#print 'Making movie animation.mpg - this make take a while'
print('Making movie animation.mpg - this make take a while')
# SC: Not all systems use mencoder. Need to change this into ffmpeg.
os.system("mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg")
os.system("rm _tmp*.png")
infile.close()
def time_slices(field=['uu1'], datadir='data/', proc=-1, extension='xz',
format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,
transform='plane[0]', dtstep=1, deltat=0,
oldfile=False, outfile=""):
"""
Read a list of 1D slice files, combine them, and plot the slice in
one dimension, and time in the other one.
Options:
field --- list of variables to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to combine the slices
dtstep --- only plot every dt step
deltat --- if set to nonzero, plot at fixed time interval rather than step
outfile --- if set, write the slice values in the text file
"""
import pylab as plt
datadir = os.path.expanduser(datadir)
if outfile != "":
outslice = open(outfile, "w")
filename = []
if proc < 0:
for i in field:
filename += [datadir + '/slice_' + i + '.' + extension]
else:
for i in field:
filename += [datadir + '/proc' +
str(proc) + '/slice_' + i + '.' + extension]
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = []
infile = []
for i in filename:
plane += [np.zeros((vsize, hsize), dtype=precision)]
infile += [npfile(i, endian=format)]
ifirst = True
islice = 0
plotplane = []
dt = 0
nextt = tmin
while True:
try:
raw_data = []
for i in infile:
raw_data += [i.fort_read(precision)]
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[0][-1]
for i in range(len(raw_data)):
plane[i] = raw_data[i][:-1].reshape(vsize, hsize)
else:
t = raw_data[0][-2]
for i in range(len(raw_data)):
plane[i] = raw_data[i][:-2].reshape(vsize, hsize)
exec('tempplane =' + transform)
if t > tmin and t < tmax:
if dt == 0:
plotplane += tempplane.tolist()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" % \ # Python 2
#(islice, t, tempplane.min(), tempplane.max(), # Python 2
#tempplane.max() - tempplane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, tempplane.min(), tempplane.max(), tempplane.max() - tempplane.min()))
if outfile != "":
outslice.write(
#"%10i %10.3e %10.3e %10.3e %10.3e" % # Python 2
#(islice, # Python 2
#t, # Python 2
#tempplane.min(), # Python 2
#tempplane.max(), # Python 2
#tempplane.max() - # Python 2
#tempplane.min())) # Python 2
"{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(
islice,
t,
tempplane.min(),
tempplane.max(),
tempplane.max() -
tempplane.min()))
outslice.write("\n")
ifirst = False
islice += 1
nextt = t + deltat
if deltat == 0:
dt = (dt + 1) % dtstep
elif t >= nextt:
dt = 0
nextt = t + deltat
else:
dt = 1
ax = plt.axes()
ax.set_xlabel('t')
ax.set_ylabel('y')
ax.set_ylim
plt.imshow(np.array(plotplane).reshape(islice, vsize).transpose(),
vmin=amin, vmax=amax)
manager = plt.get_current_fig_manager()
manager.show()
for i in infile:
i.close()
if outfile != "":
outslice.close()
def __init__(self, datadir='data/', proc=-1, ivar=-1, quiet=False,
trim=False, format='native', param=None, down=False):
"""
Read grid from pencil code. if proc < 0, then load all data
and assemble. otherwise, load grid from specified processor.
"""
datadir = os.path.expanduser(datadir)
if param is None:
param = read_param(datadir, quiet=quiet)
dim = read_dim(datadir, proc, down=down)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
if proc < 0:
procdirs = list(filter(lambda s:s.startswith('proc'),
os.listdir(datadir)))
else:
procdirs = ['proc'+str(proc)]
#global array
x = N.zeros(dim.mx, dtype=precision)
y = N.zeros(dim.my, dtype=precision)
z = N.zeros(dim.mz, dtype=precision)
dx_1 = N.zeros(dim.mx, dtype=precision)
dy_1 = N.zeros(dim.my, dtype=precision)
dz_1 = N.zeros(dim.mz, dtype=precision)
dx_tilde = N.zeros(dim.mx, dtype=precision)
dy_tilde = N.zeros(dim.my, dtype=precision)
dz_tilde = N.zeros(dim.mz, dtype=precision)
for directory in procdirs:
proc = int(directory[4:])
procdim = read_dim(datadir, proc, down=down)
if not quiet:
#print "reading data from processor %i of %i ..." \ # Python 2
#% (proc, len(procdirs)) # Python 2
print("reading data from processor {0} of {1} ...".format(proc, len(procdirs)))
mxloc = procdim.mx
myloc = procdim.my
mzloc = procdim.mz
#read data
if down:
griddat='grid_down.dat'
else:
griddat='grid.dat'
filename = os.path.join(datadir, directory, griddat)
infile = npfile(filename, endian=format)
grid_raw = infile.fort_read(precision)
dx, dy, dz = tuple(infile.fort_read(precision))
Lx, Ly, Lz = tuple(infile.fort_read(precision))
dx_1_raw = infile.fort_read(precision)
dx_tilde_raw = infile.fort_read(precision)
infile.close()
#reshape
t = grid_raw[0]
x_loc = grid_raw[1:mxloc+1]
y_loc = grid_raw[mxloc+1:mxloc+myloc+1]
z_loc = grid_raw[mxloc+myloc+1:mxloc+myloc+mzloc+1]
dx_1_loc = dx_1_raw[0:mxloc]
dy_1_loc = dx_1_raw[mxloc:mxloc+myloc]
dz_1_loc = dx_1_raw[mxloc+myloc:mxloc+myloc+mzloc]
dx_tilde_loc = dx_tilde_raw[0:mxloc]
dy_tilde_loc = dx_tilde_raw[mxloc:mxloc+myloc]
dz_tilde_loc = dx_tilde_raw[mxloc+myloc:mxloc+myloc+mzloc]
if len(procdirs) >1:
if procdim.ipx == 0:
i0x = 0
i1x = i0x+procdim.mx
i0xloc = 0
i1xloc = procdim.mx
else:
i0x = procdim.ipx*procdim.nx+procdim.nghostx
i1x = i0x+procdim.mx-procdim.nghostx
i0xloc = procdim.nghostx
i1xloc = procdim.mx
if procdim.ipy == 0:
i0y = 0
i1y = i0y+procdim.my
i0yloc = 0
i1yloc = procdim.my
else:
i0y = procdim.ipy*procdim.ny+procdim.nghosty
i1y = i0y+procdim.my-procdim.nghosty
i0yloc = procdim.nghosty
i1yloc = procdim.my
if procdim.ipz == 0:
i0z = 0
i1z = i0z+procdim.mz
i0zloc = 0
i1zloc = procdim.mz
else:
i0z = procdim.ipz*procdim.nz+procdim.nghostz
i1z = i0z+procdim.mz-procdim.nghostz
i0zloc = procdim.nghostz
i1zloc = procdim.mz
x[i0x:i1x] = x_loc[i0xloc:i1xloc]
y[i0y:i1y] = y_loc[i0yloc:i1yloc]
z[i0z:i1z] = z_loc[i0zloc:i1zloc]
dx_1[i0x:i1x] = dx_1_loc[i0xloc:i1xloc]
dy_1[i0y:i1y] = dy_1_loc[i0yloc:i1yloc]
dz_1[i0z:i1z] = dz_1_loc[i0zloc:i1zloc]
dx_tilde[i0x:i1x] = dx_tilde_loc[i0xloc:i1xloc]
dy_tilde[i0y:i1y] = dy_tilde_loc[i0yloc:i1yloc]
dz_tilde[i0z:i1z] = dz_tilde_loc[i0zloc:i1zloc]
else:
x = x_loc
y = y_loc
z = z_loc
dx_1 = dx_1_loc
dy_1 = dy_1_loc
dz_1 = dz_1_loc
dx_tilde = dx_tilde_loc
dy_tilde = dy_tilde_loc
dz_tilde = dz_tilde_loc
#endif MPI run
# end directories loop
if trim:
self.x = x[dim.l1:dim.l2+1]
self.y = y[dim.m1:dim.m2+1]
self.z = z[dim.n1:dim.n2+1]
self.dx_1 = dx_1[dim.l1:dim.l2+1]
self.dy_1 = dy_1[dim.m1:dim.m2+1]
self.dx_1 = dz_1[dim.n1:dim.n2+1]
self.dx_tilde = dx_tilde[dim.l1:dim.l2+1]
self.dy_tilde = dy_tilde[dim.m1:dim.m2+1]
self.dx_tilde = dz_tilde[dim.n1:dim.n2+1]
else:
self.x = x
self.y = y
self.z = z
self.dx_1 = dx_1
self.dy_1 = dy_1
self.dx_1 = dz_1
self.dx_tilde = dx_tilde
self.dy_tilde = dy_tilde
self.dx_tilde = dz_tilde
self.t = t
self.dx = dx
self.dy = dy
self.dz = dz
self.Lx = Lx
self.Ly = Ly
self.Lz = Lz
def animate_slices_multi(field='uu1', datadir1='data/', datadir2='data/', proc=-1, extension='xz',
format='native', tmin=0., tmax=1.e38, wait=0.,
amin=0., amax=1., transform='', oldfile=False,
makemovie=False):
"""
read 2D slice files and assemble an animation.
version that does this for two different runs, neat for comparrison
runs must have same precision and sizes
Options:
field --- which variable to slice
datadir1 --- path to data directory of first simulation
datadir2 --- path to data directory of second imulation
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to modify the slice
wait --- pause in seconds between animation slices
"""
import pylab as plt
datadir1 = os.path.expanduser(datadir1)
if proc < 0:
filename1 = join(datadir1, 'slice_' + field + '.' + extension)
else:
filename1 = join(datadir1, 'proc' + str(proc),
'slice_' + field + '.' + extension)
datadir2 = os.path.expanduser(datadir2)
if proc < 0:
filename2 = join(datadir2, 'slice_' + field + '.' + extension)
else:
filename2 = join(datadir2, 'proc' + str(proc),
'slice_' + field + '.' + extension)
# Read the global dimensions.
dim = read_dim(datadir1, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane1 = np.zeros((vsize, hsize), dtype=precision)
plane2 = np.zeros((vsize, hsize), dtype=precision)
infile1 = npfile(filename1, endian=format)
infile2 = npfile(filename2, endian=format)
#ax = plt.axes()
#ax.set_xlabel('')
#ax.set_ylabel('')
#ax.set_ylim
#ax.get_xaxis().set_visible(False)
#ax.get_yaxis().set_visible(False)
fig, (ax1,ax2) = plt.subplots(1,2)
#fig.suptitle('Re = 400', fontsize=20)
image1 = ax1.imshow(plane1, vmin=amin, vmax=amax)
image2 = ax2.imshow(plane2, vmin=amin, vmax=amax)
ax1.set_xlabel('')
ax1.set_ylabel('')
ax1.get_xaxis().set_visible(False)
ax1.get_yaxis().set_visible(False)
ax2.set_xlabel('')
ax2.set_ylabel('')
ax2.get_xaxis().set_visible(False)
ax2.get_yaxis().set_visible(False)
# Get the figure manager for real-time image display.
manager = plt.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
files = []
while True:
try:
raw_data1 = infile1.fort_read(precision)
raw_data2 = infile2.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data1[-1]
plane1 = raw_data1[:-1].reshape(vsize, hsize)
plane2 = raw_data2[:-1].reshape(vsize, hsize)
else:
t = raw_data1[-2]
plane1 = raw_data1[:-2].reshape(vsize, hsize)
plane2 = raw_data2[:-2].reshape(vsize, hsize)
if transform:
exec('plane = plane' + transform)
if t > tmin and t < tmax:
title = 't = %11.3e' % t
#fig.set_title(title)
image1.set_data(plane1)
image2.set_data(plane2)
manager.canvas.draw()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" \ # Python 2
#% (islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plane1.min(), plane1.max(), plane1.max() - plane1.min()))
if(makemovie):
fname = '_tmp%03d.png' % islice
fig.savefig(fname)
files.append(fname)
ifirst = False
islice += 1
sleep(wait)
infile1.close()
infile2.close()
if(makemovie):
print('Making movie animation.mpg - this make take a while')
# SC: Not all systems use mencoder. Need to change this into ffmpeg.
os.system("mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg")
os.system("rm _tmp*.png")
def particles_to_density(xxp,yyp,zzp,x,y,z):
dim = read_dim()
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
nnp = np.zeros([dim.mz,dim.my,dim.mx])
npar=len(xxp)
for k in range(npar):
xp=xxp[k]
yp=yyp[k]
zp=zzp[k]
ix0=find_index_bisect(xp,x)
iy0=find_index_bisect(yp,y)
iz0=find_index_bisect(zp,z)
ixx0=ix0-1
ixx1=ix0+1
iyy0=iy0-1
iyy1=iy0+1
izz0=iz0-1
izz1=iz0+1
if (dim.nx > 1):
dx=x[ix0]-x[ixx0]
else:
dx=1.0
if (dim.ny > 1):
dy=y[iy0]-y[iyy0]
else:
dy=1.0
if (dim.nz > 1):
dz=z[iz0]-z[izz0]
else:
dz=1.0
dx_1=1.0/dx
dy_1=1.0/dy
dz_1=1.0/dz
#
dx_2=1.0/dx**2
dy_2=1.0/dy**2
dz_2=1.0/dz**2
#if (not ghost) then begin
# mx=nx+6 & l1=3 & l2=l1+nx-1
# x2=fltarr(mx)*one
# x2[l1:l2]=x
# for l=l1-1, 0,-1 do x2[l]=x2[l+1]-dx
# for l=l2+1,mx-1,+1 do x2[l]=x2[l-1]+dx
# x=x2
# my=ny+6 & m1=3 & m2=m1+ny-1
# y2=fltarr(my)*one
# y2[m1:m2]=y
# for m=m1-1, 0,-1 do y2[m]=y2[m+1]-dy
# for m=m2+1,my-1,+1 do y2[m]=y2[m-1]+dy
# y=y2
#;
# if (dim.nz == 1):
# for n in np.arange(3):
# nn=n+1
# z[dim.n1-nn]=z[dim.n1]-nn*dz
# z[dim.n2+nn]=z[dim.n2]+nn*dz
for ixx in np.arange(ixx0,ixx1+1):
for iyy in np.arange(iyy0,iyy1+1):
for izz in np.arange(izz0,izz1+1):
if ( ((ixx-ix0) == -1) or ((ixx-ix0) == +1) ):
weight_x = 1.125 - 1.5*abs(xp-x[ixx]) *dx_1 + 0.5*abs(xp-x[ixx])**2*dx_2
else:
if (dim.nx != 1): weight_x = 0.75 - (xp-x[ixx])**2*dx_2
if ( ((iyy-iy0) == -1) or ((iyy-iy0) == +1) ):
weight_y = 1.125 - 1.5*abs(yp-y[iyy]) *dy_1 + 0.5*abs(yp-y[iyy])**2*dy_2
else:
if (dim.ny != 1): weight_y = 0.75 - (yp-y[iyy])**2*dy_2
if ( ((izz-iz0) == -1) or ((izz-iz0) == +1) ):
weight_z = 1.125 - 1.5*abs(zp-z[izz]) *dz_1 + 0.5*abs(zp-z[izz])**2*dz_2
else:
if (dim.nz != 1): weight_z = 0.75 - (zp-z[izz])**2*dz_2
weight=1.0
if (dim.nx != 1): weight=weight*weight_x
if (dim.ny != 1): weight=weight*weight_y
if (dim.nz != 1): weight=weight*weight_z
#
nnp[izz,iyy,ixx]=nnp[izz,iyy,ixx] + weight
return nnp
def animate_slices(field='uu1', datadir='data/', proc=-1, extension='xz',
format='native', tmin=0., tmax=1.e38, wait=0.,
amin=0., amax=1., transform='', oldfile=False):
"""
read 2D slice files and assemble an animation.
Options:
field --- which variable to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to modify the slice
wait --- pause in seconds between animation slices
"""
import pylab as plt
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = join(datadir, 'slice_' + field + '.' + extension)
else:
filename = join(datadir, 'proc' + str(proc),
'slice_' + field + '.' + extension)
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = np.zeros((vsize, hsize), dtype=precision)
infile = npfile(filename, endian=format)
ax = plt.axes()
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_ylim
image = plt.imshow(plane, vmin=amin, vmax=amax)
# Get the figure manager for real-time image display.
manager = plt.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
while True:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[-1]
plane = raw_data[:-1].reshape(vsize, hsize)
else:
t = raw_data[-2]
plane = raw_data[:-2].reshape(vsize, hsize)
if transform:
exec('plane = plane' + transform)
if t > tmin and t < tmax:
title = 't = %11.3e' % t
ax.set_title(title)
image.set_data(plane)
manager.canvas.draw()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" \ # Python 2
#% (islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))
ifirst = False
islice += 1
sleep(wait)
infile.close()
def make_movie_crossflow(field='uu1', datadir='data/', proc=-1, extension='yz',
format='native', tmin=0., tmax=1.e38, amin=0., amax=1.,
transform='', oldfile=False):
"""
read 2D slice files and assemble an animation in a mpg movie.
Quickly written from the example at
http://matplotlib.sourceforge.net/faq/howto_faq.html
Options:
field --- which variable to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to modify the slice
"""
import pylab as plt
import matplotlib.patches as patches
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = datadir + '/slice_' + field + '.' + extension
else:
filename = datadir + '/proc' + \
str(proc) + '/slice_' + field + '.' + extension
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = np.zeros((vsize, hsize), dtype=precision)
infile = npfile(filename, endian=format)
files = []
fig = plt.figure(figsize=(5, 10))
ax = fig.add_subplot(111)
ax.add_patch(patches.Rectangle(
(220,0),
40,
320,
color='gray'
)
)
#
# ax.add_patch(patches.Rectangle(
# (220,0),
# 80,
# 240,
# hatch='/'
# )
# )
ifirst = True
islice = 0
while True:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[-1]
plane = raw_data[:-1].reshape(vsize, hsize)
else:
t = raw_data[-2]
plane = raw_data[:-2].reshape(vsize, hsize)
if transform:
exec('plane = plane' + transform)
if t > tmin and t < tmax:
ax.cla()
ax.imshow(plane, vmin=amin, vmax=amax)
ax.add_patch(patches.Rectangle(
(220,0),
40,
320,
color='gray'
)
)
fname = '_tmp%03d.png' % islice
print('Saving frame' + fname)
fig.savefig(fname)
files.append(fname)
def animate_slices_multi(field='uu1', datadir1='data/', datadir2='data/', proc=-1, extension='xz',
format='native', tmin=0., tmax=1.e38, wait=0.,
amin=0., amax=1., transform='', oldfile=False,
makemovie=False):
"""
read 2D slice files and assemble an animation.
version that does this for two different runs, neat for comparrison
runs must have same precision and sizes
Options:
field --- which variable to slice
datadir1 --- path to data directory of first simulation
datadir2 --- path to data directory of second imulation
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to modify the slice
wait --- pause in seconds between animation slices
"""
import pylab as plt
datadir1 = os.path.expanduser(datadir1)
if proc < 0:
filename1 = join(datadir1, 'slice_' + field + '.' + extension)
else:
filename1 = join(datadir1, 'proc' + str(proc),
'slice_' + field + '.' + extension)
datadir2 = os.path.expanduser(datadir2)
if proc < 0:
filename2 = join(datadir2, 'slice_' + field + '.' + extension)
else:
filename2 = join(datadir2, 'proc' + str(proc),
'slice_' + field + '.' + extension)
# Read the global dimensions.
dim = read_dim(datadir1, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane1 = np.zeros((vsize, hsize), dtype=precision)
plane2 = np.zeros((vsize, hsize), dtype=precision)
infile1 = npfile(filename1, endian=format)
infile2 = npfile(filename2, endian=format)
#ax = plt.axes()
#ax.set_xlabel('')
#ax.set_ylabel('')
#ax.set_ylim
#ax.get_xaxis().set_visible(False)
#ax.get_yaxis().set_visible(False)
fig, (ax1,ax2) = plt.subplots(1,2)
#fig.suptitle('Re = 400', fontsize=20)
image1 = ax1.imshow(plane1, vmin=amin, vmax=amax)
image2 = ax2.imshow(plane2, vmin=amin, vmax=amax)
ax1.set_xlabel('')
ax1.set_ylabel('')
ax1.get_xaxis().set_visible(False)
ax1.get_yaxis().set_visible(False)
ax2.set_xlabel('')
ax2.set_ylabel('')
ax2.get_xaxis().set_visible(False)
ax2.get_yaxis().set_visible(False)
# Get the figure manager for real-time image display.
manager = plt.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
files = []
while True:
try:
raw_data1 = infile1.fort_read(precision)
raw_data2 = infile2.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data1[-1]
plane1 = raw_data1[:-1].reshape(vsize, hsize)
plane2 = raw_data2[:-1].reshape(vsize, hsize)
else:
t = raw_data1[-2]
plane1 = raw_data1[:-2].reshape(vsize, hsize)
plane2 = raw_data2[:-2].reshape(vsize, hsize)
if transform:
exec('plane = plane' + transform)
if t > tmin and t < tmax:
title = 't = %11.3e' % t
#fig.set_title(title)
image1.set_data(plane1)
image2.set_data(plane2)
manager.canvas.draw()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" \ # Python 2
#% (islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plane1.min(), plane1.max(), plane1.max() - plane1.min()))
if(makemovie):
fname = '_tmp%03d.png' % islice
fig.savefig(fname)
files.append(fname)
ifirst = False
islice += 1
sleep(wait)
infile1.close()
infile2.close()
if(makemovie):
print('Making movie animation.mpg - this make take a while')
# SC: Not all systems use mencoder. Need to change this into ffmpeg.
os.system("mencoder 'mf://_tmp*.png' -mf type=png:fps=24 -ovc lavc -lavcopts vcodec=wmv2 -oac copy -o animation.mpg")
os.system("rm _tmp*.png")
def read_zaver(datadir='data/',format='native',point=(-1,-1),proc=-1):
"""read 2D zaverage.dat file. If proc < 0, then load all data
and assemble. Otherwise, load VAR file from specified processor.
point -- an array of 2-tuples (iy,ix) representing discrete
points to be returned in an output array (not implemented yet)
proc -- Read data from proc if proc > -1, otherwise load all and assemble.
returns a tuple (zavg, t), zavg has shape (noutputs,nvars,ny,nx)
"""
datadir = os.path.expanduser(datadir)
datatopdir = re.sub('data\/*$','',datadir)
# which variables are averaged?
infile = open(datatopdir+'zaver.in')
variables = [line.strip() for line in infile.readlines()]
infile.close()
# global dim
dim = read_dim(datadir, proc=proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
if proc < 0:
procdirs = list(filter(lambda s:s.startswith('proc'),
os.listdir(datadir)))
else:
procdirs = ['proc'+str(proc)]
for directory in procdirs:
ntime = 0
# local dimensions
core = int(directory[4:]) # SC: needed to rename proc to core to keep function argument
procdim = read_dim(datadir,core)
nxloc = procdim.nx
nyloc = procdim.ny
zaver_local = []
zaver_loc_shape = (len(variables),procdim.ny,procdim.nx)
#read data
filename = os.path.join(datadir,directory,'zaverages.dat')
try:
infile = npfile(filename,endian=format)
t = N.zeros(1,dtype=precision)
except:
continue
while 1:
try:
raw_data = infile.fort_read(precision,shape=1)
except ValueError:
break
except TypeError:
break
t = N.concatenate((t,raw_data))
try:
raw_data = infile.fort_read(precision,shape=zaver_loc_shape)
except ValueError:
#print "Problem: seems there is a t without corresponding data. zaverages.dat may be corrupted" # Python 2
print("Problem: seems there is a t without corresponding data. zaverages.dat may be corrupted")
break
except TypeError:
#print "Problem: seems there is a t without corresponding data. zaverages.dat may be corrupted" # Python
print("Problem: seems there is a t without corresponding data. zaverages.dat may be corrupted")
break
zaver_local.append(raw_data)
ntime += 1
try:
zaver
pass
except:
zaver = N.zeros((ntime,len(variables),dim.ny,dim.nx))
if (proc < 0):
# append to the global zaver
for i in range(ntime):
zaver[i,:,procdim.ipy*procdim.ny:(procdim.ipy+1)*procdim.ny,
procdim.ipx*procdim.nx:(procdim.ipx+1)*procdim.nx] = zaver_local[i]
else:
for i in range(ntime):
zaver[i,:,:,:] = zaver_local[i]
return zaver,t[1:]
def animate_slices(field='uu1', datadir='data/', proc=-1, extension='xz',
format='native', tmin=0., tmax=1.e38, wait=0.,
amin=0., amax=1., transform='', oldfile=False):
"""
read 2D slice files and assemble an animation.
Options:
field --- which variable to slice
datadir --- path to data directory
proc --- an integer giving the processor to read a slice from
extension --- which plane of xy,xz,yz,Xz. for 2D this should be overwritten.
format --- endian. one of little, big, or native (default)
tmin --- start time
tmax --- end time
amin --- minimum value for image scaling
amax --- maximum value for image scaling
transform --- insert arbitrary numerical code to modify the slice
wait --- pause in seconds between animation slices
"""
import pylab as plt
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = join(datadir, 'slice_' + field + '.' + extension)
else:
filename = join(datadir, 'proc' + str(proc),
'slice_' + field + '.' + extension)
# Read the global dimensions.
dim = read_dim(datadir, proc)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
# Set up slice plane.
if extension == 'xy' or extension == 'Xy':
hsize = dim.nx
vsize = dim.ny
if extension == 'xz':
hsize = dim.nx
vsize = dim.nz
if extension == 'yz':
hsize = dim.ny
vsize = dim.nz
plane = np.zeros((vsize, hsize), dtype=precision)
infile = npfile(filename, endian=format)
ax = plt.axes()
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_ylim
image = plt.imshow(plane, vmin=amin, vmax=amax)
# Get the figure manager for real-time image display.
manager = plt.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
while True:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = raw_data[-1]
plane = raw_data[:-1].reshape(vsize, hsize)
else:
t = raw_data[-2]
plane = raw_data[:-2].reshape(vsize, hsize)
if transform:
exec('plane = plane' + transform)
if t > tmin and t < tmax:
title = 't = %11.3e' % t
ax.set_title(title)
image.set_data(plane)
manager.canvas.draw()
if ifirst:
#print "----islice----------t---------min-------max-------delta" # Python 2
print("----islice----------t---------min-------max-------delta")
#print "%10i %10.3e %10.3e %10.3e %10.3e" \ # Python 2
#% (islice, t, plane.min(), plane.max(), plane.max() - plane.min()) # Python 2
print("{0:10} {1:10.3e} {2:10.3e} {3:10.3e} {4:10.3e}".format(islice, t, plane.min(), plane.max(), plane.max() - plane.min()))
ifirst = False
islice += 1
sleep(wait)
infile.close()
