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

`Point`([a])	A mesh with a single vertex point located at `a`.
`mesh.Line`([a, b, n])	A 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 an arbitrary-order Lagrange quad between `a` and `b`.
`mesh.CubeArbitraryOrderHexahedron`([a, b, order])	A rectangular 3d-mesh with an arbitrary-order Lagrange hexahedron between `a` and `b`.

Tools

`mesh.expand`(points, cells, cell_type[, n, ...])	Expand a 0d-Point to a 1d-Line, a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh.
`mesh.translate`(points, cells, cell_type, ...)	Translate (move) a Mesh along a given axis.
`mesh.rotate`(points, cells, cell_type, ...[, ...])	Rotate a Mesh.
`mesh.revolve`(points, cells, cell_type[, n, ...])	Revolve a 0d-Point to a 1d-Line, a 1d-Line to 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh.
`mesh.sweep`(points, cells, cell_type[, decimals])	Merge duplicate 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.merge_duplicate_points`(points, cells, ...)	Merge duplicate points and update cells of a Mesh.
`mesh.merge_duplicate_cells`(points, cells, ...)	Merge duplicate cells of a Mesh.
`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 a mesh to a given order.
`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.subdivide`(points, cells, cell_type)	Subdivide cells by adding midpoints on edges, faces and volumes.
`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.extrude`(mesh, path[, other_mesh])	Extrude a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh along a given path.
`mesh.dual`(points, cells, cell_type[, ...])	Create a new dual mesh with given points per cell.
`mesh.stack`(meshes)	Stack cell-blocks from meshes with identical points-array and cell-types.
`mesh.read`(filename[, file_format, ...])	Read a mesh from a file using `meshio.read()` and create a `MeshContainer`.
`mesh.interpolate_line`(mesh, xi[, axis, ...])	Return an interpolated line mesh from an existing line mesh with provided interpolation points on a given axis.
`mesh.cell_types`()	Return a list with tuples of identical cell types for different packages.

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) – Array with point coordinates of shape (npoints, dim).
cells (ndarray) – Array with cell connectivities of shape (ncells, points_per_cell).
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.

Notes

The points-array is of shape (npoints, dim), as denoted in Eq. (1).

(1)#\[\begin{split}\hat{\boldsymbol{X}} = \begin{bmatrix} \hat{\boldsymbol{X}_1}^T \\ \hat{\boldsymbol{X}_2}^T \\ \dots \\ \hat{\boldsymbol{X}_n}^T \\ \end{bmatrix}\end{split}\]

Exemplaric point coordinates of a single point at the origin in \(\mathbb{R}^3\) are shown in Eq. (2).

(2)#\[\hat{\boldsymbol{X}_1}^T = \begin{bmatrix} 0.0 & 0.0 & 0.0 \end{bmatrix}\]

Topologic cell connectivies are stored inside the cells-array, see Eq. (3),

(3)#\[\begin{split}\boldsymbol{t} = \begin{bmatrix} \boldsymbol{t}_1^T \\ \boldsymbol{t}_2^T \\ \vdots \\ \boldsymbol{t}_n^T \\ \end{bmatrix}\end{split}\]

with an exemplaric topologic cell-connectivity of a Quad, as shown in Eq. (4).

(4)#\[\boldsymbol{t}_1^T = \begin{bmatrix} 0 & 1 & 2 & 3 \end{bmatrix}\]

Examples

>>> import numpy as np
>>> import felupe as fem
>>>
>>> points = np.array(
...     [[0.0, 0.0], [0.5, 0.1], [1.0, 0.2], [0.0, 1.0], [0.5, 0.9], [1.0, 0.8]]
... )
>>> cells = np.array([[0, 1, 4, 3], [1, 2, 5, 4]])
>>> mesh = fem.Mesh(points, cells, cell_type="quad")
>>> mesh.plot().show()

../_images/mesh-dbe976038c604947_00_00.png

A mesh provides several useful attributes, like the dimension, the number of points, number of cells, number of deegrees of freedom, points connected to cells and points not connected to cells.

>>> mesh.dim
2

>>> mesh.npoints
6

>>> mesh.ncells
2

>>> mesh.ndof
12

>>> mesh.points_with_cells
array([0, 1, 2, 3, 4, 5])

See also

felupe.MeshContainer: A container which operates on a list of meshes with identical dimensions.
felupe.Rectangle: A rectangular 2d-mesh with quads between a and b with n points per axis.
felupe.Cube: A cube shaped 3d-mesh with hexahedrons between a and b with n points per axis.
felupe.Grid: A grid shaped 3d-mesh with hexahedrons. Basically a wrapper for numpy.meshgrid() with default indexing="ij".
felupe.Circle: A circular shaped 2d-mesh with quads and n points on the circumferential edge of a 45-degree section. 90-degree sections are placed at given angles in degree.
felupe.mesh.Triangle: A triangular shaped 2d-mesh with quads and n points at the edges of the three sub-quadrilaterals.

add_midpoints_edges(cell_type=None)[source]#

Add midpoints on edges for given points and cells and update cell_type accordingly.

Parameters:: cell_type (str or None, optional) – A string in VTK-convention that specifies the new cell type (default is None). If None, the cell type is chosen automatically.
Returns:: A new mesh with inserted midpoints on cell edges.
Return type:: Mesh

Examples

Convert a mesh of hexahedrons to quadratic hexahedrons by inserting midpoints on the cell edges.

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=6)
>>> mesh_with_midpoints_edges = mesh.add_midpoints_edges()
>>>
>>> mesh_with_midpoints_edges.plot(
...     plotter=mesh.plot(), style="points", color="black"
... ).show()

../_images/mesh-de7b634d3f8cc412_00_00.png

>>> mesh_with_midpoints_edges
<felupe Mesh object>
  Number of points: 96
  Number of cells:
    quad8: 25

See also

felupe.mesh.add_midpoints_edges: Add midpoints on edges for given points and cells and update cell_type accordingly.

add_midpoints_faces(cell_type=None)[source]#

Add midpoints on faces for given points and cells and update cell_type accordingly.

Parameters:: cell_type (str or None, optional) – A string in VTK-convention that specifies the new cell type (default is None). If None, the cell type is chosen automatically.
Returns:: A new mesh with inserted midpoints on cell faces.
Return type:: Mesh

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=6)
>>> mesh_with_midpoints_faces = mesh.add_midpoints_faces(cell_type="quad")
>>>
>>> mesh_with_midpoints_faces.plot(
...     plotter=mesh.plot(), style="points", color="black"
... ).show()

../_images/mesh-c15277c09b5358ce_00_00.png

>>> mesh_with_midpoints_faces
<felupe Mesh object>
  Number of points: 61
  Number of cells:
    quad: 25

See also

felupe.mesh.add_midpoints_faces: Add midpoints on faces for given points and cells and update cell_type accordingly.

add_midpoints_volumes(cell_type=None)[source]#

Add midpoints on volumes for given points and cells and update cell_type accordingly.

Parameters:: cell_type (str or None, optional) – A string in VTK-convention that specifies the new cell type (default is None). If None, the cell type is chosen automatically.
Returns:: A new mesh with inserted midpoints on cell volumes.
Return type:: Mesh

Examples

>>> import felupe as fem
>>> import pyvista as pv
>>>
>>> mesh = fem.Cube(n=6)
>>> mesh_with_midpoints_volumes = fem.mesh.add_midpoints_volumes(
...     mesh, cell_type_new="hexahedron9"
... )
>>> plotter = pv.Plotter()
>>> actor = plotter.add_points(mesh_with_midpoints_volumes.points, color="black")
>>> mesh.plot(opacity=0.5, plotter=plotter).show()

../_images/mesh-acca69c7d1f14d4e_00_00.png

>>> mesh_with_midpoints_volumes
<felupe Mesh object>
  Number of points: 341
  Number of cells:
    hexahedron9: 125

See also

felupe.mesh.add_midpoints_volumes: Add midpoints on volumes for given points and cells and update cell_type accordingly.

add_points(points)[source]#: Add additional points to the mesh in-place.

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

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

Parameters:

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:

The mesh with the modified point coordinates.

Return type:

Mesh

Examples

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(a=(-3, -1), b=(3, 1), n=(31, 11))
>>> mesh = rect.add_runouts(axis=1, values=[0.2], normalize=True)
>>>
>>> mesh.plot().show()

../_images/mesh-7f683311082f3942_00_00.png

>>> import felupe as fem
>>>
>>> cube = fem.Cube(a=(-3, -2, -1), b=(3, 2, 1), n=(31, 21, 11))
>>> mesh = cube.add_runouts(axis=2, values=[0.1, 0.3], normalize=True)
>>>
>>> mesh.plot().show()

../_images/mesh-157f72948ee4b6fa_00_00.png

See also

felupe.mesh.runouts: Add simple rubber-runouts for realistic rubber-metal structures.

as_meshio(**kwargs)[source]#

Export the mesh as meshio.Mesh.

Parameters:: **kwargs (dict, optional) – Additional keyword-arguments for meshio.Mesh(points, cells, **kwargs).
Returns:: The mesh as meshio.Mesh.
Return type:: meshio.Mesh

as_unstructured_grid(cell_type=None, **kwargs)[source]#

Export the mesh as pyvista.UnstructuredGrid.

Parameters:

cell_type (pyvista.CellType or None, optional) – Cell-type of PyVista (default is None).
**kwargs (dict, optional) – Additional keyword-arguments for pyvista.UnstructuredGrid.

Returns:

The mesh as pyvista.UnstructuredGrid.

Return type:

pyvista.UnstructuredGrid

cells_in(other_mesh, decimals=8)[source]#

Return a boolean cells-mask for cells that are also present in another mesh.

Parameters:

other_mesh (fem.Mesh) – The mesh to compare with.
decimals (int, optional) – The number of decimals to consider for point comparison. Default is 8.

Returns:

A boolean array where True indicates that cells are also in the other mesh.

Return type:

np.ndarray

Examples

>>> import felupe as fem
>>>
>>> rect_top = fem.Rectangle(n=(4, 2)).translate(1.0, axis=1)
>>> rect_bottom = fem.Rectangle(n=(4, 2)).translate(1e-6, axis=0)
>>>
>>> meshes = [rect_top, rect_bottom]
>>> mesh = fem.MeshContainer(meshes, merge=True, decimals=6).stack()
>>>
>>> cells_mask = mesh.cells_in(rect_top, decimals=6)
>>> cells_mask
array([ True,  True,  True, False, False, False])

clear_points_without_cells()[source]#: Clear the list of points without cells.

collect_edges(cells, cell_type)#

Collect all unique edges, calculate and return midpoints on edges as well as the additional cells array.

See also

felupe.mesh.add_midpoints_edges: Add midpoints on cell edges for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_edges: Add midpoints on cell edges for given points and cells and update cell_type accordingly.

collect_faces(cells, cell_type)#

Collect all unique faces, calculate and return midpoints on faces as well as the additional cells array.

See also

felupe.mesh.add_midpoints_faces: Add midpoints on cell faces for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_faces: Add midpoints on cell faces for given points and cells and update cell_type accordingly.

collect_volumes(cells, cell_type)#

Collect all volumes, calculate and return midpoints on volumes as well as the additional cells array.

See also

felupe.mesh.add_midpoints_volumes: Add midpoints on cell volumes for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_volumes: Add midpoints on cell volumes for given points and cells and update cell_type accordingly.

convert(order=0, calc_points=False, calc_midfaces=False, calc_midvolumes=False)[source]#

Convert a mesh to a given order. Only conversions to order=0 and order=2 are supported. This function supports meshes with cell types "triangle", "tetra", "quad" and "hexahedron".

Parameters:

order (int, optional) – The order of the converted mesh (default is 0). If 0, the points-array will be of shape (ncells, dim). If 0 and calc_points is True, the mean of all points per cell is evaluated. If 0 and calc_points is False, the points array is filled with zeros. If 2, at least midpoints on cell edges are added to the mesh. If 2 and calc_midfaces is True, midpoints on cell faces are also added. If 2 and calc_midvolumes is True, midpoints on cell volumes are also added. Raises an error if not 0 or 2.
calc_points (bool, optional) – Flag to return the mean of all points per cell if order=0 (default is False). If False, the points-array is filled with zeros.
calc_midfaces (bool, optional) – Flag to add midpoints on cell faces if order=2 (default is False).
calc_midvolumes (bool, optional) – Flag to add midpoints on cell volumes if order=2 (default is False).

Returns:

The converted mesh.

Return type:

Mesh

Examples

Convert a mesh of hexahedrons to quadratic hexahedrons by inserting midpoints on the cell edges.

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=6)
>>> mesh2 = mesh.convert(order=2)
>>>
>>> mesh2.plot(plotter=mesh.plot(), style="points", color="black").show()

../_images/mesh-933b06b84f3221c0_00_00.png

>>> mesh2
<felupe Mesh object>
  Number of points: 96
  Number of cells:
    quad8: 25

See also

felupe.mesh.add_midpoints_edges: Add midpoints on edges for given points and cells and update cell_type accordingly.
felupe.mesh.add_midpoints_faces: Add midpoints on faces for given points and cells and update cell_type accordingly.
felupe.mesh.add_midpoints_volumes: Add midpoints on volumes for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_edges: Add midpoints on edges for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_faces: Add midpoints on faces for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_volumes: Add midpoints on volumes for given points and cells and update cell_type accordingly.

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.

See also

felupe.Mesh.dual: Create a new dual mesh with given points per cell.

dual(points_per_cell=None, disconnect=True, calc_points=False, offset=0, npoints=None)[source]#

Create a new dual mesh with given points per cell.

Parameters:

points_per_cell (int or None, optional) – Number of points per cell, must be equal or lower than cells.shape[1] ( default is None). If None, all points per cell are considered for the dual mesh.
disconnect (bool, optional) – A flag to disconnect the mesh (each cell has its own points). Default is True.
calc_points (bool, optional) – A flag to calculate the point coordinates for the dual mesh (default is False). If False, the points array is filled with zeros.
offset (int, optional) – An offset to be added to the cells array (default is 0).
npoints (int or None, optional) – Number of points for the dual mesh. If the given number of points is greater than npoints * points_per_cell, then the missing points are added to the points array (filled with zeros). Default is None.

Returns:

The dual mesh.

Return type:

Mesh

Notes

Note

The points array of the dual mesh always has a shape of (npoints * points_per_cell, dim).

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=5).add_midpoints_edges()
>>> region = fem.RegionQuadraticQuad(mesh=mesh)
>>>
>>> mesh_dual = mesh.dual(points_per_cell=1, disconnect=False)
>>> region_dual = fem.RegionConstantQuad(
...     mesh_dual, quadrature=region.quadrature, grad=False
... )
>>>
>>> displacement = fem.FieldPlaneStrain(region, dim=2)
>>> pressure = fem.Field(region_dual)
>>> field = fem.FieldContainer([displacement, pressure])

See also

felupe.mesh.dual: Create a new dual mesh with given points per cell.

expand(n=11, z=1, axis=-1, expand_dim=True)[source]#

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

Parameters:

n (int, optional) – Number of n-point repetitions or (n-1)-cell repetitions, default is 11. Must be greater than 0.
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.
axis (int, optional) – Axis of expansion (default is -1).
expand_dim (bool, optional) – Expand the dimension of the point coordinates (default is True).

Returns:

The expanded mesh.

Return type:

Mesh

Examples

Expand a rectangle to a cube.

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(n=4)
>>> cube = rect.expand(n=7, z=2)
>>>
>>> cube.plot().show()

../_images/mesh-9fbc9ddf2f1b8d55_00_00.png

>>> cube
<felupe Mesh object>
  Number of points: 112
  Number of cells:
    hexahedron: 54

See also

felupe.mesh.expand: Expand a 0d-Point to a 1d-Line, a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh.

extrude(path, other_mesh=None)[source]#

Extrude a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh along a given path. Optionally, the section is interpolated between the mesh and another mesh.

Parameters:

path (felupe.Mesh or ndarray) – A line-mesh or an array of point coordinates, which defines the path. The points of the path define the positions of the extruded sections. The cells of a line-mesh must be ordered consecutively along the path.
other_mesh (felupe.Mesh or None, optional) – Another line- or quad-mesh with equal cells and number of points, also located at the start of the path (default is None). If given, the section is linearly interpolated between the mesh (at the start) and the other mesh (at the end of the path) w.r.t. the normalized arc length of the path.

Returns:

The extruded mesh.

Return type:

felupe.Mesh

Notes

The section is transported along the path by rotation-minimizing frames, i.e. the section is not twisted around the path. The section is not required to be perpendicular to the path. Instead, the (initial) orientation of the section w.r.t. the tangent of the path is preserved. The mesh must be located at the start of the path.

Examples

Extrude a circular section along a helix. The section is not perpendicular to the path, it is tilted by 20 degrees.

>>> import numpy as np
>>> import felupe as fem
>>>
>>> phi = np.linspace(0, 4 * np.pi, 97)
>>> path = fem.mesh.Line(n=97)
>>> path.update(points=np.vstack([np.cos(phi), np.sin(phi), phi / 8]).T)
>>>
>>> section = (
...     fem.Circle(radius=0.2, n=4)
...     .expand(n=1)
...     .rotate(90, axis=0)
...     .rotate(20, axis=2)
...     .translate(1, axis=0)
... )
>>> mesh = section.extrude(path)
>>>
>>> mesh.plot().show()

../_images/mesh-5722b218a94ae30b_00_00.png

See also

felupe.mesh.extrude: Extrude a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh along a given path.

fill_between(other_mesh, n=11)[source]#

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:

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:

The expanded mesh.

Return type:

felupe.Mesh

Examples

>>> import felupe as fem
>>>
>>> inner = fem.mesh.revolve(fem.Point(1)).expand(z=0.4).translate(0.2, axis=2)
>>> outer = fem.mesh.revolve(fem.Point(2), phi=160).rotate(
...     axis=2, angle_deg=20
... ).expand(z=1.2)
>>> mesh = inner.fill_between(outer, n=6)
>>>
>>> mesh.plot().show()

../_images/mesh-431e78617a5431c6_00_00.png

See also

felupe.mesh.fill_between: 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.

flip(mask=None)[source]#

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

Parameters:: mask (list, ndarray or None, optional) – Boolean mask for selected cells to flip (default is None). If None, all cells are selected to be flipped.
Returns:: The mesh with a rearranged cells array to ensure positive cell volumes.
Return type:: Mesh

Examples

A quad mesh with negative cell volumes occurs if one coordinate axis is multiplied by -1. The error pops up if a region is created with this mesh.

>>> import numpy as np
>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=3)
>>> mesh.update(points=mesh.points * np.array([[-1, 1]]))
>>> region = fem.RegionQuad(mesh)

The sum of the differential volumes \(V = \sum_c \sum_q dV_{qc}\) is evaluated to -1.0.

>>> region.dV.sum()
-1.0

Let’s try to fix the mesh.

>>> mesh.cells
array([[0, 1, 4, 3],
       [1, 2, 5, 4],
       [3, 4, 7, 6],
       [4, 5, 8, 7]])

The cells array is rearranged to ensure positive cell volumes.

>>> mesh_fixed = mesh.flip()
>>> mesh_fixed.cells
array([[3, 4, 1, 0],
       [4, 5, 2, 1],
       [6, 7, 4, 3],
       [7, 8, 5, 4]])

A region now correctly evaluates the total volume of the mesh to 1.0.

>>> region_fixed = fem.RegionQuad(mesh_fixed)
>>> region_fixed.dV.sum()
1.0

See also

felupe.mesh.flip: Ensure positive cell volumes for tria, tetra, quad and hexahedron cell types.

get_cell_ids(point_ids)[source]#

Return cell ids which have the given point ids in their connectivity.

Parameters:: point_ids (list or ndarray) – Array with point ids which are used to search for cells.
Returns:: Array with cell ids which have the given point ids in their connectivity.
Return type:: ndarray

Examples

>>> import numpy as np
>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=11)
>>> point_ids = mesh.get_point_ids([0, 1, 1])
>>> point_ids
array([1320])

>>> cell_ids = mesh.get_cell_ids(point_ids)
>>> cell_ids
array([990])

get_cell_ids_neighbours(cell_ids)[source]#

Return cell ids which share points with given cell ids.

Parameters:: cell_ids (list or ndarray) – Array with cell ids which are used to search for neighbour cells.
Returns:: Array with cell ids which are next to the given cells.
Return type:: ndarray

Examples

>>> import numpy as np
>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=11)
>>> point_ids = mesh.get_point_ids([0, 1, 1])
>>> point_ids
array([1320])

>>> cell_ids = mesh.get_cell_ids(point_ids)
>>> cell_ids
array([990])

Find the cell ids which share at least one point with the given cell id(s).

>>> cell_ids_neighbours = mesh.get_cell_ids_neighbours(cell_ids)
>>> cell_ids_neighbours
array([880, 881, 890, 891, 980, 981, 990, 991])

get_point_ids(value, fun=<function isclose>, mode=<function all>, **kwargs)[source]#

Return point ids for points which are close to a given value.

Parameters:

value (float, list or ndarray) – Scalar value or point coordinates.
fun (callable, optional) – The function used to compare the points to the given value, i.e. with a function signature fun(mesh.points, value, **kwargs). Default is numpy.isclose().
mode (callable, optional) – A callable used to combine the search results, either numpy.any() or numpy.all().
**kwargs (dict, optional) – Additional keyword arguments for fun(mesh.points, value, **kwargs).

Returns:

Array with point ids.

Return type:

ndarray

Examples

Get point ids at given coordinates for a mesh with duplicate points.

>>> import numpy as np
>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=11)
>>> mesh.update(points=np.vstack([mesh.points, mesh.points]))
>>> point_ids = mesh.get_point_ids([0, 1, 1])
>>> point_ids
array([1320, 2651])

>>> mesh.points[point_ids]
array([[0., 1., 1.],
       [0., 1., 1.]])

get_point_ids_corners()[source]#

Return point ids which are located at (xmin, ymin), (xmax, ymin), etc.

Returns:: Array with point ids which are located at the corners.
Return type:: ndarray

Examples

>>> import numpy as np
>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=11)
>>> point_ids_corners = mesh.get_point_ids_corners()
>>> point_ids_corners
array([   0, 1210,   10, 1220,  110, 1320,  120, 1330])

get_point_ids_shared(cell_ids_neighbours)[source]#

Return shared point ids for given cell ids.

Parameters:: cell_ids_neighbours (list or ndarray) – Array with cell ids.
Returns:: Array with point ids which are connected to all given cell neighbours.
Return type:: ndarray

Examples

>>> import numpy as np
>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=11)
>>> point_ids = mesh.get_point_ids([0, 1, 1])
>>> point_ids
array([1320])

>>> cell_ids = mesh.get_cell_ids(point_ids)
>>> cell_ids
array([990])

Find the cell ids which share at least one point with the given cell id(s).

>>> cell_ids_neighbours = mesh.get_cell_ids_neighbours(cell_ids)
>>> cell_ids_neighbours
array([880, 881, 890, 891, 980, 981, 990, 991])

Find the shared point ids for the list of cell ids.

>>> point_ids_shared = mesh.get_point_ids_shared(cell_ids_neighbours)
>>> point_ids_shared
array([1189])

imshow(*args, ax=None, **kwargs)[source]#: Take a screenshot of the mesh, show the image data in a figure and return the ax.

merge_duplicate_cells(cells, cell_type)#

Merge duplicate cells of a 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.

Returns:

points (ndarray) – Point coordinates.
cells (list or ndarray) – Cells with merged duplicate cells.
cell_type (str or None) – A string in VTK-convention that specifies the cell type.

Notes

Warning

This function re-sorts cells.

Note

This function does not merge duplicate points.

Examples

Two quad meshes to be merged overlap some cells. Merge these duplicated points and update the cells.

>>> import felupe as fem
>>>
>>> rect1 = fem.Rectangle(n=11)
>>> rect2 = fem.Rectangle(a=(0.9, 0), b=(1.9, 1), n=11)
>>>
>>> container = fem.MeshContainer([rect1, rect2])
>>> stack = fem.mesh.stack(container.meshes)
>>> mesh = fem.mesh.merge_duplicate_points(stack)
>>>
>>> mesh.plot(opacity=0.6).show()

../_images/mesh-c0ab42634ee82aea_00_00.png

Each mesh contains 121 points and 100 cells.

>>> rect1
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

>>> rect2
<felupe Mesh object>
    Number of points: 121
    Number of cells:
    quad: 100

These two meshes are now stored in a MeshContainer.

>>> container
<felupe mesh container object>
Number of points: 242
Number of cells:
    quad: 100
    quad: 100

The meshes of the mesh container are stacked.

>>> stack
<felupe Mesh object>
Number of points: 242
Number of cells:
    quad: 200

After merging the duplicated points and cells, the number of points is reduced but the number of cells is unchanged.

>>> mesh
<felupe Mesh object>
Number of points: 220
Number of cells:
    quad: 200

Note

The MeshContainer may be directly created with merge=True. This enforces merge_duplicate_points() for the shared points array of the container.

The duplicate cells are merged in a second step.

>>> merged = fem.mesh.merge_duplicate_cells(mesh)
>>> merged
<felupe Mesh object>
Number of points: 220
Number of cells:
    quad: 190

See also

felupe.Mesh.merge_duplicate_points: Merge duplicate points of a Mesh.
felupe.Mesh.merge_duplicate_cells: Merge duplicate cells of a Mesh.
felupe.MeshContainer: A container which operates on a list of meshes with identical dimensions.

merge_duplicate_points(decimals=None)[source]#

Merge duplicate points and update cells of a Mesh.

Parameters:: decimals (int or None, optional) – Number of decimals for point coordinate comparison (default is None).
Returns:: The mesh with merged duplicate points and updated cells.
Return type:: Mesh

Notes

Warning

This function re-sorts points.

Note

This function does not merge duplicate cells.

Examples

Two quad meshes to be merged overlap some points. Merge these duplicated points and update the cells.

>>> import felupe as fem
>>>
>>> rect1 = fem.Rectangle(n=11)
>>> rect2 = fem.Rectangle(a=(0.9, 0), b=(1.9, 1), n=11)
>>> rect2
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

Each mesh contains 121 points and 100 cells. These two meshes are now stored in a MeshContainer.

>>> container = fem.MeshContainer([rect1, rect2])
>>> container
<felupe mesh container object>
  Number of points: 242
  Number of cells:
    quad: 100
    quad: 100

The meshes of the mesh container are stacked.

>>> stack = fem.mesh.stack(container.meshes)
>>> stack
<felupe Mesh object>
  Number of points: 242
  Number of cells:
    quad: 200

After merging the duplicated points and cells, the number of points is reduced but the number of cells is unchanged.

>>> mesh = stack.merge_duplicate_points()
>>> mesh
<felupe Mesh object>
  Number of points: 220
  Number of cells:
    quad: 200

>>> mesh.plot(opacity=0.6).show()

../_images/mesh-362e1ff60e3291f9_00_00.png

Note

The MeshContainer may be directly created with merge=True. This enforces merge_duplicate_points() for the shared points array of the container.

See also

felupe.mesh.merge_duplicate_points: Merge duplicated points and update cells of a Mesh.
felupe.MeshContainer: A container which operates on a list of meshes with identical dimensions.

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

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

Parameters:

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:

The mirrored mesh.

Return type:

Mesh

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Circle(sections=[0, 90, 180], n=5)
>>> mesh.plot().show()

../_images/mesh-74d7e864e0396b05_00_00.png

>>> import felupe as fem
>>>
>>> mesh = fem.Circle(sections=[0, 90, 180], n=5)
>>> mesh.mirror(normal=[0, 1, 0]).plot().show()

../_images/mesh-79eb2d1429ed0879_00_00.png

See also

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

modify_corners(point_ids=None)[source]#

Modify the corners of a regular rectangle (quad) or cube (hexahedron) inplace. Only the cells array is modified, the points array remains unchanged.

Parameters:: point_ids (ndarray or None, optional) – Array with point ids located at the corners which are modified (default is None). If None, all corners are modified.

Notes

Description of the algorithm:

Get corner point ids.

For each corner point:

Get attached cell and find cell neighbours.
Get the shared point of the cell and its neighbours.
Get pair-wise shared points which are located on an edge.
Replace the shared points with the corner point.
Delete the cell attached to the corner point.

Examples

>>> import numpy as np
>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(b=(3, 1), n=(16, 6))
>>> mesh.plot().show()

../_images/mesh-bd832ab0e05f1a73_00_00.png

>>> mesh = mesh.modify_corners()  # inplace
>>> mesh.plot().show()

../_images/mesh-ce65051743330646_00_00.png

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

Plot the mesh.

See also

felupe.Scene.plot: Plot method of a scene.

revolve(n=11, phi=180, axis=0, expand_dim=True)[source]#

Revolve a 2d-Quad to a 3d-Hexahedron Mesh.

Parameters:

n (int, optional) – Number of n-point revolutions (or (n-1) cell revolutions), default is 11.
phi (float or ndarray, optional) – Revolution angle in degree (default is 180).
axis (int, optional) – Revolution axis (default is 0).
expand_dim (bool, optional) – Expand the dimension of the point coordinates (default is True).

Returns:

The revolved mesh.

Return type:

Mesh

Examples

Revolve a cylinder from a rectangle.

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(a=(0, 4), b=(3, 5), n=(10, 4))
>>> mesh = rect.revolve(n=11, phi=180, axis=0)
>>> mesh.plot().show()

../_images/mesh-6fb6fd3b2070fc6c_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 440
  Number of cells:
    hexahedron: 270

See also

felupe.mesh.revolve: Revolve a 2d-Quad to a 3d-Hexahedron Mesh.

rotate(angle_deg, axis, center=None, mask=None)[source]#

Rotate a Mesh.

Parameters:

angle_deg (int) – Rotation angle in degree.
axis (int) – Rotation axis.
center (list or ndarray or None, optional) – Center point coordinates (default is None).
mask (ndarray or None, optional) – A boolean mask to select points which are rotated (default is None).

Returns:

The rotated mesh.

Return type:

Mesh

Examples

Rotate a rectangle in the xy-plane by 35 degree.

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(b=(3, 1), n=(10, 4))
>>> mesh = rect.rotate(angle_deg=35, axis=2, center=[1.5, 0.5])
>>> mesh.plot().show()

../_images/mesh-a0def6cb936bf5bf_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 40
  Number of cells:
    quad: 27

See also

felupe.mesh.rotate: Rotate a Mesh.

screenshot(*args, filename='mesh.png', transparent_background=None, scale=None, **kwargs)[source]#

Take a screenshot of the mesh.

See also

pyvista.Plotter.screenshot: Take a screenshot of a PyVista plotter.

subdivide()[source]#

Subdivide cells by adding midpoints on edges, faces and volumes.

Returns:: A new subdivided mesh.
Return type:: Mesh

Examples

Take a rectangle mesh and subdivide it two times.

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(n=4).modify_corners()
>>> rect.plot().show()

../_images/mesh-e2960ba293dd0a4a_00_00.png

>>> mesh = rect.subdivide().subdivide()
>>> mesh.plot().show()

../_images/mesh-51446596630267de_00_00.png

See also

felupe.Mesh.subdivide: Subdivide cells by adding midpoints on edges, faces and volumes.

translate(move, axis)[source]#

Translate (move) a Mesh along a given axis.

Parameters:

move (float) – Translation along given axis.
axis (int) – Translation axis.

Returns:

The translated mesh.

Return type:

Mesh

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Circle(n=6)
>>> mesh.points.min(axis=0), mesh.points.max(axis=0)
(array([-1., -1.]), array([1., 1.]))

>>> translated = mesh.translate(0.3, axis=1)
>>> translated.points.min(axis=0), translated.points.max(axis=0)
(array([-1. , -0.7]), array([1. , 1.3]))

See also

felupe.mesh.translate: Translate (move) a Mesh along a given axis.

triangulate(mode=3)[source]#

Triangulate a quad or a hex mesh.

Parameters:: mode (int, optional) – Choose a mode how to convert hexahedrons to tets [1]_ (default is 3).
Returns:: The triangulated mesh.
Return type:: Mesh

Examples

Use mode=0 to convert a mesh of hexahedrons into tetrahedrons [1]_.

>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=6)
>>> mesh.triangulate(mode=0).plot().show()

../_images/mesh-5fea6ab533adc53a_00_00.png

Use mode=3 to convert a mesh of hexahedrons into tetrahedrons [1]_.

>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=6)
>>> mesh.triangulate(mode=3).plot().show()

../_images/mesh-4ceae0c7c2d16132_00_00.png

References

See also

felupe.mesh.triangulate: Triangulate a quad or a hex mesh.

update(points=None, cells=None, cell_type=None, callback=None)#

Update the mesh with given points and cells arrays inplace. Optionally, a callback is evaluated.

Parameters:

points (ndarray or None) – New point coordinates (default is None). If None, it is unchanged.
cells (ndarray) – New point-connectivity of cells (default is None). If None, it is unchanged.
cell_type (str or None, optional) – New string in VTK-convention that specifies the cell type (default is None). If None, it is unchanged.
callback (callable or None, optional) – A callable which is called after the mesh is updated (default is None).

Examples

Warning

If the points of a mesh are modified and a region was already created with the mesh, it is important to re-evaluate (reload) the Region.

>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=6)
>>> region = fem.RegionHexahedron(mesh)
>>> field = fem.FieldContainer([fem.Field(region, dim=3)])
>>>
>>> new_points = mesh.rotate(angle_deg=-90, axis=2).points
>>> mesh.update(points=new_points, callback=region.reload)

See also

felupe.Region.reload: Reload the numeric region.

view(point_data=None, cell_data=None, cell_type=None)[source]#

View the mesh with optional given dicts of point- and cell-data items.

Parameters:

point_data (dict or None, optional) – Additional point-data dict (default is None).
cell_data (dict or None, optional) – Additional cell-data dict (default is None).
cell_type (pyvista.CellType or None, optional) – Cell-type of PyVista (default is None).

Returns:

A object which provides visualization methods for felupe.Mesh.

Return type:

felupe.ViewMesh

See also

felupe.ViewMesh: Visualization methods for Mesh.

write(filename='mesh.vtk', **kwargs)[source]#

Write the mesh to a file.

Parameters:

filename (str, optional) – The filename of the mesh (default is mesh.vtk).
**kwargs (dict, optional) – Additional keyword arguments for meshio.Mesh.write().

Notes

Note

For XDMF-export please ensure to have h5py (as an optional dependency of meshio) installed.

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=3)
>>> mesh.write(filename="mesh.vtk")

See also

felupe.mesh.read: Read a mesh from a file using meshio.read().
felupe.Mesh.write: Write the mesh to a file.

property x#: Return the first column (x-component) of the points array.

property y#: Return the second column (y-component) of the points array.

property z#: Return the third column (z-component) of the points array.

class felupe.MeshContainer(meshes, merge=False, decimals=None)[source]#

A container which operates on a list of meshes with identical dimensions.

Parameters:

meshes (list of Mesh) – A list of meshes which are organized by the mesh container.
merge (bool, optional) – Flag to merge duplicate mesh points. This changes the cells arrays of the meshes. Default is False.
decimals (int or None, optional) – Precision decimals for merging duplicated mesh points. Only relevant if merge=True. Default is None.

Notes

All meshes are modified to refer to the same points array. By default, the points arrays from the given list of meshes is concatenated and the cells arrays are modified accordingly. Optionally, the points array may be merged on duplicated points.

Examples

>>> import felupe as fem
>>>
>>> cube = fem.Cube(n=3)
>>> cylinder = fem.Circle().expand(n=2)
>>> mesh = fem.MeshContainer([cube, cylinder])
>>>
>>> mesh.plot().show()

../_images/mesh-8de432696504e07d_00_00.png

>>> mesh
<felupe mesh container object>
  Number of points: 61
  Number of cells:
    hexahedron: 8
    hexahedron: 12

The cells array of the second mesh starts with an offset

>>> mesh.meshes[1].cells.min()
27

identical to the number of points from the first mesh.

>>> cube.npoints
27

If the container is created with merge=True, then the number of points is lower than before.

>>> import felupe as fem
>>>
>>> cube = fem.Cube(n=3)
>>> cylinder = fem.Circle().expand(n=2)
>>> mesh = fem.MeshContainer([cube, cylinder], merge=True)
>>>
>>> mesh.plot().show()

../_images/mesh-cbab39de6f0e4cb2_00_00.png

>>> mesh
<felupe mesh container object>
  Number of points: 51
  Number of cells:
    hexahedron: 8
    hexahedron: 12

append(mesh)[source]#: Append a Mesh to the list of meshes.

as_meshio(combined=True, **kwargs)[source]#: Export a (combined) mesh object as meshio.Mesh.

as_vertex_mesh()[source]#: Return a merged vertex-mesh.

cells()[source]#: Return a list of tuples with cell-types and cell-connectivities.

copy()[source]#: Return a deepcopy of the mesh container.

classmethod from_unstructured_grid(grid, dim=None, **kwargs)[source]#

Create a mesh container from an unstructured grid (PyVista).

Parameters:

grid (pyvista.UnstructuredGrid) – PyVista dataset used for arbitrary combinations of all possible cell types.
dim (int or None, optional) – Trim the dimension of the points-array (default is None).
**kwargs (dict, optional) – Additional keyword-arguments are passed to the mesh container.

Returns:

A container which operates on a list of meshes with identical dimensions.

Return type:

MeshContainer

Examples

>>> import felupe as fem
>>> import pyvista as pv
>>>
>>> grid = pv.UnstructuredGrid(pv.examples.hexbeamfile)
>>> container = fem.MeshContainer.from_unstructured_grid(grid)
>>>
>>> container
<felupe mesh container object>
  Number of points: 99
  Number of cells:
    hexahedron: 40

See also

felupe.mesh.cell_types: Return a list with tuples of cell type mappings.
felupe.Mesh.as_unstructured_grid: Export the mesh as unstructured grid.

imshow(*args, ax=None, dpi=None, **kwargs)[source]#: Take a screenshot of the meshes of the mesh container, show the image data in a figure and return the ax.

merge_duplicate_points(decimals=None)[source]#: Merge duplicate points and update the meshes.

plot(*args, colors=None, opacity=0.99, labels=None, add_legend=None, plotter=None, **kwargs)[source]#

Plot the meshes of the mesh container.

See also

felupe.Scene.plot: Plot method of a scene.

pop(index)[source]#: Pop an item of the list of meshes.

screenshot(*args, filename='mesh.png', transparent_background=None, scale=None, colors=None, opacity=0.99, **kwargs)[source]#

Take a screenshot of the meshes of the mesh container.

See also

pyvista.Plotter.screenshot: Take a screenshot of a PyVista plotter.

stack(idx=None)[source]#

Stack cell-blocks with same cell-types into a single mesh.

Parameters:: idx (list of int or None, optional) – List of mesh-indices to be stacked (default is None).
Returns:: The stacked mesh.
Return type:: Mesh

Notes

The points-array is taken from the first mesh. The cells-array of the stacked mesh is created by a vertical stack of the cells-arrays.

Examples

Two quad meshes with identical point arrays should be stacked into a single mesh.

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=11)
>>> rect1, rect2 = mesh.copy(), mesh.copy()
>>> rect1.update(cells=mesh.cells[: 40])
>>> rect2.update(cells=mesh.cells[-50:])
>>> container = fem.MeshContainer([rect1, rect2])
>>> mesh = container.stack()
>>>
>>> mesh.plot().show()

../_images/mesh-03693cf651bc19b3_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 242
  Number of cells:
    quad: 90

See also

felupe.mesh.stack: Stack cell-blocks from meshes with identical points-array and cell-types.

class felupe.Point(a=0.0)[source]#

Bases: Mesh

A mesh with a single vertex point located at a.

Parameters:: a (float, optional) – Vertex point coordinate of the mesh (default is 0.0).

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Point(a=-2.1)
>>> mesh
<felupe Mesh object>
  Number of points: 1
  Number of cells:
    vertex: 1

>>> mesh.points
array([[-2.1]])

>>> mesh.cells
array([[0]])

class felupe.mesh.Line(a=0.0, b=1.0, n=2)[source]#

Bases: Mesh

A 1d-mesh with lines between a and b with n points.

Parameters:

a (float, optional) – Left end point of the mesh (default is 0.0).
b (float, optional) – Right end point of the mesh (default is 1.0).
n (int, optional) – Number of points (default is 2).

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.mesh.Line(a=-2.1, b=3.5, n=3)
>>> mesh.plot(line_width=8).show()

../_images/mesh-2305f2211a2fa7de_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 3
  Number of cells:
    line: 2

>>> mesh.points
array([[-2.1],
       [ 0.7],
       [ 3.5]])

>>> mesh.cells
array([[0, 1],
       [1, 2]])

class felupe.Rectangle(a=(0.0, 0.0), b=(1.0, 1.0), n=(2, 2))[source]#

Bases: Mesh

A rectangular 2d-mesh with quads between a and b with n points per axis.

Parameters:

a (2-tuple of float, optional) – Lower-left end point of the mesh (default is (0.0, 0.0)).
b (2-tuple of float, optional) – Upper-right end point of the mesh (default is (1.0, 1.0)).
n (int or 2-tuple of int, optional) – Number of points per axis (default is (2, 2)).

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.mesh.Rectangle(a=(-1.2, 0.5), b=(4.5, 7.3), n=3)
>>> mesh.plot().show()

../_images/mesh-9ed584cbc91f0637_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 9
  Number of cells:
    quad: 4

>>> mesh.points
array([[-1.2 ,  0.5 ],
       [ 1.65,  0.5 ],
       [ 4.5 ,  0.5 ],
       [-1.2 ,  3.9 ],
       [ 1.65,  3.9 ],
       [ 4.5 ,  3.9 ],
       [-1.2 ,  7.3 ],
       [ 1.65,  7.3 ],
       [ 4.5 ,  7.3 ]])

>>> mesh.cells
array([[0, 1, 4, 3],
       [1, 2, 5, 4],
       [3, 4, 7, 6],
       [4, 5, 8, 7]])

class felupe.Cube(a=(0.0, 0.0, 0.0), b=(1.0, 1.0, 1.0), n=(2, 2, 2))[source]#

Bases: Mesh

A cube shaped 3d-mesh with hexahedrons between a and b with n points per axis.

Parameters:

a (3-tuple of float, optional) – Lower-left end point of the mesh (default is (0.0, 0.0, 0.0)).
b (3-tuple of float, optional) – Upper-right end point of the mesh (default is (1.0, 1.0, 1.0)).
n (int or 3-tuple of int, optional) – Number of points per axis (default is (2, 2, 2)).

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.mesh.Cube(a=(-1.2, 0.5, 6.2), b=(4.5, 7.3, 9.3), n=(3, 2, 2))
>>> mesh.plot().show()

../_images/mesh-32c2b17e58e9b11d_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 12
  Number of cells:
    hexahedron: 2

>>> mesh.points
array([[-1.2 ,  0.5 ,  6.2 ],
       [ 1.65,  0.5 ,  6.2 ],
       [ 4.5 ,  0.5 ,  6.2 ],
       [-1.2 ,  7.3 ,  6.2 ],
       [ 1.65,  7.3 ,  6.2 ],
       [ 4.5 ,  7.3 ,  6.2 ],
       [-1.2 ,  0.5 ,  9.3 ],
       [ 1.65,  0.5 ,  9.3 ],
       [ 4.5 ,  0.5 ,  9.3 ],
       [-1.2 ,  7.3 ,  9.3 ],
       [ 1.65,  7.3 ,  9.3 ],
       [ 4.5 ,  7.3 ,  9.3 ]])

>>> mesh.cells
array([[ 0,  1,  4,  3,  6,  7, 10,  9],
       [ 1,  2,  5,  4,  7,  8, 11, 10]])

class felupe.Grid(*xi, indexing='ij', **kwargs)[source]#

Bases: Mesh

A grid shaped 3d-mesh with hexahedrons. Basically a wrapper for numpy.meshgrid() with default indexing="ij".

Parameters:

x1 (array_like) – 1-D arrays representing the coordinates of a grid.
x2 (array_like) – 1-D arrays representing the coordinates of a grid.
... (array_like) – 1-D arrays representing the coordinates of a grid.
xn (array_like) – 1-D arrays representing the coordinates of a grid.

Examples

>>> import numpy as np
>>> import felupe as fem
>>>
>>> x1 = np.linspace(0, 2, 3)**2
>>> x2 = np.sqrt(np.linspace(0, 1, 3))
>>>
>>> mesh = fem.mesh.Grid(x1, x2)
>>> mesh.plot().show()

../_images/mesh-1b1bf70444732ff9_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 9
  Number of cells:
    quad: 4

>>> mesh.points
array([[0.        , 0.        ],
       [1.        , 0.        ],
       [4.        , 0.        ],
       [0.        , 0.70710678],
       [1.        , 0.70710678],
       [4.        , 0.70710678],
       [0.        , 1.        ],
       [1.        , 1.        ],
       [4.        , 1.        ]])

>>> mesh.cells
array([[0, 1, 4, 3],
       [1, 2, 5, 4],
       [3, 4, 7, 6],
       [4, 5, 8, 7]])

See also

numpy.meshgrid: Return a list of coordinate matrices from coordinate vectors.

class felupe.Circle(radius=1.0, centerpoint=[0.0, 0.0], n=2, sections=[0, 90, 180, 270], value=0.15, exponent=2, decimals=10)[source]#

Bases: Mesh

A circular shaped 2d-mesh with quads and n points on the circumferential edge of a 45-degree section. 90-degree sections are placed at given angles in degree.

Parameters:

radius (float, optional) – Lower-left end point of the mesh (default is (0.0, 0.0)).
centerpoint (2-list of float, optional) – Coordinates of the origin where the circle is centered (default is [1.0, 1.0]).
n (int, optional) – Number of points per axis for a quarter of the embedded rectangle (default is 2).
sections (list of int or float, optional) – Rotation angles in deg where quarter circles (sections) are placed (default is [0, 90, 180, 270]).
value (float) – First shape parameter of the embedded rectangle (default is 0.15).
exponent (int) – Second shape parameter of the embedded rectangle (default is 2).
decimals (int) – Decimals used for rounding point coordinates to avoid non-connected sections (default is 10).

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.mesh.Circle()
>>> mesh.plot().show()

../_images/mesh-55f660ad17bb67d3_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 17
  Number of cells:
    quad: 12

>>> mesh.points
array([[-1.        ,  0.        ],
       [-0.70710678, -0.70710678],
       [-0.70710678,  0.70710678],
       [-0.5       ,  0.        ],
       [-0.425     , -0.425     ],
       [-0.425     ,  0.425     ],
       [ 0.        , -1.        ],
       [ 0.        , -0.5       ],
       [ 0.        ,  0.        ],
       [ 0.        ,  0.5       ],
       [ 0.        ,  1.        ],
       [ 0.425     , -0.425     ],
       [ 0.425     ,  0.425     ],
       [ 0.5       ,  0.        ],
       [ 0.70710678, -0.70710678],
       [ 0.70710678,  0.70710678],
       [ 1.        ,  0.        ]])

>>> mesh.cells
array([[12, 13, 16, 15],
       [15, 10,  9, 12],
       [ 8, 13, 12,  9],
       [ 5,  9, 10,  2],
       [ 2,  0,  3,  5],
       [ 8,  9,  5,  3],
       [ 4,  3,  0,  1],
       [ 1,  6,  7,  4],
       [ 8,  3,  4,  7],
       [11,  7,  6, 14],
       [14, 16, 13, 11],
       [ 8,  7, 11, 13]])

class felupe.mesh.Triangle(a=(0.0, 0.0), b=(1.0, 0.0), c=(0.0, 1.0), n=2, decimals=10)[source]#

Bases: Mesh

A triangular shaped 2d-mesh with quads and n points at the edges of the three sub-quadrilaterals.

Parameters:

a (2-tuple of float, optional) – First end point of the mesh (default is (0.0, 0.0)).
b (2-tuple of float, optional) – Second end point of the mesh (default is (1.0, 0.0)).
c (2-tuple of float, optional) – Third end point of the mesh (default is (0.0, 1.0)).
n (int, optional) – Number of points per axis is 2n - 1 if n >= 2 (default is 2).
decimals (int) – Decimals used for rounding point coordinates to avoid non-connected sections (default is 10).

Notes

If n < 2, a triangle mesh with a single triangle cell is created.

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.mesh.Triangle(a=(-0.1, 0.2), b=(1.2, 0.1), c=(0.1, 0.9), n=1)
>>> mesh.plot().show()

../_images/mesh-9d9e0a48a2190319_00_00.png

>>> import felupe as fem
>>>
>>> mesh = fem.mesh.Triangle(a=(-0.1, 0.2), b=(1.2, 0.1), c=(0.1, 0.9), n=2)
>>> mesh.plot().show()

../_images/mesh-daebb6d46c366a09_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 19
  Number of cells:
    quad: 12

>>> mesh.points
array([[0.1       , 0.9       ],
       [0.15      , 0.725     ],
       [0.2       , 0.55      ],
       [0.25      , 0.375     ],
       [0.3       , 0.2       ],
       [0.36666667, 0.475     ],
       [0.37083333, 0.5875    ],
       [0.375     , 0.7       ],
       [0.44583333, 0.325     ],
       [0.525     , 0.175     ],
       [0.53333333, 0.4       ],
       [0.59166667, 0.45      ],
       [0.64166667, 0.275     ],
       [0.65      , 0.5       ],
       [0.75      , 0.15      ],
       [0.78333333, 0.2875    ],
       [0.925     , 0.3       ],
       [0.975     , 0.125     ],
       [1.2       , 0.1       ]])

>>> mesh.cells
array([[14, 12,  8,  9],
       [12, 10,  5,  8],
       [ 9,  8,  3,  4],
       [ 8,  5,  2,  3],
       [18, 16, 15, 17],
       [16, 13, 11, 15],
       [17, 15, 12, 14],
       [15, 11, 10, 12],
       [10, 11,  6,  5],
       [11, 13,  7,  6],
       [ 5,  6,  1,  2],
       [ 6,  7,  0,  1]])

class felupe.mesh.RectangleArbitraryOrderQuad(a=(0.0, 0.0), b=(1.0, 1.0), order=2)[source]#

Bases: Rectangle

A rectangular 2d-mesh with an arbitrary-order Lagrange quad between a and b.

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.mesh.RectangleArbitraryOrderQuad(order=5).add_runouts()
>>> mesh.plot(
>>>     nonlinear_subdivision=4,
>>>     plotter=mesh.plot(style="points", color="black"),
>>> ).show()

../_images/mesh-d976a8cad0d5acae_00_00.png

class felupe.mesh.CubeArbitraryOrderHexahedron(a=(0.0, 0.0, 0.0), b=(1.0, 1.0, 1.0), order=2)[source]#

Bases: Cube

A rectangular 3d-mesh with an arbitrary-order Lagrange hexahedron between a and b.

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.mesh.CubeArbitraryOrderHexahedron(order=5).add_runouts()
>>> mesh.plot(
>>>     nonlinear_subdivision=4,
>>>     plotter=mesh.plot(style="points", color="black"),
>>> ).show()

../_images/mesh-8b8e79057c887683_00_00.png

felupe.mesh.add_midpoints_edges(points, cells, cell_type, cell_type_new=None)[source]#

Add midpoints on edges for given points and cells and update cell_type accordingly.

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.
cell_type_new (str or None, optional) – A string in VTK-convention that specifies the new cell type (default is None). If None, the cell type is chosen automatically.

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.

Examples

Convert a mesh of hexahedrons to quadratic hexahedrons by inserting midpoints on the cell edges.

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=6)
>>> mesh_with_midpoints_edges = fem.mesh.add_midpoints_edges(mesh)
>>>
>>> mesh_with_midpoints_edges.plot(
...     plotter=mesh.plot(), style="points", color="black"
... ).show()

../_images/mesh-514ee48fcb761204_00_00.png

>>> mesh_with_midpoints_edges
<felupe Mesh object>
  Number of points: 96
  Number of cells:
    quad8: 25

See also

felupe.Mesh.add_midpoints_edges: Add midpoints on edges for given points and cells and update cell_type accordingly.

felupe.mesh.add_midpoints_faces(points, cells, cell_type, cell_type_new=None)[source]#

Add midpoints on faces for given points and cells and update cell_type accordingly.

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.
cell_type_new (str or None, optional) – A string in VTK-convention that specifies the new cell type (default is None). If None, the cell type is chosen automatically.

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.

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=6)
>>> mesh_with_midpoints_faces = fem.mesh.add_midpoints_faces(
...     mesh, cell_type_new="quad"
... )
>>>
>>> plotter = mesh_with_midpoints_faces.plot(
...     plotter=mesh.plot(), style="points", color="black"
... ).show()

../_images/mesh-0ef8ee2e1510ef33_00_00.png

>>> mesh_with_midpoints_faces
<felupe Mesh object>
  Number of points: 61
  Number of cells:
    quad: 25

See also

felupe.Mesh.add_midpoints_faces: Add midpoints on faces for given points and cells and update cell_type accordingly.

felupe.mesh.add_midpoints_volumes(points, cells, cell_type, cell_type_new=None)[source]#

Add midpoints on volumes for given points and cells and update cell_type accordingly.

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.
cell_type_new (str or None, optional) – A string in VTK-convention that specifies the new cell type (default is None). If None, the cell type is chosen automatically.

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.

Examples

>>> import felupe as fem
>>> import pyvista as pv
>>>
>>> mesh = fem.Cube(n=6)
>>> mesh_with_midpoints_volumes = fem.mesh.add_midpoints_volumes(
...     mesh, cell_type_new="hexahedron9"
... )
>>> plotter = pv.Plotter()
>>> actor = plotter.add_points(mesh_with_midpoints_volumes.points, color="black")
>>> mesh.plot(opacity=0.5, plotter=plotter).show()

>>> mesh_with_midpoints_volumes
<felupe Mesh object>
  Number of points: 341
  Number of cells:
    hexahedron9: 125

See also

felupe.Mesh.add_midpoints_volumes: Add midpoints on volumes for given points and cells and update cell_type accordingly.

felupe.mesh.cell_types()[source]#

Return a list with tuples of identical cell types for different packages.

Examples

>>> import felupe as fem
>>>
>>> cell_types_array = fem.mesh.cell_types()

Create a dict which takes a FElupe cell type string and returns the PyVista cell type.

>>> cell_types_felupe_to_pyvista = dict(cell_types_array)
>>> cell_types_felupe_to_pyvista["line"]
<CellType.LINE: 3>

Create a dict which takes a PyVista cell type string and returns the FElupe cell type.

>>> import pyvista as pv
>>>
>>> cell_types_pyvista_to_felupe = dict(cell_types_array[:, [1, 0]])
>>> cell_types_pyvista_to_felupe[pv.CellType.LINE]
"line"

felupe.mesh.collect_edges(points, cells, cell_type)[source]#

Collect all unique edges, calculate and return midpoints on edges as well as the additional cells array.

See also

felupe.mesh.add_midpoints_edges: Add midpoints on cell edges for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_edges: Add midpoints on cell edges for given points and cells and update cell_type accordingly.

felupe.mesh.collect_faces(points, cells, cell_type)[source]#

Collect all unique faces, calculate and return midpoints on faces as well as the additional cells array.

See also

felupe.mesh.add_midpoints_faces: Add midpoints on cell faces for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_faces: Add midpoints on cell faces for given points and cells and update cell_type accordingly.

felupe.mesh.collect_volumes(points, cells, cell_type)[source]#

Collect all volumes, calculate and return midpoints on volumes as well as the additional cells array.

See also

felupe.mesh.add_midpoints_volumes: Add midpoints on cell volumes for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_volumes: Add midpoints on cell volumes for given points and cells and update cell_type accordingly.

felupe.mesh.concatenate(meshes)[source]#

Join a sequence of meshes with identical cell types.

Parameters:: meshes (list of Mesh) – A list with meshes.
Returns:: The joined mesh.
Return type:: Mesh

Notes

The points-arrays are vertically stacked. Offsets are added to the cells- arrays of the meshes to refer to the original points.

Examples

Two quad meshes should be joined (merged) into a single mesh.

>>> import felupe as fem
>>>
>>> rect1 = fem.Rectangle(n=11)
>>> rect2 = fem.Rectangle(a=(0.9, 0), b=(1.9, 1), n=11)
>>>
>>> mesh = fem.mesh.concatenate([rect1, rect2])
>>> mesh.plot(opacity=0.6).show()

Each mesh contains 121 points and 100 cells.

>>> rect1
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

>>> rect2
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

These two meshes are stored in a Mesh. Note that there are duplicate points and cells in the joined mesh.

>>> mesh
<felupe Mesh object>
  Number of points: 242
  Number of cells:
    quad: 200

felupe.mesh.convert(points, cells, cell_type, order=0, calc_points=False, calc_midfaces=False, calc_midvolumes=False)[source]#

Convert a mesh to a given order. Only conversions to order=0 and order=2 are supported. This function supports meshes with cell types "triangle", "tetra", "quad" and "hexahedron".

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. Must be one of "triangle", "tetra", "quad" or "hexahedron".
order (int, optional) – The order of the converted mesh (default is 0). If 0, the points-array will be of shape (ncells, dim). If 0 and calc_points is True, the mean of all points per cell is evaluated. If 0 and calc_points is False, the points array is filled with zeros. If 2, at least midpoints on cell edges are added to the mesh. If 2 and calc_midfaces is True, midpoints on cell faces are also added. If 2 and calc_midvolumes is True, midpoints on cell volumes are also added. Raises an error if not 0 or 2.
calc_points (bool, optional) – Flag to return the mean of all points per cell if order=0 (default is False). If False, the points-array is filled with zeros.
calc_midfaces (bool, optional) – Flag to add midpoints on cell faces if order=2 (default is False).
calc_midvolumes (bool, optional) – Flag to add midpoints on cell volumes if order=2 (default is False).

Returns:

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

Examples

Convert a mesh of hexahedrons to quadratic hexahedrons by inserting midpoints on the cell edges.

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=6)
>>> mesh2 = fem.mesh.convert(mesh, order=2)
>>>
>>> mesh2.plot(plotter=mesh.plot(), style="points", color="black").show()

../_images/mesh-80eed7d562403de2_00_00.png

>>> mesh2
<felupe Mesh object>
  Number of points: 96
  Number of cells:
    quad8: 25

See also

felupe.mesh.add_midpoints_edges: Add midpoints on edges for given points and cells and update cell_type accordingly.
felupe.mesh.add_midpoints_faces: Add midpoints on faces for given points and cells and update cell_type accordingly.
felupe.mesh.add_midpoints_volumes: Add midpoints on volumes for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_edges: Add midpoints on edges for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_faces: Add midpoints on faces for given points and cells and update cell_type accordingly.
felupe.Mesh.add_midpoints_volumes: Add midpoints on volumes for given points and cells and update cell_type accordingly.

felupe.mesh.dual(points, cells, cell_type, points_per_cell=None, disconnect=True, calc_points=False, offset=0, npoints=None)[source]#

Create a new dual mesh with given points per cell.

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.
points_per_cell (int or None, optional) – Number of points per cell, must be equal or lower than cells.shape[1] ( default is None). If None, all points per cell are considered for the dual mesh.
disconnect (bool, optional) – A flag to disconnect the mesh (each cell has its own points). Default is True.
calc_points (bool, optional) – A flag to calculate the point coordinates for the dual mesh (default is False). If False, the points array is filled with zeros.
offset (int, optional) – An offset to be added to the cells array (default is 0).
npoints (int or None, optional) – Number of points for the dual mesh. If the given number of points is greater than npoints * points_per_cell, then the missing points are added to the points array (filled with zeros). Default is None.

Returns:

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

Notes

Note

The points array of the dual mesh always has a shape of (npoints * points_per_cell, dim).

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=5).add_midpoints_edges()
>>> region = fem.RegionQuadraticQuad(mesh=mesh)
>>>
>>> mesh_dual = fem.mesh.dual(mesh, points_per_cell=1, disconnect=False)
>>> region_dual = fem.RegionConstantQuad(
...     mesh_dual, quadrature=region.quadrature, grad=False
... )
>>>
>>> displacement = fem.FieldPlaneStrain(region, dim=2)
>>> pressure = fem.Field(region_dual)
>>> field = fem.FieldContainer([displacement, pressure])

See also

felupe.Mesh.dual: Create a new dual mesh with given points per cell.

felupe.mesh.expand(points, cells, cell_type, n=11, z=1, axis=-1, expand_dim=True)[source]#

Expand a 0d-Point to a 1d-Line, 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. Must be greater or equal 0.
z (float or ndarray, optional) – Total expansion as float (edge length in expand direction is z / (n - 1)), default is 1. Optionally, if an array is passed these entries are taken as expansion and n is ignored.
axis (int, optional) – Axis of expansion (default is -1).
expand_dim (bool, optional) – Expand the dimension of the point coordinates (default is True).

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.

Examples

Expand a rectangle to a cube.

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(n=4)
>>> cube = fem.mesh.expand(rect, n=7, z=2)
>>>
>>> cube.plot().show()

../_images/mesh-5a892467d0b2fa07_00_00.png

>>> cube
<felupe Mesh object>
  Number of points: 112
  Number of cells:
    hexahedron: 54

See also

felupe.Mesh.expand: Expand a 0d-Point to a 1d-Line, a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh.

felupe.mesh.extrude(mesh, path, other_mesh=None)[source]#

Extrude a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh along a given path. Optionally, the section is interpolated between the mesh and another mesh.

Parameters:

mesh (felupe.Mesh) – A line- or quad-mesh (the section) in its position at the start of the path.
path (felupe.Mesh or ndarray) – A line-mesh or an array of point coordinates, which defines the path. The points of the path define the positions of the extruded sections. The cells of a line-mesh must be ordered consecutively along the path.
other_mesh (felupe.Mesh or None, optional) – Another line- or quad-mesh with equal cells and number of points, also located at the start of the path (default is None). If given, the section is linearly interpolated between the mesh (at the start) and the other mesh (at the end of the path) w.r.t. the normalized arc length of the path.

Returns:

The extruded mesh.

Return type:

felupe.Mesh

Notes

The section is transported along the path by rotation-minimizing frames [1]_, i.e. the section is not twisted around the path. The section is not required to be perpendicular to the path. Instead, the (initial) orientation of the section w.r.t. the tangent of the path is preserved. The tangents are evaluated as the normalized mean of the two adjacent segment directions at each point of the path. For each point \(\boldsymbol{p}_i\) of the path, the points of the section are given by Eq. (5)

(5)#\[\boldsymbol{x}_i = \boldsymbol{p}_i + \boldsymbol{Q}_i \left( \boldsymbol{X} - \boldsymbol{p}_0 \right)\]

where \(\boldsymbol{Q}_i\) is the rotation matrix from the frame at the start to the frame at the \(i\)-th point of the path.

Note

The mesh must be located at the start of the path. The path must not contain duplicate consecutive points. Duplicate points of closed paths are not merged.

If the mesh is a line-mesh and both the mesh and the path are embedded in 2d-space, the extruded quad-mesh is also embedded in 2d-space. Otherwise, the extruded mesh is embedded in 3d-space. The cells of the extruded mesh are flipped, if required, to ensure positive cell volumes (for meshes embedded in 2d-space with quads and for hexahedrons).

Examples

Extrude a circular section along a helix. The section is not perpendicular to the path, it is tilted by 20 degrees.

>>> import numpy as np
>>> import felupe as fem
>>>
>>> phi = np.linspace(0, 4 * np.pi, 97)
>>> path = fem.mesh.Line(n=97)
>>> path.update(points=np.vstack([np.cos(phi), np.sin(phi), phi / 8]).T)
>>>
>>> section = (
...     fem.Circle(radius=0.2, n=4)
...     .expand(n=1)
...     .rotate(90, axis=0)
...     .rotate(20, axis=2)
...     .translate(1, axis=0)
... )
>>> mesh = fem.mesh.extrude(section, path)
>>>
>>> mesh.plot().show()

../_images/mesh-f1ee2cdee9519ce3_00_00.png

Optionally, the section may be interpolated between two sections with equal cells. Both sections are located at the start of the path.

>>> import numpy as np
>>> import felupe as fem
>>>
>>> phi = np.linspace(0, np.pi / 2, 21)
>>> path = fem.mesh.Line(n=21)
>>> path.update(points=2 * np.vstack([np.cos(phi), np.sin(phi)]).T)
>>>
>>> section = fem.mesh.Line(a=1.8, b=2.2, n=5)
>>> section.update(points=np.pad(section.points, ((0, 0), (0, 1))))
>>> other_section = fem.mesh.Line(a=1.5, b=2.5, n=5)
>>> other_section.update(points=np.pad(other_section.points, ((0, 0), (0, 1))))
>>>
>>> mesh = fem.mesh.extrude(section, path, other_section)
>>>
>>> mesh.plot().show()

../_images/mesh-6e56fab4e04af9b6_00_00.png

References

See also

felupe.Mesh.extrude: Extrude a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh along a given path.
felupe.mesh.expand: Expand a 0d-Point to a 1d-Line, a 1d-Line to a 2d-Quad or a 2d-Quad to a 3d-Hexahedron Mesh.
felupe.mesh.fill_between: 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.
felupe.mesh.interpolate_line: Return an interpolated line mesh from an existing line mesh with provided interpolation points on a given axis.

felupe.mesh.fill_between(mesh, other_mesh, n=11)[source]#

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

Examples

>>> import felupe as fem
>>>
>>> inner = fem.mesh.revolve(fem.Point(1)).expand(z=0.4).translate(0.2, axis=2)
>>> outer = fem.mesh.revolve(fem.Point(2), phi=160).rotate(
...     axis=2, angle_deg=20
... ).expand(z=1.2)
>>> mesh = fem.mesh.fill_between(inner, outer, n=6)
>>>
>>> mesh.plot().show()

../_images/mesh-a71536b1e7545a67_00_00.png

See also

felupe.Mesh.fill_between: 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.

felupe.mesh.flip(points, cells, cell_type, mask=None)[source]#

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, ndarray or None, optional) – Boolean mask for selected cells to flip (default is None). If None, all cells are selected to be flipped.

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.

Examples

A quad mesh with negative cell volumes occurs if one coordinate axis is multiplied by -1. The error pops up if a region is created with this mesh.

>>> import numpy as np
>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=3)
>>> mesh.update(points=mesh.points * np.array([[-1, 1]]))
>>> region = fem.RegionQuad(mesh)

The sum of the differential volumes \(V = \sum_c \sum_q dV_{qc}\) is evaluated to -1.0.

>>> region.dV.sum()
-1.0

Let’s try to fix the mesh.

>>> mesh.cells
array([[0, 1, 4, 3],
       [1, 2, 5, 4],
       [3, 4, 7, 6],
       [4, 5, 8, 7]])

The cells array is rearranged to ensure positive cell volumes.

>>> mesh_fixed = fem.mesh.flip(mesh)
>>> mesh_fixed.cells
array([[3, 4, 1, 0],
       [4, 5, 2, 1],
       [6, 7, 4, 3],
       [7, 8, 5, 4]])

A region now correctly evaluates the total volume of the mesh to 1.0.

>>> region_fixed = fem.RegionQuad(mesh_fixed)
>>> region_fixed.dV.sum()
1.0

See also

felupe.Mesh.flip: Ensure positive cell volumes for tria, tetra, quad and hexahedron cell types.

felupe.mesh.interpolate_line(mesh, xi, axis=None, Interpolator=None, **kwargs)[source]#

Return an interpolated line mesh from an existing line mesh with provided interpolation points on a given axis.

Parameters:

mesh (Mesh) – A Mesh with cell-type line.
xi (ndarray) – Points at which to interpolate data. If axis is None, a normalized curve- progress must be provided (\(0 \le \xi \le 1\)).
axis (int or None, optional) – The axis of the points at which the data will be interpolated. If None, a normalized curve-progress is used. Default is None.
Interpolator (callable or None, optional) – An interpolator class (default is scipy.interpolate.PchipInterpolator).
**kwargs (dict, optional) – Optional keyword arguments are passed to the Interpolator.

Returns:

A new line mesh with interpolated points. The attribute points_derivative holds the derivatives of the independent variable w.r.t. the dependent variable(s).

Return type:

Mesh

Examples

>>> import felupe as fem
>>> import numpy as np
>>> from scipy.interpolate import CubicSpline
>>>
>>> mesh = fem.mesh.Line(b=1.0, n=5).expand(n=1)
>>> t = mesh.x.copy()
>>> mesh.points[:, 0] = np.sin(2 * np.pi * t)
>>> mesh.points[:, 1] = np.cos(2 * np.pi * t)
>>>
>>> mesh_new = fem.mesh.interpolate_line(
...     mesh, xi=np.linspace(0, 1), Interpolator=CubicSpline, bc_type="periodic"
... )
>>>
>>> mesh_new.plot(
...     plotter=mesh.plot(style="points", color="red", point_size=15),
...     color="black",
... ).show()

../_images/mesh-2074d311411c7305_00_00.png

felupe.mesh.merge_duplicate_cells(points, cells, cell_type)[source]#

Merge duplicate cells of a 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.

Returns:

points (ndarray) – Point coordinates.
cells (list or ndarray) – Cells with merged duplicate cells.
cell_type (str or None) – A string in VTK-convention that specifies the cell type.

Notes

Warning

This function re-sorts cells.

Note

This function does not merge duplicate points.

Examples

Two quad meshes to be merged overlap some cells. Merge these duplicated points and update the cells.

>>> import felupe as fem
>>>
>>> rect1 = fem.Rectangle(n=11)
>>> rect2 = fem.Rectangle(a=(0.9, 0), b=(1.9, 1), n=11)
>>>
>>> container = fem.MeshContainer([rect1, rect2])
>>> stack = fem.mesh.stack(container.meshes)
>>> mesh = fem.mesh.merge_duplicate_points(stack)
>>>
>>> mesh.plot(opacity=0.6).show()

Each mesh contains 121 points and 100 cells.

>>> rect1
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

>>> rect2
<felupe Mesh object>
    Number of points: 121
    Number of cells:
    quad: 100

These two meshes are now stored in a MeshContainer.

>>> container
<felupe mesh container object>
Number of points: 242
Number of cells:
    quad: 100
    quad: 100

The meshes of the mesh container are stacked.

>>> stack
<felupe Mesh object>
Number of points: 242
Number of cells:
    quad: 200

After merging the duplicated points and cells, the number of points is reduced but the number of cells is unchanged.

>>> mesh
<felupe Mesh object>
Number of points: 220
Number of cells:
    quad: 200

Note

The MeshContainer may be directly created with merge=True. This enforces merge_duplicate_points() for the shared points array of the container.

The duplicate cells are merged in a second step.

>>> merged = fem.mesh.merge_duplicate_cells(mesh)
>>> merged
<felupe Mesh object>
Number of points: 220
Number of cells:
    quad: 190

See also

felupe.Mesh.merge_duplicate_points: Merge duplicate points of a Mesh.
felupe.Mesh.merge_duplicate_cells: Merge duplicate cells of a Mesh.
felupe.MeshContainer: A container which operates on a list of meshes with identical dimensions.

felupe.mesh.merge_duplicate_points(points, cells, cell_type, decimals=None)[source]#

Merge duplicate points and update cells of a 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.
decimals (int or None, optional) – Number of decimals for point coordinate comparison (default is None).

Returns:

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

Notes

Warning

This function re-sorts points.

Note

This function does not merge duplicate cells.

Examples

Two quad meshes to be merged overlap some points. Merge these duplicated points and update the cells.

>>> import felupe as fem
>>>
>>> rect1 = fem.Rectangle(n=11)
>>> rect2 = fem.Rectangle(a=(0.9, 0), b=(1.9, 1), n=11)
>>>
>>> container = fem.MeshContainer([rect1, rect2])
>>> stack = fem.mesh.stack(container.meshes)
>>> mesh = fem.mesh.merge_duplicate_points(stack)
>>>
>>> mesh.plot(opacity=0.6).show()

Each mesh contains 121 points and 100 cells.

>>> rect1
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

>>> rect2
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

These two meshes are now stored in a MeshContainer.

>>> container
<felupe mesh container object>
  Number of points: 242
  Number of cells:
    quad: 100
    quad: 100

The meshes of the mesh container are stacked.

>>> stack
<felupe Mesh object>
  Number of points: 242
  Number of cells:
    quad: 200

After merging the duplicated points and cells, the number of points is reduced but the number of cells is unchanged.

>>> mesh
<felupe Mesh object>
  Number of points: 220
  Number of cells:
    quad: 200

Note

The MeshContainer may be directly created with merge=True. This enforces merge_duplicate_points() for the shared points array of the container.

See also

felupe.Mesh.merge_duplicate_points: Merge duplicated points and update cells of a Mesh.
felupe.MeshContainer: A container which operates on a list of meshes with identical dimensions.

felupe.mesh.mirror(points, cells, cell_type, normal=[1, 0, 0], centerpoint=[0, 0, 0], axis=None)[source]#

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.

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Circle(sections=[0, 90, 180], n=5)
>>> mesh.plot().show()

>>> import felupe as fem
>>>
>>> mesh = fem.Circle(sections=[0, 90, 180], n=5)
>>> fem.mesh.mirror(mesh, normal=[0, 1, 0]).plot().show()

../_images/mesh-17557dbb3dc358d9_00_00.png

See also

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

felupe.mesh.read(filename, file_format=None, cellblock=None, dim=None, merge=False, decimals=None)[source]#

Read a mesh from a file using meshio.read() and create a MeshContainer.

Parameters:

filename (str) – The filename of the mesh file.
file_format (str or None, optional) – The file format of the mesh file (default is None).
cellblock (list of int or None, optional) – Read only a subset of the cellblocks from the mesh file (default is None). If None, all cell blocks are added to the MeshContainer.
dim (int or None, optional) – If provided, the dimension to trim the points array to (default is None). If None, the points array is unchanged.
merge (bool, optional) – Flag to merge duplicate mesh points. This changes the cells arrays of the meshes. Default is False.
decimals (float or None, optional) – Precision decimals for merging duplicated mesh points. Only relevant if merge=True. Default is None.

Returns:

A mesh container created with meshio.read().

Return type:

MeshContainer

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=3)
>>> mesh.write(filename="mesh.xdmf")

>>> container = fem.mesh.read("mesh.xdmf")
>>> container
<felupe mesh container object>
  Number of points: 9
  Number of cells:
    quad: 4

>>> container.meshes[0]
<felupe Mesh object>
  Number of points: 9
  Number of cells:
    quad: 4

See also

meshio.read: Reads an unstructured mesh with added data.
felupe.Mesh.write: Write the mesh to a file.

felupe.mesh.revolve(points, cells, cell_type, n=11, phi=180, axis=0, expand_dim=True)[source]#

Revolve a 0d-Point to a 1d-Line, a 1d-Line to 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 revolutions (or (n-1) cell revolutions), default is 11.
phi (float or ndarray, optional) – Revolution angle in degree (default is 180).
axis (int, optional) – Revolution axis (default is 0).
expand_dim (bool, optional) – Expand the dimension of the point coordinates (default is True).

Returns:

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

Examples

Revolve a cylinder from a rectangle.

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(a=(0, 4), b=(3, 5), n=(10, 4))
>>> mesh = fem.mesh.revolve(rect, n=11, phi=180, axis=0)
>>> mesh.plot().show()

../_images/mesh-b6ce0a8fbd4b18b3_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 440
  Number of cells:
    hexahedron: 270

See also

felupe.Mesh.revolve: Revolve a 2d-Quad to a 3d-Hexahedron Mesh.

felupe.mesh.rotate(points, cells, cell_type, angle_deg, axis, center=None, mask=None)[source]#

Rotate a 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.
angle_deg (int) – Rotation angle in degree.
axis (int) – Rotation axis.
center (list or ndarray or None, optional) – Center point coordinates (default is None).
mask (ndarray or None, optional) – A boolean mask to select points which are rotated (default is None).

Returns:

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

Examples

Rotate a rectangle in the xy-plane by 35 degree.

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(b=(3, 1), n=(10, 4))
>>> mesh = fem.mesh.rotate(rect, angle_deg=35, axis=2, center=[1.5, 0.5])
>>> mesh.plot().show()

../_images/mesh-80ec598f031bf18b_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 40
  Number of cells:
    quad: 27

See also

felupe.Mesh.rotate: Rotate a Mesh.

felupe.mesh.runouts(points, cells, cell_type, values=[0.1, 0.1], centerpoint=[0, 0, 0], axis=0, exponent=5, mask=slice(None, None, None), normalize=False)[source]#

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.

Examples

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(a=(-3, -1), b=(3, 1), n=(31, 11))
>>> mesh = fem.mesh.runouts(rect, axis=1, values=[0.2], normalize=True)
>>>
>>> mesh.plot().show()

../_images/mesh-5110f9c87b78df22_00_00.png

>>> import felupe as fem
>>>
>>> cube = fem.Cube(a=(-3, -2, -1), b=(3, 2, 1), n=(31, 21, 11))
>>> mesh = fem.mesh.runouts(cube, axis=2, values=[0.1, 0.3], normalize=True)
>>>
>>> mesh.plot().show()

../_images/mesh-f4ef1ccf1844441d_00_00.png

See also

felupe.Mesh.add_runouts: Add simple rubber-runouts for realistic rubber-metal structures.

felupe.mesh.stack(meshes)[source]#

Stack cell-blocks from meshes with identical points-array and cell-types.

Parameters:: meshes (list of Mesh) – A list with meshes. The points-array is taken from the first mesh in the list.
Returns:: The stacked mesh.
Return type:: Mesh

Notes

The points-array is taken from the first mesh. The points-arrays of all meshes must be identical. The cells-array of the stacked mesh is created by a vertical stack of the cells-arrays.

Examples

Two quad meshes with identical point arrays should be stacked into a single mesh.

>>> import felupe as fem
>>>
>>> mesh = fem.Rectangle(n=11)
>>> rect1, rect2 = mesh.copy(), mesh.copy()
>>> rect1.update(cells=mesh.cells[: 40])
>>> rect2.update(cells=mesh.cells[-50:])
>>>
>>> mesh = fem.mesh.stack([rect1, rect2])
>>> mesh.plot().show()

../_images/mesh-78c2e596304cf990_00_00.png

>>> mesh
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 90

See also

felupe.MeshContainer.stack: Stack cell-blocks with same cell-types into a single mesh.

felupe.mesh.subdivide(points, cells, cell_type)[source]#

Subdivide cells by adding midpoints on edges, faces and volumes.

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.

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.

Examples

Take a rectangle mesh and subdivide it two times.

>>> import felupe as fem
>>>
>>> rect = fem.Rectangle(n=4).modify_corners()
>>> rect.plot().show()

>>> mesh = fem.mesh.subdivide(fem.mesh.subdivide(rect))
>>> mesh.plot().show()

../_images/mesh-b2071fb1675db370_00_00.png

See also

felupe.Mesh.subdivide: Subdivide cells by adding midpoints on edges, faces and volumes.

felupe.mesh.sweep(points, cells, cell_type, decimals=None)#

Merge duplicate points and update cells of a 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.
decimals (int or None, optional) – Number of decimals for point coordinate comparison (default is None).

Returns:

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

Notes

Warning

This function re-sorts points.

Note

This function does not merge duplicate cells.

Examples

Two quad meshes to be merged overlap some points. Merge these duplicated points and update the cells.

>>> import felupe as fem
>>>
>>> rect1 = fem.Rectangle(n=11)
>>> rect2 = fem.Rectangle(a=(0.9, 0), b=(1.9, 1), n=11)
>>>
>>> container = fem.MeshContainer([rect1, rect2])
>>> stack = fem.mesh.stack(container.meshes)
>>> mesh = fem.mesh.merge_duplicate_points(stack)
>>>
>>> mesh.plot(opacity=0.6).show()

Each mesh contains 121 points and 100 cells.

>>> rect1
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

>>> rect2
<felupe Mesh object>
  Number of points: 121
  Number of cells:
    quad: 100

These two meshes are now stored in a MeshContainer.

>>> container
<felupe mesh container object>
  Number of points: 242
  Number of cells:
    quad: 100
    quad: 100

The meshes of the mesh container are stacked.

>>> stack
<felupe Mesh object>
  Number of points: 242
  Number of cells:
    quad: 200

After merging the duplicated points and cells, the number of points is reduced but the number of cells is unchanged.

>>> mesh
<felupe Mesh object>
  Number of points: 220
  Number of cells:
    quad: 200

Note

The MeshContainer may be directly created with merge=True. This enforces merge_duplicate_points() for the shared points array of the container.

See also

felupe.Mesh.merge_duplicate_points: Merge duplicated points and update cells of a Mesh.
felupe.MeshContainer: A container which operates on a list of meshes with identical dimensions.

felupe.mesh.translate(points, cells, cell_type, move, axis)[source]#

Translate (move) a Mesh along a given axis.

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.
move (float) – Translation along given axis.
axis (int) – Translation axis.

Returns:

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

Examples

>>> import felupe as fem
>>>
>>> mesh = fem.Circle(n=6)
>>> mesh.points.min(axis=0), mesh.points.max(axis=0)
(array([-1., -1.]), array([1., 1.]))

>>> translated = fem.mesh.translate(mesh, 0.3, axis=1)
>>> translated.points.min(axis=0), translated.points.max(axis=0)
(array([-1. , -0.7]), array([1. , 1.3]))

See also

felupe.Mesh.translate: Translate (move) a Mesh along a given axis.

felupe.mesh.triangulate(points, cells, cell_type, mode=3)[source]#

Triangulate a quad or a hex 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.
mode (int, optional) – Choose a mode how to convert hexahedrons to tets [1]_ (default is 3).

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.

Examples

Use mode=0 to convert a mesh of hexahedrons into tetrahedrons [1]_.

>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=6)
>>> triangulated = fem.mesh.triangulate(mesh, mode=0)
>>> triangulated.plot().show()

../_images/mesh-22f5594aeee8dcf1_00_00.png

Use mode=3 to convert a mesh of hexahedrons into tetrahedrons [1]_.

>>> import felupe as fem
>>>
>>> mesh = fem.Cube(n=6)
>>> triangulated = fem.mesh.triangulate(mesh, mode=3)
>>> triangulated.plot().show()

../_images/mesh-86916fb4032aef08_00_00.png

References

See also

felupe.Mesh.triangulate: Triangulate a quad or a hex mesh.