2. Graph representations of restraint structures

A restraint structure is any mechanical system whose purpose is to limit, guide, or react to the motion of another body: pipe supports and hangers, seismic braces, tie rods, clamp assemblies, snubbers, and the bracket-and-anchor networks that hold process equipment in place. Before a graph neural network can predict anything about such a system — its stiffness, its load path, whether it will pass a stress check — the physical structure must be encoded as a graph. This section defines that encoding precisely: what becomes a node, what becomes an edge, which attributes attach to each, and how a single global vector summarizes the whole assembly.

The central design principle is that the graph must be a faithful, loss-minimizing abstraction of the mechanics. Every quantity the GNN is expected to predict must be derivable, at least in principle, from the graph. If a restraint's capacity depends on the weld size at a bracket toe, and no node or edge feature carries that weld geometry, no amount of training will recover it. Conversely, encoding irrelevant detail (paint color, procurement codes) adds noise and dimensionality without information. Graph construction is therefore a modeling decision, not a data-formatting chore.

Nodes: the discrete mechanical entities

Nodes represent the discrete entities between which restraint forces are transmitted. In a typical support assembly the natural node set is:

• Connection points — anchor locations on the pipe wall, structural steel, or concrete embedment, where the restraint attaches to a host body.
• Structural members — struts, braces, tie rods, and clamp bodies, each treated as one node when its internal behavior is captured by member-level features rather than resolved by sub-meshing.
• Junctions and fittings — clevis brackets, turnbuckles, pins, and base plates where load paths branch or change direction.
• Boundary nodes — the fixed supports and the restrained pipe itself, which act as sources or sinks of reaction forces.

The granularity choice matters. A single strut modeled as one node with an axial stiffness feature is cheap and adequate for global load-path prediction; the same strut modeled as five nodes along its length is necessary only if local buckling or bending near the end fittings is the prediction target. A practical rule: one node per component whose failure mode or stiffness contribution you intend to predict or condition on.

Edges: load-transfer interfaces

Edges represent the mechanical interfaces through which force and moment pass between nodes. They are not merely "connections" — each edge should correspond to a physically identifiable joint: a welded connection, a bolted flange, a pinned clevis, a threaded engagement, or a sliding contact. This matters because edge features carry the joint's mechanical character, and because the GNN's message passing will propagate information along exactly the load paths the structure actually has.

Two conventions should be fixed before any data is generated, and held consistently across the dataset and all figures:

• Direction. Use directed edges from the restrained body toward the fixed boundary (the direction of reaction-force flow), and add the reverse edge explicitly if the model is not told to treat the graph as undirected. Mixing conventions between samples silently corrupts training.
• Self-loops and duplicates. A double-sided clamp that grips a pipe at two circumferential locations is two edges, not one; collapsing them loses the load-sharing information.

Node features

Node features describe the local state and capacity of each entity. A workable feature vector for restraint prediction includes:

Normalize continuous features (zero mean, unit variance over the training set) and record the normalization statistics — they must be reused at inference. Categorical features such as node type and material grade should be one-hot encoded rather than integer-encoded, so the network does not infer a spurious ordering.

Edge features

Edge features describe the joint's geometry and mechanical behavior. Typical entries: connection type (welded / bolted / pinned / sliding, one-hot), contact area, weld leg size or bolt count and diameter, gap or clearance for sliding joints, friction coefficient, and the joint's rated capacity. For pinned connections, the pin diameter and the number of shear planes are the features that determine failure mode; for welded connections, the throat thickness and weld length dominate.

A useful derived edge feature is the relative position vector Δ_ij = p_j − p_i and its length, which lets the network reason about member orientation and span without a separate geometric preprocessing step. If the model must remain invariant to rigid-body rotation of the whole assembly, use only the length and the angle relative to a locally defined member axis, not the raw global components.

Global attributes

The global attribute vector u summarizes context that belongs to the assembly as a whole rather than to any single node or edge: design code and edition, operating pressure and design temperature, seismic design category, pipe nominal diameter and wall schedule, insulation weight per unit length, and the analysis load case identifier. Global attributes are broadcast into node and edge update functions, which is how a GNN learns that the same bracket geometry behaves differently under a thermal load case than under a seismic one.

Worked encoding example

Consider a simple two-strut brace: a pipe anchor A at (0, 0, 0), a junction J at (600, 0, 300) mm, and a structural-steel anchor B at (1200, 0, 0) mm. Strut A–J is a 2 m, Ø60×5 mm tube in S275; strut J–B is a 1.5 m, Ø48×4 mm tube. Both ends are pinned clevises with 20 mm pins, single shear. The design case is a thermal load at 180 °C with a 12 kN axial demand on the assembly.

nodes = [
  {id: "A", type: "anchor",    pos: [0, 0, 0],       A: null,  E: 210000, Fallow: 40.0},
  {id: "J", type: "junction",  pos: [600, 0, 300],   A: null,  E: 210000, Fallow: 25.0},
  {id: "B", type: "boundary",  pos: [1200, 0, 0],    A: null,  E: 210000, Fallow: 40.0},
]
edges = [
  {src: "A", dst: "J", conn: "pinned", pin_d: 20, planes: 1, L: 670.8},
  {src: "J", dst: "B", conn: "pinned", pin_d: 20, planes: 1, L: 670.8},
]
u = {code: "EN13480", T_design: 180, P_design: 1.6, load_case: "thermal", DN: 150}

Note what this encoding does and does not capture. It captures the load path (A → J → B), the pin shear configuration at each joint, and the thermal context. It does not capture the strut cross-sections as node features — those belong on the edges, since the member is the edge's physical realization. A common mistake is to attach member properties to the junction node; the result is that the network cannot distinguish two struts of different section meeting at the same junction.

Validation before training

Before any GNN sees the data, run three structural checks on every graph. First, connectivity: every node must be reachable from at least one boundary node along directed edges; an isolated node indicates a missing joint in the source model. Second, feature completeness: assert that no required feature is null, and log the fraction of missing values per feature — a feature that is 40% missing will be learned as noise. Third, physical consistency: recompute the axial stiffness of each member as EA/L from its node and edge features and compare against the source model's reported stiffness; a mismatch above 1% usually means a unit error (mm vs. m) or a section property attached to the wrong object. These checks catch the majority of encoding defects before they become unexplained training loss.

With the encoding fixed and validated, the graph is ready for the message-passing layers that follow. The quality of every downstream prediction — load path, capacity margin, failure mode — is bounded by the fidelity of this representation, which is why the node/edge/global decomposition deserves explicit engineering attention rather than being treated as a preprocessing afterthought.