Mesh#

This module contains meshing-related classes and functions. Standalone mesh-tools (functions) are also available as mesh-methods.

Core

`Mesh`(points, cells[, cell_type])	A mesh with points, cells and optional a specified cell type.
`MeshContainer`(meshes[, merge, decimals])	A container which operates on a list of meshes with identical dimensions.

Geometries

`mesh.Line`([a, b, n])	A line shaped 1d-mesh with lines between `a` and `b` with `n` points.
`Rectangle`([a, b, n])	A rectangular 2d-mesh with quads between `a` and `b` with `n` points per axis.
`Cube`([a, b, n])	A cube shaped 3d-mesh with hexahedrons between `a` and `b` with `n` points per axis.
`Grid`(*xi[, indexing])	A grid shaped 3d-mesh with hexahedrons.
`Circle`([radius, centerpoint, n, sections, ...])	A circular shaped 2d-mesh with quads and `n` points on the circumferential edge of a 45-degree section.
`mesh.Triangle`([a, b, c, n, decimals])	A triangular shaped 2d-mesh with quads and `n` points at the edges of the three sub-quadrilaterals.
`mesh.RectangleArbitraryOrderQuad`([a, b, order])	A rectangular 2d-mesh with arbitrary order quads between `a` and `b` with `n` points per axis.

Tools

`mesh.expand`(points, cells, cell_type[, n, z])	Expand a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh.
`mesh.rotate`(points, cells, cell_type, ...[, ...])	Rotate a Mesh.
`mesh.revolve`(points, cells, cell_type[, n, ...])	Revolve a 2d-Quad to a 3d-Hexahedron Mesh.
`mesh.sweep`(points, cells, cell_type[, decimals])	Merge duplicated points and update cells of a Mesh.
`mesh.mirror`(points, cells, cell_type[, ...])	Mirror points by plane normal and ensure positive cell volumes for tria, tetra, quad and hexahedron cell types.
`mesh.concatenate`(meshes)	Join a sequence of meshes with identical cell types.
`mesh.runouts`(points, cells, cell_type[, ...])	Add simple rubber-runouts for realistic rubber-metal structures.
`mesh.triangulate`(points, cells, cell_type[, ...])	Triangulate a quad or a hex mesh.
`mesh.convert`(points, cells, cell_type[, ...])	Convert mesh to a given order (only order=0 and order=2 from order=1 are supported).
`mesh.collect_edges`(points, cells, cell_type)	"Collect all unique edges, calculate and return midpoints on edges as well as the additional cells array.
`mesh.collect_faces`(points, cells, cell_type)	"Collect all unique faces, calculate and return midpoints on faces as well as the additional cells array.
`mesh.collect_volumes`(points, cells, cell_type)	"Collect all volumes, calculate and return midpoints on volumes as well as the additional cells array.
`mesh.add_midpoints_edges`(points, cells, ...)	"Add midpoints on edges for given points and cells and update cell_type accordingly.
`mesh.add_midpoints_faces`(points, cells, ...)	"Add midpoints on faces for given points and cells and update cell_type accordingly.
`mesh.add_midpoints_volumes`(points, cells, ...)	"Add midpoints on volumes for given points and cells and update cell_type accordingly.
`mesh.flip`(points, cells, cell_type[, mask])	Ensure positive cell volumes for tria, tetra, quad and hexahedron cell types.
`mesh.fill_between`(mesh, other_mesh[, n])	Fill a 2d-Quad Mesh between two 1d-Line Meshes, embedded in 2d-space, or a 3d-Hexahedron Mesh between two 2d-Quad Meshes, embedded in 3d-space, by expansion.
`mesh.dual`(points, cells, cell_type[, ...])	Create a new dual mesh with given points per cell.

Detailed API Reference

class felupe.Mesh(points, cells, cell_type=None)[source]#

A mesh with points, cells and optional a specified cell type.

Parameters:

points (ndarray) – Point coordinates.
cells (ndarray) – Point-connectivity of cells.
cell_type (str or None, optional) – An optional string in VTK-convention that specifies the cell type (default is None). Necessary when a mesh is saved to a file.

points#

Point coordinates.

Type:: ndarray

cells#

Point-connectivity of cells.

Type:: ndarray

cell_type#

A string in VTK-convention that specifies the cell type.

Type:: str or None

add_midpoints_edges(cells, cell_type, cell_type_new=None)#: “Add midpoints on edges for given points and cells and update cell_type accordingly.

add_midpoints_faces(cells, cell_type, cell_type_new=None)#: “Add midpoints on faces for given points and cells and update cell_type accordingly.

add_midpoints_volumes(cells, cell_type, cell_type_new=None)#: “Add midpoints on volumes for given points and cells and update cell_type accordingly.

add_runouts(cells, cell_type, values=[0.1, 0.1], centerpoint=[0, 0, 0], axis=0, exponent=5, mask=slice(None, None, None), normalize=False)#

Add simple rubber-runouts for realistic rubber-metal structures.

Parameters:

points (list or ndarray) – Original point coordinates.
cells (list or ndarray) – Original point-connectivity of cells.
cell_type (str) – A string in VTK-convention that specifies the cell type.
values (list or ndarray, optional) – Relative amount of runouts (per coordinate) perpendicular to the axis (default is 10% per coordinate, i.e. [0.1, 0.1]).
centerpoint (list or ndarray, optional) – Center-point coordinates (default is [0, 0, 0]).
axis (int or None, optional) – Axis (default is 0).
exponent (int, optional) – Positive exponent to control the shape of the runout. The higher the exponent, the steeper the transition (default is 5).
mask (list or None, optional) – List of points to be considered (default is None).
normalize (bool, optional) – Normalize the runouts to create indents, i.e. maintain the original shape at the ends (default is False).

Returns:

points (ndarray) – Modified point coordinates.
cells (ndarray) – Modified point-connectivity of cells.
cell_type (str or None) – A string in VTK-convention that specifies the cell type.

as_meshio(**kwargs)[source]#: Export the mesh as meshio.Mesh.

collect_edges(cells, cell_type)#: “Collect all unique edges, calculate and return midpoints on edges as well as the additional cells array.

collect_faces(cells, cell_type)#: “Collect all unique faces, calculate and return midpoints on faces as well as the additional cells array.

collect_volumes(cells, cell_type)#: “Collect all volumes, calculate and return midpoints on volumes as well as the additional cells array.

convert(cells, cell_type, order=0, calc_points=False, calc_midfaces=False, calc_midvolumes=False)#: Convert mesh to a given order (only order=0 and order=2 from order=1 are supported).

copy(points=None, cells=None, cell_type=None)#: Return a deepcopy.

disconnect(points_per_cell=None, calc_points=True)[source]#: Return a new instance of a Mesh with disconnected cells. Optionally, the points-per-cell may be specified (must be lower or equal the number of points- per-cell of the original Mesh). If the Mesh is to be used as a dual Mesh, then the point-coordinates do not have to be re-created because they are not used.

dual(cells, cell_type, points_per_cell=None, disconnect=True, calc_points=False, offset=0, npoints=None)#: Create a new dual mesh with given points per cell. The point coordinates are not used in a dual mesh and hence, by default they are all zero.

expand(cells, cell_type, n=11, z=1)#

Expand a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh.

Parameters:

points (list or ndarray) – Original point coordinates.
cells (list or ndarray) – Original point-connectivity of cells.
cell_type (str) – A string in VTK-convention that specifies the cell type.
n (int, optional) – Number of n-point repetitions or (n-1)-cell repetitions, default is 11.
z (float or ndarray, optional) – Total expand dimension as float (edge length in expand direction is z / n), default is 1. Optionally, if an array is passed these entries are taken as expansion and n is ignored.

Returns:

points (ndarray) – Modified point coordinates.
cells (ndarray) – Modified point-connectivity of cells.
cell_type (str or None) – A string in VTK-convention that specifies the cell type.

fill_between(other_mesh, n=11)#

Fill a 2d-Quad Mesh between two 1d-Line Meshes, embedded in 2d-space, or a 3d-Hexahedron Mesh between two 2d-Quad Meshes, embedded in 3d-space, by expansion. Both meshes must have equal number of points and cells. The cells-array is taken from the first mesh.

Parameters:

mesh (felupe.Mesh) – The base line- or quad-mesh.
other_mesh (felupe.Mesh) – The other line- or quad-mesh.
n (int or ndarray) – Number of n-point repetitions or (n-1)-cell repetitions, (default is 11). If an array is given, then its values are used for the relative positions in a reference configuration (-1, 1) between the two meshes.

Returns:

mesh – The expanded mesh.

Return type:

felupe.Mesh

flip(cells, cell_type, mask=None)#

Ensure positive cell volumes for tria, tetra, quad and hexahedron cell types.

Parameters:

points (list or ndarray) – Original point coordinates.
cells (list or ndarray) – Original point-connectivity of cells.
cell_type (str) – A string in VTK-convention that specifies the cell type.
mask (list or ndarray, optional) – Boolean mask for selected cells to flip.

Returns:

points (ndarray) – Point coordinates.
cells (ndarray) – Modified point-connectivity of cells.
cell_type (str or None) – A string in VTK-convention that specifies the cell type.

mirror(cells, cell_type, normal=[1, 0, 0], centerpoint=[0, 0, 0], axis=None)#

Mirror points by plane normal and ensure positive cell volumes for tria, tetra, quad and hexahedron cell types.

Parameters:

points (list or ndarray) – Original point coordinates.
cells (list or ndarray) – Original point-connectivity of cells.
cell_type (str) – A string in VTK-convention that specifies the cell type.
normal (list or ndarray, optional) – Mirror-plane normal vector (default is [1, 0, 0]).
centerpoint (list or ndarray, optional) – Center-point coordinates on the mirror plane (default is [0, 0, 0]).
axis (int or None, optional) – Mirror axis (default is None).

Returns:

points (ndarray) – Modified point coordinates.
cells (ndarray) – Modified point-connectivity of cells.
cell_type (str or None) – A string in VTK-convention that specifies the cell type.

plot(*args, **kwargs)[source]#

Plot the mesh.