2. Graph representations for crash structures

A physics-aware graph neural network is only as good as the graph it operates on. In crashworthiness simulation, the graph is not an abstract data structure invented for the model — it is a discrete abstraction of a physical body undergoing large deformation, contact, and energy absorption. Every design decision about nodes, edges, and features encodes an assumption about which physical interactions matter. This chapter establishes how to build that abstraction from a finite element (FE) crash model, covering node placement, edge construction from mesh connectivity and spatial proximity, and feature design for shell, solid, and joint components.

Nodes: Material Points versus Element Centroids

The first decision is what a node represents. Two conventions dominate, and they are not interchangeable.

Nodes as material points map graph nodes to FE mesh nodes — the vertices where displacement degrees of freedom live. This is the natural choice when the downstream task predicts nodal quantities: displacement histories, nodal forces, or per-node stress recovery. Because mesh nodes are shared between adjacent elements, connectivity is exact and no information is lost at element boundaries. The cost is resolution: a typical full-vehicle crash model contains millions of nodes, and a graph at that scale is impractical for message passing over many layers.

Nodes as element centroids collapse each element (or a small cluster of elements) into a single graph node located at its centroid. This reduces node count by roughly the element-to-node ratio — for a shell mesh of quad elements, approximately one node per element instead of one per vertex — and produces a more uniform spatial sampling. Centroid nodes are preferable when the prediction target is element-level (e.g., plastic strain, element deletion state, or internal energy density) or when the graph must be coarsened for tractability. The trade-off is that connectivity must be reconstructed: two elements sharing an edge become two centroid nodes joined by an edge, and the geometric fidelity of that edge depends on how the mapping is built.

In practice, a hybrid is common: use centroid nodes for the coarse global graph and retain material-point nodes only in regions of interest such as the front rail, bumper beam, or occupant compartment boundary. The choice should be driven by the prediction target, not by convenience.

Edges: Mesh Connectivity and Proximity

Edges define the message-passing topology. Two complementary construction rules are used together.

Connectivity edges are derived directly from the FE mesh: two nodes are connected if their corresponding elements share a face, edge, or vertex. For shell structures, adjacency across shared element edges captures the in-plane load path — the path along which axial crush and bending propagate. For solids, shared faces capture through-thickness and volumetric load transfer. Connectivity edges are exact, sparse, and physically meaningful: they follow the material, so as the structure deforms, the graph topology remains fixed while node features (positions, displacements) evolve. This fixed-topology property is what allows a GNN trained on one configuration to generalize across deformation states.

Proximity edges are added when physical interaction occurs without mesh adjacency. The canonical case is contact: a bumper beam and a rigid barrier, or two components that fold into each other during crush, are not connected in the mesh but exchange large forces. Proximity edges are built by a radius search — connect nodes within a distance r in the reference configuration, or dynamically within a distance threshold during simulation. The radius must be chosen relative to element size: too small and contact pairs are missed; too large and the graph becomes dense and message passing washes out local detail. A practical rule is r ≈ 1.5–2.0 × the characteristic element length, with a separate, larger radius reserved for known contact interfaces.

Connectivity and proximity edges should be tagged with distinct edge types so the GNN can learn type-specific message functions. A single homogeneous edge set conflates material load paths with contact interactions and degrades both.

Material-point nodes FE mesh vertices, shared DOFs exact connectivity, high node count Centroid nodes one node per element, coarsened element-level targets, tractable size Edge types connectivity (mesh) proximity (contact) tag edges by type for message passing Node feature channels by component type Shells thickness t, normal n membrane strain, curvature plastic strain, stress resultant position, velocity Solids volume, characteristic length deformation gradient F equivalent plastic strain pressure, deviatoric stress Joints spot weld / rivet / bolt type failure force, rupture state relative displacement connected part IDs

Feature Design for Shells, Solids, and Joints

Node features must carry the physics the GNN needs to predict. A generic feature vector — position and displacement only — forces the network to rediscover constitutive behavior from scratch. Instead, features should be chosen per component type so that each node exposes the state variables that govern its response.

Shells dominate automotive crash structures: rails, pillars, bumper beams, and floor panels are thin-walled. A shell node should carry thickness t, the element normal n, membrane strain components, curvature, equivalent plastic strain, and the stress resultant. Thickness and normal are essential because shell bending stiffness scales with t³ and the normal defines the bending direction; omitting them makes the graph blind to the dominant energy-absorption mechanism. Position and velocity are included as geometric context.

Solids appear in cast nodes, engine mounts, and battery enclosures. Here the relevant state is volumetric: element volume or characteristic length, the deformation gradient F (or its invariants), equivalent plastic strain, and pressure/deviatoric stress split. The deformation gradient is particularly valuable because it encodes both stretch and rotation, letting the network distinguish tension from shear without inferring it from neighbor displacements.

Joints — spot welds, rivets, bolts, and adhesive bonds — are the weak links that govern crash mode. A joint node should carry the joint type (as a categorical embedding), the failure force or rupture state, relative displacement across the joint, and the IDs of the connected parts. Treating joints as ordinary nodes with only position features is a common error: the network then cannot learn that a weld failing at 4 kN changes the load path entirely.

All features should be normalized per channel (zero mean, unit variance over the training set) and, where physically meaningful, expressed in a local frame attached to the component rather than the global frame. This keeps the representation invariant to vehicle orientation and improves generalization across configurations.

A Practical Construction Recipe

The following sequence builds a crash graph from an LS-DYNA-style keyword model and is reproducible with standard Python tooling. It is illustrative; parameters are example values, not measured results.

# 1. Parse mesh: nodes (id, xyz), elements (id, type, node_ids)
# 2. Choose node convention
#    material points: node = mesh node
#    centroids:       node = mean(xyz of element nodes)
# 3. Build connectivity edges
#    shells: share an edge (2 common nodes)
#    solids: share a face (3 or 4 common nodes)
# 4. Build proximity edges
#    radius r = 1.8 * mean_element_length
#    query with a KD-tree; exclude existing connectivity pairs
# 5. Assign edge type: 0 = connectivity, 1 = proximity
# 6. Attach features per component type (shell / solid / joint)
# 7. Normalize features; store as PyG Data(x, edge_index, edge_type)

Two verification checks catch most construction errors. First, confirm that the connectivity graph is connected within each part: a disconnected subgraph usually means the element-to-node mapping dropped shared-vertex elements. Second, inspect the proximity edge count as a function of radius — it should rise smoothly and then plateau; a sudden jump indicates a contact interface being swept in, which may be intended but should be a deliberate choice. Typical failure symptoms are a graph with far more proximity than connectivity edges (radius too large) or a model that cannot reproduce known load paths (missing joint features or wrong edge typing).

Keep the graph topology fixed across the simulation and let node features evolve. A topology that changes every frame forces the GNN to relearn message functions and destroys temporal consistency.
Do not mix material-point and centroid nodes in the same homogeneous graph without an explicit mapping edge type. The two conventions have different spatial densities, and untyped cross-edges will dominate message passing in the dense region.

The graph built here is the substrate for everything that follows: physics-informed message functions, contact-aware attention, and temporal rollout. Getting nodes, edges, and features right at this stage determines whether the network can represent the crash physics at all — no amount of architectural sophistication recovers information that was never encoded in the graph.

← Previous 📖 Contents Next →