def RequestData(self, request, inInfo, outInfo):
logger.info("Loading waveform data...")
start_time = time.time()
output = dsa.WrapDataObject(vtkTable.GetData(outInfo))
if (self._filename is not None and self._subfile is not None
and len(self.mode_names) > 0):
with h5py.File(self._filename, "r") as f:
strain = f[self._subfile]
t = strain["Y_l2_m2.dat"][:, 0]
col_time = vtknp.numpy_to_vtk(t, deep=False)
col_time.SetName("Time")
output.AddColumn(col_time)
for mode_name in self.mode_names:
logger.debug(f"Reading mode '{mode_name}'...")
col_mode = vtknp.numpy_to_vtk(strain[mode_name +
".dat"][:, 1:],
deep=False)
col_mode.SetName(mode_name)
output.AddColumn(col_mode)
logger.info(
f"Waveform data loaded in {time.time() - start_time:.3f}s.")
return 1
def coprocess(time, timeStep, grid, attributes):
global coProcessor
import vtk
from paraview.vtk import vtkPVCatalyst as catalyst
import paraview
from paraview.vtk.util import numpy_support
dataDescription = catalyst.vtkCPDataDescription()
dataDescription.SetTimeData(time, timeStep)
dataDescription.AddInput("input")
if coProcessor.RequestDataDescription(dataDescription):
import fedatastructures
imageData = vtk.vtkImageData()
imageData.SetExtent(grid.XStartPoint, grid.XEndPoint, 0, grid.NumberOfYPoints-1, 0, grid.NumberOfZPoints-1)
imageData.SetSpacing(grid.Spacing)
velocity = numpy_support.numpy_to_vtk(attributes.Velocity)
velocity.SetName("velocity")
imageData.GetPointData().AddArray(velocity)
pressure = numpy_support.numpy_to_vtk(attributes.Pressure)
pressure.SetName("pressure")
imageData.GetCellData().AddArray(pressure)
dataDescription.GetInputDescriptionByName("input").SetGrid(imageData)
dataDescription.GetInputDescriptionByName("input").SetWholeExtent(0, grid.NumberOfGlobalXPoints-1, 0, grid.NumberOfYPoints-1, 0, grid.NumberOfZPoints-1)
coProcessor.CoProcess(dataDescription)
def RequestData(self, request, inInfo, outInfo):
logger.debug("Requesting data...")
input = self.GetInputDataObject(0, 0)
trajectory_data = dsa.WrapDataObject(input)
output = dsa.WrapDataObject(vtkPolyData.GetData(outInfo))
# Retrieve current time
time = timesteps_util.get_timestep(self, logger=logger)
# Retrieve trajectory data
trajectory_times = trajectory_data.PointData["Time"]
trajectory_points = trajectory_data.Points
# Interpolate along the trajectory to find current position
current_position = [
np.interp(time, trajectory_times, trajectory_points[:, i])
for i in range(3)
]
# Expose to VTK
points_vtk = vtk.vtkPoints()
verts_vtk = vtk.vtkCellArray()
verts_vtk.InsertNextCell(1)
points_vtk.InsertPoint(0, *current_position)
verts_vtk.InsertCellPoint(0)
output.SetPoints(points_vtk)
output.SetVerts(verts_vtk)
# Interpolate remaining point data along the trajectory
for dataset in trajectory_data.PointData.keys():
if dataset == "Time":
continue
point_data = trajectory_data.PointData[dataset]
data_at_position = np.zeros(point_data.shape[1:])
if len(data_at_position.shape) > 0:
for i in itertools.product(
*map(range, data_at_position.shape)):
point_data_i = point_data[(slice(None), ) + i]
if len(trajectory_times) == len(point_data_i):
data_at_position[i] = np.interp(
time, trajectory_times, point_data_i)
else:
logger.warning(
"Unable to interpolate trajectory dataset"
f" {dataset}[{i}]: Length of dataset"
f" ({len(point_data_i)}) does not match length of"
f" trajectory times ({len(trajectory_times)}).")
else:
data_at_position = np.interp(time, trajectory_times,
point_data)
data_vtk = vtknp.numpy_to_vtk(np.array([data_at_position]))
data_vtk.SetName(dataset)
output.GetPointData().AddArray(data_vtk)
return 1
def RequestData(self, request, inInfo, outInfo):
logger.debug("Requesting data...")
output = dsa.WrapDataObject(vtkPolyData.GetData(outInfo))
with h5py.File(self._filename, "r") as trajectory_file:
subfile = trajectory_file[self._subfile]
coords = np.array(subfile[self._coords_dataset])
coords[:, 1:] *= self._radial_scale
logger.debug(f"Loaded coordinates with shape {coords.shape}.")
# Construct a line of points
points_vtk = vtk.vtkPoints()
# Each ID is composed of (1) the order of the point in the line and (2)
# the index in the `vtkPoints` constructed above
line_vtk = vtk.vtkPolyLine()
point_ids = line_vtk.GetPointIds()
point_ids.SetNumberOfIds(len(coords))
for i, point in enumerate(coords):
points_vtk.InsertPoint(i, *point[1:])
point_ids.SetId(i, i)
output.SetPoints(points_vtk)
# Set the line ordering as "cell data"
output.Allocate(1, 1)
output.InsertNextCell(line_vtk.GetCellType(), line_vtk.GetPointIds())
# Add time data to the points
time = vtknp.numpy_to_vtk(coords[:, 0])
time.SetName("Time")
output.GetPointData().AddArray(time)
# Add remaining datasets from file to trajectory points
with h5py.File(self._filename, "r") as trajectory_file:
subfile = trajectory_file[self._subfile]
for dataset in subfile:
if dataset == self._coords_dataset:
continue
dataset_vtk = vtknp.numpy_to_vtk(subfile[dataset][:, 1:])
dataset_vtk.SetName(dataset.replace(".dat", ""))
output.GetPointData().AddArray(dataset_vtk)
return 1
def RequestData(self, request, in_info_vec, out_info_vec):
if self._basis_functions is None:
self._load_basis_functions()
if self._mu is None:
self._init_mu()
if self._action == "View basis functions":
# Get basis function number from time step
out_info = out_info_vec.GetInformationObject(0)
selection = self.GetExecutive().UPDATE_TIME_STEP()
if out_info.Has(selection):
basis_function_number = int(round(out_info.Get(selection)))
else:
basis_function_number = 0
# Copy corresponding basis function to output
output = vtkUnstructuredGrid.GetData(out_info_vec)
output.ShallowCopy(self._basis_functions[basis_function_number])
elif self._action == "Run non-intrusive ROM":
if self._networks is None:
self._load_networks()
# Compute reduced solution with pytorch
mu_torch = self._normalize_inputs(tuple(self._mu))
reduced_solution = dict()
for c in self._components:
network_c = self._networks[c][self._N - 1]
normalize_outputs_c = self._normalize_outputs[c][self._N - 1]
reduced_solution[c] = normalize_outputs_c.inv(network_c(mu_torch).detach().numpy()[0])
# Copy mesh to output
output = vtkUnstructuredGrid.GetData(out_info_vec)
output.DeepCopy(self._basis_functions[0])
for (c, _) in enumerate(self._components):
output.GetPointData().RemoveArray(c)
# Combine basis functions with coefficients provided by network
for c in self._components:
array_c_np = np.dot(self._arrays[c][..., :self._N], reduced_solution[c])
array_c_vtk = numpy_to_vtk(array_c_np, deep=1)
array_c_vtk.SetName(c)
output.GetPointData().AddArray(array_c_vtk)
else:
raise RuntimeError("Invalid action")
return 1
def RequestData(self, request, inInfo, outInfo):
logger.debug("Requesting data...")
input = self.GetInputDataObject(0, 0)
trajectory_data = dsa.WrapDataObject(input)
output = dsa.WrapDataObject(vtkPolyData.GetData(outInfo))
# Shallow-copy input trajectory data to output
output.ShallowCopy(input)
# Retrieve current time
time = timesteps_util.get_timestep(self, logger=logger)
# Add age data to the points
age = time - trajectory_data.PointData["Time"]
age_vtk = vtknp.numpy_to_vtk(age, deep=True)
age_vtk.SetName("Age")
output.GetPointData().AddArray(age_vtk)
return 1
def numpy_to_image(numpy_array):
"""Convert a numpy 2D or 3D array to a vtkImageData object.
numpy_array
2D or 3D numpy array containing image data
return
vtkImageData with the numpy_array content
"""
try:
import numpy
except:
paraview.print_error("Error: Cannot import numpy")
shape = numpy_array.shape
if len(shape) < 2:
raise Exception('numpy array must have dimensionality of at least 2')
h, w = shape[0], shape[1]
c = 1
if len(shape) == 3:
c = shape[2]
# Reshape 2D image to 1D array suitable for conversion to a
# vtkArray with numpy_support.numpy_to_vtk()
linear_array = numpy.reshape(numpy_array, (w*h, c))
try:
from paraview.vtk.util import numpy_support
except:
paraview.print_error("Error: Cannot import vtk.util.numpy_support")
vtk_array = numpy_support.numpy_to_vtk(linear_array)
image = vtk.vtkImageData()
image.SetDimensions(w, h, 1)
image.AllocateScalars(vtk_array.GetDataType(), 4)
image.GetPointData().GetScalars().DeepCopy(vtk_array)
return image
def RequestData(self, request, inInfo, outInfo):
logger.debug("Requesting data...")
info = outInfo.GetInformationObject(0)
logger.debug(f"Information object: {info}")
update_extents = info.Get(self.GetExecutive().UPDATE_EXTENT())
logger.debug(
f"Responsible for updating these extents: {update_extents}")
output = dsa.WrapDataObject(vtkDataSet.GetData(outInfo))
logger.info("Computing SWSH grid...")
start_time = time.time()
# Setup grid
# TODO: Take the `update_extents` into account to support rendering
# in parallel
N = self.num_points_per_dim
N_y = N // 2 if self.clip_y_normal else N
size = self.size
spacing = 2.0 * size / N
output.SetDimensions(N, N_y, N)
output.SetOrigin(*(3 * (-size, )))
output.SetSpacing(*(3 * (spacing, )))
# Compute the SWSHs on the grid
swsh_grid, r = swsh_cache.cached_swsh_grid(
size=size,
num_points=N,
spin_weight=self.spin_weight,
ell_max=self.ell_max,
clip_y_normal=self.clip_y_normal,
clip_z_normal=False,
cache_dir=self.swsh_cache_dir,
)
# Expose radial coordinate to VTK
r_vtk = vtknp.numpy_to_vtk(r, deep=False)
r_vtk.SetName("RadialCoordinate")
output.GetPointData().AddArray(r_vtk)
for l in range(abs(self.spin_weight), self.ell_max + 1):
for m in range(1, l + 1):
mode_profile = (swsh_grid[:, LM_index(l, m, 0)] +
swsh_grid[:, LM_index(l, -m, 0)])
mode_name = "Y_l{}_m{}".format(l, m)
# Expose complex field to VTK as two arrays of floats
mode_real_vtk = vtknp.numpy_to_vtk(np.real(mode_profile),
deep=True)
mode_imag_vtk = vtknp.numpy_to_vtk(np.imag(mode_profile),
deep=True)
mode_abs_vtk = vtknp.numpy_to_vtk(np.abs(mode_profile),
deep=True)
mode_real_vtk.SetName(mode_name + " Real")
mode_imag_vtk.SetName(mode_name + " Imag")
mode_abs_vtk.SetName(mode_name + " Abs")
output.GetPointData().AddArray(mode_real_vtk)
output.GetPointData().AddArray(mode_imag_vtk)
output.GetPointData().AddArray(mode_abs_vtk)
logger.info(f"SWSH grid computed in {time.time() - start_time:.3f}s.")
return 1
def execute(inputDO, selectionNode, insidednessArrayName, outputDO):
field_type = selectionNode.GetFieldType()
if field_type == selectionNode.CELL:
attributeType = vtkDataObject.CELL
elif field_type == selectionNode.POINT:
attributeType = vtkDataObject.POINT
elif field_type == selectionNode.ROW:
attributeType = vtkDataObject.ROW
else:
raise RuntimeError ("Unsupported field attributeType %r" % field_type)
# Evaluate expression on the inputDO.
# This is equivalent to executing the Python Calculator on the input dataset
# to produce a mask array.
inputs = []
inputs.append(dsa.WrapDataObject(inputDO))
query = selectionNode.GetQueryString()
# Get a dictionary for arrays in the dataset attributes. We pass that
# as the variables in the eval namespace for calculator.compute().
elocals = calculator.get_arrays(inputs[0].GetAttributes(attributeType))
if ("id" not in elocals) and re.search(r'\bid\b', query):
# Add "id" array if the query string refers to id.
# This is a temporary fix. We should look into
# accelerating id-based selections in the future.
elocals["id"] = _create_id_array(inputs[0], attributeType)
try:
maskArray = calculator.compute(inputs, query, ns=elocals)
except:
from sys import stderr
print ("Error: Failed to evaluate Expression '%s'. "\
"The following exception stack should provide additional developer "\
"specific information. This typically implies a malformed "\
"expression. Verify that the expression is valid.\n" % query, file=stderr)
raise
if not maskarray_is_valid(maskArray):
raise RuntimeError(
"Expression '%s' did not produce a valid mask array. The value "\
"produced is of the type '%s'. This typically implies a malformed "\
"expression. Verify that the expression is valid." % \
(query, type(maskArray)))
# Preserve topology. Just add the mask array as vtkSignedCharArray to the
# output.
# Note: we must force the data type to VTK_SIGNED_CHAR or the array will
# be ignored by the freeze selection operation
from paraview.vtk.util import numpy_support
output = dsa.WrapDataObject(outputDO)
if type(maskArray) is not dsa.VTKNoneArray:
if isinstance(maskArray, dsa.VTKCompositeDataArray):
for ds, array in izip(output, maskArray.Arrays):
if array is not None:
insidedness = numpy_support.numpy_to_vtk(array, deep=1, array_type=vtkConstants.VTK_SIGNED_CHAR)
insidedness.SetName(insidednessArrayName)
ds.GetAttributes(attributeType).VTKObject.AddArray(insidedness)
else:
insidedness = numpy_support.numpy_to_vtk(maskArray, deep=1, array_type=vtkConstants.VTK_SIGNED_CHAR)
insidedness.SetName(insidednessArrayName)
output.GetAttributes(attributeType).VTKObject.AddArray(insidedness)
def execute(inputDO, selectionNode, insidednessArrayName, outputDO):
field_type = selectionNode.GetFieldType()
if field_type == selectionNode.CELL:
attributeType = vtkDataObject.CELL
elif field_type == selectionNode.POINT:
attributeType = vtkDataObject.POINT
elif field_type == selectionNode.ROW:
attributeType = vtkDataObject.ROW
else:
raise RuntimeError ("Unsupported field attributeType %r" % field_type)
# Evaluate expression on the inputDO.
# This is equivalent to executing the Python Calculator on the input dataset
# to produce a mask array.
inputs = []
inputs.append(dsa.WrapDataObject(inputDO))
query = selectionNode.GetQueryString()
# Get a dictionary for arrays in the dataset attributes. We pass that
# as the variables in the eval namespace for calculator.compute().
elocals = calculator.get_arrays(inputs[0].GetAttributes(attributeType))
if ("id" not in elocals) and re.search(r'\bid\b', query):
# Add "id" array if the query string refers to id.
# This is a temporary fix. We should look into
# accelerating id-based selections in the future.
elocals["id"] = _create_id_array(inputs[0], attributeType)
try:
maskArray = calculator.compute(inputs, query, ns=elocals)
except:
from sys import stderr
print ("Error: Failed to evaluate Expression '%s'. "\
"The following exception stack should provide additional developer "\
"specific information. This typically implies a malformed "\
"expression. Verify that the expression is valid.\n" % query, file=stderr)
raise
if not maskarray_is_valid(maskArray):
raise RuntimeError(
"Expression '%s' did not produce a valid mask array. The value "\
"produced is of the type '%s'. This typically implies a malformed "\
"expression. Verify that the expression is valid." % \
(query, type(maskArray)))
# Preserve topology. Just add the mask array as vtkSignedCharArray to the
# output.
# Note: we must force the data type to VTK_SIGNED_CHAR or the array will
# be ignored by the freeze selection operation
from paraview.vtk.util import numpy_support
output = dsa.WrapDataObject(outputDO)
if maskArray is not dsa.NoneArray:
if isinstance(maskArray, dsa.VTKCompositeDataArray):
for ds, array in izip(output, maskArray.Arrays):
if array is not dsa.NoneArray:
insidedness = numpy_support.numpy_to_vtk(array, deep=1, array_type=vtkConstants.VTK_SIGNED_CHAR)
insidedness.SetName(insidednessArrayName)
ds.GetAttributes(attributeType).VTKObject.AddArray(insidedness)
else:
insidedness = numpy_support.numpy_to_vtk(maskArray, deep=1, array_type=vtkConstants.VTK_SIGNED_CHAR)
insidedness.SetName(insidednessArrayName)
output.GetAttributes(attributeType).VTKObject.AddArray(insidedness)
