def __init__(self,filename='zaverages.dat',datadir='data',infile='zaver.in',
record_length=4,read_deltay=False):
from re import compile
from dim import read_dim
from numpy import float32,float64,array
p = compile('mxy$')
fid = open(infile,'rt')
varnames = [p.sub('',line.strip()) for line in fid.readlines()]
fid.close()
while True:
try:
varnames.remove('')
except:
break
self.__varnames = varnames
dim = read_dim(datadir)
self.__dtype = {'S': lambda: float32, 'D': lambda: float64}[dim.precision]()
self.__shape = array((dim.nx,dim.ny,len(varnames)))
self.__count = self.__shape.prod()
self.__record_length = record_length
self.__file = open(datadir+'/'+filename,'rb')
self.__read_deltay = read_deltay
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 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 = datadir+'/slice_'+field+'.'+extension
else:
filename = datadir+'/proc'+str(proc)+'/slice_'+field+'.'+extension
# global dim
param = read_param(datadir, quiet=True)
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)
ifirst = True
islice = 0
t = N.zeros(1,dtype=precision)
slices = N.zeros(1,dtype=precision)
while 1:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = N.concatenate((t,raw_data[-1:]))
slices = N.concatenate((slices,raw_data[:-1]))
else:
t = N.concatenate((t,raw_data[-2:-1]))
slices = N.concatenate((slices,raw_data[:-2]))
islice += 1
output = slices[1:].reshape(islice,vsize,hsize)
return output,t[1:]
def 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 = datadir+'/slice_'+field+'.'+extension
else:
filename = datadir+'/proc'+str(proc)+'/slice_'+field+'.'+extension
# global dim
param = read_param(datadir, quiet=True)
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
infile = npfile(filename,endian=format)
ifirst = True
islice = 0
t = N.zeros(1,dtype=precision)
slices = N.zeros(1,dtype=precision)
while 1:
try:
raw_data = infile.fort_read(precision)
except ValueError:
break
except TypeError:
break
if oldfile:
t = N.concatenate((t,raw_data[-1:]))
slices = N.concatenate((slices,raw_data[:-1]))
else:
t = N.concatenate((t,raw_data[-2:-1]))
slices = N.concatenate((slices,raw_data[:-2]))
islice += 1
output = slices[1:].reshape(islice,vsize,hsize)
return output,t[1:]
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"
break
except TypeError:
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 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"
break
except TypeError:
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_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(getoutput('wc ' + datadir + '/' + varfile).split()[0])
datafile = open(datadir + '/' + varfile)
n_vars = len(variables)
# each line of data has 8 values
rec_length = 1 + n_vars * nz / 8
if nz % 8:
rec_length += 1
n_data_records = n_lines / rec_length
if (not quiet):
print "%s: reading %i records" % (__name__, 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_yzaver(varfile='yzaverages.dat',datadir='data/'):
"""read yz averaged data.
returns a class yzaver containing a 1D time array and a 2D t-z array.
"""
datadir = os.path.expanduser(datadir)
dim = read_dim(datadir=datadir)
nx = dim.nx
datatopdir = re.sub('data\/*$','',datadir)
infile = open(datatopdir+'yzaver.in')
variables = [line.strip() for line in infile.readlines()]
infile.close()
#gotta be a better way to do this...
n_lines = int(getoutput('wc '+datadir+'/'+varfile).split()[0])
datafile = open(datadir+'/'+varfile)
n_vars = len(variables)
# each line of data has 8 values
rec_length = 1 + n_vars*nx/8
if nx%8:
rec_length += 1
n_data_records = n_lines/rec_length
print "%s: reading %i records" % (__name__,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=nx,sep=' '))
datafile.close()
#pack data into a class
yzaver = YzAver()
yzaver.t = N.array(t)
for var in variables:
setattr(yzaver,var,N.array(var_tmp[var]))
return yzaver
def __init__(self,
filename='zaverages.dat',
datadir='data',
infile='zaver.in',
record_length=4,
read_deltay=False):
from re import compile
from dim import read_dim
from numpy import float32, float64, array
p = compile('mxy$')
fid = open(infile, 'rt')
varnames = [p.sub('', line.strip()) for line in fid.readlines()]
fid.close()
while True:
try:
varnames.remove('')
except:
break
self.__varnames = varnames
dim = read_dim(datadir)
self.__dtype = {
'S': lambda: float32,
'D': lambda: float64
}[dim.precision]()
self.__shape = array((dim.nx, dim.ny, len(varnames)))
self.__count = self.__shape.prod()
self.__record_length = record_length
self.__file = open(datadir + '/' + filename, 'rb')
self.__read_deltay = read_deltay
def __init__(self,
datadir='data/',
proc=-1,
ivar=-1,
quiet=False,
trim=False,
format='native',
param=None):
"""
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)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
if proc < 0:
procdirs = 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)
if not quiet:
print "reading data from processor %i of %i ..." \
% (proc, len(procdirs))
mxloc = procdim.mx
myloc = procdim.my
mzloc = procdim.mz
#read data
filename = os.path.join(datadir, directory, 'grid.dat')
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 __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 = N.zeros((totalvars, dim.mz, dim.my, dim.mx), dtype=precision)
else:
if dim.ny == 1:
f = N.zeros((totalvars, dim.mz, dim.mx), dtype=precision)
else:
f = N.zeros((totalvars, dim.my, dim.mx), dtype=precision)
x = N.zeros(dim.mx, dtype=precision)
y = N.zeros(dim.my, dtype=precision)
z = N.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 ..." \
% (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 index.has_key('uu'):
self.uu = self.f[index['ux'] - 1:index['uz'], ...]
if index.has_key('aa'):
self.aa = self.f[index['ax'] - 1:index['az'], ...]
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 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
"""
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = datadir+'/slice_'+field+'.'+extension
else:
filename = datadir+'/proc'+str(proc)+'/slice_'+field+'.'+extension
# global dim
param = read_param(datadir)
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 = N.zeros((vsize,hsize),dtype=precision)
infile = npfile(filename,endian=format)
ax = P.axes()
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_ylim
image = P.imshow(plane,vmin=amin,vmax=amax)
# for real-time image display
manager = P.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
while 1:
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:
slice_z2pos = raw_data[-1]
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"
print "%10i %10.3e %10.3e %10.3e %10.3e" % (islice,t,plane.min(),plane.max(),plane.max()-plane.min())
ifirst = False
islice += 1
sleep(wait)
infile.close()
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
"""
datadir = os.path.expanduser(datadir)
if proc < 0:
filename = datadir+'/slice_'+field+'.'+extension
else:
filename = datadir+'/proc'+str(proc)+'/slice_'+field+'.'+extension
# global dim
param = read_param(datadir)
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 = N.zeros((vsize,hsize),dtype=precision)
infile = npfile(filename,endian=format)
files = []
fig = P.figure(figsize=(5,10))
ax = fig.add_subplot(111)
ifirst = True
islice = 0
while 1:
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:
slice_z2pos = raw_data[-1]
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"
print "%10i %10.3e %10.3e %10.3e %10.3e" % (islice,t,plane.min(),plane.max(),plane.max()-plane.min())
ifirst = False
islice += 1
print 'Making movie animation.mpg - this make take a while'
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
"""
datadir = os.path.expanduser(datadir)
if outfile != "":
outslice=file(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]
# global dim
param = read_param(datadir)
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 += [N.zeros((vsize,hsize),dtype=precision)]
infile += [npfile(i,endian=format)]
ifirst = True
islice = 0
plotplane=[]
dt=0
nextt=tmin
while 1:
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:
slice_z2pos = raw_data[0][-1]
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"
print "%10i %10.3e %10.3e %10.3e %10.3e" % (islice,t,tempplane.min(),tempplane.max(),tempplane.max()-tempplane.min())
if outfile != "":
outslice.write("%10i %10.3e %10.3e %10.3e %10.3e" % (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 = P.axes()
ax.set_xlabel('t')
ax.set_ylabel('y')
ax.set_ylim
image = P.imshow(N.array(plotplane).reshape(islice,vsize).transpose(),vmin=amin,vmax=amax)
manager = P.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
"""
datadir = os.path.expanduser(datadir)
if outfile != "":
outslice=file(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]
# global dim
param = read_param(datadir)
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 += [N.zeros((vsize,hsize),dtype=precision)]
infile += [npfile(i,endian=format)]
ax = P.axes()
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_ylim
exec('plotplane ='+transform)
image = P.imshow(plotplane,vmin=amin,vmax=amax)
# for real-time image display
manager = P.get_current_fig_manager()
manager.show()
ifirst = True
islice = 0
while 1:
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:
slice_z2pos = raw_data[0][-1]
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"
print "%10i %10.3e %10.3e %10.3e %10.3e" % (islice,t,plotplane.min(),plotplane.max(),plotplane.max()-plotplane.min())
if outfile != "":
outslice.write("%10i %10.3e %10.3e %10.3e %10.3e" % (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 ..." \
% (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 index.has_key('uu'):
self.uu = self.f[index['ux']-1:index['uz'],...]
if index.has_key('aa'):
self.aa = self.f[index['ax']-1:index['az'],...]
# Also treat Fcr (from cosmicrayflux) as a vector.
if index.has_key('fcr'):
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):
"""
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)
if dim.precision == 'D':
precision = 'd'
else:
precision = 'f'
if proc < 0:
procdirs = 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)
if not quiet:
print "reading data from processor %i of %i ..." \
% (proc, len(procdirs))
mxloc = procdim.mx
myloc = procdim.my
mzloc = procdim.mz
#read data
filename = os.path.join(datadir, directory, 'grid.dat')
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_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 = file(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"
print "%10i %10.3e %10.3e %10.3e %10.3e" % \
(islice, t, plotplane.min(), plotplane.max(),
plotplane.max() - plotplane.min())
if outfile != "":
outslice.write("%10i %10.3e %10.3e %10.3e %10.3e" %
(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 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 = 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"
break
except TypeError:
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"
print "%10i %10.3e %10.3e %10.3e %10.3e" \
% (islice, t, plane.min(), plane.max(), plane.max() - plane.min())
ifirst = False
islice += 1
sleep(wait)
infile.close()
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"
print "%10i %10.3e %10.3e %10.3e %10.3e" % \
(islice, t, plane.min(), plane.max(), plane.max() - plane.min())
ifirst = False
islice += 1
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 = file(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"
print "%10i %10.3e %10.3e %10.3e %10.3e" % \
(islice, t, tempplane.min(), tempplane.max(),
tempplane.max() - tempplane.min())
if outfile != "":
outslice.write(
"%10i %10.3e %10.3e %10.3e %10.3e" %
(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()
