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)