def get_trunkcone(b, a): phi_base, theta_base = sph.to(a, b)[1:] quads = tvtk.CellArray() #vtk.vtkCellArray() points = tvtk.Points() #vtk.vtkPoints() Nface = 3 for i in range(Nface + 1): # rotate phi, theta = convdir((i % Nface) * 2 * pi / Nface, pi * 0.5, phi_base, theta_base) # generate new points p = tuple(sph.xyz(a[3] * 0.5 * radius_factor, phi, theta, a[:3])) q = tuple(sph.xyz(b[3] * 0.5 * radius_factor, phi, theta, b[:3])) # insert points points.append(p) points.append(q) if i >= 1: # create a face quad = tvtk.Quad() n = points.number_of_points - 1 quad.point_ids.set_id(0, n - 3) # p quad.point_ids.set_id(1, n - 2) # q quad.point_ids.set_id(2, n) # q quad.point_ids.set_id(3, n - 1) # p # insert the new face quads.insert_next_cell(quad) # create the actor polydata = tvtk.PolyData(points=points, polys=quads) if new_tvtk: mapper = tvtk.PolyDataMapper() configure_input(mapper, polydata) else: mapper = tvtk.PolyDataMapper(input=polydata) actor = tvtk.Actor(mapper=mapper) fig.scene.add_actor(actor) return actor
def vtkCone(p, q): from math import pi phi_base, theta_base = misc.Spherical.to(q, p)[1:] quads = tvtk.CellArray() #vtk.vtkCellArray() points = tvtk.Points() #vtk.vtkPoints() for i in range(11): # rotate phi, theta = ConvertDirection((i % 10) * 2 * pi / 10, pi * .5, phi_base, theta_base, True) # generate new points _p = tuple( misc.Spherical.xyz(p[3] * .5 * cone_factor, phi, theta, p[0:3])) _q = tuple( misc.Spherical.xyz(q[3] * .5 * cone_factor, phi, theta, q[0:3])) # insert points points.append(_p) points.append(_q) if i >= 1: # create a face quad = tvtk.Quad() n = points.number_of_points - 1 quad.point_ids.set_id(0, n - 3) # p quad.point_ids.set_id(1, n - 2) # q quad.point_ids.set_id(2, n) # q quad.point_ids.set_id(3, n - 1) # p # insert the new face quads.insert_next_cell(quad) # create the actor polydata = tvtk.PolyData(points=points, polys=quads) mapper = tvtk.PolyDataMapper(input=polydata) actor = tvtk.Actor(mapper=mapper) return actor
for dof in loaded_dofs: F[dof] = -1000.0 U = K.solve(F) # print 'U', U d_Ia = U.reshape(-1, n_c) d_Eia = d_Ia[I_Ei] eps_Enab = np.einsum('Einabc,Eic->Enab', B_Einabc, d_Eia) # print 'eps_Emab', eps_Enab sig_Enab = np.einsum('abef,Emef->Emab', D_abef, eps_Enab) # print 'sig_Emab', sig_Enab delta23_ab = np.array([[1, 0, 0], [0, 1, 0]], dtype=np.float_) cell_class = tvtk.Quad().cell_type n_E, n_i, n_a = x_Eia.shape n_Ei = n_E * n_i points = np.einsum('Ia,ab->Ib', x_Eia.reshape(-1, n_c), delta23_ab) ug = tvtk.UnstructuredGrid(points=points) ug.set_cells(cell_class, np.arange(n_Ei).reshape(n_E, n_i)) vectors = np.einsum('Ia,ab->Ib', d_Eia.reshape(-1, n_c), delta23_ab) ug.point_data.vectors = vectors ug.point_data.vectors.name = 'displacement' # Now view the data. warp_arr = tvtk.DoubleArray(name='displacement') warp_arr.from_array(vectors) ug.point_data.add_array(warp_arr) eps_Encd = tensors = np.einsum('...ab,ac,bd->...cd', eps_Enab, delta23_ab,
class VtkGridMixIn(object): _EDGE_COUNT_TO_TYPE = { 1: tvtk.Vertex().cell_type, 2: tvtk.Line().cell_type, 3: tvtk.Triangle().cell_type, 4: tvtk.Quad().cell_type, } def to_vtk(self): points = self.vtk_points() cell_types = self.vtk_cell_types() cell_array = self.vtk_cell_array() offsets = self.vtk_offsets() vtk_grid = tvtk.UnstructuredGrid(points=points) vtk_grid.set_cells(cell_types, offsets, cell_array) return vtk_grid def vtk_points(self): pad = np.zeros((3 - self._coords.shape[0], self._coords.shape[1])) return np.vstack([self._coords, pad]).T def vtk_cell_array(self): cell_array = tvtk.CellArray() cell_array.set_cells(self.get_cell_count(), self.vtk_connectivity()) return cell_array def vtk_cell_types(self): cell_types = np.empty(self.get_cell_count(), dtype=int) for (id, n_nodes) in enumerate(self.nodes_per_cell()): try: cell_types[id] = self._EDGE_COUNT_TO_TYPE[n_nodes] except KeyError: cell_types[id] = tvtk.Polygon().cell_type return cell_types def vtk_connectivity(self): cells = np.empty(self.get_vertex_count() + self.get_cell_count(), dtype=int) cell_nodes = self.get_connectivity() offset = 0 for n_nodes in self.nodes_per_cell(): cells[offset] = n_nodes offset += n_nodes + 1 offset = 1 for cell in self.vtk_offsets(): n_nodes = cells[offset - 1] cells[offset:offset + n_nodes] = cell_nodes[cell:cell + n_nodes] offset += n_nodes + 1 return cells def vtk_offsets(self): offsets = np.empty(self.get_cell_count(), dtype=int) (offsets[0], offsets[1:]) = (0, self._offset[:-1]) return offsets def vtk_write(self, file_name): writer = tvtk.XMLUnstructuredGridWriter() writer.set_input(self.to_vtk()) writer.file_name = file_name writer.write()
def write_zeta_vtk(zeta, zeta_ref, filename_root): ''' Given a list of arrays representing the coordinates of a set of n_surf UVLM lattices and organised as: zeta[n_surf][3,M+1,N=1] this function writes a vtk for each of the n_surf surfaces. Input: - zeta: lattice coordinates to plot - zeta_ref: reference lattice used to compute the magnitude of displacements - filename_root: initial part of filename (full path) without file extension (.vtk) ''' # from IPython import embed # embed() for i_surf in range(len(zeta)): filename = filename_root + "_%02u.vtu" % (i_surf, ) _, M, N = zeta[i_surf].shape M -= 1 N -= 1 point_data_dim = (M + 1) * (N + 1) panel_data_dim = M * N coords = np.zeros((point_data_dim, 3)) conn = [] panel_id = np.zeros((panel_data_dim, ), dtype=int) panel_surf_id = np.zeros((panel_data_dim, ), dtype=int) point_struct_id = np.zeros((point_data_dim, ), dtype=int) point_struct_mag = np.zeros((point_data_dim, ), dtype=float) counter = -1 # coordinates of corners for i_n in range(N + 1): for i_m in range(M + 1): counter += 1 coords[counter, :] = zeta[i_surf][:, i_m, i_n] counter = -1 node_counter = -1 for i_n in range(N + 1): # global_counter = aero.aero2struct_mapping[i_surf][i_n] for i_m in range(M + 1): node_counter += 1 # point data # point_struct_id[node_counter]=global_counter point_struct_mag[node_counter] = \ np.linalg.norm(zeta[i_surf][:, i_m, i_n] \ - zeta_ref[i_surf][:, i_m, i_n]) if i_n < N and i_m < M: counter += 1 else: continue conn.append([ node_counter + 0, node_counter + 1, node_counter + M + 2, node_counter + M + 1 ]) # cell data panel_id[counter] = counter panel_surf_id[counter] = i_surf ug = tvtk.UnstructuredGrid(points=coords) ug.set_cells(tvtk.Quad().cell_type, conn) ug.cell_data.scalars = panel_id ug.cell_data.scalars.name = 'panel_n_id' ug.cell_data.add_array(panel_surf_id) ug.cell_data.get_array(1).name = 'panel_surface_id' ug.point_data.scalars = np.arange(0, coords.shape[0]) ug.point_data.scalars.name = 'n_id' # ug.point_data.add_array(point_struct_id) # ug.point_data.get_array(1).name = 'point_struct_id' ug.point_data.add_array(point_struct_mag) ug.point_data.get_array(1).name = 'point_displacement_magnitude' write_data(ug, filename)
State = np.zeros(mc.nel).astype(np.int) # Element state PropID = np.zeros(mc.nel) # Property ID for nod in mc.nodes: if len(nod.loc)==2: xyz[nod.localID]= np.array([nod.loc[0]+nod.Dof(dc)[0],nod.loc[1]+nod.Dof(dc)[1],0.]) uvw[nod.localID]= np.array([nod.Dof(dc)[0],nod.Dof(dc)[1],0.]) elif len(nod.loc)==3: xyz[nod.localID]= np.array([nod.loc[0]+nod.Dof(dc)[0],nod.loc[1]+nod.Dof(dc)[1],nod.loc[2]+nod.Dof(dc)[2]]) uvw[nod.localID]= np.array([nod.Dof(dc)[0],nod.Dof(dc)[1],nod.Dof(dc)[2]]) else: raise "node.loc has wrong length for plotting" ug = tvtk.UnstructuredGrid(points=xyz) line_type = tvtk.Line().cell_type quad_type = tvtk.Quad().cell_type hexa_type = tvtk.Hexahedron().cell_type count = 0; for el in mc.elements: if(el.type=='CBAR' or el.type=='CBAR1' or el.type=='CBARX' or el.type=='CBEAMX'): el_type = line_type Jg[count]= 1. elif(el.type=='CQUAD'): el_type = quad_type Jg[count]=np.mean([eh.getJg(el,ip,dc,2) for ip in range(4)]) elif(el.type=='CHEXA'): el_type = hexa_type
def generate2dCells(self, points): boundaryz = np.max(self.z) boundaryy = np.max(self.y) boundaryx = np.max(self.x) x = self.x.reshape(self.x.shape[0], 1) y = self.y.reshape(self.y.shape[0], 1) z = self.z.reshape(self.z.shape[0], 1) count = self.x.shape[0] k = np.arange(count) a = np.max(z) + 1 b = (1 + np.max(z)) * (np.max(y) + 1) #Y-Z Plane boundaries ib2 = np.asarray([ i for i in k if 0 in x[i] and boundaryz not in z[i] and boundaryy not in y[i] ]) ib1 = np.ones(np.size(ib2)) * 4 ib3 = np.asarray([i + 1 for i in ib2]) ib4 = np.asarray([i + a + 1 for i in ib2]) ib5 = np.asarray([i + a for i in ib2]) data1 = self.image[0, :, :].copy() data1[:, :] = 7 data1[self.image[0, :, :] == 0] = 3 data1 = data1.flatten() index = np.where(data1 == 7) ib1, ib2, ib3, ib4, ib5, data1 = self.delete2dindex( ib1, ib2, ib3, ib4, ib5, data1, index) #data1=np.ones(ib1.shape[0]) ob2 = np.asarray([ i for i in k if boundaryx in x[i] and boundaryy not in y[i] and boundaryz not in z[i] ]) ob1 = np.ones(np.size(ob2)) * 4 ob3 = np.asarray([i + 1 for i in ob2]) ob4 = np.asarray([i + a + 1 for i in ob2]) ob5 = np.asarray([i + a for i in ob2]) data2 = self.image[-1, :, :].copy() data2[:, :] = 8 data2[self.image[-1, :, :] == 0] = 4 data2 = data2.flatten() index = np.where(data2 == 8) ob1, ob2, ob3, ob4, ob5, data2 = self.delete2dindex( ob1, ob2, ob3, ob4, ob5, data2, index) #data2=np.ones(ob1.shape[0])*2 innercellsX = np.array(np.dstack([ib1, ib2, ib3, ib4, ib5])) innercellsX = innercellsX.reshape(ib1.shape[0], 5) outercellsX = np.array(np.dstack([ob1, ob2, ob3, ob4, ob5])) outercellsX = outercellsX.reshape(ob1.shape[0], 5) #X-Z Plane boundaries count = self.y.shape[0] k = np.arange(count) ib2 = np.asarray([ i for i in k if 0 in y[i] and boundaryz not in z[i] and boundaryx not in x[i] ]) ib1 = np.ones(np.size(ib2)) * 4 ib3 = np.asarray([i + 1 for i in ib2]) ib4 = np.asarray([i + b + 1 for i in ib2]) ib5 = np.asarray([i + b for i in ib2]) data3 = self.image[:, 0, :].copy() data3[:, :] = 9 data3[self.image[:, 0, :] == 0] = 1 data3 = data3.flatten() index = np.where(data3 == 9) ib1, ib2, ib3, ib4, ib5, data3 = self.delete2dindex( ib1, ib2, ib3, ib4, ib5, data3, index) #data3=np.ones(ob1.shape[0])*3 ob2 = np.asarray([ i for i in k if boundaryy in y[i] and boundaryz not in z[i] and boundaryx not in x[i] ]) ob1 = np.ones(np.size(ob2)) * 4 ob3 = np.asarray([i + 1 for i in ob2]) ob4 = np.asarray([i + b + 1 for i in ob2]) ob5 = np.asarray([i + b for i in ob2]) data4 = self.image[:, -1, :].copy() data4[:, :] = 10 data4[self.image[:, -1, :] == 0] = 2 data4 = data4.flatten() #data4=np.ones(ob1.shape[0])*4 index = np.where(data4 == 10) ob1, ob2, ob3, ob4, ob5, data4 = self.delete2dindex( ob1, ob2, ob3, ob4, ob5, data4, index) innercellsY = np.array(np.dstack([ib1, ib2, ib3, ib4, ib5])) innercellsY = innercellsY.reshape(ib1.shape[0], 5) outercellsY = np.array(np.dstack([ob1, ob2, ob3, ob4, ob5])) outercellsY = outercellsY.reshape(ob1.shape[0], 5) #X-Y Plane boundaries count = self.z.shape[0] k = np.arange(count) ib2 = np.asarray([ i for i in k if 0 in z[i] and boundaryx not in x[i] and boundaryy not in y[i] ]) ib1 = np.ones(np.size(ib2)) * 4 ib3 = np.asarray([i + b for i in ib2]) ib4 = np.asarray([i + b + a for i in ib2]) ib5 = np.asarray([i + a for i in ib2]) data5 = self.image[:, :, 0].copy() data5[:, :] = 11 data5[self.image[:, :, 0] == 0] = 5 data5 = data5.flatten() index = np.where(data5 == 11) ib1, ib2, ib3, ib4, ib5, data5 = self.delete2dindex( ib1, ib2, ib3, ib4, ib5, data5, index) #data5=np.ones(ob1.shape[0])*5 ob2 = np.asarray([ i for i in k if boundaryz in z[i] and boundaryx not in x[i] and boundaryy not in y[i] ]) ob1 = np.ones(np.size(ob2)) * 4 ob3 = np.asarray([i + b for i in ob2]) ob4 = np.asarray([i + b + a for i in ob2]) ob5 = np.asarray([i + a for i in ob2]) data6 = self.image[:, :, -1].copy() data6[:, :] = 12 data6[self.image[:, :, -1] == 0] = 6 data6 = data6.flatten() #data6=np.ones(ob1.shape[0])*6 index = np.where(data6 == 12) ob1, ob2, ob3, ob4, ob5, data6 = self.delete2dindex( ob1, ob2, ob3, ob4, ob5, data6, index) innercellsZ = np.array(np.dstack([ib1, ib2, ib3, ib4, ib5])) innercellsZ = innercellsZ.reshape(ib1.shape[0], 5) outercellsZ = np.array(np.dstack([ob1, ob2, ob3, ob4, ob5])) outercellsZ = outercellsZ.reshape(ob1.shape[0], 5) cells = np.vstack([ innercellsX, outercellsX, innercellsY, outercellsY, innercellsZ, outercellsZ ]) cellcount = cells.shape[0] cells = cells.flatten() quad_type = tvtk.Quad().cell_type offset = np.arange(0, cellcount, 5) cell_types = np.ones(cellcount) * quad_type data1 = data1.reshape([np.shape(data1)[0], 1]) data2 = data2.reshape([np.shape(data2)[0], 1]) data3 = data3.reshape([np.shape(data3)[0], 1]) data4 = data4.reshape([np.shape(data4)[0], 1]) data5 = data5.reshape([np.shape(data5)[0], 1]) data6 = data6.reshape([np.shape(data6)[0], 1]) cell_data = np.vstack([data1, data2, data3, data4, data5, data6]) cell_data = cell_data.flatten() return [cell_types, offset, cellcount, cells, cell_data]
def plot_wake(self): for i_surf in range(self.data.aero.timestep_info[self.ts].n_surf): filename = (self.wake_filename + '_' + '%02u_' % i_surf + '%06u' % self.ts) dims_star = self.data.aero.timestep_info[self.ts].dimensions_star[ i_surf, :].copy() dims_star[0] -= self.settings['minus_m_star'] point_data_dim = (dims_star[0] + 1) * (dims_star[1] + 1) panel_data_dim = (dims_star[0]) * (dims_star[1]) coords = np.zeros((point_data_dim, 3)) conn = [] panel_id = np.zeros((panel_data_dim, ), dtype=int) panel_surf_id = np.zeros((panel_data_dim, ), dtype=int) panel_gamma = np.zeros((panel_data_dim, )) counter = -1 # rotation_mat = self.data.structure.timestep_info[self.ts].cga().T # coordinates of corners for i_n in range(dims_star[1] + 1): for i_m in range(dims_star[0] + 1): counter += 1 coords[counter, :] = self.data.aero.timestep_info[ self.ts].zeta_star[i_surf][:, i_m, i_n] if self.settings['include_rbm']: coords[ counter, :] += self.data.structure.timestep_info[ self.ts].for_pos[0:3] if self.settings['include_forward_motion']: coords[counter, 0] -= self.settings[ 'dt'].value * self.ts * self.settings['u_inf'].value counter = -1 node_counter = -1 # wake for i_n in range(dims_star[1] + 1): for i_m in range(dims_star[0] + 1): node_counter += 1 # cell data if i_n < dims_star[1] and i_m < dims_star[0]: counter += 1 else: continue conn.append([ node_counter + 0, node_counter + 1, node_counter + dims_star[0] + 2, node_counter + dims_star[0] + 1 ]) panel_id[counter] = counter panel_surf_id[counter] = i_surf panel_gamma[counter] = self.data.aero.timestep_info[ self.ts].gamma_star[i_surf][i_m, i_n] ug = tvtk.UnstructuredGrid(points=coords) ug.set_cells(tvtk.Quad().cell_type, conn) ug.cell_data.scalars = panel_id ug.cell_data.scalars.name = 'panel_n_id' ug.cell_data.add_array(panel_surf_id) ug.cell_data.get_array(1).name = 'panel_surface_id' ug.cell_data.add_array(panel_gamma) ug.cell_data.get_array(2).name = 'panel_gamma' ug.point_data.scalars = np.arange(0, coords.shape[0]) ug.point_data.scalars.name = 'n_id' write_data(ug, filename)
def plot_body(self): aero_tstep = self.data.aero.timestep_info[self.ts] struct_tstep = self.data.structure.timestep_info[self.ts] if self.settings['include_incidence_angle']: aero_tstep.postproc_cell['incidence_angle'] = [] for isurf in range(aero_tstep.n_surf): aero_tstep.postproc_cell['incidence_angle'].append( np.zeros_like(aero_tstep.gamma[isurf])) uvlmlib.uvlm_calculate_incidence_angle(aero_tstep, struct_tstep) for i_surf in range(aero_tstep.n_surf): filename = (self.body_filename + '_' + '%02u_' % i_surf + '%06u' % self.ts) dims = aero_tstep.dimensions[i_surf, :] point_data_dim = (dims[0] + 1) * ( dims[1] + 1) # + (dims_star[0]+1)*(dims_star[1]+1) panel_data_dim = (dims[0]) * (dims[1] ) # + (dims_star[0])*(dims_star[1]) coords = np.zeros((point_data_dim, 3)) conn = [] panel_id = np.zeros((panel_data_dim, ), dtype=int) panel_surf_id = np.zeros((panel_data_dim, ), dtype=int) panel_gamma = np.zeros((panel_data_dim, )) panel_gamma_dot = np.zeros((panel_data_dim, )) normal = np.zeros((panel_data_dim, 3)) point_struct_id = np.zeros((point_data_dim, ), dtype=int) point_cf = np.zeros((point_data_dim, 3)) point_unsteady_cf = np.zeros((point_data_dim, 3)) zeta_dot = np.zeros((point_data_dim, 3)) u_inf = np.zeros((point_data_dim, 3)) if self.settings['include_velocities']: vel = np.zeros((point_data_dim, 3)) counter = -1 # coordinates of corners for i_n in range(dims[1] + 1): for i_m in range(dims[0] + 1): counter += 1 coords[counter, :] = aero_tstep.zeta[i_surf][:, i_m, i_n] if self.settings['include_rbm']: coords[counter, :] += struct_tstep.for_pos[0:3] if self.settings['include_forward_motion']: coords[counter, 0] -= self.settings[ 'dt'].value * self.ts * self.settings['u_inf'].value if self.settings['include_incidence_angle']: incidence_angle = np.zeros_like(panel_gamma) counter = -1 node_counter = -1 for i_n in range(dims[1] + 1): global_counter = self.data.aero.aero2struct_mapping[i_surf][ i_n] for i_m in range(dims[0] + 1): node_counter += 1 # point data point_struct_id[node_counter] = global_counter point_cf[node_counter, :] = aero_tstep.forces[i_surf][0:3, i_m, i_n] try: point_unsteady_cf[ node_counter, :] = aero_tstep.dynamic_forces[ i_surf][0:3, i_m, i_n] except AttributeError: pass try: zeta_dot[ node_counter, :] = aero_tstep.zeta_dot[i_surf][0:3, i_m, i_n] except AttributeError: pass try: u_inf[node_counter, :] = aero_tstep.u_ext[i_surf][0:3, i_m, i_n] except AttributeError: pass if i_n < dims[1] and i_m < dims[0]: counter += 1 else: continue conn.append([ node_counter + 0, node_counter + 1, node_counter + dims[0] + 2, node_counter + dims[0] + 1 ]) # cell data normal[counter, :] = aero_tstep.normals[i_surf][:, i_m, i_n] panel_id[counter] = counter panel_surf_id[counter] = i_surf panel_gamma[counter] = aero_tstep.gamma[i_surf][i_m, i_n] panel_gamma_dot[counter] = aero_tstep.gamma_dot[i_surf][ i_m, i_n] if self.settings['include_incidence_angle']: incidence_angle[counter] = \ aero_tstep.postproc_cell['incidence_angle'][i_surf][i_m, i_n] if self.settings['include_velocities']: vel = uvlmlib.uvlm_calculate_total_induced_velocity_at_points( aero_tstep, coords, struct_tstep.for_pos, self.settings['numcores']) ug = tvtk.UnstructuredGrid(points=coords) ug.set_cells(tvtk.Quad().cell_type, conn) ug.cell_data.scalars = panel_id ug.cell_data.scalars.name = 'panel_n_id' ug.cell_data.add_array(panel_surf_id) ug.cell_data.get_array(1).name = 'panel_surface_id' ug.cell_data.add_array(panel_gamma) ug.cell_data.get_array(2).name = 'panel_gamma' ug.cell_data.add_array(panel_gamma_dot) ug.cell_data.get_array(3).name = 'panel_gamma_dot' if self.settings['include_incidence_angle']: ug.cell_data.add_array(incidence_angle) ug.cell_data.get_array(4).name = 'incidence_angle' ug.cell_data.vectors = normal ug.cell_data.vectors.name = 'panel_normal' ug.point_data.scalars = np.arange(0, coords.shape[0]) ug.point_data.scalars.name = 'n_id' ug.point_data.add_array(point_struct_id) ug.point_data.get_array(1).name = 'point_struct_id' ug.point_data.add_array(point_cf) ug.point_data.get_array(2).name = 'point_steady_force' ug.point_data.add_array(point_unsteady_cf) ug.point_data.get_array(3).name = 'point_unsteady_force' ug.point_data.add_array(zeta_dot) ug.point_data.get_array(4).name = 'zeta_dot' ug.point_data.add_array(u_inf) ug.point_data.get_array(5).name = 'u_inf' if self.settings['include_velocities']: ug.point_data.add_array(vel) ug.point_data.get_array(6).name = 'velocity' write_data(ug, filename)
def exa2vtk(field, downsample): """A function for converting exadata to vtk data Parameters ---------- field : str a dataset in nekdata format downsample : bool flag T/F """ # if (downsample): ixs = field.lr1[0] - 1 iys = field.lr1[1] - 1 izs = max(field.lr1[2] - 1, 1) else: ixs = 1 iys = 1 izs = 1 # iix = range(0, field.lr1[0], ixs) nix = len(iix) iiy = range(0, field.lr1[1], iys) niy = len(iiy) iiz = range(0, field.lr1[2], izs) niz = len(iiz) # nppel = nix * niy * niz nepel = (nix - 1) * (niy - 1) * max((niz - 1), 1) nel = field.nel * nepel # if (field.ndim == 3): nvert = 8 cellType = tvtk.Hexahedron().cell_type else: nvert = 4 cellType = tvtk.Quad().cell_type # ct = np.array(nel * [cellType]) of = np.arange(0, nvert * nel, nvert) ce = np.zeros(nel * (nvert + 1)) ce[range(0, nel * (nvert + 1), nvert + 1)] = nvert if (field.var[0] != 0): r = np.zeros((nvert * nel, 3)) if (field.var[1] != 0): v = np.zeros((nvert * nel, 3)) if (field.var[2] == 1): p = np.zeros(nvert * nel) if (field.var[3] == 1): T = np.zeros(nvert * nel) if (field.var[4] != 0): S = np.zeros((nvert * nel, field.var[4])) # ice = -(nvert + 1) for iel in range(field.nel): for iz in range(niz): for iy in range(niy): for ix in range(nix): if (field.var[0] == 3): r[iel * nppel + ix + iy * nix + iz * nix * niy, :] = field.elem[iel].pos[:, iiz[iz], iiy[iy], iix[ix]] if (field.var[1] == 3): v[iel * nppel + ix + iy * nix + iz * nix * niy, :] = field.elem[iel].vel[:, iiz[iz], iiy[iy], iix[ix]] if (field.var[2] == 1): p[iel * nppel + ix + iy * nix + iz * nix * niy] = field.elem[iel].pres[:, iiz[iz], iiy[iy], iix[ix]] if (field.var[3] == 1): T[iel * nppel + ix + iy * nix + iz * nix * niy] = field.elem[iel].temp[:, iiz[iz], iiy[iy], iix[ix]] if (field.var[4] != 0): S[iel * nppel + ix + iy * nix + iz * nix * niy, :] = field.elem[iel].scal[:, iiz[iz], iiy[iy], iix[ix]] if (field.var[0] == 3): for iz in max(range(niz - 1), [0]): for iy in range(niy - 1): for ix in range(nix - 1): ice = ice + nvert + 1 for face in range(field.ndim - 1): ce[ice + face * 4 + 1] = iel * nppel + ix + iy * nix + ( iz + face) * nix * niy ce[ice + face * 4 + 2] = iel * nppel + ix + 1 + iy * nix + ( iz + face) * nix * niy ce[ice + face * 4 + 3] = iel * nppel + ix + 1 + ( iy + 1) * nix + (iz + face) * nix * niy ce[ice + face * 4 + 4] = iel * nppel + ix + ( iy + 1) * nix + (iz + face) * nix * niy # create the array of cells ca = tvtk.CellArray() ca.set_cells(nel, ce) # create the unstructured dataset dataset = tvtk.UnstructuredGrid(points=r) # set the cell types dataset.set_cells(ct, of, ca) # set the data dataset.point_data.vectors = v dataset.point_data.vectors.name = 'vel' if (field.var[2] == 1): dataset.point_data.scalars = p dataset.point_data.scalars.name = 'pres' if (field.var[3] == 1): dataset.point_data.add_array(T) dataset.point_data.get_array(2).name = 'temp' if (field.var[4] != 0): for ii in range(field.var[4]): dataset.point_data.add_array(S[:, ii]) dataset.point_data.get_array(ii + 3).name = 'scal_%d' % (ii + 1) # dataset.point_data.update() # return dataset
def exa2vtk(field, downsample=False): """A function for converting exadata to `Traited VTK`_ dataset. The returned dataset can be manipulated with libraries which accept a VTK object, for example Mayavi_. .. _Traited VTK: https://docs.enthought.com/mayavi/tvtk/README.html Example ------- This also requires you to have a GUI toolkit installed: either PyQt4, PySide, PySide2, PyQt5 or wxPython. .. code-block:: python import pymech as pm from pymech.vtksuite import exa2vtk from mayavi import mlab field = pm.readnek("tests/nek/channel3D_0.f00001") dataset = exa2vtk(field) mlab.pipeline.add_dataset(dataset) Instead of MayaVi_ you could use also use something high-level like PyVista_ to wrap the underlying VTK object and later visualize them. .. code-block:: python import pyvista as pv dataset = pv.wrap(dataset._vtk_obj) dataset.plot() .. _MayaVi: https://docs.enthought.com/mayavi/mayavi/mlab.html .. _PyVista: https://docs.pyvista.org/getting-started/simple.html Parameters ---------- field : exadata a dataset in nekdata format downsample : bool flag T/F Returns ------- dataset : tvtk.tvtk_classes.unstructured_grid.UnstructuredGrid a VTK dataset """ # if downsample: ixs = field.lr1[0] - 1 iys = field.lr1[1] - 1 izs = max(field.lr1[2] - 1, 1) else: ixs = 1 iys = 1 izs = 1 # iix = range(0, field.lr1[0], ixs) nix = len(iix) iiy = range(0, field.lr1[1], iys) niy = len(iiy) iiz = range(0, field.lr1[2], izs) niz = len(iiz) # nppel = nix * niy * niz nepel = (nix - 1) * (niy - 1) * max((niz - 1), 1) nel = field.nel * nepel # if field.ndim == 3: nvert = 8 cellType = tvtk.Hexahedron().cell_type else: nvert = 4 cellType = tvtk.Quad().cell_type # ct = np.array(nel * [cellType]) of = np.arange(0, nvert * nel, nvert) ce = np.zeros(nel * (nvert + 1)) ce[np.arange(nel) * (nvert + 1)] = nvert if field.var[0] != 0: r = np.zeros((nvert * nel, 3)) if field.var[1] != 0: v = np.zeros((nvert * nel, 3)) if field.var[2] == 1: p = np.zeros(nvert * nel) if field.var[3] == 1: T = np.zeros(nvert * nel) if field.var[4] != 0: S = np.zeros((nvert * nel, field.var[4])) # ice = -(nvert + 1) for iel in range(field.nel): for (iz, ez), (iy, ey), (ix, ex) in product(enumerate(iiz), enumerate(iiy), enumerate(iix)): iarray = iel * nppel + ix + iy * nix + iz * (nix * niy) # Downsample copy into a column vector if field.var[0] == 3: r[iarray, :] = field.elem[iel].pos[:, ez, ey, ex] if field.var[1] == 3: v[iarray, :] = field.elem[iel].vel[:, ez, ey, ex] if field.var[2] == 1: p[iarray] = field.elem[iel].pres[:, ez, ey, ex] if field.var[3] == 1: T[iarray] = field.elem[iel].temp[:, ez, ey, ex] if field.var[4] != 0: S[iarray, :] = field.elem[iel].scal[:, ez, ey, ex] if field.var[0] == 3: for iz, iy, ix in product(range(max(niz - 1, 1)), range(niy - 1), range(nix - 1)): ice = ice + nvert + 1 for face in range(field.ndim - 1): cell_id = iel * nppel + ix + iy * nix + (iz + face) * nix * niy ce[ice + face * 4 + 1] = cell_id ce[ice + face * 4 + 2] = cell_id + 1 ce[ice + face * 4 + 3] = cell_id + nix + 1 ce[ice + face * 4 + 4] = cell_id + nix # create the array of cells ca = tvtk.CellArray() ca.set_cells(nel, ce) # create the unstructured dataset dataset = tvtk.UnstructuredGrid(points=r) # set the cell types dataset.set_cells(ct, of, ca) # set the data idata = 0 if field.var[1] != 0: dataset.point_data.vectors = v dataset.point_data.vectors.name = "vel" idata += 1 if field.var[2] == 1: dataset.point_data.scalars = p dataset.point_data.scalars.name = "pres" idata += 1 if field.var[3] == 1: dataset.point_data.add_array(T) dataset.point_data.get_array(idata).name = "temp" idata += 1 if field.var[4] != 0: for ii in range(field.var[4]): dataset.point_data.add_array(S[:, ii]) dataset.point_data.get_array(ii + idata).name = "scal_%d" % (ii + 1) # dataset.point_data.update() # return dataset
def write_modes_vtk(data, eigenvectors, NumLambda, filename_root, rot_max_deg=15., perc_max=0.15): ''' Writes a vtk file for each of the first NumLambda eigenvectors. When these are associated to the state-space form of the structural equations, only the displacement field is saved. ''' ### initialise aero = data.aero struct = data.structure tsaero = data.aero.timestep_info[data.ts] tsstr = data.structure.timestep_info[data.ts] num_dof = struct.num_dof.value eigenvectors = eigenvectors[:num_dof, :] for mode in range(NumLambda): # scale eigenvector eigvec = eigenvectors[:num_dof, mode] eigvec = scale_mode(data, eigvec, rot_max_deg, perc_max) zeta_mode = get_mode_zeta(data, eigvec) for i_surf in range(tsaero.n_surf): # filename=filename_root+"_%06u_%02u.vtu" %(mode,i_surf) filename = filename_root + "_%02u_%06u.vtu" % (i_surf, mode) dims = tsaero.dimensions[i_surf, :] point_data_dim = (dims[0] + 1) * ( dims[1] + 1) # + (dims_star[0]+1)*(dims_star[1]+1) panel_data_dim = (dims[0]) * (dims[1] ) # + (dims_star[0])*(dims_star[1]) coords = np.zeros((point_data_dim, 3)) conn = [] panel_id = np.zeros((panel_data_dim, ), dtype=int) panel_surf_id = np.zeros((panel_data_dim, ), dtype=int) point_struct_id = np.zeros((point_data_dim, ), dtype=int) point_struct_mag = np.zeros((point_data_dim, ), dtype=float) counter = -1 # coordinates of corners for i_n in range(dims[1] + 1): for i_m in range(dims[0] + 1): counter += 1 coords[counter, :] = zeta_mode[i_surf][:, i_m, i_n] counter = -1 node_counter = -1 for i_n in range(dims[1] + 1): global_counter = aero.aero2struct_mapping[i_surf][i_n] for i_m in range(dims[0] + 1): node_counter += 1 # point data point_struct_id[node_counter] = global_counter point_struct_mag[node_counter]=\ np.linalg.norm(zeta_mode[i_surf][:, i_m, i_n]\ -tsaero.zeta[i_surf][:,i_m,i_n]) if i_n < dims[1] and i_m < dims[0]: counter += 1 else: continue conn.append([ node_counter + 0, node_counter + 1, node_counter + dims[0] + 2, node_counter + dims[0] + 1 ]) # cell data panel_id[counter] = counter panel_surf_id[counter] = i_surf ug = tvtk.UnstructuredGrid(points=coords) ug.set_cells(tvtk.Quad().cell_type, conn) ug.cell_data.scalars = panel_id ug.cell_data.scalars.name = 'panel_n_id' ug.cell_data.add_array(panel_surf_id) ug.cell_data.get_array(1).name = 'panel_surface_id' ug.point_data.scalars = np.arange(0, coords.shape[0]) ug.point_data.scalars.name = 'n_id' ug.point_data.add_array(point_struct_id) ug.point_data.get_array(1).name = 'point_struct_id' ug.point_data.add_array(point_struct_mag) ug.point_data.get_array(2).name = 'point_displacement_magnitude' write_data(ug, filename)
def plot_body(self): for i_surf in range(self.data.aero.timestep_info[self.ts].n_surf): filename = (self.body_filename + '_' + '%02u_' % i_surf + '%06u' % self.ts) dims = self.data.aero.timestep_info[self.ts].dimensions[i_surf, :] # dims_star = self.data.aero.timestep_info[self.ts].dimensions_star[i_surf, :] point_data_dim = (dims[0] + 1) * ( dims[1] + 1) # + (dims_star[0]+1)*(dims_star[1]+1) panel_data_dim = (dims[0]) * (dims[1] ) # + (dims_star[0])*(dims_star[1]) coords = np.zeros((point_data_dim, 3)) conn = [] panel_id = np.zeros((panel_data_dim, ), dtype=int) panel_surf_id = np.zeros((panel_data_dim, ), dtype=int) panel_gamma = np.zeros((panel_data_dim, )) normal = np.zeros((panel_data_dim, 3)) point_struct_id = np.zeros((point_data_dim, ), dtype=int) point_cf = np.zeros((point_data_dim, 3)) point_unsteady_cf = np.zeros((point_data_dim, 3)) counter = -1 rotation_mat = algebra.quat2rot( self.data.structure.timestep_info[self.ts].quat).transpose() # coordinates of corners for i_n in range(dims[1] + 1): for i_m in range(dims[0] + 1): counter += 1 coords[counter, :] = self.data.aero.timestep_info[ self.ts].zeta[i_surf][:, i_m, i_n] if self.settings['include_rbm']: coords[counter, :] = np.dot( rotation_mat, self.data.aero.timestep_info[ self.ts].zeta[i_surf][:, i_m, i_n]) coords[ counter, :] += self.data.structure.timestep_info[ self.ts].for_pos[0:3] counter = -1 node_counter = -1 for i_n in range(dims[1] + 1): global_counter = self.data.aero.aero2struct_mapping[i_surf][ i_n] for i_m in range(dims[0] + 1): node_counter += 1 # point data point_struct_id[node_counter] = global_counter point_cf[node_counter, :] = self.data.aero.timestep_info[ self.ts].forces[i_surf][0:3, i_m, i_n] try: point_unsteady_cf[ node_counter, :] = self.data.aero.timestep_info[ self.ts].dynamic_forces[i_surf][0:3, i_m, i_n] except AttributeError: pass if i_n < dims[1] and i_m < dims[0]: counter += 1 else: continue conn.append([ node_counter + 0, node_counter + 1, node_counter + dims[0] + 2, node_counter + dims[0] + 1 ]) # cell data normal[counter, :] = self.data.aero.timestep_info[ self.ts].normals[i_surf][:, i_m, i_n] panel_id[counter] = counter panel_surf_id[counter] = i_surf panel_gamma[counter] = self.data.aero.timestep_info[ self.ts].gamma[i_surf][i_m, i_n] ug = tvtk.UnstructuredGrid(points=coords) ug.set_cells(tvtk.Quad().cell_type, conn) ug.cell_data.scalars = panel_id ug.cell_data.scalars.name = 'panel_n_id' ug.cell_data.add_array(panel_surf_id) ug.cell_data.get_array(1).name = 'panel_surface_id' ug.cell_data.add_array(panel_gamma) ug.cell_data.get_array(2).name = 'panel_gamma' ug.cell_data.vectors = normal ug.cell_data.vectors.name = 'panel_normal' ug.point_data.scalars = np.arange(0, coords.shape[0]) ug.point_data.scalars.name = 'n_id' ug.point_data.add_array(point_struct_id) ug.point_data.get_array(1).name = 'point_struct_id' ug.point_data.add_array(point_cf) ug.point_data.get_array(2).name = 'point_steady_force' ug.point_data.add_array(point_unsteady_cf) ug.point_data.get_array(3).name = 'point_unsteady_force' write_data(ug, filename)