Note

Go to the end to download the full example code.

# Unstructured Grid with Polyhedra#

This example shows how to build a simple `pyvista.UnstructuredGrid`

using polyhedra. We will be using VTK types to determine which type of cells we
are building. A list of cell types is given in `pyvista.CellType`

.

First, we import the required libraries.

```
import pyvista as pv
```

## Define Points#

We will mix several cells in one grid for this example. Here we create the points that will define each cell.

Note

It is not necessary that each cell has an isolated set of points. This has been done here to create isolated cells for this example.

```
quad_points = [
[0.0, 0.0, 0.0], # 0
[0.0, 0.01, 0.0], # 1
[0.01, 0.01, 0.0], # 2
[0.01, 0.0, 0.0], # 3
]
polygon_points = [
[0.02, 0.0, 0.0], # 4
[0.02, 0.01, 0.0], # 5
[0.03, 0.01, 0.0], # 6
[0.035, 0.005, 0.0], # 7
[0.03, 0.0, 0.0], # 8
]
hexa_points = [
[0.0, 0.0, 0.02], # 9
[0.0, 0.01, 0.02], # 10
[0.01, 0.01, 0.02], # 11
[0.01, 0.0, 0.02], # 12
[0.0, 0.0, 0.03], # 13
[0.0, 0.01, 0.03], # 14
[0.01, 0.01, 0.03], # 15
[0.01, 0.0, 0.03], # 16
]
polyhedron_points = [
[0.02, 0.0, 0.02], # 17
[0.02, 0.01, 0.02], # 18
[0.03, 0.01, 0.02], # 19
[0.035, 0.005, 0.02], # 20
[0.03, 0.0, 0.02], # 21
[0.02, 0.0, 0.03], # 22
[0.02, 0.01, 0.03], # 23
[0.03, 0.01, 0.03], # 24
[0.035, 0.005, 0.03], # 25
[0.03, 0.0, 0.03], # 26
]
points = quad_points + polygon_points + hexa_points + polyhedron_points
```

## Cell connectivity#

Connectivity describes the indices of the points to compose each cell. The
first item in each cell’s connectivity is the number of items the cell will
have. For example, a quad cell is composed of points `[0, 1, 2, 3]`

and
totaling 4 points, therefore `[4, 0, 1, 2, 3]`

describes its connectivity.

Note

This example uses lists for simplicity, but internally PyVista converts
these lists to a `numpy.ndarray`

with `dtype=pyvista.ID_TYPE`

and
passes it to VTK.

The same approach can be applied to all the other cell types.

## Polyhedron connectivity array#

The connectivity array of polyhedra is defined differently from the rest of the cell types. For polyhedra, we need to set the faces with the following format:

`[NItems, NFaces, Face0NPoints, Face0Point0, Face0Point1..., Face0PointN-1, Face1NPoints, ...]`

Where:

`NItems`

refers to the total number of items in the list needed to describe the polyhedron.`NFaces`

is the number of faces the polyhedron will have.`Face0NPoints`

is the number of points the first face will have.`Face0Point0...Face0PointN-1`

are each of the points that describe`face0`

.

In `polyhedron_connectivity`

, the first item is `NFaces`

. `NItems`

is
added to `polyhedron`

.

```
polyhedron_connectivity = [
# NItems will go here
7, # number of faces
5, # number of points in face0
17, # point index 0
18, # point index 1
19, # point index 2
20, # point index 3
21, # point index 4
4, # number of points in face1
17, # point index ...
18,
23,
22,
4,
17,
21,
26,
22,
4,
21,
26,
25,
20,
4,
20,
25,
24,
19,
4,
19,
24,
23,
18,
5,
22,
23,
24,
25,
26,
]
# note how we retroactively add NItems
polyhedron = [len(polyhedron_connectivity), *polyhedron_connectivity]
```

## Cells array#

Now we build the input cells array for the
`pyvista.UnstructuredGrid`

. Here, we join all cells in a flat
list. Internally, the `NItems`

previously described is used to determine
which nodes belong to which cells.

```
cells = quad + polygon + hexa + polyhedron
```

## Cell types#

We need to specify the cell types for each of the cells we define in the cells array.

The number of items in this list must match the number of cells in the connectivity array.

```
celltypes = [pv.CellType.QUAD, pv.CellType.POLYGON, pv.CellType.HEXAHEDRON, pv.CellType.POLYHEDRON]
```

## Create the grid#

To create the grid, we use the cells array we built, the cell types, and the points that describe the faces.

## Plot the mesh#

Finally, we can plot the grid we’ve created. Label each cell at its cell center for clarity.

```
pl = pv.Plotter()
pl.show_axes()
pl.add_mesh(grid, show_edges=True, line_width=5)
pl.add_point_labels(
grid.cell_centers().points,
['QUAD', 'POLYGON', 'HEXAHEDRON', 'POLYHEDRON'],
always_visible=True,
font_size=20,
)
pl.show()
```

**Total running time of the script:** (0 minutes 0.204 seconds)