Mesh structures#

Mesh class #

class Mesh(vertices, connectivity, element_type=None)[source]#

A Mesh is a collection of vertices (PointCloud) associated with connectivity information (Connectivity) that defines the elements of the mesh.

The vertices are represented as a PointCloud instance with shape \((N_v, E)\), where \(N_v\) is the number of vertices (n_vertices) and \(E\) is the embedding dimension (n_dimensions). The connectivity is represented as a Connectivity instance with shape \((N_e, N_{vpe})\), where \(N_e\) is the number of elements (n_elements), and \(N_{vpe}\) is the number of vertices per element (n_vertices_per_element).

The coordinates of a point into the mesh can be accessed by the natural coordinates in the reference element. The number of natural coordinates \((\xi, \eta, \zeta, ...)\) depends on the type of element and is noted as \(K\) (the topological dimension of the element) accessible through the property n_topological_dimensions.

Lets consider a mesh with \(N_{vpe}\) vertices per element, and \(K\) natural coordinates. Lets \(X\) be the coordinates of a point in the mesh. The transformation from natural coordinates to global coordinates is given by:

\[X = \sum_{i=1}^{N_{vpe}} N_i(\xi, \eta, \zeta, ...) X_i\]

where \(N_i\) are the shape functions associated with each vertex, and \(X_i\) are the coordinates of the vertices of the element.

Instantiate and export Mesh object #

By default, the meshes are created from a set of vertices and connectivity. The vertices are represented as a pysdic.PointCloud object, and the connectivity is represented as a pysdic.Connectivity object. Mesh can also use the following methods to instantiate a Mesh object from different file formats.

`Mesh.from_meshio`(mesh[, element_type, ...])	Create a Mesh instance from a `meshio.Mesh` object.
`Mesh.from_npz`(filename[, element_type, ...])	Create a Mesh instance from a NPZ file.
`Mesh.from_vtk`(filename[, element_type, ...])	Create a Mesh instance from a VTK file (Only for 3D embedding dimension meshes \(E=3\)).

The Mesh class provides methods to export the mesh to various file formats.

`Mesh.to_meshio`([save_properties])	Convert the `Mesh` instance to a `meshio.Mesh` object (`element_type` must be defined).
`Mesh.to_npz`(filename[, save_properties])	Write the `Mesh` instance to a NPZ file.
`Mesh.to_vtk`(filename[, save_properties])	Write the `Mesh` instance to a VTK file (Only for 3D embedding dimension meshes \(E=3\)).

Accessing Mesh attributes #

The public attributes of a Mesh object can be accessed using the following properties:

`Mesh.connectivity`	[Get or Set] The connectivity of the mesh in a `Connectivity` instance.
`Mesh.vertices`	[Get or Set] The vertices of the mesh in an `PointCloud` instance.

For easier access to the vertices and connectivity information, the following properties are also available and are equivalent to the corresponding properties of the pysdic.PointCloud and pysdic.Connectivity objects:

`Mesh.coordinates`	[Get or Set] Alias for `self.points` property, returns the coordinates of the mesh vertices as a numpy array of shape (\(N_v\), \(E\)).
`Mesh.elements`	[Get or Set] The vertex indices of the mesh elements - alias for `self.connectivity.elements` property.
`Mesh.element_type`	[Get or Set] The element type of the mesh - alias for `self.connectivity.element_type` property.
`Mesh.n_dimensions`	[Get] The embedding dimension \(E\) of the mesh - alias for `self.vertices.n_dimensions` property.
`Mesh.n_elements`	[Get] The number of elements \(N_e\) in the mesh - alias for `self.connectivity.n_elements` property.
`Mesh.n_points`	[Get] Alias for `self.n_vertices` property, returns the number of vertices \(N_v\) in the mesh.
`Mesh.n_topological_dimensions`	[Get] The topological dimension \(K\) of the elements in the mesh - alias for `self.connectivity.n_topological_dimensions` property.
`Mesh.n_vertices`	[Get] The number of vertices \(N_v\) in the mesh - alias for `self.vertices.n_points` property.
`Mesh.n_vertices_per_element`	[Get] The number of vertices per element \(N_{vpe}\) in the mesh - alias for `self.connectivity.n_vertices_per_element` property.
`Mesh.points`	[Get or Set] The coordinates of the mesh vertices - alias for `self.vertices.points` property.

To ensure the integrity of the mesh, the following properties can be used:

`Mesh.copy`()	Create a deep copy of the Mesh instance.
`Mesh.validate`()	Validate the mesh by performing internal checks on vertices and connectivity.

Add, remove or modify vertices or connectivity of the Mesh objects #

The topology of the mesh can be modified using the following methods:

`Mesh.add_connectivity`(new_connectivity[, ...])	Add new elements to the mesh by appending new connectivity entries.
`Mesh.add_vertices`(new_vertices[, force_inplace])	Add new vertices to the mesh by appending new vertex coordinates.
`Mesh.get_used_vertices_mask`()	Get a boolean mask indicating which vertices are used in the connectivity of the mesh.
`Mesh.filter_connectivity`(mask[, force_inplace])	Filter the connectivity of the mesh by keeping only the elements corresponding to the True values in the mask.
`Mesh.filter_vertices`(mask[, force_inplace])	Filter the vertices of the mesh by keeping only the vertices corresponding to the True values in the mask, remove all the elements that are connected to the removed vertices and remap the vertices indices accordingly.
`Mesh.keep_connectivity`(element_indices[, ...])	Keep only the specified elements in the mesh by specifying their indices in the connectivity array.
`Mesh.keep_vertices`(vertex_indices[, ...])	Keep only the specified vertices in the mesh by specifying their indices in the vertices array, remove all the elements that are connected to the removed vertices and remap the vertices indices accordingly.
`Mesh.remove_connectivity`(element_indices[, ...])	Remove specified elements from the mesh by specifying their indices in the connectivity array.
`Mesh.remove_unused_vertices`([force_inplace])	Remove all unused vertices from the mesh, where unused vertices are defined as vertices that are not referenced in the connectivity of the mesh.
`Mesh.remove_vertices`(vertex_indices[, ...])	Remove specified vertices from the mesh by specifying their indices in the vertices array, remove all the elements that are connected to the removed vertices and remap the vertices indices accordingly.

Accessing and managing vertices and connectivity properties #

To access and manage the properties of vertices and connectivity, use the Mesh.vertices() and Mesh.connectivity() objects, which provide methods to compute and store properties related to the vertices and connectivity of the mesh. The vertices and connectivity properties are common to all meshes build on the same set of vertices and connectivity, and they are stored in PointCloud and Connectivity objects, respectively. The properties can be accessed and managed using the following methods:

# Example of accessing and managing vertices and connectivity properties
from pysdic import Mesh

# Create a simple mesh (this is just an example, replace with actual vertices and connectivity)
vertices = [[0, 0, 0], [1, 0, 0], [0, 1, 0]]
connectivity = [[0, 1, 2]]
mesh = Mesh(vertices=vertices, connectivity=connectivity)

# Access vertices properties
intensity = [1, 2, 3]  # Example property for vertices
mesh.vertices.set_property('intensity', intensity)
retrieved_intensity = mesh.vertices.get_property('intensity')

# Access connectivity properties
area = [0.5]  # Example property for connectivity
mesh.connectivity.set_property('area', area)
retrieved_area = mesh.connectivity.get_property('area')

Precomputed quantities of the mesh #

To perform geometric computations and property interpolations on the mesh, some quantities can be precomputed and stored in the mesh for later use. The precomputed quantities of the mesh are stored in a dictionary, and they can be accessed and managed using the following methods:

Warning

If any modification is made to the vertices or connectivity of the mesh, the precomputed properties may become invalid and should be cleared using Mesh.clear_precomputed() to avoid using outdated properties in subsequent computations. It is the responsibility of the user to ensure that the precomputed properties are consistent with the current state of the mesh, especially after any modifications to the vertices or connectivity.

`Mesh.get_precomputed`(key)	Get the value of a precomputed property stored in the mesh by its key.
`Mesh.list_precomputed`()	List all the keys of the precomputed properties that are currently stored in the mesh.
`Mesh.clear_precomputed`()	Clear all the precomputed properties stored in the mesh, removing all key-value pairs from the precomputed properties dictionary.

The method with precompute argument allows to compute a quantity and store it in the precomputed properties of the mesh for later use (or into IntegrationPoints). Set to True to store the computed quantity in the precomputed properties of the mesh, and set to False to compute the quantity without storing it in the precomputed properties of the mesh.

The precomputed quantities available are :

vertices_adjacency_matrix
elements_adjacency_matrix
vertices_neighborhood
elements_neighborhood

The mesh can be used to precompute quantities for IntegrationPoints as well such as:

integration_points_neighborhood
shape_functions
shape_function_derivatives

Compute connectivity and adjacency graphs #

The connectivity and adjacency graphs of a mesh can be computed using the following methods, which are based on Breadth-First Search (BFS) techniques. The connectivity graph represents the direct connections between vertices or elements in the mesh, while the adjacency graph represents the distances between vertices or elements in the mesh based on the connectivity.

`Mesh.compute_vertices_neighborhood`([...])	Compute the neighborhood of each vertex in the mesh, where the neighborhood of a vertex is defined as the set of vertices that are within a specified distance from the vertex in the connectivity of the mesh.
`Mesh.compute_elements_neighborhood`([...])	Compute the neighborhood of each element in the mesh, where the neighborhood of an element is defined as the set of elements that are within a specified distance from the element in the connectivity of the mesh.
`Mesh.compute_vertices_adjacency_matrix`([...])	Compute the vertices path distance matrix (adjacency matrix) from the connectivity of the mesh.
`Mesh.compute_elements_adjacency_matrix`([...])	Compute the elements adjacency matrix from the connectivity of the mesh.

Once computed and stored in the precomputed properties of the mesh, the neighborhood and adjacency graphs can be used to compute statistics of a property according to the adjacency (mean, median, std, …), as well as to perform geometric computations and property interpolations on the mesh.

`Mesh.compute_vertices_neighborhood_statistics`(...)	Compute the specified statistics for the given property array defined at the vertices of a mesh based on the neighborhood information for each vertex.
`Mesh.compute_elements_neighborhood_statistics`(...)	Compute the specified statistics for the given property array defined at the elements of a mesh based on the neighborhood information for each element.

Mesh geometric computations and interpolations #

Some methods are provided to perform geometric computations and property interpolations on Mesh objects:

`Mesh.compute_shape_functions`(integration_points)	Compute the shape functions and their first derivatives for the mesh elements at given `IntegrationPoints` (convenient method for `pysdic.compute_shape_functions()`).
`Mesh.compute_property_interpolation`(...[, ...])	Compute the interpolation of a property at given natural coordinates for specified elements in the mesh (convenient method for `pysdic.compute_property_interpolation()`).
`Mesh.compute_property_projection`(...[, ...])	Project a property defined at integration points within elements back to the vertices of a mesh using mesh and integration point information (convenient method for `pysdic.compute_property_projection()`).
`Mesh.compute_property_derivative`(...[, ...])	Compute the derivative of a property defined at the nodes of a mesh to given integration points within elements with respect to global coordinates \((x,y,z,...)\) from mesh and integration point information (convenient method for `pysdic.compute_property_derivative()`).

Visualize surface meshes #

The package pysdic provides functions to visualize 3D surface meshes using the Pyvista library. The element_type of the mesh must be set. Furthermore, before visualizing a mesh with a texture, make sure to have the uvmap defined.

`Mesh.uvmap`	[Get or Set] The UV mapping of each element in the mesh (only for surfacique meshes \(K=2\)).
`Mesh.visualize`([vertex_color, vertex_size, ...])	Visualize the mesh using PyVista (only for \(E \leq 3\) embbeded dimension), the mesh must have `element_type` set.

Element Type	Description
“segment_2”	2-node line element
“segment_3”	3-node line element
“triangle_3”	3-node triangular element
“triangle_6”	6-node triangular element
“quadrangle_4”	4-node quadrilateral element
“quadrangle_8”	8-node quadrilateral element

Mesh structures#

This Page