def get_rmv_info():
datadir='data';
fname='data/proc0/rmv_par.dat'
mpvar=get_mpvar(datadir);
precision=get_precision(datadir);
npf = npfile.npfile(fname)
lno=0
temp_pos=[];
temp_vel=[];
pxx=np.zeros(3);
puu=np.zeros(3);
while True:
try:
xx=npf.fort_read(dt=np.float64);
pxx=xx[0:3];
puu=xx[3:6];
temp_pos.append(pxx);
temp_vel.append(puu);
lno=lno+1;
except TypeError:
break;
rmv_ppos=np.zeros([lno,3]);
rmv_pvel=np.zeros([lno,3]);
for ino in range(0,lno):
rmv_ppos[ino,:]=temp_pos[ino];
rmv_pvel[ino,:]=temp_vel[ino];
return rmv_ppos,rmv_pvel;
def get_rmv_info():
datadir='data';
fname='data/proc0/rmv_par.dat'
mpvar=get_mpvar(datadir);
precision=get_precision(datadir);
npf = npfile.npfile(fname)
lno=0
temp_pos=[];
temp_vel=[];
pxx=np.zeros(3);
puu=np.zeros(3);
while True:
try:
xx=npf.fort_read(dt=np.float64);
pxx=xx[0:3];
puu=xx[3:6];
temp_pos.append(pxx);
temp_vel.append(puu);
lno=lno+1;
except TypeError:
break;
rmv_ppos=np.zeros([lno,3]);
rmv_pvel=np.zeros([lno,3]);
for ino in range(0,lno):
rmv_ppos[ino,:]=temp_pos[ino];
rmv_pvel[ino,:]=temp_vel[ino];
return rmv_ppos,rmv_pvel;
def get_rmv_info():
datadir = 'data'
fname = 'data/proc0/rmv_par.dat'
mpvar = get_mpvar(datadir)
precision = get_precision(datadir)
npf = npfile.npfile(fname)
lno = 0
temp_pos = []
temp_vel = []
pxx = np.zeros(3)
puu = np.zeros(3)
while True:
try:
xx = npf.fort_read(dt=np.float64)
pxx = xx[0:3]
puu = xx[3:6]
temp_pos.append(pxx)
temp_vel.append(puu)
lno = lno + 1
except TypeError:
break
rmv_ppos = np.zeros([lno, 3])
rmv_pvel = np.zeros([lno, 3])
for ino in range(0, lno):
rmv_ppos[ino, :] = temp_pos[ino]
rmv_pvel[ino, :] = temp_vel[ino]
return rmv_ppos, rmv_pvel
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" # 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 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 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 __read_slice(self,override,timeslice=False,field=0, extension='xz',proc=-1,format='native',oldfile=False):
"""
read one 2D slice files and write the array of (nslices,vsize,hsize) in '/data/slices'.
As all timeslices should be identical, only the first one is to be stocked in a common array
for all slices. By default, it is not stocked. Set timeslice to True for updating it (erase it if present)
Should only called by __read_slices.
"""
#print self.data['slices_names'][field]+"; "+extension+"; proc"+str(proc)+" ...", # Python 2
print(self.data['slices_names'][field]+"; "+extension+"; proc"+str(proc)+" ...")
if timeslice:
if self.data.listnames().count('slices_time')>0:
del(self.data['slices_time'])
t=self.data.create_dataset('slices_time',(1,),dtype=self.precision,maxshape=(None,))
if proc < 0:
#print "Please provide the proc number." # Python 2
print("Please provide the proc number.")
return timeslice
filename = os.path.join(self.datadir,'proc'+str(proc),'slice_'+self.data['slices_names'][field]+'.'+extension)
try:
infile = npfile(filename,endian=format)
except IOError: # Current slice not present for this proc
# print "Bad file "+filename
return timeslice
# set up slice plane
newly=True # If the slices have been previously been created, it will be set to False
if (extension == 'xy' or extension == 'xy2'):
hsize = self.param['dim/nx'][0] # global dimensions
vsize = self.param['dim/ny'][0]
hsizep = self.param['dim/nx'][proc+1] # local dimensions
vsizep = self.param['dim/ny'][proc+1]
offh= hsizep*self.param['dim/ipx'][proc+1] # local offset
offv= vsizep*self.param['dim/ipy'][proc+1]
elif (extension == 'xz'):
hsize = self.param['dim/nx'][0]
vsize = self.param['dim/nz'][0]
hsizep = self.param['dim/nx'][proc+1] # local dimensions
vsizep = self.param['dim/nz'][proc+1]
offh= hsizep*self.param['dim/ipx'][proc+1] # local offset
offv= vsizep*self.param['dim/ipz'][proc+1]
elif (extension == 'yz'):
hsize = self.param['dim/ny'][0]
vsize = self.param['dim/nz'][0]
hsizep = self.param['dim/ny'][proc+1] # local dimensions
vsizep = self.param['dim/nz'][proc+1]
offh= hsizep*self.param['dim/ipy'][proc+1] # local offset
offv= vsizep*self.param['dim/ipz'][proc+1]
else:
#print "Bad slice name "+extension # Python 2
print("Bad slice name "+extension)
return timeslice
if self.data.listnames().count('slices_'+extension)==0:
slices=self.data.create_dataset('slices_'+extension,(1,self.nbslices,vsize,hsize),dtype=self.precision,maxshape=(None,self.nbslices,vsize,hsize))
else:
slices=self.data['slices_'+extension]
act_slice=slices.shape[0]-1
islice = 0
if oldfile:
cutoff=-1
else:
cutoff=-2
while 1:
try: # read one time slice
raw_data = infile.fort_read(self.precision)
except ValueError:
break
except TypeError:
break
# add the new time to the time datase, and the slice at its position
if timeslice:
if islice==0:
t[0]=raw_data[cutoff:][0]
else:
append(t,raw_data[cutoff:][0])
if islice>act_slice:
slices.resize((islice+1,self.nbslices,vsize,hsize))
if override or islice>=self.__last_timeslice:
slices[islice,field,offv:offv+vsizep,offh:offh+hsizep] = raw_data[:cutoff].reshape(vsizep,hsizep)
islice += 1
return False
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 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 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 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 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 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 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 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 __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_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,
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 __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 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:]
