3. Geometric representation of computational domains

Every geometric deep learning model for stress and displacement prediction begins with a decision that is easy to overlook but hard to reverse: how the computational domain is represented. A displacement field u(x) and a stress tensor field σ(x) are continuous functions over a physical body, yet a neural network can only consume discrete, finite data. The representation you choose determines which operators are available, how boundary conditions are enforced, how well the model generalizes across geometries, and what kind of supervision you can realistically obtain. This chapter compares the four dominant representations — meshes, point clouds, graphs, and implicit functions — from the perspective of field learning rather than classical numerical analysis.

What Each Representation Actually Stores

A mesh stores a simplicial or polyhedral decomposition: vertex coordinates, element connectivity, and per-entity field values (nodal displacements, element-wise stresses, quadrature-point outputs). Its defining strength is that it carries a discrete differential structure. On a triangle with vertices i, j, k, the constant strain is obtained from the gradient of the linear shape functions, so stress can be recovered from nodal displacement by a fixed linear operator B:

# Constant-strain triangle: strain from nodal displacement
# B is 3x6 for 2D plane stress; u_e = [u_ix, u_iy, u_jx, u_jy, u_kx, u_ky]
# A = signed area of the triangle
B = (1 / (2 * A)) * np.array([
    [y_j - y_k, 0,        y_k - y_i, 0,        y_i - y_j, 0       ],
    [0,        x_k - x_j, 0,        x_i - x_k, 0,        x_j - x_i],
    [x_k - x_j, y_j - y_k, x_i - x_k, y_k - y_i, x_j - x_i, y_i - y_j]
])
strain = B @ u_e            # [ε_xx, ε_yy, γ_xy]
stress = D @ strain         # D = elastic constitutive matrix

This is why mesh-based models can be trained with physics-informed losses that are genuinely consistent with finite-element semantics: the discrete gradient, divergence, and Laplacian are exact for the chosen basis. The cost is rigidity — a mesh is tied to one topology, and transferring a trained model to a new geometry usually requires remeshing and re-projection.

A point cloud stores only coordinates (and optionally per-point features such as displacement or stress sampled from a solver). It is the natural output of mesh-free solvers, LiDAR scans, digital image correlation, and particle methods. Point clouds are permutation-invariant and topology-free, which makes them attractive for learned models, but they carry no connectivity, so differential operators must be approximated — for example with k-nearest-neighbor graphs, local polynomial fits, or learned attention kernels. A point cloud is best understood as a sampling of the underlying field, and its fidelity depends on sampling density relative to the field's spatial frequency.

A graph generalizes both: nodes carry features, edges carry relational structure. A mesh converted to a graph (nodes = vertices, edges = element edges) is a special case, but graphs also represent trusses, frame structures, contact networks, and coarse-grained subdomains. Message passing on a graph is the discrete analogue of a local stencil, and the number of propagation steps controls the receptive field — a direct lever on whether the model can capture long-range stress redistribution around a stress concentration.

An implicit function represents the domain as the zero level set of a scalar function, or represents the field itself as a coordinate network f_θ(x) → (u, σ). Signed distance functions (SDFs) and neural radiance-style coordinate MLPs fall here. Implicit representations are resolution-independent and can be evaluated at arbitrary query points, which makes them ideal for collocation-based physics losses and for handling complex or evolving boundaries. Their weakness is that they must learn or be given the geometry, and enforcing hard boundary conditions requires either architectural constraints or penalty terms.

Choosing a Representation for Field Learning

The decision is driven by three questions. First, what does the supervision look like? If your ground truth comes from a finite-element solver, you have nodal displacements and element stresses on a mesh — using that mesh directly avoids a lossy resampling step. If your data comes from experiments (DIC, strain gauges, ultrasonic measurements), you have scattered points and should treat the point cloud as primary. Second, do you need differential consistency? Physics-informed losses require derivatives of the predicted field with respect to coordinates. On a mesh, those derivatives are the discrete operators you already trust; on a point cloud, they are estimates with their own error; on an implicit function, they are exact autodiff derivatives of the network but only as good as the network's fit. Third, must the model transfer across geometries? Meshes and graphs are tied to a specific discretization; point clouds and implicit functions are not, which is why they dominate geometry-generalizing surrogates.

A practical pattern that appears repeatedly in the literature is a hybrid: represent the geometry implicitly (an SDF or a CAD kernel) for sampling and boundary queries, sample collocation or training points from it, and build a local graph or kNN structure over those points to supply the discrete operators. This gives resolution independence without giving up local differential structure.

Worked Example: The Same Plate in Four Representations

Consider a 200 mm × 100 mm steel plate (E = 210 GPa, ν = 0.3) with a central circular hole of radius 10 mm, loaded in tension along the long axis. The stress concentration at the hole rim is the quantity of interest. Here is how each representation would be prepared and what to watch for.

For the implicit case, the stress recovery is a direct application of automatic differentiation, and it is worth writing out because it clarifies what "physics-consistent" means here:

import torch

def stress_from_displacement(model, xy, E=210e3, nu=0.3):
    xy = xy.clone().requires_grad_(True)
    u = model(xy)                       # shape [N, 2]
    # Jacobian of displacement w.r.t. coordinates
    du = torch.autograd.grad(u, xy, grad_outputs=torch.ones_like(u),
                             create_graph=True)[0]   # [N, 2, 2]
    exx = du[:, 0, 0]
    eyy = du[:, 1, 1]
    gxy = du[:, 0, 1] + du[:, 1, 0]
    lam = E * nu / ((1 + nu) * (1 - 2 * nu))
    mu  = E / (2 * (1 + nu))
    sxx = lam * (exx + eyy) + 2 * mu * exx
    syy = lam * (exx + eyy) + 2 * mu * eyy
    sxy = mu * gxy
    return torch.stack([sxx, syy, sxy], dim=-1)

Note the sign and coordinate convention: x is the long axis, y the short axis, displacements positive along their respective axes, and tensile stress positive. Keep this convention identical in the mesh labels, the point-cloud features, and the implicit model's loss terms; a sign flip between representations is one of the most common and most confusing sources of training divergence in multi-representation pipelines.

The unifying view is that all four representations are discretizations of the same continuous field problem, and each one trades differential exactness against geometric flexibility. Meshes maximize exactness at the cost of topology lock-in; point clouds maximize flexibility at the cost of approximate operators; graphs sit between them and add explicit relational structure; implicit functions maximize query flexibility and give exact autodiff derivatives but require careful boundary enforcement. Choosing well means matching the representation to where your supervision comes from and to how much geometric variation the deployed model must absorb.