DOLFINx 0.12.0.0
DOLFINx C++
Loading...
Searching...
No Matches
Functions
dolfinx::io::cells Namespace Reference

Functions for the re-ordering of input mesh topology to the DOLFINx ordering, and transpose orderings for file output. More...

Functions

int cell_degree (mesh::CellType type, int num_nodes)
 Get the Lagrange order of a given cell with a given number of nodes.
std::vector< std::uint16_t > perm_vtk (mesh::CellType type, int num_nodes)
 Permutation array to map from VTK to DOLFINx node ordering.
std::vector< std::uint16_t > perm_gmsh (mesh::CellType type, int num_nodes)
 Permutation array to map from Gmsh to DOLFINx node ordering.
std::vector< std::uint16_t > transpose (std::span< const std::uint16_t > map)
 Compute the transpose of a re-ordering map.
std::vector< std::int64_t > apply_permutation (std::span< const std::int64_t > cells, std::array< std::size_t, 2 > shape, std::span< const std::uint16_t > p)
 Permute cell topology by applying a permutation array for each cell.
std::int8_t get_vtk_cell_type (mesh::CellType cell, int num_nodes)
 Get the VTK cell identifier for a cell type and node layout.
std::tuple< mesh::CellType, std::int8_t > vtk_to_dolfinx (std::int8_t vtk_cell_type)
 Get DOLFINx cell type and degree from VTK cell type.

Detailed Description

Functions for the re-ordering of input mesh topology to the DOLFINx ordering, and transpose orderings for file output.

Basix ordering is used for the geometry nodes, and is shown below for a range of cell types.

Triangle: Triangle6: Triangle10:
v
^
|
2 2 2
|`\ |`\ | \
| `\ | `\ 6 4
| `\ 4 `3 | \
| `\ | `\ 5 9 3
| `\ | `\ | \
0----------1 --> u 0-----5----1 0---7---8---1
Quadrilateral: Quadrilateral9: Quadrilateral16:
v
^
|
2-----------3 2-----7-----3 2--10--11---3
| | | | | |
| | | | 7 14 15 9
| | 5 8 6 | |
| | | | 6 12 13 8
| | | | | |
0-----------1 --> u 0-----4-----1 0---4---5---1
Tetrahedron: Tetrahedron10: Tetrahedron20
v
/
2 2 2
,/|`\ ,/\`\ ,/|`\
,/ \ `\ ,/ \ `\. 13 | `9
,/ '. `\ ,8 '. `6 ,/ 4 `\
,/ | `\ ,/ 4 `\ 12 19 | `8
,/ | `\ ,/ | `\ ,/ | `\
0-----------'.--------1 -> u 0--------9--'.--------1 0-----14----'.--15----1
`\. | ,/ `\. | ,/ `\. 17 | 16 ,/
`\. | ,/ `\. | ,5 10. 18 5 ,6
`\. '. ,/ `7. '. ,/ `\. . 7
`\. |/ `\. |/ 11. |/
`3 `3 `3
`\.
w
Hexahedron: Hexahedron27:
w
6----------7 6----19----7
/| ^ v /| /| /|
/ | | / / | 17 | 25 18|
/ | | / / | / 14 24 / 15
4----------5 | 4----16----5 |
| | +--|---|--> u |22 | 26 | 23|
| 2------+---3 | 2----13+---3
| / | / 10 / 21 12 /
| / | / | 9 20 | 11
|/ |/ |/ |/
0----------1 0-----8----1
Prism: Prism18:
w
^
|
3 3
,/|`\ ,/|`\
,/ | `\ 12 | 13
,/ | `\ ,/ | `\
4------+------5 4------14-----5
| | | | 8 |
| ,/|`\ | | 15 | 16 |
| ,/ | `\ | | | |
|,/ 0 `\| 10 0 17 11
./| ,/ `\ |\ | ,/ `\ |
/ | ,/ `\ | `\ | ,6 `7 |
u |,/ `\| v |,/ `\|
1-------------2 1------9------2
Pyramid: Pyramid14:
4 4
,/|\ ,/|\
,/ .'|\ ,/ .'|\
v ,/ | | \ ,/ | | \
\. ,/ .' | `. ,/ .' | `.
\. | '. \ 11 | 12 \
,/ \. .' w | \ ,/ .' | \
,/ \. | ^ | \ ,/ 7 | 9
2----------\'--|-3 `. 2-------10-.'----3 `.
`\ | \.| `\ \ `\ | `\ \
`\ .' +----`\ - \ -> u `6 .' 13 8 \
`\ | `\ \ `\ | `\ \
`\.' ` `\ `\.' ` `\
0-----------------1 0--------5--------1

Function Documentation

◆ apply_permutation()

std::vector< std::int64_t > apply_permutation ( std::span< const std::int64_t > cells,
std::array< std::size_t, 2 > shape,
std::span< const std::uint16_t > p )

Permute cell topology by applying a permutation array for each cell.

Parameters
[in]cellsArray of cell topologies, with each row representing a cell (row-major storage).
[in]shapeShape of the cells array.
[in]pPermutation array that maps a_p[i] = a[p[i]], where a_p is the permuted array.
Returns
Permuted cell topology, where for a cell v_new[i] = v_old[map[i]]. The storage is row-major and the shape is the same as cells.

◆ cell_degree()

int cell_degree ( mesh::CellType type,
int num_nodes )

Get the Lagrange order of a given cell with a given number of nodes.

Only Lagrange layouts have a degree here, so the node count and the degree determine each other. A serendipity layout is rejected, even where it has a degree of its own: reporting 2 for the 15-node wedge and the 13-node pyramid would make them indistinguishable from the 18-node wedge and the 14-node pyramid, and Basix has no element of either layout to build. The serendipity layouts Basix does have, the 8-node quadrilateral and the 20-node hexahedron, are mapped directly by ::perm_vtk without consulting a degree.

Parameters
[in]typeCell shape.
[in]num_nodesNumber of cell 'nodes'
Returns
Lagrange order of the cell type.
Exceptions
std::invalid_argumentIf no Lagrange layout of type has num_nodes nodes.

◆ get_vtk_cell_type()

std::int8_t get_vtk_cell_type ( mesh::CellType cell,
int num_nodes )

Get the VTK cell identifier for a cell type and node layout.

Inverse of ::vtk_to_dolfinx for the layouts that VTK can express.

Parameters
[in]cellCell type to label. To label an entity of a cell, pass the entity's own cell type, e.g. from mesh::cell_entity_type.
[in]num_nodesNumber of nodes in the cell. It must be a layout that VTK's type for cell can express and that round-trips through ::vtk_to_dolfinx. Quadrilaterals and hexahedra accept Lagrange layouts and the 8- and 20-node quadratic serendipity layouts, respectively. Only the linear pyramid is accepted, since VTK has no arbitrary-degree Lagrange pyramid.
Note
Prism and pyramid facets are not all of one type, so no single identifier labels a facet set; mesh::entities_to_geometry rejects that case.
Returns
VTK cell identifier.
Exceptions
std::invalid_argumentIf VTK has no type for the layout.

◆ perm_gmsh()

std::vector< std::uint16_t > perm_gmsh ( mesh::CellType type,
int num_nodes )

Permutation array to map from Gmsh to DOLFINx node ordering.

Parameters
[in]typeCell shape.
[in]num_nodesNumber of cell 'nodes'
Returns
Permutation array p for permuting from Gmsh ordering to DOLFINx ordering, i.e. a_dolfin[i] = a_gmsh[p[i]].

If p = [0, 2, 1, 3] and a = [10, 3, 4, 7], then a_p =[a[p[0]], a[p[1]], a[p[2]], a[p[3]]] = [10, 4, 3, 7].

◆ perm_vtk()

std::vector< std::uint16_t > perm_vtk ( mesh::CellType type,
int num_nodes )

Permutation array to map from VTK to DOLFINx node ordering.

Parameters
[in]typeCell shape.
[in]num_nodesNumber of cell 'nodes'
Returns
Permutation array p for permuting from VTK ordering to DOLFINx ordering, i.e. a_dolfin[i] = a_vtk[p[i]].

If p = [0, 2, 1, 3] and a = [10, 3, 4, 7], then a_p = [a[p[0]], a[p[1]], a[p[2]], a[p[3]]] = [10, 4, 3, 7].

◆ transpose()

std::vector< std::uint16_t > transpose ( std::span< const std::uint16_t > map)

Compute the transpose of a re-ordering map.

Parameters
[in]mapA re-ordering map.
Returns
Transpose of the map. E.g., is map = {1, 2, 3, 0}, the transpose will be {3 , 0, 1, 2 }.

◆ vtk_to_dolfinx()

std::tuple< mesh::CellType, std::int8_t > vtk_to_dolfinx ( std::int8_t vtk_cell_type)
inline

Get DOLFINx cell type and degree from VTK cell type.

Parameters
[in]vtk_cell_typeVTK cell type identifier.
Returns
Return the cell type and degree. If arbitrary order Lagragian cell from VTK is supplied, return -1 for the degree.
Generated by doxygen 1.18.0