`vtkmodules.util.functions`#

Algorithm module for the new VTK array types.

This module provides algorithms (reductions, VTK filter wrappers, vector/matrix ops, cell quality metrics) that work with the new array mixin classes (VTKAOSArray, VTKSOAArray, VTKAffineArray, VTKConstantArray, VTKPartitionedArray).

It is a self-contained reimplementation of the functionality in the three legacy modules (internal_algorithms, numpy_algorithms, algorithms) from numpy_interface/, using:

VTKPartitionedArray instead of dsa.VTKCompositeDataArray
NoneArray from utils.py instead of dsa.NoneArray
Lowercase properties (.dataset, .association, .arrays)
No dsa.vtkDataArrayToVTKArray() wrapping — the override mechanism handles types automatically.

The old modules remain in place for backward compatibility with dataset_adapter.

Module Contents#

Functions#

`_to_vtk_array`	Wrap a numpy result as a VTK array, copying metadata from source.
`_apply_func2`	Apply func to each block of a VTKPartitionedArray. Returns a list.
`apply_ufunc`	Apply a unary function to each block of a VTKPartitionedArray. Plain arrays and NoneArray are also supported.
`apply_dfunc`	Apply a binary function across composite / plain arrays.
`_make_ufunc`	Factory: wrap a unary function for composite dispatch.
`_make_dfunc`	Factory: wrap a binary function for composite dispatch.
`_make_dsfunc`	Factory: wrap a (array, dataset) function for composite dispatch.
`_make_dsfunc2`	Factory: wrap a (dataset) function for composite dispatch.
`_lookup_mpi_type`
`_reduce_dims`
`global_func`	Reduction driver with MPI parallel support.
`_local_array_count`
`array_count`	Count elements in a VTK or NumPy array, with MPI support.
`_cell_derivatives`
`_cell_quality`
`_matrix_math_filter`
`_sum`
`_max`
`_min`
`_all`
`_mean`
`_var`
`_cross`
`_dot`
`_mag`
`_matmul`
`_norm`
`_det`
`_eigenvalue`
`_eigenvector`
`_inv`
`_trace`
`_curl`
`_gradient`
`_divergence`
`_laplacian`
`_strain`
`_area`
`_aspect`
`_aspect_gamma`
`_condition`
`_diagonal`
`_jacobian`
`_max_angle`
`_min_angle`
`_shear`
`_skew`
`_volume`
`_surface_normal`
`_vertex_normal`
`_make_vector`
`sum`	Composite + MPI aware sum.
`max`	Composite + MPI aware max.
`min`	Composite + MPI aware min.
`all`	Composite + MPI aware all.
`mean`	Composite + MPI aware mean.
`var`	Composite + MPI aware variance.
`std`	Composite + MPI aware standard deviation.
`make_vector`	Composite-aware vector construction from 2 or 3 scalar arrays.
`make_mask_from_NaNs`	Create a ghost array from NaN values.
`make_point_mask_from_NaNs`	Create a ghost array for point data with NaN values.
`make_cell_mask_from_NaNs`	Create a ghost array for cell data with NaN values.
`_global_per_block`
`sum_per_block`	Per-block sum with MPI support.
`count_per_block`	Per-block count with MPI support.
`mean_per_block`	Per-block mean with MPI support.
`max_per_block`	Per-block max with MPI support.
`min_per_block`	Per-block min with MPI support.
`unstructured_from_composite_arrays`	Create a vtkUnstructuredGrid from VTKPartitionedArrays.

API#

vtkmodules.util.functions._builtin_min#: None

vtkmodules.util.functions._builtin_max#: None

vtkmodules.util.functions._builtin_sum#: None

vtkmodules.util.functions._builtin_all#: None

vtkmodules.util.functions._to_vtk_array(result, source)#

Wrap a numpy result as a VTK array, copying metadata from source.

If result is an ndarray whose first dimension matches source, creates a VTK-backed array with association/dataset propagated. Returns the result unchanged for scalars, 0-d arrays, or mismatched shapes.

vtkmodules.util.functions._apply_func2(func, array, args)#: Apply func to each block of a VTKPartitionedArray. Returns a list.

vtkmodules.util.functions.apply_ufunc(func, array, args=())#: Apply a unary function to each block of a VTKPartitionedArray. Plain arrays and NoneArray are also supported.

vtkmodules.util.functions.apply_dfunc(dfunc, array1, val2)#: Apply a binary function across composite / plain arrays.

vtkmodules.util.functions._make_ufunc(ufunc)#: Factory: wrap a unary function for composite dispatch.

vtkmodules.util.functions._make_dfunc(dfunc)#: Factory: wrap a binary function for composite dispatch.

vtkmodules.util.functions._make_dsfunc(dsfunc)#: Factory: wrap a (array, dataset) function for composite dispatch.

vtkmodules.util.functions._make_dsfunc2(dsfunc)#: Factory: wrap a (dataset) function for composite dispatch.

vtkmodules.util.functions._lookup_mpi_type(ntype)#

vtkmodules.util.functions._reduce_dims(array, comm)#

vtkmodules.util.functions.global_func(impl, array, axis, controller)#: Reduction driver with MPI parallel support.

vtkmodules.util.functions._local_array_count(array, axis)#

vtkmodules.util.functions.array_count(array, axis, controller)#: Count elements in a VTK or NumPy array, with MPI support.

vtkmodules.util.functions._cell_derivatives(array, dataset, attribute_type, filter)#

vtkmodules.util.functions._cell_quality(dataset, quality)#

vtkmodules.util.functions._matrix_math_filter(array, operation)#

vtkmodules.util.functions._sum(array, axis=None)#

vtkmodules.util.functions._max(array, axis=None)#

vtkmodules.util.functions._min(array, axis=None)#

vtkmodules.util.functions._all(array, axis=None)#

vtkmodules.util.functions._mean(array, axis=None)#

vtkmodules.util.functions._var(array, axis=None)#

vtkmodules.util.functions._cross(x, y)#

vtkmodules.util.functions._dot(a1, a2)#

vtkmodules.util.functions._mag(a)#

vtkmodules.util.functions._matmul(a, b)#

vtkmodules.util.functions._norm(a)#

vtkmodules.util.functions._det(array)#

vtkmodules.util.functions._eigenvalue(array)#

vtkmodules.util.functions._eigenvector(array)#

vtkmodules.util.functions._inv(array)#

vtkmodules.util.functions._trace(array)#

vtkmodules.util.functions._curl(array, dataset=None)#

vtkmodules.util.functions._gradient(array, dataset=None)#

vtkmodules.util.functions._divergence(array, dataset=None)#

vtkmodules.util.functions._laplacian(array, dataset=None)#

vtkmodules.util.functions._strain(array, dataset=None)#

vtkmodules.util.functions._vorticity#: None

vtkmodules.util.functions._area(dataset)#

vtkmodules.util.functions._aspect(dataset)#

vtkmodules.util.functions._aspect_gamma(dataset)#

vtkmodules.util.functions._condition(dataset)#

vtkmodules.util.functions._diagonal(dataset)#

vtkmodules.util.functions._jacobian(dataset)#

vtkmodules.util.functions._max_angle(dataset)#

vtkmodules.util.functions._min_angle(dataset)#

vtkmodules.util.functions._shear(dataset)#

vtkmodules.util.functions._skew(dataset)#

vtkmodules.util.functions._volume(dataset)#

vtkmodules.util.functions._surface_normal(dataset)#

vtkmodules.util.functions._vertex_normal(dataset)#

vtkmodules.util.functions._make_vector(ax, ay, az=None)#

vtkmodules.util.functions.sum(array, axis=None, controller=None)#: Composite + MPI aware sum.

vtkmodules.util.functions.max(array, axis=None, controller=None)#: Composite + MPI aware max.

vtkmodules.util.functions.min(array, axis=None, controller=None)#: Composite + MPI aware min.

vtkmodules.util.functions.all(array, axis=None, controller=None)#: Composite + MPI aware all.

vtkmodules.util.functions.mean(array, axis=None, controller=None, size=None)#: Composite + MPI aware mean.

vtkmodules.util.functions.var(array, axis=None, controller=None)#: Composite + MPI aware variance.

vtkmodules.util.functions.std(array, axis=None, controller=None)#: Composite + MPI aware standard deviation.

vtkmodules.util.functions.curl#: ‘_make_dsfunc(…)’

vtkmodules.util.functions.gradient#: ‘_make_dsfunc(…)’

vtkmodules.util.functions.divergence#: ‘_make_dsfunc(…)’

vtkmodules.util.functions.laplacian#: ‘_make_dsfunc(…)’

vtkmodules.util.functions.strain#: ‘_make_dsfunc(…)’

vtkmodules.util.functions.vorticity#: ‘_make_dsfunc(…)’

vtkmodules.util.functions.area#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.aspect#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.aspect_gamma#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.condition#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.diagonal#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.jacobian#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.max_angle#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.min_angle#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.shear#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.skew#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.volume#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.det#: ‘_make_ufunc(…)’

vtkmodules.util.functions.determinant#: None

vtkmodules.util.functions.eigenvalue#: ‘_make_ufunc(…)’

vtkmodules.util.functions.eigenvector#: ‘_make_ufunc(…)’

vtkmodules.util.functions.inv#: ‘_make_ufunc(…)’

vtkmodules.util.functions.inverse#: None

vtkmodules.util.functions.trace#: ‘_make_ufunc(…)’

vtkmodules.util.functions.cross#: ‘_make_dfunc(…)’

vtkmodules.util.functions.dot#: ‘_make_dfunc(…)’

vtkmodules.util.functions.matmul#: ‘_make_dfunc(…)’

vtkmodules.util.functions.mag#: ‘_make_ufunc(…)’

vtkmodules.util.functions.norm#: ‘_make_ufunc(…)’

vtkmodules.util.functions.surface_normal#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.vertex_normal#: ‘_make_dsfunc2(…)’

vtkmodules.util.functions.make_vector(arrayx, arrayy, arrayz=None)#: Composite-aware vector construction from 2 or 3 scalar arrays.

vtkmodules.util.functions.make_mask_from_NaNs(array, ghost_array=NoneArray, is_cell=False)#: Create a ghost array from NaN values.

vtkmodules.util.functions.make_point_mask_from_NaNs(dataset, array)#: Create a ghost array for point data with NaN values.

vtkmodules.util.functions.make_cell_mask_from_NaNs(dataset, array)#: Create a ghost array for cell data with NaN values.

vtkmodules.util.functions._global_per_block(impl, array, axis=None, controller=None)#

vtkmodules.util.functions.sum_per_block(array, axis=None, controller=None)#: Per-block sum with MPI support.

vtkmodules.util.functions.count_per_block(array, axis=None, controller=None)#: Per-block count with MPI support.

vtkmodules.util.functions.mean_per_block(array, axis=None, controller=None)#: Per-block mean with MPI support.

vtkmodules.util.functions.max_per_block(array, axis=None, controller=None)#: Per-block max with MPI support.

vtkmodules.util.functions.min_per_block(array, axis=None, controller=None)#: Per-block min with MPI support.

vtkmodules.util.functions.unstructured_from_composite_arrays(points, arrays, controller=None)#: Create a vtkUnstructuredGrid from VTKPartitionedArrays.

`_builtin_min`
`_builtin_max`
`_builtin_sum`
`_builtin_all`
`_vorticity`
`curl`
`gradient`
`divergence`
`laplacian`
`strain`
`vorticity`
`area`
`aspect`
`aspect_gamma`
`condition`
`diagonal`
`jacobian`
`max_angle`
`min_angle`
`shear`
`skew`
`volume`
`det`
`determinant`
`eigenvalue`
`eigenvector`
`inv`
`inverse`
`trace`
`cross`
`dot`
`matmul`
`mag`
`norm`
`surface_normal`
`vertex_normal`

vtkmodules.util.functions#

Module Contents#

Functions#

Data#

API#

`vtkmodules.util.functions`#