The force method for frames and trusses

The force method is not limited to beams. The same five steps apply to rigid frames, where bending dominates, and to trusses, where every member carries only axial force. What changes is the deformation that enters the compatibility equations: bending curvature \(M/EI\) for frames, axial strain \(N/AE\) for trusses. This lesson applies the method to the steel portal frames of the operations center garage and to the X-braced wall bays that carry wind and crane surge to the foundations.

Frames: what deformations to include

A frame member bends, stretches and shears. The virtual work expression for a displacement includes all three:

For ordinary building frames, where members are slender and the span-to-depth ratio is well above 10, the bending term is much larger than the other two. Hand analysis therefore keeps only the bending term, which treats members as inextensible. Two situations break this rule. Members that carry large axial forces relative to their bending, such as the chords of a Vierendeel truss or the columns of a tall frame, need the axial term. Deep members such as transfer girders and shear walls need the shear term. Structural software includes all three by default, which is one reason computer results differ slightly from hand results.

The flexibility coefficients of a frame are found by integrating along each member and summing over the members:

Each member can have its own \(EI\), which is how the relative stiffness of beams and columns enters the answer. The product-integral table remains the quickest tool for constant-\(EI\) members.

The garage portal frame

The garage roof is carried by single-bay rigid steel frames with pinned bases. Each frame has four reactions, so it is indeterminate to the first degree. The natural redundant is the horizontal reaction H at one base: releasing it to a roller leaves a determinate frame whose roof member behaves as a simple beam, while the columns carry no bending at all.

Writing the result in terms of the relative stiffness \(k = (I_b/I_c)(h/L)\) of beam and columns gives a formula that shows how stiffness shares the moment:

With equal sections, \(k = h/L = 1/3\) for the garage frame. A stiffer beam (larger k) reduces H and the corner moments, sending more moment to midspan; stiffer columns (smaller k) do the reverse. In the limit of rigid columns, \(k \to 0\) and \(H \to wL^2/(12h)\), so the corner moment approaches the fixed-end moment \(wL^2/12\). This is the general character of indeterminate structures: moment goes where the stiffness is.

Compare the three-hinged salt shed frames of CIV-224. There the crown hinge fixes the thrust by statics at \(wL^2/(8h)\), regardless of member sizes. In the garage portal, removing that hinge lets the beam develop sagging moment at midspan, so the thrust is smaller, here about 55 percent of the three-hinged value, and depends on the section properties.

Frames with more redundants

Fixing the bases of the garage portal adds two more restraints, making it indeterminate to the third degree. A convenient primary structure is a cantilever frame: release all three reactions at D (\(H_D\), \(V_D\), \(M_D\)) and the frame becomes a bent cantilever fixed at A. The compatibility equations state that the horizontal displacement, vertical displacement and rotation at D are all zero, and the three-by-three flexibility matrix couples them.

A second strategy, which often reduces the arithmetic, is to cut the frame at its axis of symmetry. The internal forces at the cut of a symmetric frame (axial force, shear and moment) become the redundants. Under symmetric loading the shear at the cut is zero, and under antisymmetric loading the axial force and moment are zero, so the three equations split into smaller independent sets. Any load can be written as the sum of a symmetric and an antisymmetric part, which makes this a general method.

Trusses: axial deformation only

In a pin-jointed truss the only deformation is the change of member length, so the virtual work integrals reduce to sums over the members. The coefficients of the compatibility equations become

where \(N_0\) are the member forces in the primary truss under the loads and \(n_i\) the forces under a unit value of redundant i. A truss can be externally indeterminate (more supports than needed), internally indeterminate (more members than needed) or both. For an internal redundant, the primary truss is made by cutting the redundant member. The unit redundant is then a pair of equal and opposite unit forces applied to the two cut ends, and the compatibility condition is that the gap at the cut closes: the relative displacement of the two ends must be zero. The redundant member itself is part of the structure and contributes its own term \(1^2 L/AE\) to \(f_{ii}\).

A tabular layout keeps truss calculations organized: one row per member with columns for L, A, \(N_0\), n, \(nN_0L/A\) and \(n^2L/A\), and the two sums at the foot. The same table, extended with columns for further redundants, handles trusses with several redundant members or supports. When members have different areas, the stiffer members attract more force; doubling the area of diagonal 0–2 alone would raise its share of the shear above one half.

Solving it in code

The program below builds the joint equilibrium equations of the primary truss and solves them by Gaussian elimination, then applies the compatibility equation. Because the equilibrium solver is general, the same code handles any truss with one internal redundant: change the nodes, members, areas and loads. Try setting the area of diagonal 1–3 to 0.01 to imitate a slender rod and watch the force move into the other diagonal.

# Force method for a truss with one internal redundant (X-braced wall bay)
# Pure-Python Gaussian elimination solves the joint equilibrium equations.
b, h, P = 20.0, 15.0, 13.5                 # bay width, height (ft), wind load (kips)
nodes = [(0.0, 0.0), (b, 0.0), (b, h), (0.0, h)]
members = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2), (1, 3)]
A = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]         # relative areas (E cancels)
reactions = [(0, 0), (0, 1), (1, 1)]       # (node, direction): pin at 0, roller at 1
redundant = 5                              # cut member 1-3

def gauss(M, rhs):
    n = len(rhs); a = [row[:] + [rhs[i]] for i, row in enumerate(M)]
    for c in range(n):
        p = max(range(c, n), key=lambda r: abs(a[r][c])); a[c], a[p] = a[p], a[c]
        for r in range(c + 1, n):
            f = a[r][c] / a[c][c]
            for k in range(c, n + 1): a[r][k] -= f * a[c][k]
    x = [0.0] * n
    for r in range(n - 1, -1, -1):
        x[r] = (a[r][n] - sum(a[r][k] * x[k] for k in range(r + 1, n))) / a[r][r]
    return x

def geom(m):
    (xi, yi), (xj, yj) = nodes[members[m][0]], nodes[members[m][1]]
    L = ((xj - xi) ** 2 + (yj - yi) ** 2) ** 0.5
    return L, (xj - xi) / L, (yj - yi) / L

def solve_primary(loads, pair=0.0):
    # unknowns: forces in all members except the redundant, then reactions
    kept = [m for m in range(len(members)) if m != redundant]
    nu = len(kept) + len(reactions); E = [[0.0] * nu for _ in range(2 * len(nodes))]
    rhs = [-loads[d] for d in range(2 * len(nodes))]
    for col, m in enumerate(kept):
        L, c, s = geom(m); i, j = members[m]
        E[2 * i][col] += c; E[2 * i + 1][col] += s; E[2 * j][col] -= c; E[2 * j + 1][col] -= s
    for k, (nd, d) in enumerate(reactions): E[2 * nd + d][len(kept) + k] = 1.0
    if pair:                               # unit tension pair in the cut member
        L, c, s = geom(redundant); i, j = members[redundant]
        rhs[2 * i] -= c; rhs[2 * i + 1] -= s; rhs[2 * j] += c; rhs[2 * j + 1] += s
    x = gauss(E, rhs); N = [0.0] * len(members)
    for col, m in enumerate(kept): N[m] = x[col]
    N[redundant] = pair
    return N

loads = [0.0] * 8; loads[6] = P            # horizontal load at node 3
N0 = solve_primary(loads)                  # primary structure under the load
n1 = solve_primary([0.0] * 8, pair=1.0)    # primary structure, unit force in cut member
D10 = sum(N0[m] * n1[m] * geom(m)[0] / A[m] for m in range(6))
f11 = sum(n1[m] ** 2 * geom(m)[0] / A[m] for m in range(6))
X = -D10 / f11
print("compatibility: %.2f + %.3f X = 0  ->  X = %.2f kips" % (D10, f11, X))
z = lambda v: round(v, 6) + 0.0           # tidy -0.00 in the printout
for m, (i, j) in enumerate(members):
    print("member %d-%d: N0 = %7.2f  n = %6.3f  N = %7.2f kips" % (i, j, z(N0[m]), z(n1[m]), z(N0[m] + X * n1[m])))

compatibility: 729.00 + 86.400 X = 0  ->  X = -8.44 kips
member 0-1: N0 =    0.00  n = -0.800  N =    6.75 kips
member 1-2: N0 =  -10.12  n = -0.600  N =   -5.06 kips
member 2-3: N0 =  -13.50  n = -0.800  N =   -6.75 kips
member 3-0: N0 =    0.00  n = -0.600  N =    5.06 kips
member 0-2: N0 =   16.88  n =  1.000  N =    8.44 kips
member 1-3: N0 =    0.00  n =  1.000  N =   -8.44 kips

The two numbers in the compatibility line are \(AE\Delta_{10}\) and \(AEf_{11}\) from the hand calculation, and the member table repeats the superposition column by column. Agreement between hand and program results at this level of detail is the standard you should expect of any check calculation.