Documentation / paraview-operation-reference.md
Core 11629ae · View or edit Markdown on GitHub ↗

ParaView adaptor: complete operation reference

Generated from the current installed declarations and conceptual guidance on 2026-10-10. Regenerate with PYTHONPATH=src python3 tools/generate_paraview_guide.py from the repository root.

645 operation identifiers. This lists every registered input, option (including nested proxy choices), declared command, output kind and coverage gap. Native selection descriptions retain their provenance in native-context.json; the ParaView copyright notice applies.

Guide · Shared dollar syntax

Examples are syntax templates, not native acceptance fixtures. Replace placeholder strings, upstream node IDs and data-dependent settings with appropriate real values. The small values illustrate types only; array domains, scientific intent and native compatibility require planning/inspection/execution. Options without defaults deliberately preserve native initialisation. Each option row supplies an example, including optional keys. Nested proxy examples show selection syntax; their own option tables follow.

Index#

• append — Combines the meshes of several input nodes (any dataset types, non-composite) into one unstructured grid, ParaView 5.13.3's default output type for Append Datasets. Points are not merged and only point and cell arrays present on every input are kept. Use it to treat parts as one dataset for a filter or export; use appendGeometry for surfaces, group to keep inputs as separate blocks, and merge for the blocks of one composite node.
• appendGeometry — Appends several polygonal (vtkPolyData) inputs, such as surfaces, lines or point clouds, into one polydata without merging points. Only point and cell arrays common to all inputs survive. Use it to combine surface parts for a joint export or surface filter; use append for mixed dataset types.
• calculator — Evaluates a ParaView Calculator expression at every point or cell and adds the result as a new array named by result, e.g. velocity magnitude mag(U) or a non-dimensional group. The output is the input dataset type with one more array of the chosen association; existing arrays and geometry are unchanged. Use pvCalculator for coordinate results, other result types or table data.
• cellSize — Adds cell-data arrays holding the size of each cell: Length for 1-D cells (lines, polylines), Area for 2-D cells (triangles, quads, polygons) and Volume for 3-D cells, all in dataset coordinate units (length, length squared, length cubed). Cells of a dimension that is not computed get 0 in that array. Use it for cell volumes or face areas, e.g. to weight cell values or check mesh resolution; with sum enabled the totals are also stored as field data. pvCellSize exposes the same filter with every native setting, including the vertex count and array names; pvMeshQuality rates cell shape instead of size.
• cellToPoint — Interpolates cell-centred arrays to mesh points: each point receives the average of the cells that use it, producing point fields for stream tracing, contours and smooth colouring. The mesh is unchanged. Averaging smooths sharp cell-to-cell changes and blurs discontinuities such as shocks or material interfaces. Use pointToCell for the reverse.
• clean — Cleans polygonal data: merges duplicate points within a tolerance, removes unused points and turns degenerate cells into lower-dimensional ones (a triangle with two merged points becomes a line). Output is polydata. Use it after appendGeometry or on surfaces with duplicated vertices to get a connected surface for normals, curvature, connectivity or decimation. For other dataset types use cleanGrid.
• cleanGrid — Converts any dataset into an unstructured grid and merges coincident points (exactly coincident at the Schemaxis default tolerance 0), optionally removing points used by no cell (Schemaxis default true). Use it to obtain an unstructured grid for operations that need one, or to stitch appended parts. Use clean when the input is polydata and polydata output is wanted.
• clip — Cuts the input with a plane through origin with normal normal and keeps one side, returning an unstructured grid of whole and cut cells (dimension is kept, unlike slice). With the Schemaxis default invert false the kept half is the side the normal points into; true keeps the opposite side. Use it to open a volume for viewing interior fields; use pvClip for box, sphere, cylinder or scalar clips and for crinkle (whole-cell) clipping.
• cone — Creates a polygonal cone surface of given height and base radius. Its centre is the midpoint of the axis, the axis follows direction, and the apex lies on the direction side; resolution sets the number of facets around the axis and capping closes the base. Use it as a marker, glyph or simple test geometry; coordinates are in the units of the data it is shown with.
• connectivity — Labels the connected regions of the input (cells linked through shared points) and keeps all regions, the largest one (most cells) or the one closest to a point; output is an unstructured grid. With colourRegions (Schemaxis default true) a RegionId array identifies each region. Use it to separate disjoint bodies, drop small fragments or isolate the part near a location.
• contour — Extracts isosurfaces (3-D input) or isolines (2-D input) where a point-centred scalar field equals each of the given values, and outputs them as polydata; several values give several surfaces in one output. Use it for level sets such as a temperature front or a Q-criterion vortex surface. By Schemaxis default the output carries normals and the contour value as an array, but no gradients. Use pvContour for the full native settings.
• curvature — Computes per-point curvature of a polygonal surface (Gaussian or mean, the two curvature types ParaView 5.13.3 offers) as a point array such as Mean_Curvature or Gauss_Curvature. Use it to locate ridges, valleys or highly curved regions on CAD or scanned surfaces. Mean curvature is in inverse length units and Gaussian in inverse length squared; both are noisy on coarse or irregular triangulations. The mean-curvature sign assumes outward normals.
• cylinder — Creates a polygonal cylinder surface of given radius and height, centred on centre with its axis parallel to y, including point normals and texture coordinates. resolution sets the facets around the axis and capping closes both ends. There is no orientation setting: follow it with transform to rotate the cylinder.
• decimate — Reduces the triangle count of a polygonal surface by a target fraction (Schemaxis default 0.5) with vtkDecimatePro, trying to preserve shape; preserveTopology (Schemaxis default true) prevents holes and splits at the cost of possibly missing the target. Use it to lighten large surfaces for rendering or export. Input must be triangles; run triangulate first if other polygons are present.
• delaunay2D — Builds a 2-D Delaunay triangulation of the input points (any point set, e.g. a point cloud or the points of a mesh; input cells are ignored) and outputs polydata triangles. Triangulation is done in the x-y plane: z is ignored for connectivity but kept on the points, so it suits height fields and nearly planar sets aligned with x-y. With alpha 0 (Schemaxis default) every triangle of the convex hull is kept; a positive alpha keeps only triangles whose circumcircle radius is at most alpha, carving concave outlines and gaps. Use pvDelaunay2D for a best-fitting plane, and delaunay3D for tetrahedra.
• delaunay3D — Builds a 3-D Delaunay tetrahedralization of the input points (any point set) and outputs an unstructured grid of tetrahedra filling their convex hull. A positive alpha (Schemaxis default 0) produces an alpha shape: only tetrahedra whose circumsphere radius is at most alpha, plus qualifying triangles, are kept, which recovers concave shapes from point clouds. Use it to mesh scattered 3-D samples for interpolation or volume estimates; use delaunay2D for surface-like sets and pvDelaunay3D to choose which alpha cell types are output.
• disk — Creates a flat annulus (polydata) centred at the origin in the XY plane, with inner and outer radius and radial and circumferential resolution; set innerRadius to 0 for a full disc. Use it as a seed or probe surface, a marker or test geometry, and place it with transform.
• edges — Extracts every edge of every cell as a line cell, giving a wireframe polydata of the whole mesh, including interior edges of volume cells. Each shared edge appears once and receives the cell data of the lowest-numbered cell using it. Use it to show or export mesh structure or to measure edge lengths; use featureEdges for only boundary or sharp edges of a surface, and run surface first if only the outer skin's edges are wanted.
• elevation — Adds a point scalar array named Elevation: each point is projected onto the line from lowPoint to highPoint and the position along that line is mapped linearly onto range, clamped at both ends. Use it to colour by height or depth along any direction, or as a synthetic field for testing. Schemaxis assigns its defaults (z from -1 to 1 mapped to 0 to 1), so set the points to your data's extent.
• extractBlock — Extracts selected blocks from a composite dataset (multiblock, partitioned dataset collection or AMR), such as the internalMesh or individual patches of an OpenFOAM case read by foam. Blocks are chosen by selectors, path expressions over the input's block hierarchy such as "/Root/internalMesh" or "//inlet". The output keeps the composite type with only the selected blocks (overlapping AMR becomes a partitioned dataset collection). Use merge afterwards when one dataset is needed; pvExtractBlock also exposes the assembly choice.
• extractSubset — Extracts a volume of interest from structured data (image data, rectilinear or structured grid) by an IJK point-index range, optionally keeping every n-th index. The output keeps the input's structured type, so it stays compact and works with structured filters. Use it to crop a structured block or image by index; use a clip for geometric cuts or unstructured meshes.
• featureEdges — Extracts edges of a polygonal surface as line cells (polydata): boundary edges (used by one polygon), feature edges (between two polygons whose normals differ by more than angle), non-manifold edges (shared by three or more polygons) and optionally manifold edges. With the Schemaxis defaults (boundary, feature and non-manifold on, manifold off, 30°) it outlines a CAD or CFD surface's creases, open boundaries and T-junctions. Input must be polydata; run surface first on volume meshes. Use edges for every cell edge.
• foam — Curated OpenFOAM reader: opens a case through its .foam marker file and outputs a multiblock dataset whose blocks are the selected mesh regions (internalMesh volume cells, patch/<name> boundaries) carrying the selected cell fields, with one time step per stored time directory. Schemaxis defaults read a decomposed case (processor* folders), only internalMesh, and keep the 0 directory; other reader settings keep ParaView's defaults, which also create point data interpolated from the cell fields. Use pvOpenFOAMReader for point or Lagrangian fields, zones, label/scalar size or the other native options.
• generateIds — Adds arrays holding each point's and each cell's index (zero-based ids in the input), so that later clipping, extraction or merging carries the original ids along and results can be traced back to the source mesh. The geometry and type are unchanged and existing arrays are kept; each generated id array becomes that attribute's active scalars. For hyper-tree grids cell ids are always generated, and pointIds, pointName and cellIds have no effect.
• gradient — Estimates the spatial gradient of a point or cell array and stores it as a new array on the same mesh: 3 components for a scalar, 9 (row-major d(component)/d(x, y, z)) for a 3-component vector. Optionally adds divergence, vorticity and the Q-criterion of a vector field, e.g. for vortex identification. Unstructured meshes use cell derivatives, structured ones central differences. Use pvGradient for the full native settings and other output names.
• group — Combines several input nodes into one multiblock (composite) dataset, one block per input in connection order, without changing the data. Use it to process, colour or export several parts together while keeping them distinct; use append or merge when you need a single mesh.
• integrate — Integrates all point and cell arrays over the input's cells and computes the total length, area or volume, producing a one-point unstructured grid with one integrated value per array. Only cells of the highest dimension present are used (a volume mesh ignores its faces) and vertex cells are not integrated. With divideByVolume the cell-data integrals are divided by the total size, giving size-weighted means. Use it for totals such as mass or force and for mean values; results carry the array units times length, area or volume.
• line — Creates a straight polyline from start to end with resolution intervals (Schemaxis default 20, so 21 points), as a separate polydata source. Connect it to streamTracer.seed to place streamline seeds, or use it as probe geometry; it is not the velocity dataset and carries no fields. To sample fields along a segment use probeLine.
• merge — Merges every leaf dataset of a composite input (multiblock or partitioned data, e.g. the regions and patches from foam) into one unstructured grid, ParaView's default output type. Use it before operations or exports that need a single non-composite dataset. Point merging (on by Schemaxis default) fuses exactly coincident points at block interfaces so the result is connected. Use pvMergeBlocks for polydata output, a merge tolerance or partition-only merging, and append to combine separate nodes.
• normals — Computes point normals of a polygonal surface by averaging the normals of adjacent polygons, for smooth shading and for operations that need normals (warping along normals, glyphs). With splitting, points on edges sharper than featureAngle are duplicated so each side keeps its own normal; consistency reorders polygons so neighbours agree. Output is polydata with a Normals point array.
• outline — Produces the 12 edges of the input's axis-aligned bounding box as polydata lines. Use it as a context frame in scenes or to check a dataset's extent; it carries no field data.
• passArrays — Keeps only the named point, cell and field arrays of the input and removes every other array of those associations; geometry and topology are unchanged (shallow copy, so it is cheap). Use it to slim a dataset before export or publication, or to drop arrays that would confuse later steps. Each list has the Schemaxis default [], and an empty list keeps none of that association's arrays. Use pvPassArrays when vertex, edge or row (table) arrays also need selecting.
• plane — Creates a flat parallelogram (polydata) with one corner at origin and edges running to point1 and point2, subdivided into xResolution × yResolution quadrilaterals. Use it as a probe or seed surface, for example for resampling or streamline seeds, or as test geometry. The Schemaxis defaults give a 2 × 2 square in the XY plane centred at the origin, with 10 × 10 cells.
• pointToCell — Averages point arrays onto cells: each cell receives the unweighted mean of its points' values. The mesh is unchanged; only the array association changes. Use it when a later operation, a threshold or an integration needs cell data, or to compare with cell-centred solver output. Use cellToPoint for the reverse.
• probeLine — Samples the input's point and cell arrays along the segment from start to end (Plot Over Line), interpolating within cells, and outputs a polyline with the sampled arrays plus arc_length and vtkValidPointMask (1 where a sample lies inside the data). Use it for spatial profiles, e.g. velocity across a channel. ParaView's XML default sampling pattern is uniform, for which resolution (Schemaxis default 100) is the number of intervals.
• pvADIOS2CoreImageReader — Reads variables from an ADIOS2 BP file or BP4/BP5 directory as arrays on a uniform image (vtkImageData). One variable (Image Dimension) defines the image size; each selected variable becomes a point or cell array according to its shape, and an optional variable supplies the time values. Use it for simulation codes that write plain multi-dimensional arrays through ADIOS2; use pvADIOS2VTXReader when the file embeds a VTK schema and pvFidesReader when it follows a Fides data model.
• pvADIOS2VTXReader — Reads an ADIOS2 BP file or BP4 directory that embeds a VTK XML schema (VTX), either as a BP attribute or as a vtk.xml subfile, describing image data (vti) or unstructured grid (vtu) content; the output is that dataset, with time steps from the BP steps. It is a distributed reader. Choose it for codes that write VTX-annotated ADIOS2 output (e.g. via the VTX schema), and pvADIOS2CoreImageReader or pvFidesReader for other ADIOS2 layouts.
• pvAMRConnectivity — Fragment identification on non-overlapping AMR material data (such as CTH output from pvSpyPlotReader): for each selected volume-fraction cell array it labels connected regions of cells whose value exceeds VolumeFractionValue, including across block and level boundaries when ResolveBlocks is on, and adds a cell array RegionId-<array name>. The output is the same AMR data with these labels; pvAMRFragmentIntegration then sums fragment volumes and masses. Use pvAMRFragmentsFilter to run the whole chain in one step.
• pvAMRContour — AMR Contour (vtkPVAMRDualContour) extracts material interface surfaces from non-overlapping AMR volume-fraction data using the dual grid, so surfaces stay crack-free across refinement levels. For each selected cell array it outputs a block of polygonal surface at VolumeFractionValue (multiplied by 255 internally), optionally capped where the material meets the domain boundary. Use it to visualize material boundaries in CTH-style AMR data; for meshes or image data use contour.
• pvAMRDualClip — AMR Dual Clip (vtkPVAMRDualClip) clips non-overlapping AMR volume-fraction data with the dual grid and outputs, per selected material array, an unstructured grid of tetrahedra covering the region where the fraction exceeds VolumeFractionValue (multiplied by 255 internally). Level transitions are handled and interior tetrahedra can be decimated to keep the mesh small. Use it to get a volumetric mesh of a material region; use pvAMRContour for its surface only.
• pvAMRFragmentIntegration — Integrates fragments previously labelled by pvAMRConnectivity: for each material array it reads the RegionId-<array name> cell labels and outputs a table (one block per material in a multiblock) with "Fragment ID", "Fragment Volume", "Fragment Mass" and one "Volume Weighted <name>" or "Mass Weighted <name>" column per selected array. Fragment volume is the volume fraction (0-255 scaled) times cell volume; mass is the sum of the chosen mass array. Use it for size and mass statistics of debris or droplets; pvAMRFragmentsFilter runs connectivity and integration together.
• pvAMRFragmentsFilter — One-step fragment analysis for non-overlapping AMR material data: it runs AMR connectivity (always resolving fragments across blocks), then fragment integration and optionally surface extraction, with one shared VolumeFractionValue. Output port 0 holds the fragment tables ("Fragment ID", "Fragment Volume", "Fragment Mass" and one "Volume Weighted <name>" or "Mass Weighted <name>" column per selected array) when IntegrateFragments is on; port 1 holds the fragment surfaces when ExtractSurface is on, made watertight by the AMR dual contour if UseWatertightSurface is set or by ExtractCTHPart otherwise. Select a port with {"node": id, "port": n}.
• pvAMRGaussianPulseSource — Generates a small synthetic overlapping AMR dataset (vtkOverlappingAMR) with two levels: a root block of 6 × 6 (× 6) points starting at (-2, -2, 0) with spacing RootSpacing, plus two refined patches. Cell arrays are "Gaussian-Pulse" = PulseAmplitude · exp(-Σ((x - origin)/width)²) and "Centroid". Use it to test AMR pipelines and readers (compare with pvXMLUniformGridAMRReader); it is not physical data.
• pvAMReXBoxLibGridReader — Reads AMReX/BoxLib plotfiles (directories named like plt00000) into a hierarchical-box (overlapping AMR) dataset of cell-centred grid variables, levels 0 to Level. Listing several plotfile directories in FileNames makes a time series. Use it for AMReX codes such as Castro, Nyx, MAESTROeX or PeleC; use pvAMReXBoxLibParticlesReader for the particles stored in the same plotfiles.
• pvAMReXBoxLibParticlesReader — Reads particles stored in AMReX plotfiles, producing point data (polydata blocks) with the selected particle components as point arrays; ParticleType names the particle container subdirectory inside each plotfile (ParaView default "particles"). It is a distributed reader. Several plotfile directories form a time series. Use pvAMReXBoxLibGridReader for the grid variables of the same plotfiles.
• pvANLHaloFinder — Cosmology halo finder from the HACC CosmoTools library (vtkPANLHaloFinder). Input is an unstructured grid of particles with point arrays vx, vy, vz and id, as read by pvGenericIOReader. It links particles closer than Linkinglength (in units of the mean interparticle spacing) into friends-of-friends halos of at least FOFparticlethreshold particles. Port 0 returns the particles with fof_halo_tag (-1 outside halos), port 1 one point per halo with mass, centre of mass, mean velocity, velocity dispersion and centre, and port 2 subhalos when FindSubhalos is on.
• pvANLSubhaloFinder — Runs the CosmoTools subhalo finder (vtkPANLSubhaloFinder) on halos already found by pvANLHaloFinder: the input is that filter's port 0 particles with vx, vy, vz, id and fof_halo_tag. Port 0 returns the particles with a subhalo_tag array (-1 outside subhalos) and port 1 one point per subhalo with mass, centre of mass, mean velocity and velocity dispersion. Mode chooses all halos, halos larger than SizeThreshold, or only the halo ids in HalosToProcess.
• pvAVSUCDReader — Reads AVS Unstructured Cell Data files (.inp, ASCII or binary) into an unstructured grid with optional point (node) and cell arrays. Several files in FileNames form a time series. Use it for meshes and results exported in AVS UCD form by FE or CFD tools.
• pvAdaptiveCosmoCore — Reads LANL cosmo-format particle data that an adaptive-sampling preprocessor split into resolution levels (vtkACosmoReader, extension .cosmo). The output is a multiblock with one block per level (block 0 empty), each holding particle unstructured grids; Level chooses how many levels to load (1 is the coarsest). Use pvCosmoReader for ordinary single-resolution cosmo or Gadget files.
• pvAdaptiveResampleToImage — Resamples any dataset onto several image (vtkImageData) blocks, output as a vtkPartitionedDataSet: a k-d tree splits the input points into at least NumberOfImages regions (rounded up to a power of two; 0 means one per MPI process, so one in serial), and each region is sampled with SamplingDimensions points, so densely populated regions get finer spacing. Points outside the input are marked invalid, as with pvResampleToImage. Use it to obtain regular grids of unevenly distributed data for volume rendering or image analysis; use pvResampleToImage for one image over the whole domain.
• pvAddFieldArrays — Deprecated name (since ParaView 5.13, removal planned for 5.14) of pvFieldArraysFromFile, with the same behaviour: the input passes through and the field-data arrays of a legacy VTK file (.vtk) are attached to it, to every block of a composite input. Use pvFieldArraysFromFile in new documents.
• pvAggregateDataset — Parallel data-movement filter: gathers the pieces of a distributed dataset onto NumberOfTargetProcesses MPI processes (ParaView default 1), leaving the other processes empty; VTK documents it for polydata and unstructured grids. Use it in MPI runs to reduce the number of pieces before writing or rendering a modest result. In a serial run there is only one process and the data pass through. Input must be a single, non-composite dataset.
• pvAlignImageOrigins — Gives every image block of a composite (multiblock or partitioned) image dataset the same origin and rewrites each block's extent relative to it, so blocks that are parts of one image share a global index space and extent-based operations such as extractSubset behave consistently across blocks. All images must have the same spacing; the shared origin is the minimum corner of all blocks, shifted so that corner gets index MinimumExtent. Point positions do not change.
• pvAngularPeriodicFilter — Rebuilds a full rotor or periodic set of sectors from a computed sector: selected blocks are copied and rotated about an axis (X, Y or Z through Center) by multiples of an angle, rotating point coordinates and 3- and 9-component arrays (vectors and tensors) consistently. Each selected leaf becomes a multipiece of rotated copies, the first being the original; with IterationMode Maximum (ParaView default) there are round(360 / angle) copies, otherwise NumberOfPeriods. The angle is RotationAngle in degrees (default 10) or read in radians from a field array. VTK supports polydata, structured and unstructured grid leaves.
• pvAnimateModes — Turns modal-analysis results, where each 'time step' of the input (e.g. Exodus) is really a mode shape, into a vibration animation: ModeShape (1-based) picks the mode, and the points are displaced by DisplacementMagnitude × cos(2π t) × the displacement vectors, with t the requested time in [0, 1]. Output keeps the input structure, has no discrete time steps and adds mode_shape field arrays. Use pvWarpByVector for a single static displacement.
• pvAnnotateAttributeData — Produces a one-cell text table showing Prefix followed by one value of an array: element ElementId of the chosen point, cell, field or row array, taken from MPI rank ProcessId. Use it to label an image with a probe value or a global quantity such as a residual. Input must be a non-composite dataset or a table; ParaView needs its Python support for this filter.
• pvAnnotateGlobalData — Turns one value of a field-data (global) array into a text table: Prefix, the value formatted with Format, then Suffix, e.g. "Value is: 1.234e+05". If the array has one entry per time step it is indexed by the current time step, so the text follows the animation. The output is a one-row text table for display as an annotation, not a dataset to process further.
• pvAnnotateSelection — Adds a string array named "Annotate Selection" to the points or cells of Input, labelling each element selected by node i of the Selection with Labels[i] and every other element with DefaultLabel. Use it to tag regions (e.g. inlet, outlet) for colouring or export. The output is the input dataset with the extra array.
• pvAnnotateTime — Source (no input) that produces a one-cell table whose Text column holds the requested animation time formatted with Format, e.g. "Time: 0.250000". It reports the time the pipeline asks it to update, not a dataset's time; when no time is requested the text is "?". Use pvAnnotateTimeFilter to label the time of a particular dataset, and pvText for fixed text.
• pvAnnotateTimeFilter — Produces a one-row text table showing the input's current time, transformed as time × Scale + Shift and formatted with an fmt-style Format such as "Time: {time:.3f} s". Use it to label animations or images with physical time. It needs a time-dependent input; pvAnnotateTime is the source variant that needs no input.
• pvAppendArcLength — Deprecated alias of pvPolylineLength: ParaView 5.13 marks AppendArcLength for removal in 5.14. It runs the same vtkAppendArcLength filter, adding a point array arc_length with the distance along each polyline from its first point (0 for points of other cell types).
• pvAppendAttributes — Combines the point and cell arrays of several inputs that share the same geometry: the output copies the first input's geometry and adds every array from all inputs. Inputs whose point or cell count differs from the first are ignored for that attribute type, and a repeated array name gets the suffix input<n>. Use it to gather fields computed on separate branches of one mesh (e.g. gradient and cellSize results) into one node; use append or pvAppendDatasets to join different meshes.
• pvAppendDatasets — Merges the meshes of several datasets into one. With OutputDataSetType Unstructured Grid (ParaView default) inputs of almost any type are appended; with Polygonal Mesh only polydata inputs are merged and the rest are left out. Only point and cell arrays present on every input are kept, and coincident points are not merged. Use it to combine separate nodes, e.g. two clipped regions; append is the curated equivalent, pvAppendGeometry keeps polydata, and merge or pvMergeBlocks flatten one composite input.
• pvAppendGeometry — Appends several polygonal datasets (vtkPolyData) into one polydata, keeping vertices, lines, polygons and strips; only arrays present on every input survive and points are not merged. Use it to combine surfaces or lines from several nodes while staying polydata, e.g. for a surface writer; appendGeometry is the curated equivalent and pvAppendDatasets accepts mixed types.
• pvAppendLocationAttributes — Adds point coordinates and cell centres as data arrays: PointLocations (3-component point array, a copy of each point's coordinates) and CellCenters (3-component cell array). Geometry and existing arrays are unchanged. Use it when a calculator, export or table needs coordinates as ordinary arrays, e.g. to compute a radius or write x, y, z to CSV. This is the old name of the same ParaView filter.
• pvAppendMolecule — Appends one or more molecules (vtkMolecule) into a single molecule containing all atoms and bonds with their atom and bond data. The inputs must carry the same data arrays (same number and names). Use it to assemble a system from several molecule readers or pvConvertIntoMolecule nodes before bonding, rendering or export.
• pvAppendReduce — Parallel data-movement filter (vtkReductionFilter with vtkAppendFilter as the post-gather helper): it gathers the pieces of a distributed dataset from all MPI processes and appends them into one unstructured grid on one process or on every process. Use it in MPI runs when a later step needs the whole dataset in one place; in a serial run there is only process 0, so it just appends the single piece. Input must be a non-composite vtkDataSet. To combine separate nodes use append or merge.
• pvAppendSelections — Combines several selections (vtkSelection), for example ID, block and threshold selections, into one (vtkAppendSelection). With no Expression the inputs are joined with OR; with an Expression such as "(A|B)&!C" the inputs, named by SelectionNames in input order, are combined with | (or), & (and), ^ (xor) and ! (not). InsideOut inverts the result. A selection is not a dataset: connect it to the Selection input of pvExtractSelection, pvPlotSelectionOverTime or pvAnnotateSelection; it cannot be published as geometry.
• pvArrow — Creates a 3-D arrow of total length 1 along +x from the origin: a cylindrical shaft joined to a conical tip, as polydata without normals. Use it as a glyph shape or annotation; scale and orient it with a transform, or use pvGlyph to place many arrows on vector data.
• pvAxes — Creates three line segments along the x, y and z directions from Origin, as polydata with normals and a point scalar "Axes" (0 on the x line, 0.25 on y, 0.5 on z), so colouring by that array distinguishes the axes. Each line has length ScaleFactor, or runs from -ScaleFactor to +ScaleFactor when Symmetric is true. Use it as an orientation reference in a scene.
• pvAxisAlignedSlice — Slices hyper tree grids and overlapping AMR data with an axis-aligned plane while keeping the input type, so a 3-D hyper tree grid becomes 2-D hyper tree grids. For hyper tree grids each entry of OffsetValues gives one slice and the output is a partitioned dataset collection; for AMR one slice at the plane is produced, at resolution Level. Use slice or pvSlice for ordinary meshes.
• pvBDFReader — Reads a Nastran Bulk Data File (.bdf) in free-field format into an unstructured grid. Only a small subset of entries is understood: GRID points, CTRIA3 triangles, PLOAD2 pressure loads (a cell array) and TITLE and TIME (field data); other entries such as CQUAD4 or CTETRA are skipped with a warning listing them. Use it for triangulated Nastran surfaces with pressure loads, not for general finite-element models.
• pvBYUReader — Reads Movie.BYU geometry files (.g) into polydata made of polygons. Use it for legacy surface models in this format; companion displacement, scalar or texture files supported by vtkBYUReader are not exposed by the ParaView proxy, so only the geometry is read.
• pvBlockIds — Adds a cell array named BlockIdScalars to every block of a multiblock dataset, holding the index of the block (unsigned char), so blocks can be coloured, thresholded or counted by block. The input must be a vtkMultiBlockDataSet; structure and other arrays are unchanged. Use extractBlock to keep selected blocks instead.
• pvBlockScalars — Adds a cell array named BlockIdScalars to every block of a multiblock dataset, holding the index of the block (unsigned char), so blocks can be coloured, thresholded or counted by block. The input must be a vtkMultiBlockDataSet; structure and other arrays are unchanged. This is the old name of the same ParaView filter.
• pvBlockSelectionSource — Creates a block selection: a vtkSelection naming whole blocks of a composite dataset by their flat (composite) index, so pvExtractSelection keeps just those blocks. Choose it when you know the numeric block indices; pvBlockSelectorsSelectionSource selects blocks by path, which is more robust, and extractBlock or pvExtractBlock extract blocks directly without a selection. A selection is not a dataset: connect it to the Selection input of pvExtractSelection, pvPlotSelectionOverTime or pvAnnotateSelection; it cannot be published as geometry.
• pvBlockSelectorsSelectionSource — Creates a block selection from selector paths (vtkPVSelectionSource with BLOCK_SELECTORS content): XPath-style expressions such as "/Root/internalMesh" or "//patch" evaluated against a data assembly of the composite dataset, by default ParaView's Hierarchy. Choose it over pvBlockSelectionSource when block names are known but indices may change. A selection is not a dataset: connect it to the Selection input of pvExtractSelection, pvPlotSelectionOverTime or pvAnnotateSelection; it cannot be published as geometry.
• pvBoundaryMeshQuality — Extracts the boundary faces of a volume mesh as polydata and, for each face, measures its relation to the volume cell it belongs to: DistanceFromCellCenterToFaceCenter, DistanceFromCellCenterToFacePlane (both in dataset length units) and AngleFaceNormalAndCellCenterToFaceCenterVector in degrees. Use it to inspect near-wall cell size and skewness, e.g. first-cell height on CFD walls. Input must be a volumetric grid (unstructured, structured, rectilinear or image data); use pvMeshQuality for whole-cell shape metrics.
• pvBoundingRuler — Creates a line along the input's bounding box, along X, Y or Z, or along an oriented bounding-box axis, so its length is the extent of the data along that axis. ParaView displays it as a measured ruler; in Schemaxis the output is a polydata line that can be rendered or measured. Use pvRuler for a ruler between two chosen points.
• pvBox — Creates an axis-aligned box as polydata with normals and texture coordinates: six quadrilateral faces centred at Center with edge lengths XLength, YLength and ZLength. Use it as reference geometry, a bounding region or a simple test surface. For a box defined by minimum and maximum corners as a wireframe use pvOutlineSource.
• pvCGNSSeriesReader — Reads CFD General Notation System files (.cgns, ADF or HDF5 based) into a multiblock dataset organized by base and zone: each zone becomes a structured or unstructured grid and, with LoadPatches, its boundary-condition patches are added beside the volume mesh. Field arrays come from FlowSolution_t nodes as point, cell or face data, and several files in FileNames form a time series. Choose it for general CGNS solver output; use pvIOSSReader for CGNS files that the IOSS library supports, and pvCONVERGECFDCGNSReader for CONVERGE CGNS post files with parcels.
• pvCMLMoleculeReader — Reads a Chemical Markup Language file (.cml, an XML description of atoms and bonds) into a vtkMolecule: atoms with element numbers and 3-D positions plus the bonds between them. vtkMolecule is not a mesh, so most dataset filters do not accept it; use pvMoleculeToLines to obtain polydata, or pvComputeMoleculeBonds to derive bonds. Use pvXYZReader or pvPDBReader for those formats.
• pvCONVERGECFDCGNSReader — Reads CONVERGE CFD post-processing files written in CGNS (.cgns): the volume mesh, surfaces and parcels (Lagrangian spray or particle data stored in PARCEL_DATA UserDefinedData_t nodes) into a partitioned dataset collection with mesh and parcel datasets. Parcels become point clouds whose arrays are chosen in ParcelArrayStatus. Several files in FileNames form a time series. Use pvCONVERGECFDReader for CONVERGE HDF5 (.h5) post files and pvCGNSSeriesReader for general CGNS output.
• pvCONVERGECFDReader — Reads CONVERGE CFD HDF5 post files (.h5) into a partitioned dataset collection: each stream in the file is a top-level group holding its mesh (cell data), surfaces and parcels (point clouds of spray or particle data). The reader detects a time series from files named <prefix><zero-padded index>[_<time>].h5 next to the chosen file and takes each file's time from its metadata. Use pvCONVERGECFDCGNSReader for CONVERGE output written as CGNS.
• pvCSVReader — Reads delimited text (.csv, .tsv, .txt) into a table (vtkTable): one column per field, typed as numbers when DetectNumericColumns is on (ParaView default), with the first line as column names by default. The ParaView XML calls the output a 1-D rectilinear grid, but the underlying vtkDelimitedTextReader produces a table. Use pvTableToPoints or pvTableToStructuredGrid to turn coordinate columns into geometry; several files form a time series.
• pvCalculator — Full native Calculator: evaluates an expression over point, cell, row or other attribute arrays and stores the result as a new array of a chosen numeric type, or, with CoordinateResults, as new point coordinates (moving the mesh), or as normals or texture coordinates. Output has the input's data type. Use calculator for the common point/cell array case.
• pvCellCenters — Replaces each cell by a point at its parametric centre and outputs polygonal data; the input cell arrays become point arrays on those points. Use it to place glyphs or labels per cell, to probe or export cell-centred solver values as a point cloud, or as seeds. With VertexCells on, a vertex cell is added per point so the points render and count as cells. pvCoordinates instead keeps the mesh and adds centres as an array.
• pvCellDatatoPointData — Converts cell-centred arrays to point-centred arrays by averaging, at each point, the values of the cells that use it; the output has the same dataset type. Needed before operations that require point data, such as contouring, streamline tracing or smooth colouring of solver results stored per cell. It is the native filter behind cellToPoint, which keeps the cell data by Schemaxis default; pvCellDatatoPointData keeps ParaView's defaults, which convert all arrays and drop the original cell arrays.
• pvCellGridElevation — Adds a scalar attribute (default name Elevation) to a cell grid (vtkCellGrid) measuring distance from Origin: along Axis for Planar distance (ParaView default), from the line through Origin along Axis for Cylindrical distance, or from Origin itself for Spherical distance. Shock adds an offset that makes the field jump between cells, intended to demonstrate discontinuous Galerkin (DG) cells. Use it on cell-grid data from pvConvertToCellGrid or pvIOSSCellGridReader; for ordinary datasets use elevation or pvElevation.
• pvCellGridProbe — Probes a cell grid (Source port, vtkCellGrid) at the points of a polydata (Input port): the output polydata keeps the probe points that lie inside cells of the cell grid, with the chosen cell-grid attribute interpolated to them. A point inside several overlapping cells, typically on a shared boundary, appears once per cell. Use it to sample DG or other cell-grid fields along lines or at locations; for ordinary datasets use resample, pvResampleWithDataset or probeLine.
• pvCellSize — Full native Cell Size filter: adds cell-data arrays with the point count of 0-D cells (VertexCount), the length of 1-D cells (Length), the area of 2-D cells (Area) and the volume of 3-D cells (Volume), in dataset coordinate units. Cells of other dimensions get 0 in each array. With ComputeSum the totals per array are also stored as one-value field-data arrays of the same names; for composite input the top-level output holds the sum over all blocks. Use it instead of cellSize when you need custom array names or to switch off the vertex count.
• pvCesium3DTilesReader — Reads a Cesium 3D Tiles tileset (the tileset .json file and the glTF, GLB or B3DM tiles it references) into a partitioned dataset collection with one partitioned dataset per tile. Coordinates stay in the tileset's Cartesian frame, typically Earth-centred metres for georeferenced city or terrain models. Use it to bring photogrammetry or city meshes into a pipeline; Level chooses how deep in the tile tree to read.
• pvCityGMLReader — Reads a CityGML (.gml) city model into a multiblock dataset: top-level blocks per CityGML element type (buildings, roads, water bodies, vegetation …) labelled by an element field array, with polygonal leaves carrying a gml_id field array and, when textured, tcoords and a texture_uri. Only the chosen level of detail (LOD) is read. Use it for urban geometry, e.g. as obstacles for wind or dispersion studies.
• pvClean — Cleans polygonal data: merges duplicate or nearby points, removes unused points and converts degenerate cells to lower-dimensional forms (a triangle with two merged points becomes a line, a zero-length line a point). Use it before operations that need connected topology, such as featureEdges, normals, pvDecimate or connectivity, on surfaces with duplicated vertices (STL, per-face exports). clean is the curated version; cleanGrid handles unstructured grids.
• pvCleanCellstoGrid — Removes duplicate cells (cells using the same set of points) from an unstructured grid and repairs cells that reference the same point more than once; the output is an unstructured grid. Use it after merging meshes or importing data with repeated elements. It assumes duplicate points were merged already, so run pvCleantoGrid first.
• pvCleantoGrid — Merges coincident or nearly coincident points and converts any dataset to an unstructured grid, e.g. to join blocks that share faces or to feed an operation that needs unstructured input. Merging uses Tolerance (fraction of the bounding-box diagonal) or AbsoluteTolerance, and PointDataWeightingStrategy decides how data on merged points is combined. Use cleanGrid for the common case with Schemaxis defaults.
• pvClientServerMoveData — ParaView-internal helper that copies data from the server's root process to the client in a client-server session; without a remote connection it is a pass-through filter. Because the receiving side must create its output before data arrive, the output type is fixed by OutputDataType (and image extent by WholeExtent) rather than taken from the input. It has no analysis value in a Schemaxis pipeline; use passArrays or no filter at all.
• pvClip — Full native Clip: cuts the input with an implicit function chosen in ClipType (Plane, Box, Sphere, Cylinder) or with a scalar iso-value (ClipType Scalar plus Scalars and Value) and keeps one side, returning an unstructured grid. Crinkleclip keeps whole cells instead of cutting them. HyperTreeGridClipper replaces ClipType for hyper-tree-grid input. Use clip for a simple plane clip with Schemaxis defaults.
• pvClipClosedSurface — Clips a closed, manifold polygonal surface with a plane and caps the cut with new faces, so the result is again a closed (watertight) surface, e.g. to cut a CAD solid or an STL body and still compute its volume. Output is polydata; GenerateCellOrigins can add cell scalars that distinguish original faces from cap faces. Use clip or pvClip for volume meshes.
• pvColorByArray — Converts one single-component point array of an image (vtkImageData) into colour values by passing it through a lookup table, producing image data whose scalars are unsigned char luminance, luminance-alpha, RGB (ParaView default) or RGBA tuples. Connect the LookupTable input to a lookup-table resource node such as pvResourcePVLookupTable; its value range and colours decide the mapping. Use it to bake a colour map into image data, e.g. before writing a PNG with pvWritePNGWriter; for on-screen colouring use scene appearance settings instead.
• pvCompositeCellGridReader — Reads cell-grid data (.dg JSON files, e.g. discontinuous Galerkin or other high-order results) into a partitioned dataset collection of vtkCellGrid objects, keeping only the selected cell types and cell attributes. Cell grids store fields with their own interpolation rules rather than as ordinary point or cell arrays, so only filters that support vtkCellGrid accept the output directly. It is a distributed reader.
• pvCompositeDataIDSelectionSource — Creates an ID selection for composite data (multiblock or AMR): each entry names a block by flat index, a process (piece) and an element id within that block, interpreted as cell or point ids according to FieldType. Use it to pick specific cells or points in specific blocks, for example probe cells reported by an earlier run. For non-composite data use pvIDSelectionSource. A selection is not a dataset: connect it to the Selection input of pvExtractSelection, pvPlotSelectionOverTime or pvAnnotateSelection; it cannot be published as geometry.
• pvComputeConnectedSurfaceProperties — Deprecated alias of pvConnectedSurfaceProperties (ParaView 5.13 marks it for removal in 5.14); behaviour is identical. Computes the volume, surface area and centroid of each closed object in a polygonal input, plus totals; objects are found as connected components, or taken from an object-ID cell array. Per-object results go to field data (ObjectValidity, ObjectVolumes, ObjectAreas, ObjectCentroids) and per-polygon ObjectIds, Areas and Volumes to cell data. Use it to measure particles, droplets or parts in one surface mesh; use integrate for general integrals.
• pvComputeDerivatives — Computes derivatives of point data at each cell's parametric centre and stores them as cell arrays: ScalarGradient (gradient of the selected point scalar) or Vorticity as the vector output, and VectorGradient (9-component tensor) or Strain as the tensor output. Input point and cell data pass through. Use it for cell-wise gradients of point fields on any mesh; use gradient or pvGradient for point-centred gradients and Q-criterion.
• pvComputeMoleculeBonds — Adds single bonds to a molecule (vtkMolecule) from interatomic distances alone: two atoms are bonded when their distance is below the sum of their covalent radii widened by Tolerance. Valence, hybridization, aromaticity and bond order are ignored, so every bond is single. Use it when atoms come without connectivity, e.g. after pvConvertIntoMolecule or a coordinate-only reader, and follow with pvMoleculeToLines to turn the bonds into line cells.
• pvComputeQuartiles — Computes, for every single-component numeric array, the five order statistics minimum, lower quartile, median, upper quartile and maximum, and outputs them as a table (vtkTable) with one column per array and five rows. For a dataset the point-data arrays are used; a table input uses its columns, and composite input adds one column per block (suffix Block<id>). Use it for box-plot style summaries of a field's distribution; use pvHistogram for the full distribution.
• pvComputeSides — Adds arrays to a cell grid (vtkCellGrid) listing the unshared sides of its cells, i.e. external surfaces and non-conforming internal interfaces, as (cell id, side id) pairs grouped by cell type and side shape. ParaView's cell-grid representation uses these arrays to render the grid efficiently; the cells themselves are unchanged. Use it when preparing cell grids from pvConvertToCellGrid for rendering or boundary extraction.
• pvConduit — In-situ source that converts a Conduit node following the Mesh Blueprint into a VTK dataset. The node is handed over in memory by a running simulation through Catalyst, not read from a file, so a Schemaxis document cannot supply its data. Use file readers for stored results.
• pvCone — Creates a cone as polydata: a polygonal approximation with Resolution side facets, axis along Direction, height Height and base radius Radius, centred at Center (the midpoint of the axis), with the base capped by default. Use it as reference geometry or a glyph shape. The curated cone operation offers the same geometry with Schemaxis defaults and validated ranges.
• pvConnectedSurfaceProperties — Computes the volume, surface area and centroid of each closed object in a polygonal input, plus totals; objects are found as connected components, or taken from an object-ID cell array. Per-object results go to field data (ObjectValidity, ObjectVolumes, ObjectAreas, ObjectCentroids) and per-polygon ObjectIds, Areas and Volumes to cell data. Use it to measure particles, droplets or parts in one surface mesh; use integrate for general integrals.
• pvConnectivity — Finds connected regions (cells linked through shared points) and outputs an unstructured grid of all regions, the largest one (most cells) or the one closest to ClosestPoint, per ExtractionMode. With ColorRegions (ParaView default true) RegionId arrays number the regions, in the order RegionIdAssignmentMode sets. Use it to separate disjoint parts, remove small fragments or isolate one body; connectivity is the curated version with fewer settings.
• pvContingencyStatistics — Builds contingency tables (joint frequency counts) for pairs of the selected arrays, giving a bivariate probability model and the information entropy, and can assess each observation with joint and conditional probabilities and pointwise mutual information. It suits categorical or discrete variables such as material ids or flags. Output port 0 is the statistical model (a multiblock of tables) and port 1 the input with assessment arrays added; select them with {"node": id, "port": n}.
• pvContour — Full native Contour: isosurfaces or isolines of a point scalar (cell scalar for hyper tree grids) at each value in Isosurfaces, output as polydata, with options for normals, gradients, contour-value scalars, triangle output, fast mode for image data, the 3-D strategy, point precision and point merging. Use contour for the common case with Schemaxis defaults.
• pvConvertAMRdatasettoMultiblock — Converts overlapping AMR data (vtkOverlappingAMR) into a multiblock dataset whose leaves are the individual uniform-grid blocks, so filters or writers that do not understand AMR can process them. The result is a flat multiblock with one block per AMR grid, listed level by level; grids are shallow copies, so their arrays (including any blanking array) are kept, but level and refinement metadata are lost and coarse cells covered by finer levels are not removed. Use pvResampleAMR instead when you need a single uniform grid.
• pvConvertIntoMolecule — Turns a point set (polydata, unstructured grid or another vtkPointSet) into a molecule (vtkMolecule): every point becomes an atom at the same position, its element read from a one-component point array of atomic numbers, and the other point arrays become atom data. With ConvertLinesIntoBonds (ParaView default true) each line cell becomes a bond. Use it to bring particle or simulation output into the chemistry operations pvComputeMoleculeBonds, pvAppendMolecule and pvMoleculeToLines.
• pvConvertPolyhedralCells — Tries to convert polyhedron (and polygon) cells of an unstructured grid into equivalent simple cells (tetrahedron, pyramid, wedge, hexahedron) when their topology allows; cells that cannot be converted stay as they are. Output is an unstructured grid. Use it on meshes from polyhedral-capable readers such as OpenFOAM to speed up later processing and to allow operations that handle simple cells better.
• pvConvertSelection — Converts a selection (a vtkSelection on the Input port, e.g. from pvIDSelectionSource or pvLocationSelectionSource) into another content type, evaluated against the dataset on DataInput: for example cell indices become the global IDs, or the values of a named array, at those cells. The output is again a vtkSelection with no geometry; feed it to pvExtractSelection or pvAnnotateSelection. vtkConvertSelection can produce INDICES, GLOBALIDs, PEDIGREEIDS or VALUES from another type; FRUSTUM, LOCATIONS and THRESHOLDS are only accepted when the input selection already has that type.
• pvConvertToCellGrid — Converts an unstructured grid, or a composite whose leaves are unstructured grids with linear cells, into a partitioned dataset collection of cell grids (vtkCellGrid). Field-data annotations written by the IOSS reader promote certain cell arrays to spatially varying discontinuous Galerkin (DG) attributes; data without annotations is converted too. Use it before pvComputeSides, pvCellGridElevation or pvCellGridProbe.
• pvConvertToMultiBlock — Wraps any input — a single dataset, table, graph or composite — in a vtkMultiBlockDataSet: a non-composite input becomes one block, other composites keep their hierarchy, and a multiblock passes through. Use it when a later step or writer expects multiblock data, e.g. pvWriteXMLMultiBlockDataWriter; pvConvertToPartitionedDataSetCollection produces the newer partitioned format.
• pvConvertToPartitionedDataSetCollection — Converts any input to a vtkPartitionedDataSetCollection. Multiblock and AMR inputs get a data assembly that reproduces their hierarchy, so blocks can still be chosen by path with extractBlock or pvExtractBlock. Use it for steps or writers that require partitioned collections, such as pvWriteXMLPartitionedDataSetCollectionWriter; pvConvertToMultiBlock produces the older multiblock format.
• pvConvertToPointCloud — Converts any dataset into polydata that keeps only the input points and their point-data arrays; cells and cell data are dropped. CellGenerationMode decides whether the result has one vertex cell per point (ParaView default), a single polyvertex cell, or no cells at all. Use it to treat mesh nodes or particles as a point cloud, e.g. before pvPCANormalEstimation or point-based interpolation.
• pvCoordinates — Adds point coordinates and cell centres as data arrays: PointLocations (3-component point array, a copy of each point's coordinates) and CellCenters (3-component cell array). Geometry and existing arrays are unchanged. Use it when a calculator, export or table needs coordinates as ordinary arrays, e.g. to compute a radius or write x, y, z to CSV. pvCellCenters instead produces points at the cell centres.
• pvCosmoReader — Reads binary cosmology particle files in LANL cosmo format (.cosmo, .cosmo64) or Gadget-2 format (vtkPCosmoReader) into an unstructured grid of particles with point arrays velocity, mass, tag and ghost. Several file names form a time series, one file per time step. Its output is the expected input of pvLANLFOFSODHaloFinder. Use pvGenericIOReader for HACC GenericIO output.
• pvCountCellFaces — Adds a cell array (default name "Face Count") with the number of faces of each cell, as reported by VTK: 6 for a hexahedron, 4 for a tetrahedron, the face count of a polyhedron, and 0 for 2-D and lower cells, whose edges are not faces. Use it to inspect polyhedral meshes, e.g. from snappyHexMesh, or to threshold cells by face count.
• pvCountCellVertices — Adds a cell array (default name "Vertex Count") with the number of points of each cell, e.g. 3 for triangles, 8 for hexahedra and the point count of polygons and polyhedra. Use it to check mixed meshes or threshold cells by type-like size.
• pvCriticalTime — Scans every time step of a temporal input and records, for each point or cell, the first time value at which the selected array meets a threshold criterion (above, below or between thresholds; comparisons include the threshold values). The result is a static (non-temporal) dataset with one array named <array>_critical_time; other point and cell arrays are dropped, and entries whose criterion is never met are NaN. Use it for arrival or exceedance maps, e.g. when temperature first exceeds a limit. The mesh must keep the same points and cells over time.
• pvCrop — Extracts a sub-block of an image or volume (vtkImageData) given as a point-index extent [imin, imax, jmin, jmax, kmin, kmax]; the output keeps the input origin and spacing, so cropped points stay at their original positions. Use it to cut a region of interest from a large image before costly filtering or export. To cut by world coordinates or with an arbitrary shape use clip; extractSubset selects an index range with sampling rates as well.
• pvCurvature — Generated binding of ParaView's Curvature filter: computes per-point Gaussian (ParaView default) or mean curvature of a polygonal surface into the point array Gauss_Curvature or Mean_Curvature. Gaussian curvature is positive on sphere-like and negative on saddle-like regions (units 1/length²); mean curvature (1/length) assumes outward normals. Use the curated curvature (Schemaxis default Mean) for the usual case; this binding defaults to Gaussian.
• pvCylinder — Creates a cylinder as polydata with normals and texture coordinates: Resolution side facets, axis parallel to y, centred at Center, with both ends capped by default. Use it as reference geometry, e.g. a pipe or probe region. The orientation is fixed to y; rotate it with transform for other axes.
• pvD3 — Parallel repartitioning (distributed data decomposition): builds a k-d tree over the distributed dataset and redistributes cells so each MPI process owns a spatially contiguous, load-balanced region, optionally with ghost-cell layers; output is an unstructured grid. In a serial run it acts almost as a pass-through, but non-composite input is still converted to an unstructured grid. pvRedistributeDataSet is the newer alternative with more output control.
• pvDEMReader — Reads a USGS Digital Elevation Model (.dem, the ASCII DEM format) into 2-D uniform image data whose point scalars are elevations; origin and spacing come from the DEM header. Use pvWarpByScalar or warpScalar to turn it into a 3-D terrain surface.
• pvDICOMReaderSingleFile — Reads one uncompressed DICOM file (.dcm) into uniform image data with the pixel values as point scalars and the pixel spacing from the header. Use it for a single slice; for a series stored as one slice per file use pvDICOMReaderdirectory.
• pvDICOMReaderdirectory — Reads every DICOM file in one directory as the slices of a single 3-D image volume (uniform image data), the usual layout of CT and MR series. In Schemaxis, FileName must be the directory itself: the value goes straight to vtkDICOMImageReader's SetDirectoryName. Use pvDICOMReaderSingleFile for one file.
• pvDataObjectGenerator — Builds small test datasets from a text Program: atomic templates ID1 (image data), UF1 (uniform grid), RG1 (rectilinear), SG1 (structured), PD1/PD2 (polydata) and UG1 (unstructured grid), nested in composites with MB{ … } (multiblock) or HB[ … ] (hierarchical box AMR, levels in parentheses). For example "MB{ ID1 PD1 MB{} }" gives a multiblock of an image, a polydata and an empty block. Use it to exercise how a pipeline handles particular data types and composite structures.
• pvDateToNumeric — Finds string arrays holding dates (point, cell, field or table row data) and adds a numeric copy of each as <name>_numeric, in seconds since the Unix epoch, so dates can be plotted, thresholded or used in calculators. VTK tries DateFormat first, then built-in fallback formats; the format is chosen from the first value, and an array whose first value does not parse is skipped. Typical input is a CSV table read with a CSV reader.
• pvDecimate — Reduces the triangle count of a triangle surface with vtkDecimatePro, removing vertices in order of least error until TargetReduction (ParaView default 0.9, about 90 % of triangles removed) is reached. By ParaView default PreserveTopology is off, so the surface may be split along feature edges (FeatureAngle 15°) and holes may open to reach the target. Input must be triangles; run triangulate first. decimate is the curated version (Schemaxis defaults 0.5, topology preserved); pvQuadricClustering is faster on very large meshes.
• pvDecimatePolyline — Reduces the points of polylines by repeatedly deleting the interior vertex with the smallest error until TargetReduction (ParaView default 0.9) of the segments is removed or the next deletion would exceed MaximumError. The error comes from DecimationStrategy: distance of a vertex from the line through its neighbours (Decimation Distance Strategy, default), the angle at the vertex, or a custom point array. End points are kept, but closed loops can collapse to one segment. Use it to simplify streamlines, contours or GIS polylines.
• pvDeflectNormals — Tilts surface normals by a vector field: each new normal is normalize(N + ScaleFactor × V), where N is the input point normal (or the constant UserNormal) and V the selected point vector. The result is a point normal array DeflectedNormals set as the active normals; geometry is unchanged. It is a shading effect for visualizing a vector field on a surface (e.g. bump-like lighting from velocity), not a physical quantity.
• pvDelaunay2D — Full native Delaunay 2D: triangulates input points (vtkPointSet) into polydata triangles. Beyond delaunay2D it exposes ProjectionPlaneMode — XY Plane (default) ignores z, Best-Fitting Plane projects the points onto their least-squares plane first so tilted, nearly planar sets triangulate correctly — and Offset and BoundingTriangulation, which control the initial bounding triangulation. Alpha and Tolerance act as in delaunay2D (ParaView defaults 0 and 0.00001).
• pvDelaunay3D — Full native Delaunay 3D: tetrahedralizes input points (vtkPointSet) into an unstructured grid. Beyond delaunay3D it exposes which alpha-shape cell types are output when Alpha > 0 (AlphaTets and AlphaTris on, AlphaLines and AlphaVerts off by ParaView default), the Offset of the initial bounding tetrahedralization (default 2.5) and BoundingTriangulation. Alpha and Tolerance act as in delaunay3D (ParaView defaults 0 and 0.001).
• pvDescriptiveStatistics — Computes univariate statistics of each selected array: minimum, maximum, mean, raw moments, standard deviation, skewness and kurtosis. Assessment expresses each value as its number of standard deviations from the mean (signed or unsigned). Use it for summary statistics of fields over a mesh or table; counts are per point or cell, not weighted by cell size. Output port 0 is the statistical model (a multiblock of tables) and port 1 the input with assessment arrays added; select them with {"node": id, "port": n}.
• pvDisk — Creates a flat annulus (a disk with a central hole) in the x-y plane centred at the origin, as polydata made of quadrilaterals: InnerRadius to OuterRadius, divided into RadialResolution rings and CircumferentialResolution sectors. Use it as an inlet or outlet patch, seed surface or reference geometry. The curated disk operation exposes the same source with Schemaxis defaults.
• pvDistributePoints — Redistributes the points of a point set across MPI processes into spatially contiguous regions with roughly equal point counts, by recursively splitting the points in two (a k-d tree). Output is polydata containing the points and their point data but no cells; input cells are ignored. Use it in MPI runs to balance particle or point-cloud data before point-based processing.
• pvDistributedTrivialProducer — Trivial producer (vtkDistributedTrivialProducer) that takes its data from a dataset previously registered under a key by native code in the same process (SetGlobalOutput); UpdateDataset names that key. Schemaxis provides no way to register such a dataset, so in a workflow the key finds nothing and the node has no data. It exists for in-situ and embedding applications.
• pvENZOAMRParticlesReader — Reads particles from an Enzo AMR output (the .hierarchy or .boundary file of a data dump) into a multiblock dataset with one polydata block of particle points per grid. It can keep only every Frequency-th particle, particles inside a box, or one particle type (dark matter, star or tracer). Use pvEnzoReader for the gas fields of the same output.
• pvERFHDF5datareader — Reads ESI Result Format files stored in HDF5 (.erfh5), as written by ESI structural and crash solvers, into a partitioned dataset collection. A file holds stages (top-level groups; the "post" link names the default stage), each with constant data (mesh connectivity, nodes) and singlestate time states; Stages, Blocks and Variables choose what is read. Multistate data are not supported.
• pvElevation — Adds a floating-point point array named Elevation by projecting each point onto the segment from LowPoint to HighPoint and mapping its position linearly into ScalarRange: the LowPoint end gets the first value, the HighPoint end the second, and points beyond either end are clamped. Use it for height colouring, a linear test ramp or a coordinate along any direction; elevation is the curated version and pvCellGridElevation works on cell grids.
• pvEllipse — Creates an elliptical arc or full ellipse as a polyline: centred at Center, in the plane normal to Normal, with major radius given by the length of MajorRadiusVector and minor radius Ratio × major. StartAngle and SectorAngle (degrees, measured from the major axis) select part of the perimeter, and Close joins the ends. Use it for annotation, seed curves or circular probes (Ratio 1 gives a circle).
• pvEnSightMasterServerReader — Reads EnSight data written in parallel through a Server-of-Servers master file (.sos) that lists one .case file per partition; the partitions are combined into one multiblock dataset of EnSight parts with the selected node and element variables. Choose it for EnSight output split across processes; for an ordinary .case file use pvEnSightReader. It reads the time given by SetTimeValue and exposes a ByteOrder setting for binary files.
• pvEnSightReader — Reads an EnSight 6 or EnSight Gold case (.case, ASCII or binary), a post-processing format exported by many CFD and structural solvers (OpenFOAM's foamToEnsight among them). Output is a multiblock dataset with one block per EnSight part, carrying the node (point) and element (cell) variables selected in PointArrays and CellArrays; transient cases expose their time steps. Use pvEnSightMasterServerReader for a parallel .sos master file and pvWriteEnSightWriter to write EnSight.
• pvEnsembleDataReader — Reads a ParaView ensemble table (.pve): a CSV file with a header row in which each further row describes one ensemble member through parameter columns, and the last column gives that member's data file, relative to the .pve file. CurrentEnsembleMember selects which member is read; the output is whatever that file's reader produces. Use it to step through a parameter study by member number; read a member's file directly when only one is needed.
• pvEnvironmentAnnotation — Produces a text annotation stating the user name, system name, date and time and, optionally, the input's file name, for stamping provenance on images. ParaView marks its output port as text: it is an annotation, not a dataset, and the input data are not passed through. The text depends on the machine, user and run time.
• pvEnzoReader — Reads an Enzo AMR simulation output (the .hierarchy or .boundary file) into a hierarchical-box (overlapping AMR) dataset of the selected cell and point fields, refinement levels 0 to Level. ConvertToCGS optionally converts the fields from Enzo code units to CGS. Use it for Enzo gas and field data; use pvENZOAMRParticlesReader for its particles.
• pvEqualizerFilter — Applies a frequency-domain equalizer to signal columns of a table: each column is Fourier transformed, its spectrum multiplied by a piecewise-linear gain curve given in EqualizerPoints, and transformed back. Output ports: 0 the spectrum, 1 the filtered signal (Result), 2 the normalized spectrum; select one with {"node": id, "port": n}. Use it for band-pass or notch filtering of probe or sensor time series.
• pvEvenlySpacedStreamlines2D — Fills a 2-D vector field with streamlines at roughly uniform spacing (Jobard–Lefer algorithm): starting at StartPosition it integrates forward and backward, seeds new lines SeparatingDistance beside existing ones, and stops a line when it comes closer than SeparatingDistance × SeparatingDistanceRatio to another, closes a loop, leaves the domain, slows below TerminalSpeed or reaches MaximumSteps. Input must lie in the x-y plane with in-plane point vectors; output is polylines with IntegrationTime, interpolated fields and a ReasonForTermination cell array. Use it for even flow pictures of 2-D slices; streamTracer seeds from a chosen source.
• pvExodusIIReader — Reads Exodus II finite-element results (.e, .exo, .g, .ex2 …, written by SEACAS-based codes such as Sierra, MOOSE or Cubit) into a multiblock dataset of unstructured grids: element blocks, optional face and edge blocks, node, side and element sets, and global variables, with nodal and element result variables per time step. By default node positions include the displacement vector (ApplyDisplacements, scaled by DisplacementMagnitude). Use pvRestartedSimExodusReader for a restarted run described by a metadata file, or pvIOSSReader, the IOSS-based alternative.
• pvExtractAMRBlocks — Extracts chosen datasets (boxes) from an AMR input (vtkUniformGridAMR), each identified by its refinement level and its index within that level. The output is a multiblock with one block per level, each holding the extracted uniform grids as pieces. Use it to inspect or process individual AMR patches; pvConvertAMRdatasettoMultiblock or pvResampleAMR convert the whole hierarchy instead.
• pvExtractAttributes — Converts one attribute association of the input (points, cells, field data, vertices, edges or rows) into a table (vtkTable): one column per array, one row per point or cell (or other element). Composite input gives a multiblock of tables. Use it to inspect or export raw array values, e.g. as CSV through a table writer. Geometry and connectivity are dropped unless AddMetaData adds coordinates.
• pvExtractBlock — Full native Extract Block: keeps selected blocks of a multiblock, partitioned dataset collection or AMR input, chosen by Selectors (path expressions) evaluated against the data assembly named in Assembly — the block hierarchy, or an assembly supplied by readers such as IOSS or CGNS that groups blocks by meaning. The composite type is kept (overlapping AMR becomes a partitioned dataset collection). Use extractBlock when the hierarchy is enough.
• pvExtractCTHParts — Specialized for CTH shock-physics results: for each selected cell-centred volume-fraction array (VolumeArrays) it converts the array to point data and contours it at VolumeFractionValue (ParaView default 0.45), giving one material surface per array. Output is a multiblock with one polydata block per selected array, optionally clipped by a plane (ClipType, ParaView default None) and capped to look closed. Input is CTH data: non-overlapping AMR or multiblock rectilinear grids with cell data, e.g. from pvSpyPlotReader.
• pvExtractCellsAlongLine — Extracts every cell of the input that the straight segment from Point1 to Point2 intersects and outputs those cells, with their point and cell data, as an unstructured grid. Use it to inspect the actual mesh cells crossed by a probe line, for example before plotting with probeLine; probeLine instead samples interpolated values at evenly spaced points. Use pvExtractCellsAlongLinesCustomSource for polylines or several lines.
• pvExtractCellsAlongLinesCustomSource — Extracts the input cells intersected by the line and polyline cells of a second dataset (Source, polydata or unstructured grid) and outputs them as an unstructured grid. Use it with a curved or multi-segment path, e.g. a traced streamline or a polyline read from a file; for a single straight segment pvExtractCellsAlongLine is simpler.
• pvExtractCellsByRegion — Extracts the cells lying entirely inside (ParaView default) or entirely outside an implicit region — a Plane (ParaView's default choice, whose inside is the side opposite its normal), Box or Sphere — without cutting them, and outputs an unstructured grid. Extractintersected adds cells straddling the region boundary and Extractonlyintersected keeps only those. Use it to cut out a sub-volume of whole original cells; clip cuts cells exactly at the surface and slice returns the surface itself.
• pvExtractCellsByType — Keeps only the cells whose VTK cell type is listed in CellTypes, e.g. the Tetrahedron cells of a mixed mesh, or the Triangle and Quadrilateral faces of a surface. The output has the same dataset type as the input; structured inputs (image, rectilinear or structured grids) consist of one cell type, so they come through either whole or empty. Use pvExtractSelection to pick cells by ID or value instead.
• pvExtractComponent — Copies one component of a multi-component array (e.g. the z velocity Uz from U) into a new single-component array named OutputArrayName on the same points or cells; the dataset is otherwise unchanged. Use it when a later operation (contour, threshold) needs a scalar. calculator can do the same with an expression such as U_Z.
• pvExtractEdges — Native Extract Edges, the same filter as edges: every cell edge becomes a line cell in an output polydata wireframe, with shared edges emitted once and cell data copied from the lowest-numbered cell using the edge. Use edges unless you need the generated pv identifier; featureEdges or pvFeatureEdges return only boundary and sharp edges.
• pvExtractEnclosedPoints — Keeps the input points that lie inside a closed, manifold polygonal Surface (second input) and outputs them as a point cloud (polydata) on port 0; with GenerateOutliers, port 1 holds the points outside. Only points and their point data are kept, not the input's cells. Use it to select particles or probe points within a body; to keep mesh cells, use a clip instead.
• pvExtractGhostCells — Extracts only the ghost cells of the input (the overlap layers that parallel or partitioned data carry to neighbouring pieces) so they can be inspected, and records the original ghost flags in an array named ArrayName. Use it to debug decompositions or ghost-cell generation; data without ghost cells gives an empty output.
• pvExtractLocation — Looks up one point in space: in Interpolate At Location mode it outputs a single point with all data interpolated there (a probe); in Extract Cell At Location mode, the ParaView default, it outputs the cell or cells containing the location with their data. Use it for a monitoring-point value or to inspect the element at a position; use probeLine or pvPlotOverLine for lines.
• pvExtractParticlesOverTime — Finds the particles of a temporal point dataset (Particles port) that pass through a volume (Volume port, a dataset with 3-D cells) at any time step, and outputs the Particles data restricted to those particles, still time-dependent. It visits every input time step, so it can be slow. Particles are matched between steps by IdChannelArray. Use it to isolate particles crossing a region such as an inlet or a reaction zone; pvExtractCellsByRegion selects by position at one time only.
• pvExtractRegionSurface — Extracts polygonal surfaces of an unstructured grid on its outer boundary and also on internal interfaces between regions, where regions are defined by an integer cell array (RegionArrayName, ParaView default "material"). It suits multi-material meshes: each interface face is output once or once per side (SingleSided), and output faces can record their source cell (OrigCellIds) and the face of that cell (CellFaceIds). Use surface or pvExtractSurface when only the outer boundary is needed.
• pvExtractSelection — Extracts the points or cells described by a selection (Selection port, from one of the pv*SelectionSource operations or pvConvertSelection) from Input. By default the result is an unstructured grid holding only the selected elements (a table of selected rows for table input); with PreserveTopology it is a copy of the input with a vtkInsidedness array marking selected elements. Use it to isolate cells by ID, value, threshold, location, frustum or query.
• pvExtractSelectioninternal — Internal ParaView variant of Extract Selection (vtkPVExtractSelection) with three output ports: 0 the extracted dataset, 1 a selection of the extracted point/cell indices, and 2 the input selection passed through; select a port with {"node": id, "port": n}. ParaView documents it as internal and recommends Extract Selection; use pvExtractSelection unless you need the index selection on port 1.
• pvExtractSubset — Extracts a sub-block of a structured dataset (image data, rectilinear or curvilinear grid) by point-index ranges in I, J and K, optionally keeping only every n-th index; the output has the same structured type. Use it to crop or coarsen a structured grid cheaply, e.g. one K-plane of a 3-D grid. Use extractSubset for the same operation with Schemaxis defaults (includeBoundary true).
• pvExtractSubsetWithSeed — From a structured grid (vtkStructuredGrid, including multiblock structured data split across blocks or processes), extracts the grid line (I, J or K) or grid surface (IJ, JK or KI) that passes through the cell containing Seed, following it across block boundaries even when block i-j-k origins differ. Typical use: pick a point to extract a wall-normal grid line or a constant-k surface of a curvilinear CFD mesh. Output keeps the structured cells, as a partitioned dataset for a single grid or the input's composite type otherwise.
• pvExtractSurface — Extracts the outer surface of any dataset as polygonal data (vtkGeometryFilter): boundary faces of 3-D cells plus all lower-dimensional cells, with point and cell arrays carried over and internal faces removed. It is the same native filter as the curated surface operation, which has no options; choose pvExtractSurface to control nonlinear-face subdivision, fast mode, ghost-interface removal or piece invariance. For interfaces between materials use pvExtractRegionSurface.
• pvExtractTimeSteps — Restricts a time-varying input to selected time steps, given as listed zero-based indices (Select Time Steps, ParaView default) or as an inclusive index range with a stride (Select Time Range). Downstream nodes see only those steps: a request for an unselected time is answered by a selected step chosen by ApproximationMode (Nearest Time Step by default), and times outside the selection get the first or last selected step. Use it to thin a long transient before temporalStatistics or pvParticlePath, or to hold a branch at one step.
• pvFDSReader — Reads Fire Dynamics Simulator results through the Smokeview .smv file, which lists the other output files. The output is a partitioned dataset collection with five groups: Grids (meshes), Devices (point measurements over time), HRR (heat-release-rate tables), Slices and Boundaries (field data on planes and walls). AssemblySelectors chooses which of these are read. Use it for fire and smoke CFD from NIST FDS.
• pvFFTOfSelectionOverTime — ParaView's compound filter that extracts the values of selected points or cells over all time steps (as Plot Selection Over Time does) and applies a discrete Fourier transform to each resulting time series (Table FFT), producing tables for spectral plots. Connect Input to the temporal dataset and Selection to a selection-source node (e.g. pvIDSelectionSource or pvLocationSelectionSource). Use it to find dominant frequencies of probe signals such as vortex shedding; use pvPlotSelectionOverTime and pvTableFFT separately when you need the frequency column or windowing.
• pvFLASHAMRParticlesReader — Reads particles from a FLASH HDF5 checkpoint or plot file into a multiblock dataset of polydata particle points with the selected particle arrays. Frequency keeps every N-th particle and FilterLocation keeps only particles inside a box. Use pvFlashReader for the grid fields of the same FLASH output.
• pvFacetReader — Reads a Facet file (.facet): a simple ASCII format listing point coordinates and the polygons connecting them, producing polygonal data. Use it for legacy surface geometry exported in this format; for common CAD exchange use readSTL or readPLY.
• pvFastUniformGrid — Synthetic source producing a 3-D uniform grid (image data) with cheap analytic point arrays: X (the x index, active scalars), optionally DistanceSquared (squared distance from the origin) and Swirl (the vector (y, z, x)). Use it for tests, benchmarks and demonstrations that need a predictable volume of adjustable size; use wavelet for a smoothly varying scalar field.
• pvFeatureEdges — Full native Feature Edges: extracts boundary, feature, non-manifold and (optionally) manifold edges of a polygonal surface as polydata lines, with the same classes and ParaView defaults as featureEdges (boundary, feature and non-manifold on, manifold off, FeatureAngle 30°). It also exposes Coloring, which adds a cell array identifying each edge's class so the classes can be coloured or thresholded separately.
• pvFidesJSONReader — Reads ADIOS2 data through Fides using an explicit Fides data model given as a JSON file, which describes how ADIOS2 variables form coordinates, cells and fields. The data model names one or more data sources, and DataSourcePath tells the reader which BP file or stream each source is. The output is a partitioned dataset collection. ParaView marks this route as mainly for debugging data models; use pvFidesReader when the BP output carries its own Fides metadata.
• pvFidesReader — Reads ADIOS2 output through the Fides library, which maps ADIOS2 variables to meshes using a data model; for a BP file or BP4/BP5 directory written with Fides metadata the data model is found automatically. The output is a partitioned dataset collection with the selected point, cell and field arrays and the stored time steps. Use it for Fides-annotated simulation output; use pvFidesJSONReader when the data model is a separate JSON file.
• pvFieldArraysFromFile — Passes its input through unchanged and attaches the field-data arrays found in a legacy VTK file (.vtk, read with vtkDataObjectReader, e.g. a file holding a FIELD section); on a composite input every block receives them. Only field data (whole-dataset values such as run parameters, metadata or small history tables) is added, never point or cell arrays. Use it to carry case metadata alongside a mesh; for per-point or per-cell values join data with another operation instead.
• pvFieldDatatoAttribute — Copies field-data arrays (one value per dataset, e.g. a time value or a parameter stored by a reader) into point or cell arrays holding that value at every point or cell. Only the first component of the first tuple is used, stored as a constant (implicit) array, so the memory cost is small; string arrays are not supported. Use it to colour, threshold or calculate with dataset-level values alongside the fields.
• pvFiniteElementFieldDistributor — Turns element-wise finite-element coefficients into point fields for visualization: it duplicates points so each element owns its own nodes, promotes cells to higher-order Lagrange types where needed, and evaluates H(Grad) discontinuous-Galerkin scalars and H(Curl)/H(Div) vector fields at those nodes. Input must be a partitioned dataset collection whose field data has an "Information Records" string array describing bases and fields (Intrepid2 conventions, e.g. Exodus files read with the IOSS reader); the output has the same structure with the distributed point arrays.
• pvFlashReader — Reads output of the FLASH astrophysics code (HDF5 plot or checkpoint files) into an overlapping AMR (hierarchical box) dataset: nested refinement levels of uniform blocks with cell-centred variables. Level sets the finest level loaded, counted from the root level 0 (ParaView default 1), and every variable starts disabled, so name the ones you need in CellArrayStatus. Several files form a time series. For particles use pvFLASHAMRParticlesReader; to analyse on a uniform grid, follow with pvResampleToImage or pvResampleAMR.
• pvFluentCFFCaseReader — Reads ANSYS Fluent results in the HDF5-based Common Fluids Format: the case file (.cas.h5) and, automatically, the data file of the same name (.dat.h5). The output is a multiblock dataset of unstructured grids with cell-centred solution fields. Several case files form a time series. Use pvFluentCaseReader for the legacy .cas/.dat format.
• pvFluentCaseReader — Reads ANSYS Fluent legacy case files (.cas, or .msh mesh files) and the data file whose name replaces the extension with .dat, producing a multiblock dataset of unstructured grids with cell-centred fields. Several case files form a time series. Use pvFluentCFFCaseReader for the HDF5-based .cas.h5/.dat.h5 format.
• pvForceStaticMesh — Caches the geometry and topology of its input the first time it runs and keeps reusing that mesh for later time steps, updating only point, cell and field data while the point and cell counts stay the same. Use it after readers or filters that rebuild an unchanged mesh at every time step, so that downstream work depending only on the mesh need not be repeated. It handles an unstructured grid, polydata, or the first block of a composite input when that block is an unstructured grid.
• pvForceTime — Makes its output use one fixed time, ForcedTime (ParaView default 0.0), whatever time the scene requests: the upstream pipeline is updated once at ForcedTime, the result is cached, and every time step it reports is replaced by ForcedTime. Use it to hold a reference state, such as the initial geometry or a chosen snapshot, fixed while the rest of the scene follows the selected times. With IgnorePipelineTime false it passes the input through unchanged.
• pvFrustumSelectionSource — Creates a frustum selection: everything inside a convex volume bounded by six planes, given by the eight corner vertices in Frustum. This is how ParaView stores a rubber-band selection through a camera view, but any convex hexahedral region (e.g. a box) can be described. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. For an axis-aligned box clip, pvClip with a Box type is often simpler.
• pvGDALRasterReader — Reads a GIS raster (GeoTIFF, DEM, ERDAS and the other formats supported by GDAL) into a uniform grid (vtkUniformGrid, supporting blanking of no-data pixels) whose bands are cell-data arrays, one cell per raster pixel. Colour bands are by default collated into one RGB, RGBA, grey-alpha or palette array. Use it for terrain heights, satellite images or land-use maps; warp a height band with warpScalar to obtain terrain.
• pvGDALVectorReader — Reads one layer of a GIS vector file (Shapefile, GeoJSON, KML, GML, DXF and other GDAL vector formats) into polydata: points, lines and polygons with the feature attributes as cell-data arrays. By ParaView default each feature is a separate block of a multiblock dataset; AppendFeatures merges them into one polydata. Use it for outlines, roads, building footprints or measurement locations in GIS formats.
• pvGaussianCubeReader — Reads a Gaussian Cube file (.cube) produced by the Gaussian quantum-chemistry package. Output port 0 is the molecule (vtkMolecule: atoms and positions) and port 1 the gridded volumetric quantity, such as electron density or an orbital, as image data; select it with {"node": id, "port": 1} for contouring or volume rendering. Use pvXYZReader or pvPDBReader for structures without volumetric data.
• pvGaussianResampling — Splats the input points into a uniform volume (vtkImageData, point array SplatterValues): each point adds a Gaussian kernel ScaleFactor × value × exp(ExponentFactor × r² / R²) to nearby voxels within radius R, and overlapping contributions are combined by the accumulation mode (ParaView default Max). Without a selected array, or with scale splats off, each point contributes the kernel alone, giving a smooth point-density field. Use it to turn scattered particles or measurements into a continuous field for contouring or volume rendering; use pvResampleToImage to sample an existing mesh instead.
• pvGenerateGlobalIds — Deprecated alias of pvGlobalPointAndCellIds (renamed in ParaView 5.13, removal planned for 5.14): generates global point and cell ids consistent across blocks and processes and flags duplicated points as ghosts. Prefer pvGlobalPointAndCellIds for new workflows.
• pvGenerateIds — Deprecated alias of pvPointAndCellIds: ParaView 5.13 marks GenerateIdScalars for removal in 5.14, and it still runs the older vtkIdFilter. It adds zero-based point indices (PointIds) and cell indices (CellIds) as point and cell arrays. Use pvPointAndCellIds or generateIds in new workflows.
• pvGenerateProcessIds — Deprecated alias of pvProcessIds (ParaView marks GenerateProcessIds deprecated in 5.13, to be removed in 5.14): it adds PointProcessIds and/or CellProcessIds arrays giving the owning MPI process of each point or cell. Prefer pvProcessIds for new workflows; behaviour is the same.
• pvGenerateQuadraturePoints — Creates a point cloud (polydata with one vertex per quadrature point) from the selected quadrature offset array, carrying as point data the field-data arrays previously interpolated to the same offsets. The quadrature tools work in sequence: pvGenerateQuadratureSchemeDictionary adds a cell offset array QuadratureOffset carrying the quadrature rules, pvInterpolatetoQuadraturePoints evaluates point fields at the quadrature points, and pvGenerateQuadraturePoints turns them into a point cloud. Use it to view or export quadrature-point values, e.g. for finite-element verification.
• pvGenerateQuadratureSchemeDictionary — Adds a cell array QuadratureOffset (one offset per cell) whose metadata holds a quadrature-rule dictionary for each cell type, the starting point of ParaView's quadrature workflow. The quadrature tools work in sequence: pvGenerateQuadratureSchemeDictionary adds a cell offset array QuadratureOffset carrying the quadrature rules, pvInterpolatetoQuadraturePoints evaluates point fields at the quadrature points, and pvGenerateQuadraturePoints turns them into a point cloud. Rules exist only for triangles, quadratic triangles, pixels, quads, quadratic quads, tetrahedra and quadratic tetrahedra.
• pvGenerateSpatioTemporalHarmonics — Adds a point array SpatioTemporalHarmonics (set as active scalars) whose value at point x and time t is the sum over harmonics of A·sin(k·x + ω·t + φ), with t the requested pipeline time and x in dataset coordinates. It produces analytic, time-varying test fields, e.g. to check interpolation, temporal statistics or FFT workflows against known waves. This is the old name of the same ParaView filter.
• pvGenerateSurfaceNormals — Deprecated ParaView alias of pvSurfaceNormals: the PolyDataNormals proxy was renamed SurfaceNormals, deprecated in ParaView 5.13 and is scheduled for removal in 5.14. It computes point normals on polygonal surfaces for smooth shading, with exactly the settings and behaviour of pvSurfaceNormals. Prefer pvSurfaceNormals in new documents.
• pvGenerateSurfaceTangents — Deprecated alias of pvSurfaceTangents: ParaView 5.13 marks PolyDataTangents for removal in 5.14. It computes point tangents (array Tangents) of a triangulated surface from point normals and texture coordinates for normal-map rendering.
• pvGenerateTimeSteps — Passes its input through unchanged (shallow copy) but declares a new list of time steps (TimeStepValues), ignoring any time steps the input reports. Use it to give static or untimed data a time axis, so temporal filters or time-dependent scenes downstream have steps to work with. It only relabels: a request for one of the new times is passed upstream unchanged, so static input returns the same data at every step and nothing is interpolated.
• pvGenericIOMultiBlockReader — Reads HACC GenericIO particle files (.gio) into a multiblock dataset with one unstructured-grid block per block stored in the file (usually one per writing MPI rank), vtkPGenericIOMultiBlockReader. Coordinate, array and halo settings work as in pvGenericIOReader. Choose it to keep the file's decomposition, for example to read back pvWriteGenericIOWriter output; use pvGenericIOReader for a single particle grid.
• pvGenericIOReader — Reads HACC GenericIO particle files (.gio) into one unstructured grid of particles (vtkPGenericIOReader): xAxis, yAxis and zAxis name the coordinate variables, PointArrayStatus chooses the other variables to load, and HalosToLoad with HaloId can restrict reading to particles of chosen halos. Several file names form a time series. Its output suits pvANLHaloFinder; use pvGenericIOMultiBlockReader to keep the file's blocks separate and pvMultiResGenericIO for multi-resolution .gios sets.
• pvGeometryFilter — ParaView's rendering geometry extractor (vtkPVGeometryFilter): converts any dataset, including composite and nonlinear-cell data, into polydata of its outer surface or, with UseOutline, its bounding outline, adding original cell and point id arrays by default. Representations use it internally; as a pipeline node it is a robust way to get the renderable surface. For an ordinary surface use surface or pvExtractSurface.
• pvGhostCells — Generates ghost cells and points: layers of neighbouring cells copied from adjacent blocks of a partitioned dataset or from other MPI processes, marked with vtkGhostType. Supported block types are image, rectilinear, structured, polydata and unstructured grids (and hyper tree grids). Use it before filters that need neighbour information across partition boundaries, such as gradients or smoothing, so results do not show seams; remove the layers afterwards with pvRemoveGhostInformation.
• pvGhostCellsGenerator — Deprecated alias of pvGhostCells (renamed in ParaView 5.13, removal planned for 5.15): generates ghost cell and point layers between partitions and processes. Prefer pvGhostCells for new workflows; the settings are identical.
• pvGlobalIDSelectionSource — Creates a selection by global ID: the elements whose value in the input's designated global-ID array (point or cell, per FieldType) equals one of GlobalIDs. Global IDs stay the same across MPI decompositions and across composite blocks, so this is the robust way to pick the same nodes or elements in a partitioned mesh. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. Use pvIDSelectionSource for plain zero-based indices.
• pvGlobalPointAndCellIds — Assigns global point and cell ids that are unique across all blocks and MPI processes, giving the same id to points duplicated at block or process boundaries (matched within Tolerance) and marking the duplicates as ghost points. Hyper tree grids get cell ids only. Use it before operations that need consistent ids across partitions, such as ghost generation or merging; for simple local indices use generateIds or pvPointAndCellIds.
• pvGlyph — Places a copy of a glyph shape (arrow, cone, cube, cylinder, line, sphere or 2-D glyph, GlyphType) at points of the input, or at cell centres when the chosen arrays are cell data, oriented by a vector array and scaled by a scalar or vector array; output is polydata. Use it for velocity arrows or sized markers. Use pvGlyphWithCustomSource to glyph with your own geometry.
• pvGlyphWithCustomSource — Like pvGlyph, but the glyph geometry is any polydata connected to the GlyphSource input (e.g. a CAD part or a custom marker), placed at points or cell centres, oriented by a vector array and scaled by a scalar or vector array; output is polydata. Use it when the built-in shapes are not enough.
• pvGradient — Full native Gradient: estimates the gradient of a point or cell array (3 components for a scalar, 9 for a vector), optionally with divergence, vorticity and Q-criterion, and adds them as arrays on the same mesh. Extra settings cover result names, boundary treatment and dimensionality for image data, which neighbouring cells contribute, the value used where no gradient can be computed, a faster approximation, and hyper-tree-grid modes. Use gradient for the common case.
• pvGradientMagnitude — Computes the magnitude of the spatial gradient of an image's point scalars with central differences that account for the pixel spacing, giving image data of the same size (edge values use one-sided neighbours). It is the classic edge-strength image, useful to locate interfaces or fronts. Dimensionality decides whether the z derivative is included. For gradients of general meshes, or vector results, use gradient.
• pvGroupDatasets — Combines several inputs into one composite dataset, each input becoming one block: a multiblock dataset by ParaView default, or a partitioned dataset (all inputs as partitions of one block) or partitioned dataset collection. Use it to process, colour or export separate nodes together; use append or merge when you need one merged mesh instead. The curated group is the simpler alternative.
• pvGroupTimeSteps — Loads every time step of the input and returns them together as one dataset without time: a multiblock if the input is multiblock, otherwise a partitioned dataset collection, with one block per step named timestep0, timestep1, … (zero-based step index, not the time value). Use it to overlay or export all steps at once, e.g. to compare particle positions.
• pvH5PartReader — Reads H5Part particle files (.h5part, an HDF5 layout used by accelerator and plasma codes) into polydata points with the selected particle arrays; every step stored in the file becomes a time step (time values from the file, or the step index when they are missing). Coordinates come from three scalar arrays chosen by Xarray, Yarray and Zarray (by default the first of x, coords_0, coords0 and so on that exists).
• pvHDF5RageReader — Reads RAGE simulation output stored in HDF5 through an ASCII descriptor that lists the data files and the type and order of the variables (ParaView registers the .h5rage extension; the native text calls it a .pio file). The output is uniform image data with the selected variables as point arrays, one time step per data file.
• pvHDRReader — Reads a Radiance HDR image (.hdr, run-length-encoded RGBE or XYZE) into 2-D uniform image data with 32-bit floating-point colour channels, keeping the full dynamic range for analysis or image-based lighting. Use pvPNGSeriesReader or pvTIFFSeriesReader for ordinary 8- or 16-bit images.
• pvHierarchicalDataIDSelectionSource — Creates an index selection inside an AMR (overlapping AMR / hierarchical box) dataset: each entry names an AMR level, a dataset (box) within that level and a zero-based point or cell index inside that box. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. Use pvCompositeDataIDSelectionSource for multiblock data and pvIDSelectionSource for a single non-composite dataset.
• pvHierarchicalFractal — Test source that builds a refined hierarchy of uniform (or rectilinear) grid blocks around a Mandelbrot-set fractal, with a cell array scaled to look like a material volume fraction (0.5 at FractalValue). It produces a composite, AMR-like dataset and exists to exercise AMR, ghost-level and material-interface filters, not to represent physical data. For an AMR test pulse use pvAMRGaussianPulseSource; for a single-block fractal use pvMandelbrot.
• pvHistogram — Bins one component (or the magnitude) of one array into equal-width bins and outputs a table with bin_extents (bin centre positions) and bin_values (counts), plus per-bin averages of the other arrays when CalculateAverages is on. Use it to study a value distribution, e.g. of pressure or velocity magnitude over a mesh. Counts are per point or per cell, not weighted by cell size. Use pvHistogram2D for the joint distribution of two variables.
• pvHistogram2D — Builds a joint (2-D) histogram of two array components and outputs it as a 2-D image (vtkImageData) whose point scalars are the counts: X-variable bins along the image x axis, Y bins along y. By ParaView default the Y variable is the gradient magnitude of the X array, the value-versus-gradient plot used to design volume-rendering transfer functions; turn UseGradientasYAxisArray off to histogram two arbitrary arrays, e.g. temperature against pressure. Both arrays must have the same association and number of tuples. Use pvHistogram for one variable.
• pvHyperTreeGrid — Builds a hyper tree grid (vtkHyperTreeGrid), a tree-based AMR structure: a rectilinear grid of root cells, each refined recursively by a binary (BranchFactor 2) or ternary (3) subdivision described by the Descriptor string. In the descriptor, levels are separated by "|", "R" marks a refined cell and "." a leaf, e.g. "RR | .R. ... | ...". Use it to construct exact test cases for hyper-tree-grid filters; for random trees use pvHyperTreeGridRandom.
• pvHyperTreeGridAxisReflection — Mirrors a hyper tree grid (vtkHyperTreeGrid, an adaptively refined tree-based grid) across a plane perpendicular to x, y or z: PlaneNormal picks the axis and PlanePosition the plane's coordinate on it. The output holds only the mirrored grid, unlike pvReflect, which can keep the original too, and cell arrays are copied unchanged. For ordinary datasets use reflect or pvReflect.
• pvHyperTreeGridCellCenters — Produces a point cloud (polydata) with one point at the centre of each leaf cell of a hyper tree grid; the cell arrays become point arrays on those points. CreateVertexCells (ParaView default true) adds a vertex per point so the points render and count as cells. Use it for glyphs or for sampling HTG data at cell centres; for ordinary meshes use pvCellCenters.
• pvHyperTreeGridDepthLimiter — Truncates a hyper tree grid at a maximum refinement depth: cells at depth SetDepth become leaves and finer levels are dropped, giving a coarser view of an adaptively refined grid. Depth counts from 0 at the root cells; if it is at least the grid's deepest level, the output equals the input. With a material mask present, ParaView notes that the output extent can be larger than the input's.
• pvHyperTreeGridEvaluateCoarse — Recomputes the values stored on refined (coarse) cells of a hyper tree grid from their children, for every cell array, with the chosen Operator: Min, Max, Sum, Average (masked children count as Default), Unmasked Average, Elder Child (the first child's value) or Splatting Average; the Don't change options leave coarse values as they are. Leaf values are unchanged. Use it before coarse-level views such as pvHyperTreeGridDepthLimiter so coarse cells summarise their children.
• pvHyperTreeGridFeatureEdgesFilter — Generates polygonal lines along the feature edges of a hyper tree grid: the grid itself in 1-D, border edges in 2-D, and edges where faces meet at 90 degrees in 3-D, computed while traversing the trees so T-junctions between refinement levels are handled. Use it to outline HTG geometry in images; for ordinary meshes use featureEdges or pvFeatureEdges.
• pvHyperTreeGridGeometryFilter — Extracts the external surface of a hyper tree grid as polydata: segments for a 1-D grid and faces for 2-D and 3-D grids, cut along material interfaces when the grid carries them, with cell data on the output faces. Use it to render or export an HTG surface; for volume operations convert with pvHyperTreeGridToUnstructuredGrid or pvHyperTreeGridToDualGrid.
• pvHyperTreeGridGhostCellsGenerator — Generates ghost hyper trees at the interfaces between MPI processes for a distributed hyper tree grid, containing only the interface nodes and leaves. It is needed only in parallel runs before filters that use neighbour (Von Neumann or Moore) super-cursors; a serial run has no process interfaces. For ordinary datasets use pvGhostCellsGenerator.
• pvHyperTreeGridRandom — Builds a hyper tree grid (vtkHyperTreeGrid) with pseudo-random binary refinement: each node is split with probability SplitFraction down to MaxDepth, a target MaskedFraction of cells is masked, and the root grid spans OutputBounds. A "Depth" cell array records each cell's level. The same Seed reproduces the same tree. Use it to stress-test hyper-tree-grid filters; use pvHyperTreeGrid for an exactly specified tree.
• pvHyperTreeGridReader — Reads a VTK XML hypertree grid file (.htg): an adaptive tree-based mesh (vtkHyperTreeGrid) in which each coarse cell is refined recursively, typical of AMR codes. MaximumNumberOfLevels limits the refinement depth loaded and BoundingBoxByCoordinates loads only the trees touching a box, both cutting memory and read time. Several files form a time series. Use pvXMLPartitionedHyperTreeGridReader for partitioned .phtg data.
• pvHyperTreeGridToDualGrid — Converts a hyper tree grid to its dual unstructured grid: one point at the centre of each leaf cell, cells connecting neighbouring centres, and the HTG cell arrays turned into point arrays. The result works with the standard filters (contour, slice, gradient) and gives smooth point-interpolated fields, but uses much more memory than the HTG. Use pvHyperTreeGridToUnstructuredGrid to keep the original leaf cells and cell values.
• pvHyperTreeGridToUnstructuredGrid — Converts every leaf of a hyper tree grid into an explicit unstructured-grid cell (segments in 1-D, rectangles in 2-D, right hexahedra in 3-D) with the cell arrays kept. The result works with all standard filters but uses much more memory, and cells at different refinement levels meet at T-junctions (hanging nodes), so faces are not conformally connected. Use pvHyperTreeGridToDualGrid for a point-based dual mesh.
• pvHyperTreeGridVisibleLeavesSize — Adds two double cell arrays to a hyper tree grid: ValidCell, 1.0 for leaves that are neither masked nor ghost and 0.0 otherwise, and CellSize, the cell's volume in 3-D, area in 2-D or length in 1-D, derived from its refinement level. Multiplying a field by both and summing gives a size-weighted total over visible leaves, e.g. the grid's total volume. Run it again if cells are refined afterwards.
• pvIDSelectionSource — Creates an index selection: points or cells (per FieldType) chosen by their zero-based position in a single, non-composite dataset, each given with the MPI process that owns it. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. Indices change whenever the mesh or its decomposition changes; use pvGlobalIDSelectionSource for stable IDs and pvCompositeDataIDSelectionSource for multiblock data.
• pvIGESReader — Reads a IGES CAD file through OpenCASCADE and tessellates its B-rep faces into triangles, giving a multiblock dataset with one polydata block per shape (named from the file, or Unnamed) and a per-cell Colors array from the CAD colours. LinearDeflection and AngularDeflection set how closely the triangles follow curved surfaces; ReadWire adds edges as polylines. Use it to bring CAD geometry in for rendering, clipping or probing; use pvSTEPReader for .step/.stp, and readSTL or pvSTLReader for already-tessellated STL.
• pvIOSSCellGridReader — Reads IOSS databases (Exodus, including the discontinuous-Galerkin .exdg variant) into a partitioned dataset collection whose partitions are cell grids (vtkCellGrid), ParaView's representation for higher-order and DG cells with attributes defined per cell type. Use it when cell-grid filters (pvCellGridElevation, pvCellGridProbe) or high-order fields are needed; use pvIOSSReader for ordinary unstructured grids accepted by most filters.
• pvIOSSReader — Reads Exodus II and CGNS databases through Sandia's IOSS library into a partitioned dataset collection: one partitioned dataset per selected block or set, organized in an assembly by entity type. Spatially partitioned files (name.e.N.r) and restart series (name.e-s.001…) are found automatically. By default all blocks and all fields are read and sets are not. Choose it for finite-element results from Sierra, MOOSE or other Exodus writers; pvExodusIIReader is the older Exodus reader and pvCGNSSeriesReader handles CGNS files IOSS cannot open.
• pvImageDataToAMR — Converts a uniform image (vtkImageData, at least 2-D) into an overlapping AMR dataset (vtkOverlappingAMR). The input image is the finest level; coarser levels are generated from it with RefinementRatio between consecutive levels, and the hierarchy is split into at most MaximumNumberofBlocks blocks. No resolution is added. Use it to feed AMR operations such as pvExtractAMRBlocks, pvAMRContour or pvResampleAMR from image data.
• pvImageDataToUniformGrid — Converts image data (vtkImageData, or composite data whose leaves are images) into a vtkUniformGrid with blanking: a single-component point or cell array marks which points or cells are hidden. Values strictly between -1 and 1 (effectively zero) hide the element and other values keep it; Reverse swaps this. The blanking is written as a vtkGhostType array of hidden points or cells, which rendering and blanking-aware filters skip. Use it to mask solid or invalid regions of a regular grid without changing its structure.
• pvImageDatatoPointSet — Converts uniform image data (vtkImageData) into an equivalent structured grid with explicit point coordinates; point and cell arrays are kept. Use it before operations that move or need explicit points but reject image data, at the cost of storing coordinates.
• pvImageReader — Reads headerless raw binary voxel files (.raw) into uniform image data. The file carries no metadata, so you describe it: DataExtent (index ranges), DataScalarType, DataByteOrder, NumberOfScalarComponents and FileDimensionality, plus DataSpacing and DataOrigin for world placement. Several files are a time series unless ReadAsImageStack stacks 2-D files as z slices. Use pvNrrdReader or pvMetaFileSeriesReader when a header file exists.
• pvImageShrink — Reduces the resolution of an image or volume (vtkImageData) by integer factors per axis, either by averaging each block of input pixels (ParaView default) or by keeping every nth pixel. The output spacing grows by the same factors. Use it to make large images manageable for preview or export; use resample or pvResampleToImage for non-integer target resolutions.
• pvInSituParticlePath — Parallel particle-path (pathline) tracer intended for in-situ use, e.g. inside a Catalyst pipeline that advances with a running simulation. Seeds from SeedSource are advected through the time-varying point vector field of Input; it adds options to clear the particle cache, keep advecting from previously computed particles (RestartSource) after a simulation restart, and start at FirstTimeStep. Output is polydata. For post-processing saved time series use pvParticlePath or pvParticleTracer.
• pvIntegrateVariables — Integrates every point and cell array over the input cells and sums the total length, area or volume; the output is a single point with one vertex cell holding the results. Only cells of the highest dimension present are used (with lines, triangles and hexahedra mixed, only the hexahedra count) and vertices are ignored. Same native filter as the curated integrate; use it for totals such as a surface-integrated flux or a volume-integrated quantity.
• pvInterpolatetoQuadraturePoints — Interpolates every point array of the input to the quadrature points of each cell, using the selected quadrature offset array, and stores the results as field-data arrays of the same names (linked to the offset array); the mesh is unchanged. The quadrature tools work in sequence: pvGenerateQuadratureSchemeDictionary adds a cell offset array QuadratureOffset carrying the quadrature rules, pvInterpolatetoQuadraturePoints evaluates point fields at the quadrature points, and pvGenerateQuadraturePoints turns them into a point cloud.
• pvIntersectFragments — Intersects material fragments with a plane, box or sphere. Input must be the fragment geometry and Source the fragment statistics (centres), i.e. output ports 0 and 1 of pvMaterialInterfaceFilter. Output port 0 is the intersection geometry and port 1 a point set approximating the centre of each fragment's cut. Use it to measure fragment cross-sections on a cutting surface.
• pvIsoVolume — Keeps the part of the input where a scalar lies between the two bounds of ThresholdRange (inclusive), cutting cells exactly at both iso-values for point arrays; the output is an unstructured grid. Use it for the volume between two levels, e.g. 0.1 < alpha < 0.9 at a phase interface. Unlike threshold, which keeps or drops whole cells, it produces smooth boundaries.
• pvJPEGSeriesReader — Reads JPEG images (.jpg, .jpeg) into uniform image data with 8-bit greyscale or RGB point scalars. Several files are stacked into a 3-D volume by default (ReadAsImageStack true); set it false to read them as a time series. JPEG is lossy, so use it for photographs or rendered images rather than quantitative fields; pvPNGSeriesReader or pvTIFFSeriesReader keep exact values.
• pvKMeans — Clusters observations into k groups (ParaView default 5) in the space spanned by the selected arrays, iterating until cluster centres move less than Tolerance or MaxIterations is reached. The model is the set of centres; assessment labels each point or cell with its nearest cluster and the distance to it, e.g. to segment flow regimes. Output port 0 is the statistical model (a multiblock of tables) and port 1 the input with assessment arrays added; select them with {"node": id, "port": n}.
• pvLANLFOFSODHaloFinder — LANL cosmology halo finder (vtkPLANLHaloFinder): it groups particles into friends-of-friends halos using a linking length in units of the interparticle spacing and, if SphereOverdensityHalosSOD is on, also computes spherical-overdensity (SOD) halo mass and radius around each large FOF halo. The input must carry point arrays velocity, mass, tag and ghost, as produced by pvCosmoReader. Port 0 returns the particles with a HaloID array; port 1 one point per halo with HaloMass, AverageVelocity, VelocityDispersion and, with SOD, the SOD arrays.
• pvLSDynaReader — Reads an LS-DYNA d3plot database (the d3plot file and its numbered family files d3plot01, d3plot02… holding later states) as a time series. The output is a multiblock dataset with one unstructured-grid block per selected part, named after the part, carrying nodal arrays (e.g. Velocity, Acceleration) and per-element-type cell arrays (e.g. Stress, EffPlastStrn). Use it for crash, forming and impact results; select parts and arrays to limit memory.
• pvLegacyParticlePath — Legacy particle-path (pathline) tracer kept for compatibility with older ParaView states: it integrates particles from the SeedSource points through a time-dependent, point-centred velocity field and outputs polydata polylines, one per particle, up to the time at which the node is updated. Use it to follow fluid parcels in unsteady flow. For new work prefer pvParticlePath; for snapshot streamlines use streamTracer.
• pvLegacyStreakLine — Legacy streakline tracer kept for compatibility with older ParaView states: particles are released from the SeedSource points at every step (reinjection every step by ParaView default) and advected through a time-dependent, point-centred velocity field; the output polydata connects all particles released from the same seed, like dye from a fixed injector. For new work prefer pvStreakLine; use pvLegacyParticlePath to follow individual particles.
• pvLegacyVTKReader — Reads a legacy-format VTK file (.vtk, ASCII or binary), the older single-file format that can hold structured points (image data), a structured, rectilinear or unstructured grid, or polydata, with point and cell arrays; the output type is whatever the file stores. Several file names form a time series, one file per step. Prefer the VTK XML readers (pvXMLPolyDataReader, pvXMLUnstructuredGridReader, …) for new data; use pvPartitionedLegacyVTKReader for a .pvtk set of pieces.
• pvLevelScalarsOverlappingAMR — Adds an array named LevelIdScalars holding the refinement level of each block of an overlapping AMR dataset, so refinement levels can be coloured or thresholded. The input must be vtkOverlappingAMR (e.g. from AMR readers); structure is unchanged. This is the old name of the same ParaView filter.
• pvLine — Creates a straight line from Point1 to Point2 as a polyline with intermediate points: either Resolution equal segments (UseRegularRefinement true, the default) or points at the fractions listed in RefinementRatios. Use it as a probe or seed line, a ruler-like annotation or a reference edge; to sample data along a line use probeLine.
• pvLinearCellExtrusion — Extrudes every polygon of a polygonal surface independently into a 3-D cell (triangles to wedges, quads to hexahedra, other polygons to polyhedra) by a length equal to a cell scalar times ScaleFactor, along the cell normal or a user vector; the output is an unstructured grid. Use it for 3-D bar maps, e.g. building heights on a footprint map or values drawn as columns on a surface. Use pvLinearExtrusion to sweep the whole surface by one vector.
• pvLinearExtrusion — Sweeps a polygonal dataset along one vector, creating side faces from its edges and, with Capping, copies of the polygons at both ends; output is polydata. Use it to turn a 2-D outline or planar surface into a prism-like solid surface, e.g. a profile into a constant-thickness part. Use pvLinearCellExtrusion for per-cell heights or volume cells.
• pvLocationSelectionSource — Creates a location selection from world-space points. With FieldType CELL (the ParaView default) it selects the cells that contain each location; with POINT it selects mesh points located at each location. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. To sample interpolated values at a point instead, use pvExtractLocation or pvProbeLocation.
• pvLogo — Source that turns a texture resource into image data: it copies the texture's image (vtkImageData) with origin [0, 0, 0] and spacing 1, so pixel indices become coordinates. In ParaView it feeds the logo annotation; in Schemaxis its output can be published or processed like any image. Connect a pvResourceImageTexture or pvResourceTexture node to the Texture input; without one the output is empty.
• pvLoopSubdivision — Refines a triangle surface with Loop's approximating subdivision: each pass splits every triangle into four and repositions points so the surface becomes smooth; point data are interpolated by the same scheme and new triangles inherit their parent's cell data. Use it to smooth coarse triangulated geometry for display. Input must be polydata of triangles only (run triangulate first). Because points move, the result no longer passes through the original vertices; use pvSubdivide for refinement that keeps the shape.
• pvMFIXReader — Reads MFIX multiphase-flow results: the restart file (.RES) supplies the cylindrical or rectilinear mesh, converted to an unstructured grid, and the SP* files beside it supply transient cell data, with one time step per stored output. Use it for MFIX gas-solid simulations; fields are cell-centred.
• pvMPIMoveData — ParaView-internal data-delivery filter that moves polydata, unstructured grids or AMR data between MPI processes and between data server, render server and client: PassThrough leaves data where they are, Collect gathers them to one process and Clone copies them to all. Its output type is PolyData unless OutputDataType says otherwise. It exists for ParaView's rendering pipeline; in Schemaxis prefer pvAppendReduce or pvReductionFilter to gather data.
• pvMRCSeriesReader — Reads MRC volumes (.mrc, also .st, .rec, .ali), the format of cryo-electron microscopy maps and tomograms, into uniform image data. Several files are read as a time series (one per step); this reader has no stacking option.
• pvMandelbrot — Generates image data whose float point scalar "Iterations" counts the iterations of z → z² + C before |z| exceeds 2 (capped at MaximumNumberofIterations). The 4-D parameter space (C real, C imaginary, X real, X imaginary, where X is the starting z) is sampled from OriginCX over SizeCX, with ProjectionAxes choosing which three parameters map to the image x, y and z axes. Use it as a synthetic image or volume with fine detail for testing.
• pvMaskPoints — Reduces a dataset to a subset of its points, output as polydata points (optionally with vertex cells) carrying the point data. By ParaView default it keeps every OnRatio-th point by point id (2), starting at Offset, until MaximumNumberofPoints (5000) is reached; random modes instead draw a random or spatially uniform sample. Use it to thin points before glyphs (arrows) or for lighter scatter exports.
• pvMaterialInterfaceFilter — Finds material fragments in AMR (hierarchical box) data such as CTH Spy Plot output: cells whose material fraction exceeds MaterialFractionThreshold are connected into fragments, whose surfaces form output port 0 (geometry) and whose centres of mass, volumes, masses and selected weighted averages form a point set on port 1 (statistics). It can invert the fraction and clip with a plane or sphere to measure craters, and can write both outputs to text files. Use pvRectilinearGridConnectivity for rectilinear multiblock data.
• pvMedian — Replaces each pixel or voxel of an image by the median of the selected array over a rectangular neighbourhood of KernelSize pixels, giving image data of the same size. Unlike a mean filter it removes isolated outliers (salt-and-pepper or shot noise) while keeping sharp edges. Each component is filtered separately. Near the image border the neighbourhood is clipped to the image.
• pvMergeBlocks — Full native Merge Blocks: appends the leaf datasets of a composite input into one dataset. OutputDataSetType decides the result: Unstructured Grid (ParaView default) merges blocks of any type, Polygonal Mesh merges only polydata blocks and leaves others out. MergePartitionsOnly keeps the block hierarchy and merges only the partitions within each block. Use merge for the common case (merge everything with point merging); use this when you need polydata output, a merge tolerance or partition-only merging.
• pvMergeTime — Combines several time-dependent inputs into one multiblock dataset (one block per input) whose time steps are the union of the inputs' times, or their intersection with Intersection on, with near-duplicates removed using Tolerance. For each requested time, every input supplies the matching step within tolerance, otherwise its last step before that time. Use it to view or export sources with different output times together.
• pvMergeVectorComponents — Combines three single-component arrays of the same association (e.g. Ux, Uy, Uz from a solver that writes components separately) into one 3-component vector array named OutputVectorName; the dataset is otherwise unchanged. Use it before operations that need a vector field, such as glyphs, stream tracing or vorticity.
• pvMeshQuality — Adds a cell array Quality rating the shape of each cell with a Verdict metric chosen per cell type (triangle, quad, tetrahedron, pyramid, wedge, hexahedron); other cell types get 0. Use it to locate distorted or degenerate cells before a simulation or to explain solver problems. Each metric has its own scale and ideal value (for example Scaled Jacobian is 1 for an ideal element and negative for inverted ones), so read thresholds from the Verdict documentation. ParaView's defaults are Radius Ratio (triangles, tetrahedra), Edge Ratio (quads, wedges), Shape (pyramids) and Maximum Aspect Frobenius (hexahedra). Use pvCellSize or cellSize for cell size.
• pvMetaFileSeriesReader — Reads MetaImage files (.mhd header with a separate data file, or single-file .mha), common in ITK-based medical imaging and segmentation, into uniform image data; dimensions, spacing, origin and element type come from the header. Several files form a time series. pvWriteMetaImageWriter writes this format.
• pvMinMax — Computes, for every point and cell array of the input, the componentwise minimum, maximum or sum over all tuples, and outputs a polydata with exactly one point and one vertex cell that carries the results under the original array names. Use it for one-number summaries such as peak temperature. In parallel runs ghost arrays are needed to avoid double counting. For cell-size-weighted totals use integrate; for distributions use pvHistogram.
• pvMinkowskiFilter — Computes Minkowski functionals and shapefinders for each polyhedral cell of a Voronoi tessellation (vtkMinkowskiFilter). It adds cell arrays S (surface area), V (volume, copied from the input's Volumes array), C (integrated mean curvature), X (Euler characteristic), G (genus), T = 3V/S (thickness), B = S/C (breadth), L = C/(4 pi (G + 1)) (length), and planarity P and filamentarity F, which characterize whether a structure is sheet-like or filament-like. Use it on merged Voronoi regions from pvVoronoiMergeConnected.
• pvMoleculeToLines — Converts a molecule (vtkMolecule) into polygonal data: each atom becomes a point and each bond a two-point line cell, with atom data copied to point data and bond data to cell data. Use it to process or export molecular structure with ordinary geometry operations, e.g. pvTube for stick models or a polydata writer. It reverses pvConvertIntoMolecule with line conversion on.
• pvMotionFXCFGReader — Reads a MotionFX .cfg motion definition: rigid-body motions (such as translation, rotation or planetary motion) applied to STL bodies listed in the file. The output is a temporal multiblock dataset with one block per body, positioned at each generated time step; TimeResolution sets how many steps cover the motion's time range. Use it to animate machine parts, e.g. gears or mixers, alongside simulation results.
• pvMultiResGenericIO — Reads a multi-resolution set of HACC GenericIO files described by a JSON .gios file (vtkPMultiResolutionGenericIOReader). The file lists levels, each with time steps mapping times to GenericIO files; level 0 is the coarsest. The output is a multiblock with one block per level; without a streaming view requesting finer blocks only level 0 is loaded. Use pvGenericIOReader for a single resolution.
• pvMulticorrelativeStatistics — Computes the mean vector and covariance matrix (with its Cholesky decomposition) of the selected arrays, i.e. a multivariate Gaussian model, and assesses each observation by its squared Mahalanobis distance from the mean, useful for outlier detection across several correlated fields. Use pvPrincipalComponentAnalysis to add eigen-decomposition. Output port 0 is the statistical model (a multiblock of tables) and port 1 the input with assessment arrays added; select them with {"node": id, "port": n}.
• pvNek5000Reader — Reads Nek5000 spectral-element results through a .nek5000 metadata file that names the field-file template and the time steps. The output is an unstructured grid built from each spectral element's nodal points, with the selected fields as point arrays. Each element keeps its own copy of points shared with its neighbours unless MergePointstoCleangrid is enabled. This is a distributed reader.
• pvNetCDFCAMreader — Reads Community Atmosphere Model (CAM) output on an unstructured horizontal grid from two NetCDF files: FileName holds the points and fields and ConnectivityFileName the cell connectivity. The output is an unstructured grid that is unstructured horizontally and layered vertically: quadrilaterals for one layer, hexahedra when several layers are read. VerticalDimension chooses single-layer, midpoint (lev) or interface (ilev) variables; ParaView's default is midpoint layers. Use pvNetCDFReader for CF-convention gridded files.
• pvNetCDFMPASreader — Reads one MPAS (Model for Prediction Across Scales) NetCDF file on a global unstructured Voronoi mesh and builds its dual grid as an unstructured grid: MPAS cell variables become point data and vertex variables become cell data. By default it shows vertical level 0 on a sphere as ocean data; options give a multilayer view, a lat/lon projection or atmospheric layering. Edge-centred data and regional (planar) domains are not supported, and it is not a parallel reader.
• pvNetCDFPOPreader — Reads Parallel Ocean Program (POP) NetCDF output into a rectilinear grid. The NetCDF x, y, z order becomes the grid's z, y, x order, and z coordinates are negated so the first level is the highest (depth downwards). Only three-dimensional variables are offered; Stride subsamples the grid. Use pvNetCDFReader for general CF-convention files and pvParallelNetCDFPOPreader for the parallel variant.
• pvNetCDFReader — Reads NetCDF files using the CF (and COARDS) conventions into structured VTK data: image data when nothing else is known, or rectilinear or curvilinear grids when CF coordinate metadata describes them; latitude/longitude grids can be shaped as a sphere (SphericalCoordinates). Dimensions chooses which group of variables (those sharing a dimension list) is loaded, and time comes from the CF time coordinate. Use it for climate, weather and ocean gridded data; use pvNetCDFCAMreader, pvNetCDFMPASreader or pvNetCDFPOPreader for those models' specific layouts.
• pvNetCDFUGRIDreader — Reads a NetCDF file that follows the UGRID conventions for unstructured meshes (used by some ocean, coastal and climate models) into an unstructured grid. vtkNetCDFUGRIDReader reads one 2-D mesh: mesh nodes become points and faces become cells (edges are not read), node variables become point arrays and face variables cell arrays, and a "time" variable provides time steps. Use pvNetCDFReader for CF-convention gridded NetCDF, pvNetCDFMPASreader for MPAS meshes or pvNetCDFPOPreader for POP ocean grids.
• pvNetworkImageSource — ParaView-internal source that reads an image file on one process and makes the image available on the client and render-server processes, used for textures and background images. In ReadFromMemory mode it instead fetches an image registered under TrivialProducerKey on the server. It is not a general network download. To read image data for analysis use readImageData or a pv image reader such as pvPNGSeriesReader.
• pvNormalGlyphs — ParaView's compound Normal Glyphs filter: extracts the outer surface, computes one normal per surface cell, and draws an arrow glyph at every cell centre along that normal. The output is polydata of arrows, typically rendered over the surface to check normal orientation, e.g. before extrusion, offsets or boundary-condition assignment. Arrow length is the glyph scale factor in dataset units; all arrows have the same size.
• pvNrrdReader — Reads NRRD images (.nrrd, or a detached .nhdr header with its data file or files) into uniform image data, taking dimensions, type and spacing from the header. vtkNrrdReader reads raw, ascii (also spelled txt or text) and gzip-compressed (gzip or gz) data; hex and bzip2 encodings are rejected with 'Unsupported encoding'. A detached header may name several data files only when each holds one 2-D slice of a 3-D volume. DataVOI loads a sub-box of a large volume.
• pvOMETIFFChannelCalculator — Combines up to ten fluorescence-microscopy channels of an OME-TIFF image into one RGBA colour image. Each enabled point array named Channel_1 to Channel_10 (the names pvOMETIFFReader produces) is mapped through its ChannelNLUT lookup table, its opacity is multiplied by ChannelNWeight, and the channels are blended additively into a new unsigned-char point array named Colors; the input image and its arrays are passed through unchanged. Use it to make a false-colour composite for display or PNG export; the channel data themselves are not modified.
• pvOMETIFFReader — Reads an OME-TIFF microscopy file (.ome.tif, .ome.tiff), using its OME-XML metadata to split the TIFF pages into z-planes, channels and time steps; the output is uniform image data with time steps. Only single-file, multi-page OME-TIFF is supported. Use pvOMETIFFChannelCalculator downstream to combine channels, or pvTIFFSeriesReader for plain TIFF.
• pvOMFReader — Reads an Open Mining Format (.omf) project into a partitioned dataset collection with one entry per selected element: point sets (e.g. drill-hole samples), line sets, surfaces and block-model volumes, with their attribute data. Use it for geological and mining models. Elements are not loaded unless selected in DataElements.
• pvObjectFileFormatOFFReader — Reads Object File Format geometry (.off: vertex list followed by polygon faces) into polydata with polygons and lines. Use it for meshes from geometry-processing tools; for CAD surfaces in STL or OBJ use readSTL/pvSTLReader or pvWavefrontOBJReader.
• pvOctreeImagetoPointSet — Reverses pvPointSetToOctreeImage: reads an image whose cell scalars are the unsigned-char "octree" bit mask and emits polydata with one point for every set bit, placed at the centre of the corresponding octant of the cell (a quarter of the spacing from the cell centre). It can also copy one component of a chosen cell array to the generated points. Use it to rebuild an approximate point cloud from a compact octree image; positions are quantized to octants, so original coordinates are not recovered.
• pvOpenFOAMReader — Full native OpenFOAM reader: opens a case through its .foam marker and outputs a multiblock dataset with the selected mesh regions (internalMesh, patches, patch groups, Lagrangian clouds and optionally zones) carrying cell, point and Lagrangian fields for each stored time. Omitted settings keep ParaView's own defaults: Reconstructed Case, the 0 directory skipped, point data interpolated from cell fields, 32-bit labels and 64-bit scalars. Use the curated foam operation for the common case (decomposed case, internalMesh only, 0 kept); use this one for point or Lagrangian fields, zones, binary label/scalar sizes and the other native options.
• pvOpenVDBReader — Reads an OpenVDB (.vdb) file, the sparse volume format used in visual effects and some simulation tools. Each grid becomes a block of a partitioned dataset collection: volume grids become image data (vtkImageData) and point grids become polydata vertices. MergeImageVolumes or MergePointSets instead combine the selected grids into one image (one array per grid) or one point set, and DownsamplingFactor coarsens the sampled volume.
• pvOutline — Produces the 12 edges of the input's axis-aligned bounding box as polydata lines, a lightweight frame for images of volumes or point clouds; in MPI runs the global bounds are used. Same native filter as the curated outline (neither has options). Accepts datasets and graphs; use pvOutlineCorners to draw only the corners.
• pvOutlineCorners — Draws only the corners of the input's axis-aligned bounding box, as short segments running from each corner along the three box edges, for a less cluttered frame than pvOutline. CornerFactor sets each segment's length as a fraction of the box size along that axis.
• pvOutlineCurvilinearDataSet — Draws the 12 boundary edges of a structured (curvilinear) grid as polydata lines that follow the grid's curved outer edges instead of its axis-aligned bounding box. Input must be a vtkStructuredGrid. Use it to show the extent of a body-fitted CFD block; outline or pvOutline draw a bounding-box outline of any dataset.
• pvOutlineSource — Creates the twelve edges of an axis-aligned box as line polydata from explicit Bounds [xmin, xmax, ymin, ymax, zmin, zmax]. Use it to draw a region of interest or a fixed reference box in a scene; to outline the bounds of existing data use outline, and for a solid box use pvBox.
• pvOverlappingAMRLevelIds — Adds an array named LevelIdScalars holding the refinement level of each block of an overlapping AMR dataset, so refinement levels can be coloured or thresholded. The input must be vtkOverlappingAMR (e.g. from AMR readers); structure is unchanged.
• pvOverlappingCellsDetector — Detects cells that overlap other cells of the same mesh and adds a cell array, NumberOfOverlapsPerCell, counting for each cell how many other cells it collides with (the upstream description's name NumberOfCollisionsPerCell is outdated). Use it as a mesh-quality check, e.g. for overlapping overset regions or badly merged parts; zero everywhere means no overlap was found. It accepts point sets and composite data and works across MPI processes.
• pvPCANormalEstimation — Estimates a normal at every point of a polydata point cloud by principal component analysis: a plane is fitted to each point's neighbours and its normal is stored in the point array PCANormals. Use it for scanned or particle data without connectivity, where surface normals cannot be computed from polygons (use normals or pvGenerateSurfaceNormals for meshed surfaces). The neighbourhood is chosen by SearchMode, SampleSize and Radius; the sign of each normal is arbitrary unless NormalOrientation fixes it.
• pvPDALReader — Reads LiDAR and other point-cloud files through the PDAL library (LAS/LAZ, PCD, PLY, text and the other formats PDAL supports) into polydata points with per-point attribute arrays such as Intensity, Classification and colour. Use it for terrain, building or vegetation scans; follow it with pvPCANormalEstimation or pvGaussianResampling to derive normals or density fields.
• pvPDBReader — Reads a Protein Data Bank file (.pdb) of macromolecular structure into polydata: atoms as points with arrays such as atom_type, residue, chain and secondary_structures, and bonds as lines estimated from atomic distances. Recent VTK sources also provide a vtkMolecule on output port 1. Use it for protein or nucleic-acid structures; pvXYZReader suits simple coordinate lists.
• pvPIOReader — Reads xRAGE PIO dump files (Los Alamos radiation-hydrodynamics code) through an ASCII .pio file describing the dump directory, cycles and variables. AMR data become an unstructured grid of cells or, with UseHyperTreeGridHTGforAMRMesh, a hypertree grid; the selected variables are cell arrays. LoadTracers adds tracer particles as a second unstructured grid, and TimeArray chooses the field used as time (ParaView default SimulationTime). This is a distributed reader.
• pvPLOT3DMetaFileReader — Reads a PLOT3D case through a .p3d meta file: a small JSON file naming the grid (.xyz), solution (.q) and optional function files for each time value, and recording the format settings PLOT3D files do not describe themselves (binary or ASCII, byte order, precision, multi-grid, Fortran byte counts, blanking, 2-D, R, gamma, derived functions). The output is a multiblock dataset of structured grids. Use it for time series or to keep format settings with the data; use pvPLOT3DReader to set the format in the node instead.
• pvPLOT3DReader — Reads NASA PLOT3D structured-grid data: a grid file (.xyz) with block coordinates, solution files (.q) holding density, momentum and stagnation energy, and a function file (.f) of extra variables. The output is a multiblock dataset of structured grids with density, momentum and stagnation energy as point arrays; Functions adds derived quantities (pressure, Mach number, velocity, vorticity …) computed with the reader's gas constants R = 1.0 and γ = 1.4, which are not exposed here. Several .q files form a time series. Use pvPLOT3DMetaFileReader when a .p3d meta file describes the case.
• pvPLYReader — Full native PLY reader: reads Stanford PLY polygon files (ASCII or binary) into polydata. ParaView's documentation requires vertex elements with x, y and z and face elements with vertex_indices; further vertex properties such as normals, colours or texture coordinates are carried along as arrays. Several file names form a time series. Use readPLY for one file; use this operation for file series or the texture-coordinate settings.
• pvPNGSeriesReader — Reads PNG images (.png) into uniform image data with 8- or 16-bit, 1 to 4 component point scalars. Several files are stacked into a volume by default (ReadAsImageStack true), e.g. a segmentation-mask stack; set it false to read them as a time series. PNG is lossless, so values are exact; pair with pvWritePNGWriter for round trips.
• pvPTSReader — Reads an ASCII PTS point cloud (.pts: point count, then x y z [intensity [r g b]] per line), as produced by laser scanners, into polydata with one vertex cell holding all points and Intensities and Color arrays when present. Optional limits subsample the file to a maximum number of points and/or keep only points inside a box. Use pvPDALReader for LAS/LAZ point clouds.
• pvPVDReader — Reads a ParaView .pvd collection: an XML index listing VTK XML data files (.vtu, .vtp, .vti, .vtm, .vtt …) with timestep, part and group attributes. Distinct timestep values become a time series; several parts at one time are combined into a composite (multiblock) output. Use it to reopen results written by pvWriteXMLPVDWriter or by solvers that emit .pvd; for a single VTK XML file use the matching reader such as pvXMLUnstructuredGridReader.
• pvPVTrivialProducer — ParaView's trivial producer (vtkPVTrivialProducer) wraps an existing data object and can also report time steps and a whole extent for structured data split across processes. As with pvTrivialProducer, the data must be attached by native code, which Schemaxis input cannot do, so it is not a useful authoring operation.
• pvPVTrivialProducer2 — A second registration of ParaView's vtkPVTrivialProducer without the WholeExtent property, used internally by ParaView. It needs a data object attached from native code, which Schemaxis input cannot provide, so it is not useful in an authored workflow; use pvPVTrivialProducer's documentation for context and a reader for real data.
• pvParallelNetCDFPOPreader — Reads Parallel Ocean Program (POP) output stored in NetCDF (.pop.ncdf, .pop.nc) into a rectilinear grid, with only some MPI processes reading the file and sending the data to the others. ParaView marks this proxy mpi_required, so it is meant for runs with several ranks; for serial runs use pvNetCDFPOPreader. VariableArrayStatus selects the ocean variables and Stride subsamples the grid.
• pvParticlePath — Advects particles from the seed points (SeedSource port) through a time-varying vector field (Input port) and outputs pathlines: polylines tracing each particle from injection up to the requested time, with arrays such as ParticleId, ParticleAge and InjectionStepId. It integrates through the input's time steps from the first, so later scene times cost more. Use it for unsteady flows where instantaneous streamlines mislead; pvParticleTracer returns only current positions and streamTracer instantaneous streamlines.
• pvParticleTracer — Advects particles from the seed points (SeedSource port) through a time-varying vector field (Input port) and outputs, at the requested time, only the current particle positions as points with attributes such as ParticleId and ParticleAge; no paths are kept and no cells are created. ForceReinjectionEveryNSteps releases new particles periodically for a continuous stream. Use it to animate particle clouds in unsteady flow; pvParticlePath keeps trajectories.
• pvParticlesReader — Reads simple particle files (text or binary records of x, y, z and an optional scalar, as float or double) into polydata points with vertex cells and, when HasScalar is true, one scalar point array. Several files form a time series. Use it for raw particle dumps; for structured text tables use pvCSVReader followed by pvTableToPoints.
• pvPartitionBalancer — For partitioned data (vtkPartitionedDataSet or collections), makes every MPI process hold the same number of partitions by adding empty (null) partitions, and drops empty input partitions. Squash (ParaView default) pads only up to the largest per-process count; Expand gives every non-empty partition its own global index, so partition n exists on exactly one process. Data and geometry are unchanged. Use it before writers or filters that expect a consistent partition layout; in a serial run it only removes empty partitions.
• pvPartitionedDataSetCollectionSource — Generates a vtkPartitionedDataSetCollection of up to 12 parametric surfaces (Boy, Cross Cap, Figure-8 Klein, Klein, Mobius, Roman, Conic Spiral, Dini, Ellipsoid, Enneper, Super Toroid, Torus, in that order), shifted 2.5 units apart along x, each split into partitions and grouped in a data assembly by orientability. Point arrays "ObjectId" and "PartitionId" identify shape and partition. Use it to test how pipelines handle partitioned collections and assemblies.
• pvPartitionedLegacyVTKReader — Reads a partitioned legacy VTK data set: a .pvtk summary file listing several legacy .vtk piece files (structured points, structured, rectilinear or unstructured grid, or polydata), which are read as one data set. Use it for older parallel outputs; use pvLegacyVTKReader for a single .vtk file and the XML partitioned readers (e.g. pvXMLPartitionedUnstructuredGridReader) for .pvtu or .pvtp data.
• pvPassArrays — Generated binding of ParaView's Pass Arrays: keeps only the selected arrays of each association (point, cell, field, and for graphs and tables vertex, edge and row data) and removes the rest, with geometry unchanged. An association whose list is empty passes none of its arrays. Unlike the curated passArrays, omitted lists are not set by Schemaxis, so ParaView's own initial selection applies; name every list whose arrays matter.
• pvPassThrough — Returns its input unchanged (vtkPassThrough), for any non-composite dataset. It is useful as a named, stable connection point in a workflow, e.g. to give a reader's output a second node id or to separate a branch for publication; it computes nothing.
• pvPedigreeIDSelectionSource — Creates a pedigree-ID selection: elements whose value in the input's designated pedigree-ID array matches the given IDs, which are integers (PedigreeIDs) or strings (PedigreeStringIDs), each paired with a domain name. Pedigree IDs identify where an element came from (e.g. a source-file element number) and survive filtering. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. Use pvGlobalIDSelectionSource for global IDs.
• pvPerlinNoise — Adds a point array (default name PerlinNoise) of deterministic Perlin noise evaluated at each point's coordinates, varying between -|Amplitude| and |Amplitude|; geometry is unchanged. Use it to generate smooth pseudo-random test fields, perturb geometry together with a warp, or add texture for rendering. The same coordinates and settings always give the same values.
• pvPhastaReader — Reads results of the PHASTA parallel CFD solver through its .pht meta-file, an XML description of the geometry and field files per time step and partition. The output is a multipiece dataset of unstructured grid pieces with the solver's fields and time steps. Use it only for PHASTA output.
• pvPlane — Creates a flat parallelogram as polydata: Origin is one corner, and the edges run from Origin to Point1 (the plane's x axis) and from Origin to Point2 (its y axis), subdivided into XResolution × YResolution quadrilaterals. Use it as a seed or probe surface, a sampling plane or reference geometry. The curated plane operation offers the same source with Schemaxis defaults.
• pvPlotData — ParaView's Plot Data: passes any data object through unchanged (vtkPassThrough) while tagging it for display in a line chart (XYChartView), where ParaView plots its arrays against point or row index. In Schemaxis the data result is the unchanged input; the chart is only a ParaView view preference.
• pvPlotDataOverTime — Builds time histories by updating the input at every time step it reports and collecting one attribute association (FieldAssociation: Points by ParaView default, Cells, Vertices, Edges or table Rows). Output is a multiblock of tables with a time column: by default one table of per-step statistics (minimum, maximum, quartiles and, for numeric arrays, mean and standard deviation) per input block, otherwise one table per tracked point or cell. Use it for convergence or transient monitoring of a region already reduced to what matters (a probe, slice or clipped zone).
• pvPlotGlobalVariablesOverTime — Extracts global (field-data) quantities over time into a table with one row per time step, e.g. Exodus global variables such as total energy or time-step size. With AutoDetectGlobalTemporalDataArrays (ParaView default true), arrays flagged as Exodus global temporal variables are used if any exist; otherwise every single-tuple field-data array is collected by updating the input at each time step.
• pvPlotOnIntersectionCurves — ParaView's compound filter that extracts the outer surface of the input, cuts it with an implicit function (SliceType, a plane by default) and orders the resulting intersection edges into polylines. The output is a multiblock of polylines carrying the interpolated point data plus an arc_length array, suitable for line plots of a field along the curve, e.g. pressure around an aerofoil section. Use pvPlotOverLine or probeLine to sample along a straight segment through the volume instead.
• pvPlotOnSortedLines — Takes polydata made of line segments, for example the lines produced by slicing a surface, and reassembles them into continuous, ordered polylines, adding an arc_length point array measured along each one. The output is a multiblock dataset with one block per continuous segment, suitable for line charts of a field against distance along an intersection curve. Use pvPlotOnIntersectionCurves to slice and sort in one step, or probeLine / pvPlotOverLine to sample along a straight line instead.
• pvPlotOverLine — Samples all point and cell arrays of the input along the straight segment Point1-Point2 and returns a polyline (polydata) with the interpolated values plus arc_length and vtkValidPointMask point arrays, ready for line charts or CSV export. SamplingPattern chooses uniform samples (ParaView default, Resolution 1000) or exact cell-boundary or one-per-cell sampling. Composite inputs give a single non-composite line. Use probeLine for the same filter with Schemaxis defaults, and pvResampleToLine for a coarse uniform resampling.
• pvPlotOverLinesFromCustomSource — Samples the Input dataset along every line or polyline cell of the Source (polydata or an unstructured grid of lines, e.g. extracted feature edges or a polyline source), interpolating point data and taking cell data from the containing cell. Output is a multiblock with one polydata block per source cell, points ordered along the line. SamplingPattern chooses uniform samples (ParaView default, Resolution 1000), samples at cell boundaries (step profiles of cell data) or one sample per crossed cell. Use pvPlotOverLine or probeLine for a single straight line.
• pvPlotSelectionOverTime — Extracts the points or cells chosen by a selection (the Selection input, e.g. from pvIDSelectionSource or pvLocationSelectionSource) at every time step and reports their values over time. Output is a multiblock of tables with a time column: by ParaView default one table of statistics over the selected elements per step, otherwise one history per element. Location selections take values from the cell containing each location.
• pvPointAndCellIds — Adds integer arrays with each point's zero-based index (PointIds, point data) and each cell's index (CellIds, cell data) as numbered in this dataset; hyper tree grid input gets cell ids only. The arrays travel with points and cells through later extraction, so they can trace results back to the original elements. generateIds is the curated alternative.
• pvPointDatasetInterpolator — Interpolates the point arrays of a point cloud (Input: any point set, e.g. particles, scattered measurements or the points of a mesh) onto the points of a second dataset (Source), weighting nearby cloud points with a kernel. The output keeps Source's type, points and cells and adds the interpolated arrays, so a slice, image or mesh can be coloured by cloud data. Kernels range from Voronoi (nearest point, the ParaView default) to smooth Gaussian or Shepard weighting. Use resample when the data live on a mesh with cells, and pvSPHDatasetInterpolator for SPH particles.
• pvPointDatatoCellData — Converts point arrays to cell arrays by averaging, for each cell, the values at its points; with CategoricalData the most frequent value among the cell's points wins instead, which suits integer labels. The output is the same dataset type with new cell arrays, and by ParaView default the point arrays are dropped. Use it when a step needs cell data, e.g. per-cell statistics or cell-based thresholds; pointToCell is the curated version, and cellToPoint or pvCellDatatoPointData go the other way.
• pvPointLineInterpolator — Interpolates point data from a point cloud (Input) onto a high-resolution straight line set in the Source options (Point1, Point2, Resolution; ParaView default 1000 intervals), producing a polyline profile for line plots. Use it for profiles through scattered or particle data; for data on a mesh with cells, probeLine samples by cell interpolation instead.
• pvPointPlaneInterpolator — Interpolates point data from a point cloud (Input) onto a bounded plane set in the Source options (a plane through Center with Normal, limited to BoundingBox plus Padding and refined by Resolution or CellSize), producing a planar grid with interpolated arrays, e.g. a heat-map section through particle or scattered data. For meshes with cells, use slice or resample instead.
• pvPointSetToOctreeImage — Bins a point set (point cloud or any vtkPointSet) into a uniform image covering the points' bounding box, sized so that each cell holds about NumberOfPointsPerCell points. The output (a partitioned dataset containing one image) has an unsigned-char cell array "octree" whose eight bits record which octants of each cell contain points, and optionally a float cell array, named after a chosen single-component point array, with per-cell last value, min, max, count, sum and/or mean components. Use it to voxelize particle or LiDAR data, or with pvOctreeImagetoPointSet as a compact, lossy point-cloud encoding.
• pvPointSource — Creates a cloud of NumberOfPoints points placed pseudo-randomly with uniform density inside a sphere of radius Radius around Center, as polydata vertices. Use it as a seed cloud for streamlines or particle tracing, or as test input. With the ParaView defaults (one point, radius 0) it yields a single point at the centre.
• pvPointVolumeInterpolator — Interpolates point data from a point cloud (Input) onto a bounded volume set in the Source options (Origin, Scale, Padding and Resolution or CellSize), producing image data that can be contoured, sliced or volume-rendered. Use it to turn scattered or particle data into a regular grid; the grid resolution and the kernel radius together set how smooth the result is.
• pvPolyLineSource — Creates one polyline through an ordered list of points, optionally closed into a loop. Use it for seed curves, measurement paths, outlines or probe paths that are not straight; for a straight subdivided line use pvLine, for a smooth curve through control points use pvSplineSource.
• pvPolyPointSource — Creates polydata containing exactly the points you list, as vertices with no connectivity between them. Use it to place probe or seed locations at known coordinates (e.g. sensor positions) or to mark points in a scene; for random clouds use pvPointSource.
• pvPolylineLength — Adds a point array named arc_length holding, at each point of a polyline, the distance travelled along that polyline from its first point; points of other cell types get 0. The output is the same polydata. Use it after probeLine, a streamline or a contour to plot values against distance along the curve.
• pvPrincipalComponentAnalysis — Extends pvMulticorrelativeStatistics with the eigenvalues and eigenvectors of the covariance matrix (optionally normalized, or robust using medians), and assesses data by projecting each observation onto the principal components, using the full basis, a fixed number of components or enough components to reach a fixed energy fraction. Use it to find dominant correlated modes among several fields or to reduce their dimensionality. Output port 0 is the statistical model (a multiblock of tables) and port 1 the input with assessment arrays added; select them with {"node": id, "port": n}.
• pvProbeLocation — Samples the input dataset at the points of a probe point cloud (ProbeType; ParaView 5.13.3 offers only the fixed-radius point source) and outputs those points as polydata with interpolated point data, the containing cell's cell data and a vtkValidPointMask array marking points that fell inside the data. Use it for values at a monitor location, and pvPlotDataOverTime after it for a time history. Use probeLine or pvPlotOverLine for profiles.
• pvProcessIdScalars — Adds an array named ProcessId holding the MPI rank that owns each point (or each cell with CellScalars), so partitioning and load balance can be coloured. In a serial run every value is 0. ParaView deprecated this filter in 5.12 (removal planned for 5.14) in favour of Process Ids; use pvProcessIds in new documents.
• pvProcessIds — Adds arrays recording which MPI process owns each point (PointProcessIds) and/or cell (CellProcessIds); hyper tree grids get only cell ids. Geometry is unchanged. Use it to visualize or debug the domain decomposition of a parallel run; in a serial run every value is 0.
• pvProtractor — ParaView's protractor: a polyline (vtkPolyLineSource) through three points, [point 1, vertex, point 2], whose angle at the vertex ParaView's interactive widget displays. In Schemaxis the output is only the polyline geometry; the angle is not written into the data, so compute it from the three points when you need the value. Use it to show an angle annotation in a scene; pvRuler is the equivalent for distances.
• pvQuadricClustering — Simplifies a polygonal surface by spatial binning: the bounding box is divided into NumberofDimensions bins, all points in a bin collapse to one representative point chosen to minimize quadric error, and degenerate triangles are dropped. It is fast enough for huge meshes (ParaView uses it for level-of-detail rendering), but the result follows the bin grid rather than surface features. Use pvDecimate or decimate when shape fidelity matters more than speed.
• pvRTXMLPolyDataReader — Real-time VTK XML polydata reader (vtkRTXMLPolyDataReader): it can watch a data directory (Location, optional) for .vtp files arriving from a running simulation; each run of its UpdateToNextFile command reads the next unprocessed file, and ResetReader rescans the directory. FileName names the polydata file read first. Schemaxis declares both commands for onVisit, but a batch run sees only the files present while it runs; use pvXMLPolyDataReader for a fixed file or series.
• pvRandomAttributes — Adds random-valued arrays to a dataset, composite dataset or hyper-tree grid: point and/or cell scalars (1 component) and vectors (3 components) of the chosen DataType, each component drawn between the two ComponentRange values. By ParaView default only cell vectors of unsigned char in [0, 255] are generated. Generated arrays become the active attributes. Use it for test data or to colour blocks distinctly (AttributesConstantPerBlock).
• pvRandomVectors — Adds a point array BrownianVectors of random 3-D vectors (random direction, length drawn between MinimumSpeed and MaximumSpeed) and makes it the active vectors; existing vectors are not copied as active. Output has the input's type. Use it for test vector fields or to jitter points with a warp.
• pvRectilinearDatatoPointSet — Converts a rectilinear grid (axis-aligned with per-axis coordinate arrays) into an equivalent structured grid with explicit point coordinates; arrays are kept. Use it before operations that need explicit points or reject rectilinear grids.
• pvRectilinearGridConnectivity — Extracts material fragments from rectilinear-grid data (single grids or multiblock collections, typically CTH results) using cell-centred volume-fraction arrays and an isovalue. Fragments are built at sub-cell resolution with an extended marching-cubes table, connected across blocks and MPI processes, and returned as a multiblock dataset with one polydata block per material; cell data carry FragmentId and the integrated attributes such as MaterialVolume. Choose it for fragment counting and volume integration on rectilinear CTH data; for AMR input use pvMaterialInterfaceFilter or pvAMRFragmentsFilter.
• pvRectilinearGridGeometryFilter — Converts a rectilinear grid (vtkRectilinearGrid: axis-aligned cells with separate coordinate arrays along x, y and z) into polygonal data. VTK can restrict this to an i-j-k extent, but ParaView exposes no extent, so the whole grid is used: a 3-D grid becomes a cloud of vertices (one per grid point), a 2-D grid a surface of quadrilaterals and a 1-D grid a polyline, with point and cell data carried over. Use surface or pvExtractSurface to get the outer surface of a 3-D grid instead.
• pvRedistributeDataSet — Load-balances a dataset across MPI processes: it computes spatial cuts for the requested number of partitions and moves cells accordingly, assigning boundary cells to one region (ParaView default), duplicating them (marked as duplicate ghost cells) or splitting them. Output is an unstructured grid per process, or a vtkPartitionedDataSet with PreservePartitionsInOutput, and global cell ids can be generated. With default settings a serial run has one partition, so the main effect is conversion to an unstructured grid. It is the newer alternative to pvD3.
• pvReductionFilter — Generic parallel reduction (vtkReductionFilter): an optional pre-gather algorithm runs on each MPI process, the results are gathered, and a post-gather algorithm combines them on one or all processes. The helpers are named by VTK class name (PreGatherHelperName, PostGatherHelperName); the helper proxies themselves cannot be set in Schemaxis. In a serial run there is a single piece, so the operation mainly applies the helpers to it. Prefer pvAppendReduce for the common gather-and-append case.
• pvReflect — Mirrors the input across an axis-aligned plane and outputs an unstructured grid containing, by ParaView default, both the original and the mirrored copy (CopyInput). The plane is either a face of the input bounding box (X Min to Z Max) or x, y or z = Center. Vectors, normals and tensors are flipped; with FlipAllInputArrays (default true) every signed 3-, 6- or 9-component array is treated as a vector or tensor too. Use it to complete a symmetric half-model; the curated reflect uses the same filter with Schemaxis defaults (plane X at 0).
• pvRemoteSourceProxy — ParaView's Remote Source Proxy (vtkPVMultiServerDataSource) mirrors, inside the client's built-in session, a dataset that lives on another server in a multi-server ParaView setup. It has no inputs or file and receives its data only through a native DependencyLink to that external proxy, which Schemaxis does not expose (it is listed as a property gap). In a Schemaxis workflow it therefore has nothing to fetch and is not a useful data source; use a reader or a source operation instead.
• pvRemoveGhostInformation — Removes ghost cells and the vtkGhostType point and cell arrays from polydata or unstructured grids; for hyper tree grids it removes the ghost array and masks the ghost cells. Use it before writing or measuring data from a parallel pipeline so duplicated boundary layers are not exported or counted twice.
• pvRenameArrays — Passes its input through unchanged except for array names. Each list property holds [current name, new name] pairs for one attribute type: points, cells, field data, graph vertices, graph edges or table rows. It accepts any data object, including composites and tables. Use it to give arrays the names a later step expects, e.g. to make datasets agree before pvAppendDatasets, or to replace solver names before export.
• pvResampleAMR — Samples overlapping AMR data (vtkOverlappingAMR) onto a uniform grid covering the box from Min to Max with NumberofSamples points per axis, taking each value from the finest level that covers the sample. The result is a multiblock of uniform-grid partitions (NumberOfPartitions) with the fields on points (TransferToNodes true) or cells. Use it to compare AMR results with regular-grid data or to export a fixed-resolution image; use pvConvertAMRdatasettoMultiblock to keep the native blocks.
• pvResampleToImage — Samples the input's point and cell arrays onto a new uniform image (vtkImageData) with SamplingDimensions points along x, y and z, spanning the input bounds (UseInputBounds, ParaView default) or custom SamplingBounds. Values are interpolated at the image points by a probe filter, so cell arrays also become point arrays, and points outside the input get 0 in the vtkValidPointMask array. Use it to convert unstructured results to a regular grid for image writers, volume rendering or pvHistogram2D; resample probes onto an existing mesh instead.
• pvResampleToLine — Same native filter as pvPlotOverLine (vtkPVProbeLineFilter) with a different starting configuration: uniform sampling with Resolution 40 and the SamplingPattern hidden in ParaView's GUI. It returns a polyline with the input arrays interpolated along Point1-Point2 plus arc_length and vtkValidPointMask. Use it for a light uniform resampling, e.g. a coarse profile to compare between runs; use pvPlotOverLine or probeLine for detailed profiles.
• pvResampleWithDataset — Samples the arrays of SourceDataArrays at the points of DestinationMesh: the output has the destination's geometry and structure, and its point data holds the source's point and cell values interpolated at each destination point plus a vtkValidPointMask array marking points found inside the source. Both inputs may be composite. Use it to transfer a solution onto another mesh, e.g. CFD results onto a structural or measurement mesh; resample is the curated version and pvResampleToImage samples onto a generated image.
• pvResourceImageTexture — Typed texture resource (vtkTexture) that loads its image from a file such as a PNG or JPEG. It produces no dataset: other nodes reference it through texture inputs, currently pvLogo's Texture port, and several consumers may share it. Use it when the picture is a file on disk; use pvResourceTexture when the image comes from a pipeline node.
• pvResourcePVLookupTable — Typed colour lookup-table resource (vtkPVDiscretizableColorTransferFunction) that maps data values to colours, either as a continuous colour map defined by RGBPoints control points or as categorical colours for annotated values (InterpretValuesAsCategories). It is not a dataset: it is connected to lookup-table inputs such as pvColorByArray, pvOMETIFFChannelCalculator or the PLY and OpenVDB writers, and several consumers can share one table. Scene appearances build their own colour maps from field, range and preset, so use this resource only for those explicit ports.
• pvResourcePiecewiseFunction — Typed piecewise-function resource (vtkPiecewiseFunction) that maps a data value to a single number, normally opacity from 0 to 1, through control points. Its main use is the ScalarOpacityFunction input of pvResourcePVLookupTable, where it defines how transparent each data value is. It produces no dataset and can be shared by several lookup tables.
• pvResourceTexture — Typed texture resource (vtkTexture) whose image comes from a connected pipeline node producing image data (vtkImageData), for example a PNG series reader or a resampled field. Like pvResourceImageTexture it is referenced by texture inputs such as pvLogo's Texture port and produces no dataset of its own. Choose it when the texture must follow pipeline changes; use pvResourceImageTexture to load a file directly.
• pvResourceTransferFunction2D — Typed two-dimensional transfer-function resource (vtkPVTransferFunction2D): colour and opacity defined over two axes, usually a scalar on x and a second quantity such as gradient magnitude on y, as used by ParaView's 2-D volume rendering. It is built from coloured rectangles (Boxes) within Range and sampled to an image of OutputDimensions. In Schemaxis it only connects to the TransferFunction2D input of pvResourcePVLookupTable; Schemaxis scene appearances do not perform volume rendering.
• pvRestartedSimExodusReader — Reads an Exodus simulation that was restarted, through a metadata file listing the output file sets of each restart, so they behave as one continuous time series. The output and the block, set, map and variable selections are those of pvExodusIIReader: a multiblock of unstructured grids with nodal and element variables, displacements applied by default. Use pvExodusIIReader for a single run's files.
• pvRestartedSimSpyPlotReader — Reads a CTH (Spy Plot) simulation that was restarted, through a metadata file (.spcth-timeseries) listing the output file sets of each restart, so the sets behave as one continuous time series. Output port 0 is the volume data (hierarchical blocks with cell-centred arrays such as material volume fractions), port 1 the tracers and port 2 the markers; select a port with {"node": id, "port": n}. Use pvSpyPlotReader for a single .spcth case and pvspcthhistoryreader for history files.
• pvReverseSense — Flips the orientation of polygonal data: ReverseCells (ParaView default true) reverses each cell's point order, which flips its implied front face, and ReverseNormals (default false) multiplies existing point and cell normals by −1. Use it when a surface's normals point inward, e.g. an STL with clockwise winding, before shading, normal-based glyphs or operations that assume outward orientation; normals with consistency orients a surface automatically.
• pvRibbon — Turns lines and polylines (polydata, e.g. streamlines) into flat ribbon strips that follow each line. The ribbon's orientation comes from a normal: the 3-component point array chosen in Vectors, or the fixed DefaultNormal when UseDefaultNormal is true; with neither, VTK computes sliding normals for each line. Width is the half-width; VaryWidth scales it along the line by the Scalars array from Width at the array minimum to twice Width at its maximum, and Angle rotates the ribbon about the line. Use tube or pvTube for round tubes.
• pvRotationalExtrusion — Sweeps polygonal data around an axis through the coordinate origin (RotationAxis, ParaView default z) to build a swept surface: free edges and lines become surfaces and vertices become lines, so a profile curve becomes an axisymmetric shell (cylinder, bottle), and Translation or DeltaRadius turn it into a spring or spiral. Capping closes the ends with copies of a filled 2-D input. Output is polydata, a surface rather than a volume; use pvVolumeOfRevolution to sweep 2-D cells into volume cells.
• pvRuler — ParaView's ruler: a straight line (vtkLineSource) from Point1 to Point2 that ParaView's ruler representation labels with its length. In Schemaxis the output is only the line geometry; the distance is not stored in the data, so compute it from the two points when you need the value. Use it as a distance annotation; pvLine gives a subdivided line for probing.
• pvSAVGReader — Reads a NIST SAVG file (.savg), a plain-text format of coloured points, lines and polygons used for immersive-visualization scenes. The output is a partitioned dataset collection with one polydata partition per primitive kind found (points, lines, polygons), with optional "rgba_colors" and "vertex_normals" point arrays. Use it to bring such scene geometry into a pipeline; it carries no simulation fields.
• pvSEPReader — Reads Stanford Exploration Project seismic data: a text .H header describing up to 32 named axes (labels such as CDP, LINE, OFFSET, DEPTH) with their sizes, origins and sampling, which points to the raw .H@ data file. You choose which named axes become the output x, y and z (or x and y for 2-D output) and hold the remaining axes at one index each; the result is uniform image data with an ImageScalars array.
• pvSLACDataReader — Reads the NetCDF-based mesh and mode files of SLAC's accelerator electromagnetics codes (Omega3P, Tau3P and related tools). MeshFileName is the element mesh; ModeFileName is one mode file (usually an eigenmode with electric and magnetic fields) or several files forming a time series. Output port 0 (External Surface) is the boundary surface and port 1 (Entire Volume) the volume mesh, filled only when ReadInternalVolume is enabled. When a mode file stores a frequency (100 or more, treated as hertz) the complex fields are animated over one period of the lowest frequency: each mode contributes magnitude × FrequencyScale × cos(initial phase + 2πft + PhaseShift) and the modes are summed.
• pvSLACParticleDataReader — Reads particle data written by SLAC's accelerator codes (NetCDF files with the SLAC particle conventions) into polydata: a set of particle points in 3-D space. Several files form a time series, one file per step in the order listed. Use it with pvSLACDataReader to show particles inside the cavity fields.
• pvSPHDatasetInterpolator — Interpolates particle data with smoothed-particle-hydrodynamics kernels: the Input is the particle set (a point set with point arrays, normally including density and optionally mass) and the Source is any dataset whose points receive the SPH-weighted values. The output keeps Source's structure and adds the interpolated arrays, a Shepard-sum array (on by default) and any derivative arrays. Use it to post-process SPH simulation output on meshes, slices or images; for non-SPH scattered data use pvPointDatasetInterpolator.
• pvSPHLineInterpolator — Interpolates SPH particle data (Input) with SPH kernels onto a high-resolution straight line set in the Source options (Point1, Point2, Resolution; ParaView default 1000 intervals), producing a polyline profile with the interpolated arrays and a Shepard-sum array, e.g. a density or pressure profile through a particle simulation.
• pvSPHPlaneInterpolator — Interpolates SPH particle data (Input) with SPH kernels onto a bounded plane set in the Source options (Center, Normal, BoundingBox, Padding, Resolution or CellSize), producing a planar grid of SPH-weighted values for heat-map sections through a particle simulation.
• pvSPHVolumeInterpolator — Interpolates SPH particle data (Input) with SPH kernels onto a bounded volume set in the Source options (Origin, Scale, Padding, Resolution or CellSize), producing image data that can be contoured, sliced or volume-rendered as a continuous field.
• pvSTEPReader — Reads a STEP CAD file through OpenCASCADE and tessellates its B-rep faces into triangles, giving a multiblock dataset with one polydata block per shape (named from the file, or Unnamed) and a per-cell Colors array from the CAD colours. LinearDeflection and AngularDeflection set how closely the triangles follow curved surfaces; ReadWire adds edges as polylines. Use it to bring CAD geometry in for rendering, clipping or probing; use pvIGESReader for .iges, and readSTL or pvSTLReader for already-tessellated STL.
• pvSTLReader — Full native STL reader: reads ASCII or binary stereolithography files (.stl) into triangle polydata, and a list of several files into a time series. In ParaView 5.13.3 this proxy exposes only the file list (the ScalarTags option of the core reader is not exposed). For a single CAD surface the curated readSTL does the same with one file.
• pvScatterPlot — ParaView's Scatter Plot: passes a dataset through unchanged (vtkPassThrough) and marks it for the plot-matrix view, which shows every pair of arrays as a scatter plot in the ParaView GUI. In Schemaxis the data result is the unchanged input.
• pvSegYReader — Reads a SEG-Y seismic file. 3-D surveys become a structured grid (default) or, with StructuredGrid false, a lighter image data whose positions and shape may be approximate; 2-D lines become a structured grid sheet. Axes are crossline, inline and depth, and the trace samples are the point values. Trace positions come from source, CDP or custom header bytes, and VerticalCRS decides whether the vertical axis is height (positive up) or depth.
• pvSelectionQuerySource — Creates a query selection, ParaView's "Find Data" mechanism: QueryString is a structured query over the input's arrays, element indices or locations, evaluated per element when pvExtractSelection (or another extractor) runs; the elements where it is true are selected. ElementType chooses cells (ParaView default) or points, and Selectors can restrict the query to some blocks of a composite input. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. For a plain range on one array, pvThresholdSelectionSource is simpler.
• pvShrink — Moves the points of every cell toward that cell's centroid (average of its points) by ShrinkFactor, separating cells so individual elements become visible; output is an unstructured grid with unshared points. It is a mesh-inspection aid, not a geometric operation for measurements; the curated shrink offers the same with a Schemaxis default.
• pvSlice — ParaView's general Slice filter: cuts any dataset (or hyper tree grid) with an implicit surface (Plane, Box, Sphere or Cylinder) and returns polygonal data, i.e. surfaces from volumes and lines from surfaces, with point data interpolated. SliceOffsetValues produces several parallel copies of the cut surface in one node, and Crinkle slice instead keeps the whole input cells crossed by the surface. Use slice for a simple plane with Schemaxis defaults, pvSliceWithPlane for a faster multithreaded plane cut, or pvAxisAlignedSlice for hyper tree grids.
• pvSliceAlongPolyLine — Cuts a dataset with the curtain surface swept by moving a polyline parallel to the z-axis, like a vertical cross-section along a ship track, river or flight path. Connect the dataset to Dataset and the path (polydata containing a polyline) to PolyLine; the result is polygonal data with interpolated attributes. Only the polyline's x-y path matters. For a single straight cut use pvSlice or slice.
• pvSliceWithPlane — Fast, multithreaded plane cut (vtkPVPlaneCutter) of any dataset, composite dataset, overlapping AMR or hyper tree grid, producing polygonal data with interpolated point data and transferred cell data. It accepts only planes (Plane or Axis Aligned Plane) and, for unstructured input, can build a sphere tree to accelerate repeated cuts. Choose it over pvSlice when a plane is all you need and speed matters, or when slicing AMR data at a chosen level; use pvSlice for spheres, boxes, cylinders or offset copies.
• pvSmooth — Laplacian smoothing of a polygonal surface: each point moves iteratively toward the average of its connected neighbours, for up to NumberofIterations (ParaView default 20) or until the largest motion falls below Convergence. VTK's relaxation factor of 0.01 keeps each step small. Connectivity, point count and arrays are unchanged. Use it to reduce noise or faceting of scanned or iso-surfaces; smooth is the curated version.
• pvSpatioTemporalHarmonics — Adds a point array SpatioTemporalHarmonics (set as active scalars) whose value at point x and time t is the sum over harmonics of A·sin(k·x + ω·t + φ), with t the requested pipeline time and x in dataset coordinates. It produces analytic, time-varying test fields, e.g. to check interpolation, temporal statistics or FFT workflows against known waves.
• pvSpatioTemporalHarmonicsUniformGrid — Generates image data (a uniform grid with spacing 1 over WholeExtent) with a time-dependent point array "SpatioTemporalHarmonics" = Σ A·sin(ω·t + k·x + φ), summed over the listed harmonics, at each listed time step. The ParaView defaults give four harmonics and 20 time steps over one 2π period, so the animation loops. Use it to test temporal filters, animation and time-dependent exports with a known analytic field; use pvWavelet for a static analytic volume.
• pvSphere — Creates a polygonal sphere (or a section of one) with point normals: radius Radius around Center, tessellated by ThetaResolution longitude and PhiResolution latitude divisions. StartTheta/EndTheta (around z, 0 to 360 degrees) and StartPhi/EndPhi (from +z at 0 to -z at 180 degrees) cut out partial spheres. Use it as reference geometry or a probe surface; the curated sphere operation offers Schemaxis defaults.
• pvSplineSource — Creates a smooth curve through control points: a parametric spline (ParametricFunction "Spline", with its own Points and Closed options) tessellated into a polyline of Resolution points. Use it for smooth seed or probe paths and annotation curves; pvPolyLineSource joins the points with straight segments instead.
• pvSpyPlotReader — Reads a CTH Spy Plot case: an ASCII .spcth case file listing the binary files that hold the data. Output port 0 is the volume data (a hierarchical composite of blocks with cell-centred arrays), port 1 the tracers and port 2 the markers. By ParaView default it derives material densities from selected material mass and volume fraction and merges X/Y/Z component arrays into vectors. Use pvRestartedSimSpyPlotReader for a restarted run split over several file sets and pvspcthhistoryreader for history files.
• pvStitchImageDataWithGhosts — Joins image blocks that are separated by a one-voxel gap, such as blocks written independently by each process, by generating ghost points at the new interfaces, so the partitions behave as one continuous image. Input is image data or a composite of images with point data only. Use it before contouring or gradients on such tiled images to avoid gaps.
• pvStreakLine — Computes streaklines in an unsteady (time-dependent) vector field: particles are released from every SeedSource point at each input time step and advected through the changing field, and the particles released from the same place are joined into lines, the analogue of continuous dye injection. ParaView requests the input time steps itself, from the first step up to the requested time, so the input must have at least two time steps and a 3-component point vector field. Output is polydata (polylines, single points as vertices) with ParticleAge, ParticleId, InjectedPointId and the interpolated input arrays. Use pvStreamTracer for a steady snapshot and pvTemporalParticlesToPathlines to draw trails of existing particles.
• pvStreamTracer — Integrates steady streamlines through one time step of a 3-component vector field, forward, backward or both, from seeds made by the built-in SeedType generator (Point Cloud, the ParaView default, or Line). The output is polydata polylines carrying the input point arrays interpolated along each line, IntegrationTime, and cell arrays SeedIds and ReasonForTermination (1 left the domain, 4 maximum length, 5 maximum steps, 6 below terminal speed); with ComputeVorticity on (ParaView default) Vorticity, Rotation, AngularVelocity and Normals are added. Use the curated streamTracer for the common case, pvStreamTracerWithCustomSource to seed from another node's points, and pvStreakLine or pvTemporalParticlesToPathlines for unsteady flow.
• pvStreamTracerWithCustomSource — Integrates steady streamlines like pvStreamTracer, but every point of a second input (SeedSource) that lies inside the dataset starts a streamline, so any node's points can seed it: a probe line, a slice, an inlet patch or points read from a file. The vector field must be point-centred with 3 components. The output is polydata polylines carrying the input point arrays interpolated along each line, IntegrationTime, and cell arrays SeedIds and ReasonForTermination (1 left the domain, 4 maximum length, 5 maximum steps, 6 below terminal speed); with ComputeVorticity on (ParaView default) Vorticity, Rotation, AngularVelocity and Normals are added. With direction BOTH, N seeds give up to 2N lines.
• pvSubdivide — Refines a triangle mesh linearly: each pass splits every triangle into four by adding a point at the midpoint of each edge, so the original surface shape and points are kept exactly while the resolution increases. Use it to give a coarse triangulated surface more points before interpolating onto it, warping or sampling. Input must be polydata of triangles (run triangulate first); use pvLoopSubdivision for a smoothed surface.
• pvSuperquadric — Creates a superquadric surface with normals and texture coordinates: one family covering ellipsoids, rounded boxes, cylinders and tori, chosen by the ThetaRoundness and PhiRoundness exponents (1 = round, near 0 = square-edged, above 1 = pinched). With Toroidal true (the ParaView default) it is a torus-like ring whose hole size is set by Thickness. Use it for test geometry or glyph shapes.
• pvSurfaceFlow — Computes the net flux of a point vector field through a surface: at each point it takes the dot product of the vector with a normal averaged from the neighbouring 2-D cells, then integrates it over the surface with Integrate Variables. The output is a one-point unstructured grid whose point array Surface Flow holds the integral (vector units times area), e.g. a volumetric flow rate when the vector is velocity. Use it on a slice, a boundary patch or any 2-D surface; integrate gives other surface integrals.
• pvSurfaceNormals — Computes point normals (array Normals) on polygonal surfaces by averaging the normals of the polygons around each point, for smooth shading and for operations that need surface normals. By ParaView default polygon ordering is made consistent and points are split along edges sharper than FeatureAngle (30 degrees), keeping edges crisp but duplicating points; cell normals can be output too. The curated normals operation uses the same algorithm with Schemaxis defaults (splitting off).
• pvSurfaceTangents — Computes per-point tangent vectors (array Tangents) of a triangulated surface from its point normals and texture coordinates, as required for normal-map texturing in rendering. The input must be triangle polydata with point Normals and texture coordinates; the output is the same polydata with tangents added. Use it only for textured rendering; it has no analysis meaning.
• pvSurfaceVectors — Constrains a point vector field on a 2-D surface relative to the local surface normal (averaged from neighbouring 2-D cells). Parallel removes the normal component, leaving the tangential part (e.g. wall shear direction or surface streamlines); Perpendicular keeps only the normal component; PerpendicularScale outputs the signed normal component as a new scalar array named Perpendicular Scale. The modified vectors keep the input array name; geometry is unchanged. pvSurfaceFlow uses the PerpendicularScale mode internally to compute fluxes.
• pvSynchronizeTime — Snaps the time values of one dataset to those of another. DataToPass supplies the data and its time steps; any of its time values within RelativeTolerance × (its time range) of a TimeToSync time value is replaced by that value, so both sources report identical times, e.g. a simulation written at 0.1000001 s and experimental data at 0.1 s. The output keeps DataToPass's data and number of time steps; only the time labels change.
• pvTIFFReader — Reads one TIFF file (.tif, .tiff) into uniform image data; it is kept for backward compatibility, and pvTIFFSeriesReader reads the same files with stacking, time series and custom spacing added. Spacing comes from the TIFF resolution tags when present (converted to millimetres for inch or centimetre units), otherwise 1.
• pvTIFFSeriesReader — Reads TIFF images (.tif, .tiff; 8- or 16-bit integer or 32-bit float) into uniform image data. Several files are stacked as z slices by default (ReadAsImageStack true) or read as a time series. Spacing comes from the TIFF resolution tags (millimetres for inch or centimetre units, otherwise 1) unless UseCustomDataSpacing applies CustomDataSpacing. Pair with pvWriteTIFFWriter for round trips; use pvOMETIFFReader for OME-TIFF.
• pvTRUCHASReader — Reads output of TRUCHAS (Los Alamos casting, solidification and heat-transfer code) stored in HDF5 into a multiblock dataset, with selectable mesh blocks and point and cell arrays at each stored time step. Use it to inspect temperature, phase fraction or flow fields of casting simulations.
• pvTableFFT — Computes the discrete Fourier transform of every numeric column of a table (columns whose names start with vtk are skipped; 2-component columns are treated as complex), returning a table of spectra. The sampling rate is taken from a column named Time (any capitalization, assumed evenly spaced) or else from DefaultSampleRate (ParaView default 10000 Hz), and a Frequency column is added by default. Use it for spectra of probe histories, e.g. pressure fluctuations over time from a plot-over-time table; enable UseWelchMethod for an averaged, smoother spectrum of long noisy signals.
• pvTableToPoints — Turns a table (e.g. a CSV file of x, y, z samples) into polydata points: three numeric columns give the coordinates and the other columns become point arrays. The coordinate columns are removed from the arrays unless KeepAllDataArrays is on; with a2DPoints the Z column is ignored and z = 0. Use it to place measurement or particle data in space for probing, interpolation or glyphs.
• pvTableToStructuredGrid — Turns a table into a curvilinear structured grid: X, Y and Z columns give the point coordinates, row order is point order with i varying fastest, then j, then k, and the other columns become point arrays. WholeExtent gives the grid's index ranges, and the table must have exactly (imax-imin+1)(jmax-jmin+1)(kmax-kmin+1) rows. Use it for gridded data exported row by row, e.g. a CSV of a structured solver block; use pvTableToPoints for scattered points.
• pvTecplotReader — Reads ASCII Tecplot files (.dat, .tec, .tp) into a multiblock dataset with one block per zone; each block is a structured grid (ordered zones) or unstructured grid (finite-element zones). Point-packed zones give point data only; block-packed zones may carry point or cell data. Several files form a time series. Use pvTecplotTableReader for Tecplot data that is a plain table, and pvVisItTecplotBinaryReader for binary .plt files.
• pvTecplotTableReader — Reads a Tecplot ASCII data file (.dat) as a table (vtkTable): one column per variable and one row per data record, with column names taken from a header line. It creates no geometry, so it suits point-wise or line data for plots and table exports. Use pvTecplotReader for Tecplot zone (mesh) data and pvCSVReader for comma-separated tables.
• pvTemporalArrayOperator — Combines one array at two of the input's stored time steps, chosen by zero-based indices (FirstTimeStepIndex, SecondTimeStepIndex), with +, -, * or / applied value by value as first-operator-second. The output is the dataset at the second step plus one new array named after the input array with a suffix (by default _add, _sub, _mul or _div), e.g. p_sub for the pressure change between two saved times. Both steps must hold the array with the same number of tuples and components, so the mesh must not change. Use temporalStatistics or pvTemporalStatistics for averages over all steps.
• pvTemporalCache — Keeps copies of the input at up to CacheSize recently requested time steps (ParaView default 2, range 2 to 10) and returns a cached copy when the same time is requested again, instead of re-running the upstream pipeline. Data and time values are unchanged. It helps when downstream temporal filters, e.g. pvTemporalInterpolator, repeatedly request the same steps from an expensive reader or filter chain.
• pvTemporalCacheSource — The same cache as pvTemporalCache (vtkTemporalDataSetCache), registered by ParaView as a source with IsASource true, the configuration meant for Catalyst in-situ pipelines: it then reports only the times currently held in the cache as its time steps and keeps entries even when the upstream pipeline changes, so it can hold a short history of a live simulation. For post-processing stored results use pvTemporalCache.
• pvTemporalInterpolator — Linearly interpolates point coordinates and point and cell arrays between the two stored time steps around a requested time, so data can be obtained at times the input did not save; ParaView uses vtkAdaptiveTemporalInterpolator, which also copes when the mesh appears to change between steps. By ParaView default it reports the input's own steps; DiscreteTimeStepInterval reports evenly spaced steps instead and ResampleFactor adds steps inside each stored interval. The input needs at least two time steps, and interpolated values are a linear approximation, not solver results.
• pvTemporalParticlesToPathlines — Builds trails from moving particles: it takes a point set whose points move between time steps (e.g. Lagrangian particles read from a solver, or a particle tracer's output) and joins each particle's successive positions into a polyline. ParaView loops over the input times itself up to the requested time. Output port 0 (Pathlines) holds the trails with TrailId and TrackLength; port 1 (Particles) holds one vertex at each trail's head. Particles are matched by IdChannelArray (global ids or point index by default). Use pvStreakLine to compute particle motion from a velocity field instead.
• pvTemporalShiftScale — Relabels time without touching the data: an input time t is reported as (t + PreShift) × Scale + PostShift, and a request for output time T fetches input time (T − PostShift) / Scale − PreShift. Use it to align runs that started at different times, change time units (Scale 0.001 turns milliseconds into seconds), or repeat a cyclic dataset with Periodic. Nothing is resampled; use pvTemporalInterpolator for in-between states.
• pvTemporalSmoothing — Replaces each point and cell array value by its plain (unweighted) mean over a sliding window of 2 × TemporalWindowHalfWidth + 1 stored time steps centred on the requested step. The output is still temporal, but loses HalfWidth steps at each end of the series, and requests outside the remaining range use the nearest available step. Use it to suppress step-to-step noise in transient results; the number and order of points and cells must not change over time.
• pvTemporalSnaptoTimeStep — Makes a request for any time return the data of one of the input's stored time steps: SnapMode picks the nearest stored step (ParaView default), the last step at or below, or the first step at or above the requested time. Data are neither modified nor interpolated. Use it when scene times do not match the saved solver times exactly; use pvTemporalInterpolator to blend between steps instead.
• pvTemporalStatistics — Computes, for every point and cell array of a time-dependent input, its average, minimum, maximum and population standard deviation over all input time steps, which the filter requests itself. The output has the input's type and geometry, no time, and arrays named <name>_average, <name>_minimum, <name>_maximum and <name>_stddev (other arrays are not kept). Every step is weighted equally regardless of time spacing, so this is not a time integral. This is the generated binding with native names (ComputeAverage, …); the curated temporalStatistics does the same with shorter option names.
• pvTensorGlyph — Places a glyph (sphere by ParaView default; cylinder, box or superquadric) at every point and scales and orients it by the eigen-decomposition of the symmetric part of a point tensor: the major eigenvalue scales the glyph's x axis along the major eigenvector, the medium y, the minor z. Tensors may have 9 components or 6 symmetric components ordered XX, YY, ZZ, XY, YZ, XZ. Output is polydata, by default coloured by input scalars. Use it for stress, strain or diffusion tensors; pvGlyph handles vectors.
• pvTensorPrincipalInvariants — Computes the principal values and principal directions of selected symmetric tensor arrays (for example stress or strain). For each selected array <name> it adds <name> - Sigma 1, 2 and 3 (values sorted from largest to smallest) and the matching <name> - Sigma n (Vector) direction arrays, keeping the input arrays. Accepted tensors have 6 components in the order XX, YY, ZZ, XY, YZ, XZ, or 3 components named XX, YY, XY for 2-D tensors. Use pvYieldCriteria when you need Tresca or von Mises values.
• pvTessellate — Subdivides cells with non-linear geometry or fields (quadratic and higher-order cells) into linear simplices (tetrahedra, triangles or lines up to OutputDimension) until the chord error and optional per-field errors at edge midpoints fall below their limits, giving an unstructured grid that approximates curved geometry and fields with linear pieces. Use it before operations or exports that only handle linear cells; linear input is just split into simplices.
• pvTest3DWidget — ParaView-internal test proxy: a vtkConeSource exposing only Resolution, with VTK's cone defaults (height 1, radius 0.5, apex along +x, centred at the origin). It exists to test 3-D widgets and has no analysis purpose; use pvCone or the curated cone operation for real cone geometry.
• pvTetrahedralize — Splits all 3-D cells into tetrahedra and 2-D cells into triangles, producing an unstructured grid; point data are unchanged and cell data are copied to the pieces. Use it when a later step or export needs simplices only. ParaView warns on creation because the cell count can grow several-fold.
• pvText — Source that produces a one-row, one-column table whose Text column holds the whole Text string as a single cell; the string is not split. ParaView's help describes '|' as a column separator and newlines as rows, but that applies to ParaView's text display of the table, not to the table vtkPVTextSource outputs. Use it for titles, captions or a fixed label; use pvAnnotateTime or pvAnnotateAttributeData for text derived from time or data.
• pvTextureMaptoCylinder — Adds 2-D texture coordinates (point array "Texture Coordinates") by projecting each point onto a cylinder: s follows the angle around the axis and t the position along it, 0 at Point1 and 1 at Point2. The axis is fitted automatically from an oriented bounding box (ParaView default) or given by Point1 and Point2. Use it to wrap an image texture around roughly cylindrical geometry such as pipes or vessels; pvTextureMaptoPlane suits flat parts. The geometry and other arrays pass through unchanged.
• pvTextureMaptoPlane — Adds 2-D texture coordinates (point array "Texture Coordinates") by projecting each point onto a plane. In automatic mode (ParaView default, used while Origin and Point1 are both [0, 0, 0]) a least-squares plane is fitted and s and t run from 0 to 1 across the projected bounds. Otherwise s is the projection of (point − Origin) on Point1 − Origin, divided by that edge's squared length, and t likewise with Point2, so s and t are 0 at Origin and 1 at Point1 or Point2. Use it to drape an image (e.g. a photograph or map) on a flat or gently curved surface; pvTextureMaptoCylinder suits round parts.
• pvTextureMaptoSphere — Adds 2-D texture coordinates (array Texture Coordinates) by projecting each point onto a sphere centred at the mean of the input points: s runs around the z axis, counter-clockwise from +x, and t increases from the north pole towards the south pole, both within 0 to 1. Use it to wrap an image texture, e.g. a map, onto roughly spherical geometry in rendered scenes; geometry and data values are unchanged.
• pvThreshold — Extracts the cells whose values of a chosen point or cell array satisfy a criterion (Between LowerThreshold and UpperThreshold, below the lower or above the upper), producing an unstructured grid (or a masked hyper tree grid). It exposes the full native control: component handling for vector arrays (one component, magnitude, All or Any), Invert, AllScalars for point data and a continuous cell range. Use threshold for the common inclusive range test with validated field names; use pvClip with a scalar clip for smooth cuts through cells.
• pvThresholdSelectionSource — Creates a threshold selection: elements whose value of ArrayName lies inside any of the [min, max] ranges in Thresholds (inclusive), on cells or points per FieldType. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. Unlike threshold or pvThreshold it does not change the data by itself, so the same selection can be reused, inverted with InsideOut or grown with NumberOfLayers.
• pvThresholdTable — Keeps the rows of a table (vtkTable) whose value in one numeric column satisfies a threshold: below MaxValue, above MinValue, between them, or outside them. The output is a table with the same columns and the same or fewer rows. Use it to filter CSV data, statistics output or probe tables; use threshold or pvThreshold for meshes.
• pvTimeSource — Test source with time: an unstructured grid of one unit voxel cell (or a column of voxels along y that grows and shrinks over time when Growing is on) carrying "Point Value" and "Cell Value" arrays equal to sin(2πt) plus label and coordinate arrays, over the time range 0 to 1 with ten discrete steps. XAmplitude and YAmplitude move the cell along a sine path over time. Use it to check time handling ($time, animation, temporal filters) without a real case.
• pvTimeStepProgressBar — Produces a one-row, one-column table with a ProgressRate value between 0 and 1 giving the position of the input's current time within its time steps or time range. In ParaView it drives a progress-bar annotation in an animation; in Schemaxis the result is just that table. Any time-dependent input works; the input data are not passed through.
• pvTransform — Applies a translation, rotation and scaling (Transform, ParaView default the Transform3 'Transform' choice, identity until set) to point coordinates. Point-set inputs keep their type; image and rectilinear inputs come out as structured grids. Vectors and normals are rotated with the geometry and, with TransformAllInputVectors (ParaView default true), every other 3-component array too. The curated transform is the simpler alternative.
• pvTransposeTable — Builds a sub-table from selected columns of a table and, by default, transposes it so that each selected column becomes a row; a first column holding the original column names is added by default. With Onlyextractselectedcolumns it skips the transposition and simply returns the selected columns. Use it to reshape statistics or probe tables for plotting or export.
• pvTriangleStrips — Joins triangles into triangle strips and line segments into polylines (vtkStripper), giving more compact polydata with the same geometry. Other polygons and existing strips or polylines pass through, and cell data is discarded because the cells change. Its main use in workflows is joining separate segments into polylines (JoinContiguousSegments), e.g. contour or slice lines before pvDecimatePolyline, pvPolylineLength or tube.
• pvTriangulate — Converts polygonal data to triangles, lines and vertices only: polygons are triangulated, triangle strips split into triangles and polylines into single segments (vtkTriangleFilter). The output stays polydata with the same points. Use it before operations that need triangles, such as decimate, pvDecimate or pvSurfaceTangents, or before triangle-only exports; triangulate is the curated equivalent and pvTetrahedralize handles volume cells.
• pvTrivialProducer — Wraps an already-existing VTK data object so it can feed a pipeline (vtkTrivialProducer). The data must be attached by native code (SetOutput); authored Schemaxis input cannot do that, so in a workflow this source has nothing to produce. Schemaxis uses the class internally in its writer qualification tool, not as an authoring operation. Use a reader or a source operation for real data.
• pvTube — Wraps every line or polyline of polygonal input in a tube of NumberofSides faces (ParaView default 6) and Radius, producing polydata surfaces. VaryRadius can make the radius follow a point scalar or vector array, up to RadiusFactor times Radius. The cross-section is oriented by the input's point Normals array, by normals generated along each line, or by DefaultNormal when UseDefaultNormal is true. Use it to render streamlines, particle paths or wire models in 3-D; tube is the curated version.
• pvUnstructuredCellTypes — Generates an unstructured grid made of one chosen cell type (linear, quadratic, Lagrange or Bezier lines, triangles, quads, tetrahedra, hexahedra, wedges, pyramids, polyhedra…) by filling a BlocksDimensions grid of unit blocks starting at the origin; one block may hold several cells (e.g. six pyramids). Point arrays "DistanceToCenter" and "Polynomial" give known fields. Use it to test how filters, writers or renderers handle a specific cell type or element order.
• pvUnstructuredNetCDFPOPreader — Reads Parallel Ocean Program (POP) NetCDF output (.pop.nc, .pop.ncdf) and converts its logically structured grid into an unstructured grid on a sphere: horizontal positions come from a companion GRID.nc file in the same folder, and each layer's depth_t is subtracted from an Earth radius of 6371000 (metres), so deeper layers lie closer to the sphere's centre. Stride subsamples and VOI crops the structured index space before conversion. Use pvNetCDFPOPreader for the structured form.
• pvVASPAnimationReader — Reads a VASP molecular-dynamics animation file (NPT_Z_ANIMATE.out) into a time-varying vtkMolecule, one frame of atom positions per time step. Use it to animate or analyse trajectories from VASP runs; pvVASPTessellationReader reads the matching Voronoi tessellation file. vtkMolecule output needs pvMoleculeToLines before ordinary dataset filters.
• pvVASPTessellationReader — Reads a VASP NPT_Z_TESSELLATE.out file. Output port 0 is the molecule (vtkMolecule) and port 1 the Voronoi tessellation of the atoms as an unstructured grid, one cell per atom, for each time step. Select port 1 with {"node": id, "port": 1} to measure or render Voronoi cells. Use pvVASPAnimationReader for the trajectory alone.
• pvVPICReader — Reads VPIC kinetic plasma particle-in-cell output through its ASCII .vpc file, which describes the per-processor data files, grid size and time steps. Field and hydro quantities are assembled into one uniform image (vtkImageData) of point arrays. Stride subsamples the grid, and XExtent, YExtent and ZExtent restrict which simulation files (the per-processor tiling of the domain) are read, so a subregion can be viewed at full resolution. This is a distributed reader.
• pvVRMLReader — Reads the geometry of a VRML 2.0 scene (.wrl, .vrml) through VTK's VRML importer: shapes become polygonal data that, by default, are appended into one block of a multiblock output with a colour array; lights, cameras and textures are dropped. Use it to bring VRML exports from CAD or visualization tools into a pipeline as surfaces.
• pvVTKHDFReader — Reads VTK's HDF5-based VTKHDF format (.vtkhdf, .hdf): image data, polydata, unstructured grids, overlapping AMR, hyper-tree grids, partitioned collections and multiblock data, including transient data stored in one file. MergeParts (ParaView default true) merges partitioned pieces into one dataset. Several files in FileName form a time series. Choose it for large VTK data written by vtkHDFWriter or simulation codes; use the XML readers (pvXMLUnstructuredGridReader and others) for .vtu/.vtp-style files.
• pvValidateCells — Checks every cell for defects that break other filters and adds a cell array ValidityState: 0 for a valid cell, otherwise a bit field of problems such as wrong number of points, intersecting edges or faces, non-contiguous edges, non-convexity, or wrongly oriented faces. Geometry and arrays pass through. Use it to diagnose meshes that fail in clipping, integration or export, then threshold on ValidityState to locate bad cells.
• pvValueSelectionSource — Creates a value selection: elements whose value of ArrayName equals one of the listed integer values, e.g. all cells with MaterialId 3 or 7. The output is a vtkSelection (no geometry) for the Selection port of pvExtractSelection or pvAnnotateSelection. ParaView documents that it cannot select within composite datasets. Use pvThresholdSelectionSource for value ranges or floating-point data.
• pvVelodyneAMRReader — Reads Velodyne AMR files (.xamr) into an overlapping AMR dataset: nested refinement levels of uniform blocks with cell-centred variables. Level sets the finest level loaded, counted from the root level 0 (ParaView default 15, which in practice loads all levels of most files), and every variable starts disabled, so name the ones you need in CellArrayStatus. Several files form a time series. pvVisItVelodyneReader is the VisIt-based alternative for Velodyne data.
• pvVisItANSYSReader — Reads an ASCII ANSYS input deck (.inp) through VisIt's ANSYS plugin: the nodes and elements in its NBLOCK and EBLOCK blocks become one unstructured-grid block named "mesh". The plugin defines no variables or materials, so the result is geometry only. ParaView 5.13.3 has no native reader for ANSYS input decks in the Schemaxis catalogue. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItAUXFileReader — Reads an ASCII .aux fluence file through VisIt's AUXFile plugin: the output is a 2-D rectilinear grid named "mesh" carrying one point array, "fluence". The format is documented only by the plugin source; choose this reader only for files written in that layout. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItBOVReader — Reads VisIt's BOV (brick of values) format: a short text header (.bov) giving DATA_FILE, DATA_SIZE, DATA_FORMAT, BRICK_ORIGIN, BRICK_SIZE, VARIABLE and CENTERING for one raw binary array on a regular grid. The output is a rectilinear-grid block named "mesh" carrying that one variable. Use pvImageReader instead for raw volumes without a BOV header, where you supply dimensions, spacing and data type yourself. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItCEAucdReader — Reads the CEA (French Alternative Energies and Atomic Energy Commission) variant of AVS UCD (.ucd, .inp), where a case is split into per-domain UCD files plus a root file holding time, cycle and material names. The output is one unstructured mesh named "mesh" with one domain per file, point and cell arrays from the files and optional material volume fractions. For ordinary single-file AVS UCD data use the native pvAVSUCDReader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItCMATReader — Reads ASCII output of the CMAT Fortran simulation code (.cmat): a 2-D rectilinear mesh named "Mesh" with one cell-centred variable "M". Neither ParaView nor VisIt documents the code further; choose this reader only for CMAT output. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItCTRLReader — Reads the control (ctrl) input file of the TB-LMTO (tight-binding linear muffin-tin orbital) electronic-structure code: the atom sites become a point mesh named "mesh" with a point array "element". VisIt's element-name labels and unit-cell metadata are not converted by the bridge, so the result is a point cloud of sites, not a molecule with bonds. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItChomboReader — Reads HDF5 plotfiles from the Chombo block-structured adaptive mesh refinement framework (LBNL). With only the AMR mesh selected the output is vtkOverlappingAMR (patches on refinement levels); with other meshes selected it is a multiblock dataset. ParaView 5.13.3 has no native Chombo reader; AMReX/BoxLib plotfiles should use pvAMReXBoxLibGridReader instead. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItClawReader — Reads Clawpack/AMRClaw ASCII output through a small .claw boot file whose DIR=, TIME_FILES_SCANF/REGEX and GRID_FILES_SCANF/REGEX (and optional CYCLE_REGEX) lines locate the time-header and grid-data files. The output is a multiblock dataset in which "claw_mesh" holds every grid of every refinement level, with cell-centred solution components. The captured ParaView summary ("a material-ordered format very similar to IOUT=1") does not describe what the plugin source reads. One file supplies every time step the format stores.
• pvVisItCurve2DReader — Intended for VisIt's ASCII curve format (.curve, .ultra, .ult, .u): named x-y curves, one pair per line. The plugin describes these as VisIt curves, but the bridge converts only meshes listed in the plugin metadata (vtkAvtFileFormatAlgorithm), so the output is probably an empty multiblock; this has not been verified. For x-y columns prefer pvCSVReader, then pvTableToPoints or a table plot. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItDDCMDReader — Reads particle and atom snapshot files from ddcMD, LLNL's domain-decomposition molecular dynamics code. Particle files become a point mesh with per-particle fields (species, type, group and the recorded quantities); cgrid files become a rectilinear grid. ParaView 5.13.3 has no native ddcMD reader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItDyna3DReader — Reads DYNA3D input decks (.dyn) for LLNL's explicit finite-element structural code: control, material, node and element cards become one unstructured mesh named "mesh" with material volume fractions and per-element material properties (density, strength, plastic strain, material number). It reads model input, not results; LS-DYNA d3plot result databases need pvLSDynaReader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItExtrudedVolReader — Reads VisIt's ExtrudedVol format: a text header (.exvol) naming a file stem, a chunk count, a time count and variables, with connectivity and variable files per chunk. The output is an unstructured mesh named "wedge_mesh" with node-centred variables. VisIt itself can write this format; ParaView has no other reader for it. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItFLASHReader — Reads HDF5 checkpoint and plot files of the FLASH multiphysics AMR code. With only "amr_mesh" selected the output is vtkOverlappingAMR; adding particles or diagnostic meshes gives a multiblock dataset. The native pvFlashReader (hierarchical-box AMR) and pvFLASHAMRParticlesReader are the usual choice; use this reader to cross-check them or to get the AMR blocks and particles from one node. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItFluentReader — Reads a legacy ANSYS Fluent case file (.cas) together with the .dat data file of the same name: the mesh becomes one unstructured block named "Mesh" with cell-centred solution fields. The native pvFluentCaseReader (legacy .cas/.dat, distributed) and pvFluentCFFCaseReader (.cas.h5/.dat.h5) are normally preferable; this reader is a cross-check when the native reader rejects a file. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItGGCMReader — Reads output of the (Open)GGCM Geospace General Circulation Model of the magnetosphere (.3df and .mer files; the plugin derives the companion grid-file name from the data-file name). The output is a rectilinear grid named "GGCM mesh" with node-centred fields. ParaView 5.13.3 has no native GGCM reader. One file supplies every time step the format stores.
• pvVisItGTCReader — Reads HDF5 particle output of GTC, the Gyrokinetic Toroidal Code for fusion-plasma turbulence: the particles become a point mesh named "particles" with node-centred particle properties. ParaView 5.13.3 has no native GTC reader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItGULPReader — Reads trajectory files (.trg) from GULP, the General Utility Lattice Program for atomistic simulation: each frame becomes a time step of a point mesh of atoms named "mesh" with per-atom energy, velocity and force components. ParaView 5.13.3 has no native GULP reader. One file supplies every time step the format stores.
• pvVisItGadgetReader — Reads snapshot files of Gadget-2, the cosmological N-body/SPH code: particle positions become a point mesh named "POS " and the other particle blocks become arrays. ParaView 5.13.3 has no native Gadget reader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItH5NimrodReader — Reads HDF5 output of NIMROD, the extended-MHD code for fusion plasmas, in its H5Nimrod data model (.h5nimrod): a curvilinear mesh with node- and cell-centred fields over several time steps. ParaView 5.13.3 has no native NIMROD reader. One file supplies every time step the format stores.
• pvVisItImageReader — Reads images through VisIt's Image plugin: PNM/PPM, Stimulate SDT/SPR and .imgvol image stacks. It offers two rectilinear meshes, "ImageMesh" with pixel values as cell data and "ImageMesh_nodal" with them as point data. For PNG, JPEG or TIFF series the native pvPNGSeriesReader, pvJPEGSeriesReader and pvTIFFSeriesReader give vtkImageData directly; pvImageReader handles headerless raw volumes. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItLAMMPSDumpReader — Reads LAMMPS molecular-dynamics dump files (.dump, text with ITEM: sections) in which one file holds many time steps: each step becomes a time of a point mesh of atoms with the dumped per-atom columns as point arrays. ParaView 5.13.3 has no native LAMMPS dump reader; pvVisItLAMMPSStructureReader reads LAMMPS structure files instead. One file supplies every time step the format stores.
• pvVisItLAMMPSStructureReader — Reads LAMMPS atom structure files (registered for .eam, .meam, .rigid and .lammps): atom positions become a point mesh named "mesh" with per-atom id and species arrays. Use pvVisItLAMMPSDumpReader for dump trajectories. ParaView 5.13.3 has no native reader for these files. One file supplies every time step the format stores.
• pvVisItLinesReader — Reads VisIt's ASCII Lines format (.lines): named polylines given as coordinate lists. The output is one unstructured mesh named "Lines" of line cells, with no variables. For point coordinates in CSV columns pvCSVReader with pvTableToPoints is the native route. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItM3DC1Reader — Reads HDF5 output of M3D-C1, the high-order finite-element extended-MHD code for tokamak plasmas: the element mesh and the equilibrium mesh become unstructured blocks with node- and cell-centred fields over several time slices. The plugin's VisIt read options stay at their defaults. ParaView 5.13.3 has no native M3D-C1 reader. One file supplies every time step the format stores.
• pvVisItM3DReader — Reads output of M3D, the multilevel 3-D MHD code for fusion plasmas (.m3d, .h5): an unstructured mesh named "mesh" with node-centred fields over the stored time steps. ParaView 5.13.3 has no native M3D reader; for M3D-C1 output use pvVisItM3DC1Reader. One file supplies every time step the format stores.
• pvVisItMFIXCDFReader — Reads the netCDF-based output of MFiX (NETL's Multiphase Flow with Interphase eXchanges code): the fluid grid "Mesh" with cell-centred gas and solids fields over time, plus a "flagclass" mesh of cell flags. The native pvMFIXReader reads the classic .RES/SP* format, not this netCDF variant. One file supplies every time step the format stores.
• pvVisItMFIXReader — Reads classic MFiX output: the .RES restart file (mesh and run information) with its SP* result files. The output is the fluid grid "Mesh" with cell-centred fields over time. The native pvMFIXReader reads the same files into an unstructured grid and is normally preferable; use this reader as a cross-check or for the flag-class mesh. One file supplies every time step the format stores.
• pvVisItMM5Reader — Reads output of the PSU/NCAR Mesoscale Model (MM5) for regional weather simulation: rectilinear grids with cell-centred meteorological fields over the stored times. ParaView 5.13.3 has no native MM5 reader; netCDF output from MM5's successor WRF can often use pvNetCDFReader instead. One file supplies every time step the format stores.
• pvVisItMiliReader — Reads Mili, LLNL's engineering results database used by structural finite-element codes: open the .mili JSON root file, from which the plugin locates the per-processor state files. The output is a multiblock of unstructured meshes with materials and node and element results over time. ParaView 5.13.3 has no native Mili reader; the Mili plugin is an optional part of the VisIt bridge. One file supplies every time step the format stores.
• pvVisItMirandaReader — Reads raw output of Miranda, LLNL's high-order hydrodynamics code for turbulent mixing, through its text .mir metadata file (gridfiles, datafiles, domainsize, blocksize, origin, spacing, variables, materials). The output is the block-decomposed "mesh" with the listed variables and material volume fractions over time. ParaView 5.13.3 has no native Miranda reader. One file supplies every time step the format stores.
• pvVisItNASTRANReader — Reads NASTRAN bulk data decks (.nas) into one unstructured mesh named "mesh" with element groups as materials; no results are read. The native pvBDFReader reads NASTRAN bulk data in free format; this reader also handles fixed and large-field cards, so use it when the native reader rejects a deck. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItNek5000Reader — Reads Nek5000 spectral-element CFD output through its small metadata file (.nek3d, .nek5000, …) whose filetemplate, firsttimestep and numtimesteps lines locate the field dumps. The output is the element mesh with node-centred velocity, pressure, temperature and scalars over time. The native pvNek5000Reader reads the same metadata file into an unstructured grid and is distributed; prefer it for parallel runs. One file supplies every time step the format stores.
• pvVisItNetCDFADAPTReader — Reads netCDF files written by ADAPT, an LLNL atmospheric modelling format that VisIt's netCDF plugin recognises by its specific variables. One file holds one time; a list of files forms a series. For netCDF following the CF/COARDS conventions the native pvNetCDFReader is the general choice. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItNetCDFCCSM_MTSDReader — Reads netCDF history files of the CCSM (Community Climate System Model) in which one file holds several time records; each record becomes a time step. Use pvVisItNetCDFCCSM_STSDReader when each file holds one time. The native pvNetCDFReader reads CF-compliant climate files with optional spherical coordinates and is usually the first choice. One file supplies every time step the format stores.
• pvVisItNetCDFCCSM_STSDReader — Reads netCDF history files of the CCSM (Community Climate System Model) that hold one time record each; a list of files forms the time series. Use pvVisItNetCDFCCSM_MTSDReader when one file holds many records. The native pvNetCDFReader reads CF-compliant climate files and is usually the first choice. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItNetCDFFVCOMParticleReader — Reads Lagrangian particle-tracking files written by FVCOM (Finite-Volume Community Ocean Model): particle positions over time become a point mesh with per-particle quantities. The ocean fields themselves need pvVisItNetCDFFVCOM_MTSDReader, pvVisItNetCDFFVCOM_MTMDReader or pvVisItNetCDFFVCOM_STSDReader. One file supplies every time step the format stores.
• pvVisItNetCDFFVCOM_MTMDReader — Reads FVCOM (Finite-Volume Community Ocean Model) netCDF output on an unstructured triangular grid with sigma layers and levels through a master file that ties several domain files together (multi-time, multi-domain). Use pvVisItNetCDFFVCOM_MTSDReader for a single file with many times and pvVisItNetCDFFVCOM_STSDReader for one time per file. If the output follows the UGRID conventions, the native pvNetCDFUGRIDreader is an alternative. One file supplies every time step the format stores.
• pvVisItNetCDFFVCOM_MTSDReader — Reads FVCOM (Finite-Volume Community Ocean Model) netCDF output on an unstructured triangular grid with sigma layers and levels where one file holds many time records. Use pvVisItNetCDFFVCOM_MTMDReader for multi-domain master files and pvVisItNetCDFFVCOM_STSDReader for one time per file. If the output follows the UGRID conventions, the native pvNetCDFUGRIDreader is an alternative. One file supplies every time step the format stores.
• pvVisItNetCDFFVCOM_STSDReader — Reads FVCOM (Finite-Volume Community Ocean Model) netCDF output on an unstructured triangular grid with sigma layers and levels where each file holds one time; a list of files forms the series. Use pvVisItNetCDFFVCOM_MTSDReader when one file holds many times. If the output follows the UGRID conventions, the native pvNetCDFUGRIDreader is an alternative. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItNetCDFLODIParticleReader — Reads netCDF particle files of LODI, LLNL's Lagrangian atmospheric dispersion model: particle positions over time become a point mesh with per-particle quantities and, where defined, source groups as materials. Gridded LODI concentrations need pvVisItNetCDFLODIReader. One file supplies every time step the format stores.
• pvVisItNetCDFLODIReader — Reads gridded netCDF output of LODI, LLNL's Lagrangian atmospheric dispersion model, with several time records in one file. Particle files of the same model need pvVisItNetCDFLODIParticleReader; generic CF-compliant netCDF uses pvNetCDFReader. One file supplies every time step the format stores.
• pvVisItOVERFLOWReader — Reads binary Fortran grid and solution files of NASA's OVERFLOW overset-grid CFD solver (.dat, .save): every overlapping curvilinear grid becomes a domain of "mesh" with node-centred solution variables. The native pvPLOT3DReader reads standard PLOT3D grid and solution files; use this reader for OVERFLOW's own files. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItOpenFOAMReader — Reads an OpenFOAM case through VisIt's OpenFOAM plugin (a variant of VTK's OpenFOAM reader): open the case's system/controlDict file. The output is a multiblock with the selected internal mesh, patches, zones and Lagrangian clouds, with fields over all time directories. Prefer foam (Schemaxis-curated, with checked defaults) or the native pvOpenFOAMReader, which handle decomposed cases and region selection; this reader is mainly a cross-check. One file supplies every time step the format stores.
• pvVisItPATRANReader — Reads MSC PATRAN neutral files (.neu), ASCII packet files describing unstructured finite-element geometry: one unstructured mesh named "mesh" with element attributes as cell arrays and named components as materials. ParaView 5.13.3 has no native PATRAN reader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItPFLOTRANReader — Reads HDF5 output of PFLOTRAN, the parallel subsurface flow and reactive-transport code: a rectilinear grid named "mesh" with cell-centred fields for every output time and material ids as materials. ParaView 5.13.3 has no native PFLOTRAN reader. One file supplies every time step the format stores.
• pvVisItPLOT2DReader — Registers VisIt's PLOT3D plugin for 2-D .p2d grid files. Because the plugin's read options stay at their 3-D binary defaults and a .p2d name is neither a .vp3d meta file nor a .x/.q pair, it is not established that 2-D files are read correctly. Prefer the native pvPLOT3DReader, whose properties describe the file variant explicitly. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItPLOT3DReader — Reads NASA PLOT3D structured grid (.x) and solution (.q) files described by a VisIt .vp3d text meta file. The output is a curvilinear "mesh" with one domain per grid and node-centred solution variables. The native pvPLOT3DReader (properties for each variant) and pvPLOT3DMetaFileReader (JSON .p3d time series) are normally preferable. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItParaDiSTecplotReader — Reads the Tecplot-like text output of ParaDiS, LLNL's Parallel Dislocation Simulator: dislocation nodes and segments become point and polyline meshes with their quantities. For ParaDiS's own data files use pvVisItParaDisReader; general Tecplot ASCII uses pvTecplotReader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItParaDisReader — Reads data files of ParaDiS, LLNL's Parallel Dislocation Simulator: dislocation segments, nodes and the derived meta-arms become line and point meshes, with Burgers-vector and arm classifications as materials and per-node and per-segment arrays. Use pvVisItParaDisTecplotReader for the Tecplot-like text output. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItPixieReader — Reads 2-D and 3-D HDF5 output of the Pixie3D extended-MHD code: rectilinear or curvilinear grids with node- and cell-centred fields over the stored time steps. ParaView 5.13.3 has no native Pixie reader. One file supplies every time step the format stores.
• pvVisItPoint3DReader — Reads an ASCII table of x, y, z and data-value columns (.3D): every row becomes a point and every column a point array. The native route for such tables is pvCSVReader followed by pvTableToPoints, which also handles more columns and other delimiters. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItProteinDataBankReader — Reads Protein Data Bank files (.pdb, .ent) of macromolecular structures: atoms become a point mesh with numeric per-atom arrays (element, residue type and sequence, backbone flag, occupancy, temperature factor). The native pvPDBReader produces molecule geometry for ball-and-stick rendering; choose this reader when you need the per-atom attributes as arrays. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItRAWReader — Reads the ASCII RAW triangle format used to exchange geometry with programs such as POV-Ray and Blender: each line is one triangle, grouped into named objects, giving a polygonal surface mesh "mesh" with one domain per object and no variables. It is not a raw binary image reader; use pvImageReader for raw volumes. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItSAMRAIReader — Reads output of SAMRAI, LLNL's Structured Adaptive Mesh Refinement Application Infrastructure, through the .samrai summary file of each time step: patches on refinement levels become vtkOverlappingAMR when only "amr_mesh" is selected. Materials are converted; SAMRAI species are not. The captured ParaView summary ("Reads Specific Absorption Rate image volume files") is copied from pvVisItSARReader and is wrong. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItSARReader — Reads Specific Absorption Rate (SAR) image volumes (.sar): a 3-D rectilinear grid named "mesh" with one point array "SAR", the radio-frequency energy absorption per voxel. The plugin source documents no units, so treat values as stored in the file. Use pvVisItSAMRAIReader for SAMRAI AMR files despite the shared upstream description. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItSASReader — Reads binary Fortran SAS geometry and data files (.sasgeom with .sas/.sasdata): an unstructured mesh of assemblies and channels with cell arrays identifying each assembly and channel and a temperature field over time. The plugin source gives no further description of the producing code; ParaView has no other reader for it. One file supplies every time step the format stores.
• pvVisItSiloReader — Reads LLNL Silo files (PDB or HDF5 driver): rectilinear and curvilinear quad meshes, unstructured UCD meshes, point meshes and CSG meshes (discretized), multi-block objects, variables and materials. Silo is the native format of many LLNL codes and of VisIt. ParaView 5.13.3 has no native Silo reader; this plugin is an optional part of the VisIt bridge. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItSpheralReader — Reads ASCII output of Spheral++, LLNL's smoothed-particle hydrodynamics code with coupled gravity: SPH nodes become point meshes with node-centred fields, and node lists are also offered as materials. ParaView 5.13.3 has no native Spheral reader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItTFTReader — Intended for ASCII results of the TFT Fortran simulation code (.dat, .tft). The plugin publishes them as VisIt curves, but the bridge converts only meshes, so the output is probably empty; this has not been verified. For tabular text use pvCSVReader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItTSurfReader — Reads GOCAD TSurf triangulated surfaces (geological horizons and faults; ASCII with a "GOCAD TSurf" header, vertex and triangle records) into one unstructured triangle mesh named "mesh" without variables. ParaView 5.13.3 has no native GOCAD reader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItTecplotBinaryReader — Reads a subset of Tecplot's binary .plt format: ordered and finite-element zones become structured or unstructured blocks with their variables. ParaView's native pvTecplotReader reads only ASCII Tecplot, so this is the catalogue's reader for binary .plt files (SZL .szplt files are a different format). FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItTecplotReader — Reads a subset of ASCII Tecplot (.tec, .tp): ordered (IJK) and finite-element zones become structured or unstructured domains with their variables. The native pvTecplotReader (multiblock of zones) is normally preferable; use this reader when it rejects a file. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItTetradReader — Reads Tetrad HDF5 files (a format written for INEEL, now Idaho National Laboratory): a tetrahedral unstructured mesh named "mesh" with cell-centred variables over the stored time steps. ParaView 5.13.3 has no native Tetrad reader. One file supplies every time step the format stores.
• pvVisItUNICReader — Reads HDF5 result files of UNIC, Argonne's unstructured-mesh neutron transport code: unstructured meshes with node- and cell-centred results. ParaView 5.13.3 has no native UNIC reader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItVASPCHGCARReader — Reads VASP (Vienna Ab initio Simulation Package) charge-density files (CHGCAR or CHG; the reader matches names starting with CHG): the density on the unit-cell grid becomes a point array "charge", with atom and unit-cell meshes alongside. ParaView's pvVASPAnimationReader and pvVASPTessellationReader read different VASP files, not CHGCAR. One file supplies every time step the format stores.
• pvVisItVASPOUTCARReader — Reads VASP (Vienna Ab initio Simulation Package) OUTCAR files (names starting with OUT): every ionic step becomes a time step of a point mesh of atoms with element and force components, plus the unit cell. Use pvVisItVASPPOSCARReader for a single structure and pvVisItVASPCHGCARReader for charge densities. One file supplies every time step the format stores.
• pvVisItVASPPOSCARReader — Reads VASP (Vienna Ab initio Simulation Package) structure files (POSCAR, names starting with POS): atom positions become a point mesh with an element array, plus the unit cell. Listing several files gives a series. Use pvVisItVASPOUTCARReader for relaxation or dynamics trajectories. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItVelodyneReader — Reads HDF5 result files of Velodyne, Corvid Technologies' structural mechanics code (.vld, .rst): solid, shell, surface, particle and SPH meshes with materials and node and element results. It is unrelated to Velodyne lidar data; pvVelodyneAMRReader reads a different (XAMR AMR) format. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItVsReader — Reads HDF5 files annotated with VizSchema markup (.h5, .vsh5), the convention used by Tech-X simulation codes such as VSim/Vorpal to describe meshes, variables and particles. The output is a multiblock of the declared meshes with their variables. ParaView 5.13.3 has no native VizSchema reader. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVisItXYZReader — Reads XYZ molecular files (atom count, comment line, then element and x y z per atom, optionally more columns); several frames in one file become time steps of a point mesh with element and extra-column arrays. The native pvXYZReader produces a vtkMolecule for molecular rendering; choose this reader for frame-by-frame point data or extra columns. One file supplies every time step the format stores.
• pvVisItXmdvReader — Reads XmdvTool .okc files, a simple ASCII format for multivariate records (header with variable count, names and ranges, then one record per line). Each record becomes a point whose coordinates are the first three variables, and every variable becomes an array. For general delimited tables pvCSVReader is the native route. FileName takes a list of files, each one time step of a series (ParaView's file-series wrapper).
• pvVolumeOfRevolution — Sweeps a 2-D (planar) dataset about an axis to create a 3-D unstructured grid: vertices become lines, lines become quadrilaterals and 2-D cells become volume cells, with point and cell data copied to each swept copy. Use it to build a 3-D volume from an axisymmetric simulation for visualization or export. The axis is given by AxisPosition and AxisDirection (ParaView default: the x axis through the origin) and the sweep by SweepAngle and Resolution. ParaView's own short description of this filter (elevation) is a copying error.
• pvVoronoiMergeConnected — Merges the cells of a Voronoi tessellation that share the same global RegionId into single polyhedron cells (vtkPMergeConnected), turning per-particle Voronoi cells into one cell per connected region. Input is a multiblock of unstructured grids carrying RegionId on points and cells and a Volumes cell array, as produced by ParaView's cosmology Voronoi tools; output is a multiblock with merged polyhedra, RegionId and summed Volumes. pvMinkowskiFilter can then characterize the shapes.
• pvVortexCores — Extracts vortex core lines with the parallel-vectors method: lines where velocity is parallel to acceleration (or to jerk with UseHigherOrderMethod). Candidate cells are prefiltered with the Q and delta criteria, and the output polylines carry q-criterion, delta-criterion, lambda_2-criterion, lambda_ci-criterion and vorticity_magnitude point arrays for further filtering. Only 3-D linear cells are processed and the vector field must be a 3-component point array. Use it to locate swirling-flow axes; for vortex regions rather than lines, compute Q or lambda2 with gradient and contour them.
• pvWarpByScalar — Displaces each point along a direction by ScaleFactor × its scalar value: x' = x + ScaleFactor · s · n, with n the point normal when the input has normals and UseNormal is false, otherwise the constant Normal. XYPlane uses each point's z coordinate as s and warps along z (carpet plots). Polydata, structured and unstructured grids keep their type; image and rectilinear inputs become structured grids. Use it for elevation or carpet plots of a scalar on a surface; the curated warpScalar covers the common case.
• pvWarpByVector — Displaces each point by ScaleFactor × a 3-component point vector (x' = x + ScaleFactor · v), e.g. structural displacements or mode shapes, to show the deformed shape. Polydata, structured and unstructured grids keep their type; image and rectilinear inputs become structured grids. Point and cell data pass through, but input normals are dropped because the geometry changed. The curated warpVector covers the common case.
• pvWavefrontOBJReader — Reads Wavefront .obj geometry into polydata with polygons and lines, keeping normals and texture coordinates when the file provides them. Materials (.mtl) are not applied to the data. Use it for surface models exported by modelling or CAD tools; use readSTL for STL and pvglTFReader for glTF scenes.
• pvWavelet — Generates image data over WholeExtent (spacing SubsampleRate, origin 0) with the point scalar "RTData" = Maximum·exp(-r²/(2·StandardDeviation²)) + XMag·sin(XFreq·x) + YMag·sin(YFreq·y) + ZMag·cos(ZFreq·z), where x, y, z are offsets from Center divided by the extent width on each axis and r is their length. It is ParaView's standard synthetic volume, used to test contouring, slicing, volume rendering and exports. The curated wavelet operation offers Schemaxis defaults.
• pvWindBladereader — Reads WindBlade/Firetec simulations (wind over terrain, turbines or wildfire spread) through an ASCII .wind file that describes the data files, grid sizes and variables, one data file per time step. Output port 0 is the wind field (structured grid), port 1 the turbine blades (an unstructured grid, when turbines are used) and port 2 the ground topology (structured grid); select a port with {"node": id, "port": n}.
• pvWriteCGNSWriter — Explicit-export writer for CGNS (.cgns), the CFD General Notation System read by many solvers, meshers and post-processors. It accepts structured grids, polygonal data, unstructured grids, or a multiblock containing these, and stores mesh and point/cell solution fields in one file, using HDF5 storage by default (UseHDF5) or the older ADF layout. Publication uses the semantic contract: ParaView re-reads the file and geometry plus every input point and cell field are compared, accepting changes in block structure, point identity, connectivity order and storage type. Use it to hand results to CGNS-based tools; use pvWriteXMLUnstructuredGridWriter or pvWriteXMLMultiBlockDataWriter when the data only needs to round-trip through VTK.
• pvWriteCSVWriter — Explicit-export writer that turns one dataset, composite dataset or table into delimited text (.csv, .txt or .tsv): one row per point, cell or table row and one column per array component, optionally with point coordinates (AddMetaData) and time columns. Use it to hand values to spreadsheets, pandas or R; mesh topology is not kept. Publication uses the table contract: Schemaxis re-reads the file and checks the row count and every input array of the written association within the export tolerance, accepting the loss of topology, coordinates and structure.
• pvWriteDataSetCSVWriter — Legacy alias of pvWriteCSVWriter: ParaView keeps DataSetCSVWriter, a proxy derived from CSVWriter with the same class and settings, only for old state files and traces. It writes the same delimited text (one row per point, cell or table row, one column per component) and is verified the same way under the table contract. Prefer pvWriteCSVWriter in new documents.
• pvWriteDataSetWriter — Explicit-export writer for the legacy VTK format (.vtk), the original single-file VTK layout still read by ParaView, VisIt, many solver converters and simple scripts. It writes one non-composite dataset of any mesh type, a table or a graph, in binary by default or ASCII (FileType). Publication uses the exact contract: ParaView re-reads the file and structure, connectivity, values and storage types must match the input exactly. Prefer scene geometry or the VTK XML writers (pvWriteXMLUnstructuredGridWriter, pvWriteXMLPolyDataWriter, ...) for new work, and use this writer when a downstream tool reads only legacy .vtk files.
• pvWriteEnSightWriter — Explicit-export writer for EnSight Gold, the case format read by Ansys EnSight and many CFD post-processors: a .case index, a binary .geo geometry file and one file per point or cell array. It accepts only a single, non-composite unstructured grid; cells are grouped into EnSight parts by an integer BlockId cell array when present, otherwise everything is part 1. Publication uses the semantic contract: the case is read back and geometry plus every input point and cell field are compared, accepting changes in structure, point identity, connectivity order and storage type. Use pvWriteXMLUnstructuredGridWriter for lossless VTK storage, or pvWriteCGNSWriter / pvWriteIOSSWriter for other solver formats.
• pvWriteExodusIIWriter — Explicit-export writer that saves a dataset or composite dataset as an Exodus II file (.e, .g, .ex2 …), the finite-element results format of the SEACAS tools. vtkExodusIIWriter writes each leaf's cells as unstructured elements grouped into element blocks; when the input carries no Exodus metadata (it did not come from an Exodus reader) it creates one block per cell type. Publication uses the semantic contract: the file is reopened and mesh geometry and every input field are compared, while block structure, point identity, connectivity order and storage type may change. Use pvWriteIOSSWriter for the IOSS path, or VTK XML output when Exodus is not required.
• pvWriteGenericIOWriter — Explicit-export writer that saves a multiblock of particle unstructured grids as one HACC GenericIO file (.gio), each block becoming one rank's data (vtkPGenericIOMultiBlockWriter). Point coordinates are written as double variables x, y, z, single-component point arrays keep their names and 3-component arrays become <name>_x, _y and _z; cells and connectivity are not stored. Schemaxis verifies it with the semantic comparison, accepting structure and storage changes.
• pvWriteHoudiniWriter — Explicit-export writer for the ASCII Houdini geometry format (.geo, pre-version-12 PGEOMETRY V2), for taking surfaces into SideFX Houdini for effects or rendering. The input must be polygonal data; point arrays become point attributes, cell arrays primitive attributes, and triangle strips are split into triangles. Schemaxis verifies geometry only, with its own parser of the writer's exact grammar (vertices, lines, polygons, triangle strips, attribute brackets, and NPrims counting emitted triangles): points and primitives are compared with the triangulated input surface, accepting loss of fields, point identity, interior cells and structure. Use pvWritePOBJWriter or pvWritePSTLWriter for more widely read surface formats.
• pvWriteHyperTreeGridWriter — Explicit-export writer for VTK's hyper tree grid XML format (.htg), which stores adaptive tree-based meshes (vtkHyperTreeGrid: a coarse grid of quadtrees or octrees) with their refinement trees, masks, coordinates and cell fields. The input must be one non-composite hyper tree grid; all its arrays are written. Publication uses the exact contract: ParaView re-reads the file and tree structure, masks, coordinates and cell arrays must match exactly. Use pvWriteSerialHTGMultiBlock for a multiblock of hyper tree grids; this is also the format scene geometry chooses for hyper tree grids.
• pvWriteIOSSWriter — Explicit-export writer for Exodus II (.exo) through the IOSS library, the finite-element format of Sandia's SIERRA codes, Cubit and many structural and multiphysics solvers. It accepts a dataset, a partitioned dataset or a partitioned dataset collection; every partition becomes an element block unless selectors (or, for data read by ParaView's IOSS reader, its IOSS assembly) assign partitions to blocks and sets, and a time-dependent input is exported for the one scheduled time step: Schemaxis manages TimeStepRange and TimeStepStride, because the writer otherwise loops over every input time step itself. Publication uses the semantic contract: the file is re-read and geometry plus every input point and cell field are compared, accepting loss of structure, point identity, connectivity order and storage type. Use pvWriteExodusIIWriter for ParaView's older Exodus writer and pvWriteCGNSWriter for CGNS tools.
• pvWriteJPEGWriter — Explicit-export writer that saves image data (vtkImageData) as a JPEG (.jpg) file: 1 to 3 components of unsigned char values, compressed lossily at VTK's quality 95. Publication uses the pixels contract, comparing dimensions, components and values after re-reading, so a positive export tolerance is required (zero is rejected at planning) and pvWritePNGWriter is the choice for exact pixels.
• pvWriteJSONImageWriter — Explicit-export writer that saves a uniform image (vtkImageData) node as a JSON document listing the image dimensions, origin, spacing and the values of its point arrays, for web or scripting tools rather than for re-reading in ParaView. Use it as an export writer with comparison "pixels": Schemaxis then parses the JSON itself and checks dimensions, origin, spacing and exactly the arrays the writer emits against the source image: one-component point arrays other than vtkValidPointMask, narrowed by ArrayName and Slice, with null where vtkValidPointMask is 0. The input must be non-composite image data; resample other datasets to an image first. For standard raster formats use pvWritePNGWriter, pvWriteTIFFWriter or pvWriteMetaImageWriter.
• pvWriteMetaImageWriter — Explicit-export writer for MetaImage (.mhd): a short text header (dimensions, spacing, element type) plus a separate binary data file, the format read by ITK-based medical-imaging and segmentation tools. The input must be one non-composite vtkImageData; VTK writes the image scalars and compresses the data file by default. Schemaxis publishes it under the pixels contract: the file is read back and dimensions, component count and scalar values are compared, while coordinates and other fields are accepted as lost. Use pvWriteTIFFWriter or pvWritePNGWriter for 2-D raster interchange, or automatic VTK XML image output (.vti) to keep all arrays.
• pvWriteOpenVDBWriter — Explicit-export writer for OpenVDB (.vdb), the sparse volume format used by Houdini, Blender and film-style renderers. It accepts non-composite image data (volumes) or point sets (meshes or point clouds handled through their points); with EnableColoring it adds a colour channel, and with EnableAlpha an alpha channel, computed from a lookup table supplied through the export's LookupTable resource. The declared publication uses the exact contract, comparing ParaView's readback of the .vdb with the input. Use it to send simulation volumes to rendering tools; keep pvWriteXMLImageDataWriter for lossless analysis data.
• pvWritePDataSetWriterPolyData — Legacy VTK (.vtk) writer for polygonal data built on ParaView's parallel-serial writer, which in an MPI run gathers all pieces to one or a few ranks (NumberOfIORanks) and writes a single file. Schemaxis runs explicit exports serially, so the result is the same single binary-by-default legacy file that pvWriteDataSetWriter produces for a polydata. Publication uses the exact contract: ParaView re-reads the file and structure, connectivity, values and storage types must match exactly. Prefer pvWriteDataSetWriter, which accepts any dataset type, or pvWriteXMLPolyDataWriter for the modern XML format.
• pvWritePDataSetWriterUnstructuredGrid — Legacy VTK (.vtk) writer for unstructured grids built on ParaView's parallel-serial writer, which in an MPI run gathers all pieces to one or a few ranks (NumberOfIORanks) and writes a single file. Schemaxis runs explicit exports serially, so the result is the same single binary-by-default legacy file that pvWriteDataSetWriter produces for a unstructured grid. Publication uses the exact contract: ParaView re-reads the file and structure, connectivity, values and storage types must match exactly. Prefer pvWriteDataSetWriter, which accepts any dataset type, or pvWriteXMLUnstructuredGridWriter for the modern XML format.
• pvWritePNGWriter — Explicit-export writer that stores image data (vtkImageData) as PNG, a lossless raster format holding 1 to 4 components of unsigned char (8-bit) or unsigned short (16-bit) values. It suits masks, label images and already-quantized images, not floating-point simulation fields; this writes data values, unlike a rendered scene image. Publication uses the pixels contract: the PNG is read back and its dimensions, components and values are compared with the input scalars. Use pvWriteTIFFWriter for 32-bit float data.
• pvWritePOBJWriter — Explicit-export writer for Wavefront OBJ (.obj), a plain-text surface format read by almost every 3-D modelling, rendering and visualization tool. It writes the points, lines, triangles and polygons of polygonal data plus point normals and texture coordinates when present; solution fields are not stored. TextureFileName additionally writes a material (.mtl) file that refers to an existing texture image. Publication uses the geometry contract: the file is read back and the triangulated surface is compared, accepting loss of fields, point identity, interior cells and structure. Use pvWritePSTLWriter for triangle-only CAD or 3-D printing exchange, and VTK XML writers when fields matter.
• pvWritePPLYWriter — Explicit-export writer for Stanford PLY (.ply): polygonal surface geometry (points and polygons) for mesh, 3-D printing and point-cloud tools, binary by default (FileType). It accepts polygonal data only, so extract a surface first (pvExtractSurface). Field arrays are not carried, except optional per-point or per-cell RGB(A) colours written when EnableColoring is true, ColorArrayName names the array and a lookup-table resource is attached to the export. Publication uses the geometry contract: Schemaxis re-reads the file with ParaView's PLY reader and compares the triangulated surface within the tolerance.
• pvWritePSTLWriter — Explicit-export writer for STL (.stl), the triangle-only surface format used by 3-D printing, CAD and meshing tools (for example as snappyHexMesh geometry). It writes binary STL by default or ASCII with FileType; only triangles are stored, with no units or fields. Publication uses the geometry contract: the file is re-read and its triangles are compared with the triangulated input surface within the tolerance, accepting loss of fields, point identity, interior cells and structure. Use pvWritePOBJWriter to keep polygons and normals, or pvWritePPLYWriter for per-vertex attributes.
• pvWriteSerialHTGMultiBlock — Explicit-export writer that saves a multiblock dataset whose blocks are hyper tree grids as a VTK multiblock file (.vtm) plus one .htg file per block in a data/ subfolder. ParaView marks its input as composite-only (the input contract records composite as "required"): the node must output a multiblock of hyper tree grids. Publication uses the exact contract: ParaView re-reads the .vtm and the block structure, trees and cell arrays must match exactly. Use pvWriteHyperTreeGridWriter for a single hyper tree grid.
• pvWriteTIFFWriter — Explicit-export writer that saves image data (vtkImageData) as TIFF. vtkTIFFWriter accepts unsigned char, unsigned short or float scalars, so unlike PNG it can store 32-bit floating-point fields such as a sampled temperature image. Scalars selects which point array becomes the image values. Publication uses the pixels contract: the TIFF is read back and dimensions, components and values are compared; coordinates and other arrays are not preserved.
• pvWriteVTKHDFWriter — Explicit-export writer for VTKHDF (.vtkhdf), VTK's HDF5-based single-file format, suited to large meshes and to parallel or partial reading. In ParaView 5.13.3 it accepts unstructured grids, polygonal data, partitioned dataset collections and multiblock datasets. Publication uses the exact contract: ParaView re-reads the file and structure, connectivity, values and storage types must match the input exactly. Use it for compact archives of large meshes; the VTK XML writers (for example pvWriteXMLUnstructuredGridWriter) remain the most widely supported VTK format.
• pvWriteXMLHierarchicalBoxDataWriter — Deprecated ParaView name for the VTK XML AMR writer: it saves overlapping AMR data (vtkHierarchicalBoxDataSet, i.e. refinement levels of uniform image blocks) as a .vthb index plus one .vti file per block in a data/ subfolder. ParaView 5.13.3 marks it deprecated in favour of pvWriteXMLUniformGridAMRWriter, which takes the same settings and is the better choice for new documents. Publication uses the exact contract: ParaView re-reads the .vthb (Schemaxis requests every level) and levels, boxes, origins and arrays must match exactly.
• pvWriteXMLImageDataWriter — Explicit-export writer for VTK XML image data (.vti): a uniform grid (origin, spacing, dimensions, direction) with all point, cell and field arrays, stored losslessly in one file. Scene geometry already chooses this format automatically for image data; use this writer for explicit DataMode or compression control or several exports of one node. Publication uses the exact contract: ParaView re-reads the file and extent, origin, spacing, direction and every array must match exactly. Use pvWriteXMLPImageDataWriter for the parallel .pvti layout, and pvWriteTIFFWriter or pvWritePNGWriter for raster interchange.
• pvWriteXMLMultiBlockDataWriter — Explicit-export writer for VTK XML multiblock data (.vtm): an index describing the block tree (names and nesting) plus one VTK XML file per leaf dataset in a data/ subfolder, keeping every array. Scene geometry uses the same format automatically for multiblock outputs; choose this writer for explicit storage settings or block selection. Publication uses the exact contract: ParaView re-reads the .vtm and block structure, names, geometry and arrays must match exactly. Use pvWriteXMLPartitionedDataSetCollectionWriter for partitioned collections and pvWriteIOSSWriter or pvWriteCGNSWriter for solver interchange.
• pvWriteXMLPHyperTreeGridWriter — Parallel-layout writer for hyper tree grids: a .phtg summary file that lists one .htg piece per process. Schemaxis runs explicit exports serially, so the result is one piece; choosing a parallel writer does not launch MPI. Publication uses the exact contract: ParaView re-reads the summary and trees, masks and cell arrays must match exactly. Prefer pvWriteHyperTreeGridWriter, which writes the same data as one self-contained .htg file.
• pvWriteXMLPImageDataWriter — Explicit-export writer for the parallel VTK XML layout of image data (uniform grids with origin, spacing and extent): a small .pvti summary file listing one .vti piece per process, stored in a data/ subfolder. Schemaxis runs explicit exports serially, so the result is one piece; choosing a parallel writer does not launch MPI. Publication uses the exact contract: ParaView re-reads the .pvti and structure, values and storage types must match the input exactly. Use it when a downstream tool expects the .pvti layout; otherwise pvWriteXMLImageDataWriter or scene geometry gives one self-contained .vti file.
• pvWriteXMLPPartitionedDataSetWriter — Explicit-export writer for VTK XML partitioned datasets (.vtpd): an index plus one VTK XML file per partition (each partition a dataset of its own type) in a data/ subfolder, keeping every partition's geometry and arrays. Scene geometry uses the same format automatically for partitioned datasets; choose this writer for explicit storage settings. Publication uses the exact contract: ParaView re-reads the .vtpd and partitions, geometry and arrays must match exactly. Use pvWriteXMLPartitionedDataSetCollectionWriter for collections of partitioned datasets and pvWriteXMLMultiBlockDataWriter for multiblock data.
• pvWriteXMLPPolyDataWriter — Explicit-export writer for the parallel VTK XML layout of polygonal data (surfaces, lines and points): a small .pvtp summary file listing one .vtp piece per process, stored in a data/ subfolder by default (UseSubdirectory). Schemaxis runs explicit exports serially, so the result is one piece; choosing a parallel writer does not launch MPI. Publication uses the exact contract: ParaView re-reads the .pvtp and structure, values and storage types must match the input exactly. Use it when a downstream tool expects the .pvtp layout; otherwise pvWriteXMLPolyDataWriter or scene geometry gives one self-contained .vtp file.
• pvWriteXMLPRectilinearGridWriter — Explicit-export writer for the parallel VTK XML layout of rectilinear grids (axis-aligned grids with separate x, y and z coordinate arrays): a small .pvtr summary file listing one .vtr piece per process, stored in a data/ subfolder. Schemaxis runs explicit exports serially, so the result is one piece; choosing a parallel writer does not launch MPI. Publication uses the exact contract: ParaView re-reads the .pvtr and structure, values and storage types must match the input exactly. Use it when a downstream tool expects the .pvtr layout; otherwise pvWriteXMLRectilinearGridWriter or scene geometry gives one self-contained .vtr file.
• pvWriteXMLPStructuredGridWriter — Explicit-export writer for the parallel VTK XML layout of structured grids (curvilinear i-j-k grids with explicit point coordinates): a small .pvts summary file listing one .vts piece per process, stored in a data/ subfolder. Schemaxis runs explicit exports serially, so the result is one piece; choosing a parallel writer does not launch MPI. Publication uses the exact contract: ParaView re-reads the .pvts and structure, values and storage types must match the input exactly. Use it when a downstream tool expects the .pvts layout; otherwise pvWriteXMLStructuredGridWriter or scene geometry gives one self-contained .vts file.
• pvWriteXMLPTableWriter — Explicit-export writer for the parallel VTK XML layout of tables (rows of named columns): a small .pvtt summary file listing one .vtt piece per process, stored in a data/ subfolder by default (UseSubdirectory). Schemaxis runs explicit exports serially, so the result is one piece; choosing a parallel writer does not launch MPI. Publication uses the exact contract: ParaView re-reads the .pvtt and structure, values and storage types must match the input exactly. Use it when a downstream tool expects the .pvtt layout; otherwise pvWriteXMLTableWriter or scene geometry gives one self-contained .vtt file.
• pvWriteXMLPUnstructuredGridWriter — Explicit-export writer for the parallel VTK XML layout of unstructured grids (meshes of arbitrary cell types): a small .pvtu summary file listing one .vtu piece per process, stored in a data/ subfolder by default (UseSubdirectory). Schemaxis runs explicit exports serially, so the result is one piece; choosing a parallel writer does not launch MPI. Publication uses the exact contract: ParaView re-reads the .pvtu and structure, values and storage types must match the input exactly. Use it when a downstream tool expects the .pvtu layout; otherwise pvWriteXMLUnstructuredGridWriter or scene geometry gives one self-contained .vtu file.
• pvWriteXMLPVDWriter — Explicit-export writer for ParaView's PVD format: a small XML .pvd index plus the VTK XML piece file(s) it references (type chosen from the data, e.g. .vtu or .vtp), written into a subdirectory named after the file, for one time step. It accepts a single non-composite dataset or table. Publication uses the exact contract: the .pvd is reopened and structure, connectivity, values and storage types must match the input. Choose it when the recipient expects a .pvd collection; otherwise a single-file pvWriteXML…Writer is simpler.
• pvWriteXMLPartitionedDataSetCollectionWriter — Explicit-export writer for VTK XML partitioned dataset collections (.vtpc): an index plus one VTK XML file per partition in a data/ subfolder, keeping the collection's partitioned datasets, names, data assembly and arrays. Scene geometry uses the same format automatically for collections (for example multi-region readers' output); choose this writer for explicit storage settings or block selection. Publication uses the exact contract: ParaView re-reads the .vtpc and the partitions, names, assembly and arrays must match exactly. Use pvWriteXMLMultiBlockDataWriter for multiblock data.
• pvWriteXMLPolyDataWriter — Explicit-export writer that saves a polygonal (vtkPolyData) node, such as a slice, contour, extracted surface, lines or points, as a VTK XML PolyData file (.vtp) with its geometry, connectivity and point, cell and field arrays. Schemaxis reopens the file and requires an exact match of structure, connectivity, values and storage types, so the .vtp is a lossless copy of the node. Automatic geometry output already writes .vtp for polydata; choose this writer when you need to control the encoding (DataMode, CompressorType) or want an export receipt. Use pvWriteXMLUnstructuredGridWriter for volume meshes and pvWriteXMLMultiBlockDataWriter for composite data.
• pvWriteXMLRectilinearGridWriter — Explicit-export writer that saves a rectilinear grid (vtkRectilinearGrid: a structured grid with independent, possibly non-uniform, coordinate arrays along x, y and z) as a VTK XML RectilinearGrid file (.vtr), keeping the extent, the three coordinate arrays and all point, cell and field arrays. Schemaxis verifies the reopened file with an exact comparison. Automatic geometry output already writes .vtr for this type; use this writer to control encoding or to get an explicit export receipt. For uniform spacing the data are usually image data (pvWriteXMLImageDataWriter); for curvilinear grids use pvWriteXMLStructuredGridWriter.
• pvWriteXMLStructuredGridWriter — Explicit-export writer that saves a curvilinear structured grid (vtkStructuredGrid: i-j-k topology with explicit point coordinates, typical of body-fitted CFD blocks) as a VTK XML StructuredGrid file (.vts), with extent, points and all point, cell and field arrays. The reopened file must match the node exactly. Automatic geometry already writes .vts for this type; choose this writer for encoding control or an explicit export receipt. Use pvWriteXMLRectilinearGridWriter for axis-aligned grids and pvWriteXMLUnstructuredGridWriter for general meshes.
• pvWriteXMLTableWriter — Explicit-export writer that saves a table (vtkTable), such as probe-over-line, integration or statistics results, as a VTK XML Table file (.vtt) that keeps every column with its name, type and component count. Unlike pvWriteCSVWriter it is binary-capable and lossless, and Schemaxis verifies the reopened file with an exact comparison. Automatic geometry output already writes .vtt for tables; choose this writer for encoding control or an explicit export receipt. The input must be a single table, not a dataset with point or cell data.
• pvWriteXMLUniformGridAMRWriter — Explicit-export writer for adaptive-mesh-refinement data (vtkUniformGridAMR, overlapping or non-overlapping): it writes a .vthb index file plus one VTK XML image file per AMR block in a companion folder, keeping levels, refinement ratios, block extents and all arrays. Schemaxis reopens the set (asking the reader for all levels) and requires an exact match. Automatic geometry already writes .vthb for overlapping AMR; choose this writer for encoding or header-size control or an explicit export receipt. pvWriteXMLHierarchicalBoxDataWriter is the deprecated name of the same format.
• pvWriteXMLUnstructuredGridWriter — Explicit-export writer that saves an unstructured grid (vtkUnstructuredGrid: arbitrary cells such as tetrahedra, hexahedra, prisms or polyhedra, the usual output of clip, threshold, merge and many mesh readers) as a VTK XML UnstructuredGrid file (.vtu) with points, cells and all point, cell and field arrays. Schemaxis reopens the file and requires an exact match. Automatic geometry already writes .vtu for this type; choose this writer for encoding control or an explicit export receipt. Use pvWriteXMLPolyDataWriter for surfaces stored as polydata and pvWriteXMLMultiBlockDataWriter for composite data such as an OpenFOAM case.
• pvWriteXdmf3Writer — Explicit-export writer for XDMF 3 (.xmf): an XML description of the mesh and arrays with large arrays in an HDF5 companion file, accepting datasets, composite data and graphs. Schemaxis writes one scheduled state and verifies it semantically: the readback must reproduce the mesh geometry and every input point and cell field, while block structure, point identity, connectivity order and storage type may change. Use it for exchange with XDMF 3 tools; pvWriteXdmfWriter writes the older XDMF 2 dialect.
• pvWriteXdmfWriter — Explicit-export writer for XDMF 2 (.xmf): an XML description of the mesh and arrays, with large arrays stored in an HDF5 file beside it. Schemaxis writes one scheduled state per export and verifies it semantically: the file is read back and the mesh geometry and every input point and cell field must match, while block structure, point identity, connectivity order and storage type may change. Use it to hand results to XDMF-aware tools; pvWriteXdmf3Writer writes the newer XDMF 3 dialect with array selection.
• pvXDMFReader — Reads XDMF 2 files (.xmf/.xdmf): XML metadata with heavy arrays in HDF5. The output is the file's grid type (unstructured, structured or rectilinear) or a multiblock when it has several grids. Several file names form a file series read as time steps. Selections choose which grids, sets and point or cell arrays are loaded, and Stride subsamples structured grids. It is a distributed reader. pvXdmf3ReaderT and pvXdmf3ReaderS read XDMF 3 files.
• pvXMLHierarchicalBoxDatareader — Reads VTK XML hierarchical-box AMR files (.vthb, .vth) in the version 1.0 or older layout: a summary file referring to vtkUniformGrid pieces at several refinement levels, read as an overlapping AMR dataset. For the newer layout use pvXMLUniformGridAMRReader, which also offers array selection and a level limit. Several summary files form a time series.
• pvXMLImageDataReader — Reads VTK XML image data files (.vti) into image data (vtkImageData): a uniform grid defined by origin, spacing and extent, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use readImageData for the simple single-file case and pvXMLPartitionedImageDataReader for .pvti pieces.
• pvXMLMultiBlockDataReader — Reads VTK XML multiblock files (.vtm, .vtmb) into a multiblock dataset whose named blocks are read from the serial VTK XML files the .vtm meta file lists, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use readMultiBlock for the simple single-file case; PieceDistribution only matters in parallel.
• pvXMLPartitionedDatasetCollectionReader — Reads VTK XML partitioned dataset collection files (.vtpc) into a partitioned dataset collection: several datasets, each split into partitions, with an optional assembly hierarchy, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use pvXMLMultiBlockDataReader for .vtm files and pvXMLPartitionedDatasetReader for one partitioned dataset (.vtpd).
• pvXMLPartitionedDatasetReader — Reads VTK XML partitioned dataset files (.vtpd) into a partitioned dataset: one dataset split into partitions read from the serial VTK XML files the .vtpd meta file lists, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use pvXMLPartitionedDatasetCollectionReader for .vtpc collections of several datasets.
• pvXMLPartitionedHyperTreeGridReader — Reads partitioned VTK XML hypertree grid data: a .phtg summary file and the .htg piece files it lists, assembled into a hypertree grid (adaptive tree-based AMR mesh). Several summary files form a time series. Use pvHyperTreeGridReader for a single .htg file, which also offers a level limit and a selection box.
• pvXMLPartitionedImageDataReader — Reads partitioned VTK XML image data files (.pvti) into image data (vtkImageData) assembled from the .vti pieces the .pvti summary file lists, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use pvXMLImageDataReader or readImageData for a single .vti file.
• pvXMLPartitionedPolydataReader — Reads partitioned VTK XML polydata files (.pvtp) into polydata assembled from the .vtp pieces the .pvtp summary file lists, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use readParallelPolyData for the simple single-file case and pvXMLPolyDataReader for one .vtp file.
• pvXMLPartitionedRectilinearGridReader — Reads partitioned VTK XML rectilinear grid files (.pvtr) into a rectilinear grid (axis-aligned, with per-axis coordinate arrays) assembled from the .vtr pieces the .pvtr summary file lists, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use pvXMLRectilinearGridReader or readRectilinearGrid for a single .vtr file.
• pvXMLPartitionedStructuredGridReader — Reads partitioned VTK XML structured grid files (.pvts) into a structured (curvilinear) grid assembled from the .vts pieces the .pvts summary file lists, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use pvXMLStructuredGridReader or readStructuredGrid for a single .vts file.
• pvXMLPartitionedTableReader — Reads partitioned VTK XML table data: a .pvtt summary file and the .vtt piece files it lists, assembled into one table (vtkTable) of named columns with no geometry. Several summary files form a time series. Use pvXMLTableReader for one .vtt file and pvCSVReader for text tables.
• pvXMLPartitionedUnstructuredGridReader — Reads partitioned VTK XML unstructured grid files (.pvtu) into an unstructured grid assembled from the .vtu pieces the .pvtu summary file lists, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use readParallelUnstructuredGrid for the simple single-file case and pvXMLUnstructuredGridReader for one .vtu file.
• pvXMLPolyDataReader — Reads VTK XML polydata files (.vtp) into polydata: surfaces, lines and vertices, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use readSurface for the simple single-file case and pvXMLPartitionedPolydataReader for .pvtp pieces.
• pvXMLRectilinearGridReader — Reads VTK XML rectilinear grid files (.vtr) into a rectilinear grid (axis-aligned, with per-axis coordinate arrays), with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use readRectilinearGrid for the simple single-file case and pvXMLPartitionedRectilinearGridReader for .pvtr pieces.
• pvXMLStructuredGridReader — Reads VTK XML structured grid files (.vts) into a structured (curvilinear) grid with explicit point coordinates, with the selected point and cell arrays and any field data. The VTK XML formats keep every array as written, so this is the natural way to reload data saved by ParaView, VTK or Schemaxis exports. Several file names form a time series. Use readStructuredGrid for the simple single-file case and pvXMLPartitionedStructuredGridReader for .pvts pieces.
• pvXMLTableReader — Reads a VTK XML table file (.vtt): a vtkTable of named columns with no geometry, such as values exported by an extract-attributes or statistics step. The output is a table, so use it for plotting, statistics or CSV-style export rather than for rendering or spatial filters. Several files (or a .vtt.series file) form a time series with one file per time step. For geometry use readSurface, readUnstructuredGrid or the other VTK XML readers.
• pvXMLUniformGridAMRReader — Reads a VTK XML overlapping or non-overlapping AMR file (.vthb, or the older .vth): a hierarchy of refinement levels made of uniform-grid blocks, as written by AMR codes or by ParaView. The output is a vtkOverlappingAMR or vtkNonOverlappingAMR composite dataset. ParaView reads only DefaultNumberOfLevels levels unless a downstream filter asks for more, and its default is 1, so by default only the coarsest level is loaded. Use pvAMRGaussianPulseSource for a synthetic AMR test dataset.
• pvXMLUnstructuredGridReader — Generated binding of ParaView's XML Unstructured Grid Reader: reads VTK XML unstructured grid files (.vtu) holding arbitrary cells (tetrahedra, hexahedra, polyhedra, mixed) with point and cell arrays, and outputs a vtkUnstructuredGrid. Unlike the curated readUnstructuredGrid (one file, every array), it accepts a list of files read as a time series and lets you choose which point and cell arrays to load. Use readParallelUnstructuredGrid for partitioned .pvtu output.
• pvXYZReader — Reads an XYZ molecular file (.xyz: atom count, comment line, then element symbol and x y z per atom) into a vtkMolecule; files with several consecutive frames become time steps. Bonds are not stored in the format; use pvComputeMoleculeBonds to derive them and pvMoleculeToLines to obtain polydata for general filters. Use pvPDBReader or pvCMLMoleculeReader for formats that carry more chemistry.
• pvXdmf3ReaderS — Reads XDMF 3 files (.xmf/.xdmf) with heavy data in HDF5. A single domain with one grid gives that dataset type; otherwise the output is a multiblock. This variant treats a series of files as spatial partitions of one dataset (top-level partitioning) (AsTime false by default). Point and cell arrays and named sets can be selected. Use pvXdmf3ReaderT for the other file-series interpretation and pvXDMFReader for XDMF 2 files.
• pvXdmf3ReaderT — Reads XDMF 3 files (.xmf/.xdmf) with heavy data in HDF5. A single domain with one grid gives that dataset type; otherwise the output is a multiblock. This variant treats a series of files as successive time steps (AsTime true by default). Point and cell arrays and named sets can be selected. Use pvXdmf3ReaderS for the other file-series interpretation and pvXDMFReader for XDMF 2 files.
• pvYieldCriteria — Evaluates yield criteria of selected symmetric stress tensors from their principal values σ1 ≥ σ2 ≥ σ3: Tresca as |σ3 − σ1| and von Mises as √(((σ1 − σ2)² + (σ2 − σ3)² + (σ1 − σ3)²) / 2), stored as <name> - Tresca Criterion and <name> - Von Mises Criterion in the tensor's units. The Principal Stress choice also keeps the principal value and direction arrays. Use it in structural post-processing to compare stress states with a material's yield strength. Tensor requirements match pvTensorPrincipalInvariants (6 components XX, YY, ZZ, XY, YZ, XZ, or 3 named XX, YY, XY).
• pvYoungsMaterialInterface — Reconstructs sharp material interfaces in mixed cells of Eulerian or ALE multi-material simulations (e.g. CTH or other volume-of-fluid output) with Youngs' method: in each cell the material is bounded by a plane perpendicular to its interface normal, placed so the cut volume matches the cell's volume fraction. Input is a composite dataset with one cell-centred volume fraction array per material and, ideally, a 3-component cell normal array per material. Output is a multiblock with one block per material (in VolumeFractionArrays order) holding the interface polygons or, with FillMaterial (ParaView default), the material's volume.
• pva2DGlyph — Creates one flat 2-D marker in the x-y plane as polydata: vertex, dash, cross, thick cross, triangle, square, circle, diamond or one of four arrow styles (GlyphType, ParaView default Arrow), about one unit in size around Center. Use it as the glyph shape for 2-D vector or point-marker plots, or as an annotation symbol.
• pva3DText — Creates polygonal (filled outline) geometry spelling Text in a vector font, lying in the x-y plane with the text starting near the origin and characters about one unit tall. It is real geometry, so it can be transformed, clipped or exported, unlike a screen-space text annotation. Use it to label parts of a 3-D scene.
• pvglTFReader — Reads a glTF 2.0 asset (.gltf with external buffers, or binary .glb) into a multiblock dataset of polydata for one scene, with skinning, morph targets and enabled animations applied to the geometry when ApplyDeformationsToGeometry is true. Animations become time steps sampled at Framerate. Materials and textures are not applied. Use it to bring 3-D models or animated scenes into a pipeline; for static CAD surfaces pvWavefrontOBJReader or readSTL are simpler.
• pvopenPMDReader — Reads an openPMD particle-mesh data series (plasma and accelerator simulations such as WarpX or PIConGPU) through a .pmd file: a text file whose first line is the openPMD file pattern, e.g. "data_%T.h5", resolved next to the .pmd file. Output port 0 is the mesh records as image data (a vtkPartitionedDataSet), port 1 the particle species as point clouds (a vtkPartitionedDataSetCollection, one per species); select it with {"node": id, "port": 1}. Values, coordinates and times are converted to SI using the openPMD unit factors.
• pvproSTARSTARCDReader — Reads a proSTAR (STAR-CD) mesh stored as ASCII .vrt (vertices) and .cel (cells) files with a common base name into an unstructured grid; pass either file. ScaleFactor multiplies all coordinates, e.g. 0.001 to convert a millimetre mesh to metres. Only geometry is read, not solution fields.
• pvspcthhistoryreader — Reads a CTH Spy Plot history file (.hscth, names matching hsct): delimited text in which each row is one time step and the columns hold tracer-point positions, materials and properties. The output is a table (vtkTable), with the rows exposed as time steps, suitable for plotting probe histories; it is not a mesh. Use pvSpyPlotReader for the field data itself.
• readImageData — Reads one VTK XML image data file (.vti) into vtkImageData: a uniform grid defined by extent, origin and spacing, with point and cell arrays. Use it for voxel or pixel data such as sampled volumes, resampled CFD fields or images exported by ParaView; the result suits volume rendering, contouring and image filters. For curvilinear or irregular meshes use readStructuredGrid or readUnstructuredGrid.
• readMultiBlock — Reads a VTK XML multiblock file (.vtm, or the older .vtmb): a small index file that names the serial VTK XML files of each block and nests them in a block hierarchy. The output is a vtkMultiBlockDataSet whose leaves may mix datasets of different types. Use it to reopen composite results such as a multi-region case saved by ParaView or Schemaxis; follow it with extractBlock to pick blocks or merge to combine them into one dataset.
• readPLY — Curated PLY reader: reads exactly one Stanford PLY file (ASCII or binary) into polydata, with vertex properties such as normals, colours or texture coordinates carried as arrays. PLY has no unit, so coordinates are in whatever unit the scanner or CAD tool used. Use it for scanned or meshed surfaces to render, clip or probe; use pvPLYReader for file series or texture settings, and readSTL for STL.
• readParallelPolyData — Reads a partitioned VTK XML polydata dataset: the .pvtp summary file plus the per-piece .vtp files it lists, typically written by an MPI run. The pieces are combined into polydata (surfaces, lines, vertices) with their point and cell arrays. Use it to reopen distributed surface output, including Schemaxis's own native parallel geometry; in Schemaxis MPI runs it is one of the operations qualified for distributed reading. Use readSurface for a single .vtp file.
• readParallelUnstructuredGrid — Reads a partitioned VTK XML unstructured grid: the .pvtu summary file plus the per-piece .vtu files it lists, typically written by an MPI run. The result is an unstructured grid with the point and cell arrays of all pieces. Use it to reopen distributed volume output, including Schemaxis's native parallel geometry (examples/schemaxis/foam-native-parallel.json); it is in Schemaxis's MPI-qualified operation list. Use readUnstructuredGrid for a single .vtu file.
• readRectilinearGrid — Reads one VTK XML rectilinear grid file (.vtr) into vtkRectilinearGrid: an axis-aligned structured grid whose x, y and z coordinates are given by three independent (possibly non-uniform) coordinate arrays. Use it for tensor-product meshes with graded spacing, e.g. stretched finite-difference grids. For uniform spacing readImageData is the lighter equivalent; for curved structured meshes use readStructuredGrid.
• readSTL — Reads one ASCII or binary STL file into polydata made of triangles. STL stores only triangle geometry, with no units or field arrays, so coordinates are in whatever unit the exporting CAD tool used. Use it for CAD or scanned surfaces to render, clip against, or probe onto; add normals for smooth shading. Schemaxis reads exactly one file (no file series).
• readStructuredGrid — Reads one VTK XML structured grid file (.vts) into vtkStructuredGrid: a curvilinear i-j-k grid with explicit point coordinates and implicit hexahedral (or quadrilateral) connectivity. Use it for body-fitted structured meshes, e.g. multi-block CFD grids exported block by block. For axis-aligned grids use readRectilinearGrid or readImageData; for arbitrary cells use readUnstructuredGrid.
• readSurface — Reads one VTK XML polydata file (.vtp): polygonal surfaces, lines and vertices with point and cell arrays, such as extracted boundaries, slices or streamlines saved earlier. Use it to reopen surface artifacts, for instance in a later workflow that renders or measures them. Use readParallelPolyData for partitioned .pvtp output and readUnstructuredGrid for volume meshes.
• readUnstructuredGrid — Reads one VTK XML unstructured grid file (.vtu) into vtkUnstructuredGrid, with any mix of cell types (tetrahedra, hexahedra, wedges, polyhedra) and all point and cell arrays. Use it to reopen volume meshes exported by Schemaxis, Gmsh or a solver; it is the reader covered by Schemaxis's reader fixture. Use pvXMLUnstructuredGridReader when you need array selection or a file series, and readParallelUnstructuredGrid for .pvtu output.
• reflect — Mirrors the input across an axis-aligned plane and outputs an unstructured grid (a composite input gives a multiblock of unstructured grids) holding the mirrored copy, plus the original when copyInput is true. Use it to rebuild a full model from a half- or quarter-symmetry simulation, or to mirror a part for display. The plane is x, y or z = centre (Schemaxis default plane X at 0) or one face of the input's bounding box (X Min to Z Max). Vector and tensor arrays such as velocity are mirrored with the geometry because ParaView's FlipAllInputArrays stays at its default (on); scalars are copied unchanged.
• resample — Samples the arrays of the input node (port input, native SourceDataArrays) at the points of the mesh node (port mesh, native DestinationMesh). The result has the mesh's geometry with the input's point and cell values interpolated to its points and a vtkValidPointMask array; with passPointArrays (Schemaxis default true) the mesh's own point arrays are kept too. Use it to compare or combine results on a common mesh, e.g. map a CFD field onto a measurement or structural mesh; pvResampleWithDataset exposes the remaining native settings.
• shrink — Moves the points of every cell towards that cell's centroid (the average of its points) so that cells separate from their neighbours, and outputs an unstructured grid in which no point is shared between cells. It is a mesh-inspection aid that reveals cell shapes, sizes and gaps inside a volume or surface mesh; point and cell arrays travel with the cells. factor is the fraction of each cell's size kept (Schemaxis default 0.8; ParaView's own default is 0.5).
• slice — Cuts the input with one infinite plane through origin, perpendicular to normal, and returns polygonal data: a surface from a volume mesh, lines from a surface. Point arrays are interpolated onto the cut and cell arrays are copied from the cell each polygon came from, so cell-centred CFD fields appear piecewise constant. Use it for cross-sections of 3-D fields; use clip to keep one side of a volume, contour for an isosurface, probeLine for a 1-D profile, and pvSlice for several parallel offsets or other cut shapes.
• smooth — Applies Laplacian smoothing to a polygonal surface: each iteration moves every point a small step towards the average of its connected neighbours. The output is polygonal data with the same points and connectivity at smoother positions, and arrays are passed unchanged. Use it to reduce faceting or noise on scanned, marching-cubes or STL surfaces before rendering or curvature. Input must be vtkPolyData; run surface first on volume meshes.
• sphere — Creates a triangulated polygonal sphere (vtkPolyData with point normals) of given radius about centre, with its poles on the z axis. resolution sets the number of longitude divisions around z (Schemaxis default 24, ParaView's own default 8); latitude divisions are fixed at 24 by Schemaxis. Use it as a marker, a target mesh for resample, a seed surface for streamTracer or simple test geometry; its coordinates are in the units of the data it is combined with.
• streamTracer — Integrates streamlines of a steady vector field from the points of a separate seed dataset and returns polygonal data made of polylines. Connect the flow dataset to input and any point-producing node (line, sphere, a slice) to seed; every seed point starts a trace. Input point arrays are interpolated onto the lines and ParaView adds IntegrationTime, Vorticity, Rotation and AngularVelocity point arrays and a ReasonForTermination cell array. Point vectors are interpolated along the trace. A cell vector array (association CELLS) is traced as constant within each cell, but ParaView's input domain also requires some three-component point array on the input, so a cell-only input fails INPUT_DOMAIN_MISMATCH at update. Convert cell-centred CFD velocity with cellToPoint for the usual smooth traces. The integrator stays at ParaView's Runge-Kutta 4-5 with step lengths in cell lengths. Use pvStreamTracerWithCustomSource to change the integrator, step unit or terminal speed, and pvStreamTracer for ParaView's built-in seed shapes.
• surface — Extracts the outer boundary surface of any dataset as polygonal data: the exterior faces of volume cells plus any 2-D, line and vertex cells already present. Use it to turn a volume mesh into a surface for rendering, normals, featureEdges, decimate or surface export, or to see the whole boundary of a CFD domain (walls, inlets and outlets together). Cell arrays are copied from the adjacent cell to each face and point arrays are passed; nothing is interpolated.
• temporalStatistics — Computes, for every point and cell array of a time-dependent input, its average, minimum, maximum and population standard deviation over all input time steps, which the filter requests itself. The output has the input's type and geometry, no time, and arrays named <name>_average, <name>_minimum, <name>_maximum and <name>_stddev (other arrays are not kept). Every step is weighted equally regardless of time spacing, so this is not a time integral. Schemaxis enables all four statistics by default; use pvTemporalStatistics only if you want the generated binding with native option names.
• threshold — Keeps the cells of a mesh whose selected point or cell scalar lies inside the inclusive range [lower, upper], producing an unstructured grid. Schemaxis fixes ParaView's ThresholdMethod to Between, requires all three options, checks that lower does not exceed upper and that the named array exists with the stated association. Use it to isolate a region such as hot gas or a recirculation zone; use pvThreshold for inverted, one-sided or component-wise tests.
• transform — Applies a linear transform to the point coordinates: scale, then rotation, then translation, all about the coordinate origin [0, 0, 0]. Vectors and normals are transformed with the geometry (every three-component array while allVectors is true). Polygonal, unstructured and structured grids keep their type; image data and rectilinear grids become an explicit-point dataset. Use it to position, orient or rescale geometry, e.g. scale [0.001, 0.001, 0.001] to convert millimetre coordinates to metres.
• triangulate — Converts polygonal data so that every polygon and triangle strip becomes triangles and polylines become single line segments; vertices are kept. The output is vtkPolyData on the same points, with cell values copied from each parent cell. Use it before operations or exports that need triangles, such as decimate or STL output. It accepts only polygonal input: run surface first for volume data, or use pvTetrahedralize to split volume cells into tetrahedra.
• tube — Builds a polygonal tube of constant radius around each line or polyline of polygonal input, typically streamlines from streamTracer, so that thin lines become visible shaded geometry in images and exports. The output is vtkPolyData, and input point arrays are carried onto the tube surface so it can be coloured by the same fields. Schemaxis assigns radius 0.1, 12 sides and capped ends; ParaView's radius variation stays off, so use pvTube for tubes whose radius follows a scalar or vector.
• warpScalar — Displaces each point along a direction by scale times a point scalar (new position = point + scale x value x direction), turning a field on a flat surface into a relief or carpet plot, or moving a surface by a normal displacement. With useNormal true (Schemaxis default) every point moves along the same normal (default z+); with useNormal false the input's point normals are used when present. The output keeps the input type, except that image data and rectilinear grids become a structured grid; all arrays are carried along.
• warpVector — Moves every point by scale times a three-component point vector (new position = point + scale x vector), typically to show a structural displacement field or exaggerate a deformation mode. The output keeps the input type (image data and rectilinear grids become structured grids) and carries all arrays. With scale 1 and a displacement in the same length units as the coordinates the result is the true deformed shape; warping by a velocity is only a visual distortion.
• wavelet — Creates a synthetic uniform image (vtkImageData) whose point array RTData combines a Gaussian peak of height maximum with sinusoidal terms along x, y and z. With the Schemaxis defaults it is a 21 x 21 x 21-point grid with unit spacing spanning -10 to 10 on each axis. Use it as a self-contained input to try slice, contour, clip, streamTracer or scene settings without a real case; its values have no physical meaning or units.

append#

Combines the meshes of several input nodes (any dataset types, non-composite) into one unstructured grid, ParaView 5.13.3's default output type for Append Datasets. Points are not merged and only point and cell arrays present on every input are kept. Use it to treat parts as one dataset for a filter or export; use appendGeometry for surfaces, group to keep inputs as separate blocks, and merge for the blocks of one composite node.

Common mistakes and assumptions:

• Arrays missing on any input are dropped; make array names consistent across inputs first.
• Coincident points at part interfaces stay duplicated; follow with cleanGrid to merge them.

Native constructor: AppendDatasets. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "append",
  "inputs": {
    "input": [
      "UPSTREAM_input"
    ]
  }
}

appendGeometry#

Appends several polygonal (vtkPolyData) inputs, such as surfaces, lines or point clouds, into one polydata without merging points. Only point and cell arrays common to all inputs survive. Use it to combine surface parts for a joint export or surface filter; use append for mixed dataset types.

Common mistakes and assumptions:

• Shared edges between parts keep duplicate points; run clean afterwards for a connected surface (needed for consistent normals or connectivity).

Native constructor: AppendGeometry. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "appendGeometry",
  "inputs": {
    "input": [
      "UPSTREAM_input"
    ]
  }
}

calculator#

Evaluates a ParaView Calculator expression at every point or cell and adds the result as a new array named by result, e.g. velocity magnitude mag(U) or a non-dimensional group. The output is the input dataset type with one more array of the chosen association; existing arrays and geometry are unchanged. Use pvCalculator for coordinate results, other result types or table data.

Common mistakes and assumptions:

• The expression language is ParaView's parser (ExprTk syntax), not Python and not a Schemaxis $calc expression.
• An expression can only use arrays of the selected association; point and cell arrays cannot be mixed, and nothing is interpolated between them.
• Invalid results (e.g. sqrt of a negative) are replaced by 0 under ParaView's defaults, which can hide errors.

Native constructor: Calculator. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "calculator",
  "inputs": {
    "input": "UPSTREAM_input"
  },
  "options": {
    "expression": "REPLACE_WITH_VALUE",
    "result": "REPLACE_WITH_VALUE"
  }
}

cellSize#

Adds cell-data arrays holding the size of each cell: Length for 1-D cells (lines, polylines), Area for 2-D cells (triangles, quads, polygons) and Volume for 3-D cells, all in dataset coordinate units (length, length squared, length cubed). Cells of a dimension that is not computed get 0 in that array. Use it for cell volumes or face areas, e.g. to weight cell values or check mesh resolution; with sum enabled the totals are also stored as field data. pvCellSize exposes the same filter with every native setting, including the vertex count and array names; pvMeshQuality rates cell shape instead of size.

Common mistakes and assumptions:

• Each array is filled for every cell, so a mixed mesh shows 0 in Volume for its faces and 0 in Area for its volume cells; filter by cell type before taking statistics.
• Polygon areas are computed by a fan triangulation that is exact only for convex planar polygons.

Native constructor: CellSize. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "cellSize",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

cellToPoint#

Interpolates cell-centred arrays to mesh points: each point receives the average of the cells that use it, producing point fields for stream tracing, contours and smooth colouring. The mesh is unchanged. Averaging smooths sharp cell-to-cell changes and blurs discontinuities such as shocks or material interfaces. Use pointToCell for the reverse.

Common mistakes and assumptions:

• Averages are unweighted across neighbouring cells, so values at boundaries between very different cells are not conservative.
• With passCellData true (Schemaxis default) the output carries both versions of each array; select the association explicitly downstream.

Native constructor: CellDatatoPointData. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Conditional requirements:

[
  {
    "when": [
      "allArrays",
      false
    ],
    "option": "arrays"
  }
]

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "cellToPoint",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

clean#

Cleans polygonal data: merges duplicate points within a tolerance, removes unused points and turns degenerate cells into lower-dimensional ones (a triangle with two merged points becomes a line). Output is polydata. Use it after appendGeometry or on surfaces with duplicated vertices to get a connected surface for normals, curvature, connectivity or decimation. For other dataset types use cleanGrid.

Common mistakes and assumptions:

• A large tolerance collapses small features and can change topology; keep it well below the smallest edge length.

Native constructor: Clean. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "clean",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

cleanGrid#

Converts any dataset into an unstructured grid and merges coincident points (exactly coincident at the Schemaxis default tolerance 0), optionally removing points used by no cell (Schemaxis default true). Use it to obtain an unstructured grid for operations that need one, or to stitch appended parts. Use clean when the input is polydata and polydata output is wanted.

Common mistakes and assumptions:

• Structured inputs lose their implicit structure and grow in memory once converted.

Native constructor: CleantoGrid. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "cleanGrid",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

clip#

Cuts the input with a plane through origin with normal normal and keeps one side, returning an unstructured grid of whole and cut cells (dimension is kept, unlike slice). With the Schemaxis default invert false the kept half is the side the normal points into; true keeps the opposite side. Use it to open a volume for viewing interior fields; use pvClip for box, sphere, cylinder or scalar clips and for crinkle (whole-cell) clipping.

Common mistakes and assumptions:

• ParaView's own Clip starts with Invert on (keeping the side opposite the normal); Schemaxis sets invert false by default, so results can be mirrored relative to a ParaView GUI session.
• Clipping structured data produces an unstructured grid, which can use much more memory.

Native constructor: Clip. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "clip",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

cone#

Creates a polygonal cone surface of given height and base radius. Its centre is the midpoint of the axis, the axis follows direction, and the apex lies on the direction side; resolution sets the number of facets around the axis and capping closes the base. Use it as a marker, glyph or simple test geometry; coordinates are in the units of the data it is shown with.

Common mistakes and assumptions:

• centre is not the centre of the base: the base lies height/2 behind it and the apex height/2 ahead along direction.

Native constructor: Cone. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "cone"
}

connectivity#

Labels the connected regions of the input (cells linked through shared points) and keeps all regions, the largest one (most cells) or the one closest to a point; output is an unstructured grid. With colourRegions (Schemaxis default true) a RegionId array identifies each region. Use it to separate disjoint bodies, drop small fragments or isolate the part near a location.

Common mistakes and assumptions:

• Connectivity is topological: parts that touch only geometrically, with duplicate points, count as separate regions; run clean or cleanGrid first.

Native constructor: Connectivity. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "connectivity",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

contour#

Extracts isosurfaces (3-D input) or isolines (2-D input) where a point-centred scalar field equals each of the given values, and outputs them as polydata; several values give several surfaces in one output. Use it for level sets such as a temperature front or a Q-criterion vortex surface. By Schemaxis default the output carries normals and the contour value as an array, but no gradients. Use pvContour for the full native settings.

Common mistakes and assumptions:

• The scalar must be point data; for cell arrays run cellToPoint first.
• Values outside the field's range produce an empty output without an error.

Native constructor: Contour. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "contour",
  "inputs": {
    "input": "UPSTREAM_input"
  },
  "options": {
    "field": [
      "REPLACE_WITH_VALUE",
      "REPLACE_WITH_VALUE"
    ],
    "values": [
      1
    ]
  }
}

curvature#

Computes per-point curvature of a polygonal surface (Gaussian or mean, the two curvature types ParaView 5.13.3 offers) as a point array such as Mean_Curvature or Gauss_Curvature. Use it to locate ridges, valleys or highly curved regions on CAD or scanned surfaces. Mean curvature is in inverse length units and Gaussian in inverse length squared; both are noisy on coarse or irregular triangulations. The mean-curvature sign assumes outward normals.

Common mistakes and assumptions:

• type accepts only Gaussian or Mean, the entries of ParaView 5.13.3's Curvature enumeration (filters_filtersgeneral.xml:445-485); maximum and minimum principal curvature are not available and any other value is rejected at planning.
• If convex regions show negative mean curvature, the normals point inward; set invertMean.

Native constructor: Curvature. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "curvature",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

cylinder#

Creates a polygonal cylinder surface of given radius and height, centred on centre with its axis parallel to y, including point normals and texture coordinates. resolution sets the facets around the axis and capping closes both ends. There is no orientation setting: follow it with transform to rotate the cylinder.

Common mistakes and assumptions:

• The axis is always along y before any transform; a cylinder meant along z needs a 90-degree rotation about x.

Native constructor: Cylinder. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "cylinder"
}

decimate#

Reduces the triangle count of a polygonal surface by a target fraction (Schemaxis default 0.5) with vtkDecimatePro, trying to preserve shape; preserveTopology (Schemaxis default true) prevents holes and splits at the cost of possibly missing the target. Use it to lighten large surfaces for rendering or export. Input must be triangles; run triangulate first if other polygons are present.

Common mistakes and assumptions:

• Small features and sharp detail are lost first; compare with the original before measuring on the result.

Native constructor: Decimate. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "decimate",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

delaunay2D#

Builds a 2-D Delaunay triangulation of the input points (any point set, e.g. a point cloud or the points of a mesh; input cells are ignored) and outputs polydata triangles. Triangulation is done in the x-y plane: z is ignored for connectivity but kept on the points, so it suits height fields and nearly planar sets aligned with x-y. With alpha 0 (Schemaxis default) every triangle of the convex hull is kept; a positive alpha keeps only triangles whose circumcircle radius is at most alpha, carving concave outlines and gaps. Use pvDelaunay2D for a best-fitting plane, and delaunay3D for tetrahedra.

Common mistakes and assumptions:

• Points on a plane not parallel to x-y (e.g. a vertical wall) triangulate badly or collapse; transform them first or use pvDelaunay2D with ProjectionPlaneMode Best-Fitting Plane.
• Points closer than tolerance (a fraction of the bounding-box diagonal) are discarded as duplicates.

Native constructor: Delaunay2D. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "delaunay2D",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

delaunay3D#

Builds a 3-D Delaunay tetrahedralization of the input points (any point set) and outputs an unstructured grid of tetrahedra filling their convex hull. A positive alpha (Schemaxis default 0) produces an alpha shape: only tetrahedra whose circumsphere radius is at most alpha, plus qualifying triangles, are kept, which recovers concave shapes from point clouds. Use it to mesh scattered 3-D samples for interpolation or volume estimates; use delaunay2D for surface-like sets and pvDelaunay3D to choose which alpha cell types are output.

Common mistakes and assumptions:

• Output grows quickly and ParaView warns that Delaunay 3D can exhaust memory; thin large point sets first.
• Points on a regular lattice are degenerate: the result depends on point order, and nearly coplanar points produce sliver tetrahedra.

Native constructor: Delaunay3D. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "delaunay3D",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

disk#

Creates a flat annulus (polydata) centred at the origin in the XY plane, with inner and outer radius and radial and circumferential resolution; set innerRadius to 0 for a full disc. Use it as a seed or probe surface, a marker or test geometry, and place it with transform.

Common mistakes and assumptions:

• Schemaxis requires innerRadius not to exceed outerRadius.

Native constructor: Disk. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Cross-option checks:

[
  {
    "kind": "ordered",
    "options": [
      "innerRadius",
      "outerRadius"
    ]
  }
]

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "disk"
}

edges#

Extracts every edge of every cell as a line cell, giving a wireframe polydata of the whole mesh, including interior edges of volume cells. Each shared edge appears once and receives the cell data of the lowest-numbered cell using it. Use it to show or export mesh structure or to measure edge lengths; use featureEdges for only boundary or sharp edges of a surface, and run surface first if only the outer skin's edges are wanted.

Common mistakes and assumptions:

• On volume meshes the output holds all interior edges and can be several times larger than the input; ParaView warns about memory for structured inputs.

Native constructor: ExtractEdges. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "edges",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

elevation#

Adds a point scalar array named Elevation: each point is projected onto the line from lowPoint to highPoint and the position along that line is mapped linearly onto range, clamped at both ends. Use it to colour by height or depth along any direction, or as a synthetic field for testing. Schemaxis assigns its defaults (z from -1 to 1 mapped to 0 to 1), so set the points to your data's extent.

Common mistakes and assumptions:

• Points beyond either end point all receive the end value, so a line shorter than the data flattens the field outside it.

Native constructor: Elevation. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "elevation",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

extractBlock#

Extracts selected blocks from a composite dataset (multiblock, partitioned dataset collection or AMR), such as the internalMesh or individual patches of an OpenFOAM case read by foam. Blocks are chosen by selectors, path expressions over the input's block hierarchy such as "/Root/internalMesh" or "//inlet". The output keeps the composite type with only the selected blocks (overlapping AMR becomes a partitioned dataset collection). Use merge afterwards when one dataset is needed; pvExtractBlock also exposes the assembly choice.

Common mistakes and assumptions:

• Selectors that match nothing give an empty composite rather than an error; check names in the input hierarchy (Studio lists them).
• Only blocks that the reader loaded can be extracted; enable the patches in the reader options first.

Native constructor: ExtractBlock. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "extractBlock",
  "inputs": {
    "input": "UPSTREAM_input"
  },
  "options": {
    "selectors": [
      "REPLACE_WITH_VALUE"
    ]
  }
}

extractSubset#

Extracts a volume of interest from structured data (image data, rectilinear or structured grid) by an IJK point-index range, optionally keeping every n-th index. The output keeps the input's structured type, so it stays compact and works with structured filters. Use it to crop a structured block or image by index; use a clip for geometric cuts or unstructured meshes.

Common mistakes and assumptions:

• Indices are in the input's extent space, which need not start at 0; inspect the input extent before choosing the range.

Native constructor: ExtractSubset. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "extractSubset",
  "inputs": {
    "input": "UPSTREAM_input"
  },
  "options": {
    "extent": [
      1,
      1,
      1,
      1,
      1,
      1
    ]
  }
}

featureEdges#

Extracts edges of a polygonal surface as line cells (polydata): boundary edges (used by one polygon), feature edges (between two polygons whose normals differ by more than angle), non-manifold edges (shared by three or more polygons) and optionally manifold edges. With the Schemaxis defaults (boundary, feature and non-manifold on, manifold off, 30°) it outlines a CAD or CFD surface's creases, open boundaries and T-junctions. Input must be polydata; run surface first on volume meshes. Use edges for every cell edge.

Common mistakes and assumptions:

• Feature detection uses polygon normals, so inconsistently oriented polygons create spurious feature edges; run normals with consistency first.
• Unmerged duplicate points make every polygon edge a boundary edge; run clean first.

Native constructor: FeatureEdges. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "featureEdges",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

foam#

Curated OpenFOAM reader: opens a case through its .foam marker file and outputs a multiblock dataset whose blocks are the selected mesh regions (internalMesh volume cells, patch/<name> boundaries) carrying the selected cell fields, with one time step per stored time directory. Schemaxis defaults read a decomposed case (processor* folders), only internalMesh, and keep the 0 directory; other reader settings keep ParaView's defaults, which also create point data interpolated from the cell fields. Use pvOpenFOAMReader for point or Lagrangian fields, zones, label/scalar size or the other native options.

Common mistakes and assumptions:

• caseType defaults to Decomposed Case in Schemaxis (ParaView's own default is Reconstructed Case); for a serial or reconstructed case set Reconstructed Case, otherwise the reader finds no data.
• Boundary patches are loaded only when listed in regions as patch/<name>.
• Pick stored times with the document's times selection using this node as the source.

Native constructor: OpenFOAMReader. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "foam",
  "options": {
    "file": "REPLACE_WITH_VALUE"
  }
}

generateIds#

Adds arrays holding each point's and each cell's index (zero-based ids in the input), so that later clipping, extraction or merging carries the original ids along and results can be traced back to the source mesh. The geometry and type are unchanged and existing arrays are kept; each generated id array becomes that attribute's active scalars. For hyper-tree grids cell ids are always generated, and pointIds, pointName and cellIds have no effect.

Common mistakes and assumptions:

• Ids are indices in this node's input, not solver-native ids; apply the operation before filters that renumber points or cells.

Native constructor: PointAndCellIds. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "generateIds",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

gradient#

Estimates the spatial gradient of a point or cell array and stores it as a new array on the same mesh: 3 components for a scalar, 9 (row-major d(component)/d(x, y, z)) for a 3-component vector. Optionally adds divergence, vorticity and the Q-criterion of a vector field, e.g. for vortex identification. Unstructured meshes use cell derivatives, structured ones central differences. Use pvGradient for the full native settings and other output names.

Common mistakes and assumptions:

• Divergence, vorticity and Q-criterion need a 3-component array; they fail or are skipped for scalars.
• Derivatives are in field units per dataset length unit; no unit conversion is applied.

Native constructor: Gradient. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "gradient",
  "inputs": {
    "input": "UPSTREAM_input"
  },
  "options": {
    "field": [
      "REPLACE_WITH_VALUE",
      "REPLACE_WITH_VALUE"
    ]
  }
}

group#

Combines several input nodes into one multiblock (composite) dataset, one block per input in connection order, without changing the data. Use it to process, colour or export several parts together while keeping them distinct; use append or merge when you need a single mesh.

Common mistakes and assumptions:

• Filters that need a non-composite input will not accept the grouped result; merge it first.

Native constructor: GroupDatasets. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "group",
  "inputs": {
    "input": [
      "UPSTREAM_input"
    ]
  }
}

integrate#

Integrates all point and cell arrays over the input's cells and computes the total length, area or volume, producing a one-point unstructured grid with one integrated value per array. Only cells of the highest dimension present are used (a volume mesh ignores its faces) and vertex cells are not integrated. With divideByVolume the cell-data integrals are divided by the total size, giving size-weighted means. Use it for totals such as mass or force and for mean values; results carry the array units times length, area or volume.

Common mistakes and assumptions:

• Point-data results are never divided; for a point-field mean divide by the size array yourself or convert to cell data first.
• Integrating a vector gives componentwise integrals, not a flux; compute the normal component with a calculator first.

Native constructor: IntegrateVariables. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "integrate",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

line#

Creates a straight polyline from start to end with resolution intervals (Schemaxis default 20, so 21 points), as a separate polydata source. Connect it to streamTracer.seed to place streamline seeds, or use it as probe geometry; it is not the velocity dataset and carries no fields. To sample fields along a segment use probeLine.

Common mistakes and assumptions:

• Coordinates use the dataset coordinate system. A line inside the bounding box can still cross solid regions or gaps.
• Resolution is the number of intervals, so a line with resolution 20 has 21 points.

Native constructor: Line. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "line"
}

merge#

Merges every leaf dataset of a composite input (multiblock or partitioned data, e.g. the regions and patches from foam) into one unstructured grid, ParaView's default output type. Use it before operations or exports that need a single non-composite dataset. Point merging (on by Schemaxis default) fuses exactly coincident points at block interfaces so the result is connected. Use pvMergeBlocks for polydata output, a merge tolerance or partition-only merging, and append to combine separate nodes.

Common mistakes and assumptions:

• Block identity and names are lost; use extractBlock first if only some blocks should be merged.
• Arrays that are missing on some blocks may be absent or incomplete after merging; check the output arrays.

Native constructor: MergeBlocks. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "merge",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

normals#

Computes point normals of a polygonal surface by averaging the normals of adjacent polygons, for smooth shading and for operations that need normals (warping along normals, glyphs). With splitting, points on edges sharper than featureAngle are duplicated so each side keeps its own normal; consistency reorders polygons so neighbours agree. Output is polydata with a Normals point array.

Common mistakes and assumptions:

• Consistent orientation does not make normals point outward; check their direction, since flipping is not exposed by this operation.
• Schemaxis turns splitting off by default (ParaView's own default is on), so sharp edges are shaded smoothly unless you enable it.
• Input must be polygonal; extract the surface of a volume mesh first (surface).

Native constructor: SurfaceNormals. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "normals",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

outline#

Produces the 12 edges of the input's axis-aligned bounding box as polydata lines. Use it as a context frame in scenes or to check a dataset's extent; it carries no field data.

Common mistakes and assumptions:

• The box is axis-aligned, so it can be much larger than a rotated or thin object.

Native constructor: Outline. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "outline",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

passArrays#

Keeps only the named point, cell and field arrays of the input and removes every other array of those associations; geometry and topology are unchanged (shallow copy, so it is cheap). Use it to slim a dataset before export or publication, or to drop arrays that would confuse later steps. Each list has the Schemaxis default [], and an empty list keeps none of that association's arrays. Use pvPassArrays when vertex, edge or row (table) arrays also need selecting.

Common mistakes and assumptions:

• Listing only pointArrays removes every cell and field array, because the other lists default to []; list the arrays you need in each association.
• Names are matched exactly; a misspelt name keeps nothing and the array disappears.
• Ghost-cell arrays (vtkGhostType) are kept unless explicitly deselected.

Native constructor: PassArrays. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "passArrays",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

plane#

Creates a flat parallelogram (polydata) with one corner at origin and edges running to point1 and point2, subdivided into xResolution × yResolution quadrilaterals. Use it as a probe or seed surface, for example for resampling or streamline seeds, or as test geometry. The Schemaxis defaults give a 2 × 2 square in the XY plane centred at the origin, with 10 × 10 cells.

Common mistakes and assumptions:

• point1 and point2 must not be collinear with origin, or the plane is degenerate.

Native constructor: Plane. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "plane"
}

pointToCell#

Averages point arrays onto cells: each cell receives the unweighted mean of its points' values. The mesh is unchanged; only the array association changes. Use it when a later operation, a threshold or an integration needs cell data, or to compare with cell-centred solver output. Use cellToPoint for the reverse.

Common mistakes and assumptions:

• Averaging over cell points smooths peaks; the cell values are not exact cell integrals.
• With passPointData true (Schemaxis default) both versions of each array remain; select the association explicitly downstream.

Native constructor: PointDatatoCellData. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Conditional requirements:

[
  {
    "when": [
      "allArrays",
      false
    ],
    "option": "arrays"
  }
]

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pointToCell",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

probeLine#

Samples the input's point and cell arrays along the segment from start to end (Plot Over Line), interpolating within cells, and outputs a polyline with the sampled arrays plus arc_length and vtkValidPointMask (1 where a sample lies inside the data). Use it for spatial profiles, e.g. velocity across a channel. ParaView's XML default sampling pattern is uniform, for which resolution (Schemaxis default 100) is the number of intervals.

Common mistakes and assumptions:

• Samples outside the mesh have vtkValidPointMask 0 and placeholder values; mask them before plotting or measuring.
• Sampling behaviour follows the native PlotOverLine settings; resolution controls the uniform-sampling mode.

Native constructor: PlotOverLine. Identity: curated binding. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "probeLine",
  "inputs": {
    "input": "UPSTREAM_input"
  }
}

pvADIOS2CoreImageReader#

Reads variables from an ADIOS2 BP file or BP4/BP5 directory as arrays on a uniform image (vtkImageData). One variable (Image Dimension) defines the image size; each selected variable becomes a point or cell array according to its shape, and an optional variable supplies the time values. Use it for simulation codes that write plain multi-dimensional arrays through ADIOS2; use pvADIOS2VTXReader when the file embeds a VTK schema and pvFidesReader when it follows a Fides data model.

Common mistakes and assumptions:

• Arrays whose shape matches neither the point nor the cell dimensions of the chosen dimension variable cannot be placed on the image; pick the dimension variable that matches the fields you need.
• Schemaxis generates this reader binding from ParaView's catalogue; it has not run a native acceptance check with a sample file of this format.

Native constructor: ADIOS2CoreImageReader. Identity: sources/ADIOS2CoreImageReader. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvADIOS2CoreImageReader",
  "options": {
    "FileName": "REPLACE_WITH_VALUE"
  }
}

pvADIOS2VTXReader#

Reads an ADIOS2 BP file or BP4 directory that embeds a VTK XML schema (VTX), either as a BP attribute or as a vtk.xml subfile, describing image data (vti) or unstructured grid (vtu) content; the output is that dataset, with time steps from the BP steps. It is a distributed reader. Choose it for codes that write VTX-annotated ADIOS2 output (e.g. via the VTX schema), and pvADIOS2CoreImageReader or pvFidesReader for other ADIOS2 layouts.

Common mistakes and assumptions:

• Files without the embedded VTK schema cannot be interpreted by this reader.
• Schemaxis generates this reader binding from ParaView's catalogue; it has not run a native acceptance check with a sample file of this format.

Native constructor: ADIOS2VTXReader. Identity: sources/ADIOS2VTXReader. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvADIOS2VTXReader",
  "options": {
    "FileName": "REPLACE_WITH_VALUE"
  }
}

pvAMRConnectivity#

Fragment identification on non-overlapping AMR material data (such as CTH output from pvSpyPlotReader): for each selected volume-fraction cell array it labels connected regions of cells whose value exceeds VolumeFractionValue, including across block and level boundaries when ResolveBlocks is on, and adds a cell array RegionId-<array name>. The output is the same AMR data with these labels; pvAMRFragmentIntegration then sums fragment volumes and masses. Use pvAMRFragmentsFilter to run the whole chain in one step.

Common mistakes and assumptions:

• Unlike AMR Contour and AMR Dual Clip, this filter compares VolumeFractionValue with the stored array values without scaling by 255; with unsigned char fractions the default 0.1 therefore keeps any cell with a non-zero fraction.
• Without at least one SelectMaterialArrays entry no labels are produced.
• Overlapping AMR is rejected; the input must be vtkNonOverlappingAMR.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AMRConnectivity. Identity: filters/AMRConnectivity. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAMRConnectivity",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAMRContour#

AMR Contour (vtkPVAMRDualContour) extracts material interface surfaces from non-overlapping AMR volume-fraction data using the dual grid, so surfaces stay crack-free across refinement levels. For each selected cell array it outputs a block of polygonal surface at VolumeFractionValue (multiplied by 255 internally), optionally capped where the material meets the domain boundary. Use it to visualize material boundaries in CTH-style AMR data; for meshes or image data use contour.

Common mistakes and assumptions:

• Volume fractions are expected as unsigned char 0-255 (as the Spy Plot reader produces by default); VolumeFractionValue is a fraction of 1 and is multiplied by 255, so 0.5 means a stored value of 127.5.
• Nothing is produced until at least one SelectMaterialArrays entry is given.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AMRContour. Identity: filters/AMRDualContour. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAMRContour",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAMRDualClip#

AMR Dual Clip (vtkPVAMRDualClip) clips non-overlapping AMR volume-fraction data with the dual grid and outputs, per selected material array, an unstructured grid of tetrahedra covering the region where the fraction exceeds VolumeFractionValue (multiplied by 255 internally). Level transitions are handled and interior tetrahedra can be decimated to keep the mesh small. Use it to get a volumetric mesh of a material region; use pvAMRContour for its surface only.

Common mistakes and assumptions:

• Volume fractions are expected as unsigned char 0-255 (as the Spy Plot reader produces by default); only unsigned char arrays are accepted here.
• The native class documentation states that it does not copy attributes yet; check which arrays the clipped mesh carries before relying on them.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AMRDualClip. Identity: filters/AMRDualClip. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAMRDualClip",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAMRFragmentIntegration#

Integrates fragments previously labelled by pvAMRConnectivity: for each material array it reads the RegionId-<array name> cell labels and outputs a table (one block per material in a multiblock) with "Fragment ID", "Fragment Volume", "Fragment Mass" and one "Volume Weighted <name>" or "Mass Weighted <name>" column per selected array. Fragment volume is the volume fraction (0-255 scaled) times cell volume; mass is the sum of the chosen mass array. Use it for size and mass statistics of debris or droplets; pvAMRFragmentsFilter runs connectivity and integration together.

Common mistakes and assumptions:

• The input must come from pvAMRConnectivity with the same material arrays; otherwise the native filter reports that no RegionId array exists.
• Give exactly one mass array per material array, in the same order; the native code pairs them by position.
• Mass arrays are summed as they are, so they must hold mass per cell, not density.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AMRFragmentIntegration. Identity: filters/AMRFragmentIntegration. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAMRFragmentIntegration",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAMRFragmentsFilter#

One-step fragment analysis for non-overlapping AMR material data: it runs AMR connectivity (always resolving fragments across blocks), then fragment integration and optionally surface extraction, with one shared VolumeFractionValue. Output port 0 holds the fragment tables ("Fragment ID", "Fragment Volume", "Fragment Mass" and one "Volume Weighted <name>" or "Mass Weighted <name>" column per selected array) when IntegrateFragments is on; port 1 holds the fragment surfaces when ExtractSurface is on, made watertight by the AMR dual contour if UseWatertightSurface is set or by ExtractCTHPart otherwise. Select a port with {"node": id, "port": n}.

Common mistakes and assumptions:

• The shared VolumeFractionValue is used raw by the connectivity step but scaled by 255 by the contour step, so labels and surfaces can disagree slightly near the threshold.
• Give one mass array per material array, in the same order.
• With default settings port 1 is empty; enable ExtractSurface to get surfaces.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AMRFragmentsFilter. Identity: filters/AMRFragmentsFilter. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAMRFragmentsFilter",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAMRGaussianPulseSource#

Generates a small synthetic overlapping AMR dataset (vtkOverlappingAMR) with two levels: a root block of 6 × 6 (× 6) points starting at (-2, -2, 0) with spacing RootSpacing, plus two refined patches. Cell arrays are "Gaussian-Pulse" = PulseAmplitude · exp(-Σ((x - origin)/width)²) and "Centroid". Use it to test AMR pipelines and readers (compare with pvXMLUniformGridAMRReader); it is not physical data.

Common mistakes and assumptions:

• The pulse origin and width are in the same coordinates as the grid; with the default spacing 0.5 the root block spans only [-2, 0.5] in x and y, so a pulse placed far outside is invisible.
• Schemaxis generates this source from ParaView's catalogue; it has not run a native acceptance check for it, so inspect the output before relying on it.

Native constructor: AMRGaussianPulseSource. Identity: sources/AMRGaussianPulseSource. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAMRGaussianPulseSource"
}

pvAMReXBoxLibGridReader#

Reads AMReX/BoxLib plotfiles (directories named like plt00000) into a hierarchical-box (overlapping AMR) dataset of cell-centred grid variables, levels 0 to Level. Listing several plotfile directories in FileNames makes a time series. Use it for AMReX codes such as Castro, Nyx, MAESTROeX or PeleC; use pvAMReXBoxLibParticlesReader for the particles stored in the same plotfiles.

Common mistakes and assumptions:

• Level defaults to 1, so only the two coarsest levels are loaded; raise it to see the finest data.
• Each FileNames entry is a plotfile directory, not the Header file inside it.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AMReXBoxLibGridReader. Identity: sources/AMReXGridReader. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAMReXBoxLibGridReader",
  "options": {
    "FileNames": [
      "REPLACE_WITH_VALUE"
    ]
  }
}

pvAMReXBoxLibParticlesReader#

Reads particles stored in AMReX plotfiles, producing point data (polydata blocks) with the selected particle components as point arrays; ParticleType names the particle container subdirectory inside each plotfile (ParaView default "particles"). It is a distributed reader. Several plotfile directories form a time series. Use pvAMReXBoxLibGridReader for the grid variables of the same plotfiles.

Common mistakes and assumptions:

• ParticleType must match the subdirectory name in the plotfile (e.g. DM or Tracer for some codes); a wrong name yields no particles.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AMReXBoxLibParticlesReader. Identity: sources/AMReXParticlesReader. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAMReXBoxLibParticlesReader",
  "options": {
    "FileNames": [
      "REPLACE_WITH_VALUE"
    ]
  }
}

pvANLHaloFinder#

Cosmology halo finder from the HACC CosmoTools library (vtkPANLHaloFinder). Input is an unstructured grid of particles with point arrays vx, vy, vz and id, as read by pvGenericIOReader. It links particles closer than Linkinglength (in units of the mean interparticle spacing) into friends-of-friends halos of at least FOFparticlethreshold particles. Port 0 returns the particles with fof_halo_tag (-1 outside halos), port 1 one point per halo with mass, centre of mass, mean velocity, velocity dispersion and centre, and port 2 subhalos when FindSubhalos is on.

Common mistakes and assumptions:

• Boxsize, Seedparticles and ParticleMass must match the simulation: the interparticle spacing that Linkinglength is measured in is Boxsize / Seedparticles, and the ParaView defaults are example values.
• Positions must lie in [0, Boxsize); others are wrapped periodically.
• Centre finding other than None can be very slow on large halos.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: ANLHaloFinder. Identity: filters/ANLHaloFinder. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvANLHaloFinder",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvANLSubhaloFinder#

Runs the CosmoTools subhalo finder (vtkPANLSubhaloFinder) on halos already found by pvANLHaloFinder: the input is that filter's port 0 particles with vx, vy, vz, id and fof_halo_tag. Port 0 returns the particles with a subhalo_tag array (-1 outside subhalos) and port 1 one point per subhalo with mass, centre of mass, mean velocity and velocity dispersion. Mode chooses all halos, halos larger than SizeThreshold, or only the halo ids in HalosToProcess.

Common mistakes and assumptions:

• Feed it pvANLHaloFinder output port 0; plain particle data lack fof_halo_tag.
• Use the same Boxsize, Seedparticles and ParticleMass as the halo finder.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: ANLSubhaloFinder. Identity: filters/ANLSubhaloFinder. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvANLSubhaloFinder",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAVSUCDReader#

Reads AVS Unstructured Cell Data files (.inp, ASCII or binary) into an unstructured grid with optional point (node) and cell arrays. Several files in FileNames form a time series. Use it for meshes and results exported in AVS UCD form by FE or CFD tools.

Common mistakes and assumptions:

• Only the arrays named in the file are available; coordinates are used as written, with no unit conversion.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this reader, so inspect the output blocks, arrays and time steps on your own files before relying on it.

Native constructor: AVSUCDReader. Identity: sources/AVSucdSeriesReader. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAVSUCDReader",
  "options": {
    "FileNames": [
      "REPLACE_WITH_VALUE"
    ]
  }
}

pvAdaptiveCosmoCore#

Reads LANL cosmo-format particle data that an adaptive-sampling preprocessor split into resolution levels (vtkACosmoReader, extension .cosmo). The output is a multiblock with one block per level (block 0 empty), each holding particle unstructured grids; Level chooses how many levels to load (1 is the coarsest). Use pvCosmoReader for ordinary single-resolution cosmo or Gadget files.

Common mistakes and assumptions:

• File names must follow the preprocessor pattern <base>.<process>.<levels>.cosmo; a dot elsewhere in the path, for example in a folder name, breaks this parsing.
• Data sampled in parallel (process number above 0) are rejected by the reader.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AdaptiveCosmoCore. Identity: sources/AdaptiveCosmoCore. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAdaptiveCosmoCore",
  "options": {
    "FileName": [
      "REPLACE_WITH_VALUE"
    ]
  }
}

pvAdaptiveResampleToImage#

Resamples any dataset onto several image (vtkImageData) blocks, output as a vtkPartitionedDataSet: a k-d tree splits the input points into at least NumberOfImages regions (rounded up to a power of two; 0 means one per MPI process, so one in serial), and each region is sampled with SamplingDimensions points, so densely populated regions get finer spacing. Points outside the input are marked invalid, as with pvResampleToImage. Use it to obtain regular grids of unevenly distributed data for volume rendering or image analysis; use pvResampleToImage for one image over the whole domain.

Common mistakes and assumptions:

• Each block has its own spacing and origin; do not treat the blocks as one uniform grid.
• The sample count is the number of blocks times the product of SamplingDimensions; 8 blocks of 64 × 64 × 64 already give about 2 million points.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AdaptiveResampleToImage. Identity: filters/AdaptiveResampleToImage. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAdaptiveResampleToImage",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAddFieldArrays#

Deprecated name (since ParaView 5.13, removal planned for 5.14) of pvFieldArraysFromFile, with the same behaviour: the input passes through and the field-data arrays of a legacy VTK file (.vtk) are attached to it, to every block of a composite input. Use pvFieldArraysFromFile in new documents.

Common mistakes and assumptions:

• Documents using this id will need updating when ParaView removes the alias.
• Only field data is added, never point or cell arrays.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AddFieldArrays. Identity: filters/AddFieldArrays. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

onVisit commands:

{
  "Reload": {
    "command": "Modified",
    "native": "Reload"
  }
}

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAddFieldArrays",
  "inputs": {
    "Input": "UPSTREAM_Input"
  },
  "options": {
    "FileName": "REPLACE_WITH_VALUE"
  }
}

Example command request (pipeline node only): "onVisit":["Reload"]. Commands run in this authored order before the update.

pvAggregateDataset#

Parallel data-movement filter: gathers the pieces of a distributed dataset onto NumberOfTargetProcesses MPI processes (ParaView default 1), leaving the other processes empty; VTK documents it for polydata and unstructured grids. Use it in MPI runs to reduce the number of pieces before writing or rendering a modest result. In a serial run there is only one process and the data pass through. Input must be a single, non-composite dataset.

Common mistakes and assumptions:

• Gathering a large dataset onto few processes can exhaust their memory.
• Schemaxis serial examples do not establish MPI behaviour. Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AggregateDataset. Identity: filters/AggregateDataSet. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAggregateDataset",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAlignImageOrigins#

Gives every image block of a composite (multiblock or partitioned) image dataset the same origin and rewrites each block's extent relative to it, so blocks that are parts of one image share a global index space and extent-based operations such as extractSubset behave consistently across blocks. All images must have the same spacing; the shared origin is the minimum corner of all blocks, shifted so that corner gets index MinimumExtent. Point positions do not change.

Common mistakes and assumptions:

• Blocks with different spacing cannot be aligned; ParaView reports an error.
• Blocks whose origins are not offset by whole multiples of the spacing cannot keep their positions; the native code reports them as misaligned.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AlignImageOrigins. Identity: filters/AlignImageOrigin. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAlignImageOrigins",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAngularPeriodicFilter#

Rebuilds a full rotor or periodic set of sectors from a computed sector: selected blocks are copied and rotated about an axis (X, Y or Z through Center) by multiples of an angle, rotating point coordinates and 3- and 9-component arrays (vectors and tensors) consistently. Each selected leaf becomes a multipiece of rotated copies, the first being the original; with IterationMode Maximum (ParaView default) there are round(360 / angle) copies, otherwise NumberOfPeriods. The angle is RotationAngle in degrees (default 10) or read in radians from a field array. VTK supports polydata, structured and unstructured grid leaves.

Common mistakes and assumptions:

• For multiblock input only blocks listed in BlockIndices are rotated; with none listed the output is an unchanged copy. A single non-composite dataset is always processed.
• Rotated arrays are computed on the fly by default (ComputeRotationsOnTheFly), saving memory but costing time at every access.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AngularPeriodicFilter. Identity: filters/AngularPeriodicFilter. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAngularPeriodicFilter",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAnimateModes#

Turns modal-analysis results, where each 'time step' of the input (e.g. Exodus) is really a mode shape, into a vibration animation: ModeShape (1-based) picks the mode, and the points are displaced by DisplacementMagnitude × cos(2π t) × the displacement vectors, with t the requested time in [0, 1]. Output keeps the input structure, has no discrete time steps and adds mode_shape field arrays. Use pvWarpByVector for a single static displacement.

Common mistakes and assumptions:

• DisplacementPreapplied is true by ParaView default, so one displacement is subtracted; set it false if the input coordinates are the undeformed geometry.
• Requested times are treated as a phase in [0, 1], not as physical time.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AnimateModes. Identity: filters/AnimateModes. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAnimateModes",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAnnotateAttributeData#

Produces a one-cell text table showing Prefix followed by one value of an array: element ElementId of the chosen point, cell, field or row array, taken from MPI rank ProcessId. Use it to label an image with a probe value or a global quantity such as a residual. Input must be a non-composite dataset or a table; ParaView needs its Python support for this filter.

Common mistakes and assumptions:

• Composite datasets are not supported; extract a block first (extractBlock).
• ElementId indexes the array's tuples from 0; check the index after any filter that reorders points or cells.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AnnotateAttributeData. Identity: filters/AnnotateAttributeData. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAnnotateAttributeData",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAnnotateGlobalData#

Turns one value of a field-data (global) array into a text table: Prefix, the value formatted with Format, then Suffix, e.g. "Value is: 1.234e+05". If the array has one entry per time step it is indexed by the current time step, so the text follows the animation. The output is a one-row text table for display as an annotation, not a dataset to process further.

Common mistakes and assumptions:

• Only field (global) arrays qualify; point and cell arrays are not listed.
• Format is a C printf pattern and must match the array type: %g/%f/%e for floating point, %d for integers; a mismatch makes ParaView warn and drop the value.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AnnotateGlobalData. Identity: filters/AnnotateGlobalData. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAnnotateGlobalData",
  "inputs": {
    "Input": [
      "UPSTREAM_Input"
    ]
  }
}

pvAnnotateSelection#

Adds a string array named "Annotate Selection" to the points or cells of Input, labelling each element selected by node i of the Selection with Labels[i] and every other element with DefaultLabel. Use it to tag regions (e.g. inlet, outlet) for colouring or export. The output is the input dataset with the extra array.

Common mistakes and assumptions:

• The number of Labels must equal the number of selection nodes; otherwise ParaView warns and the output stays empty.
• Only POINT or CELL selections whose nodes hold element indices are labelled; convert other selection types to INDICES with pvConvertSelection.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AnnotateSelection. Identity: filters/AnnotateSelection. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAnnotateSelection",
  "inputs": {
    "Input": "UPSTREAM_Input",
    "Selection": "UPSTREAM_Selection"
  }
}

pvAnnotateTime#

Source (no input) that produces a one-cell table whose Text column holds the requested animation time formatted with Format, e.g. "Time: 0.250000". It reports the time the pipeline asks it to update, not a dataset's time; when no time is requested the text is "?". Use pvAnnotateTimeFilter to label the time of a particular dataset, and pvText for fixed text.

Common mistakes and assumptions:

• Format uses fmt syntax with the argument {time}; legacy printf %f is converted with a warning.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AnnotateTime. Identity: sources/TimeToTextConvertorSource. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAnnotateTime"
}

pvAnnotateTimeFilter#

Produces a one-row text table showing the input's current time, transformed as time × Scale + Shift and formatted with an fmt-style Format such as "Time: {time:.3f} s". Use it to label animations or images with physical time. It needs a time-dependent input; pvAnnotateTime is the source variant that needs no input.

Common mistakes and assumptions:

• Format uses fmt/Python brace syntax with the name time; old printf patterns such as "%f" are converted with a warning.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AnnotateTimeFilter. Identity: filters/TimeToTextConvertor. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAnnotateTimeFilter",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAppendArcLength#

Deprecated alias of pvPolylineLength: ParaView 5.13 marks AppendArcLength for removal in 5.14. It runs the same vtkAppendArcLength filter, adding a point array arc_length with the distance along each polyline from its first point (0 for points of other cell types).

Common mistakes and assumptions:

• Use pvPolylineLength in new workflows; this identifier is expected to disappear when ParaView 5.14 is absorbed.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AppendArcLength. Identity: filters/AppendArcLength. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAppendArcLength",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAppendAttributes#

Combines the point and cell arrays of several inputs that share the same geometry: the output copies the first input's geometry and adds every array from all inputs. Inputs whose point or cell count differs from the first are ignored for that attribute type, and a repeated array name gets the suffix input<n>. Use it to gather fields computed on separate branches of one mesh (e.g. gradient and cellSize results) into one node; use append or pvAppendDatasets to join different meshes.

Common mistakes and assumptions:

• Only counts are checked, not point order or coordinates; inputs from differently numbered meshes silently attach values to the wrong points.
• Duplicate array names are renamed, not replaced; check names before later nodes refer to them.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AppendAttributes. Identity: filters/AppendAttributes. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAppendAttributes",
  "inputs": {
    "Input": [
      "UPSTREAM_Input"
    ]
  }
}

pvAppendDatasets#

Merges the meshes of several datasets into one. With OutputDataSetType Unstructured Grid (ParaView default) inputs of almost any type are appended; with Polygonal Mesh only polydata inputs are merged and the rest are left out. Only point and cell arrays present on every input are kept, and coincident points are not merged. Use it to combine separate nodes, e.g. two clipped regions; append is the curated equivalent, pvAppendGeometry keeps polydata, and merge or pvMergeBlocks flatten one composite input.

Common mistakes and assumptions:

• Composite (multiblock) inputs are not accepted; flatten them with merge first.
• Arrays missing from any one input are dropped; make names agree, e.g. with pvRenameArrays.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AppendDatasets. Identity: filters/Append. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAppendDatasets",
  "inputs": {
    "Input": [
      "UPSTREAM_Input"
    ]
  }
}

pvAppendGeometry#

Appends several polygonal datasets (vtkPolyData) into one polydata, keeping vertices, lines, polygons and strips; only arrays present on every input survive and points are not merged. Use it to combine surfaces or lines from several nodes while staying polydata, e.g. for a surface writer; appendGeometry is the curated equivalent and pvAppendDatasets accepts mixed types.

Common mistakes and assumptions:

• Every input must be polydata; extract surfaces of volume meshes first.
• Arrays that exist on only some inputs disappear from the result.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AppendGeometry. Identity: filters/AppendPolyData. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAppendGeometry",
  "inputs": {
    "Input": [
      "UPSTREAM_Input"
    ]
  }
}

pvAppendLocationAttributes#

Adds point coordinates and cell centres as data arrays: PointLocations (3-component point array, a copy of each point's coordinates) and CellCenters (3-component cell array). Geometry and existing arrays are unchanged. Use it when a calculator, export or table needs coordinates as ordinary arrays, e.g. to compute a radius or write x, y, z to CSV. This is the old name of the same ParaView filter.

Common mistakes and assumptions:

• ParaView 5.13 marks this proxy deprecated (renamed Coordinates, removal planned for 5.14); use pvCoordinates, which has the same behaviour and settings.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AppendLocationAttributes. Identity: filters/AppendLocationAttributes. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAppendLocationAttributes",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAppendMolecule#

Appends one or more molecules (vtkMolecule) into a single molecule containing all atoms and bonds with their atom and bond data. The inputs must carry the same data arrays (same number and names). Use it to assemble a system from several molecule readers or pvConvertIntoMolecule nodes before bonding, rendering or export.

Common mistakes and assumptions:

• VTK merges atoms at identical positions by default (MergeCoincidentAtoms, not exposed in ParaView), so overlapping copies of a structure collapse into one.
• Inputs with differing atom or bond arrays are not reconciled; give all inputs the same arrays.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AppendMolecule. Identity: filters/AppendMolecule. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAppendMolecule",
  "inputs": {
    "Input": [
      "UPSTREAM_Input"
    ]
  }
}

pvAppendReduce#

Parallel data-movement filter (vtkReductionFilter with vtkAppendFilter as the post-gather helper): it gathers the pieces of a distributed dataset from all MPI processes and appends them into one unstructured grid on one process or on every process. Use it in MPI runs when a later step needs the whole dataset in one place; in a serial run there is only process 0, so it just appends the single piece. Input must be a non-composite vtkDataSet. To combine separate nodes use append or merge.

Common mistakes and assumptions:

• Gathering a large mesh onto one process can exceed that process's memory.
• Schemaxis serial examples do not establish MPI behaviour. Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AppendReduce. Identity: filters/AppendReductionFilter. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAppendReduce",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvAppendSelections#

Combines several selections (vtkSelection), for example ID, block and threshold selections, into one (vtkAppendSelection). With no Expression the inputs are joined with OR; with an Expression such as "(A|B)&!C" the inputs, named by SelectionNames in input order, are combined with | (or), & (and), ^ (xor) and ! (not). InsideOut inverts the result. A selection is not a dataset: connect it to the Selection input of pvExtractSelection, pvPlotSelectionOverTime or pvAnnotateSelection; it cannot be published as geometry.

Common mistakes and assumptions:

• When Expression is set, give exactly one name per input; otherwise the native filter fails.
• Inputs should use the same FieldType (all cells or all points); the filter does not check this.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AppendSelections. Identity: filters/AppendSelections. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAppendSelections",
  "inputs": {
    "Input": [
      "UPSTREAM_Input"
    ]
  }
}

pvArrow#

Creates a 3-D arrow of total length 1 along +x from the origin: a cylindrical shaft joined to a conical tip, as polydata without normals. Use it as a glyph shape or annotation; scale and orient it with a transform, or use pvGlyph to place many arrows on vector data.

Common mistakes and assumptions:

• Normals are not generated, so the arrow renders faceted; apply the normals operation for smooth shading.
• TipLength, ShaftRadius and TipRadius are fractions of the unit arrow length, not absolute sizes.
• Schemaxis generates this source from ParaView's catalogue; it has not run a native acceptance check for it, so inspect the output before relying on it.

Native constructor: Arrow. Identity: sources/ArrowSource. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvArrow"
}

pvAxes#

Creates three line segments along the x, y and z directions from Origin, as polydata with normals and a point scalar "Axes" (0 on the x line, 0.25 on y, 0.5 on z), so colouring by that array distinguishes the axes. Each line has length ScaleFactor, or runs from -ScaleFactor to +ScaleFactor when Symmetric is true. Use it as an orientation reference in a scene.

Common mistakes and assumptions:

• The axis colours depend on the colour map applied to "Axes"; the native documentation's colour descriptions are inconsistent, so check the rendered result.
• Lines are dataset geometry with no arrowheads or labels; scale them to the data with ScaleFactor.
• Schemaxis generates this source from ParaView's catalogue; it has not run a native acceptance check for it, so inspect the output before relying on it.

Native constructor: Axes. Identity: sources/Axes. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAxes"
}

pvAxisAlignedSlice#

Slices hyper tree grids and overlapping AMR data with an axis-aligned plane while keeping the input type, so a 3-D hyper tree grid becomes 2-D hyper tree grids. For hyper tree grids each entry of OffsetValues gives one slice and the output is a partitioned dataset collection; for AMR one slice at the plane is produced, at resolution Level. Use slice or pvSlice for ordinary meshes.

Common mistakes and assumptions:

• Only vtkHyperTreeGrid and vtkOverlappingAMR inputs are accepted.
• The cut plane must be axis-aligned; oblique normals are not supported.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: AxisAlignedSlice. Identity: filters/AxisAlignedSlice. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

Nested CutFunction → Axis Aligned Plane#

Syntax: {"type":"Axis Aligned Plane","options":{...}}. Native identity: implicit_functions/Axis Aligned Plane. Omitted nested options retain native values on subsequent visits.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvAxisAlignedSlice",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvBDFReader#

Reads a Nastran Bulk Data File (.bdf) in free-field format into an unstructured grid. Only a small subset of entries is understood: GRID points, CTRIA3 triangles, PLOAD2 pressure loads (a cell array) and TITLE and TIME (field data); other entries such as CQUAD4 or CTETRA are skipped with a warning listing them. Use it for triangulated Nastran surfaces with pressure loads, not for general finite-element models.

Common mistakes and assumptions:

• Fixed-field (8-character column) BDF files are not supported; convert them to free-field (comma-separated) format.
• Check the reader's warning for skipped entries; a model with only quadrilaterals or solids yields points without cells.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: BDFReader. Identity: sources/BDFReader. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvBDFReader",
  "options": {
    "FileName": "REPLACE_WITH_VALUE"
  }
}

pvBYUReader#

Reads Movie.BYU geometry files (.g) into polydata made of polygons. Use it for legacy surface models in this format; companion displacement, scalar or texture files supported by vtkBYUReader are not exposed by the ParaView proxy, so only the geometry is read.

Common mistakes and assumptions:

• Coordinates are used as written; check the unit before combining with other data.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this reader, so inspect the output blocks, arrays and time steps on your own files before relying on it.

Native constructor: BYUReader. Identity: sources/byureader. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvBYUReader",
  "options": {
    "FileName": "REPLACE_WITH_VALUE"
  }
}

pvBlockIds#

Adds a cell array named BlockIdScalars to every block of a multiblock dataset, holding the index of the block (unsigned char), so blocks can be coloured, thresholded or counted by block. The input must be a vtkMultiBlockDataSet; structure and other arrays are unchanged. Use extractBlock to keep selected blocks instead.

Common mistakes and assumptions:

• Partitioned dataset collections (e.g. from newer readers) are not multiblock; the input domain rejects them.
• The index is a traversal counter, not the block name; keep names via the reader's block list.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: BlockIds. Identity: filters/BlockIds. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvBlockIds",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvBlockScalars#

Adds a cell array named BlockIdScalars to every block of a multiblock dataset, holding the index of the block (unsigned char), so blocks can be coloured, thresholded or counted by block. The input must be a vtkMultiBlockDataSet; structure and other arrays are unchanged. This is the old name of the same ParaView filter.

Common mistakes and assumptions:

• ParaView 5.13 marks this proxy deprecated (renamed BlockIds, removal planned for 5.14); use pvBlockIds, which has the same behaviour and settings.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: BlockScalars. Identity: filters/BlockIdScalars. Role: pipeline. Output kinds: ["data"].

Inputs#

Options#

No authored options.

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvBlockScalars",
  "inputs": {
    "Input": "UPSTREAM_Input"
  }
}

pvBlockSelectionSource#

Creates a block selection: a vtkSelection naming whole blocks of a composite dataset by their flat (composite) index, so pvExtractSelection keeps just those blocks. Choose it when you know the numeric block indices; pvBlockSelectorsSelectionSource selects blocks by path, which is more robust, and extractBlock or pvExtractBlock extract blocks directly without a selection. A selection is not a dataset: connect it to the Selection input of pvExtractSelection, pvPlotSelectionOverTime or pvAnnotateSelection; it cannot be published as geometry.

Common mistakes and assumptions:

• Flat indices count every node of the composite tree in depth-first order, including the root (0) and intermediate multiblocks, so the first leaf is usually 1 or more.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: BlockSelectionSource. Identity: sources/BlockSelectionSource. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvBlockSelectionSource"
}

pvBlockSelectorsSelectionSource#

Creates a block selection from selector paths (vtkPVSelectionSource with BLOCK_SELECTORS content): XPath-style expressions such as "/Root/internalMesh" or "//patch" evaluated against a data assembly of the composite dataset, by default ParaView's Hierarchy. Choose it over pvBlockSelectionSource when block names are known but indices may change. A selection is not a dataset: connect it to the Selection input of pvExtractSelection, pvPlotSelectionOverTime or pvAnnotateSelection; it cannot be published as geometry.

Common mistakes and assumptions:

• Block names in the Hierarchy assembly are made path-safe: characters other than letters, digits, '.', '-' and '_' are dropped, so "Level 0" becomes Level0.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: BlockSelectorsSelectionSource. Identity: sources/BlockSelectorsSelectionSource. Role: pipeline. Output kinds: ["data"].

Inputs#

No connected inputs (source/resource).

Options#

Execution contract:

{
  "mode": "serial",
  "performance": "unknown"
}

Coverage and unbound native properties:

{
  "defaults": "native defaults for omitted options",
  "gaps": {},
  "origin": "generated",
  "output": "native inspection required; explicit output-port selection available",
  "outputPorts": null,
  "qualification": "not-run"
}

Syntax example#

Place in nodes. Data outputs may be selected by a scene; resource outputs must be connected to a compatible consumer.

{
  "id": "result",
  "filter": "pvBlockSelectorsSelectionSource"
}

pvBoundaryMeshQuality#

Extracts the boundary faces of a volume mesh as polydata and, for each face, measures its relation to the volume cell it belongs to: DistanceFromCellCenterToFaceCenter, DistanceFromCellCenterToFacePlane (both in dataset length units) and AngleFaceNormalAndCellCenterToFaceCenterVector in degrees. Use it to inspect near-wall cell size and skewness, e.g. first-cell height on CFD walls. Input must be a volumetric grid (unstructured, structured, rectilinear or image data); use pvMeshQuality for whole-cell shape metrics.

Common mistakes and assumptions:

• The output contains only boundary faces, so it cannot be combined cell by cell with the volume mesh without the original cell ids.
• Schemaxis generates this binding from ParaView's catalogue; it has not run a native acceptance check for this operation.

Native constructor: BoundaryMeshQuality. Identity: filters/BoundaryMeshQuality. Role: pipeline. Output kinds: ["data"].

Inputs#