def plot_to_grid(grid_parameters, primary_variables, secondary_variables, number): # Get the shape from the grid parameters point_x = grid_parameters[0] point_y = grid_parameters[1] point_z = grid_parameters[2] nv, nu, nw = point_x.shape # "Unpack" the primary flow variables ro = primary_variables[0] ro_vel_x = primary_variables[1] ro_vel_y = primary_variables[2] ro_energy = primary_variables[3] # "Unpack" the existing secondary flow variables vel_x = secondary_variables[0] vel_y = secondary_variables[1] pressure = secondary_variables[2] enthalpy_stag = secondary_variables[3] # mach number velocity_magnitude = np.zeros((nv, nu, nw)) for j in range(0, nv): for i in range(0, nu): velocity_magnitude[j,i,0] = np.sqrt( vel_x[j,i,0] * vel_x[j,i,0] + vel_y[j,i,0] * vel_y[j,i,0] ) filename = "./output"+str(number) gridToVTK(filename, point_x, point_y, point_z, pointData={"pressure": pressure, "density": ro, "vel-x": vel_x, "vel-y": vel_y , "vel-mag": velocity_magnitude})
def rcut2vtk(self, fname, data, r, name): """ This routine transforms a radial cut of dimension (n_phi,n_theta) into a vts file. :param fname: file name :type fname: str :param data: input data :type data: numpy.ndarray :param r: radius of the selected cut :type r: float :param name: name of the physical field stored in the vts file :type name: str """ data = symmetrize(data, self.minc) phi = np.linspace(0., 2.*np.pi, data.shape[0]) X = np.zeros((data.shape[0], data.shape[1], 1), dtype=np.float32) Y = np.zeros_like(X) Z = np.zeros_like(X) ttheta, pphi = np.meshgrid(self.theta, phi) X[:, :, 0] = r*np.sin(ttheta)*np.cos(pphi) Y[:, :, 0] = r*np.sin(ttheta)*np.sin(pphi) Z[:, :, 0] = r*np.cos(ttheta) dat = np.zeros_like(X) point_data = {} dat[..., 0] = data point_data[name] = dat gridToVTK(fname, X, Y, Z, pointData=point_data) print('Store {}.vts'.format(fname))
def export_to_vtk(self, vtk_filename="geo_grid", real_coords = True, **kwds): """Export grid to VTK for visualisation **Arguments**: - *vtk_filename* = string : vtk filename (obviously...) - *real_coords* = bool : model extent in "real world" coordinates **Optional Keywords**: - *grid* = numpy grid : grid to save to vtk (default: self.grid) - *var_name* = string : name of variable to plot (default: Geology) Note: requires pyevtk, available at: https://bitbucket.org/pauloh/pyevtk """ grid = kwds.get("grid", self.grid) var_name = kwds.get("var_name", "Geology") from evtk.hl import gridToVTK # define coordinates x = np.zeros(self.nx + 1) y = np.zeros(self.ny + 1) z = np.zeros(self.nz + 1) x[1:] = np.cumsum(self.delx) y[1:] = np.cumsum(self.dely) z[1:] = np.cumsum(self.delz) # plot in coordinates if real_coords: x += self.xmin y += self.ymin z += self.zmin gridToVTK(vtk_filename, x, y, z, cellData = {var_name: grid})
def scal3D2vtk(self, fname, data, name): """ This routine transforms a 3-D scalar field of dimension (n_phi,n_theta,n_r) into a vts file. :param fname: file name :type fname: str :param data: input data :type data: numpy.ndarray :param r: radius of the selected cut :type r: float :param name: name of the physical field stored in the vts file :type name: str """ data = symmetrize(data, self.minc) phi = np.linspace(0., 2.*np.pi, data.shape[0]) X = np.zeros(data.shape, dtype=np.float32) Y = np.zeros_like(X) Z = np.zeros_like(X) ttheta, pphi, rr = np.meshgrid(self.theta, phi, self.radius) X = rr*np.sin(ttheta)*np.cos(pphi) Y = rr*np.sin(ttheta)*np.sin(pphi) Z = rr*np.cos(ttheta)*np.ones_like(pphi) point_data = {} point_data[name] = data gridToVTK(fname, X, Y, Z, pointData=point_data) print('Store {}.vts'.format(fname))
def plotvtk(x,y,name,fields): """ Dump solution to a VTK after flipping it. """ z = array([0.0]) Nx = len(x) Ny = len(y) transform = {k : flipud(v.T).reshape(Ny,Nx,1) for k,v in fields.items()} gridToVTK("./{}".format(name), x, y, z, pointData = transform)
def mer2vtk(self, fname, data, phi0, name): """ This routine transforms a meridional cut of dimension (n_theta,n_r) into a vts file. :param fname: file name :type fname: str :param data: input data :type data: numpy.ndarray :param phi0: longitude of the selected cut :type phi0: float :param name: name of the physical field stored in the vts file :type name: str """ X = np.zeros((1, data.shape[0], data.shape[1]), dtype=np.float32) Y = np.zeros_like(X) Z = np.zeros_like(X) rr, ttheta = np.meshgrid(self.radius, self.theta) X[0, :, :] = rr*np.sin(ttheta)*np.cos(phi0) Y[0, :, :] = rr*np.sin(ttheta)*np.sin(phi0) Z[0, :, :] = rr*np.cos(ttheta) dat = np.zeros_like(X) dat[0, ...] = data point_data = {} point_data[name] = dat gridToVTK(fname, X, Y, Z, pointData=point_data) print('Store {}.vts'.format(fname))
def NParray2VTK(npmodel,dims,scale,vtkfilename): # Dimensions # x, y & z Number of Voxels nx, ny, nz = dims[0], dims[1], dims[2] # x, y & z Length lx , ly, lz = scale, scale, scale # x, y & z Voxel size dx, dy, dz = lx/nx, ly/ny, lz/nz # all equal # Coordinates - change to real pos later? # +0.1*dx used to get end value in arange X = np.arange(0,lx+0.1*dx,dx, dtype='float64') Y = np.arange(0,ly+0.1*dy,dy, dtype='float64') Z = np.arange(0,lz+0.1*dz,dz, dtype='float64') # x, y & z empty arrays x = np.zeros((nx + 1, ny + 1, nz + 1)) y = np.zeros((nx + 1, ny + 1, nz + 1)) z = np.zeros((nx + 1, ny + 1, nz + 1)) # Loop to fill position arrays for k in range(nz + 1): for j in range(ny + 1): for i in range(nx + 1): x[i,j,k] = X[i] y[i,j,k] = Y[j] z[i,j,k] = Z[k] # write to VTK file vtkfilename = "./%s" % vtkfilename gridToVTK(vtkfilename, x, y, z, cellData = {vtkfilename : npmodel.astype(int)})
def write_cov_vtk_file(self, cov_vtk_fn, model_fn=None, grid_east=None, grid_north=None, grid_z=None): """ write a vtk file of the covariance to match things up """ if model_fn is not None: m_obj = Model() m_obj.read_model_file(model_fn) grid_east = m_obj.grid_east grid_north = m_obj.grid_north grid_z = m_obj.grid_z if grid_east is not None: grid_east = grid_east if grid_north is not None: grid_north = grid_north if grid_z is not None: grid_z = grid_z # use cellData, this makes the grid properly as grid is n+1 gridToVTK(cov_vtk_fn, grid_north / 1000., grid_east / 1000., grid_z / 1000., cellData={'covariance_mask': self.mask_arr}) self._logger.info('Wrote covariance file to {0}\n'.format(cov_vtk_fn))
def save_eostab_to_vtk(eosmat, filename): for view in ['DT']: for spec in ['e', 'i', 't']: pattern = '_'.join([spec,view]) ftables = [el for el in eosmat.tables if pattern in el] if len(ftables): xl = [] yl = [] data = {} for tab_name in ftables: tab = getattr(eosmat, tab_name) xl.append(tab['R_Array']) yl.append(tab['T_Array']) data[tab_name] = _3d_reshape(tab['F_Array']) for x in xl: assert_allclose(x,xl[0]) for y in xl: assert_allclose(y,xl[0]) X, Y = np.meshgrid(x,y, indexing='ij') X = _3d_reshape(X) Y = _3d_reshape(Y) Z = np.zeros(X.shape) #print X gridToVTK("./{0}".format(filename), X, Y, Z, pointData=data)
def NParray2VTK(npmodel, dims, scale, vtkfilename): # Dimensions # x, y & z Number of Voxels nx, ny, nz = dims, dims, dims # x, y & z Length lx, ly, lz = scale, scale, scale # x, y & z Voxel size dx, dy, dz = lx / nx, ly / ny, lz / nz # all equal # Coordinates - change to real pos later? # +0.1*dx used to get end value in arange X = np.arange(0, lx + 0.1 * dx, dx, dtype='float64') Y = np.arange(0, ly + 0.1 * dy, dy, dtype='float64') Z = np.arange(0, lz + 0.1 * dz, dz, dtype='float64') # x, y & z empty arrays x = np.zeros((nx + 1, ny + 1, nz + 1)) y = np.zeros((nx + 1, ny + 1, nz + 1)) z = np.zeros((nx + 1, ny + 1, nz + 1)) # Loop to fill position arrays for k in range(nz + 1): for j in range(ny + 1): for i in range(nx + 1): x[i, j, k] = X[i] y[i, j, k] = Y[j] z[i, j, k] = Z[k] # write to VTK file vtkfilename = "./%s" % vtkfilename gridToVTK(vtkfilename, x, y, z, cellData={vtkfilename: npmodel.astype(int)})
def save_eostab_to_vtk(eosmat, filename): for view in ['DT']: for spec in ['e', 'i', 't']: pattern = '_'.join([spec, view]) ftables = [el for el in eosmat.tables if pattern in el] if len(ftables): xl = [] yl = [] data = {} for tab_name in ftables: tab = getattr(eosmat, tab_name) xl.append(tab['R_Array']) yl.append(tab['T_Array']) data[tab_name] = _3d_reshape(tab['F_Array']) for x in xl: assert_allclose(x, xl[0]) for y in xl: assert_allclose(y, xl[0]) X, Y = np.meshgrid(x, y, indexing='ij') X = _3d_reshape(X) Y = _3d_reshape(Y) Z = np.zeros(X.shape) #print X gridToVTK("./{0}".format(filename), X, Y, Z, pointData=data)
def equat2vtk(self, fname, data, name): """ This routine transforms an equatorial cut of dimension (n_phi,n_r) into a vts file. :param fname: file name :type fname: str :param data: input data :type data: numpy.ndarray :param name: name of the physical field stored in the vts file :type name: str """ data = symmetrize(data, self.minc) phi = np.linspace(0., 2.*np.pi, data.shape[0]) X = np.zeros((1, data.shape[0], data.shape[1]), dtype=np.float32) Y = np.zeros_like(X) Z = np.zeros_like(X) rr, pphi = np.meshgrid(self.radius, phi) X[0, :, :] = rr*np.cos(pphi) Y[0, :, :] = rr*np.sin(pphi) dat = np.zeros_like(X) dat[0, ...] = data point_data = {} point_data[name] = dat gridToVTK(fname, X, Y, Z, pointData=point_data) print('Store {}.vts'.format(fname))
def export_to_vtk(self, **kwds): """Export model to VTK Export the geology blocks to VTK for visualisation of the entire 3-D model in an external VTK viewer, e.g. Paraview. ..Note:: Requires pyevtk, available for free on: https://github.com/firedrakeproject/firedrake/tree/master/python/evtk **Optional keywords**: - *vtk_filename* = string : filename of VTK file (default: output_name) - *data* = np.array : data array to export to VKT (default: entire block model) """ vtk_filename = kwds.get("vtk_filename", self.basename) from evtk.hl import gridToVTK # Coordinates x = np.arange(0, self.extent_x + 0.1*self.delx, self.delx, dtype='float64') y = np.arange(0, self.extent_y + 0.1*self.dely, self.dely, dtype='float64') z = np.arange(0, self.extent_z + 0.1*self.delz, self.delz, dtype='float64') # self.block = np.swapaxes(self.block, 0, 2) if kwds.has_key("data"): gridToVTK(vtk_filename, x, y, z, cellData = {"data" : kwds['data']}) else: gridToVTK(vtk_filename, x, y, z, cellData = {"geology" : self.block})
def export_to_vtk(self, grid, name, **kwds): """Export model to VTK Export grid to VTK for visualisation of the entire 3-D model in an external VTK viewer, e.g. Paraview. ..Note:: Requires pyevtk, available for free on: https://github.com/firedrakeproject/firedrake/tree/master/python/evtk """ vtk_filename = "GBasin_%s" % name from evtk.hl import gridToVTK # Coordinates, from one output file NO_tmp = self.load_output_file(0) x = np.arange(0, NO_tmp.extent_x + 0.1 * NO_tmp.delx, NO_tmp.delx, dtype='float64') y = np.arange(0, NO_tmp.extent_y + 0.1 * NO_tmp.dely, NO_tmp.dely, dtype='float64') z = np.arange(0, NO_tmp.extent_z + 0.1 * NO_tmp.delz, NO_tmp.delz, dtype='float64') # self.block = np.swapaxes(self.block, 0, 2) gridToVTK(vtk_filename, x, y, z, cellData={"%s" % name: grid})
def opg_op2vtk(data, fname): x = data['dens'][:] y = data['temp'][:] z = 0.5 * (data['groups'][1:] + data['groups'][:-1]) #X, Y, Z = meshgrid_nd(x, y,z) pointData = {key: data[key][:] for key in ['opp_mg', 'opr_mg', 'emp_mg']} gridToVTK(fname, x, y, z, pointData=pointData)
def opg_op2vtk(data, fname): x = data['dens'][:] y = data['temp'][:] z = 0.5*(data['groups'][1:] + data['groups'][:-1]) #X, Y, Z = meshgrid_nd(x, y,z) pointData = {key: data[key][:] for key in ['opp_mg', 'opr_mg', 'emp_mg']} gridToVTK(fname, x, y, z, pointData = pointData)
def arrayToVTKfile(vtkfilename,array,dims,scale,translate,voxelsize): #def main(binvoxfile): # OPEN BINVOX FILE AS NP ARRAY # buffer 3d array #olddims = tempmodel.dims # old dims before buffer #oldscale = tempmodel.scale # old scale before buffer #oldtranslate = tempmodel.translate # old translate before buffer #voxelsize = oldscale/olddims[0] #print "voxelsize = %s " % (voxelsize) # BUFFER THE ARRAY #model = np.zeros( (olddims[0]+2,olddims[1]+2,olddims[2]+2)) #model[1:olddims[0]+1,1:olddims[1]+1,1:olddims[2]+1]=tempmodel.data #dims = [x+2 for x in olddims] #print dims #scale = oldscale + 2*voxelsize #translate = [x-voxelsize for x in oldtranslate] # WRITE TO VTK #dims = dims[0] #vtkfilename = binvoxfile.replace(".binvox","") # Dimensions # x, y & z Number of Voxels nx, ny, nz = dims,dims,dims # x, y & z Length lx , ly, lz = scale,scale,scale # x, y & z Voxel size dx, dy, dz = lx/nx, ly/ny, lz/nz # all equal # Coordinates - change to real pos later? # +0.1*dx used to get end value in arange X = np.arange(0,lx+0.1*dx,dx, dtype='float64') Y = np.arange(0,ly+0.1*dy,dy, dtype='float64') Z = np.arange(0,lz+0.1*dz,dz, dtype='float64') # x, y & z empty arrays x = np.zeros((nx + 1, ny + 1, nz + 1)) y = np.zeros((nx + 1, ny + 1, nz + 1)) z = np.zeros((nx + 1, ny + 1, nz + 1)) # Loop to fill position arrays for k in range(nz + 1): for j in range(ny + 1): for i in range(nx + 1): x[i,j,k] = X[i] y[i,j,k] = Y[j] z[i,j,k] = Z[k] # write to VTK file vtkfilename = "./%s" % vtkfilename gridToVTK(vtkfilename, x, y, z, cellData = {vtkfilename : array.astype(int)}) #if __name__ == "__main__": #main("testGeom_64.binvox") #main("montreal131.binvox")
def model2vtkgrid(ModEMmodelfn,VTKfn='VTKresistivitymodel' ): """ Convert ModEM output files (model and responses) into 3D VTK resistivity grid Input: - ModEM model name - [optional] VTK resistivity grid file - output file name """ if not os.path.isfile(os.path.abspath(os.path.realpath(ModEMmodelfn))): sys.exit('ERROR - could not find file:\n%s'%(os.path.abspath(os.path.realpath(ModEMmodelfn)))) if not os.path.isfile(os.path.abspath(os.path.realpath(VTKfn))): VTKfn = os.path.abspath(os.path.realpath('VTKresistivitymodel')) F = open(ModEMmodelfn, 'r') raw_data = F.readlines() F.close() coords_list = mdt.getmeshblockcoordinates(ModEMmodelfn) n_north_blocks = len(coords_list[0]) n_east_blocks = len(coords_list[1]) n_depth_blocks = len(coords_list[2]) res_model = np.zeros((n_north_blocks,n_east_blocks,n_depth_blocks)) current_line_idx = 5 for idx_depth in range(n_depth_blocks): #catering for the empty line between depths current_line_idx += 1 for idx_east in range(n_east_blocks): #use North-to-South convention in the grid!! current_line = raw_data[current_line_idx] lo_data_tmp = current_line.strip().split() for idx_north in range(n_north_blocks): res_model[idx_north,idx_east, idx_depth] = np.exp(float(lo_data_tmp[idx_east]) ) current_line_idx +=1 #transfer grid to km instead of m #use North-to-South convention in the grid!! coords_list[0].reverse() N = np.array(coords_list[0])/1000. E = np.array(coords_list[1])/1000. D = np.array(coords_list[2])/1000. gridToVTK(VTKfn, N, E, D, cellData = {'resistivity (in Ohm)' : res_model}) print('Created Resistivity File: ',VTKfn) return VTKfn
def writeAllToParaview(self,start=0,end=100000,skip=1): grid = np.load('../DGgrid.npz') x,y,z = np.meshgrid(grid['x'],grid['y'],grid['z'],indexing='ij') for i in range(0,end,skip): sol_str = 'npsol' + str(i) + '.npz' if (os.path.isfile(sol_str)): print('found ' + sol_str) sol = np.load('npsol' + str(i) + '.npz') string = 'PVsol' + str(i) gridToVTK(string, x,y,z, pointData = {"rho" : sol['U'][0] , \ "u" : sol['U'][1]/sol['U'][0] , "v" : sol['U'][2], "w" : sol['U'][3]/sol['U'][0], \ "rhoE" : sol['U'][4]} )
def model2vtkgrid(ModEMmodelfn, VTKfn='VTKresistivitymodel'): """ Convert ModEM output files (model and responses) into 3D VTK resistivity grid Input: - ModEM model name - [optional] VTK resistivity grid file - output file name """ if not os.path.isfile(os.path.abspath(os.path.realpath(ModEMmodelfn))): sys.exit('ERROR - could not find file:\n%s' % (os.path.abspath(os.path.realpath(ModEMmodelfn)))) if not os.path.isfile(os.path.abspath(os.path.realpath(VTKfn))): VTKfn = os.path.abspath(os.path.realpath('VTKresistivitymodel')) F = open(ModEMmodelfn, 'r') raw_data = F.readlines() F.close() coords_list = mdt.getmeshblockcoordinates(ModEMmodelfn) n_north_blocks = len(coords_list[0]) n_east_blocks = len(coords_list[1]) n_depth_blocks = len(coords_list[2]) res_model = np.zeros((n_north_blocks, n_east_blocks, n_depth_blocks)) current_line_idx = 5 for idx_depth in range(n_depth_blocks): # catering for the empty line between depths current_line_idx += 1 for idx_east in range(n_east_blocks): # use North-to-South convention in the grid!! current_line = raw_data[current_line_idx] lo_data_tmp = current_line.strip().split() for idx_north in range(n_north_blocks): res_model[idx_north, idx_east, idx_depth] = np.exp(float(lo_data_tmp[idx_east])) current_line_idx += 1 # transfer grid to km instead of m # use North-to-South convention in the grid!! coords_list[0].reverse() N = np.array(coords_list[0]) / 1000. E = np.array(coords_list[1]) / 1000. D = np.array(coords_list[2]) / 1000. gridToVTK(VTKfn, N, E, D, cellData={'resistivity (in Ohm)': res_model}) print 'Created Resistivity File: ', VTKfn return VTKfn
def saveVTK(filename, i, j): ind = numpy.arange(0, len(i)*len(j), dtype = 'uint32') temp = numpy.zeros((1), dtype = 'int32') def fun(x,y): array = numpy.zeros((len(x),len(y))) for i in range(len(x)): array[i, :] = x[i]*y return array dictionary = {'whatever': fun(i,j)[:,None]} evtk.gridToVTK(filename, i, j, temp, pointData = dictionary)
def export_vtk_rectilinear(geo_data, block, path=None): """ Export data to a vtk file for posterior visualizations Args: geo_data(gempy.InputData): All values of a DataManagement object block(numpy.array): 3D array containing the lithology block path (str): path to the location of the vtk Returns: None """ from evtk.hl import gridToVTK import numpy as np import random as rnd # Dimensions nx, ny, nz = geo_data.resolution lx = geo_data.extent[0] - geo_data.extent[1] ly = geo_data.extent[2] - geo_data.extent[3] lz = geo_data.extent[4] - geo_data.extent[5] dx, dy, dz = lx / nx, ly / ny, lz / nz ncells = nx * ny * nz npoints = (nx + 1) * (ny + 1) * (nz + 1) # Coordinates x = np.arange(0, lx + 0.1 * dx, dx, dtype='float64') y = np.arange(0, ly + 0.1 * dy, dy, dtype='float64') z = np.arange(0, lz + 0.1 * dz, dz, dtype='float64') # Variables lith = block.reshape((nx, ny, nz)) if not path: path = "./Lithology_block" gridToVTK(path, x, y, z, cellData={"Lithology": lith})
def write_vtk(s): from evtk.hl import gridToVTK xgrid = np.outer(np.sin(np.radians(s.thetaphi)) * np.cos(np.radians(s.phitheta)), s.radii) ygrid = np.outer(np.sin(np.radians(s.thetaphi)) * np.sin(np.radians(s.phitheta)), s.radii) zgrid = np.outer(np.cos(np.radians(s.thetaphi)), s.radii) xgrid = xgrid.reshape(s.ntheta, s.nphi, s.nr) ygrid = ygrid.reshape(s.ntheta, s.nphi, s.nr) zgrid = zgrid.reshape(s.ntheta, s.nphi, s.nr) print s.kernel[5].shape print xgrid.shape print ygrid.shape print zgrid.shape gridToVTK('kernel', xgrid, ygrid, zgrid, pointData={'kernel':s.kernel[8,:,:,:]})
def toVtr(filePrefix): iFile = filePrefix + '.nc' # geometry rho = read_data(iFile, 'rho') nx, ny, nz = rho.shape lx, ly, lz = 1.0 * nx, 1.0 * ny, 1.0 * nz dx, dy, dz = lx / nx, ly / ny, lz / nz ncells = nx * ny * nz # Coordinates x = np.arange(0, lx + 0.1 * dx, dx, dtype='float64') y = np.arange(0, ly + 0.1 * dy, dy, dtype='float64') z = np.arange(0, lz + 0.1 * dz, dz, dtype='float64') # read input data rho = read_data(iFile, 'rho') rho_vx = read_data(iFile, 'rho_vx') rho_vy = read_data(iFile, 'rho_vy') rho_vz = read_data(iFile, 'rho_vz') Bx = read_data(iFile, 'Bx') By = read_data(iFile, 'By') Bz = read_data(iFile, 'Bz') E = read_data(iFile, 'E') # # write output file # # write file gridToVTK(filePrefix, x, y, z, cellData={ "rho": rho, "E": E, "rho_vx": rho_vx, "rho_vy": rho_vy, "rho_vz": rho_vz, "Bx": Bx, "By": By, "Bz": Bz })
def _write_network(points_array, multiple_networks=False): n_columns = int(points_array.shape[0]) n_rows = int(points_array.shape[1]) X = np.zeros((n_rows, n_columns, 1)) Y = np.zeros((n_rows, n_columns, 1)) Z = np.zeros((n_rows, n_columns, 1)) for i in range(n_columns): for j in range(n_rows): X[j, i, 0] = points_array[i, j, 0] Y[j, i, 0] = points_array[i, j, 1] Z[j, i, 0] = points_array[i, j, 2] if multiple_networks: gridToVTK(filename + '_network' + str(n + 1), X, Y, Z) else: gridToVTK(filename + '_network', X, Y, Z)
def grid2vtk(): fd = FldFolder() vtkfolder= 'vtk' from evtk.hl import gridToVTK grid = fd.get_grid() x = grid['x'] y = grid['y'] nx,ny,nz,ne = x.shape x = grid_to_3d(x)[:,0,0] y = grid_to_3d(y)[0,:,0] z = np.array([0.0]) dat = fd('2000')['data'] dat ={key:grid_to_3d( dat[ key ] ) for key in dat} gridToVTK('./vtk/test',x,y,z,pointData = dat)
def plot_to_grid(grid_parameters, primary_variables, secondary_variables, number): # Get the shape from the grid parameters point_x = grid_parameters[0] point_y = grid_parameters[1] point_z = grid_parameters[2] nv, nu, nw = point_x.shape # "Unpack" the primary flow variables ro = primary_variables[0] ro_vel_x = primary_variables[1] ro_vel_y = primary_variables[2] ro_energy = primary_variables[3] # "Unpack" the existing secondary flow variables vel_x = secondary_variables[0] vel_y = secondary_variables[1] pressure = secondary_variables[2] enthalpy_stag = secondary_variables[3] # mach number velocity_magnitude = np.zeros((nv, nu, nw)) for j in range(0, nv): for i in range(0, nu): velocity_magnitude[j, i, 0] = np.sqrt(vel_x[j, i, 0] * vel_x[j, i, 0] + vel_y[j, i, 0] * vel_y[j, i, 0]) filename = "./output" + str(number) gridToVTK(filename, point_x, point_y, point_z, pointData={ "pressure": pressure, "density": ro, "vel-x": vel_x, "vel-y": vel_y, "vel-mag": velocity_magnitude })
def export_vtk_rectilinear(geo_data, block_lith, path=None): """ export vtk :return: """ from evtk.hl import gridToVTK import numpy as np import random as rnd # Dimensions nx, ny, nz = geo_data.resolution lx = geo_data.extent[0] - geo_data.extent[1] ly = geo_data.extent[2] - geo_data.extent[3] lz = geo_data.extent[4] - geo_data.extent[5] dx, dy, dz = lx / nx, ly / ny, lz / nz ncells = nx * ny * nz npoints = (nx + 1) * (ny + 1) * (nz + 1) # Coordinates x = np.arange(0, lx + 0.1 * dx, dx, dtype='float64') y = np.arange(0, ly + 0.1 * dy, dy, dtype='float64') z = np.arange(0, lz + 0.1 * dz, dz, dtype='float64') # Variables lith = block_lith.reshape((nx, ny, nz)) if not path: path = "./Lithology_block" gridToVTK(path, x, y, z, cellData={"Lithology": lith})
def toVtr(filePrefix): iFile=filePrefix+'.nc' # geometry rho = read_data(iFile, 'rho') nx,ny,nz = rho.shape lx, ly, lz = 1.0*nx, 1.0*ny, 1.0*nz dx, dy, dz = lx/nx, ly/ny, lz/nz ncells = nx * ny * nz # Coordinates x = np.arange(0, lx + 0.1*dx, dx, dtype='float64') y = np.arange(0, ly + 0.1*dy, dy, dtype='float64') z = np.arange(0, lz + 0.1*dz, dz, dtype='float64') # read input data rho = read_data(iFile, 'rho') rho_vx = read_data(iFile, 'rho_vx') rho_vy = read_data(iFile, 'rho_vy') rho_vz = read_data(iFile, 'rho_vz') Bx = read_data(iFile, 'Bx') By = read_data(iFile, 'By') Bz = read_data(iFile, 'Bz') E = read_data(iFile, 'E') # # write output file # # write file gridToVTK(filePrefix, x, y, z, cellData = {"rho" : rho, "E" : E, "rho_vx" : rho_vx, "rho_vy" : rho_vy, "rho_vz" : rho_vz, "Bx" : Bx, "By" : By, "Bz" : Bz})
def export_to_vtk(self, **kwds): """Export model to VTK Export the geology blocks to VTK for visualisation of the entire 3-D model in an external VTK viewer, e.g. Paraview. ..Note:: Requires pyevtk, available for free on: https://github.com/firedrakeproject/firedrake/tree/master/python/evtk **Optional keywords**: - *vtk_filename* = string : filename of VTK file (default: output_name) """ vtk_filename = kwds.get("vtk_filename", self.basename) from evtk.hl import gridToVTK # Coordinates x = np.arange(0, self.extent_x + 0.1*self.delx, self.delx, dtype='float64') y = np.arange(0, self.extent_y + 0.1*self.dely, self.dely, dtype='float64') z = np.arange(0, self.extent_z + 0.1*self.delz, self.delz, dtype='float64') # self.block = np.swapaxes(self.block, 0, 2) gridToVTK(vtk_filename, x, y, z, cellData = {"geology" : self.block})
def generate_surface(data, filename='panair'): ''' Function to generate vtk files from a panair input mesh INPUT : - data is a list of networks which are 3D arrays with the dimensions being columns, rows, and coordinates) - 'filename' is a string to use in filenames. For example 'panair' will result in files called 'panair_network_1', etc. OUTPUT : The function will produce one or several files, one for each network, in the folder it's run from. ''' from evtk.hl import gridToVTK # TODO: Currently not working when meshes seeds are not the same # X, Y, Z = data X = np.ascontiguousarray(data[:, :, 0]) Y = np.ascontiguousarray(data[:, :, 1]) Z = np.ascontiguousarray(data[:, :, 2]) gridToVTK(filename+'_network', X[:, :, None], Y[:, :, None], Z[:, :, None], cellData={'test': Z[:, :, None]})
def export_to_vtk(self, grid, name, **kwds): """Export model to VTK Export grid to VTK for visualisation of the entire 3-D model in an external VTK viewer, e.g. Paraview. ..Note:: Requires pyevtk, available for free on: https://github.com/firedrakeproject/firedrake/tree/master/python/evtk """ vtk_filename = "GBasin_%s" % name from evtk.hl import gridToVTK # Coordinates, from one output file NO_tmp = self.load_output_file(0) x = np.arange(0, NO_tmp.extent_x + 0.1*NO_tmp.delx, NO_tmp.delx, dtype='float64') y = np.arange(0, NO_tmp.extent_y + 0.1*NO_tmp.dely, NO_tmp.dely, dtype='float64') z = np.arange(0, NO_tmp.extent_z + 0.1*NO_tmp.delz, NO_tmp.delz, dtype='float64') # self.block = np.swapaxes(self.block, 0, 2) gridToVTK(vtk_filename, x, y, z, cellData = {"%s" % name : grid})
def saveToVTK(self, path: str): import evtk.hl as vtk_export x_coords = [node.x for node in self.__nodes[::self.__data.mH]] y_coords = [node.y for node in self.__nodes[:self.__data.mH:]] temp = [node.value for node in self.__nodes] x = np.zeros((self.__data.mW, self.__data.mH, 1)) y = np.zeros((self.__data.mW, self.__data.mH, 1)) z = np.zeros((self.__data.mW, self.__data.mH, 1)) temp_matrix = np.asarray(temp).reshape( (self.__data.mW, self.__data.mH, 1)) for j in range(self.__data.mW): for i in range(self.__data.mH): x[j, i, 0] = x_coords[j] y[j, i, 0] = y_coords[i] temp_matrix[j, i, 0] = temp[i + j * self.__data.mH] vtk_export.gridToVTK(path, x, y, z, pointData={"Temperature": temp_matrix})
zn = len(Zlist) time = range(dayi,dayf,days) t = 0 for tt in time: tlabel = str(tt) while len(tlabel) < 3: tlabel = '0'+tlabel # file1 = './vts/'+basename+'_'+label+'_' + tlabel print file1 var = np.zeros((xn,yn,zn)) x = np.zeros((xn,yn,zn)) y = np.zeros((xn,yn,zn)) z = np.zeros((xn,yn,zn)) # Temp = fio.read_Scalar(path+'/'+basename+'_'+label+'_'+str(tt)+'.csv',xn,yn,zn) # for k in range(len(Zlist)): for i in range(len(Xlist)): for j in range(len(Ylist)): var[i,j,k] = Temp[i,j,k] x[i,j,k] = Xlist[i] y[i,j,k] = Ylist[j] z[i,j,k] = Zlist[k] gridToVTK(file1, x,y,z, pointData = {basename : var})
def initial_setup(nu, nv, nw): #-------------------------------------------------------------- # # Read in the boundary conditions file and save variables # #-------------------------------------------------------------- # Read in boundary condition file! bcfile = open('boundary_conditions.txt', 'r') input_data = bcfile.readlines() bcfile.close() # Skip the header and proceed with the initialization! line_2 = input_data[1].split() rgas = np.float(line_2[2]) line_3 = input_data[2].split() gamma = np.float(line_3[2]) line_4 = input_data[3].split() pressure_stag_inlet = np.float(line_4[2]) line_5 = input_data[4].split() temp_stag_inlet = np.float(line_5[2]) line_6 = input_data[5].split() alpha_1 = np.float(line_6[2]) line_7 = input_data[6].split() pressure_static_exit = np.float(line_7[2]) line_8 = input_data[7].split() cfl = np.float(line_8[2]) line_9 = input_data[8].split() smooth_fac_input = np.float(line_9[2]) line_10 = input_data[9].split() nsteps = np.float(line_10[2]) line_11 = input_data[10].split() conlim_in = np.float(line_11[2]) boundary_conditions = [ rgas, gamma, pressure_stag_inlet, temp_stag_inlet, alpha_1, pressure_static_exit, cfl, smooth_fac_input, nsteps, conlim_in ] #---------------------------------------------- # # Setup other variables! # #---------------------------------------------- cp = rgas * gamma / (gamma - 1.0) cv = cp / (gamma * 1.0) gamma_factor = (gamma - 1.0) / (gamma * 1.0) #---------------------------------------------- # # Here we initialize the flow variables! # #----------------------------------------------- ro = np.zeros((nv, nu, nw)) # Density ro_vel_x = np.zeros((nv, nu, nw)) # Density * Velocity in "x" direction ro_vel_y = np.zeros((nv, nu, nw)) # Density * Velocity in "y" direction pressure = np.zeros((nv, nu, nw)) # static pressure ro_energy = np.zeros((nv, nu, nw)) # Density * energy vel_x = np.zeros((nv, nu, nw)) # velocity-x vel_y = np.zeros((nv, nu, nw)) # velocity-y enthalpy_stag = np.zeros((nv, nu, nw)) # Stagnation enthalpy #---------------------------------------------- # # Here we initialize the fluxes! # #----------------------------------------------- flux_i_mass = np.zeros((nv, nu)) # Mass flux_j_mass = np.zeros((nv, nu)) flux_i_xmom = np.zeros((nv, nu)) # X-MOMENTUM flux_j_xmom = np.zeros((nv, nu)) flux_i_ymom = np.zeros((nv, nu)) # Y-MOMENTUM flux_j_ymom = np.zeros((nv, nu)) flux_i_enthalpy = np.zeros((nv, nu)) # Enthalpy flux_j_enthalpy = np.zeros((nv, nu)) flow = np.zeros((nu, 1)) # total mass flow rate across each "i" #---------------------------------------------- # # new guess subroutine # #----------------------------------------------- jmid = nv / 2.0 temp_static_exit = temp_stag_inlet * (pressure_static_exit / pressure_stag_inlet)**gamma_factor vel_exit = np.sqrt(2 * cp * (temp_stag_inlet - temp_static_exit)) ro_exit = pressure_static_exit / rgas / temp_static_exit pressure_static_inlet = 55000 temp_static_inlet = temp_stag_inlet * (pressure_static_inlet / pressure_stag_inlet)**gamma_factor vel_inlet = np.sqrt(2 * cp * (temp_stag_inlet - temp_static_inlet)) ro_inlet = pressure_static_inlet / rgas / temp_static_inlet # Get the grid! grid_parameters = create_grid(nu, nv, nw) point_x = grid_parameters[0] point_y = grid_parameters[1] point_z = grid_parameters[2] # Initial guess! for j in range(0, nv): for i in range(0, nu): ro[j, i, 0] = 1.2 ro_vel_x[j, i, 0] = 100 * (i * 1.0) / (nu * 1.0) ro_vel_y[j, i, 0] = 0.0 pressure[j, i, 0] = 100000 * (0.9 + 0.1 * (i * 1.0) / (nu * 1.0)) enthalpy_stag[j, i, 0] = 300000 ro_energy[j, i, 0] = pressure[j, i, 0] / (gamma - 1.0) for j in range(0, nv): for i in range(0, nu - 1): dx = point_x[jmid, i + 1, 0] - point_x[jmid, i, 0] dy = point_y[jmid, i + 1, 0] - point_y[jmid, i, 0] ds = np.sqrt(dx * dx + dy * dy) vel_local = vel_inlet + (vel_exit - vel_inlet) * (1.0 * (i - 1.0) / (nu - 1.0)) ro_local = ro_inlet + (ro_exit - ro_inlet) * (1.0 * (i - 1.0) / (nu - 1.0)) temp_local = temp_static_inlet + (temp_static_exit - temp_static_inlet) * (1.0 * (i - 1.0) / (nu - 1.0)) velx = vel_local * dx / ds vely = vel_local * dy / ds ro_vel_x[j, i, 0] = ro_local * velx ro_vel_y[j, i, 0] = ro_local * vely ro[j, i, 0] = ro_local ro_energy[j, i, 0] = ro_local * (cv * temp_local + 0.5 * vel_local * vel_local) ro_vel_x[j, nu - 1, 0] = ro_vel_x[j, nu - 2, 0] ro_vel_y[j, nu - 1, 0] = ro_vel_y[j, nu - 2, 0] ro[j, nu - 1, 0] = ro[j, nu - 2, 0] ro_energy[j, nu - 1, 0] = ro_energy[j, nu - 2, 0] #------------------------------------------------------------------------- # # Output initial flow solution with grid # #------------------------------------------------------------------------- gridToVTK("./initial_flow", point_x, point_y, point_z, pointData={ "pressure": pressure, "density": ro, "density-velx": ro_vel_x }) #------------------------------------------------------------------------- # # Setting primary & secondary flow variables # #------------------------------------------------------------------------- primary_variables = {} secondary_variables = {} primary_variables[0] = ro primary_variables[1] = ro_vel_x primary_variables[2] = ro_vel_y primary_variables[3] = ro_energy secondary_variables[0] = vel_x secondary_variables[1] = vel_y secondary_variables[2] = pressure secondary_variables[3] = enthalpy_stag #------------------------------------------------------------------------- # # Setting the fluxes # #------------------------------------------------------------------------- fluxes = {} fluxes[0] = flux_i_mass fluxes[1] = flux_j_mass fluxes[2] = flux_i_xmom fluxes[3] = flux_j_xmom fluxes[4] = flux_i_ymom fluxes[5] = flux_j_ymom fluxes[6] = flux_i_enthalpy fluxes[7] = flux_j_enthalpy fluxes[8] = flow secondary_variables = set_other_variables(primary_variables, secondary_variables, boundary_conditions, grid_parameters) return primary_variables, secondary_variables, fluxes, boundary_conditions, grid_parameters
lx, ly, lz = 1.0, 1.0, 1.0 dx, dy, dz = lx / nx, ly / ny, lz / nz ncells = nx * ny * nz npoints = (nx + 1) * (ny + 1) * (nz + 1) # Coordinates X = np.arange(0, lx + 0.1 * dx, dx, dtype='float64') Y = np.arange(0, ly + 0.1 * dy, dy, dtype='float64') Z = np.arange(0, lz + 0.1 * dz, dz, dtype='float64') x = np.zeros((nx + 1, ny + 1, nz + 1)) y = np.zeros((nx + 1, ny + 1, nz + 1)) z = np.zeros((nx + 1, ny + 1, nz + 1)) # We add some random fluctuation to make the grid # more interesting for k in range(nz + 1): for j in range(ny + 1): for i in range(nx + 1): x[i, j, k] = X[i] + (0.5 - rnd.random()) * 0.2 * dx y[i, j, k] = Y[j] + (0.5 - rnd.random()) * 0.2 * dy z[i, j, k] = Z[k] + (0.5 - rnd.random()) * 0.2 * dz # Variables pressure = np.random.rand(ncells).reshape((nx, ny, nz)) temp = np.random.rand(npoints).reshape((nx + 1, ny + 1, nz + 1)) gridToVTK("./structured", x, y, z, cellData={ "pressure": pressure}, pointData={"temp": temp})
main.u = myFFT.myifft3D(main.uhat) main.v = myFFT.myifft3D(main.vhat) main.w = myFFT.myifft3D(main.what) if (main.turb_model == 'DNS' or main.turb_model == 'Smagorinsky'): np.savez(string2,u=main.u,v=main.v,w=main.w) if (main.turb_model == 'FM1'): w0_up = myFFT.myifft3D(main.w0_u[:,:,:,0]) w0_vp = myFFT.myifft3D(main.w0_v[:,:,:,0]) w0_wp = myFFT.myifft3D(main.w0_w[:,:,:,0]) np.savez(string2,u=main.u,v=main.v,w=main.w,w0_u=w0_up,w0_v=w0_vp,w0_w=w0_wp) #main.p = myFFT.myifft3D(main.phat) sys.stdout.write("===================================================================================== \n") sys.stdout.write('t = ' + str(main.t) + ' Wall time = ' + str(time.time() - t0) + '\n' ) sys.stdout.write('Div = ' + str( np.linalg.norm(div) ) + '\n') sys.stdout.flush() gridToVTK(string, x,y,z, pointData = {"u" : np.real(main.u.transpose()) , \ "v" : np.real(main.v.transpose()) , "w" : np.real(main.w.transpose()) } ) #, \ #363 "p" : np.real(pdummy.transpose())} ) #--------------------------------------------- # advance by Adams Bashforth/Crank Nicolson main.iteration += 1 advance_AdamsCrank(main,grid,myFFT) main.t += main.dt #========================================================================
# * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * # * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * # ************************************************************************ # ************************************************************** # * Example of how to use the high level gridToVTK function. * # * This example shows how to export a rectilinear grid. * # ************************************************************** from evtk.hl import gridToVTK import numpy as np # Dimensions nx, ny, nz = 6, 6, 2 lx, ly, lz = 1.0, 1.0, 1.0 dx, dy, dz = lx / nx, ly / ny, lz / nz ncells = nx * ny * nz npoints = (nx + 1) * (ny + 1) * (nz + 1) # Coordinates x = np.arange(0, lx + 0.1 * dx, dx, dtype="float64") y = np.arange(0, ly + 0.1 * dy, dy, dtype="float64") z = np.arange(0, lz + 0.1 * dz, dz, dtype="float64") # Variables pressure = np.random.rand(ncells).reshape((nx, ny, nz)) temp = np.random.rand(npoints).reshape((nx + 1, ny + 1, nz + 1)) gridToVTK("./rectilinear", x, y, z, cellData={"pressure": pressure}, pointData={"temp": temp})
data3 = file['/Fields/Bz'][...] data4 = file['/Fields/Ex'][...] data5 = file['/Fields/Ey'][...] data6 = file['/Fields/Ez'][...] data7 = file['/Fields/Rho_0'][...] data8 = file['/Fields/Rho_1'][...] data9 = file['/Fields/Jx_0'][...] data10 = file['/Fields/Jy_0'][...] data11 = file['/Fields/Jz_0'][...] data12 = file['/Fields/Jx_1'][...] data13 = file['/Fields/Jy_1'][...] data14 = file['/Fields/Jz_1'][...] # Write the VTK file gridToVTK(vtkfilename+"_"+cycle, xc, yc, zc, cellData = {"Bx" : data1, \ "By" : data2, \ "Bz" : data3, \ "Ex" : data4, \ "Ey" : data5, \ "Ez" : data6, \ "Rho_0" : data7, \ "Rho_1" : data8, \ "Jx_0" : data9, \ "Jy_0" : data10, \ "Jz_0" : data11, \ "Jx_1" : data12, \ "Jy_1" : data13, \ "Jz_1" : data14 })
def write_vtk_2(name,pts,vrbl_r,vrbl_i,eig_num): i,j,k = pts # names = (name + '_r', name + '_i') # vrbl_m = vrbl_r,vrbl_i vtk_file_path = gridToVTK( name + "_eigen_%d" % eig_num,i,j,k, pointData = {str(name + '_r'): vrbl_r , str(name + '_i') : vrbl_i}) return vtk_file_path
x_vals = A**3 / 9 lambdas = A**3 / 9 alphas = A**3 / 9 # Create the meshes that will be used to generate the attributes. The purpose # of these meshes is to make good use of vectorization. x_grid = x_vals.reshape(1, 1, len(x_vals)) x_grid = x_grid.repeat(len(lambdas), axis=1) x_grid = x_grid.repeat(len(alphas), axis=0) lambda_grid = lambdas.reshape(1, len(lambdas), 1) lambda_grid = lambda_grid.repeat(len(x_vals), axis=2) lambda_grid = lambda_grid.repeat(len(alphas), axis=0) alpha_grid = alphas.reshape(len(alphas), 1, 1) alpha_grid = alpha_grid.repeat(len(x_vals), axis=2) alpha_grid = alpha_grid.repeat(len(lambdas), axis=1) # Create the attribute for G = x^3 + lambda*x + alpha_1*x^2. The alpha_2 # auxiliary parameter will be included using animation in ParaView. G = x_grid**3 + lambda_grid * x_grid + alpha_grid * x_grid**2 # Create the attribute for G_x = 3*x^2 + lambda + 2*alpha*x # and use the signum function as a test for stability. Gx = 3 * x_grid**2 + lambda_grid + 2 * alpha_grid * x_grid sgn_Gx = np.sign(Gx) # Use EVTK to create the VTR file. # The parameters for gridToVtk: (file name, x-coords of mesh, y-coords of mesh, # z-coords of mesh, pointData). gridToVTK("./pitchforkMesh", alphas, lambdas, x_vals, \ pointData={"G":G, "stability":sgn_Gx, "G_x":Gx})
# * Example of how to use the high level gridToVTK function. * # * This example shows how to export a rectilinear grid. * # ************************************************************** from evtk.hl import gridToVTK import numpy as np # Dimensions nx, ny, nz = 6, 6, 2 lx, ly, lz = 1.0, 1.0, 1.0 dx, dy, dz = lx / nx, ly / ny, lz / nz ncells = nx * ny * nz npoints = (nx + 1) * (ny + 1) * (nz + 1) # Coordinates x = np.arange(0, lx + 0.1 * dx, dx, dtype='float64') y = np.arange(0, ly + 0.1 * dy, dy, dtype='float64') z = np.arange(0, lz + 0.1 * dz, dz, dtype='float64') # Variables pressure = np.random.rand(ncells).reshape((nx, ny, nz)) temp = np.random.rand(npoints).reshape((nx + 1, ny + 1, nz + 1)) gridToVTK("./rectilinear", x, y, z, cellData={"pressure": pressure}, pointData={"temp": temp})
dh_mean = f.root.fris.dh_mean[:] z = np.arange(0, dh_mean.shape[2], dtype='float64') f.close() # Dimensions ''' nx, ny, nz = 6, 6, 2 lx, ly, lz = 1.0, 1.0, 1.0 dx, dy, dz = lx/nx, ly/ny, lz/nz ncells = nx * ny * nz npoints = (nx + 1) * (ny + 1) * (nz + 1) ''' # Coordinates ''' x = np.arange(0, lx + 0.1*dx, dx, dtype='float64') y = np.arange(0, ly + 0.1*dy, dy, dtype='float64') z = np.arange(0, lz + 0.1*dz, dz, dtype='float64') ''' # Variables ''' pressure = np.random.rand(ncells).reshape( (nx, ny, nz)) temp = np.random.rand(npoints).reshape( (nx + 1, ny + 1, nz + 1)) ''' gridToVTK("./rectilinear", x, y, z, cellData = {"dh_mean" : dh_mean}) #, pointData = {"temp" : temp}) #imageToVTK("./image", cellData = {"dh_mean" : zz})#, pointData = {"temp" : z} )
y_slice = 4 z_slice = 6 SIG = np.linspace(sigma0, sigmaN, Nx, dtype='float32') EPSA = np.linspace(epsilon0, epsilonN, Ny, dtype='float32') KAPPA = np.linspace(k0, kN, Nz, dtype='float32') surface = avSlope.reshape((Nx, Ny, Nz)) surfaceFlag = np.require(surface, dtype=np.float32, requirements=['A', 'O', 'W', 'C']) gridToVTK("./" + file_name, SIG, EPSA, KAPPA, pointData={file_name: surfaceFlag}) x_vals = SIG y_vals = EPSA z_vals = KAPPA x_axis = [] y_axis = [] z_axis = [] # for i in range (len(x_vals)): # for j in range (len(y_vals)): # x_axis=np.append(x_axis,x_vals[i]) # y_axis=np.append(y_axis,y_vals[j])
Nx = len(model.x) Ny = len(model.y) Nz = len(model.z) Xgrid = (np.add.accumulate(np.append([0.], model.x)) + model.orig[0]) * scale Ygrid = (np.add.accumulate(np.append([0.], model.y)) + model.orig[1]) * scale Zgrid = (np.add.accumulate(np.append([0.], model.z)) + model.orig[2]) * scale # in wsinv3Dmodel.py: self.m.shape = (Nz,Ny,Nx) gridToVTK(model_file, Zgrid, Ygrid, Xgrid, cellData={"resistivity": model.m.copy()}) # print "# vtk DataFile Version 3.0" # print "%s" % model.comment_line # print "ASCII" # print "DATASET RECTILINEAR_GRID" # print "DIMENSIONS %d %d %d" % (Nx,Ny,Nz) # print "X_COORDINATES %d float" % Nx # print "%s" % print_grid(model.x,model.orig[0]) # print "Y_COORDINATES %d float" % Ny # print "%s" % print_grid(model.y,model.orig[1]) # print "Z_COORDINATES %d float" % Nz # print "%s" % print_grid(model.z,model.orig[2]) # print "CELL_DATA 1"
Z = np.arange(0, lz + 0.1*dz, dz, dtype='float64') ''' x3 = np.zeros((ny, nx, nz)) y3 = np.zeros((ny, nx, nz)) z3 = np.zeros((ny, nx, nz)) ''' # We add some random fluctuation to make the grid # more interesting for k in range(nz): for j in range(nx): for i in range(ny): x3[i,j,k], y3[i,j,k] = proj(x[j], y[i]) #x3[i,j,k] = x[j] ''' for k in range(16): x3[:,:,k] = xx[:] y3[:,:,k] = yy[:] z3[:,:,k] = k # Variables ''' pressure = np.random.rand(ncells).reshape( (nx, ny, nz)) temp = np.random.rand(npoints).reshape( (nx + 1, ny + 1, nz + 1)) ''' print 'x3, y3, z3, dh_mean:', x3.shape, y3.shape, z3.shape, dh_mean.shape gridToVTK("./structured", x3, y3, z3, cellData = {"dh_mean" : dh_mean}) #, pointData = {"temp" : temp})
def write_vtk(name,pts,vrbl,t,nx,ny,nz): i,j,k = pts vrbl = np.array(vrbl) vtk_file_path = gridToVTK("./batch/" + name + "_batch_%d" % t, i, j, k, pointData = {str(name) : vrbl}) return vtk_file_path
def main(): """ Convert ModEM output files (model) into 3D VTK resistivity grid (distance is given in kilometers) Input: - ModEM model file - ModEM data file - [optional] VTK resistivity grid file - output file name - [optional] VTK station grid file - output file name """ arguments = sys.argv if len(arguments) < 2: sys.exit('\nERROR - provide at least 1 file name: <model file> [<data>]'\ ' [out:rho] [out:stations]\n') try: Mmodel = os.path.abspath(os.path.realpath(arguments[1])) try: VTKresist = os.path.abspath(os.path.realpath(arguments[3])) except: VTKresist = os.path.abspath(os.path.realpath('VTKResistivityGrid')) try: Mdata = os.path.abspath(os.path.realpath(arguments[2])) except: pass try: VTKstations = os.path.abspath(os.path.realpath(arguments[4])) except: VTKstations = os.path.abspath(os.path.realpath('VTKStationGrid')) except: sys.exit('ERROR - could not find file(s)') f = open(Mmodel, 'r') # skip first line in file f.readline() # read X,Y,Z mesh dimensions dims = [] modeldata_firstline = f.readline().split() try: function = modeldata_firstline[4].lower() except: function = None for n in range(3): dims.append(int(modeldata_firstline[n])) size = dims[0]*dims[1]*dims[2] print 'Mesh: ', dims print 'Datapoints: ', size # read N,E,D spacing # (depends on line break only after final value) spacing = [] for n in range(3): i=0 while i < dims[n]: modeldata_nextlines = f.readline().split() for j in modeldata_nextlines: spacing.append(float(j)/1000.0) i += 1 # read model values # (depends on line break only after final value) mt = np.zeros(size) i=0 while i < size: modeldata_morelines = f.readline().split() if len(modeldata_morelines) == 0: continue for j in modeldata_morelines: if function is None: mt[i] = float(j) elif function in ['loge']: mt[i] = np.e**(float(j)) elif function in ['log','log10']: mt[i] = 10**(float(j)) i += 1 #reading the mesh blocks and calculate coordinates. #Coords are taken at the center points of the blocks #read the lines following the model: appendix = f.readlines() # the second last non empty line contains a triple that defines the # lower left corner coordinates of the model x0 = None for line in appendix[::-1]: line = line.strip().split() if len(line) != 3: continue else: try: x0 = float(line[0])/1000. y0 = float(line[1])/1000. z0 = float(line[2])/1000. break except: continue if x0 is None: x0 = 0 y0 = 0 z0 = 0 print 'Warning - no reference point found - lower left corner of model'\ ' set to 0,0,0' Xspacing = spacing[:dims[0]] # calc North coordinates of vtk mesh Xdist = 0 # calculate total North distance by summing all blocks for i in range(dims[0]): Xdist += Xspacing[i] X = np.zeros(dims[0]) #X[0] = -0.5 * Xdist + 0.5*(Xspacing[0])# define zero at the center of the model X[0] = 0.5*(Xspacing[0])# define zero at the lower left corner of the model for i in range(dims[0]-1): local_spacing = 0.5*(Xspacing[i]+Xspacing[i+1]) X[i+1] = X[i] + local_spacing #add reference point coordinate X += x0 Yspacing = spacing[dims[0]:dims[0]+dims[1]] # calc Yast coordinates of vtk mesh Ydist = 0 # calculate total Yast distance by summing all blocks for i in range(dims[1]): Ydist += Yspacing[i] Y = np.zeros(dims[1]) #Y[0] = -0.5 * Ydist + 0.5*(Yspacing[0])# define zero at the center of the model Y[0] = 0.5*(Yspacing[0])# define zero at the lower left corner of the model for i in range(dims[1]-1): local_spacing = 0.5*(Yspacing[i]+Yspacing[i+1]) Y[i+1] = Y[i] + local_spacing #add reference point coordinate Y += y0 Dspacing=spacing[dims[0]+dims[1]:] # calc Down coordinates of vtk mesh D = np.zeros(dims[2]) D[0] = 0.5*Dspacing[0] for i in range(dims[2]-1): local_spacing = 0.5*(Dspacing[i]+Dspacing[i+1]) D[i+1] = D[i] + local_spacing #add reference point coordinate D+= z0 # output to vtk format # first components read in reverse order!! mtNS = np.zeros((dims[0],dims[1],dims[2])) n=0 #define array for alternative output as csv file, which #can be read by paraview directly arr = np.zeros((len(X)*len(Y)*len(D),4)) for idx_D in range(dims[2]): for idx_Y in range(dims[1]): for idx_X in range(dims[0]): #switch North/South by convention mtNS[-(idx_X+1),idx_Y,idx_D] = mt[n] arr[n,0] = X[idx_X] arr[n,1] = Y[idx_Y] arr[n,2] = D[idx_D] arr[n,3] = mt[n] n += 1 gridToVTK(VTKresist, X, Y, D, pointData = {'resistivity' : mtNS}) f.close() #fn2 = VTKresist+'.csv' #F = open(fn2,'w') #F.write('X , Y , Down , Rho \n') #np.savetxt(F,arr,delimiter=',') #F.close() #print 'Created Resistivity Array: {0}.csv'.format(VTKresist) print 'Created Resistivity VTK File: {0}.vtr'.format(VTKresist) try: f = open(Mdata, 'r') # get stations by parsing all lines that do NOT start with > or # rawdata = f.readlines() f.close() lo_datalines = [] for l in rawdata: if l.strip()[0] not in ['#','>']: lo_datalines.append(l.strip()) lo_coords = [] for line in lo_datalines: line = line.split() x = float(line[4])/1000. y = float(line[5])/1000. z = float(line[6])/1000. point = (x,y,z) if point not in lo_coords: lo_coords.append(point) all_coords = np.array(lo_coords)[:] print 'Stations: ', len(all_coords) #sorting N->S, W->E all_coords = all_coords[np.lexsort((all_coords[:, 1], all_coords[:, 0]))] N = np.array(all_coords[:,0]) E = np.array(all_coords[:,1]) D = np.array(all_coords[:,2]) dummy = np.ones(len(all_coords)) pointsToVTK(VTKstations, N, E, D, data = {"dummyvalue" : dummy}) print 'Created Station VTK File: {0}.vtu'.format(VTKstations) except: print 'Could not create Station File '
#t = 0.2: 0.108 t0 = time.time() t = 0 et = 20 dt = 1.e-1 Q = zeros((3*N1,3*N2,3*(N3/2+1)),dtype='complex') Q = U2Q(Q,uhat,vhat,what) iteration = 0 save_freq = 50 Energy = zeros(1) Energy[0] = real( mean(0.5*uhat*conj(uhat) + 0.5*vhat*conj(vhat) + 0.5*what*conj(what)) ) EnergyScale = mean( 0.5*(u*u +v*v + w*w) )/Energy[0] print(Energy[0]) while t <= et: Q = advanceQ_RK4(dt,Q,uhat,vhat,what,grid,myFFT) t += dt if (iteration%save_freq == 0): string = '3DSolution/sol' + str(iteration) u = irfftn(uhat)*sqrt(N1*N2*N3) v = irfftn(vhat)*sqrt(N1*N2*N3) w = irfftn(what)*sqrt(N1*N2*N3) gridToVTK(string, grid.x,grid.y,grid.z, pointData = {"u" : real(u.transpose()) , \ "v" : real(v.transpose()), \ "w" : real(w.transpose())} ) iteration += 1 Energy = append(Energy,EnergyScale*mean(0.5*uhat*conj(uhat) + 0.5*vhat*conj(vhat) + 0.5*what*conj(what))) print(time.time() - t0,t,Energy[-1]) t1 = time.time() print('time = ' + str(t1 - t0))
def main(): """ Convert ws3Dinv output files (model and responses) into 3D VTK resistivity grid and unstructured VTKGrid containing station locations. Input: - ws3dInv model name - ws3DInv response file name - [optional] VTK resistivity grid file - output file name - [optional] VTK stations grid file - output file name """ arguments = sys.argv if len(arguments) < 3: sys.exit( 'ERROR - provide at least 2 file names: <modeldata file> <responses file>') try: WSMTmodel = os.path.abspath(os.path.realpath(arguments[1])) WSMTresp = os.path.abspath(os.path.realpath(arguments[2])) try: VTKresist = os.path.abspath(os.path.realpath(arguments[3])) except: VTKresist = os.path.abspath(os.path.realpath('VTKResistivityGrid')) try: VTKstations = os.path.abspath(os.path.realpath(arguments[4])) except: VTKstations = os.path.abspath(os.path.realpath('VTKStationGrid')) except: sys.exit('ERROR - could not find file(s)') f = open(WSMTmodel, 'r') # skip first line in file f.readline() # read N,E,D mesh dimensions dims = [] modeldata_firstline = f.readline().split() for n in range(3): dims.append(int(modeldata_firstline[n])) size = dims[0] * dims[1] * dims[2] print 'Mesh ', dims print 'Data ', size # read N,E,D spacing # (depends on line break only after final value) spacing = [] for n in range(3): i = 0 while i < dims[n]: modeldata_nextlines = f.readline().split() for j in modeldata_nextlines: spacing.append(float(j) / 1000.0) i += 1 # read mt data # (depends on line break only after final value) mt = np.zeros(size) i = 0 while i < size: modeldata_morelines = f.readline().split() for j in modeldata_morelines: mt[i] = float(j) i += 1 # calc North coordinates of vtk mesh Ndist = 0 # calculate total North distance for i in range(dims[0]): Ndist += spacing[i] N = np.zeros(dims[0] + 1) N[0] = -0.5 * Ndist # zero center of model for i in range(dims[0]): N[i + 1] = N[i] + spacing[i] # calc East coordinates of vtk mesh Edist = 0 # calculate total y distance for i in range(dims[1]): Edist += spacing[dims[0] + i] E = np.zeros(dims[1] + 1) E[0] = -0.5 * Edist # zero center of model for i in range(dims[1]): E[i + 1] = E[i] + spacing[dims[0] + i] # calc Down coordinates of vtk mesh D = np.zeros(dims[2] + 1) D[0] = 0.0 for i in range(dims[2]): D[i + 1] = D[i] + spacing[dims[0] + dims[1] + i] # output to vtk format # first components read in reverse order!! mtNS = np.zeros((dims[0], dims[1], dims[2])) # North-to-South conversion n = 0 for idx_D in range(dims[2]): for idx_E in range(dims[1]): for idx_S in range(dims[0]): mtNS[(dims[0] - 1) - idx_S, idx_E, idx_D] = mt[n] n += 1 gridToVTK(VTKresist, N, E, D, cellData={'resistivity': mtNS}) f.close() f = open(WSMTresp, 'r') # get station count respdata_firstline = f.readline().split() nstations = int(respdata_firstline[0]) print 'Stations ', nstations # read North locations f.readline() # skip line N = np.zeros(nstations) i = 0 while i < nstations: respdata_nextlines = f.readline().split() for j in respdata_nextlines: N[i] = float(j) / 1000.0 i += 1 # read East locations f.readline() # skip line E = np.zeros(nstations) i = 0 while i < nstations: respdata_morelines = f.readline().split() for j in respdata_morelines: E[i] = float(j) / 1000.0 i += 1 f.close() # set Depths -- all stations at the surface!! D = np.zeros(nstations) # output to vtk format - dummy value for scalar field needed dummy = np.ones(nstations) # for j in range(nstations): # dummy[j] = 1.0 print np.shape(dummy), np.shape(N), np.shape(E), np.shape(D) pointsToVTK(VTKstations, N, E, D, data={"dummyvalue": dummy}) print 'Created Resistivity File: {0}.vtr '.format(VTKresist) print 'Created Station File: {0}.vtu '.format(VTKstations)
Z = np.arange(0, lz + 0.1*dz, dz, dtype='float64') ''' x3 = np.zeros((ny, nx, nz)) y3 = np.zeros((ny, nx, nz)) z3 = np.zeros((ny, nx, nz)) ''' # We add some random fluctuation to make the grid # more interesting for k in range(nz): for j in range(nx): for i in range(ny): x3[i,j,k], y3[i,j,k] = proj(x[j], y[i]) #x3[i,j,k] = x[j] ''' for k in range(16): x3[:, :, k] = xx[:] y3[:, :, k] = yy[:] z3[:, :, k] = k # Variables ''' pressure = np.random.rand(ncells).reshape( (nx, ny, nz)) temp = np.random.rand(npoints).reshape( (nx + 1, ny + 1, nz + 1)) ''' print 'x3, y3, z3, dh_mean:', x3.shape, y3.shape, z3.shape, dh_mean.shape gridToVTK("./structured", x3, y3, z3, cellData={"dh_mean": dh_mean}) #, pointData = {"temp" : temp})
def main(): """ Convert ws3Dinv output files (model and responses) into 3D VTK resistivity grid and unstructured VTKGrid containing station locations. Input: - ws3dInv model name - ws3DInv response file name - [optional] VTK resistivity grid file - output file name - [optional] VTK stations grid file - output file name """ arguments = sys.argv if len(arguments) < 3: sys.exit('ERROR - provide at least 2 file names: <modeldata file> <responses file>') try: WSMTmodel = os.path.abspath(os.path.realpath(arguments[1])) WSMTresp = os.path.abspath(os.path.realpath(arguments[2])) try: VTKresist = os.path.abspath(os.path.realpath(arguments[3])) except: VTKresist = os.path.abspath(os.path.realpath('VTKResistivityGrid')) try: VTKstations = os.path.abspath(os.path.realpath(arguments[4])) except: VTKstations = os.path.abspath(os.path.realpath('VTKStationGrid')) except: sys.exit('ERROR - could not find file(s)') f = open(WSMTmodel, 'r') # skip first line in file f.readline() # read N,E,D mesh dimensions dims = [] modeldata_firstline = f.readline().split() for n in range(3): dims.append(int(modeldata_firstline[n])) size = dims[0]*dims[1]*dims[2] print 'Mesh ', dims print 'Data ', size # read N,E,D spacing # (depends on line break only after final value) spacing = [] for n in range(3): i=0 while i < dims[n]: modeldata_nextlines = f.readline().split() for j in modeldata_nextlines: spacing.append(float(j)/1000.0) i += 1 # read mt data # (depends on line break only after final value) mt = np.zeros(size) i=0 while i < size: modeldata_morelines = f.readline().split() for j in modeldata_morelines: mt[i] = float(j) i += 1 # calc North coordinates of vtk mesh Ndist = 0 # calculate total North distance for i in range(dims[0]): Ndist += spacing[i] N = np.zeros(dims[0]+1) N[0] = -0.5 * Ndist # zero center of model for i in range(dims[0]): N[i+1] = N[i] + spacing[i] # calc East coordinates of vtk mesh Edist = 0 # calculate total y distance for i in range(dims[1]): Edist += spacing[dims[0] + i] E = np.zeros(dims[1]+1) E[0] = -0.5 * Edist # zero center of model for i in range(dims[1]): E[i+1] = E[i] + spacing[dims[0] + i] # calc Down coordinates of vtk mesh D = np.zeros(dims[2]+1) D[0] = 0.0 for i in range(dims[2]): D[i+1] = D[i] + spacing[dims[0] + dims[1] + i] # output to vtk format # first components read in reverse order!! mtNS = np.zeros((dims[0],dims[1],dims[2])) # North-to-South conversion n=0 for idx_D in range(dims[2]): for idx_E in range(dims[1]): for idx_S in range(dims[0]): mtNS[(dims[0]-1)-idx_S,idx_E,idx_D] = mt[n] n += 1 gridToVTK(VTKresist, N, E, D, cellData = {'resistivity' : mtNS}) f.close() f = open(WSMTresp, 'r') # get station count respdata_firstline = f.readline().split() nstations = int(respdata_firstline[0]) print 'Stations ', nstations # read North locations f.readline() #skip line N = np.zeros(nstations) i=0 while i < nstations: respdata_nextlines = f.readline().split() for j in respdata_nextlines: N[i] = float(j)/1000.0 i += 1 # read East locations f.readline() #skip line E = np.zeros(nstations) i=0 while i < nstations: respdata_morelines = f.readline().split() for j in respdata_morelines: E[i] = float(j)/1000.0 i += 1 f.close() # set Depths -- all stations at the surface!! D = np.zeros(nstations) # output to vtk format - dummy value for scalar field needed dummy = np.ones(nstations) #for j in range(nstations): # dummy[j] = 1.0 print np.shape(dummy),np.shape(N),np.shape(E),np.shape(D) pointsToVTK(VTKstations, N, E, D, data = {"dummyvalue" : dummy}) print 'Created Resistivity File: {0}.vtr '.format(VTKresist) print 'Created Station File: {0}.vtu '.format(VTKstations)
def initial_setup(nu, nv, nw): #-------------------------------------------------------------- # # Read in the boundary conditions file and save variables # #-------------------------------------------------------------- # Read in boundary condition file! bcfile = open('boundary_conditions.txt', 'r') input_data = bcfile.readlines() bcfile.close() # Skip the header and proceed with the initialization! line_2 = input_data[1].split() rgas = np.float(line_2[2]) line_3 = input_data[2].split() gamma = np.float(line_3[2]) line_4 = input_data[3].split() pressure_stag_inlet = np.float(line_4[2]) line_5 = input_data[4].split() temp_stag_inlet = np.float(line_5[2]) line_6 = input_data[5].split() alpha_1 = np.float(line_6[2]) line_7 = input_data[6].split() pressure_static_exit = np.float(line_7[2]) line_8 = input_data[7].split() cfl = np.float(line_8[2]) line_9 = input_data[8].split() smooth_fac_input = np.float(line_9[2]) line_10 = input_data[9].split() nsteps = np.float(line_10[2]) line_11 = input_data[10].split() conlim_in = np.float(line_11[2]) boundary_conditions = [rgas, gamma, pressure_stag_inlet, temp_stag_inlet, alpha_1, pressure_static_exit, cfl , smooth_fac_input, nsteps, conlim_in ] #---------------------------------------------- # # Setup other variables! # #---------------------------------------------- cp = rgas * gamma / (gamma - 1.0) cv = cp / (gamma * 1.0) gamma_factor = (gamma - 1.0) / (gamma * 1.0) #---------------------------------------------- # # Here we initialize the flow variables! # #----------------------------------------------- ro = np.zeros((nv, nu, nw)) # Density ro_vel_x = np.zeros((nv, nu, nw)) # Density * Velocity in "x" direction ro_vel_y = np.zeros((nv, nu, nw)) # Density * Velocity in "y" direction pressure = np.zeros((nv, nu, nw)) # static pressure ro_energy = np.zeros((nv, nu, nw)) # Density * energy vel_x = np.zeros((nv, nu, nw)) # velocity-x vel_y = np.zeros((nv, nu, nw)) # velocity-y enthalpy_stag = np.zeros((nv, nu, nw)) # Stagnation enthalpy #---------------------------------------------- # # Here we initialize the fluxes! # #----------------------------------------------- flux_i_mass = np.zeros((nv, nu)) # Mass flux_j_mass = np.zeros((nv, nu)) flux_i_xmom = np.zeros((nv, nu)) # X-MOMENTUM flux_j_xmom = np.zeros((nv, nu)) flux_i_ymom = np.zeros((nv, nu)) # Y-MOMENTUM flux_j_ymom = np.zeros((nv, nu)) flux_i_enthalpy = np.zeros((nv, nu)) # Enthalpy flux_j_enthalpy = np.zeros((nv, nu)) flow = np.zeros((nu, 1)) # total mass flow rate across each "i" #---------------------------------------------- # # new guess subroutine # #----------------------------------------------- jmid = nv / 2.0 temp_static_exit = temp_stag_inlet * (pressure_static_exit/pressure_stag_inlet)**gamma_factor vel_exit = np.sqrt(2 * cp * (temp_stag_inlet - temp_static_exit)) ro_exit = pressure_static_exit / rgas / temp_static_exit pressure_static_inlet = 55000 temp_static_inlet = temp_stag_inlet * (pressure_static_inlet / pressure_stag_inlet)**gamma_factor vel_inlet = np.sqrt(2 * cp * (temp_stag_inlet - temp_static_inlet)) ro_inlet = pressure_static_inlet / rgas / temp_static_inlet # Get the grid! grid_parameters = create_grid(nu, nv, nw) point_x = grid_parameters[0] point_y = grid_parameters[1] point_z = grid_parameters[2] # Initial guess! for j in range(0, nv): for i in range(0, nu): ro[j,i,0] = 1.2 ro_vel_x[j,i,0] = 100 * (i * 1.0)/(nu * 1.0) ro_vel_y[j,i,0] = 0.0 pressure[j,i,0] = 100000 * (0.9 + 0.1 * (i * 1.0)/(nu * 1.0)) enthalpy_stag[j,i,0] = 300000 ro_energy[j,i,0] = pressure[j,i,0] / (gamma - 1.0) for j in range(0, nv): for i in range(0, nu-1): dx = point_x[jmid, i+1, 0] - point_x[jmid, i, 0] dy = point_y[jmid, i+1, 0] - point_y[jmid, i, 0] ds = np.sqrt(dx*dx + dy*dy) vel_local = vel_inlet + (vel_exit - vel_inlet)* (1.0 * (i-1.0)/(nu - 1.0) ) ro_local = ro_inlet + (ro_exit - ro_inlet)* (1.0 * (i-1.0)/(nu - 1.0) ) temp_local = temp_static_inlet + (temp_static_exit - temp_static_inlet)* (1.0 * (i-1.0)/(nu - 1.0) ) velx = vel_local * dx / ds vely = vel_local * dy / ds ro_vel_x[j,i,0] = ro_local * velx ro_vel_y[j,i,0] = ro_local * vely ro[j,i,0] = ro_local ro_energy[j,i,0] = ro_local * (cv * temp_local + 0.5 * vel_local * vel_local) ro_vel_x[j,nu-1,0] = ro_vel_x[j,nu-2,0] ro_vel_y[j,nu-1,0] = ro_vel_y[j,nu-2,0] ro[j,nu-1,0] = ro[j,nu-2,0] ro_energy[j,nu-1,0] = ro_energy[j,nu-2,0] #------------------------------------------------------------------------- # # Output initial flow solution with grid # #------------------------------------------------------------------------- gridToVTK("./initial_flow", point_x, point_y, point_z, pointData={"pressure": pressure, "density": ro, "density-velx": ro_vel_x }) #------------------------------------------------------------------------- # # Setting primary & secondary flow variables # #------------------------------------------------------------------------- primary_variables = {} secondary_variables = {} primary_variables[0] = ro primary_variables[1] = ro_vel_x primary_variables[2] = ro_vel_y primary_variables[3] = ro_energy secondary_variables[0] = vel_x secondary_variables[1] = vel_y secondary_variables[2] = pressure secondary_variables[3] = enthalpy_stag #------------------------------------------------------------------------- # # Setting the fluxes # #------------------------------------------------------------------------- fluxes = {} fluxes[0] = flux_i_mass fluxes[1] = flux_j_mass fluxes[2] = flux_i_xmom fluxes[3] = flux_j_xmom fluxes[4] = flux_i_ymom fluxes[5] = flux_j_ymom fluxes[6] = flux_i_enthalpy fluxes[7] = flux_j_enthalpy fluxes[8] = flow secondary_variables = set_other_variables(primary_variables, secondary_variables, boundary_conditions, grid_parameters) return primary_variables, secondary_variables, fluxes, boundary_conditions, grid_parameters