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 main():
time_source = vtk.vtkTimeSourceExample()
exodus_writer = vtk.vtkExodusIIWriter()
exodus_writer.SetFileName("output.exii")
exodus_writer.SetInputConnection(time_source.GetOutputPort())
exodus_writer.WriteAllTimeStepsOn()
exodus_writer.Write()
def writeExodusIIGrid(self,path, points, cellNodes, cellTypes):
"""
Methods writes the points and the cells in the Exodus II file format
Args:
path (string): The path where to write the Exodus II mesh
points (list): The coordinates of the nodes of the grid
cellNodes (list): The indices of the points to define the mesh
cellTypes (list) The type of the vtk cells
1 = VTK_LINE
2 = VTK_TRIANGLE
3 = VTK_QUAD
4 = VTK_TETRA
"""
mesh = vtkUnstructuredGrid()
vtk_points = vtkPoints()
for point in points:
vtk_points.InsertNextPoint(
float(point[0]), float(point[1]), float(point[2]))
mesh.SetPoints(vtk_points)
i = 0
for cellNodes in cellNodes:
pts = vtkIdList()
num_local_nodes = len(cellNodes)
pts.SetNumberOfIds(num_local_nodes)
for k, node_index in enumerate(cellNodes):
pts.InsertId(k, int(node_index) - 1)
#if cellTypes[i] == 1:
# mesh.InsertNextCell(VTK_LINE, pts)
if cellTypes[i] == 2:
mesh.InsertNextCell(VTK_TRIANGLE, pts)
if cellTypes[i] == 3:
mesh.InsertNextCell(VTK_QUAD, pts)
if cellTypes[i] == 4:
mesh.InsertNextCell(VTK_TETRA, pts)
i += 1
writer = vtkExodusIIWriter()
writer.WriteAllTimeStepsOn()
#writer.WriteOutBlockIdArrayOn()
writer.WriteOutGlobalNodeIdArrayOn()
#writer.WriteOutGlobalElementIdArrayOn()
writer.SetFileName(path)
self.setInput(mesh, writer)
writer.Write()
def writeExodusIIGrid(path, points, cellNodes, case):
"""
Methods writes the points and the cells in the Exodus II file format
Args:
path (string): The path where to write the Exodus II mesh
points (list): The coordinates of the nodes of the grid
cellNodes (list): The indices of the points to define the mesh
case (int) The type of the vtk cells
1 = VTK_LINE
2 = VTK_TRIANGLE
3 = VTK_QUAD
4 = VTK_TETRA
"""
mesh = vtkUnstructuredGrid()
vtk_points = vtkPoints()
for point in points:
vtk_points.InsertNextPoint(
float(point[0]), float(point[1]), float(point[2]))
mesh.SetPoints(vtk_points)
for cellNodes in cellNodes:
pts = vtkIdList()
num_local_nodes = len(cellNodes)
pts.SetNumberOfIds(num_local_nodes)
for k, node_index in enumerate(cellNodes):
pts.InsertId(k, int(node_index) - 1)
if case == '1':
mesh.InsertNextCell(VTK_LINE, pts)
if case == '2':
mesh.InsertNextCell(VTK_TRIANGLE, pts)
if case == '3':
mesh.InsertNextCell(VTK_QUAD, pts)
if case == '4':
mesh.InsertNextCell(VTK_TETRA, pts)
writer = vtkExodusIIWriter()
writer.WriteAllTimeStepsOn()
writer.WriteOutBlockIdArrayOn()
writer.WriteOutGlobalNodeIdArrayOn()
writer.WriteOutGlobalElementIdArrayOn()
writer.SetFileName(path)
setInput(mesh, writer)
writer.Write()
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 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
def write(filetype,
filename,
points,
cells,
point_data=None,
cell_data=None,
field_data=None):
import vtk
from vtk.util import numpy_support
def _create_vtkarray(X, name):
array = vtk.util.numpy_support.numpy_to_vtk(X, deep=1)
array.SetName(name)
return array
if point_data is None:
point_data = {}
if cell_data is None:
cell_data = {}
if field_data is None:
field_data = {}
vtk_mesh = _generate_vtk_mesh(points, cells)
# add point data
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_x', 'v_y'
# (note the underscore), if it has three, then they are called 'vx',
# 'vy', 'vz'. See bug <http://www.vtk.org/Bug/view.php?id=15894>.
# For VT{K,U} files, no underscore is ever added.
pd.AddArray(_create_vtkarray(X, name))
# add cell data
cd = vtk_mesh.GetCellData()
for key, value in cell_data.iteritems():
cd.AddArray(_create_vtkarray(value, key))
# add field data
fd = vtk_mesh.GetFieldData()
for key, value in field_data.iteritems():
fd.AddArray(_create_vtkarray(value, key))
if filetype in 'vtk-ascii':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == 'vtk-binary':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
elif filetype == 'vtu': # vtk xml format
writer = vtk.vtkXMLUnstructuredGridWriter()
elif filetype == 'xdmf':
writer = vtk.vtkXdmfWriter()
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
def AssembleStatistics(data_dir):
"""
collect all statistics into one exodus file
"""
# post process stats on FEM mesh
# import petsc and numpy
import vtk, numpy
import vtk.util.numpy_support as vtkNumPy
# initialize FEM Mesh
pkl_file = open('%s/CaseInfo.pkl' % ".", 'rb')
fem_params = pickle.load(pkl_file)
pkl_file.close()
vtkExodusIIReader = vtk.vtkExodusIIReader()
print "opening %s " % fem_params['mesh_file']
vtkExodusIIReader.SetFileName( fem_params['mesh_file'] )
#vtkExodusIIReader.SetFileName( "/data/fuentes/utsa/vasculature_july10/vessel_0/realization.1//fem_data.0001.e")
vtkExodusIIReader.ExodusModelMetadataOn ()
vtkExodusIIReader.Update()
exodusObject = vtkExodusIIReader.GetOutput()
responseLevelVarList = fem_params['responseLevelVarList']
probabilityLevelList = fem_params['probabilityLevelList']
reliabilityLevelList = fem_params['reliabilityLevelList']
# loop over time steps and import data
# vtkTemporalDataSet = vtk.vtkTemporalDataSet()
# multiBlockData = {}
#for timeID in [69]:
#TODO how can we assemble all time steps at once ?
#for timeID in range(0,fem_params['ntime']+1):
for timeID in [int(data_dir.split(".").pop())]:
for variable,responseList in responseLevelVarList:
#(variable,responseList) = responseLevelVarList[0]
basePath = "%s/%s" % (data_dir,variable)
# mean
meanFile=open("%s/meanFile.txt" % (basePath) ,"r")
meandataList = [float(line.strip()) for line in meanFile]
meanFile.close()
# std dev
stdFile=open("%s/stddFile.txt" % (basePath),"r")
stdddataList = [float(line.strip()) for line in stdFile]
stdFile.close()
# skewness
skewFile=open("%s/skewFile.txt" % (basePath),"r")
skewdataList = [float(line.strip()) for line in skewFile]
skewFile.close()
# kurtosis
kurtFile=open("%s/kurtFile.txt" % (basePath),"r")
kurtdataList = [float(line.strip()) for line in kurtFile]
kurtFile.close()
# response data
responsedataList = []
for iii,response in enumerate(responseList):
responseFile=open("%s/response.%d.txt" %(basePath,iii),"r")
singleresponseList = [float(line.strip()) for line in responseFile]
responseFile.close()
responsedataList.append(singleresponseList)
# probability data
probabilitydataList = []
for iii,probability in enumerate(probabilityLevelList):
probFile=open("%s/probability.%d.txt" %(basePath,iii),"r")
probList = [float(line.strip()) for line in probFile]
probFile.close()
probabilitydataList.append(probList)
# reliability data
reliabilitydataList = []
for iii,reliability in enumerate(reliabilityLevelList):
reliabFile=open("%s/reliability.%d.txt" %(basePath,iii),"r")
reliabList = [float(line.strip()) for line in reliabFile]
reliabFile.close()
reliabilitydataList.append(reliabList)
# multi block
if exodusObject.IsA("vtkMultiBlockDataSet"):
iter = exodusObject.NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
# iter.GoToNextItem();
# iter.GoToNextItem();
metadata = exodusObject.GetMetaData(iter)
# initialize list for storage
listSliceInit = 0
# loop over blocks...
while not iter.IsDoneWithTraversal():
curInput = iter.GetCurrentDataObject()
curNumberPoints = curInput.GetNumberOfPoints()
fem_point_data= curInput.GetPointData()
DeepCopy = 1
#print timeID,listSliceInit,curNumberPoints
vtkMean= vtkNumPy.numpy_to_vtk( meandataList[listSliceInit:listSliceInit+curNumberPoints ] , DeepCopy)
vtkStdD= vtkNumPy.numpy_to_vtk( stdddataList[listSliceInit:listSliceInit+curNumberPoints ] , DeepCopy)
vtkSkew= vtkNumPy.numpy_to_vtk( skewdataList[listSliceInit:listSliceInit+curNumberPoints ] , DeepCopy)
vtkKurt= vtkNumPy.numpy_to_vtk( kurtdataList[listSliceInit:listSliceInit+curNumberPoints ] , DeepCopy)
vtkMean.SetName( "Var%sMean" % variable )
vtkStdD.SetName( "Var%sStdDev" % variable )
vtkSkew.SetName( "Var%sSkew" % variable )
vtkKurt.SetName( "Var%sKurt" % variable )
fem_point_data.AddArray( vtkMean )
fem_point_data.AddArray( vtkStdD )
fem_point_data.AddArray( vtkSkew )
fem_point_data.AddArray( vtkKurt )
fem_point_data.Update()
for iii,response in enumerate(responsedataList):
vtkResponse= vtkNumPy.numpy_to_vtk( response[listSliceInit:listSliceInit+curNumberPoints ] , DeepCopy)
vtkResponse.SetName( "Var%sresponse%d" %(variable,iii) )
fem_point_data.AddArray( vtkResponse )
fem_point_data.Update()
for iii,probability in enumerate(probabilitydataList):
vtkProb= vtkNumPy.numpy_to_vtk( probability[listSliceInit:listSliceInit+curNumberPoints ] , DeepCopy)
vtkProb.SetName( "Var%sprobability%d" %(variable,iii) )
fem_point_data.AddArray( vtkProb )
fem_point_data.Update()
for iii,reliability in enumerate(reliabilitydataList):
vtkReliab= vtkNumPy.numpy_to_vtk( reliability[listSliceInit:listSliceInit+curNumberPoints ] , DeepCopy)
vtkReliab.SetName( "Var%sreliability%d" %(variable,iii) )
fem_point_data.AddArray( vtkReliab )
fem_point_data.Update()
#vtkSoln = vtkNumPy.numpy_to_vtk( listSliceInit * numpy.ones(curNumberPoints ), DeepCopy )
#vtkSoln.SetName("%d" % listSliceInit)
curInput.Update()
# multiBlockData['%d' % timeID] = vtk.vtkUnstructuredGrid()
# multiBlockData['%d' % timeID].DeepCopy( curInput )
listSliceInit = listSliceInit + curNumberPoints
iter.GoToNextItem();
# single block
else:
raise RuntimeError("not implemented yet... " )
vtkExodusIIWriter = vtk.vtkExodusIIWriter()
vtkExodusIIWriter.SetFileName( '%s/fem_stats.%04d.e' % (".",timeID) )
vtkExodusIIWriter.SetInput( exodusObject)
vtkExodusIIWriter.Update()
# load vtk data
for iii in [2,3,4]:
vtkReader = vtk.vtkUnstructuredGridReader()
vtkReader.SetFileName( "%s.%d.vtk" % (options.output,iii) )
vtkReader.Update()
## vtkNew<vtkDummyController> controller;
## controller->Initialize(&argc, &argv, 1);
## vtkMultiProcessController::SetGlobalController(controller.Get());
## HACK for parallel write
## https://www.paraview.org/Bug/view.php?id=15813
controller =vtk.vtkDummyController()
vtk.vtkMultiProcessController.SetGlobalController(controller)
# convert to exodus
vtkExodusIIWriter = vtk.vtkExodusIIWriter()
#vtkExodusIIWriter.DebugOn()
vtkExodusIIWriter.SetFileName("%s.%d.exo" % (options.output,iii))
vtkExodusIIWriter.SetInputData( vtkReader.GetOutput() )
print vtkExodusIIWriter
vtkExodusIIWriter.Update()
else:
parser.print_help()
print options
## with open("isosurface.1.node") as myfile:
## lines = [list(filter(len,line.strip().split(' '))) for line in myfile]
## numnodes = int(lines[0][0] )
def write(filetype,
filename,
points,
cells,
point_data=None,
cell_data=None,
field_data=None
):
# pylint: disable=import-error
import vtk
def _create_vtkarray(X, name):
array = vtk.util.numpy_support.numpy_to_vtk(X, deep=1)
array.SetName(name)
return array
point_data = {} if point_data is None else point_data
cell_data = {} if cell_data is None else cell_data
field_data = {} if field_data is None else field_data
# assert data integrity
for key in point_data:
assert len(point_data[key]) == len(points), \
'Point data mismatch.'
for key in cell_data:
assert key in cells, 'Cell data without cell'
for key2 in cell_data[key]:
assert len(cell_data[key][key2]) == len(cells[key]), \
'Cell data mismatch.'
vtk_mesh = _generate_vtk_mesh(points, cells)
# add point data
pd = vtk_mesh.GetPointData()
for name, X in point_data.items():
# 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_x', 'v_y'
# (note the underscore), if it has three, then they are called 'vx',
# 'vy', 'vz'. See bug <http://www.vtk.org/Bug/view.php?id=15894>.
# For VT{K,U} files, no underscore is ever added.
pd.AddArray(_create_vtkarray(X, name))
# Add cell data.
# The cell_data is structured like
#
# cell_type ->
# key -> array
# key -> array
# [...]
# cell_type ->
# key -> array
# key -> array
# [...]
# [...]
#
# VTK expects one array for each `key`, so assemble the keys across all
# mesh_types. This requires each key to be present for each mesh_type, of
# course.
all_keys = []
for cell_type in cell_data:
all_keys += cell_data[cell_type].keys()
# create unified cell data
for key in all_keys:
for cell_type in cell_data:
assert key in cell_data[cell_type]
unified_cell_data = {
key: numpy.concatenate([
cell_data[cell_type][key]
for cell_type in cell_data
])
for key in all_keys
}
# add the array data to the mesh
cd = vtk_mesh.GetCellData()
for name, array in unified_cell_data.items():
cd.AddArray(_create_vtkarray(array, name))
# add field data
fd = vtk_mesh.GetFieldData()
for key, value in field_data.items():
fd.AddArray(_create_vtkarray(value, key))
if filetype in 'vtk-ascii':
logging.warning('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('ASCII files are only meant for debugging.')
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToAscii()
elif filetype == 'vtu-binary':
writer = vtk.vtkXMLUnstructuredGridWriter()
writer.SetDataModeToBinary()
elif filetype == 'xdmf':
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()
writer.SetFileName(filename)
try:
writer.SetInput(vtk_mesh)
except AttributeError:
writer.SetInputData(vtk_mesh)
writer.Write()
return
def write(filetype,
filename,
points,
cells,
point_data=None,
cell_data=None,
field_data=None
):
import vtk
from vtk.util import numpy_support
def _create_vtkarray(X, name):
array = vtk.util.numpy_support.numpy_to_vtk(X, deep=1)
array.SetName(name)
return array
if point_data is None:
point_data = {}
if cell_data is None:
cell_data = {}
if field_data is None:
field_data = {}
vtk_mesh = _generate_vtk_mesh(points, cells)
# add point data
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_x', 'v_y'
# (note the underscore), if it has three, then they are called 'vx',
# 'vy', 'vz'. See bug <http://www.vtk.org/Bug/view.php?id=15894>.
# For VT{K,U} files, no underscore is ever added.
pd.AddArray(_create_vtkarray(X, name))
# add cell data
cd = vtk_mesh.GetCellData()
for key, value in cell_data.iteritems():
cd.AddArray(_create_vtkarray(value, key))
# add field data
fd = vtk_mesh.GetFieldData()
for key, value in field_data.iteritems():
fd.AddArray(_create_vtkarray(value, key))
if filetype in 'vtk-ascii':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToASCII()
elif filetype == 'vtk-binary':
writer = vtk.vtkUnstructuredGridWriter()
writer.SetFileTypeToBinary()
elif filetype == 'vtu': # vtk xml format
writer = vtk.vtkXMLUnstructuredGridWriter()
elif filetype == 'xdmf':
writer = vtk.vtkXdmfWriter()
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
[curData.GetValue(i) for i in range(curData.GetSize())] )
iter.GoToNextItem();
block = block + 1
else:
raise ValueError("unknown data type")
if maxData == None:
maxData = rawdata
else:
tmpData = maxData
for idblock in range(block):
for i,(x,y) in enumerate(zip(tmpData[idblock],rawdata[idblock])):
maxData[idblock][i] = max(x,y)
#print max(maxData[idblock])
# write out max to a file as the only "timestep"
vtkExodusIIWriter = vtk.vtkExodusIIWriter()
vtkExodusIIWriter.SetFileName("max_fem_data.e" )
vtkExodusIIWriter.WriteAllTimeStepsOff()
vtkExodusIIWriter.WriteOutBlockIdArrayOn ();
vtkExodusIIWriter.WriteOutGlobalNodeIdArrayOn ();
vtkExodusIIWriter.WriteOutGlobalElementIdArrayOn ();
#vtkExodusIIWriter.WriteAllTimeStepsOn ();
# needs >= VTK 5.6.1 to get vtkexodusIIwriter to work for multiblock data
# overwrite w max data
if femData.IsA("vtkMultiBlockDataSet"):
iter = femData.NewIterator()
iter.UnRegister(None)
iter.InitTraversal()
block = 0
while not iter.IsDoneWithTraversal():
