def write_vtk(self, filename):
import pyvtk
if self.mesh_type is "cube":
vtkelements = pyvtk.VtkData(
pyvtk.UnstructuredGrid(self.points, hexahedron=self.elements),
"Mesh")
vtkelements.tofile(filename)
def dump_vtk_grid(self, path: str):
self.set_sigma()
point_coords = np.zeros([self.n_nodes, 3])
point_coords += self.a.reshape([self.n_nodes, 3])
point_coords[:, 0] += self.x_0
point_coords[:, 1] += self.y_0
point_velocities = self.a_t.reshape([self.n_nodes, 3])
pd = pvtk.PointData(pvtk.Vectors(point_velocities, name='Velocity'))
pd.append(pvtk.Scalars(point_coords[:, 2], name='z'))
triangles = []
sigmas = []
for elem in self.elements:
triangles.append(list(elem.node_ind))
sigmas.append(elem.sigma)
cd = []
names = [
'sigma_xx', 'sigma_yy', 'sigma_zz', 'tau_xy', 'tau_yz', 'tau_xz'
]
sigmas = np.array(sigmas)
for i in range(6):
cd.append(pvtk.Scalars(sigmas[:, i], name=names[i]))
usg = pvtk.UnstructuredGrid(point_coords, triangle=triangles)
vtk = pvtk.VtkData(usg, pd)
for e in cd:
vtk.cell_data.append(e)
vtk.tofile(path, 'binary')
def export_paraview(self):
if self.export_paraview == 0:
self.vtk_points = [_v.coord for _v in self.vertices[1:]]
self.vtk_triangle = [[_e.vertices[0].tag-1, _e.vertices[1].tag-1, _e.vertices[2].tag-1] for _e in self.elements[1:] if _e.typ==2]
pressure = [np.abs(_v.sol[3]) for _v in self.vertices[1:]]
# Bidouille pour que la tour et les lettres clignotent dans IAGS 20201
pressure_max = max(pressure)
light_on = self.export_paraview%4
if light_on<2:
tower_on = 0
else:
tower_on = 1
for _ent in self.fem_entities:
if _ent.dim ==2:
if _ent.mat.MEDIUM_TYPE == "eqf":
if _ent.mat.name == "tower":
for _elem in _ent.elements:
for _v in _elem.vertices:
_v.sol[3] = (1+(-1)**tower_on)*(pressure_max/2.)
if _ent.mat.name == "letter":
for _elem in _ent.elements:
for _v in _elem.vertices:
_v.sol[3] = (1+(-1)**(tower_on+1))*(pressure_max/2.)
pressure = [np.abs(_v.sol[3]) for _v in self.vertices[1:]]
vtk = pyvtk.VtkData(pyvtk.UnstructuredGrid(self.vtk_points,triangle=self.vtk_triangle), pyvtk.PointData(pyvtk.Scalars(pressure,name='Pressure')))
vtk.tofile("vtk/"+self.name_project + "-{}".format(self.export_paraview))
self.export_paraview +=1
def save_vtk(self, modei, scale):
path = str(
QFileDialog.getExistingDirectory(self,
"Select Directory")) + '/'
print path
U = self.MODOS.coord.copy()
nnos = self.MODOS.nnos
ngl = self.MODOS.ngl
nodesr = self.MODOS.nodesr
nodesl = list(set(range(nnos)) - set(nodesr))
scale = float(scale)
modei = int(modei) - 1
g = self.MODOS.g
U_i = zeros((nnos, g), float)
U_i[nodesl] = self.MODOS.modo[:, modei].reshape(
self.MODOS.modo[:, modei].size / g, g)
Ux, Uy, Uz = U_i[:, 0].copy(), U_i[:, 1].copy(), U_i[:, 2].copy()
U_i = U_i * scale
U = U + U_i[:, :3]
connec_face = self.MODOS.connec_face
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(U, triangle=connec_face),
pyvtk.PointData(pyvtk.Scalars(Ux, name='Ux'),
pyvtk.Scalars(Uy, name='Uy'),
pyvtk.Scalars(Uz, name='Uz')))
vtk.tofile(path + 'MODAL_' + str(modei + 1))
def test_tet_mesh(visualize=False):
pytest.importorskip("meshpy")
from math import pi, cos, sin
from meshpy.tet import MeshInfo, build
from meshpy.geometry import \
GeometryBuilder, generate_surface_of_revolution, EXT_CLOSED_IN_RZ
pytest.importorskip("meshpy")
big_r = 3
little_r = 1.5
points = 50
dphi = 2 * pi / points
rz = np.array(
[[big_r + little_r * cos(i * dphi), little_r * sin(i * dphi)]
for i in range(points)])
geo = GeometryBuilder()
geo.add_geometry(*generate_surface_of_revolution(
rz, closure=EXT_CLOSED_IN_RZ, radial_subdiv=20))
mesh_info = MeshInfo()
geo.set(mesh_info)
mesh = build(mesh_info)
def tet_face_vertices(vertices):
return [
(vertices[0], vertices[1], vertices[2]),
(vertices[0], vertices[1], vertices[3]),
(vertices[0], vertices[2], vertices[3]),
(vertices[1], vertices[2], vertices[3]),
]
face_map = {}
for el_id, el in enumerate(mesh.elements):
for fid, face_vertices in enumerate(tet_face_vertices(el)):
face_map.setdefault(frozenset(face_vertices), []).append(
(el_id, fid))
adjacency = {}
for face_vertices, els_faces in face_map.items():
if len(els_faces) == 2:
(e1, f1), (e2, f2) = els_faces
adjacency.setdefault(e1, []).append(e2)
adjacency.setdefault(e2, []).append(e1)
cuts, part_vert = pymetis.part_graph(17, adjacency)
if visualize:
import pyvtk
vtkelements = pyvtk.VtkData(
pyvtk.UnstructuredGrid(mesh.points, tetra=mesh.elements), "Mesh",
pyvtk.CellData(pyvtk.Scalars(part_vert, name="partition")))
vtkelements.tofile('split.vtk')
def write_vtk(self, filename):
import pyvtk
vtkelements = pyvtk.VtkData(
pyvtk.UnstructuredGrid(
self.points,
tetra=self.elements),
"Mesh")
vtkelements.tofile(filename)
def inp2vtk(self, inp_file=''):
"""
:rtype : object
"""
if self._inp_file:
inp_file = self._inp_file
else:
self._inp_file = inp_file
if inp_file == '':
sys.exit('ERROR: Please provide inp filename!')
if self._vtk_file:
vtk_file = self._vtk_file
else:
vtk_file = inp_file[:-4]
self._vtk_file = vtk_file + '.vtk'
print("--> Reading inp data")
with open(inp_file, 'r') as f:
line = f.readline()
num_nodes = int(line.strip(' ').split()[0])
num_elems = int(line.strip(' ').split()[1])
coord = np.zeros((num_nodes, 3), 'float')
elem_list_tri = []
elem_list_tetra = []
for i in range(num_nodes):
line = f.readline()
coord[i, 0] = float(line.strip(' ').split()[1])
coord[i, 1] = float(line.strip(' ').split()[2])
coord[i, 2] = float(line.strip(' ').split()[3])
for i in range(num_elems):
line = f.readline().strip(' ').split()
line.pop(0)
line.pop(0)
elem_type = line.pop(0)
if elem_type == 'tri':
elem_list_tri.append([int(i) - 1 for i in line])
if elem_type == 'tet':
elem_list_tetra.append([int(i) - 1 for i in line])
print('--> Writing inp data to vtk format')
vtk = pv.VtkData(
pv.UnstructuredGrid(coord,
tetra=elem_list_tetra,
triangle=elem_list_tri),
'Unstructured pflotran grid')
vtk.tofile(vtk_file)
def inp2vtk_python(self, inp_file=''):
import pyvtk as pv
""" Using Python VTK library, convert inp file to VTK file. then change name of CELL_DATA to POINT_DATA.
"""
print("--> Using Python to convert inp files to VTK files")
if self._inp_file:
inp_file = self._inp_file
else:
self._inp_file = inp_file
if inp_file == '':
sys.exit('ERROR: Please provide inp filename!')
if self._vtk_file:
vtk_file = self._vtk_file
else:
vtk_file = inp_file[:-4]
self._vtk_file = vtk_file + '.vtk'
print("--> Reading inp data")
with open(inp_file, 'r') as f:
line = f.readline()
num_nodes = int(line.strip(' ').split()[0])
num_elems = int(line.strip(' ').split()[1])
coord = np.zeros((num_nodes, 3), 'float')
elem_list_tri = []
elem_list_tetra = []
for i in range(num_nodes):
line = f.readline()
coord[i, 0] = float(line.strip(' ').split()[1])
coord[i, 1] = float(line.strip(' ').split()[2])
coord[i, 2] = float(line.strip(' ').split()[3])
for i in range(num_elems):
line = f.readline().strip(' ').split()
line.pop(0)
line.pop(0)
elem_type = line.pop(0)
if elem_type == 'tri':
elem_list_tri.append([int(i) - 1 for i in line])
if elem_type == 'tet':
elem_list_tetra.append([int(i) - 1 for i in line])
print('--> Writing inp data to vtk format')
vtk = pv.VtkData(
pv.UnstructuredGrid(coord,
tetra=elem_list_tetra,
triangle=elem_list_tri),
'Unstructured pflotran grid')
vtk.tofile(vtk_file)
def getVTKRepresentation(self):
"""
Get VTK representatnion of the mesh.
return: VTK representation of the receiver. Requires pyvtk module.
:rtype: pyvtk.UnstructuredGrid
"""
import pyvtk
vertices = []
hexahedrons = []
tetrahedrons = []
quads = []
triangles = []
#loop over receiver vertices and create list of vertex coordinates
for v in range(len(self.vertexList)):
vertices.append(self.vertexList[v].coords)
#loop over receiver cells
for c in range(len(self.cellList)):
cell = self.cellList[c]
cgt = cell.getGeometryType()
if (cgt == CellGeometryType.CGT_TRIANGLE_1):
triangles.append(cell.vertices)
elif (cgt == CellGeometryType.CGT_QUAD):
quads.append(cell.vertices)
elif (cgt == CellGeometryType.CGT_TETRA):
tetrahedrons.append(cell.vertices)
elif (cgt == CellGeometryType.CGT_HEXAHEDRON):
hexahedrons.append(cell.vertices)
elif (cgt == CellGeometryType.CGT_TRIANGLE_2):
# no direct support in pyvtk. map it to linear tringles
triangles.append(
(cell.vertices[0], cell.vertices[3], cell.vertices[5]))
triangles.append(
(cell.vertices[1], cell.vertices[4], cell.vertices[3]))
triangles.append(
(cell.vertices[2], cell.vertices[5], cell.vertices[4]))
triangles.append(
(cell.vertices[3], cell.vertices[4], cell.vertices[5]))
else:
msg = "Unsupported cell geometry type encountered: " + str(cgt)
raise APIError.APIError(msg)
return pyvtk.UnstructuredGrid(vertices,
hexahedron=hexahedrons,
tetra=tetrahedrons,
quad=quads,
triangle=triangles)
def plot_vtk(A, V, partition) :
V = numpy.append( V, numpy.zeros((A.shape[0],1)), axis=1 )
triples = []
A = scipy.sparse.triu(A,k=1).tocsr()
for i in range(A.shape[0]-1):
row = A.indices[A.indptr[i]:A.indptr[i+1]].tolist()
for t1,t2 in itertools.combinations(row, 2) :
if A[t1,t2] :
triples.append((i,t1,t2))
vtkelements = pyvtk.VtkData(
pyvtk.UnstructuredGrid(V, triangle=triples),
"Mesh",
pyvtk.PointData(pyvtk.Scalars(partition, name="partition")))
vtkelements.tofile('{0}_{1}.vtk'.format(graph_name,num_parts))
def write2vtk(self, G):
# import sys
# sys.path = ['..'] + sys.path
import pyvtk
points = [list(node) for node, data in G.nodes(data=True)]
line = []
for edge in G.edges():
for i, node in enumerate(G.nodes()):
if node == edge[0]:
n1 = i
for i, node in enumerate(G.nodes()):
if node == edge[1]:
n2 = i
line.append([n1, n2])
vtk = pyvtk.VtkData(pyvtk.UnstructuredGrid(points, line=line))
vtk.tofile('example1', 'ascii')
def write2vtk(self, G, filename):
"""
Exports a graph to a vtk file to be visualized with paraview
"""
# import sys
# sys.path = ['..'] + sys.path
import pyvtk
points = [list(node) for node, data in G.nodes(data=True)]
line = []
for edge in G.edges():
for i, node in enumerate(G.nodes()):
if node == edge[0]:
n1 = i
for i, node in enumerate(G.nodes()):
if node == edge[1]:
n2 = i
line.append([n1, n2])
vtk = pyvtk.VtkData(pyvtk.UnstructuredGrid(points, line=line))
vtk.tofile(filename, 'ascii')
def write_vtk(filename, points, tetra, vals, name=None):
"""Writes a vtk from the given set of grid locations, values and connectivity
:param points: An ndarray containing all the grid locations in cartesion coordinates
in the form of: | x0 y0 z0 |
| : : : |
| xn yn zn |
:param vals: an array containing the values to be specified on the mesh
:param tetra: connectivity of the mesh
"""
import pyvtk
from pyvtk import PointData, Scalars
vtkElements = pyvtk.VtkData(
pyvtk.UnstructuredGrid(
points,
tetra=tetra),
PointData(Scalars(vals, name)),
"Mesh")
vtkElements.tofile(filename)
def make_grid(coords, connect, **kw):
grid = None
gridtype = kw.get('gridtype', 'unstructured')
if gridtype == 'unstructured':
(nex, ney) = connect
(nx, ny) = (nex + 1, ney + 1)
conn = numpy.zeros((nex * ney, 4), dtype=int)
def node(i, j):
return ny * i + j
for i in xrange(nex):
for j in xrange(ney):
e = (ney) * i + j
n1 = node(i, j)
n2 = node(i + 1, j)
n3 = node(i + 1, j + 1)
n4 = node(i, j + 1)
conn[e] = (n1, n2, n3, n4)
grid = pyvtk.UnstructuredGrid(coords, quad=conn)
else:
raise Exception('Unknown grid type')
return grid
pointPressure = np.random.rand(npoints)
# Compute the 2D Delaunay triangulation in the x-y plane
xTmp = list(zip(x, y))
tri = Delaunay(xTmp)
# Generate Cell Data
nCells = tri.nsimplex
cellTemp = np.random.rand(nCells)
# Zip the point co-ordinates for the VtkData input
points = list(zip(x, y, z))
vtk = pyvtk.VtkData(\
pyvtk.UnstructuredGrid(points,
triangle=tri.simplices
),
pyvtk.PointData(pyvtk.Scalars(pointPressure,name='Pressure')),
pyvtk.CellData(pyvtk.Scalars(cellTemp,name='Temperature')),
'2D Delaunay Example'
)
vtk.tofile('Delaunay2D')
vtk.tofile('Delaunay2Db', 'binary')
# Compute the 3D Delaunay triangulation in the x-y plane
xTmp = list(zip(x, y, z))
tri = Delaunay(xTmp)
# Generate Cell Data
nCells = tri.nsimplex
cellTemp = np.random.rand(nCells)
def _getStructure(self):
##maxX = self.distanceVar.mesh.faceCenters[0].max()
##minX = self.distanceVar.mesh.faceCenters[0].min()
IDs = numerix.nonzero(self.distanceVar._cellInterfaceFlag)[0]
coordinates = numerix.take(
numerix.array(self.distanceVar.mesh.cellCenters).swapaxes(0, 1),
IDs)
coordinates -= numerix.take(
numerix.array(self.distanceVar.grad * self.distanceVar).swapaxes(
0, 1), IDs)
coordinates *= self.zoomFactor
shiftedCoords = coordinates.copy()
shiftedCoords[:, 0] = -coordinates[:, 0] ##+ (maxX - minX)
coordinates = numerix.concatenate((coordinates, shiftedCoords))
from lines import _getOrderedLines
lines = _getOrderedLines(
range(2 * len(IDs)),
coordinates,
thresholdDistance=self.distanceVar.mesh._cellDistances.min() * 10)
data = numerix.take(self.surfactantVar, IDs)
data = numerix.concatenate((data, data))
tmpIDs = numerix.nonzero(data > 0.0001)[0]
if len(tmpIDs) > 0:
val = numerix.take(data, tmpIDs).min()
else:
val = 0.0001
data = numerix.where(data < 0.0001, val, data)
for line in lines:
if len(line) > 2:
for smooth in range(self.smooth):
for arr in (coordinates, data):
tmp = numerix.take(arr, line)
tmp[1:-1] = tmp[2:] * 0.25 + tmp[:-2] * 0.25 + tmp[
1:-1] * 0.5
if len(arr.shape) > 1:
for i in range(len(arr[0])):
arrI = arr[:, i].copy()
numerix.put(arrI, line, tmp[:, i])
arr[:, i] = arrI
else:
numerix.put(arrI, line, tmp)
name = self.title
name = name.strip()
if name == '':
name = None
coords = numerix.zeros((coordinates.shape[0], 3), 'd')
coords[:, :coordinates.shape[1]] = coordinates
import pyvtk
## making lists as pyvtk doesn't know what to do with numpy arrays
coords = list(coords)
coords = map(
lambda coord: [float(coord[0]),
float(coord[1]),
float(coord[2])], coords)
data = list(data)
data = map(lambda item: float(item), data)
return (pyvtk.UnstructuredGrid(points=coords, poly_line=lines),
pyvtk.PointData(pyvtk.Scalars(data, name=name)))
def run(self):
vtk = pyvtk.VtkData(\
pyvtk.UnstructuredGrid(self.p.points,
hexahedron=self.p.cells),
'm2v output')
vtk.tofile('m2v_file')
DegNd = DegNd.reshape((DegNd.size, ))
DegRep = np.array(find_repeats(DegNd)[0], int)
for i in DegRep:
DegNd = DegNd[DegNd <> i]
DegNd = np.r_[DegNd, DegRep]
NCS[DegNd, ] = NCSprev[DegNd, ] + DS[DegNd, ]
#DegNd = np.array(find_repeats(np.r_[DegNd,outer])[0],int)
DegNd.sort()
PointConst = np.zeros((NCS.shape[0], ))
PointConst[outer, ] = 1
PointConst[DegNd, ] = 0
PointConst = np.array(PointConst, int)
print 'Construct VTK object for optimization'
##ADD CONTRAINTS AS POINT SCALARS
skvtk = pv.VtkData(pv.UnstructuredGrid(points=NCS, tetra=TetT),
'skull 4 symm',
pv.PointData(pv.Scalars(PointConst, 'fixed')))
skvtk.tofile(fname[0:6] + '015constr.vtk')
os.system('~/Software/Trilinos/Mesquite/msqshape -s ./' + fname[0:6] +
'015constr.vtk ./' + fname[0:6] + '015constrOUT.vtk')
fil = open(fname[0:6] + '015constrOUT.vtk', 'r+')
fil.writelines('# vtk DataFile Version 2.0\n')
fil.close()
skvtk = pv.VtkData(fname[0:6] + '015constrOUT.vtk')
NCS = np.array(skvtk.structure.points)
NCSprev = np.r_[NCS]
EQ, delt, Sn2, Sig = qu.elemQual_mu(np.array(range(TetT.shape[0])), NCS,
TetT)
print ' Average Element Quality: ', np.average(EQ)
import os
f, jac = lorenz_attractor(10., 28., 8. / 3)
T = 40.
tau = 1e-2
ipf = 4
n_steps = int(T / tau)
n_particles = 10000
deviation = 0.01
start_point = np.array([0., 0., 0.])
starts = np.random.normal(start_point, deviation, (n_particles, 3))
r_0 = np.linalg.norm(starts - start_point, axis=1, ord=2)
cloud = [RK45Solver(f, x_0, 0., T, n_steps) for x_0 in starts]
for particle in cloud:
particle.solve()
dirpath = 'vtk/000_10k/'
if not os.path.exists(dirpath):
os.mkdir(dirpath)
for i in range(0, n_steps + 1, ipf):
points = [p.x[:, i] for p in cloud]
velocities = [f(i, x) for x in points]
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(points),
pyvtk.PointData(pyvtk.Vectors(velocities, name='Velocity'),
pyvtk.Scalars(r_0, name='r_0')))
vtk.tofile(dirpath + f'f{i}')
def _vtk_createVtkData(meshpoints,
meshsimplices,
data,
name,
header="Data header (unused)"):
#If data is list of float, convert into list of lists, each list containing one float
if type(data[0]) in [types.FloatType, types.IntType]:
#raw data in scalar data set, convert float a into [a]:
data = map(lambda a: [a], data)
#Due to inflexibility in pyvtk, we need to distinguish 4 different cases for
#2d-meshes with scalar data
#2d-meshes with vector data
#3d-meshes with scalar data
#3d-meshes with vector data
#Here we go:
if len(meshpoints[0]) == 2:
log.debug("Mesh seems 2d")
#make 3d for pyvtk
meshpoints = map(lambda pos: pos + [0.], meshpoints)
if len(data[0]) == 1:
log.debug("Data seems 1d (scalar)")
log.debug("Creating vtk data structure with dof '%s'" % name)
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(meshpoints, triangle=meshsimplices),
pyvtk.PointData(
pyvtk.Scalars(data, name=name, lookup_table='default')),
header)
elif len(data[0]) in [2, 3]:
if len(data[0]) == 2:
log.debug("Data seems 2d (vector)")
#make 3d for pyvtk
data = map(lambda a: a + [0.], data)
else:
log.debug("Data seems 3d (vector)")
log.debug("Creating vtk data structure with dof '%s'" % name)
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(meshpoints, triangle=meshsimplices),
pyvtk.PointData(pyvtk.Vectors(data, name=name)), header)
else:
raise NfemValueError, "Can only deal with scalar or vector data"
elif len(meshpoints[0]) == 3:
log.debug("Mesh seems 3d")
if len(data[0]) == 1:
log.debug("Data seems 1d (scalar)")
log.debug("Creating vtk data structure with dof '%s'" % name)
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(meshpoints, tetra=meshsimplices),
pyvtk.PointData(
pyvtk.Scalars(data, name=name, lookup_table='default')),
header)
elif len(data[0]) in [2, 3]:
if len(data[0]) == 2:
log.debug("Data seems 2d (vector)")
#make 3d for pyvtk
data = map(lambda a: a + [0.], data)
else:
log.debug("Data seems 3d (vector)")
log.debug("Creating vtk data structure with dof '%s'" % name)
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(meshpoints, tetra=meshsimplices),
pyvtk.PointData(pyvtk.Vectors(data, name=name)), header)
else:
raise NfemValueError, "Can only deal with scalar or vector data"
elif len(meshpoints[0]) == 1:
log.debug("Mesh seems 1d")
#make 3d for pyvtk
meshpoints = map(lambda pos: pos + [0., 0.], meshpoints)
if len(data[0]) == 1:
log.debug("Data seems 1d (scalar)")
log.debug("Creating vtk data structure with dof '%s'" % name)
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(meshpoints, line=meshsimplices),
pyvtk.PointData(
pyvtk.Scalars(data, name=name, lookup_table='default')),
header)
elif len(data[0]) in [2, 3]:
if len(data[0]) == 2:
log.debug("Data seems 2d (vector)")
#make 3d for pyvtk
data = map(lambda a: a + [0.], data)
else:
log.debug("Data seems 3d (vector)")
log.debug("Creating vtk data structure with dof '%s'" % name)
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(meshpoints, line=meshsimplices),
pyvtk.PointData(pyvtk.Vectors(data, name=name)), header)
else:
raise NfemValueError, "Can only deal with scalar or vector data"
else:
NfemValueError, "Mesh seems to be %d dimensional. Can only do 1, 2 or 3." % len(
meshpoints[0])
return vtk
def inp2vtk_python(self):
""" Using Python VTK library, convert inp file to VTK file.
Parameters
----------
self : object
DFN Class
Returns
--------
None
Notes
--------
For a mesh base.inp, this dumps a VTK file named base.vtk
"""
import pyvtk as pv
if self.flow_solver != "PFLOTRAN":
error = "ERROR! Wrong flow solver requested"
sys.stderr.write(error)
sys.exit(1)
print("--> Using Python to convert inp files to VTK files")
if self.inp_file:
inp_file = self.inp_file
if inp_file == '':
error = 'ERROR: Please provide inp filename!'
sys.stderr.write(error)
sys.exit(1)
if self.vtk_file:
vtk_file = self.vtk_file
else:
vtk_file = inp_file[:-4]
self.vtk_file = vtk_file + '.vtk'
print("--> Reading inp data")
with open(inp_file, 'r') as f:
line = f.readline()
num_nodes = int(line.strip(' ').split()[0])
num_elems = int(line.strip(' ').split()[1])
coord = np.zeros((num_nodes, 3), 'float')
elem_list_tri = []
elem_list_tetra = []
for i in range(num_nodes):
line = f.readline()
coord[i, 0] = float(line.strip(' ').split()[1])
coord[i, 1] = float(line.strip(' ').split()[2])
coord[i, 2] = float(line.strip(' ').split()[3])
for i in range(num_elems):
line = f.readline().strip(' ').split()
line.pop(0)
line.pop(0)
elem_type = line.pop(0)
if elem_type == 'tri':
elem_list_tri.append([int(i) - 1 for i in line])
if elem_type == 'tet':
elem_list_tetra.append([int(i) - 1 for i in line])
print('--> Writing inp data to vtk format')
vtk = pv.VtkData(
pv.UnstructuredGrid(coord,
tetra=elem_list_tetra,
triangle=elem_list_tri),
'Unstructured pflotran grid')
vtk.tofile(vtk_file)
ntpts += npts
fi.close()
data = np.array(datal, dtype=float).T
elems = np.array(elems, dtype=int).T
pl = []
for i in np.arange(data.shape[1]):
pl.append(tuple(data[:3, i]))
el = []
for i in np.arange(elems.shape[1]):
el.append(tuple(elems[:, i]))
grid = pyvtk.UnstructuredGrid(pl, tetra=el)
pointdata = pyvtk.PointData()
for j, var in enumerate(vars[3:]):
pointdata.append(
pyvtk.Scalars(data[j + 3, :].tolist(),
name=var,
lookup_table='default'))
vtk = pyvtk.VtkData(grid, pointdata, title)
if binary:
vtk.tofile(t_step + '.vtk', 'binary')
else:
vtk.tofile(t_step + '.vtk', 'ascii')
print t_step + '.vtk written'
#============================================================
#- Triangulation.
#============================================================
for i in range(0, m.shape[0]):
S = m[i, :]
outfile = outfilename + '.' + str(i) + '.vtk'
print('Compute Delauney triangulation ...')
x = 6371.0 * np.cos(lat * np.pi / 180.0) * np.cos(lon * np.pi / 180.0)
y = 6371.0 * np.cos(lat * np.pi / 180.0) * np.sin(lon * np.pi / 180.0)
z = 6371.0 * np.sin(lat * np.pi / 180.0)
pts = np.array((x, y, z)).T
mesh_info = MeshInfo()
mesh_info.set_points(pts)
opts = Options("Q")
mesh = build(mesh_info, options=opts)
elements = mesh.elements
#============================================================
#- Write vtk file.
#============================================================
print('Write vtk file ...')
vtkElements = pyvtk.VtkData(pyvtk.UnstructuredGrid(pts, tetra=elements),
PointData(Scalars(S, 'grad_PSD_ZZ')), "Mesh")
vtkElements.tofile(outfile)
num_steps = int((END_TSTEP - START_TSTEP) / INT_TSTEP)
#---------- </LOAD VARIABLES> ----------
#---------- <CREATE VTK FILE> ----------
wc = WavefieldComputer(wavefield, nu, s, z, sem_mesh)
for i_slice in range(SLICES):
x_slice, y_slice, z_slice, wvf_slice = wc.compute_slice(
RMIN[i_slice], RMAX[i_slice], PHIS_SLICES[i_slice])
points_slice = list(zip(x_slice, y_slice, z_slice))
range_slice = range(len(x_slice))
for it in range(num_steps):
vtk = pyvtk.VtkData(
pyvtk.UnstructuredGrid(points_slice, range_slice),
pyvtk.PointData(
pyvtk.Scalars(wvf_slice[it], name='wavefield_slice')),
'animation')
vtk.tofile(OUTPUT_DIR + 'slices/' + 'slice_' +
str(int(RMIN[i_slice] * 1.e-3)) + '_' +
str(int(RMAX[i_slice] * 1.e-3)) + '_' +
str(PHIS_SLICES[i_slice]) + '_' + str(it) + '.vtk')
### write info file for each slice
f = open(
OUTPUT_DIR + 'slices/'
'slice_' + str(int(RMIN[i_slice] * 1.e-3)) + '_' +
str(int(RMAX[i_slice] * 1.e-3)) + '_' + str(PHIS_SLICES[i_slice]) +
'_INFO.txt', 'w')
f.write('########## SLICE INFO ##########\n')
# -2, -2, -2, -2, +2, -2, +2, +2, -2, +2, -2, -2, -2, -2, +2, +2, -2,
# +2, +2, +2, +2, -2, +2, +2;
#
# specfem = Specfem(interp_method='trilinear_interpolation')
# first_element = specfem.connectivity[0,:]
# element_vtcs = specfem.nodes[first_element]
#
# permutation = [0,3,2,1,4,5,6,7] # looks like this is the correct one
# i = np.argsort(permutation)
# element_perturbed = first_element[i]
# element_vtcs = specfem.nodes[element_perturbed]
#
# #pnt = np.mean(element_vtcs, axis=0)
# pnt = (element_vtcs[4,:] + element_vtcs[6,:]) / 2
# solution = tlp.check_hull(pnt, element_vtcs)
# print(solution)
# print(tlp.interpolate_at_point(solution[1]))
#
import pyvtk
from pyvtk import PointData, Scalars
vtkElements = pyvtk.VtkData(pyvtk.UnstructuredGrid(
specfem.nodes, hexahedron=specfem.connectivity),
PointData(Scalars(grid_data.get_component('vsv'), 'node_number')),
"Mesh")
vtkElements.tofile('specfem_mesh.vtk')
zmin = np.cos(np.radians(args.max_dist))
zmax = np.cos(np.radians(args.min_dist))
xyz, connect = SpherifiedCube(divisions, zmin, zmax)
nstation = len(xyz)
ncell = len(connect)
if args.verbose:
elapsed = time.clock() - clock0
print(' Number of sampling points: %d' % (nstation))
print(' Number of quad cells: %d' % (ncell))
print('Sampling surface done, ' + '%f sec elapsed.\n' % (elapsed))
###### generate mesh vtk
if args.verbose:
clock0 = time.clock()
print('Generating vtk mesh...')
vtk_points = pyvtk.UnstructuredGrid(list(zip(xyz[:, 0], xyz[:, 1], xyz[:, 2])),
quad=connect)
if args.verbose:
elapsed = time.clock() - clock0
print('Generating vtk mesh done, ' + '%f sec elapsed.\n' % (elapsed))
###### dist, azim
if args.verbose:
clock0 = time.clock()
print('Computing (distances, azimuths) of points...')
# dists
dists = np.arccos(xyz[:, 2] / r_plot)
azims = np.arctan2(xyz[:, 1], xyz[:, 0])
if args.verbose:
elapsed = time.clock() - clock0
print('Computing (distances, azimuths) of points done, ' +
'%f sec elapsed.\n' % (elapsed))
def citcom2vtk(t):
print "Timestep:", t
benchmarkstr = ""
#Assign create_bottom and create_surface to bottom and surface
#to make them valid in methods namespace
bottom = create_bottom
surface = create_surface
ordered_points = [] #reset Sequences for points
ordered_temperature = []
ordered_velocity = []
ordered_visc = []
#Surface and Bottom Points
#Initialize empty sequences
surf_vec = []
botm_vec = []
surf_topo = []
surf_hflux = []
botm_topo = []
botm_hflux = []
surf_points = []
botm_points = []
for capnr in xrange(nproc_surf):
###Benchmark Point 1 Start##
#start = datetime.now()
############################
print "Processing cap", capnr + 1, "of", nproc_surf
cap = f.root._f_getChild("cap%02d" % capnr)
#Information from hdf
#This information needs to be read only once
hdf_coords = cap.coord[:]
hdf_velocity = cap.velocity[t]
hdf_temperature = cap.temperature[t]
hdf_viscosity = cap.viscosity[t]
###Benchmark Point 1 Stop##
#delta = datetime.now() - start
#benchmarkstr += "%.5lf," % (delta.seconds + float(delta.microseconds)/1e6)
###Benchmark Point 2 Start##
#start = datetime.now()
############################
#Create Iterator to change data representation
nx_redu_iter = reduce_iter(nx, nx_redu)
ny_redu_iter = reduce_iter(ny, ny_redu)
nz_redu_iter = reduce_iter(nz, nz_redu)
#vtk_i = vtk_iter(el_nx_redu,el_ny_redu,el_nz_redu)
# read citcom data - zxy (z fastest)
for j in xrange(el_ny_redu):
j_redu = ny_redu_iter.next()
nx_redu_iter = reduce_iter(nx, nx_redu)
for i in xrange(el_nx_redu):
i_redu = nx_redu_iter.next()
nz_redu_iter = reduce_iter(nz, nz_redu)
for k in xrange(el_nz_redu):
k_redu = nz_redu_iter.next()
colat, lon, r = map(float, hdf_coords[i_redu, j_redu,
k_redu])
x_coord, y_coord, z_coord = RTF2XYZ(colat, lon, r)
ordered_points.append((x_coord, y_coord, z_coord))
ordered_temperature.append(
float(hdf_temperature[i_redu, j_redu, k_redu]))
ordered_visc.append(
float(hdf_viscosity[i_redu, j_redu, k_redu]))
vel_colat, vel_lon, vel_r = map(
float, hdf_velocity[i_redu, j_redu, k_redu])
x_velo, y_velo, z_velo = velocity2cart(
vel_colat, vel_lon, vel_r, colat, lon, r)
ordered_velocity.append((x_velo, y_velo, z_velo))
##Delete Objects for GC
del hdf_coords
del hdf_velocity
del hdf_temperature
del hdf_viscosity
###Benchmark Point 2 Stop##
#delta = datetime.now() - start
#benchmarkstr += "%.5lf," % (delta.seconds + float(delta.microseconds)/1e6)
###Benchmark Point 3 Start##
#start = datetime.now()
############################
#Bottom Information from hdf
if bottom == True:
try:
hdf_bottom_coord = cap.botm.coord[:]
hdf_bottom_heatflux = cap.botm.heatflux[t]
hdf_bottom_topography = cap.botm.topography[t]
hdf_bottom_velocity = cap.botm.velocity[t]
except:
print "\tCould not find bottom information in file.\n \
Set create bottom to false"
bottom = False
#Surface Information from hdf
if surface == True:
try:
hdf_surface_coord = cap.surf.coord[:]
hdf_surface_heatflux = cap.surf.heatflux[t]
hdf_surface_topography = cap.surf.topography[t]
hdf_surface_velocity = cap.surf.velocity[t]
except:
print "\tCould not find surface information in file.\n \
Set create surface to false"
surface = False
###Benchmark Point 3 Stop##
#delta = datetime.now() - start
#benchmarkstr += "%.5lf," % (delta.seconds + float(delta.microseconds)/1e6)
###Benchmark Point 4 Start##
#start = datetime.now()
############################
#Compute surface/bottom topography mean
if create_topo:
surf_mean = 0.0
botm_mean = 0.0
if surface:
for i in xrange(nx):
surf_mean += numpy.mean(hdf_surface_topography[i])
surf_mean = surf_mean / ny
if bottom:
for i in xrange(nx):
botm_mean += numpy.mean(hdf_bottom_topography[i])
botm_mean = botm_mean / nx
###Benchmark Point 4 Stop##
#delta = datetime.now() - start
#benchmarkstr += "%.5lf," % (delta.seconds + float(delta.microseconds)/1e6)
###Benchmark Point 5 Start##
#start = datetime.now()
############################
#Read Surface and Bottom Data
if bottom == True or surface == True:
for i in xrange(nx):
for j in xrange(ny):
if bottom == True:
#Bottom Coordinates
if create_topo == True:
colat, lon = hdf_bottom_coord[i, j]
x, y, z = RTF2XYZ(
colat, lon, radius_inner + float(
(hdf_bottom_topography[i, j] - botm_mean) *
(10**21) / (6371000**2 / 10**(-6)) /
(3300 * 10) / 1000))
botm_points.append((x, y, z))
else:
colat, lon = hdf_bottom_coord[i, j]
x, y, z = RTF2XYZ(colat, lon, radius_inner)
botm_points.append((x, y, z))
#Bottom Heatflux
botm_hflux.append(float(hdf_bottom_heatflux[i, j]))
#Bottom Velocity
vel_colat, vel_lon = map(float, hdf_bottom_velocity[i,
j])
x, y, z = velocity2cart(vel_colat, vel_lon,
radius_inner, colat, lon,
radius_inner)
botm_vec.append((x, y, z))
if surface == True:
#Surface Information
if create_topo == True:
colat, lon = hdf_surface_coord[i, j]
#637100 = Earth radius, 33000 = ?
x, y, z = RTF2XYZ(
colat, lon, radius_outer + float(
(hdf_surface_topography[i, j] - surf_mean)
* (10**21) / (6371000**2 / 10**(-6)) /
(3300 * 10) / 1000))
surf_points.append((x, y, z))
else:
colat, lon = hdf_surface_coord[i, j]
x, y, z = RTF2XYZ(colat, lon, radius_outer)
surf_points.append((x, y, z))
#Surface Heatflux
surf_hflux.append(float(hdf_surface_heatflux[i, j]))
#Surface Velocity
vel_colat, vel_lon = map(float,
hdf_surface_velocity[i, j])
x, y, z = velocity2cart(vel_colat, vel_lon,
radius_outer, colat, lon,
radius_outer)
surf_vec.append((x, y, z))
#del variables for GC
if bottom == True:
del hdf_bottom_coord
del hdf_bottom_heatflux
del hdf_bottom_velocity
if surface == True:
del hdf_surface_coord
del hdf_surface_heatflux
del hdf_surface_velocity
###Benchmark Point 5 Stop##
#delta = datetime.now() - start
#benchmarkstr += "%.5lf," % (delta.seconds + float(delta.microseconds)/1e6)
###Benchmark Point 6 Start##
#start = datetime.now()
############################
##################################################################
#Create Connectivity info
if counter == 0:
#For 3d Data
i = 1 #Counts X Direction
j = 1 #Counts Y Direction
k = 1 #Counts Z Direction
for n in xrange((el_nx_redu * el_ny_redu * el_nz_redu) -
(el_nz_redu * el_nx_redu)):
if (i % el_nz_redu) == 0: #X-Values!!!
j += 1 #Count Y-Values
if (j % el_nx_redu) == 0:
k += 1 #Count Z-Values
if i % el_nz_redu != 0 and j % el_nx_redu != 0: #Check if Box can be created
#Get Vertnumbers
n0 = n + (capnr * (el_nx_redu * el_ny_redu * el_nz_redu))
n1 = n0 + el_nz_redu
n2 = n1 + el_nz_redu * el_nx_redu
n3 = n0 + el_nz_redu * el_nx_redu
n4 = n0 + 1
n5 = n4 + el_nz_redu
n6 = n5 + el_nz_redu * el_nx_redu
n7 = n4 + el_nz_redu * el_nx_redu
#Created Polygon Box
polygons3d.append([n0, n1, n2, n3, n4, n5, n6,
n7]) #Hexahedron VTK Representation
i += 1
if bottom == True or surface == True:
#Connectivity for 2d-Data
i = 1
for n in xrange((nx) * (ny) - ny):
if i % ny != 0:
n0 = n + (capnr * ((nx) * (ny)))
n1 = n0 + 1
n2 = n0 + ny
n3 = n2 + 1
polygons2d.append([n0, n1, n2, n3])
i += 1
###Benchmark Point 6 Stop##
#delta = datetime.now() - start
#benchmarkstr += "%.5lf\n" % (delta.seconds + float(delta.microseconds)/1e6)
#print benchmarkstr
#################################################################
#Write Data to VTK
#benchmarkstr = "\n\nIO:\n"
###Benchmark Point 7 Start##
#start = datetime.now()
############################
print 'Writing data to vtk...'
#Surface Points
if surface == True:
struct_coords = pyvtk.UnstructuredGrid(surf_points, pixel=polygons2d)
#topo_scal = pyvtk.Scalars(surf_topo,'Surface Topography', lookup_table='default')
hflux_scal = pyvtk.Scalars(surf_hflux,
'Surface Heatflux',
lookup_table='default')
vel_vec = pyvtk.Vectors(surf_vec, 'Surface Velocity Vectors')
##
tempdata = pyvtk.PointData(hflux_scal, vel_vec)
data = pyvtk.VtkData(
struct_coords, tempdata,
'CitcomS Output %s Timestep %s' % ('surface info', t))
if create_ascii:
data.tofile(vtk_path + (vtkfile % ('surface', t)), )
else:
data.tofile(vtk_path + (vtkfile % ('surface', t)), 'binary')
print "Written Surface information to file"
###Benchmark Point 7 Stop##
#delta = datetime.now() - start
#benchmarkstr += "%.5lf," % (delta.seconds + float(delta.microseconds)/1e6)
###Benchmark Point 8 Start##
#start = datetime.now()
############################
if bottom == True:
#Bottom Points
struct_coords = pyvtk.UnstructuredGrid(botm_points, pixel=polygons2d)
#topo_scal = pyvtk.Scalars(botm_topo,'Bottom Topography','default')
hflux_scal = pyvtk.Scalars(botm_hflux, 'Bottom Heatflux', 'default')
vel_vec = pyvtk.Vectors(botm_vec, 'Bottom Velocity Vectors')
##
tempdata = pyvtk.PointData(hflux_scal, vel_vec)
data = pyvtk.VtkData(
struct_coords, tempdata,
'CitcomS Output %s Timestep %s' % ('Bottom info', t))
if create_ascii:
data.tofile(vtk_path + (vtkfile % ('bottom', t)))
else:
data.tofile(vtk_path + (vtkfile % ('bottom', t)), 'binary')
print "Written Bottom information to file"
###Benchmark Point 8 Stop##
#delta = datetime.now() - start
#benchmarkstr += "%.5lf," % (delta.seconds + float(delta.microseconds)/1e6)
###Benchmark Point 9 Start##
#start = datetime.now()
#General Data
struct_coords = pyvtk.UnstructuredGrid(ordered_points,
hexahedron=polygons3d)
vel_vec = pyvtk.Vectors(ordered_velocity, 'Velocity Vectors')
temp_scal = pyvtk.Scalars(ordered_temperature, 'Temperature Scalars',
'default')
visc_scal = pyvtk.Scalars(ordered_visc, 'Viscosity Scalars', 'default')
##
tempdata = pyvtk.PointData(temp_scal, visc_scal, vel_vec)
data = pyvtk.VtkData(
struct_coords, tempdata,
'CitcomS Output %s Timestep:%d NX:%d NY:%d NZ:%d Radius_Inner:%f' %
(path, t, el_nx_redu, el_ny_redu, el_nz_redu, radius_inner))
############################
if create_ascii:
data.tofile(vtk_path + (vtkfile % ('general', t)))
else:
data.tofile(vtk_path + (vtkfile % ('general', t)), 'binary')
print "Written general data to file"
