pysdic.remap_vertices_coordinates

remap_vertices_coordinates(vertices_coordinates, connectivity, element_indices, *, skip_m1=True, default=nan)

Remap the global coordinates of the vertices to given integration points within elements based on the element connectivity, and the remapped coordinates will have shape \((N_{p}, N_{vpe}, E)\).

remapped_coordinates[i] contains the global coordinates of the vertices for the element containing integration point \(i\).

Note

• Input vertices_coordinates will be converted to numpy.float64.

• Inputs connectivity and element_indices will be converted to numpy.int64.

Warning

No tests are performed to check if the inputs array are consistent (e.g., if the connectivity contains invalid vertex indices, …). Only shapes are validated. The behavior of the function is undefined in this case.

Important

When using -1 in element_indices for invalid elements, ensure to set skip_m1 to True to avoid indexing errors.

Parameters:

• vertices_coordinates (ArrayLike) – An array of shape \((N_{v}, E)\) containing the global coordinates of the vertices in the mesh.

• connectivity (ArrayLike) – An array of shape \((N_{e}, N_{vpe})\) defining the connectivity of the elements in the mesh, where each row contains the indices of the nodes that form an element.

• element_indices (ArrayLike) – An array of shape \((N_{p},)\) containing the indices of each element corresponding to the \(N_{p}\) integration points.

• skip_m1 (bool, optional) – If set to True, any element index of -1 in element_indices will result in the corresponding remapped coordinates being set to default. Default is True.

• default (Real, optional) – The default value to assign to remapped coordinates for integration points associated with an element index of -1 when skip_m1 is True. Default is numpy.nan.

Returns:

remapped_coordinates – An array of shape \((N_{p}, N_{vpe}, E)\) containing the remapped global coordinates of the vertices for each integration point within the elements.

Return type:

numpy.ndarray

Notes

In a space of dimension \(E\) with a mesh constituted of \(N_{e}\) elements and \(N_{v}\) nodes. The mesh is composed of \(K\)-dimensional elements (with \(K \leq E\)) defined by \(N_{vpe}\) nodes for each element.

For a given set of \(N_{p}\) integration points located within elements, the remapped coordinates array has shape \((N_{p}, N_{vpe}, E)\) where each entry corresponds to the global coordinates of the nodes associated with the element containing the integration point.

See also

pysdic.assemble_jacobian_matrix

To compute the Jacobian matrices for the transformation between natural and global coordinates.

Examples

Lets construct a simple 2D mesh and remap the vertex coordinates to given integration points for triangular elements.

import numpy
from pysdic import remap_vertices_coordinates

vertices_coordinates = numpy.array(
    [[0.0, 0.0],
     [1.0, 0.0],
     [1.0, 1.0],
     [0.0, 1.0]]
)

connectivity = numpy.array(
    [[0, 1, 2],
     [0, 2, 3]]
)

natural_coordinates = numpy.array(
    [[0.2, 0.3],
     [0.6, 0.2]]
)

element_indices = numpy.array([0, 1, 0])

remapped_coords = remap_vertices_coordinates(
    vertices_coordinates=vertices_coordinates,
    connectivity=connectivity,
    element_indices=element_indices
)

print(f"remapped coordinates (shape={remapped_coords.shape}):")
print(remapped_coords)

remapped coordinates (shape=(3, 3, 2)):
[[[0. 0.]
  [1. 0.]
  [1. 1.]]

 [[0. 0.]
  [1. 1.]
  [0. 1.]]]

 [[0. 0.]
  [1. 0.]
  [1. 1.]]]