def test_cell_array(self): """ Test if cell array insertion updates number of cells. Fixes GH Issue 178. """ cell_array = tvtk.CellArray() line1 = tvtk.Line() self.assertEqual(cell_array.number_of_cells, 0) cell_array.insert_next_cell(line1) self.assertEqual(cell_array.number_of_cells, 1) line2 = tvtk.Line() cell_array.insert_next_cell(line2) self.assertEqual(cell_array.number_of_cells, 2)
class Mesh1D(Mesh): def __init__(self, vertexCoords, faceVertexIDs, cellFaceIDs, communicator=serialComm, _RepresentationClass=_MeshRepresentation, _TopologyClass=_Mesh1DTopology): super(Mesh1D, self).__init__(vertexCoords=vertexCoords, faceVertexIDs=faceVertexIDs, cellFaceIDs=cellFaceIDs, communicator=communicator, _RepresentationClass=_RepresentationClass, _TopologyClass=_TopologyClass) def _calcScaleArea(self): return 1. def _calcScaleVolume(self): return self.scale['length'] def _calcFaceAreas(self): return numerix.ones(self.numberOfFaces, 'd') def _calcFaceNormals(self): faceNormals = numerix.array((numerix.ones(self.numberOfFaces, 'd'), )) # The left-most face has neighboring cells None and the left-most cell. # We must reverse the normal to make fluxes work correctly. if self.numberOfFaces > 0: faceNormals[..., 0] = -faceNormals[..., 0] return faceNormals def _calcFaceTangents(self): faceTangents1 = numerix.zeros(self.numberOfFaces, 'd')[numerix.NewAxis, ...] faceTangents2 = numerix.zeros(self.numberOfFaces, 'd')[numerix.NewAxis, ...] return faceTangents1, faceTangents2 def _translate(self, vector): newCoords = self.vertexCoords + vector newmesh = Mesh1D(newCoords, numerix.array(self.faceVertexIDs), numerix.array(self.cellFaceIDs)) return newmesh def __mul__(self, factor): newCoords = self.vertexCoords * factor newmesh = Mesh1D(newCoords, numerix.array(self.faceVertexIDs), numerix.array(self.cellFaceIDs)) return newmesh @property def _VTKCellType(self): try: from tvtk.api import tvtk except ImportError, e: from enthought.tvtk.api import tvtk return tvtk.Line().cell_type
def _configure(self, points): self.vtk_points = tvtk.Points() self.lines = tvtk.CellArray() for point in points: self.vtk_points.insert_next_point(self._to_float_tuple(point)) for i in xrange(len(points)-1): line = tvtk.Line() line.point_ids.set_id(0, i) line.point_ids.set_id(1, i+1) self.lines.insert_next_cell(line) self.poly_data = tvtk.PolyData(points=self.vtk_points, lines=self.lines) self._set_actor()
def add_point(self, point): """Adds a point to the polyline. Arguments: :point: a point of the form (x, y, z) or an object returned by the Point function. """ idx = len(self.vtk_points) - 1 self.vtk_points.insert_next_point(self._to_float_tuple(point)) line = tvtk.Line() line.point_ids.set_id(0, idx) line.point_ids.set_id(1, idx+1) self.lines.insert_next_cell(line) self.poly_data.update_traits() self.poly_data.modified() self.actor.mapper.update()
def save_wires_vtk(result, outfile, **kwds): ''' Save wires. ''' from tvtk.api import tvtk, write_data points = list() lines = list() plane_numbers = list() domains = list() iplane = 0 for typ, nam, arr in result.triplets(): if typ != 'rays': continue mp = result.params[iplane] params = mp['params'] domain_offset = params['domain_offset'] iplane += 1 print iplane, domain_offset, typ, nam, arr.shape for iwire, (t, h) in enumerate(arr): plane_numbers.append(iplane) ti = len(points) points.append(t) hi = len(points) points.append(h) lines.append((ti, hi)) domains.append(domain_offset + iwire) point_type = tvtk.Line().cell_type pd = tvtk.PolyData(points=numpy.asarray(points), lines=numpy.asarray(lines)) pd.cell_data.add_array(numpy.asarray(plane_numbers)) pd.cell_data.get_array(0).name = 'plane' pd.cell_data.add_array(numpy.asarray(domains)) pd.cell_data.get_array(1).name = 'domain' write_data(pd, outfile)
def _VTKCellType(self): try: from tvtk.api import tvtk except ImportError as e: from enthought.tvtk.api import tvtk return tvtk.Line().cell_type
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()
Jg = np.zeros(mc.nel) # Growth factor 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 plot(self): for it in range(len(self.data.structure.timestep_info)): it_filename = (self.filename + '%06u' % it) num_nodes = self.data.structure.num_node num_elem = self.data.structure.num_elem coords = np.zeros((num_nodes, 3)) conn = np.zeros((num_elem, 3), dtype=int) node_id = np.zeros((num_nodes, ), dtype=int) elem_id = np.zeros((num_elem, ), dtype=int) local_x = np.zeros((num_nodes, 3)) local_y = np.zeros((num_nodes, 3)) local_z = np.zeros((num_nodes, 3)) # output_loads = True # try: # self.data.beam.timestep_info[it].loads # except AttributeError: # output_loads = False # if output_loads: # gamma = np.zeros((num_elem, 3)) # kappa = np.zeros((num_elem, 3)) # if self.settings['applied_forces']: # if self.settings['frame'] == 'inertial': # try: # self.aero2inertial = self.data.grid.inertial2aero.T # except AttributeError: # self.aero2inertial = np.eye(3) # cout.cout_wrap('BeamPlot: No inertial2aero information, output will be in body FoR', 0) # # else: # self.aero2inertial = np.eye(3) app_forces = np.zeros((num_nodes, 3)) unsteady_app_forces = np.zeros((num_nodes, 3)) # aero2inertial rotation aero2inertial = algebra.quat2rot( self.data.structure.timestep_info[it].quat).transpose() # coordinates of corners # for i_node in range(num_nodes): # coords[i_node, :] = self.data.structure.timestep_info[it].pos[i_node, :] # if self.settings['include_rbm']: # coords[i_node, :] = np.dot(aero2inertial, coords[i_node, :]) # coords[i_node, :] += self.data.structure.timestep_info[it].for_pos[0:3] coords = self.data.structure.timestep_info[it].glob_pos( include_rbm=self.settings['include_rbm']) for i_node in range(num_nodes): i_elem = self.data.structure.node_master_elem[i_node, 0] i_local_node = self.data.structure.node_master_elem[i_node, 1] node_id[i_node] = i_node # v1, v2, v3 = self.data.structure.elements[i_elem].deformed_triad( # self.data.structure.timestep_info[it].psi[i_elem, :, :] # ) # local_x[i_node, :] = np.dot(aero2inertial, v1[i_local_node, :]) # local_y[i_node, :] = np.dot(aero2inertial, v2[i_local_node, :]) # local_z[i_node, :] = np.dot(aero2inertial, v3[i_local_node, :]) v1 = np.array([1., 0, 0]) v2 = np.array([0., 1, 0]) v3 = np.array([0., 0, 1]) cab = algebra.crv2rot( self.data.structure.timestep_info[it].psi[i_elem, i_local_node, :]) local_x[i_node, :] = np.dot(aero2inertial, np.dot(cab, v1)) local_y[i_node, :] = np.dot(aero2inertial, np.dot(cab, v2)) local_z[i_node, :] = np.dot(aero2inertial, np.dot(cab, v3)) # applied forces cab = algebra.crv2rot( self.data.structure.timestep_info[it].psi[i_elem, i_local_node, :]) app_forces[i_node, :] = np.dot( aero2inertial, np.dot( cab, self.data.structure.timestep_info[it]. steady_applied_forces[i_node, 0:3])) if not it == 0: try: unsteady_app_forces[i_node, :] = np.dot( aero2inertial, np.dot( cab, self.data.structure.dynamic_input[it - 1] ['dynamic_forces'][i_node, 0:3])) except IndexError: pass for i_elem in range(num_elem): conn[i_elem, :] = self.data.structure.elements[ i_elem].reordered_global_connectivities elem_id[i_elem] = i_elem # if output_loads: # gamma[i_elem, :] = self.data.structure.timestep_info[it].loads[i_elem, 0:3] # kappa[i_elem, :] = self.data.structure.timestep_info[it].loads[i_elem, 3:6] ug = tvtk.UnstructuredGrid(points=coords) ug.set_cells(tvtk.Line().cell_type, conn) ug.cell_data.scalars = elem_id ug.cell_data.scalars.name = 'elem_id' # if output_loads: # ug.cell_data.add_array(gamma, 'vector') # ug.cell_data.get_array(1).name = 'gamma' # ug.cell_data.add_array(kappa, 'vector') # ug.cell_data.get_array(2).name = 'kappa' ug.point_data.scalars = node_id ug.point_data.scalars.name = 'node_id' point_vector_counter = 1 ug.point_data.add_array(local_x, 'vector') ug.point_data.get_array(point_vector_counter).name = 'local_x' point_vector_counter += 1 ug.point_data.add_array(local_y, 'vector') ug.point_data.get_array(point_vector_counter).name = 'local_y' point_vector_counter += 1 ug.point_data.add_array(local_z, 'vector') ug.point_data.get_array(point_vector_counter).name = 'local_z' if self.settings['include_applied_forces']: point_vector_counter += 1 ug.point_data.add_array(app_forces, 'vector') ug.point_data.get_array( point_vector_counter).name = 'app_forces' if self.settings['include_unsteady_applied_forces']: point_vector_counter += 1 ug.point_data.add_array(unsteady_app_forces, 'vector') ug.point_data.get_array( point_vector_counter).name = 'unsteady_app_forces' write_data(ug, it_filename)
def write_beam(self, it): it_filename = (self.filename + '%06u' % it) num_nodes = self.data.structure.num_node num_elem = self.data.structure.num_elem coords = np.zeros((num_nodes, 3)) conn = np.zeros((num_elem, 3), dtype=int) node_id = np.zeros((num_nodes, ), dtype=int) elem_id = np.zeros((num_elem, ), dtype=int) coords_a_cell = np.zeros((num_elem, 3), dtype=int) local_x = np.zeros((num_nodes, 3)) local_y = np.zeros((num_nodes, 3)) local_z = np.zeros((num_nodes, 3)) coords_a = np.zeros((num_nodes, 3)) app_forces = np.zeros((num_nodes, 3)) app_moment = np.zeros((num_nodes, 3)) forces_constraints_nodes = np.zeros((num_nodes, 3)) moments_constraints_nodes = np.zeros((num_nodes, 3)) if self.data.structure.timestep_info[it].in_global_AFoR: tstep = self.data.structure.timestep_info[it] else: tstep = self.data.structure.timestep_info[it].copy() tstep.whole_structure_to_global_AFoR(self.data.structure) # aero2inertial rotation aero2inertial = tstep.cga() # coordinates of corners coords = tstep.glob_pos(include_rbm=self.settings['include_rbm']) # check if I can output gravity forces with_gravity = False try: gravity_forces = tstep.gravity_forces[:] gravity_forces_g = np.zeros_like(gravity_forces) with_gravity = True except AttributeError: pass # check if postproc dicts are present and count/prepare with_postproc_cell = False try: tstep.postproc_cell with_postproc_cell = True except AttributeError: pass with_postproc_node = False try: tstep.postproc_node with_postproc_node = True except AttributeError: pass # count number of arguments postproc_cell_keys = tstep.postproc_cell.keys() postproc_cell_vals = tstep.postproc_cell.values() postproc_cell_scalar = [] postproc_cell_vector = [] postproc_cell_6vector = [] for k, v in tstep.postproc_cell.items(): _, cols = v.shape if cols == 1: raise NotImplementedError( 'scalar cell types not supported in beamplot (Easy to implement)' ) # postproc_cell_scalar.append(k) elif cols == 3: postproc_cell_vector.append(k) elif cols == 6: postproc_cell_6vector.append(k) else: raise AttributeError( 'Only scalar and 3-vector types supported in beamplot') # count number of arguments postproc_node_keys = tstep.postproc_node.keys() postproc_node_vals = tstep.postproc_node.values() postproc_node_scalar = [] postproc_node_vector = [] postproc_node_6vector = [] for k, v in tstep.postproc_node.items(): _, cols = v.shape if cols == 1: raise NotImplementedError( 'scalar node types not supported in beamplot (Easy to implement)' ) # postproc_cell_scalar.append(k) elif cols == 3: postproc_node_vector.append(k) elif cols == 6: postproc_node_6vector.append(k) else: raise AttributeError( 'Only scalar and 3-vector types supported in beamplot') for i_node in range(num_nodes): i_elem = self.data.structure.node_master_elem[i_node, 0] i_local_node = self.data.structure.node_master_elem[i_node, 1] node_id[i_node] = i_node v1 = np.array([1., 0, 0]) v2 = np.array([0., 1, 0]) v3 = np.array([0., 0, 1]) cab = algebra.crv2rotation(tstep.psi[i_elem, i_local_node, :]) local_x[i_node, :] = np.dot(aero2inertial, np.dot(cab, v1)) local_y[i_node, :] = np.dot(aero2inertial, np.dot(cab, v2)) local_z[i_node, :] = np.dot(aero2inertial, np.dot(cab, v3)) if i_local_node == 2: coords_a_cell[i_elem, :] = tstep.pos[i_node, :] coords_a[i_node, :] = tstep.pos[i_node, :] # applied forces cab = algebra.crv2rotation(tstep.psi[i_elem, i_local_node, :]) app_forces[i_node, :] = np.dot( aero2inertial, np.dot( cab, tstep.steady_applied_forces[i_node, 0:3] + tstep.unsteady_applied_forces[i_node, 0:3])) app_moment[i_node, :] = np.dot( aero2inertial, np.dot( cab, tstep.steady_applied_forces[i_node, 3:6] + tstep.unsteady_applied_forces[i_node, 3:6])) forces_constraints_nodes[i_node, :] = np.dot( aero2inertial, np.dot(cab, tstep.forces_constraints_nodes[i_node, 0:3])) moments_constraints_nodes[i_node, :] = np.dot( aero2inertial, np.dot(cab, tstep.forces_constraints_nodes[i_node, 3:6])) if with_gravity: gravity_forces_g[i_node, 0:3] = np.dot(aero2inertial, gravity_forces[i_node, 0:3]) gravity_forces_g[i_node, 3:6] = np.dot(aero2inertial, gravity_forces[i_node, 3:6]) for i_elem in range(num_elem): conn[i_elem, :] = self.data.structure.elements[ i_elem].reordered_global_connectivities elem_id[i_elem] = i_elem ug = tvtk.UnstructuredGrid(points=coords) ug.set_cells(tvtk.Line().cell_type, conn) ug.cell_data.scalars = elem_id ug.cell_data.scalars.name = 'elem_id' counter = 1 if with_postproc_cell: for k in postproc_cell_vector: ug.cell_data.add_array(tstep.postproc_cell[k]) ug.cell_data.get_array(counter).name = k + '_cell' counter += 1 for k in postproc_cell_6vector: for i in range(0, 2): ug.cell_data.add_array(tstep.postproc_cell[k][:, 3 * i:3 * (i + 1)]) ug.cell_data.get_array( counter).name = k + '_' + str(i) + '_cell' counter += 1 ug.cell_data.add_array(coords_a_cell) ug.cell_data.get_array(counter).name = 'coords_a_elem' counter += 1 ug.point_data.scalars = node_id ug.point_data.scalars.name = 'node_id' point_vector_counter = 1 ug.point_data.add_array(local_x, 'vector') ug.point_data.get_array(point_vector_counter).name = 'local_x' point_vector_counter += 1 ug.point_data.add_array(local_y, 'vector') ug.point_data.get_array(point_vector_counter).name = 'local_y' point_vector_counter += 1 ug.point_data.add_array(local_z, 'vector') ug.point_data.get_array(point_vector_counter).name = 'local_z' point_vector_counter += 1 ug.point_data.add_array(coords_a, 'vector') ug.point_data.get_array(point_vector_counter).name = 'coords_a' if self.settings['include_applied_forces']: point_vector_counter += 1 ug.point_data.add_array(app_forces, 'vector') ug.point_data.get_array(point_vector_counter).name = 'app_forces' point_vector_counter += 1 ug.point_data.add_array(forces_constraints_nodes, 'vector') ug.point_data.get_array( point_vector_counter).name = 'forces_constraints_nodes' if with_gravity: point_vector_counter += 1 ug.point_data.add_array(gravity_forces_g[:, 0:3], 'vector') ug.point_data.get_array( point_vector_counter).name = 'gravity_forces' if self.settings['include_applied_moments']: point_vector_counter += 1 ug.point_data.add_array(app_moment, 'vector') ug.point_data.get_array(point_vector_counter).name = 'app_moments' point_vector_counter += 1 ug.point_data.add_array(moments_constraints_nodes, 'vector') ug.point_data.get_array( point_vector_counter).name = 'moments_constraints_nodes' if with_gravity: point_vector_counter += 1 ug.point_data.add_array(gravity_forces_g[:, 3:6], 'vector') ug.point_data.get_array( point_vector_counter).name = 'gravity_moments' if with_postproc_node: for k in postproc_node_vector: point_vector_counter += 1 ug.point_data.add_array(tstep.postproc_node[k]) ug.point_data.get_array( point_vector_counter).name = k + '_point' for k in postproc_node_6vector: for i in range(0, 2): point_vector_counter += 1 ug.point_data.add_array(tstep.postproc_node[k][:, 3 * i:3 * (i + 1)]) ug.point_data.get_array( point_vector_counter ).name = k + '_' + str(i) + '_point' write_data(ug, it_filename)