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)
