---
title: "VectorDisplacementPlot3D"
language: "en"
type: "Symbol"
summary: "VectorDisplacementPlot3D[{vx, vy, vz}, {x, xmin, xmax}, {y, ymin, ymax}, {z, zmin, zmax}] generates a displacement plot of the vector field {vx, vy, vz} as a function of x, y and z. VectorDisplacementPlot3D[{vx, vy, vz}, {x, y, z} \\[Element] reg] plots the displacement over the geometric region reg. VectorDisplacementPlot3D[{{vx, vy, vz}, s}, ...] uses the scalar field s to style the displacement."
canonical_url: "https://reference.wolfram.com/language/ref/VectorDisplacementPlot3D.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Vector Visualization"
    link: "https://reference.wolfram.com/language/guide/VectorVisualization.en.md"
related_functions: 
  - 
    title: "VectorDisplacementPlot"
    link: "https://reference.wolfram.com/language/ref/VectorDisplacementPlot.en.md"
  - 
    title: "VectorPlot3D"
    link: "https://reference.wolfram.com/language/ref/VectorPlot3D.en.md"
  - 
    title: "StreamPlot3D"
    link: "https://reference.wolfram.com/language/ref/StreamPlot3D.en.md"
  - 
    title: "VectorPlot"
    link: "https://reference.wolfram.com/language/ref/VectorPlot.en.md"
  - 
    title: "VectorDensityPlot"
    link: "https://reference.wolfram.com/language/ref/VectorDensityPlot.en.md"
  - 
    title: "StreamPlot"
    link: "https://reference.wolfram.com/language/ref/StreamPlot.en.md"
  - 
    title: "StreamDensityPlot"
    link: "https://reference.wolfram.com/language/ref/StreamDensityPlot.en.md"
---
# VectorDisplacementPlot3D

VectorDisplacementPlot3D[{vx, vy, vz}, {x, xmin, xmax}, {y, ymin, ymax}, {z, zmin, zmax}] generates a displacement plot of the vector field {vx, vy, vz} as a function of x, y and z.

VectorDisplacementPlot3D[{vx, vy, vz}, {x, y, z}∈reg] plots the displacement over the geometric region reg.

VectorDisplacementPlot3D[{{vx, vy, vz}, s}, …] uses the scalar field s to style the displacement.

## Details and Options

* ``VectorDisplacementPlot3D`` uses the vector field ``{vx, vy, vz}`` to displace the points in a region. By default, the size of the displacement is automatically scaled so that both small and large displacements remain visible. The displaced region is by default colored according to the magnitude of the displacement.

[image]

* ``VectorDisplacementPlot3D`` has the same options as ``Graphics3D``, with the following additions and changes: []

|                             |                    |                                                      |
| --------------------------- | ------------------ | ---------------------------------------------------- |
| Axes                        | True               | whether to include axes on the plot                  |
| BoundaryStyle               | None               | how to draw displaced boundaries                     |
| BoxRatios                   | Automatic          | ratio of height to width                             |
| ClippingStyle               | Automatic          | how to display arrows outside the vector range       |
| ColorFunction               | Automatic          | how to color the displaced region                    |
| ColorFunctionScaling        | True               | whether to scale the arguments to ColorFunction      |
| EvaluationMonitor           | None               | expression to evaluate at every function evaluation  |
| Mesh                        | None               | how many mesh lines in each direction to draw        |
| MeshFunctions               | {#1&, #2&, #3&}    | how to determine the placement of mesh lines         |
| MeshStyle                   | Automatic          | the style for mesh lines                             |
| Method                      | Automatic          | methods to use for the plot                          |
| PerformanceGoal             | \$PerformanceGoal  | aspects of performance to try to optimize            |
| PlotLegends                 | None               | legends to include                                   |
| PlotRange                   | {Full, Full, Full} | range of x, y, z values to include                   |
| PlotRangePadding            | Automatic          | how much to pad the range of values                  |
| PlotStyle                   | Automatic          | how to style the deformed region                     |
| PlotTheme                   | \$PlotTheme        | overall theme for the plot                           |
| RegionBoundaryStyle         | Automatic          | how to style plot region boundaries                  |
| RegionFunction              | (True&)            | determine what region to include                     |
| VectorColorFunction         | Automatic          | how to color vectors                                 |
| VectorColorFunctionScaling  | True               | whether to scale the argument to VectorColorFunction |
| VectorMarkers               | Automatic          | shape to use for arrows                              |
| VectorPoints                | None               | the number or placement of arrows                    |
| VectorRange                 | Automatic          | range of vector lengths to show                      |
| VectorScaling               | None               | how to scale the sizes of arrows                     |
| VectorSizes                 | Automatic          | sizes of displayed arrows                            |
| VectorStyle                 | Automatic          | how to draw arrows                                   |
| WorkingPrecision            | MachinePrecision   | precision to use in internal computations            |

* By default, the displacement plot shows a representation of the original region and the displaced region.

* ``RegionBoundaryStyle`` and ``RegionFillingStyle`` can be used to change the style of the original region.

* ``VectorSizes`` determines the visual scale of the displacement. Possible settings include:

|           |                                              |
| --------- | -------------------------------------------- |
| Automatic | automatically scale the displacement         |
| s         | scale the default displacement by a factor s |
| Full      | use the raw, unscaled displacement           |

* Additional settings for ``VectorPoints`` to show displacement arrows include:

|            |                                  |
| ---------- | -------------------------------- |
| Automatic  | automatically chosen points      |
| "Boundary" | points along the boundary of reg |

* By default, displacement arrows connect locations in the original region with the corresponding displaced locations.

### List of all options

|                            |                    |                                                                                    |
| -------------------------- | ------------------ | ---------------------------------------------------------------------------------- |
| AlignmentPoint             | Center             | the default point in the graphic to align with                                     |
| AspectRatio                | Automatic          | ratio of height to width                                                           |
| Axes                       | True               | whether to include axes on the plot                                                |
| AxesEdge                   | Automatic          | on which edges to put axes                                                         |
| AxesLabel                  | None               | axes labels                                                                        |
| AxesOrigin                 | Automatic          | where axes should cross                                                            |
| AxesStyle                  | {}                 | graphics directives to specify the style for axes                                  |
| Background                 | None               | background color for the plot                                                      |
| BaselinePosition           | Automatic          | how to align with a surrounding text baseline                                      |
| BaseStyle                  | {}                 | base style specifications for the graphic                                          |
| BoundaryStyle              | None               | how to draw displaced boundaries                                                   |
| Boxed                      | True               | whether to draw the bounding box                                                   |
| BoxRatios                  | Automatic          | ratio of height to width                                                           |
| BoxStyle                   | {}                 | style specifications for the box                                                   |
| ClippingStyle              | Automatic          | how to display arrows outside the vector range                                     |
| ClipPlanes                 | None               | clipping planes                                                                    |
| ClipPlanesStyle            | Automatic          | style specifications for clipping planes                                           |
| ColorFunction              | Automatic          | how to color the displaced region                                                  |
| ColorFunctionScaling       | True               | whether to scale the arguments to ColorFunction                                    |
| ContentSelectable          | Automatic          | whether to allow contents to be selected                                           |
| ControllerLinking          | False              | when to link to external rotation controllers                                      |
| ControllerPath             | Automatic          | what external controllers to try to use                                            |
| Epilog                     | {}                 | 2D graphics primitives to be rendered after the main plot                          |
| EvaluationMonitor          | None               | expression to evaluate at every function evaluation                                |
| FaceGrids                  | None               | grid lines to draw on the bounding box                                             |
| FaceGridsStyle             | {}                 | style specifications for face grids                                                |
| FormatType                 | TraditionalForm    | default format type for text                                                       |
| ImageMargins               | 0.                 | the margins to leave around the graphic                                            |
| ImagePadding               | All                | what extra padding to allow for labels, etc.                                       |
| ImageSize                  | Automatic          | absolute size at which to render the graphic                                       |
| LabelStyle                 | {}                 | style specifications for labels                                                    |
| Lighting                   | Automatic          | simulated light sources to use                                                     |
| Mesh                       | None               | how many mesh lines in each direction to draw                                      |
| MeshFunctions              | {#1&, #2&, #3&}    | how to determine the placement of mesh lines                                       |
| MeshStyle                  | Automatic          | the style for mesh lines                                                           |
| Method                     | Automatic          | methods to use for the plot                                                        |
| PerformanceGoal            | \$PerformanceGoal  | aspects of performance to try to optimize                                          |
| PlotLabel                  | None               | a label for the plot                                                               |
| PlotLegends                | None               | legends to include                                                                 |
| PlotRange                  | {Full, Full, Full} | range of x, y, z values to include                                                 |
| PlotRangePadding           | Automatic          | how much to pad the range of values                                                |
| PlotRegion                 | Automatic          | final display region to be filled                                                  |
| PlotStyle                  | Automatic          | how to style the deformed region                                                   |
| PlotTheme                  | \$PlotTheme        | overall theme for the plot                                                         |
| PreserveImageOptions       | Automatic          | whether to preserve image options when displaying new versions of the same graphic |
| Prolog                     | {}                 | 2D graphics primitives to be rendered before the main plot                         |
| RegionBoundaryStyle        | Automatic          | how to style plot region boundaries                                                |
| RegionFunction             | (True&)            | determine what region to include                                                   |
| RotationAction             | "Fit"              | how to render after interactive rotation                                           |
| SphericalRegion            | Automatic          | whether to make the circumscribing sphere fit in the final display area            |
| Ticks                      | Automatic          | specification for ticks                                                            |
| TicksStyle                 | {}                 | style specification for ticks                                                      |
| TouchscreenAutoZoom        | False              | whether to zoom to fullscreen when activated on a touchscreen                      |
| VectorColorFunction        | Automatic          | how to color vectors                                                               |
| VectorColorFunctionScaling | True               | whether to scale the argument to VectorColorFunction                               |
| VectorMarkers              | Automatic          | shape to use for arrows                                                            |
| VectorPoints               | None               | the number or placement of arrows                                                  |
| VectorRange                | Automatic          | range of vector lengths to show                                                    |
| VectorScaling              | None               | how to scale the sizes of arrows                                                   |
| VectorSizes                | Automatic          | sizes of displayed arrows                                                          |
| VectorStyle                | Automatic          | how to draw arrows                                                                 |
| ViewAngle                  | Automatic          | angle of the field of view                                                         |
| ViewCenter                 | Automatic          | point to display at the center                                                     |
| ViewMatrix                 | Automatic          | explicit transformation matrix                                                     |
| ViewPoint                  | {1.3, -2.4, 2.}    | viewing position                                                                   |
| ViewProjection             | Automatic          | projection method for rendering objects distant from the viewer                    |
| ViewRange                  | All                | range of viewing distances to include                                              |
| ViewVector                 | Automatic          | position and direction of a simulated camera                                       |
| ViewVertical               | {0, 0, 1}          | direction to make vertical                                                         |
| WorkingPrecision           | MachinePrecision   | precision to use in internal computations                                          |

## Examples (114)

### Basic Examples (5)

Plot a reference region and the corresponding (scaled) deformed region for a specified displacement field:

```wl
In[1]:= VectorDisplacementPlot3D[{2x, -y, -z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

---

Include a legend for the norms of the displacements:

```wl
In[1]:= VectorDisplacementPlot3D[{2x, -y, -z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, PlotLegends -> Automatic]

Out[1]= [image]
```

---

Show a sampling of displacement vectors that extend from points in the reference region to corresponding points in the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{2x, -y, -z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorPoints -> "Boundary"]

Out[1]= [image]
```

---

Use a scalar field other than the norm of the displacement field to color the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{{2x, -y, -z}, x y z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

---

Show a twisted elastic bar:

```wl
In[1]:= VectorDisplacementPlot3D[IconizedObject[«[image]»], {x, y, z}∈[image], Mesh -> 3, RegionFillingStyle -> None, RegionBoundaryStyle -> None]

Out[1]= [image]
```

### Scope (18)

#### Sampling (11)

Visualize a scaled displacement field by comparing a reference and a deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

---

Vectors are drawn from points in the reference region to corresponding points in the (scaled) deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorPoints -> "Boundary"]

Out[1]= [image]
```

---

Specify other vector locations:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorPoints -> "Hexagonal"]

Out[1]= [image]
```

---

Displacements can be drawn to scale:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorSizes -> Full]

Out[1]= [image]
```

---

Use the displacement field over a specified region:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, RegionFunction -> Function[{x, y, z, vx, vy, vz, n}, x y z ≤ 0.1]]

Out[1]= [image]
```

---

The domain may be specified by a region:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, y, z}∈Ball[]]

Out[1]= [image]
```

---

The domain may be a curve:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, y, z}∈HilbertCurve[2, 3]]

Out[1]= [image]
```

---

The domain may be an ``ImplicitRegion`` :

```wl
In[1]:= ℛ = ImplicitRegion[1 ≤ x^4 + y^4 + z^4 ≤ 16, {x, y, z}];

In[2]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, y, z}∈ℛ]

Out[2]= [image]
```

---

The domain may be a ``ParametricRegion`` :

```wl
In[1]:= ℛ = ParametricRegion[{{t, (1 + t) s ^ 2 - t, s}, -1 ≤ s ≤ 1 && 0 ≤ t ≤ 1}, {s, t}];

In[2]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, y, z}∈ℛ]

Out[2]= [image]
```

---

The domain may be a ``MeshRegion`` :

```wl
In[1]:= ℛ = MeshRegion[Table[(2 + (-1)^t){Cos[π t / 5], Sin[π t / 5], Sin[π t / 5]}, {t, 0, 9}], Polygon[{Range[10]}]];

In[2]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, y, z}∈ℛ]

Out[2]= [image]
```

---

The domain may be a ``BoundaryMeshRegion`` :

```wl
In[1]:= ℛ = BoundaryMeshRegion[{{0, 0, 0}, {4, 0, 0}, {0, 4, 0}, {0, 0, 4}}, Polygon[{{1, 2, 3}, {1, 2, 4}, {2, 3, 4}, {1, 3, 4}}]];

In[2]:= VectorDisplacementPlot3D[{y, x / 2, z}, {x, y, z}∈ℛ]

Out[2]= [image]
```

#### Presentation (7)

Specify the ``ColorFunction`` for the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{x, -y / 2, -z / 4}, {x, y, z}∈Ball[], ColorFunction -> "Rainbow"]

Out[1]= [image]
```

---

Specify the ``VectorColorFunction`` independently of the ``ColorFunction`` :

```wl
In[1]:= VectorDisplacementPlot3D[{x, -y / 2, -z / 4}, {x, y, z}∈Ball[], VectorPoints -> Automatic, VectorColorFunction -> "DarkRainbow"]

Out[1]= [image]
```

---

Use a single color for the arrows:

```wl
In[1]:= VectorDisplacementPlot3D[{x, -y / 2, -z / 4}, {x, y, z}∈Ball[], VectorPoints -> Automatic, VectorColorFunction -> None]

Out[1]= [image]
```

---

Include a legend for the norms of the displacements:

```wl
In[1]:= VectorDisplacementPlot3D[{x, -y / 2, -z / 4}, {x, y, z}∈Ball[], PlotLegends -> Automatic]

Out[1]= [image]
```

---

Include a legend for the optional scalar field:

```wl
In[1]:= VectorDisplacementPlot3D[{{x, -y / 2, -z / 4}, x y z}, {x, y, z}∈Ball[], PlotLegends -> Automatic]

Out[1]= [image]
```

---

Include a ``Mesh`` :

```wl
In[1]:= VectorDisplacementPlot3D[{x, -y / 2, -z / 4}, {x, y, z}∈Ball[], Mesh -> 5]

Out[1]= [image]
```

---

Draw displacements to scale:

```wl
In[1]:= VectorDisplacementPlot3D[{x, -y / 2, -z / 4}, {x, y, z}∈Ball[], VectorSizes -> Full]

Out[1]= [image]
```

### Options (63)

#### BoxRatios (2)

By default, the aspect ratio is ``Automatic`` :

```wl
In[1]:= VectorDisplacementPlot3D[{y, x, 1}, {x, -2, 2}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

---

Set the box ratios:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x, 1}, {x, -2, 2}, {y, -1, 1}, {z, -1, 1}, BoxRatios -> {1, 1, 1}]

Out[1]= [image]
```

#### BoundaryStyle (3)

By default, the boundary style matches the interior colors in the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{y, x, z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Specify the ``BoundaryStyle`` :

```wl
In[1]:= VectorDisplacementPlot3D[{y, x, z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, BoundaryStyle -> Directive[Red, Thick]]

Out[1]= [image]
```

---

``BoundaryStyle`` applies to regions cut by ``RegionFunction`` :

```wl
In[1]:= VectorDisplacementPlot3D[{y, x, z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, BoundaryStyle -> Directive[Red, Thick], RegionFunction -> Function[{x, y, z, vx, vy, vz, n}, x^2 + z^2 ≥ 1]]

Out[1]= [image]
```

#### ColorFunction (4)

By default, the deformed region is colored by the norm of the field:

```wl
In[1]:= VectorDisplacementPlot3D[{1 - x, y, z}, {x, y, z}∈Ball[]]

Out[1]= [image]
```

---

Specify a scalar field for the colors:

```wl
In[1]:= VectorDisplacementPlot3D[{{1 - x, y, z}, z}, {x, y, z}∈Ball[]]

Out[1]= [image]
```

---

Use a named color gradient:

```wl
In[1]:= VectorDisplacementPlot3D[{1 - x, y, z}, {x, y, z}∈Ball[], ColorFunction -> "Rainbow"]

Out[1]= [image]
```

---

Specify a custom ``ColorFunction`` :

```wl
In[1]:= VectorDisplacementPlot3D[{1 - x, y, z}, {x, y, z}∈Ball[], ColorFunction -> Function[{x, y, z, vx, vy, vz, n}, Hue[vx vy, n, 1]]]

Out[1]= [image]
```

#### ColorFunctionScaling (2)

Use the natural range of norm values:

```wl
In[1]:= VectorDisplacementPlot3D[{1 - x, y, z}, {x, y, z}∈Ball[], ColorFunctionScaling -> False]

Out[1]= [image]
```

---

Control the scaling of the individual arguments of the ``ColorFunction`` :

```wl
In[1]:= VectorDisplacementPlot3D[{1 - x, y, z}, {x, y, z}∈Ball[], ColorFunction -> Function[{x, y, z, vx, vy, vz, n}, Hue[vx vy, n, 1]], ColorFunctionScaling -> {True, True, True, False, False, False, True}]

Out[1]= [image]
```

#### Mesh (6)

Specify a ``Mesh`` to visualize the displacements:

```wl
In[1]:= VectorDisplacementPlot3D[{z, y, x}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, Mesh -> 5]

Out[1]= [image]
```

---

Show the initial and final sampling mesh:

```wl
In[1]:= {VectorDisplacementPlot3D[{z, y, x}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, Mesh -> Full], VectorDisplacementPlot3D[{z, y, x}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, Mesh -> All]}

Out[1]= {[image], [image]}
```

---

Specify 10 mesh lines in the $x$ direction, 5 in the $y$ direction and 3 in the $z$ direction:

```wl
In[1]:= VectorDisplacementPlot3D[{z, y, x}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, Mesh -> {10, 5, 3}]

Out[1]= [image]
```

---

Use mesh lines at specific values:

```wl
In[1]:= VectorDisplacementPlot3D[{z, y, x}, {x, 0, 10}, {y, 0, 10}, {z, 0, 10}, Mesh -> {{2, 4}, {5, 6, 7}, {5}}]

Out[1]= [image]
```

---

Highlight specific mesh lines:

```wl
In[1]:= VectorDisplacementPlot3D[{z, y, x}, {x, 0, 10}, {y, 0, 10}, {z, 0, 10}, Mesh -> {{{2, Red}, {4, Blue}}, {5, 6, 7}, {{5, Green}}}]

Out[1]= [image]
```

---

Mesh lines are suppressed in the reference region if the boundary and filling of the reference region are removed:

```wl
In[1]:= VectorDisplacementPlot3D[{z, y, x}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, Mesh -> 5, RegionBoundaryStyle -> None, RegionFillingStyle -> None]

Out[1]= [image]
```

#### MeshFunctions (2)

By default, the mesh lines are parallel to the $x y$, $x z$ and $y z$ planes in the reference region:

```wl
In[1]:= VectorDisplacementPlot3D[{Sin[2z], Sin[3x], Cos[y]}, {x, y, z}∈Ball[], Mesh -> 6]

Out[1]= [image]
```

---

Use circular mesh lines in the reference region:

```wl
In[1]:= VectorDisplacementPlot3D[{Sin[2z], Sin[3x], Cos[y]}, {x, y, z}∈Ball[], Mesh -> 5, MeshFunctions -> {#1^2 + #2^2&, #1^2 + #3^2&, #2^2 + #3^2&}]

Out[1]= [image]
```

#### MeshStyle (2)

Style the mesh lines:

```wl
In[1]:= VectorDisplacementPlot3D[{Sin[2z], Sin[3x], Cos[y]}, {x, y, z}∈Ball[], Mesh -> 6, MeshStyle -> Red]

Out[1]= [image]
```

---

Style the mesh lines differently in different directions:

```wl
In[1]:= VectorDisplacementPlot3D[{Sin[2z], Sin[3x], Cos[y]}, {x, y, z}∈Ball[], Mesh -> 6, MeshStyle -> {Red, Green, Blue}]

Out[1]= [image]
```

#### PlotLegends (3)

Include a legend to show the color range of vector norms:

```wl
In[1]:= VectorDisplacementPlot3D[{x^2 - y^2, x y, z - x}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotLegends -> Automatic]

Out[1]= [image]
```

---

Include a legend to show the color range of an optional scalar field:

```wl
In[1]:= VectorDisplacementPlot3D[{{x^2 - y^2, x y, z - x}, x y z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotLegends -> Automatic]

Out[1]= [image]
```

---

Control the placement of the legend:

```wl
In[1]:= VectorDisplacementPlot3D[{{x^2 - y^2, x y, z - x}, x y z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotLegends -> Placed[Automatic, Below]]

Out[1]= [image]
```

#### PlotPoints (1)

Use more points to get smoother regions:

```wl
In[1]:= VectorDisplacementPlot3D[{x, y, z}, {x, y, z}∈RegionUnion[Ball[], Cylinder[{{0, 0, -2}, {0, 0, -1}}, 1]], PlotPoints -> 50]

Out[1]= [image]
```

#### PlotRange (3)

The full ``PlotRange`` is used by default:

```wl
In[1]:= VectorDisplacementPlot3D[{x^2 - y^2, x y, z - x}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}]

Out[1]= [image]
```

---

Specify an explicit limit that is shared by the $x$, $y$ and $z$ directions:

```wl
In[1]:= VectorDisplacementPlot3D[{x^2 - y^2, x y, z - x}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotRange -> 3]

Out[1]= [image]
```

---

Specify different plot ranges in the $x$, $y$ and $z$ directions:

```wl
In[1]:= VectorDisplacementPlot3D[{x^2 - y^2, x y, z - x}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, PlotRange -> {{-3, 3}, {-4, 4}, {-4, 4}}]

Out[1]= [image]
```

#### PlotStyle (3)

Remove the filling for the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{-y, z, x}, {x, -1, 6}, {y, -2, 3}, {z, -1, 1}, PlotStyle -> None]

Out[1]= [image]
```

---

Apply a ``Texture`` to the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{-y, z, x}, {x, -1, 6}, {y, -2, 3}, {z, -1, 1}, PlotStyle -> Texture[[image]]]

Out[1]= [image]
```

---

``ColorFunction`` has precedence over ``PlotStyle`` :

```wl
In[1]:= VectorDisplacementPlot3D[{-y, z, x}, {x, -1, 6}, {y, -2, 3}, {z, -1, 1}, ColorFunction -> None, PlotStyle -> Red]

Out[1]= [image]
```

#### RegionBoundaryStyle (2)

Specify the boundary style of the reference region:

```wl
In[1]:= VectorDisplacementPlot3D[{x y, z, x}, {x, y, z}∈Cylinder[], RegionBoundaryStyle -> Directive[Red, Thick]]

Out[1]= [image]
```

---

Remove the boundary of the reference region:

```wl
In[1]:= VectorDisplacementPlot3D[{x y, z, x}, {x, y, z}∈Cylinder[], RegionBoundaryStyle -> None]

Out[1]= [image]
```

#### RegionFillingStyle (2)

Specify the filling of the reference region:

```wl
In[1]:= VectorDisplacementPlot3D[{x y, z, x}, {x, y, z}∈Cylinder[], RegionFillingStyle -> Red]

Out[1]= [image]
```

---

Remove the filling for the reference region:

```wl
In[1]:= VectorDisplacementPlot3D[{x y, z, x}, {x, y, z}∈Cylinder[], RegionFillingStyle -> None]

Out[1]= [image]
```

#### RegionFunction (1)

Use a ``RegionFunction`` to specify the reference region:

```wl
In[1]:= VectorDisplacementPlot3D[{x^2 - y, y^2 - z, z^2 - x}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, RegionFunction -> Function[{x, y, z, vx, vy, vz, n}, 1 ≤ x^2 + 2y^2 ≤ 4]]

Out[1]= [image]
```

#### VectorAspectRatio (2)

The default aspect ratio for a vector marker is 1/4:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary"]

Out[1]= [image]
```

---

Specify the relative width of a vector marker:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", VectorAspectRatio -> 1 / 8]

Out[1]= [image]
```

#### VectorColorFunction (3)

By default, if ``VectorColorFunction`` is ``Automatic``, then the ``VectorColorFunction`` matches the ``ColorFunction`` :

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", ColorFunction -> GrayLevel]

Out[1]= [image]
```

---

Specify a ``VectorColorFunction`` that is different from the ``ColorFunction`` :

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", ColorFunction -> GrayLevel, VectorColorFunction -> "Rainbow"]

Out[1]= [image]
```

---

Use no ``VectorColorFunction`` :

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", VectorColorFunction -> None]

Out[1]= [image]
```

#### VectorColorFunctionScaling (1)

Use the natural range of norm values for vector colors:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", ColorFunction -> GrayLevel, VectorColorFunction -> "Rainbow", VectorColorFunctionScaling -> False]

Out[1]= [image]
```

#### VectorMarkers (3)

By default, vectors are drawn from points in the reference region to corresponding points in the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> Automatic]

Out[1]= [image]
```

---

Use a named appearance to draw the vectors:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", VectorMarkers -> "Tube"]

Out[1]= [image]
```

---

Center the markers at the sampled points:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", VectorMarkers -> Placed["Arrow", "Center"]]

Out[1]= [image]
```

#### VectorPoints (9)

No vectors are shown by default:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}]

Out[1]= [image]
```

---

Show vectors sampled from the entire original region:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> Automatic]

Out[1]= [image]
```

---

Sample vectors from the boundary of the region:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary"]

Out[1]= [image]
```

---

Use symbolic names to specify the density of vectors:

```wl
In[1]:=
{VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Fine"], 
	VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Coarse"]}

Out[1]= {[image], [image]}
```

---

Use symbolic names to specify the arrangement of vectors:

```wl
In[1]:=
{VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Hexagonal"], 
	VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "FaceCenteredCubic"], 
	VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Regular"]}

Out[1]= {[image], [image], [image]}
```

---

Specify the number of vectors in the $x$, $y$ and $z$ directions:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> 6]

Out[1]= [image]
```

---

Specify a different number of vectors in the $x$, $y$ and $z$ directions:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> {6, 8, 3}]

Out[1]= [image]
```

---

Give specific locations for vectors:

```wl
In[1]:= points = {{3, 3, 3}, {-3, 3, 3}, {-3, -3, 3}, {3, -3, 3}, {3, 3, -3}, {-3, 3, -3}, {-3, -3, -3}, {3, -3, -3}};

In[2]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> points]

Out[2]= [image]
```

---

Along a curve, vectors are equally spaced by default:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, y, z}∈HilbertCurve[2, 3], VectorPoints -> Automatic]

Out[1]= [image]
```

#### VectorRange (2)

Specify the range of vector norms:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", VectorRange -> {1, 3.5}]

Out[1]= [image]
```

---

Style the clipped vectors:

```wl
In[1]:= VectorDisplacementPlot3D[{y, -x, z / 2}, {x, -3, 3}, {y, -3, 3}, {z, -3, 3}, VectorPoints -> "Boundary", VectorRange -> {1, 3.5}, ClippingStyle -> Black]

Out[1]= [image]
```

#### VectorScaling (2)

By default, vectors extend from points in the reference region to corresponding points in the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[{Sin[y], Cos[3z], Sin[2x]}, {x, y, z}∈Cuboid[], VectorPoints -> "Boundary"]

Out[1]= [image]
```

---

Set all vectors to have the same size:

```wl
In[1]:= VectorDisplacementPlot3D[{Sin[y], Cos[3z], Sin[2x]}, {x, y, z}∈Cuboid[], VectorPoints -> "Boundary", VectorScaling -> None]

Out[1]= [image]
```

#### VectorSizes (4)

By default, vectors extend from points in the reference region to corresponding points in the deformed region:

```wl
In[1]:= VectorDisplacementPlot3D[(RotationMatrix[π / 4, {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, VectorPoints -> "Boundary"]

Out[1]= [image]
```

---

Suppress scaling of the displacement vectors so that a rotation of 45° looks appropriate:

```wl
In[1]:= VectorDisplacementPlot3D[(RotationMatrix[π / 4, {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, VectorPoints -> "Boundary", VectorSizes -> Full]

Out[1]= [image]
```

---

Specify the displacement size relative to the default scaled displacement:

```wl
In[1]:= VectorDisplacementPlot3D[(RotationMatrix[π / 4, {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, VectorPoints -> "Boundary", VectorSizes -> 2]

Out[1]= [image]
```

---

Suppress scaling of the displacement vectors even if no vectors are displayed:

```wl
In[1]:= VectorDisplacementPlot3D[(RotationMatrix[π / 4, {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, VectorSizes -> Full]

Out[1]= [image]
```

#### VectorStyle (1)

``VectorColorFunction`` has precedence over ``VectorStyle`` :

```wl
In[1]:= VectorDisplacementPlot3D[{x^2 + y^2, x^2 - z^2, y + x}, {x, y, z}∈Cone[], VectorPoints -> "Boundary", VectorColorFunction -> None, VectorStyle -> Red]

Out[1]= [image]
```

### Applications (19)

#### Basic Applications (16)

A constant displacement field moves each point in the reference region by the same amount:

```wl
In[1]:= VectorDisplacementPlot3D[{3, 2, 1}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}]

Out[1]= [image]
```

---

Note that the displacements are automatically scaled so that very small and very large displacements are both visible:

```wl
In[1]:= {VectorDisplacementPlot3D[{0.3, 0.2, 0.1}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}], VectorDisplacementPlot3D[{300, 200, 100}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}]}

Out[1]= [image]
```

---

Use ``VectorSizes -> Full`` to display the actual sizes of displacements:

```wl
In[1]:= VectorDisplacementPlot3D[{3, 2, 1}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, VectorSizes -> Full]

Out[1]= [image]
```

---

Color is used to indicate the magnitude of the displacements:

```wl
In[1]:= VectorDisplacementPlot3D[{3 - y, 2 + x, 1}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, PlotLegends -> Automatic]

Out[1]= [image]
```

---

Color the region by a different scalar function:

```wl
In[1]:= VectorDisplacementPlot3D[{{3 - y, 2 + x, 1}, x y z}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, PlotLegends -> Automatic]

Out[1]= [image]
```

---

Use arrows to indicate initial and final locations for sample points:

```wl
In[1]:= VectorDisplacementPlot3D[{3 - y, 2 + x, 1}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, VectorPoints -> "Boundary"]

Out[1]= [image]
```

---

Visualize a dilation in the $x$ direction:

```wl
In[1]:=
VectorDisplacementPlot3D[(⁠|   |   |   |
| - | - | - |
| 2 | 0 | 0 |
| 0 | 0 | 0 |
| 0 | 0 | 0 |⁠).{x, y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorSizes -> Full]

Out[1]= [image]
```

---

Visualize a contraction in the $x$ direction:

```wl
In[1]:=
VectorDisplacementPlot3D[(⁠|        |   |   |
| ------ | - | - |
| -1 / 2 | 0 | 0 |
| 0      | 0 | 0 |
| 0      | 0 | 0 |⁠).{x, y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorSizes -> Full]

Out[1]= [image]
```

---

Visualize dilations in the $x$ and $y$ directions and a contraction in the $z$ direction:

```wl
In[1]:=
VectorDisplacementPlot3D[(⁠|   |   |        |
| - | - | ------ |
| 1 | 0 | 0      |
| 0 | 2 | 0      |
| 0 | 0 | -1 / 2 |⁠).{x, y, z}, {x, y, z}∈Cylinder[], VectorSizes -> Full]

Out[1]= [image]
```

---

Visualize extension and contraction of a spring in the $z$ direction:

```wl
In[1]:= VectorDisplacementPlot3D[{0, 0, z / 2}, {x, y, z}∈Line[Table[{Cos[10t], Sin[10t], t}, {t, -2, 2, 0.02}]], PlotStyle -> Thick, RegionFillingStyle -> Gray, VectorSizes -> Full]

Out[1]= [image]

In[2]:= VectorDisplacementPlot3D[{0, 0, -z / 2}, {x, y, z}∈Line[Table[{Cos[10t], Sin[10t], t}, {t, -2, 2, 0.02}]], PlotStyle -> Thick, RegionFillingStyle -> Gray, VectorSizes -> Full]

Out[2]= [image]
```

---

Visualize a shear in the $x$ direction applied to the faces $y=\pm 1$ :

```wl
In[1]:=
VectorDisplacementPlot3D[(⁠|   |   |   |
| - | - | - |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
| 0 | 0 | 0 |⁠).{x, y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorSizes -> Full]

Out[1]= [image]
```

---

Visualize a shear in the $x$ direction applied to the faces $z=\pm 1$ :

```wl
In[1]:=
VectorDisplacementPlot3D[(⁠|   |   |   |
| - | - | - |
| 0 | 0 | 1 |
| 0 | 0 | 0 |
| 0 | 0 | 0 |⁠).{x, y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorSizes -> Full]

Out[1]= [image]
```

---

Visualize a combined shear:

```wl
In[1]:=
VectorDisplacementPlot3D[(⁠|   |   |   |
| - | - | - |
| 0 | 1 | 2 |
| 0 | 0 | 3 |
| 0 | 0 | 0 |⁠).{x, y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorSizes -> Full]

Out[1]= [image]
```

---

Visualize a rotation about the $z$ axis:

```wl
In[1]:= VectorDisplacementPlot3D[(RotationMatrix[(π/6), {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}, VectorSizes -> Full]

Out[1]= [image]
```

---

Visualize a combined dilation and rotation:

```wl
In[1]:= shuttle = ExampleData[{"Geometry3D", "SpaceShuttle"}, "BoundaryMeshRegion"];

In[2]:=
VectorDisplacementPlot3D[((⁠|   |   |   |
| - | - | - |
| 2 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 1 |⁠).RotationMatrix[(π/6), {0, 0, 1}] - IdentityMatrix[3]).{x, y, z}, {x, y, z}∈shuttle, VectorSizes -> Full]

Out[2]= [image]
```

---

Visualize a deformation that is localized near the origin:

```wl
In[1]:= VectorDisplacementPlot3D[Exp[-5(x^2 + y^2 + z^2)](RotationMatrix[(π/6), {1, 1, 1}] - IdentityMatrix[3]).{x, y, z}, {x, 0, 1}, {y, 0, 1}, {z, 0, 1}, VectorSizes -> Full, VectorPoints -> "Boundary"]

Out[1]= [image]
```

#### Solid Mechanics (3)

Consider a homogeneous, isotropic, linearly elastic material. Specify Young's modulus and Poisson's ratio:

```wl
In[1]:= {young, ν} = {30 10^6, 0.25};
```

Applying a uniform tensile load of magnitude $P$ in the $z$ direction:

```wl
In[2]:= Graphics3D[{Cuboid[{-1, -1, -1}, {1, 1, 1}], Table[Arrow[Tube[{{x, y, sign}, {x, y, sign 1.4}}]], {x, -1, 1, 0.25}, {y, -1, 1, 0.25}, {sign, {-1, 1}}]}]

Out[2]= [image]
```

If $P>0$, then the resulting deformation involves extension in the $z$ direction and contraction in the $x$ and $y$ directions:

```wl
In[3]:= P = 1;VectorDisplacementPlot3D[(P/young){-ν x, -ν y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[3]= [image]
```

If $P<0$, then the load is compressive and the resulting deformation involves compression in the $z$ direction and expansion in the $x$ and $y$ directions:

```wl
In[4]:= P = -1;VectorDisplacementPlot3D[(P/young){-ν x, -ν y, z}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[4]= [image]
```

Replace the region with a cylinder:

```wl
In[5]:= VectorDisplacementPlot3D[(P/young){-ν x, -ν y, z}, {x, y, z}∈Cylinder[{{0, 0, -1}, {0, 0, 1}}, 1]]

Out[5]= [image]
```

---

Consider an elliptic cylinder centered on the $z$ axis:

```wl
In[1]:=
{a, b} = {2, 1};
Ω = ImplicitRegion[(x^2/a^2) + (y^2/b^2) ≤ 1 && -3 ≤ z ≤ 3, {x, y, z}];
```

Apply constant torque $T$ to the ends of the bar:

```wl
In[2]:= Show[Region[Ω], Graphics3D[{Black, Arrow[Tube[Table[{Cos[t], Sin[t], 3.5}, {t, 0, 6, 0.1}]]], Arrow[Tube[Table[{Cos[t], -Sin[t], -3.5}, {t, 0, 6, 0.1}]]], Text["T", {1.3, 0, 3.5}], Text["T", {1.3, 0, -3.5}]}]]

Out[2]= [image]
```

Specify the magnitude of the applied torque:

```wl
In[3]:= T = 1;
```

If the material is linearly elastic with shear modulus $\mu$, then the resulting displacement field is:

```wl
In[4]:=
μ = 80; (* GPa for steel*)
displacement = (T/a^3 b^3 π μ){-(a^2 + b^2)  y z, (a^2 + b^2)  x z, (b^2 - a^2)  x y};
```

Use a mesh to illustrate the twisting of the bar:

```wl
In[5]:= VectorDisplacementPlot3D[displacement, {x, y, z}∈Ω, Mesh -> 3, RegionFillingStyle -> None, RegionBoundaryStyle -> None]

Out[5]= [image]
```

Compute the nontrivial shear stresses:

```wl
In[6]:= {σxz, σyz} = (2T/π a b){-(y/b^2), (x/a^2)};
```

Use the shear stresses to color the region:

```wl
In[7]:=
{VectorDisplacementPlot3D[{displacement, σxz}, {x, y, z}∈Ω, Mesh -> 3, RegionFillingStyle -> None, RegionBoundaryStyle -> None], 
	VectorDisplacementPlot3D[{displacement, σyz}, {x, y, z}∈Ω, Mesh -> 3, RegionFillingStyle -> None, RegionBoundaryStyle -> None]}

Out[7]= {[image], [image]}
```

---

Compute the deflection of a spoon held fixed at the end and with a force applied at the top.

Set up variables and parameters:

```wl
In[1]:=
vars = {{u[x, y, z], v[x, y, z], w[x, y, z]}, {x, y, z}};
pars = <|"Material" -> \[FreeformPrompt]["Silver"]|>;
```

Set up the PDE and the geometry:

```wl
In[2]:=
spoon = [image];
{d1, d2, d3} = NDSolveValue[{SolidMechanicsPDEComponent[vars, pars] == SolidBoundaryLoadValue[x >= 1 / 10, vars, pars, <|"Force" -> {0, 0, Quantity[-100, "Newtons"]}|>], 
	SolidFixedCondition[x <= -1 / 10, vars, pars]}, {u, v, w}, {x, y, z}∈spoon];
```

Visualize the displacement:

```wl
In[3]:= VectorDisplacementPlot3D[{d1[x, y, z], d2[x, y, z], d3[x, y, z]}, {x, y, z}∈spoon]

Out[3]= [image]
```

### Properties & Relations (9)

Use ``ListVectorDisplacementPlot3D`` to visualize a deformation based on displacement field data:

```wl
In[1]:= data = Table[{{x, y, z} = RandomReal[{0, 1}, {3}], {y, x, -z}}, {300}];

In[2]:= ListVectorDisplacementPlot3D[data, Cuboid[], VectorPoints -> "Boundary"]

Out[2]= [image]
```

---

Use ``VectorDisplacementPlot`` to visualize the deformation of a region associated with a displacement vector field:

```wl
In[1]:= VectorDisplacementPlot[{y, x - x^3}, {x, y}∈Disk[], VectorPoints -> Automatic]

Out[1]= [image]
```

Use ``ListVectorDisplacementPlot`` to visualize the same deformation based on data:

```wl
In[2]:= data = Table[{{x, y} = RandomReal[{-1, 1}, {2}], {y, x - x ^ 3}}, {300}];

In[3]:= ListVectorDisplacementPlot[data, Disk[], VectorPoints -> Automatic]

Out[3]= [image]
```

---

Use ``VectorPlot`` to directly plot a vector field:

```wl
In[1]:= VectorPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}]

Out[1]= [image]
```

Use ``StreamPlot`` to plot with streamlines instead of vectors :

```wl
In[2]:= StreamPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}]

Out[2]= [image]
```

Use ``ListVectorPlot`` or ``ListStreamPlot`` for plotting data:

```wl
In[3]:= data = Table[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3, 0.2}, {y, -3, 3, 0.2}];

In[4]:= {ListVectorPlot[data], ListStreamPlot[data]}

Out[4]= {[image], [image]}
```

---

Use ``VectorDensityPlot`` to add a density plot of the scalar field:

```wl
In[1]:= VectorDensityPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}]

Out[1]= [image]
```

Use ``StreamDensityPlot`` to plot streamlines instead of vectors:

```wl
In[2]:= StreamDensityPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}]

Out[2]= [image]
```

Use ``ListVectorDensityPlot`` or ``ListStreamDensityPlot`` for plotting data:

```wl
In[3]:= data = Table[{{x, y} = RandomReal[{-1.5, 1.5}, {2}], {{y, x - x ^ 3}, Abs[x + y]}}, {300}];

In[4]:= {ListVectorDensityPlot[data], ListStreamDensityPlot[data]}

Out[4]= [image]
```

---

Use ``LineIntegralConvolutionPlot`` to plot the line integral convolution of a vector field:

```wl
In[1]:= LineIntegralConvolutionPlot[{-1 - x ^ 2 + y, 1 + x - y ^ 2}, {x, -3, 3}, {y, -3, 3}]

Out[1]= [image]
```

---

Use ``VectorPlot3D`` and ``StreamPlot3D`` to visualize 3D vector fields:

```wl
In[1]:= {VectorPlot3D[{z, x, x + y}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}], StreamPlot3D[{z, x, x + y}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]}

Out[1]= {[image], [image]}
```

Use ``ListVectorPlot3D`` or ``ListStreamPlot3D`` to plot with data:

```wl
In[2]:= data = Table[{z, x, x + y}, {x, -1, 1}, {y, -1, 1}, {z, -1, 1}];

In[3]:= {ListVectorPlot3D[data], ListStreamPlot3D[data]}

Out[3]= {[image], [image]}
```

---

Plot vectors on surfaces with ``SliceVectorPlot3D`` :

```wl
In[1]:= SliceVectorPlot3D[{-y, x, z}, "CenterPlanes", {x, -1, 1}, {y, -1, 1}, {z, -1, 1}]

Out[1]= [image]
```

Use ``ListSliceVectorPlot3D`` to plot with data:

```wl
In[2]:= data = Table[{-y, x, z}, {x, -1, 1, 0.1}, {y, -1, 1, 0.1}, {z, -1, 1, 0.1}];

In[3]:= ListSliceVectorPlot3D[data, "CenterPlanes"]

Out[3]= [image]
```

---

Use ``ComplexVectorPlot`` or ``ComplexStreamPlot`` to visualize a complex function of a complex variable as a vector field or with streamlines:

```wl
In[1]:= {ComplexVectorPlot[Sin[3z], {z, 2}], ComplexStreamPlot[Sin[3z], {z, 2}]}

Out[1]= [image]
```

---

Use ``GeoVectorPlot`` to plot vectors on a map:

```wl
In[1]:=
GeoVectorPlot[GeoVector[GeoPosition[CompressedData["«6488»"]] -> 
  {{0.5706379232485146, Quantity[354.01686143622794, "AngularDegrees"]}, 
   {0.48751317221734114, Quantity[327.18610724051325, "AngularDegrees"]}, 
   {0.42407845478418604, Quantity[199.859344783 ... 904, "AngularDegrees"]}, 
   {0.9366099079317551, Quantity[357.70482317743733, "AngularDegrees"]}, 
   {0.8256817194791912, Quantity[242.07227508889662, "AngularDegrees"]}, 
   {0.2661401145642981, Quantity[152.90003252279325, "AngularDegrees"]}}]]

Out[1]= [image]
```

Use ``GeoStreamPlot`` to plot streamlines instead of vectors:

```wl
In[2]:=
GeoStreamPlot[GeoVector[GeoPosition[CompressedData["«6488»"]] -> 
  {{0.5706379232485146, Quantity[354.01686143622794, "AngularDegrees"]}, 
   {0.48751317221734114, Quantity[327.18610724051325, "AngularDegrees"]}, 
   {0.42407845478418604, Quantity[199.859344783 ... 904, "AngularDegrees"]}, 
   {0.9366099079317551, Quantity[357.70482317743733, "AngularDegrees"]}, 
   {0.8256817194791912, Quantity[242.07227508889662, "AngularDegrees"]}, 
   {0.2661401145642981, Quantity[152.90003252279325, "AngularDegrees"]}}]]

Out[2]= [image]
```

## See Also

* [`VectorDisplacementPlot`](https://reference.wolfram.com/language/ref/VectorDisplacementPlot.en.md)
* [`VectorPlot3D`](https://reference.wolfram.com/language/ref/VectorPlot3D.en.md)
* [`StreamPlot3D`](https://reference.wolfram.com/language/ref/StreamPlot3D.en.md)
* [`VectorPlot`](https://reference.wolfram.com/language/ref/VectorPlot.en.md)
* [`VectorDensityPlot`](https://reference.wolfram.com/language/ref/VectorDensityPlot.en.md)
* [`StreamPlot`](https://reference.wolfram.com/language/ref/StreamPlot.en.md)
* [`StreamDensityPlot`](https://reference.wolfram.com/language/ref/StreamDensityPlot.en.md)

## Related Guides

* [Vector Visualization](https://reference.wolfram.com/language/guide/VectorVisualization.en.md)

## History

* [Introduced in 2021 (13.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn130.en.md)