# Mesh¶

class dolfin.cpp.mesh.Mesh(*args, **kwargs)

A Mesh consists of a set of connected and numbered mesh entities. Both the representation and the interface are dimension-independent, but a concrete interface is also provided for standard named mesh entities:

Entity Dimension Codimension
Vertex 0
Edge 1
Face 2
Facet   1
Cell   0

When working with mesh iterators, all entities and connectivity are precomputed automatically the first time an iterator is created over any given topological dimension or connectivity. Note that for efficiency, only entities of dimension zero (vertices) and entities of the maximal dimension (cells) exist when creating a Mesh . Other entities must be explicitly created by calling init . For example, all edges in a mesh may be created by a call to mesh.init(1). Similarly, connectivities such as all edges connected to a given vertex must also be explicitly created (in this case by a call to mesh.init(0, 1)).

Friends: MeshEditor, MeshPartitioning, TopologyComputation, create_mesh.

Create a mesh from a filename or a geometry.

A mesh may be created from a given filename, which should contain mesh data stored in DOLFIN XML format:

mesh = Mesh("mesh.xml")


An empty mesh may be created as follows:

mesh = Mesh()


A copy of a mesh may be created as follows:

mesh_copy = Mesh(mesh)

bounding_box_tree()

Get bounding box tree for mesh. The bounding box tree is initialized and built upon the first call to this function. The bounding box tree can be used to compute collisions between the mesh and other objects. It is the responsibility of the caller to use (and possibly rebuild) the tree. It is stored as a (mutable) member of the mesh to enable sharing of the bounding box tree data structure.

Return type: std::shared_ptr< BoundingBoxTree > std::shared_ptr
cell_orientations()

Get the cell orientations set.

Returns
numpy.array(int)
Cell orientations
cells()

Get cell connectivity.

Returns
numpy.array(int)
Connectivity for all cells.
Example
>>> mesh = dolfin.UnitSquare(1,1)
>>> mesh.cells()
array([[0, 1, 3],
[0, 2, 3]])

clean()

Clean out all auxiliary topology data. This clears all topological data, except the connectivity between cells and vertices.

Return type: void
color()

Color the cells of the mesh such that no two neighboring cells share the same color. A colored mesh keeps a MeshFunction<std::size_t> named “cell colors” as mesh data which holds the colors of the mesh.

Parameters: coloring_type (std::string) – (std::string) Coloring type, specifying what relation makes two cells neighbors, can be one of “vertex”, “edge” or “facet”. const std::vector< std::size_t > & std::vector& The colors as a mesh function over the cells of the mesh.
coordinates()
• coordinates()

Get vertex coordinates.

Returns
numpy.array(float)

Coordinates of all vertices.

Example
>>> mesh = dolfin.UnitSquare(1,1)
>>> mesh.coordinates()
array([[ 0.,  0.],
[ 1.,  0.],
[ 0.,  1.],
[ 1.,  1.]])

data()

Get mesh data.

Return type: MeshData & MeshData & The mesh data object associated with the mesh.
domains()

Get mesh (sub)domains.

Return type: MeshDomains & MeshDomains The (sub)domains associated with the mesh.
geometry()

Get mesh geometry.

Return type: MeshGeometry & MeshGeometry The geometry object associated with the mesh.
ghost_mode()

Ghost mode used for partitioning. Possible values are same as parameters["ghost_mode"] . WARNING: the interface may change in future without deprecation; the method is now intended for internal library use.

Return type: std::string
hash()

Compute hash of mesh, currently based on the has of the mesh geometry and mesh topology.

Return type: std::size_t std::size_t A tree-hashed value of the coordinates over all MPI processes
hmax()

Compute maximum cell size in mesh, measured greatest distance between any two vertices of a cell.

Return type: double double The maximum cell size. The size is computed using Cell::h
hmin()

Compute minimum cell size in mesh, measured greatest distance between any two vertices of a cell.

Return type: double double The minimum cell size. The size is computed using Cell::h
init()

Compute connectivity between given pair of dimensions.

Parameters: d0 (std::size_t) – (std::size_t) Topological dimension. d1 (std::size_t) – (std::size_t) Topological dimension. void
init_cell_orientations()

Compute and initialize cell_orientations relative to a given global outward direction/normal/orientation. Only defined if mesh is orientable.

Parameters: Expression & global_normal (const) – (Expression ) A global normal direction to the mesh void
init_global()

Compute global indices for entity dimension dim.

Parameters: dim (std::size_t) – void
mpi_comm()

Mesh MPI communicator

Return type: MPI_Comm MPI_Comm
num_cells()

Get number of cells in mesh.

Return type: std::size_t std::size_t Number of cells.
num_edges()

Get number of edges in mesh.

Return type: std::size_t std::size_t Number of edges.
num_entities()

Get number of entities of given topological dimension.

Parameters: d (std::size_t) – (std::size_t) Topological dimension. std::size_t std::size_t Number of entities of topological dimension d.
num_entities_global()

Get global number of entities of given topological dimension.

Parameters: dim (std::size_t) – (std::size_t) Topological dimension. std::size_t std::size_t Global number of entities of topological dimension d.
num_faces()

Get number of faces in mesh.

Return type: std::size_t std::size_t Number of faces.
num_facets()

Get number of facets in mesh.

Return type: std::size_t std::size_t Number of facets.
num_vertices()

Get number of vertices in mesh.

Return type: std::size_t std::size_t Number of vertices.
order()

Order all mesh entities. See also: UFC documentation (put link here!)

Return type: void
ordered()

Check if mesh is ordered according to the UFC numbering convention.

Return type: bool bool The return values is true iff the mesh is ordered.
renumber_by_color()

Renumber mesh entities by coloring. This function is currently restricted to renumbering by cell coloring. The cells (cell-vertex connectivity) and the coordinates of the mesh are renumbered to improve the locality within each color. It is assumed that the mesh has already been colored and that only cell-vertex connectivity exists as part of the mesh.

Return type: Mesh Mesh
rmax()

Return type: double double The maximum of cells’ inscribed sphere radii
rmin()

Return type: double double The minimum of cells’ inscribed sphere radii
rotate()

Rotate mesh around a coordinate axis through center of mass of all mesh vertices

Parameters: angle (double) – (double) The number of degrees (0-360) of rotation. axis (std::size_t) – (std::size_t) The coordinate axis around which to rotate the mesh. void
scale()

Scale mesh coordinates with given factor. Arguments factor (double) The factor defining the scaling.

Parameters: factor (double) – void
smooth()

Smooth internal vertices of mesh by local averaging.

Parameters: num_iterations (std::size_t) – (std::size_t) Number of iterations to perform smoothing, default value is 1. void
smooth_boundary()

Smooth boundary vertices of mesh by local averaging.

Parameters: num_iterations (std::size_t) – (std::size_t) Number of iterations to perform smoothing, default value is 1. harmonic_smoothing (bool) – (bool) Flag to turn on harmonics smoothing, default value is true. void
snap_boundary()

Snap boundary vertices of mesh to match given sub domain.

Parameters: SubDomain & sub_domain (const) – (SubDomain ) A SubDomain object. harmonic_smoothing (bool) – (bool) Flag to turn on harmonics smoothing, default value is true. void
thisown

The membership flag

topology()

Get mesh topology.

Return type: MeshTopology & MeshTopology The topology object associated with the mesh.
translate()

Translate mesh according to a given vector.

Parameters: Point & point (const) – (Point ) The vector defining the translation. void
type()

Get mesh cell type.

Return type: CellType & CellType & The cell type object associated with the mesh.
ufl_cell()

Returns the ufl cell of the mesh.

ufl_coordinate_element()

Return the finite element of the coordinate vector field of this domain.

ufl_domain()

Returns the ufl domain corresponding to the mesh.

ufl_id()

Returns an id that UFL can use to decide if two objects are the same.