pysdic.assemble_property_interpolation

assemble_property_interpolation(property_array, connectivity, element_indices, shape_functions, *, skip_m1=True, default=nan)

Interpolate a property defined at the nodes of a mesh to given integration points within elements using precomputed shape functions .

interpolated_properties[i] contains the interpolated property at the integration point \(i\).

Note

• Inputs property_array and shape_functions 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:

• property_array (ArrayLike) – An array of shape \((N_{v}, P)\) containing the property values defined at the nodes of the mesh. If 1D-array is provided, it will be treated as a single-component property of shape \((N_{v}, 1)\).

• 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.

• shape_functions (ArrayLike) – An array of shape \((N_{p}, N_{vpe})\) containing the shape function values evaluated at \(N_{p}\) points for the \(N_{vpe}\) nodes of the element.

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

• default (Union[Real, ArrayLike], optional) – The default value to assign to interpolated properties for integration points associated with an element index of -1 when skip_m1 is True. Default is numpy.nan. The input can also be a numpy.ndarray of shape (P,) to assign different default values for each property component.

Returns:

interpolated_properties – An array of shape \((N_{p}, P)\) containing the interpolated property values at each of the \(N_{p}\) integration points.

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 interpolated property array has shape \((N_{p}, P)\) where \(P\) is the number of property components (e.g., 1 for scalar properties, 3 for vector properties).

The property at each integration point is computed as:

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

where \(N_i\) are the shape functions associated with each node, and \(P_i\) are the property values at the nodes of the element.

See also

pysdic.compute_shape_functions

To compute the shape functions at given natural coordinates within elements.

pysdic.compute_property_interpolation

To compute the property interpolation directly from mesh and integration point information.

pysdic.assemble_property_interpolation

To project properties defined at integration points back to the nodes of the mesh.

Examples

Lets construct a simple 2D mesh and interpolate a scalar property at given integration points for triangular elements.

import numpy
from pysdic import (
    compute_shape_functions,
    assemble_property_interpolation
)

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])

property_array = numpy.array([10.0, 20.0, 30.0, 40.0])  # Scalar property

shape_functions = compute_shape_functions(
    natural_coordinates=natural_coordinates,
    element_type='triangle_3',
    return_derivatives=False
)

interpolated_props = assemble_property_interpolation(
    property_array=property_array,
    connectivity=connectivity,
    element_indices=element_indices,
    shape_functions=shape_functions
)

print(f"interpolated properties (shape={interpolated_props.shape}):")
print(interpolated_props)

interpolated properties (shape=(2, 1)):
[[18.  ]
 [28. ]]