def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkRectilinearGridWriter(), 'Writing vtkRectilinearGrid.',
('vtkRectilinearGrid',), (),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(self,
module_manager,
vtk.vtkRectilinearGridWriter(),
'Writing vtkRectilinearGrid.',
('vtkRectilinearGrid', ), (),
replaceDoc=True,
inputFunctions=None,
outputFunctions=None)
def write_3d_mesh_tally_to_vtk(
xs,
ys,
zs,
tally_label: str,
tally_data,
error_data,
outfile):
try:
import vtk
except (ImportError, ModuleNotFoundError):
msg = "Conversion to VTK requested," \
"but the Python VTK module is not installed."
raise ImportError(msg)
vtk_box = vtk.vtkRectilinearGrid()
vtk_box.SetDimensions(len(xs), len(ys), len(zs))
vtk_x_array = vtk.vtkDoubleArray()
vtk_x_array.SetName('x-coords')
vtk_x_array.SetArray(xs, len(xs), True)
vtk_box.SetXCoordinates(vtk_x_array)
vtk_y_array = vtk.vtkDoubleArray()
vtk_y_array.SetName('y-coords')
vtk_y_array.SetArray(ys, len(ys), True)
vtk_box.SetYCoordinates(vtk_y_array)
vtk_z_array = vtk.vtkDoubleArray()
vtk_z_array.SetName('z-coords')
vtk_z_array.SetArray(zs, len(zs), True)
vtk_box.SetZCoordinates(vtk_z_array)
tally = np.array(tally_data)
tally_data = vtk.vtkDoubleArray()
tally_data.SetName(tally_label)
tally_data.SetArray(tally, tally.size, True)
error = np.array(error_data)
error_data = vtk.vtkDoubleArray()
error_data.SetName("error_tag")
error_data.SetArray(error, error.size, True)
vtk_box.GetCellData().AddArray(tally_data)
vtk_box.GetCellData().AddArray(error_data)
writer = vtk.vtkRectilinearGridWriter()
writer.SetFileName(outfile)
writer.SetInputData(vtk_box)
print('Writing %s' % outfile)
writer.Write()
def WriteVtkFile(grid, filename, time=None, xml=False, binary=False):
"""Writes a vtk Grid object to a file.
Parameters:
grid -- vtk Grid Object
filename -- the filename for the vtk file
xml -- write the vtk in xml format
binary -- writes in binary format; xml should be True
"""
if binary: xml=True
if not xml:
#write to .vtk file
writer = vtkRectilinearGridWriter();
writer.SetFileName(filename)
if binary:
print
writer.SetInputData(grid)
writer.Write()
if time:
#manually add the time data
vtk_file = open(filename, 'r+').read().split('\n')
line_index = 0
line = ''
_pos = []
while 'CELL_DATA' not in line:
line = vtk_file[line_index]
line_index += 1
vtk_file.insert(line_index-1,'FIELD FieldData 1\nTime 1 1 double\n' + str(time))
with open(filename, 'w+') as fo:
fo.writelines('\n'.join(vtk_file))
else:
if time:
#insert time data; this has a bug on the vtk legacy writer, manually insert time field instead for vtk legacy files.
timeArray = vtkDoubleArray()
timeArray.SetName('Time')
# print time, type(time)
timeArray.InsertNextValue(time)
grid.GetFieldData().AddArray(timeArray)
writer = vtkXMLRectilinearGridWriter();
if binary:
writer.SetDataModeToBinary()
else: writer.SetDataModeToAscii()
print filename
writer.SetFileName(filename)
writer.SetInputData(grid)
writer.Write()
def save(self, filename, binary=True):
"""
Writes a rectilinear grid to disk.
Parameters
----------
filename : str
Filename of grid to be written. The file extension will select the
type of writer to use. ".vtk" will use the legacy writer, while
".vtr" will select the VTK XML writer.
binary : bool, optional
Writes as a binary file by default. Set to False to write ASCII.
Notes
-----
Binary files write much faster than ASCII, but binary files written on
one system may not be readable on other systems. Binary can be used
only with the legacy writer.
"""
filename = os.path.abspath(os.path.expanduser(filename))
# Use legacy writer if vtk is in filename
if '.vtk' in filename:
writer = vtk.vtkRectilinearGridWriter()
legacy = True
elif '.vtr' in filename:
writer = vtk.vtkXMLRectilinearGridWriter()
legacy = False
else:
raise Exception('Extension should be either ".vtr" (xml) or' +
'".vtk" (legacy)')
# Write
writer.SetFileName(filename)
writer.SetInputData(self)
if binary and legacy:
writer.SetFileTypeToBinary()
writer.Write()
def output(self):
"""Save superposition results to npy for plotting & Write superposition result to vtk if SUPERPOSITION_MESH = True.
"""
if cfg.PLOT_2D:
plot_eval_depth(self.results_eval, cfg.DEPTH_COORDS, cfg.PATH_2D,
cfg.FILE_SUFFIX_2D)
print(
"> [Plot] Response at evaluation points plotted in eval_x_2d.png"
)
print("> Writing evaluation results to NPY")
np.save(
os.path.join(cfg.PATH_2D, 'evals' + cfg.FILE_SUFFIX_2D + '.npy'),
self.results_eval)
np.save(
os.path.join(cfg.PATH_2D, 'depths' + cfg.FILE_SUFFIX_2D + '.npy'),
cfg.DEPTH_COORDS)
if cfg.SUPERPOSITION_MESH:
print("> Writing 2D superposition results to VTK")
fields = cfg.FEM_FIELDS_3D
grid = self.queryMesh
for i, field in enumerate(fields):
array = numpy_to_vtk(self.results_grid[:, i],
array_type=vtk.VTK_DOUBLE)
array.SetName(field)
grid.GetPointData().AddArray(array) # add field values
writer = vtk.vtkRectilinearGridWriter()
writer.SetInputData(grid)
writer.SetFileName(
os.path.join(cfg.PATH_2D,
'input' + cfg.FILE_SUFFIX_2D + '_final.vtk'))
writer.Write()
"""Old version
assert(r.GetOutput().GetExtent() == (5,10,5,10,5,10))
assert(r.GetOutput().GetOrigin() == (0, 0, 0))
rg = vtk.vtkRectilinearGrid()
extents = (1, 3, 1, 3, 1, 3)
rg.SetExtent(extents)
pts = vtk.vtkFloatArray()
pts.InsertNextTuple1(0)
pts.InsertNextTuple1(1)
pts.InsertNextTuple1(2)
rg.SetXCoordinates(pts)
rg.SetYCoordinates(pts)
rg.SetZCoordinates(pts)
w = vtk.vtkRectilinearGridWriter()
w.SetInputData(rg)
w.SetFileName("test-dim.vtk")
w.Write()
r = vtk.vtkRectilinearGridReader()
r.SetFileName("test-dim.vtk")
r.Update()
os.remove("test-dim.vtk")
assert(r.GetOutput().GetExtent() == (0,2,0,2,0,2))
w.SetInputData(rg)
w.SetFileName("test-dim.vtk")
w.SetWriteExtent(True)
assert (r.GetOutput().GetExtent() == (5, 10, 5, 10, 5, 10))
assert (r.GetOutput().GetOrigin() == (0, 0, 0))
rg = vtk.vtkRectilinearGrid()
extents = (1, 3, 1, 3, 1, 3)
rg.SetExtent(extents)
pts = vtk.vtkFloatArray()
pts.InsertNextTuple1(0)
pts.InsertNextTuple1(1)
pts.InsertNextTuple1(2)
rg.SetXCoordinates(pts)
rg.SetYCoordinates(pts)
rg.SetZCoordinates(pts)
w = vtk.vtkRectilinearGridWriter()
w.SetInputData(rg)
w.SetFileName("test-dim.vtk")
w.Write()
r = vtk.vtkRectilinearGridReader()
r.SetFileName("test-dim.vtk")
r.Update()
os.remove("test-dim.vtk")
assert (r.GetOutput().GetExtent() == (0, 2, 0, 2, 0, 2))
w.SetInputData(rg)
w.SetFileName("test-dim.vtk")
w.SetWriteExtent(True)
def write_polydata(input_data, filename, datatype=None, file_type="ascii"):
"""
Write the given input data based on the file name extension.
Args:
file_type (string): Filetype of output
input_data (vtkSTL/vtkPolyData/vtkXMLStructured/
vtkXMLRectilinear/vtkXMLPolydata/vtkXMLUnstructured/
vtkXMLImage/Tecplot): Input data.
filename (str): Save path location.
datatype (str): Additional parameter for vtkIdList objects.
"""
# Check filename format
fileType = filename.split(".")[-1]
if fileType == '':
raise RuntimeError('The file does not have an extension')
# Get writer
if fileType == 'stl':
writer = vtk.vtkSTLWriter()
elif fileType == 'vtk':
# Set reader based on data type
if isinstance(input_data, vtk.vtkUnstructuredGrid):
writer = vtk.vtkUnstructuredGridWriter()
elif isinstance(input_data, vtk.vtkStructuredGrid):
writer = vtk.vtkStructuredGridWriter()
elif isinstance(input_data, vtk.vtkRectilinearGrid):
writer = vtk.vtkRectilinearGridWriter()
elif isinstance(input_data, vtk.vtkStructuredPoints) or \
isinstance(input_data, vtk.vtkImageData):
writer = vtk.vtkStructuredPointsWriter()
elif isinstance(input_data, vtk.vtkPolyData):
writer = vtk.vtkPolyDataWriter()
if file_type.lower() == "ascii":
writer.SetFileType(1)
elif file_type.lower() == "binary":
writer.SetFileType(0)
else:
raise ValueError("Invalid file type, can only be ascii or binary")
elif fileType == 'vts':
writer = vtk.vtkXMLStructuredGridWriter()
elif fileType == 'vtr':
writer = vtk.vtkXMLRectilinearGridWriter()
elif fileType == 'vtp':
writer = vtk.vtkXMLPolyDataWriter()
elif fileType == 'vtu':
writer = vtk.vtkXMLUnstructuredGridWriter()
elif fileType == "vti":
writer = vtk.vtkXMLImageDataWriter()
elif fileType == "np" and datatype == "vtkIdList":
output_data = np.zeros(input_data.GetNumberOfIds())
for i in range(input_data.GetNumberOfIds()):
output_data[i] = input_data.GetId(i)
output_data.dump(filename)
return
else:
raise RuntimeError('Unknown file type %s' % fileType)
# Set filename and input
writer.SetFileName(filename)
writer.SetInputData(input_data)
writer.Update()
# Write
writer.Write()
for ifield in range(len(grfields)):
try:
dummy = griddata[grfields[ifield]]
except:
# variable does not exist in output
continue
grid_array = vtk.vtkDoubleArray()
grid_array.SetNumberOfComponents(1)
grid_array.SetNumberOfTuples(N)
for i in range(len(grid[IZ])):
for j in range(len(grid[IX])):
grid_array.SetTuple1(i * len(grid[IX]) + j,
griddata[grfields[ifield]][i, j])
grid_array.SetName(grfieldnames[ifield])
vtkgrid.GetPointData().AddArray(grid_array)
grid_writer = vtk.vtkRectilinearGridWriter()
grid_writer.SetFileName(griddatafile + ".vtk")
if vtk.VTK_MAJOR_VERSION <= 5:
grid_writer.SetInput(vtkgrid)
else:
grid_writer.SetInputData(vtkgrid)
grid_writer.Write()
else:
raise Exception("Undefined plot type")
