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 __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 __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 = 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([s for s in os.listdir(datadir) if s.startswith('proc')]) 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 list(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: self.uu = self.f[index['ux']-1:index['uz'],...] if 'aa' in index: 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)