def _get_writer(filetype, filename):
import vtk
if filetype in "vtk-ascii":
logging.warning("VTK ASCII files are only meant for debugging.")
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == "vtk-binary":
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
elif filetype == "vtu-ascii":
logging.warning("VTU ASCII files are only meant for debugging.")
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToAscii()
elif filetype == "vtu-binary":
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToBinary()
elif filetype == "xdmf2":
writer = vtk.vtkXdmfWriter()
elif filetype == "xdmf3":
writer = vtk.vtkXdmf3Writer()
else:
assert filetype == "exodus", "Unknown file type '{}'.".format(filename)
writer = vtk.vtkExodusIIWriter()
# if the mesh contains vtkmodeldata information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
return writer
def _get_writer(filetype, filename):
import vtk
if filetype in "vtk-ascii":
logging.warning("VTK ASCII files are only meant for debugging.")
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == "vtk-binary":
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
elif filetype == "vtu-ascii":
logging.warning("VTU ASCII files are only meant for debugging.")
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToAscii()
elif filetype == "vtu-binary":
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToBinary()
elif filetype == "xdmf2":
writer = vtk.vtkXdmfWriter()
elif filetype == "xdmf3":
writer = vtk.vtkXdmf3Writer()
else:
assert filetype == "exodus", "Unknown file type '{}'.".format(filename)
writer = vtk.vtkExodusIIWriter()
# if the mesh contains vtkmodeldata information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
return writer
def Slice_VTK_data_to_VTK(inputFileName,
outputFileName,
point, normal,
resolution
):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(inputFileName)
reader.Update()
plane = vtk.vtkPlane()
plane.SetOrigin(point)
plane.SetNormal(normal)
cutter = vtk.vtkFiltersCorePython.vtkCutter()
cutter.SetCutFunction(plane)
cutter.SetInputConnection(reader.GetOutputPort())
cutter.Update()
#Convert tht polydata structure générated by cutter into unstructured grid by triangulation
triFilter = vtk.vtkDataSetTriangleFilter()
triFilter.SetInputConnection(cutter.GetOutputPort())
triFilter.Update()
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputData(triFilter.GetOutput())
writer.SetFileName(outputFileName)
writer.Write()
def writeVTKsurface(self, filename):
"Create data in VTK format to compute isocontour"
# Conteneur du nouveau maillage
data = vtk.vtkUnstructuredGrid()
pts = vtk.vtkPoints()
for i in range(self.nbDof):
pts.InsertPoint(i, self.meshNode[i, 0], self.meshNode[i, 1],
self.meshNode[i, 2])
data.SetPoints(pts)
for i in range(self.nbElem):
Tri3 = vtk.vtkTriangle()
for j, inode in enumerate(self.meshTable[i, :]):
Tri3.GetPointIds().SetId(j, inode)
data.InsertNextCell(Tri3.GetCellType(), Tri3.GetPointIds())
value0 = vtk.vtkDoubleArray()
value0.SetName("Value0")
value0.SetNumberOfComponents(1)
for i in range(self.nbDof):
value0.InsertTuple1(i, self.X[i])
data.GetPointData().AddArray(value0)
value1 = vtk.vtkDoubleArray()
value1.SetName("Value1")
value1.SetNumberOfComponents(1)
for i in range(self.nbDof):
value1.InsertTuple1(i, self.Y[i])
data.GetPointData().AddArray(value1)
# Ecriture du nouveau maillage
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInput(data)
writer.SetFileName(filename + '.vtu')
writer.Update()
def write_vtu_ascii(file_name, polyData):
out = vtk.vtkXMLUnstructuredGridWriter()
out.SetInputDataObject(polyData)
out.SetDataModeToAscii()
out.SetFileName(file_name)
out.Write()
return
def export_data(cls, filename, vtk_unstructured_grid, verbose):
r"""
Save grid data to a single vtu file for visualizing in ParaView.
Parameters
----------
filename : string
A string that holds the name (path) of the grid file.
vtk_unstructured_grid : vtkUnstructuredGrid Object
Object holding VTK Unstructured Grid.
verbose : boolean, default is True.
A boolean that will be used to emit (or not) messages to screen while processing.
Notes
-----
The vtu file will be created on the directory 'Results' that will be created
on the same directory than grid file
"""
# Create the 'Results' directory
results_dir = misc.create_results_directory(misc.get_path(filename))
if verbose:
print("\n[OUTPUT] Writting ParaView file \"" +
misc.get_basename(filename).split('.')[0] + ".vtu\"")
xml_writer = vtk.vtkXMLUnstructuredGridWriter()
xml_writer.SetFileName(results_dir +
misc.get_basename(filename).split('.')[0] +
".vtu")
xml_writer.SetInputData(vtk_unstructured_grid)
xml_writer.Write()
def setup(mb,time,dt):
N = 0
X = 0.5+0.5*(numpy.random.random((N, 3))-0.5)
X[:,0] += 0.2
X[:,2] = 0
V = numpy.zeros((N,3))
V[:,0] = 1.0
SYSTEM=pm.System.get_system_from_options(block=(mb,time,dt))
PAR=pm.ParticleBase.get_parameters_from_options()[0]
writer=vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName('boundary.vtu')
writer.SetInput(SYSTEM.boundary.bnd)
writer.Write()
PB = pm.Particles.ParticleBucket(X, V, time, delta_t=0.2*dt,
system=SYSTEM,
parameters=PAR)
return PB
def vtkFile(self, outFile, type_):
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(outFile)
grid = vtk.vtkUnstructuredGrid()
points = vtk.vtkPoints()
points.SetNumberOfPoints(len(self.cells[type_]))
points.SetDataTypeToDouble()
dataOut = grid.GetPointData()
array = vtk.vtkDoubleArray()
array.SetName("Volume")
array.SetNumberOfComponents(1)
array.SetNumberOfTuples(len(self.cells[type_]))
if type_ == "triangle":
for i in range(0, len(self.cells[type_])):
center = self.centerTriangle(self.cells[type_][i])
area = self.areaTriangle(self.cells[type_][i])
points.InsertPoint(i, center[0], center[1], 0)
array.SetTuple1(i, area)
elif type_ == "quad":
for i in range(0, len(self.cells[type_])):
center = self.centerSquare(self.cells[type_][i])
area = self.areaSquare(self.cells[type_][i])
points.InsertPoint(i, center[0], center[1], 0)
array.SetTuple1(i, area)
grid.SetPoints(points)
dataOut.AddArray(array)
writer.SetInputData(grid)
writer.GetCompressor().SetCompressionLevel(0)
writer.SetDataModeToAscii()
writer.Write()
def write(self, fname):
"""
Write to file.
Parameters
----------
fname : str
Filename for writing.
"""
if isinstance(self.geom, vtk.vtkRectilinearGrid):
writer = vtk.vtkXMLRectilinearGridWriter()
elif isinstance(self.geom, vtk.vtkUnstructuredGrid):
writer = vtk.vtkXMLUnstructuredGridWriter()
elif isinstance(self.geom, vtk.vtkPolyData):
writer = vtk.vtkXMLPolyDataWriter()
default_ext = writer.GetDefaultFileExtension()
name, ext = os.path.splitext(fname)
if ext and ext != '.' + default_ext:
raise ValueError('Given extension {} is not .{}'.format(
ext, default_ext))
writer.SetFileName('{}.{}'.format(name, default_ext))
writer.SetCompressorTypeToZLib()
writer.SetDataModeToBinary()
writer.SetInputData(self.geom)
writer.Write()
def _write_vtk(self, fields, name, g_VTK):
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputData(g_VTK)
writer.SetFileName(name)
if fields is not None:
for field in fields:
if field.values is None:
continue
dataVTK = ns.numpy_to_vtk(field.values,
deep=True,
array_type=field.dtype())
dataVTK.SetName(field.name)
dataVTK.SetNumberOfComponents(field.num_components)
if field.cell_data:
g_VTK.GetCellData().AddArray(dataVTK)
elif field.point_data:
g_VTK.GetPointData().AddArray(dataVTK)
if not self.binary:
writer.SetDataModeToAscii()
writer.Update()
if fields is not None:
for field in fields:
if field.cell_data:
g_VTK.GetCellData().RemoveArray(field.name)
elif field.point_data:
g_VTK.GetPointData().RemoveArray(field.name)
def write_polydata(file_name, data, datatype=None):
""" Write the given VTK object to a file.
Args:
file_name (str): The name of the file to write.
data (vtkDataObject): Data to write.
datatype (str): Additional parameter for vtkIdList objects.
"""
# Check filename format.
file_ext = file_name.split(".")[-1]
if file_ext == '':
raise RuntimeError('The file does not have an extension')
# Get writer.
if file_ext == 'vtp':
writer = vtk.vtkXMLPolyDataWriter()
elif file_ext == 'vtu':
writer = vtk.vtkXMLUnstructuredGridWriter()
else:
raise RuntimeError('Unknown file type %s' % file_ext)
# Set file name and the data to write.
writer.SetFileName(file_name)
writer.SetInputData(data)
writer.Update()
# Write the data.
writer.Write()
def make_vtu(path, add_elset_id_field=False, elset_prefix='_ELSET'):
'''Convert a mesh to vtk format.
This method reads the mesh and then write the corresponding .vtu file.
The file will have the same name as the input mesh, with the extension changed to vtu.
Only .geof and .mesh file are currently supported.
:param str path: path to the mesh file.
:param bool add_elset_id_field: flag to add a field representing the elset id.
:param str elset_prefix: prefix to use if computing the leset id field.
'''
if path.endswith('.geof'):
m = FE_Mesh.load_from_geof(path)
elif path.endswith('.mesh'):
m = FE_Mesh.load_from_mesh(path)
else:
print('unsupported mesh format (must be .geof or .mesh): %s' %
path)
return
vtk_mesh = m.build_vtk()
if add_elset_id_field:
from vtk.util import numpy_support
id_field = m.compute_elset_id_field(elset_prefix)
print('adding field %s' % 'elset_id')
vtk_data_array = numpy_support.numpy_to_vtk(id_field, deep=1)
vtk_data_array.SetName('elset_id')
vtk_mesh.GetCellData().AddArray(vtk_data_array)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(path[:-5] + '.vtu')
if vtk.vtkVersion().GetVTKMajorVersion() > 5:
writer.SetInputData(vtk_mesh)
else:
writer.SetInput(vtk_mesh)
writer.Write()
def write_vtu(self):
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputDataObject(self.ugrid)
# writer.SetDataModeToAscii() # text file
writer.SetDataModeToBinary() # compressed file
writer.SetFileName(self.file_name)
writer.Write()
def HDF5toVTKLumen():
cellType = "ec" # Both ATP and WSS maps use EC mesh
input_meshes = []
# Read input EC meshes.
for in_file in input_mesh_files[cellType]:
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(in_file)
reader.Update()
input_meshes += [reader.GetOutput()]
# Only add parent mesh for a tube (non-bifurcation)
if branches == 1:
break
append_filter = vtk.vtkAppendFilter()
for branch in range(branches):
species_array = []
mesh = vtk.vtkPolyData()
mesh.DeepCopy(input_meshes[branch])
# The base input h5 filename given the branch and from which writer it came on said branch.
h5_file_base = base_names[output] + '_b_' + str(branch + 1) + '_' + 'x' + '.h5'
print "Processing file", h5_file_base
for writer in range(writers):
h5_file_name = h5_file_base[:-4] + str(writer) + h5_file_base[-3:]
fid = h5py.h5f.open(h5_file_name)
dset = h5py.h5d.open(fid, "data")
shape = dset.shape
rdata = numpy.zeros(shape[0], dtype=numpy.float64)
dset.read(h5py.h5s.ALL, h5py.h5s.ALL, rdata)
species_array += list(rdata.ravel())[:]
reordered_array = vtk.vtkDoubleArray()
reordered_array.SetName(output)
reordered_array.SetNumberOfValues(numCells[cellType][0] * numCells[cellType][1] * circQuads * axialQuads)
reorder_species(species_array, reordered_array, cellType)
mesh.GetCellData().AddArray(reordered_array)
append_filter.AddInputData(mesh)
append_filter.Update()
# Write the result.
vtu_file = base_names[output] + '.vtu'
print 'Writing file', os.path.abspath(vtu_file)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(vtu_file)
writer.SetInputData(append_filter.GetOutput())
writer.Update()
def output_vtk_file(self, file_name='tests.vtk', in_xml_format=True):
"""
Write the mesh to a VTK file
:param file_name:
:param in_xml_format:
:return:
"""
gw = vtk.vtkXMLUnstructuredGridWriter(
) if in_xml_format else vtk.vtkUnstructuredGridWriter()
if in_xml_format:
# XML data written in binary format by default
gw.SetDataModeToAscii()
gw.SetFileName(file_name)
gw.SetInputData(self.vtk_mesh)
rtc = gw.Write()
if rtc == 1:
print('--> Wrote mesh to {}'.format(file_name))
else:
print('--> Failed to write mesh to file')
# Exodus format
# exow = vtk.vtkExodusIIWriter()
# exow.SetFileName( 'tests.exo' )
# exow.SetInputData( mesh )
#
# rtc = exow.Write()
return
def write_vtu(ugrid):
out_path = argv[3] if len(argv) > 3 else path.splitext(argv[2])[0] + ".vtu"
print('writing: ' + out_path)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(out_path)
writer.SetInputData(ugrid)
writer.Write()
def setup(mb, time, dt):
N = 0
X = 0.5 + 0.5 * (numpy.random.random((N, 3)) - 0.5)
X[:, 0] += 0.2
X[:, 2] = 0
V = numpy.zeros((N, 3))
V[:, 0] = 1.0
SYSTEM = pm.System.get_system_from_options(block=(mb, time, dt))
PAR = pm.ParticleBase.get_parameters_from_options()[0]
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName('boundary.vtu')
writer.SetInput(SYSTEM.boundary.bnd)
writer.Write()
PB = pm.Particles.ParticleBucket(X,
V,
time,
delta_t=0.2 * dt,
system=SYSTEM,
parameters=PAR)
return PB
def write_to_vtk(self, fname, mesh):
"""
Notes
-----
"""
node, cell, cellType, NC = mesh.to_vtk()
points = vtk.vtkPoints()
points.SetData(vnp.numpy_to_vtk(node))
cells = vtk.vtkCellArray()
cells.SetCells(NC, vnp.numpy_to_vtkIdTypeArray(cell))
vtkmesh = vtk.vtkUnstructuredGrid()
vtkmesh.SetPoints(points)
vtkmesh.SetCells(cellType, cells)
pdata = vtkmesh.GetPointData()
for key, val in mesh.nodedata.items():
d = vnp.numpy_to_vtk(val)
d.SetName(key)
pdata.AddArray(d)
cdata = vtkmesh.GetCellData()
for key, val in mesh.celldata.items():
d = vnp.numpy_to_vtk(val)
d.SetName(key)
cdata.AddArray(d)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(fname)
writer.SetInputData(vtkmesh)
writer.Write()
def write_volume_mesh(file_base_name, mesh, model_name):
'''Write a volume mesh to a VTK vtu file and mesh information to the .msh file..
'''
file_name = file_base_name + "-mesh.vtu"
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(file_name)
writer.SetInputData(mesh)
writer.Update()
writer.Write()
## Create the XML data.
#
root = etree.Element("mitk_mesh", type="TetGen", model_name=model_name)
time_step = etree.SubElement(root, 'timestep', id='0')
mesh_element = etree.SubElement(time_step, 'mesh', type="TetGen")
command_history = etree.SubElement(mesh_element, 'command_history')
command = etree.SubElement(command_history, 'command', content="option surface 1")
command = etree.SubElement(command_history, 'command', content="option volume 1")
command = etree.SubElement(command_history, 'command', content="option UseMMG 1")
command = etree.SubElement(command_history, 'command', content="option GlobalEdgeSize 0.7992")
command = etree.SubElement(command_history, 'command', content="setWalls")
command = etree.SubElement(command_history, 'command', content="option Optimization 3")
command = etree.SubElement(command_history, 'command', content="generateMesh")
command = etree.SubElement(command_history, 'command', content="writeMesh")
# Write XML data.
tree = etree.ElementTree(root)
file_name = file_base_name + '-mesh.msh'
with open(file_name, 'wb') as f:
tree.write(f, encoding='utf-8')
def write_vtk_particle_grid(self, output):
if self.vtk_particle_grid is None:
raise TypeError("No grid to be written")
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(output)
writer.SetInputData(self.vtk_particle_grid)
writer.Write()
def write(self):
"""
Actually write the tube object to a vtk file using a
VTKUntructuredGrid
"""
R, T, Z = self.tube.mesh
X = R * np.cos(T)
Y = R * np.sin(T)
for i in range(self.tube.ntime):
grid = vtk.vtkUnstructuredGrid()
points = vtk.vtkPoints()
for x, y, z in zip(X.flatten(), Y.flatten(), Z.flatten()):
points.InsertNextPoint(x, y, z)
grid.SetPoints(points)
self._set_grid(grid)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(self.fname + ("-%i" % i) + ".vtu")
writer.SetInputData(grid)
self._dump_point_data(grid, i)
self._dump_element_data(grid, i)
writer.Write()
def Write2VTU(self, vtk_file_name):
vtk_file_name = vtk_file_name + '.vtu'
xmlWriter = vtk.vtkXMLUnstructuredGridWriter()
xmlWriter.SetFileName(vtk_file_name)
xmlWriter.SetInputData(self.VTK_Grids)
xmlWriter.Write()
return vtk_file_name
def visualize(points):
alreadyConnected = []
for i in range(0, points.GetNumberOfPoints()):
alreadyConnected.append(i)
for i in range(0, points.GetNumberOfPoints()):
index = -1
distance = float("inf")
distanceOrder = 0
record = float("inf")
for j in range(0, points.GetNumberOfPoints()):
distance = math.sqrt(
vtk.vtkMath.Distance2BetweenPoints(points.GetPoint(i),
points.GetPoint(j)))
if (distance > 0 and distance < record and alreadyConnected[j] != i
and alreadyConnected[alreadyConnected[j]] != i):
record = distance
index = j
elif (distance > 0 and distance < record):
distanceOrder += 1
if (index != -1 and distanceOrder < 2):
alreadyConnected[i] = index
line.InsertNextCell(2)
line.InsertCellPoint(i)
line.InsertCellPoint(index)
for i in range(0, points.GetNumberOfPoints()):
index = -1
distance = float("inf")
distanceOrder = 0
record = float("inf")
for j in range(0, points.GetNumberOfPoints()):
distance = vtk.vtkMath.Distance2BetweenPoints(
points.GetPoint(i), points.GetPoint(j))
if (distance > 0 and distance < record and alreadyConnected[j] != i
and alreadyConnected[i] != j
and alreadyConnected[alreadyConnected[j]] !=
alreadyConnected[alreadyConnected[i]]):
record = distance
index = j
elif (distance > 0 and distance < record):
distanceOrder += 1
if (index != -1 and distanceOrder < 2):
alreadyConnected[i] = index
line.InsertNextCell(2)
line.InsertCellPoint(i)
line.InsertCellPoint(index)
G = vtk.vtkUnstructuredGrid()
G.GetPointData().SetScalars(degree)
G.SetPoints(Points)
G.SetCells(vtk.VTK_LINE, line)
gw = vtk.vtkXMLUnstructuredGridWriter()
gw.SetFileName(outputFileName)
gw.SetInputData(G)
gw.Write()
def createDEM_v2():
ds = xr.open_dataset('../data/static/static.nc')
points = vtk.vtkPoints()
quad = vtk.vtkQuad()
cells = vtk.vtkCellArray()
numPoints = ds.lat.size*ds.lon.size
print('Write points \n')
for i,j in product(ds.lat.values,ds.lon.values):
points.InsertNextPoint(j, i, ds.HGT.sel(lat=i,lon=j).values/6370000.0)
print('Write cells \n')
for idx in range(points.GetNumberOfPoints()-ds.lon.size):
if (idx%ds.lon.size != 0):
quad.GetPointIds().SetId(0,idx)
quad.GetPointIds().SetId(1,idx+1)
quad.GetPointIds().SetId(2,idx+ds.lon.size+1)
quad.GetPointIds().SetId(3,idx+ds.lon.size)
cells.InsertNextCell(quad)
print('Create unstructured grid \n')
grid = vtk.vtkUnstructuredGrid()
grid.SetPoints(points)
grid.SetCells(vtk.VTK_QUAD, cells)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName('cosipy.vtu')
writer.SetInputData(grid)
writer.Write()
def write_updated_mesh(mesh, new_vtu_file_path):
""" Function to write the new VTU file
Function 'write_updated_mesh' crete new VTU file with utdated value given
by 'mesh' and save at 'new_vtu_file_path'
Args:
mesh (vtkhelpers object instance): Python instance of SU2 result file
with added force and normal vectors
new_vtu_file_path (str): New VTU file path
"""
# To write .vtk file
# writer = vtk.vtkUnstructuredGridWriter()
# writer.SetFileType(0)
# To write .vtu file
writer = vtk.vtkXMLUnstructuredGridWriter()
try:
source = mesh.GetOutput()
except AttributeError:
source = mesh
writer.SetInputData(source)
writer.SetFileName(new_vtu_file_path)
writer.Update()
def Save(self, filename, counter, u, stress, uname='displacement'):
""" Save the stress result of elements at time t with stress tensor of dim.
Dim is an array like ['xx', 'yy', 'xy', 'xz', 'yz']
"""
dim = np.array(['xx', 'yy', 'xy', 'xz', 'yz'])
for i, name in enumerate(dim):
for iSmp in range(self.nSmp):
stressVec = numpy_to_vtk(stress[:, iSmp, i])
stressVec.SetName('{}_{:03d}'.format(name, iSmp))
self.polyDataModel.GetCellData().AddArray(stressVec)
for iSmp in range(self.nSmp):
uTuples = numpy_to_vtk(u[iSmp, :, :])
uTuples.SetName('{}_{:03d}'.format(uname, iSmp))
self.polyDataModel.GetPointData().AddArray(uTuples)
filename, fileExtension = os.path.splitext(filename)
stressFilename = '{}{}{}'.format(filename, counter, fileExtension)
writer = vtk.vtkXMLPolyDataWriter() if fileExtension.endswith(
'vtp') else vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputData(self.polyDataModel)
writer.SetFileName(stressFilename)
writer.Write()
print('Write result to {}.'.format(stressFilename))
def write_vtu(mesh, fn):
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputData(mesh)
writer.SetFileName(fn)
writer.Update()
writer.Write()
return
def _save_unstructured_grid(filename, vtkUnstructGrid, directory=''):
"""Saves a VTK unstructured grid file (vtu) for an already generated
:class:`pyvista.UnstructuredGrid` object.
Parameters
----------
filename : str
path to the output vtk file or just its name if directory is specified
directory : str
directory where the UBC GIF file lives
"""
if not isinstance(vtkUnstructGrid, vtk.vtkUnstructuredGrid):
raise RuntimeError(
'`_save_unstructured_grid` can only handle `vtkUnstructuredGrid` objects. `%s` is not supported.'
% vtkUnstructGrid.__class__)
# Check the extension of the filename
fname = os.path.join(directory, filename)
ext = os.path.splitext(fname)[1]
if ext is '':
fname = fname + '.vtu'
elif ext not in '.vtu':
raise IOError(
'{:s} is an incorrect extension, has to be .vtu'.format(ext))
# Make the writer
vtuWriteFilter = vtkXMLUnstructuredGridWriter()
if float(VTK_VERSION.split('.')[0]) >= 6:
vtuWriteFilter.SetInputDataObject(vtkUnstructGrid)
else:
vtuWriteFilter.SetInput(vtkUnstructGrid)
vtuWriteFilter.SetFileName(fname)
# Write the file
vtuWriteFilter.Update()
def write_to_vtk(self, fname):
# 重心处的值
bc = np.array([1 / 3, 1 / 3, 1 / 3], dtype=np.float64)
ps = self.mesh.bc_to_point(bc)
vmesh = vtk.vtkUnstructuredGrid()
vmesh.SetPoints(self.points)
vmesh.SetCells(self.cellType, self.cells)
cdata = vmesh.GetCellData()
pdata = vmesh.GetPointData()
uh = self.uh
V = uh.value(bc)
V = np.r_['1', V, np.zeros((len(V), 1), dtype=np.float64)]
val = vnp.numpy_to_vtk(V)
val.SetName('velocity')
cdata.AddArray(val)
if True:
ch = self.ch
rch = ch.to_cspace_function()
val = vnp.numpy_to_vtk(rch)
val.SetName('concentration')
pdata.AddArray(val)
else:
ch = self.ch
val = ch.value(ps)
val = vnp.numpy_to_vtk(val)
val.SetName('concentration')
cdata.AddArray(val)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(fname)
writer.SetInputData(vmesh)
writer.Write()
def write_data(input_data, filename):
"""
Write the given input data based on the file name extension.
Args:
input_data (vtkSTL/vtkPolyData/vtkXMLPolydata/vtkXMLUnstructured): Input data.
filename (str): Save path location.
"""
# Check filename format
fileType = filename.split(".")[-1]
if fileType == '':
raise NameError('The file does not have an extension')
# Get writer
if fileType == 'stl':
writer = vtk.vtkSTLWriter()
elif fileType == 'vtp':
writer = vtk.vtkXMLPolyDataWriter()
elif fileType == 'vtu':
writer = vtk.vtkXMLUnstructuredGridWriter()
else:
raise NameError('Unknown file type %s' % fileType)
# Set filename and input
writer.SetFileName(filename)
writer.SetInputData(input_data)
writer.Update()
# Write
writer.Write()
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkXMLUnstructuredGridWriter(), 'Writing vtkXMLUnstructuredGrid.',
('vtkXMLUnstructuredGrid',), (),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def write_VTU(filename, vertices, faces):
"""Writes .vtu file format for the paraview (Kitware (c)) visualisation software.
It relies on the VTK library for its writer. VTU files use the last XML file format of the VTK library.
Parameters
----------
filename: str
name of the mesh file to be written on disk
vertices: ndarray
numpy array of the coordinates of the mesh's nodes
faces: ndarray
numpy array of the faces' nodes connectivities
"""
from vtk import vtkXMLUnstructuredGridWriter, VTK_MAJOR_VERSION
writer = vtkXMLUnstructuredGridWriter()
writer.SetDataModeToAscii()
writer.SetFileName(filename)
unstructured_grid = _build_vtkUnstructuredGrid(vertices, faces)
if VTK_MAJOR_VERSION <= 5:
writer.SetInput(unstructured_grid)
else:
writer.SetInputData(unstructured_grid)
writer.Write()
def writeVTU(mesh, filename):
print('Writing .vtu file...')
w = vtk.vtkXMLUnstructuredGridWriter()
w.SetInputData(mesh)
w.SetFileName(filename)
w.Write()
print('done.')
def writeVTU(mesh, filename, vprint):
vprint('Writing ' + filename + ' file...')
w = vtk.vtkXMLUnstructuredGridWriter()
w.SetInputData(mesh)
w.SetFileName(filename + '.vtu')
w.Write()
vprint('done.')
def write_volume_mesh(file_base_name, mesh, region_id):
file_name = file_base_name + "-mesh-" + str(region_id) + ".vtu"
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(file_name)
writer.SetInputData(mesh)
writer.Update()
writer.Write()
def save( self, name ):
import vtk
vtkWriter = vtk.vtkXMLUnstructuredGridWriter()
vtkWriter.SetInput ( self.vtkMesh )
vtkWriter.SetFileName( os.path.join( self.path, name ) )
if self.ascii:
vtkWriter.SetDataModeToAscii()
vtkWriter.Write()
def WriteVTKXMLMeshFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTK XML mesh file.')
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInput(self.Mesh)
writer.SetFileName(self.OutputFileName)
writer.Write()
def HDF5toVTKCells():
input_meshes = []
# Read input meshes.
for in_file in input_mesh_files[output]:
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(in_file)
reader.Update()
input_meshes += [reader.GetOutput()]
# Only add parent mesh for a tube (non-bifurcation)
if branches == 1:
break
for time_step in range(args.start, args.end + 1):
print("Time:", time_step)
append_filter = vtk.vtkAppendFilter()
for branch in range(branches):
mesh = vtk.vtkPolyData()
mesh.DeepCopy(input_meshes[branch])
# The base input h5 filename given the branch and from which writer it came on said branch.
h5_file_base = base_names[output] + str(time_step) + '_b_' + str(branch + 1) + '_' + 'x' + '.h5'
print("Processing file", h5_file_base)
# Group all datasets of a branch at a specific time point given
# the number of writers the data was split into.
species_array = append_datasets(writers, h5_file_base, "data")
# Loop through all attirbutes and append them to a new array in the
# correct order given the quad to task ratio.
for attribute in attributes[output]:
reordered_array = vtk.vtkDoubleArray()
reordered_array.SetName(attribute)
reordered_array.SetNumberOfValues(numCells[output][0] * numCells[output][1] * circQuads * axialQuads)
reorder_species(species_array[attribute], reordered_array, output)
mesh.GetCellData().AddArray(reordered_array)
append_filter.AddInputData(mesh)
append_filter.Update()
# Write the result.
vtu_file = base_names[output] + str(time_step) + '.vtu'
print("Writing file", os.path.abspath(vtu_file))
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(vtu_file)
writer.SetInputData(append_filter.GetOutput())
writer.Update()
def write_vtu(filename, atoms, data=None):
from vtk import VTK_MAJOR_VERSION, vtkUnstructuredGrid, vtkPoints, vtkXMLUnstructuredGridWriter
from vtk.util.numpy_support import numpy_to_vtk
if isinstance(atoms, list):
if len(atoms) > 1:
raise ValueError('Can only write one configuration to a VTI file!')
atoms = atoms[0]
# Create a VTK grid of structured points
ugd = vtkUnstructuredGrid()
# add atoms as vtk Points
p = vtkPoints()
p.SetNumberOfPoints(len(atoms))
p.SetDataTypeToDouble()
for i,pos in enumerate(atoms.get_positions()):
p.InsertPoint(i,pos[0],pos[1],pos[2])
ugd.SetPoints(p)
# add atomic numbers
numbers = numpy_to_vtk(atoms.get_atomic_numbers(), deep=1)
ugd.GetPointData().AddArray(numbers)
numbers.SetName("atomic numbers")
# add tags
tags = numpy_to_vtk(atoms.get_tags(), deep=1)
ugd.GetPointData().AddArray(tags)
tags.SetName("tags")
# add covalent radii
from ase.data import covalent_radii
radii = numpy_to_vtk(np.array([covalent_radii[i] for i in atoms.get_atomic_numbers()]), deep=1)
ugd.GetPointData().AddArray(radii)
radii.SetName("radii")
# Save the UnstructuredGrid dataset to a VTK XML file.
w = vtkXMLUnstructuredGridWriter()
if fast:
w.SetDataModeToAppend()
w.EncodeAppendedDataOff()
else:
w.GetCompressor().SetCompressionLevel(0)
w.SetDataModeToAscii()
if isinstance(filename, str):
w.SetFileName(filename)
else:
w.SetFileName(filename.name)
if VTK_MAJOR_VERSION <= 5:
w.SetInput(ugd)
else:
w.SetInputData(ugd)
w.Write()
def writeVTUFile(fileName,vtkUnstructuredGrid,compress=True):
'''Function to write vtk unstructured grid (vtu).'''
Writer = vtk.vtkXMLUnstructuredGridWriter()
if float(vtk.VTK_VERSION.split('.')[0]) >=6:
Writer.SetInputData(vtkUnstructuredGrid)
else:
Writer.SetInput(vtkUnstructuredGrid)
if not compress:
Writer.SetCompressorTypeToNone()
Writer.SetDataModeToAscii()
Writer.SetFileName(fileName)
Writer.Update()
def WriteVTKXMLMeshFile(self):
if (self.OutputFileName == ''):
self.PrintError('Error: no OutputFileName.')
self.PrintLog('Writing VTK XML mesh file.')
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInput(self.Mesh)
writer.SetFileName(self.OutputFileName)
if self.Mode == "binary":
writer.SetDataModeToBinary()
elif self.Mode == "ascii":
writer.SetDataModeToAscii()
writer.Write()
def write_vtu(ugrid, filename, mode = 'ascii'):
writer = vtk.vtkXMLUnstructuredGridWriter()
if mode == 'ascii':
writer.SetDataModeToAscii()
elif mode == 'binary':
writer.SetDataModeToBinary()
elif mode == 'append':
writer.SetDataModetoAppend()
writer.SetFileName(filename)
writer.SetInputData(ugrid)
writer.Write()
def write_vtk(self,geo,filename,wells=False):
"""Writes *.vtu file for a vtkUnstructuredGrid object corresponding to the grid in 3D, with the specified filename,
for visualisation with VTK."""
from vtk import vtkXMLUnstructuredGridWriter
if wells: geo.write_well_vtk()
arrays=geo.vtk_data
grid_arrays=self.get_vtk_data(geo)
for array_type,array_dict in arrays.items():
array_dict.update(grid_arrays[array_type])
vtu=geo.get_vtk_grid(arrays)
writer=vtkXMLUnstructuredGridWriter()
writer.SetFileName(filename)
writer.SetInput(vtu)
writer.Write()
def vtkbasis(mesh, etob, fname, coeffs):
''' Find the directions from a (non-uniform) plane wave basis and output a VTK-compatible file
It's possible that this needs to be updated to work with recent changes to ElementToBasis
'''
try:
import vtk
points = vtk.vtkPoints()
vectors = vtk.vtkDoubleArray()
vectors.SetNumberOfComponents(3)
scalars = vtk.vtkDoubleArray()
nc = 0
for e in range(mesh.nelements):
c = paa.origin(mesh, e)
bs = etob[e]
cc = np.zeros(3)
cc[:len(c)] = c
nondir = 0
ndir = 0
for b in bs:
if hasattr(b, "directions"):
for d in b.directions.transpose():
dd = np.zeros(3)
dd[:len(d)] = d
if coeffs is not None: dd *= abs(coeffs[nc])
points.InsertNextPoint(*cc)
vectors.InsertNextTuple3(*dd)
ndir+=1
nc+=1
else:
nondir += np.sqrt(np.sum(coeffs[nc:nc+b.n]**2))
nc += b.n
for _ in range(ndir): scalars.InsertNextValue(nondir)
g = vtk.vtkUnstructuredGrid()
g.SetPoints(points)
gpd = g.GetPointData()
gpd.SetVectors(vectors)
gpd.SetScalars(scalars)
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(fname)
writer.SetInput(g)
writer.Write()
except ImportError as e:
print "Unable to write basis to file: ",e
def SaveVTK(self, outfile="Output"):
""" Save grid in vtk structured format.
Parameters
----------
grid: vtkStructuredGrid : grid used in computation
outfile: string : output file name in system
Defaults to "Output"
Return
------
pass
save file directly on outfile location
"""
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(outfile + ".vtu")
writer.SetInput(self.mesh)
writer.Write()
def write(self):
# polydata = vtk.vtkPolyData()
# polydata.SetPoints(self._points)
# polydata.SetPolys(self._hexs)
# for ptData in self._resultsPoint:
# polydata.GetPointData().AddArray(ptData)
# for cellData in self._resultsCell:
# polydata.GetCellData().AddArray(cellData)
# polydata.Modified()
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(self._fname)
if vtk.VTK_MAJOR_VERSION <= 5:
writer.SetInput(self._hexs)
else:
writer.SetInputData(self._hexs)
writer.Write()
def Write(self, filename=[]):
"""Writes the grid to a vtu file.
If no filename is specified it will use the name of the file originally
read in, thus overwriting it!
"""
if filename==[]:
filename=self.filename
if filename is None:
raise Exception("No file supplied")
if filename.endswith('pvtu'):
gridwriter=vtk.vtkXMLPUnstructuredGridWriter()
else:
gridwriter=vtk.vtkXMLUnstructuredGridWriter()
gridwriter.SetFileName(filename)
gridwriter.SetInput(self.ugrid)
gridwriter.Write()
def writeUGrid(
ugrid,
filename,
verbose=1):
myVTK.myPrint(verbose, "*** writeUGrid: " + filename + " ***")
if ('vtk' in filename):
ugrid_writer = vtk.vtkUnstructuredGridWriter()
elif ('vtu' in filename):
ugrid_writer = vtk.vtkXMLUnstructuredGridWriter()
else:
assert 0, "File must be .vtk or .vtu. Aborting."
ugrid_writer.SetFileName(filename)
ugrid_writer.SetInputData(ugrid)
ugrid_writer.Update()
ugrid_writer.Write()
def makeVTKWellsUsingModule(fname_base, welltracks_df, xml=False):
numpoints = welltracks_df.shape[0]
wells = welltracks_df['Well'].unique().tolist()
numwells = len(wells)
grid = vtkUnstructuredGrid()
points = vtkPoints()
for i in range(numpoints):
points.InsertNextPoint(welltracks_df.loc[i,'X'], welltracks_df.loc[i,'Y'], welltracks_df.loc[i,'Elev_mASL'])
cells = vtkCellArray()
wellname = vtkStringArray()
wellname.SetName('Well')
for well in wells:
print well
polyline = vtkPolyLine()
indices = welltracks_df[welltracks_df['Well']==well].index.tolist()
for i, j in enumerate(indices):
polyline.GetPointIds().SetNumberOfIds(len(indices))
polyline.GetPointIds().SetId(i,j)
cells.InsertNextCell(polyline)
wellname.InsertNextValue(well)
grid.SetPoints(points)
grid.SetCells(VTK_POLY_LINE, cells)
grid.GetCellData().AddArray(wellname)
if xml:
writer = vtkXMLUnstructuredGridWriter()
writer.SetFileName('{}.vtu'.format(fname_base))
writer.SetDataModeToAscii()
writer.SetInputData(grid)
writer.Write()
else:
writer = vtkUnstructuredGridWriter()
writer.SetFileName('{}.vtk'.format(fname_base))
writer.SetInputData(grid)
writer.Write()
def writeUGrid(
ugrid,
filename,
verbose=0):
mypy.my_print(verbose, "*** writeUGrid: "+filename+" ***")
if ('vtk' in filename):
ugrid_writer = vtk.vtkUnstructuredGridWriter()
elif ('vtu' in filename):
ugrid_writer = vtk.vtkXMLUnstructuredGridWriter()
else:
assert 0, "File must be .vtk or .vtu. Aborting."
ugrid_writer.SetFileName(filename)
if (vtk.vtkVersion.GetVTKMajorVersion() >= 6):
ugrid_writer.SetInputData(ugrid)
else:
ugrid_writer.SetInput(ugrid)
ugrid_writer.Update()
ugrid_writer.Write()
def Clip_VTK_data_to_VTK(inputFileName,
outputFileName,
point, normal,
resolution
):
reader = vtk.vtkXMLUnstructuredGridReader()
reader.SetFileName(inputFileName)
reader.Update()
plane = vtk.vtkPlane()
plane.SetOrigin(point)
plane.SetNormal(normal)
clipper = vtk.vtkClipDataSet()
clipper.SetClipFunction(plane)
clipper.SetInputConnection(reader.GetOutputPort())
clipper.Update()
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInputData(clipper.GetOutput())
writer.SetFileName(outputFileName)
writer.Write()
def manyToVTK3(fields,fileName,ascii=False,compress=True):
'''
Save all fields passed as argument into VTK3 Unstructured Grid file (``*.vtu``).
All *fields* must be defined on the same mesh object; exception will be raised if this is not the case.
:param bool ascii: write numbers are ASCII in the XML-based VTU file (rather than base64-encoded binary in XML)
:param bool compress: apply compression to the data
'''
import vtk
if not fields: raise ValueError('At least one field must be passed.')
# check if all fields are defined on the same mesh
if len(set([f.mesh for f in fields]))!=1: raise RuntimeError('Not all fields are sharing the same Mesh object (and could not be saved to a single .vtu file')
# convert mesh to VTK UnstructuredGrid
mesh=fields[0].getMesh()
vtkgrid=mesh.asVtkUnstructuredGrid()
# add fields as arrays
for f in fields:
arr=vtk.vtkDoubleArray()
arr.SetNumberOfComponents(f.getRecordSize())
arr.SetName(f.getFieldIDName())
assert f.getFieldType() in (FieldType.FT_vertexBased,FieldType.FT_cellBased) # other future types not handled
if f.getFieldType()==FieldType.FT_vertexBased: nn=mesh.getNumberOfVertices()
else: nn=mesh.getNumberOfCells()
arr.SetNumberOfValues(nn)
for i in range(nn): arr.SetTuple(i,f.giveValue(i))
if f.getFieldType()==FieldType.FT_vertexBased: vtkgrid.GetPointData().AddArray(arr)
else: vtkgrid.GetCellData().AddArray(arr)
# write the unstructured grid to file
writer=vtk.vtkXMLUnstructuredGridWriter()
if compress: writer.SetCompressor(vtk.vtkZLibDataCompressor())
if ascii: writer.SetDataModeToAscii()
writer.SetFileName(fileName)
# change between VTK5 and VTK6
if vtk.vtkVersion().GetVTKMajorVersion()==6: writer.SetInputData(vtkgrid)
else: writer.SetInput(vtkgrid)
writer.Write()
def write_vtu(filename, atoms, data=None):
from vtk import vtkUnstructuredGrid, vtkPoints, vtkXMLUnstructuredGridWriter
#if isinstance(fileobj, str):
# fileobj = paropen(fileobj, 'w')
if isinstance(atoms, list):
if len(atoms) > 1:
raise ValueError('Can only write one configuration to a VTI file!')
atoms = atoms[0]
"""
if data is None:
raise ValueError('VTK XML Unstructured Grid (VTI) format requires data!')
data = np.asarray(data)
if data.dtype == complex:
data = np.abs(data)
"""
cell = atoms.get_cell()
assert np.all(cell==np.diag(cell.diagonal())), 'Unit cell must be orthogonal' #TODO bounding box with general unit cell?!
bbox = np.array(list(zip(np.zeros(3),cell.diagonal()))).ravel()
# Create a VTK grid of structured points
ugd = vtkUnstructuredGrid()
ugd.SetWholeBoundingBox(bbox)
"""
# Allocate a VTK array of type double and copy data
da = vtkDoubleArray()
da.SetName('scalars')
da.SetNumberOfComponents(3)
da.SetNumberOfTuples(len(atoms))
for i,pos in enumerate(atoms.get_positions()):
da.SetTuple3(i,pos[0],pos[1],pos[2])
"""
p = vtkPoints()
p.SetNumberOfPoints(len(atoms))
p.SetDataTypeToDouble()
for i,pos in enumerate(atoms.get_positions()):
p.InsertPoint(i,pos[0],pos[1],pos[2])
ugd.SetPoints(p)
# Assign the VTK array as point data of the grid
#upd = ugd.GetPointData() # type(spd) is vtkPointData
#upd.SetScalars(da)
# Save the UnstructuredGrid dataset to a VTK XML file.
w = vtkXMLUnstructuredGridWriter()
if fast:
w.SetDataModeToAppend()
w.EncodeAppendedDataOff()
else:
w.GetCompressor().SetCompressionLevel(0)
w.SetDataModeToAscii()
w.SetFileName(filename)
w.SetInput(ugd)
w.Write()
def write(self, fname):
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetFileName(fname)
writer.SetInput(self.__grid)
writer.Write()
p.add_option("-a", action="store_true", dest="twoD_example_alternative", help="Yield function will contain contributions from an alternative example 2D yield function")
(opts, args) = p.parse_args()
# get the com filename
if len(args) != 1:
p.print_help()
sys.exit(1)
in_file = args[0]
if opts.verbose: print "Reading", in_file
if in_file.endswith(".vtp"):
indata = vtk.vtkXMLPolyDataReader()
writer = vtk.vtkXMLPolyDataWriter()
elif in_file.endswith(".vtu"):
indata = vtk.vtkXMLUnstructuredGridReader()
writer = vtk.vtkXMLUnstructuredGridWriter()
elif in_file.endswith(".vtr"):
indata = vtk.vtkXMLRectilinearGridReader()
writer = vtk.vtkXMLRectilinearGridWriter()
else:
print "This program has not yet been configured to read files of type", in_file
sys.exit(2)
indata.SetFileName(in_file)
indata.Update()
indata = indata.GetOutput()
if opts.verbose: print "Generating", opts.name
yf = vtk.vtkDoubleArray()
def write(
filename,
vtk_mesh,
point_data = None,
cell_data = None,
field_data = None
):
'''Writes mesh together with data to a file.
:params filename: File to write to.
:type filename: str
:params point_data: Named additional point data to write to the file.
:type point_data: dict
'''
import os
extension = os.path.splitext(filename)[1]
# add point data
is_exodus_format = extension in [ '.ex2', '.exo', '.e' ]
if point_data:
for name, data in point_data.iteritems():
new_name = name
# There is a naming inconsistency in VTK when it comes to
# multivectors in Exodus files:
# If a vector 'v' has two components, they are called 'v_r',
# 'v_z' (note the underscore), if it has three, then they are
# called 'vx', 'vy', 'vz'.
# Make this consistent by appending an underscore if needed.
# Note that for VTK files, this problem does not occur since
# the label of a vector is always stored as a string.
is_3d_vector = len(data.shape) == 2 and data.shape[1] == 3
if is_exodus_format and is_3d_vector and name[-1] != '_':
new_name += '_'
vtk_mesh.GetPointData() \
.AddArray(_create_vtkarray(data, new_name))
# add cell data
if cell_data:
for key, value in cell_data.iteritems():
vtk_mesh.GetCellData() \
.AddArray(_create_vtkarray(value, key))
# add field data
if field_data:
for key, value in field_data.iteritems():
vtk_mesh.GetFieldData() \
.AddArray(_create_vtkarray(value, key))
import re
extension = os.path.splitext(filename)[1]
if extension == '.vtu': # VTK XML format
from vtk import vtkXMLUnstructuredGridWriter
writer = vtkXMLUnstructuredGridWriter()
elif extension == '.pvtu': # parallel VTK XML format
from vtk import vtkXMLPUnstructuredGridWriter
writer = vtkXMLPUnstructuredGridWriter()
elif extension == '.vtk': # classical VTK format
from vtk import vtkUnstructuredGridWriter
writer = vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif extension == '.xmf': # XDMF format
from vtk import vtkXdmfWriter
writer = vtkXdmfWriter()
elif extension in [ '.ex2', '.exo', '.e' ]: # Exodus II format
from vtk import vtkExodusIIWriter
writer = vtkExodusIIWriter()
# If the mesh contains vtkModelData information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
elif re.match('[^\.]*\.e\.\d+\.\d+', filename):
# TODO handle parallel I/O with vtkPExodusIIWriter
from vtk import vtkExodusIIWriter
writer = vtkExodusIIWriter()
# If the mesh contains vtkModelData information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
else:
raise IOError( 'Unknown file type \'%s\'.' % filename )
writer.SetFileName( filename )
writer.SetInputData( vtk_mesh )
writer.Write()
return
def main(argv):
import vtk
from vtk.numpy_interface import dataset_adapter as dsa
from vtk.numpy_interface import algorithms as algs
import numpy as np
### get parameters
import os
if not os.path.exists(OD):
os.makedirs(OD)
print '!!!Output to DIR: ',OD
if not read_fields_from_file:
### Readin stage
# using parallel openfoam reader
ofr = vtk.vtkPOpenFOAMReader()
# set reader's options
ofr.SetFileName(ID+IF)
print '!!!open file: ',ID+IF
ofr.SetDecomposePolyhedra(0)
ofr.CacheMeshOn()
ofr.SetCreateCellToPoint(0)
ofr.DisableAllCellArrays()
ofr.SetCellArrayStatus(fieldname,1)
ofr.Update()
# VTKArray is same as numpy array
times = dsa.vtkDataArrayToVTKArray( ofr.GetTimeValues() ,ofr)
# select the timestep between t0 and tf
times = [t for t in times if t>=t0 and t<=tf]
print '!!!available time steps: ',times
N = len(times)
np.save(times_filename,times)
# using CellQuality to get cell's volumes as weight
cq = vtk.vtkCellQuality()
cq.SetInputConnection(0,ofr.GetOutputPort(0))
cq.SetQualityMeasureToVolume()
cq.Update()
# cq is a composite dataset so I need GetBlock(0)
geom = cq.GetOutputDataObject(0).GetBlock(0)
# get volumes of cells V, size = L (number of cells)
V = np.copy(dsa.WrapDataObject(geom).CellData['CellQuality'])
# normalize it as weight
Vtotal = sum(V)
V /= Vtotal
# delete all other CellDataArray in geom DataSet, preserve its mesh structure and topology structure
for i in range(geom.GetCellData().GetNumberOfArrays()):
geom.GetCellData().RemoveArray(0)
# add volume weight to it for saving
geom.GetCellData().AddArray(dsa.numpyTovtkDataArray(V,'vol_weight'))
# using *.vtu file format to save the vol_weight
ugw = vtk.vtkXMLUnstructuredGridWriter()
ugw.SetInputDataObject(geom)
print '!!!Output vol_weight to file: ',geom_filename
ugw.SetFileName(geom_filename)
# using binary format
ugw.SetDataModeToBinary()
# enable compression
ugw.SetCompressorTypeToZLib()
# write to the file
ugw.Write()
# disconnect cq and ofr in order to isolate this dataset object from Update()
cq.RemoveAllInputConnections(0)
L = V.size # number of cells
N = len(times) #number of timesteps
# vector data is larger in size
if field_is_vector == True:
fields = np.zeros([N,L,3])
else:
fields = np.zeros([N,L])
pipepout = ofr
for i in range(N):
t = times[i]
print '!!!reading time:{}'.format(t)
# set time value
pipepout.GetOutputInformation(0).Set(vtk.vtkStreamingDemandDrivenPipeline.UPDATE_TIME_STEP(),t)
# read in field data of new timestep
pipepout.Update()
#
d = dsa.WrapDataObject(pipepout.GetOutput().GetBlock(0))
print '!!!reading field:{}'.format(fieldname)
field = d.CellData[fieldname]
# get the first component of composite dataset, it is the internalField
fields[i]=np.copy(field)
# write data to file
print '!!!write field data to file:',fields_filename
np.savez(fields_filename,fields)
else: #read fields from file
fields = np.load(fields_filename)['arr_0']
ugr = vtk.vtkXMLUnstructuredGridReader()
ugr.SetFileName(geom_filename)
ugr.Update()
geom = ugr.GetOutputDataObject(0)
V = np.copy(dsa.WrapDataObject(geom).CellData['vol_weight'])
times = np.load(times_filename)
assert times.shape[0] == fields.shape[0]
assert fields.shape[1] == V.shape[0]
N = times.shape[0]
L = fields.shape[1]
print 'Read in dataset complete'
### POD section
# calculate average
field_avg = np.average(fields, axis=0)
if subtractAvg:
fields = fields - field_avg
import modred as mr
if do_POD:
# if field is a vector, reshape the fields and corresponding volument weight
if field_is_vector:
shp_vec = fields.shape
shp_flat = (fields.shape[0],fields.shape[1]*fields.shape[2])
fields = fields.reshape(shp_flat)
V = np.tile(V,shp_vec[2])
# POD
print '!!!Doing POD analysis'
modes, eigen_vals, eigen_vecs, correlation_mat = mr.compute_POD_matrices_snaps_method(fields.T,range(M),inner_product_weights=V,return_all=True)
# if field is a vector, reshape the output matrix
if field_is_vector:
fields = fields.reshape(shp_vec)
modes = np.asarray(modes).T.reshape((modes.shape[1],shp_vec[1],shp_vec[2]))
V = V[:shp_vec[1]]
if output_correlation_matrix:
print "!!!output POD correlation matrix",POD_cm_filename
np.savetxt(POD_cm_filename,correlation_mat,delimiter=',')
if output_POD_temporal_modes:
print "!!!output POD temporal modes",POD_tm_filename
# output temporal modes
singular_vals = eigen_vals**0.5
POD_mode_energy_normalized = eigen_vals/correlation_mat.trace()[0,0]
cumsum_POD_mode_energy_normalized = np.cumsum(POD_mode_energy_normalized)
# generate header string
header_str = 'temporal modes\n'
header_str += 'time,eigen value,singular value,normalized eigen value,accumulated normalized eigen value'
for i in range(N-1):
header_str += ',Mode{}'.format(i)
header_str += '\n'
for i in range(N-1):
header_str += ',SV ={}'.format(singular_vals[i])
header_str += '\n'
for i in range(N-1):
header_str += ',EV ={}'.format(eigen_vals[i])
header_str += '\n'
for i in range(N-1):
header_str += ',NEnergy ={}'.format(POD_mode_energy_normalized[i])
header_str += '\n'
for i in range(N-1):
header_str += ',CumsumEnergy ={}'.format(cumsum_POD_mode_energy_normalized[i])
header_str += '\n'
np.savetxt(POD_tm_filename, \
np.c_[times, \
eigen_vecs], \
delimiter = ',', \
header = header_str)
if output_POD_spatial_modes:
print "!!!output POD spatial Modes to ",POD_sm_filename
#output to xml vtk unstructured grid file
ugcd = geom.GetCellData()
ugcd.Reset()
ugcd.CopyAllOff()
for i in range(ugcd.GetNumberOfArrays()):
ugcd.RemoveArray(0)
# import POD mode
for i in range(M):
ugcd.AddArray(dsa.numpyTovtkDataArray(modes[i],prefix+'_POD_mode_{}_{}'.format(fieldname,i)))
# add average field
ugcd.AddArray(dsa.numpyTovtkDataArray(field_avg,'field_{}_avg'.format(fieldname)))
ugw = vtk.vtkXMLUnstructuredGridWriter()
ugw.SetInputDataObject(geom)
ugw.SetFileName(POD_sm_filename)
ugw.Write()
if doReconstruction:
print "!!! do Reconstrution with {} POD modes at time {}".format(MR,ReconTime)
#get an empty mesh
ugcd = geom.GetCellData()
ugcd.Reset()
ugcd.CopyAllOff()
for i in range(ugcd.GetNumberOfArrays()):
ugcd.RemoveArray(0)
# reconstruct from first MR POD modes
#
ReconN = np.searchsorted(times,ReconTime)
print "!!!actually, reconstruction is done at time {} rather than time {}".format(times[ReconN],ReconTime)
recon_field = np.einsum("i...,i,i",modes[:MR],eigen_vals[:MR]**0.5,np.asarray(eigen_vecs)[ReconN,:MR])+field_avg;
ugcd.AddArray(dsa.numpyTovtkDataArray(recon_field,prefix+'_POD_{}_Reconstructed_{}_{}'.format(MR,fieldname,ReconTime)))
ugw = vtk.vtkXMLUnstructuredGridWriter()
ugw.SetInputDataObject(geom)
ugw.SetFileName(POD_reconstruction_filename)
ugw.Write()
if do_DMD:
print "!!!Begin to calculate DMD modes"
# if field is a vector, reshape the fields and corresponding volument weight
if field_is_vector:
shp_vec = fields.shape
shp_flat = (fields.shape[0],fields.shape[1]*fields.shape[2])
fields = fields.reshape(shp_flat)
V = np.tile(V,shp_vec[2])
# DMD, I do not know which mode is important, so I have to discard modes_
modes_, ritz_vals, mode_norms, build_coeffs = mr.compute_DMD_matrices_snaps_method(fields.T,[],inner_product_weights=V,return_all=True)
# if field is a vector, reshape the fields, V and output matrix
if field_is_vector:
fields = fields.reshape(shp_vec)
V = V[:shp_vec[1]]
# sorting
eorder = np.argsort(mode_norms)[::-1]
# re-order the outputs
ritz_vals = ritz_vals[eorder]
mode_norms = mode_norms[eorder]
build_coeffs = build_coeffs[:,eorder]
#build the DMD_modes
DMD_modes = np.einsum('ijk,il->ljk', fields,build_coeffs[:,:M_DMD])
if output_DMD_info:
print "!!!output DMD info to :",DMD_info_filename
# output modes info
header_str = 'DMD modes info\n'
header_str += 'ritz_vals.real,ritz_vals.imag,growth_rate, frequency, mode_norms\n'
header_str += r'AU,AU,1/s, Hz, AU'
dt = np.average(times[1:]-times[:-1]) #time step
np.savetxt(DMD_info_filename, \
np.c_[ np.real(ritz_vals), \
np.imag(ritz_vals), \
np.log(np.abs(ritz_vals))/dt, \
np.angle(ritz_vals)/dt, \
mode_norms], \
delimiter = ',', \
header = header_str)
if output_DMD_build_coeffs:
print "!!!output DMD build coeffs. to :",DMD_build_coeffs_filename
np.savez(DMD_build_coeffs_filename, build_coeffs)
if output_DMD_spatial_modes:
print "!!!output DMD info to :",DMD_sm_filename
#output to xml vtk unstructured grid file
ugcd = geom.GetCellData()
ugcd.Reset()
ugcd.CopyAllOff()
for i in range(ugcd.GetNumberOfArrays()):
ugcd.RemoveArray(0)
#import pi
from numpy import pi
for i in range(M_DMD):
ugcd.AddArray(dsa.numpyTovtkDataArray(np.abs(DMD_modes[i]),prefix+'_DMD_mode_abs_{}_{}'.format(fieldname,i)))
ugcd.AddArray(dsa.numpyTovtkDataArray(np.angle(DMD_modes[i])*180/pi,prefix+'_DMD_mode_angle_{}_{}'.format(fieldname,i)))
ugw = vtk.vtkXMLUnstructuredGridWriter()
ugw.SetInputDataObject(geom)
ugw.SetFileName(DMD_sm_filename)
ugw.Write()
def writevtu(grid, path):
"""Write VTU-files, i.e. unstructured grids in VTK XML format."""
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetInput(grid)
writer.SetFileName(path)
writer.Write()
def ComputeObjective(self,MRTIDataDirectory,VolumeOfInterest ):
print self.SEMDataDirectory
ObjectiveFunction = 0.0
# loop over time points of interest
for idwrite,(SEMtimeID,MRTItimeID) in enumerate([(0,135),(0,136),(0,137),(0,138)]):
mrtifilename = '%s/temperature.%04d.vtk' % (MRTIDataDirectory,MRTItimeID)
if MRTItimeID in self.DataDictionary:
print "already loaded", mrtifilename
else:
print 'opening' , mrtifilename
# FIXME vtk needs to be loaded AFTER kernel is built
import vtk
import vtk.util.numpy_support as vtkNumPy
print "using vtk version", vtk.vtkVersion.GetVTKVersion()
print "read SEM data"
vtkImageReader = vtk.vtkDataSetReader()
vtkImageReader.SetFileName(mrtifilename )
vtkImageReader.Update()
## image_cells = vtkImageReader.GetOutput().GetPointData()
## data_array = vtkNumPy.vtk_to_numpy(image_cells.GetArray('scalars'))
# extract voi for QOI
vtkVOIExtract = vtk.vtkExtractVOI()
vtkVOIExtract.SetInput( vtkImageReader.GetOutput() )
vtkVOIExtract.SetVOI( VolumeOfInterest )
vtkVOIExtract.Update()
mrti_point_data= vtkVOIExtract.GetOutput().GetPointData()
mrti_array = vtkNumPy.vtk_to_numpy(mrti_point_data.GetArray('image_data'))
#print mrti_array
#print type(mrti_array)
print "project SEM onto MRTI for comparison"
vtkResample = vtk.vtkCompositeDataProbeFilter()
vtkResample.SetSource( vtkVOIExtract.GetOutput() )
vtkResample.SetInput( self.SEMRegister.GetOutput() )
vtkResample.Update()
if ( self.DebugObjective ):
roifileName = "%s/mrti.%04d.vtu" % (self.SEMDataDirectory,MRTItimeID)
print "writing ", roifileName
start = time.clock()
# setup mrti projection file
vtkTemperatureWriter = vtk.vtkXMLUnstructuredGridWriter()
vtkTemperatureWriter.SetFileName( roifileName )
vtkTemperatureWriter.SetInput(vtkResample.GetOutput())
vtkTemperatureWriter.Update()
elapsed = (time.clock() - start)
print "write output", elapsed
print " accumulate objective function"
fem_point_data= vtkResample.GetOutput().GetPointData()
self.DataDictionary[MRTItimeID] = vtkNumPy.vtk_to_numpy(fem_point_data.GetArray('image_data'))
#print fem_array
#print type(fem_array )
h_mrti = self.DataDictionary[MRTItimeID]
mf = cl.mem_flags
d_mrti = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=h_mrti )
# TODO need to get cl buffer from brainNek
d_fem = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=h_mrti )
# storage for output
dest_buf = cl.Buffer(self.ctx, mf.WRITE_ONLY, h_mrti.nbytes)
self.prg.diff_sq(self.queue, h_mrti.shape, None, d_mrti , d_fem , dest_buf)
mrti_minus_fem_squared = numpy.empty_like(h_mrti)
cl.enqueue_copy(self.queue, mrti_minus_fem_squared , dest_buf)
ObjectiveFunction = ObjectiveFunction + mrti_minus_fem_squared.sum()
return ObjectiveFunction
def write(filetype,
filename,
points,
cells,
point_data=None,
cell_data=None,
field_data=None):
vtk_mesh = _generate_vtk_mesh(points, cells)
# add point data
if point_data is not None:
pd = vtk_mesh.GetPointData()
for name, X in point_data.iteritems():
# There is a naming inconsistency in VTK when it comes to
# multivectors in Exodus files:
# If a vector 'v' has two components, they are called 'v_r', 'v_z'
# (note the underscore), if it has three, then they are called
# 'vx', 'vy', 'vz'. Make this consistent by appending an
# underscore if needed. Note that for VTK files, this problem does
# not occur since the label of a vector is always stored as a
# string.
if filetype == 'exodus' and len(X.shape) == 2 \
and X.shape[1] == 3 and name[-1] != '_':
name += '_'
pd.AddArray(_create_vtkarray(X, name))
# add cell data
if cell_data:
cd = vtk_mesh.GetCellData()
for key, value in cell_data.iteritems():
cd.AddArray(_create_vtkarray(value, key))
# add field data
if field_data:
fd = vtk_mesh.GetFieldData()
for key, value in field_data.iteritems():
fd.AddArray(_create_vtkarray(value, key))
if filetype == 'vtk': # classical vtk format
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == 'vtu': # vtk xml format
writer = vtk.vtk.vtkXMLUnstructuredGridWriter()
elif filetype == 'pvtu': # parallel vtk xml format
writer = vtk.vtkXMLUnstructuredGridWriter()
elif filetype == 'exodus': # exodus ii format
writer = vtk.vtkExodusIIWriter()
# if the mesh contains vtkmodeldata information, make use of it
# and write out all time steps.
writer.WriteAllTimeStepsOn()
else:
raise RuntimeError('unknown file type \'%s\'.' % filetype)
writer.SetFileName(filename)
try:
writer.SetInput(vtk_mesh)
except AttributeError:
writer.SetInputData(vtk_mesh)
writer.Write()
return
