Deflections by virtual work

The moment-area method works well for beams, but it does not extend easily to trusses, frames with several members or deflections in a direction other than vertical. The method of virtual work does all of these with one procedure. It is the most versatile hand method for displacements, it is the foundation of the force method for indeterminate structures in lesson 12, and its ideas underlie the finite element method. The core idea is simple: to find a displacement at a point, apply an imaginary unit load at that point in the direction of the displacement, and use the work it would do.

Work and the principle of virtual work

A force does work when its point of application moves in the direction of the force: work equals force times the displacement component along it. For a linearly elastic structure loaded gradually, the external work done by the loads is stored as strain energy in the members. Virtual work separates the forces from the displacements. It considers one system of forces in equilibrium and an unrelated set of compatible displacements, and states that if the displacements are imposed on the structure while the forces stay constant, the external virtual work equals the internal virtual work.

For computing deflections we use the principle of virtual forces. The virtual force system is a unit load (or unit couple) applied at the point and in the direction of the displacement we want, together with the internal forces and reactions it produces. The real displacements are those caused by the actual loads, temperature changes or other effects. Equating external and internal virtual work gives

where n is the internal force in a member due to the unit load and \(d\delta\) is the real deformation of an element of that member. The left side is the work of the unit load moving through the real displacement \(\Delta\); the right side is the work of the virtual internal forces moving through the real internal deformations. Because the unit load and the real loads are independent, the same real deformation can be paired with any virtual load to give any displacement.

Trusses

In a truss, each member has a constant axial force N from the real loads, and its real elongation is \(NL/(AE)\). If n is the force in the same member due to a unit load at the joint and in the direction of the desired displacement, then

summed over all members. Use a consistent sign convention, tension positive for both n and N, and the sign of \(\Delta\) tells you whether the joint moves in the direction of the unit load (positive) or opposite to it. Organizing the calculation as a table with columns for L, A, N, n and the product \(nNL/A\) keeps it tidy, and a spreadsheet or short program makes it painless for large trusses.

The same formula handles deformations that do not come from loads. If a member's length changes by \(\delta_{\text{other}}\), because of a temperature change (\(\alpha\,\Delta T\,L\)) or a fabrication error, the displacement is \(\Delta = \sum n\,\delta_{\text{other}}\). Engineers use this to camber trusses: by making some members slightly longer or shorter on purpose, they build the truss with an upward deflection that cancels the dead load deflection.

Beams and frames

In a beam, the dominant real deformation is bending. An element of length dx rotates through \(d\theta = M\,dx/(EI)\) under the real moment M, and the virtual moment m from the unit load does work \(m\,d\theta\) on it. Hence

where for a slope you apply a unit couple at the point and \(m_\theta\) is its moment diagram. For a frame, sum the integrals over all members. Axial and shear deformations contribute too, with terms \(\int nN/(AE)\,dx\) and \(\int f_s vV/(GA)\,dx\), but for ordinary beams and frames they are small compared with bending and are usually neglected. For trusses, by contrast, the axial term is everything.

You must use the same sign convention for m and M in each member, and the same coordinate x. Choose the origin for each segment wherever the expressions are simplest, often at a free end or a support, and you can choose differently for different segments, as long as m and M in that segment are both written with the same origin.

Product integrals

Because m and M are usually simple shapes (rectangles, triangles, parabolas), the integral of their product over a member of length L can be read from a table instead of integrated each time. With a and b the end or peak values of the two diagrams:

Divide the result by EI for each member and add. For frames with several members this turns a page of integration into a few lines, and it is how most engineers do virtual work by hand.

Truss deflection by computer

Sofia applies the unit load method to the whole garage Pratt truss under specified dead plus snow load, using trial member areas. The program reuses the joint-equilibrium solver from lesson 4 twice, once for the real loads and once for a unit load at midspan, and sums \(nNL/(AE)\). It also reports which members contribute most, which tells the designer where extra area would reduce deflection most efficiently.

import math

def solve(A, b):
    n = len(b); M = [row[:] + [b[i]] for i, row in enumerate(A)]
    for k in range(n):
        p = max(range(k, n), key=lambda i: abs(M[i][k])); M[k], M[p] = M[p], M[k]
        for i in range(k + 1, n):
            f = M[i][k] / M[k][k]
            for jj in range(k, n + 1): M[i][jj] -= f * M[k][jj]
    x = [0.0] * n
    for i in reversed(range(n)):
        x[i] = (M[i][n] - sum(M[i][jj] * x[jj] for jj in range(i + 1, n))) / M[i][i]
    return x

span, panels, depth = 60.0, 6, 7.0
a = span / panels
nodes = {}
for i in range(panels + 1):
    nodes[f"L{i}"] = (i * a, 0.0); nodes[f"U{i}"] = (i * a, depth)
mem = [(f"L{i}", f"L{i+1}") for i in range(panels)] + [(f"U{i}", f"U{i+1}") for i in range(panels)]
mem += [(f"L{i}", f"U{i}") for i in range(panels + 1)]
mem += [(f"U{i}", f"L{i+1}") for i in range(panels // 2)] + [(f"U{i+1}", f"L{i}") for i in range(panels // 2, panels)]
area = {m: (9.0 / 144 if m[0][0] == m[1][0] else 4.5 / 144) for m in mem}   # chords vs webs
E = 29000.0 * 144
sup = [("L0", 0), ("L0", 1), (f"L{panels}", 1)]
names = list(nodes); idx = {n: k for k, n in enumerate(names)}

def member_forces(loads):
    nu = len(mem) + len(sup)
    A = [[0.0] * nu for _ in range(2 * len(names))]; rhs = [0.0] * (2 * len(names))
    for m, (i, j) in enumerate(mem):
        (xi, yi), (xj, yj) = nodes[i], nodes[j]
        L = math.hypot(xj - xi, yj - yi); c, s = (xj - xi) / L, (yj - yi) / L
        A[2*idx[i]][m] += c; A[2*idx[i]+1][m] += s; A[2*idx[j]][m] -= c; A[2*idx[j]+1][m] -= s
    for k, (n, d) in enumerate(sup):
        A[2*idx[n] + d][len(mem) + k] = 1.0
    for n, fy in loads.items():
        rhs[2*idx[n] + 1] -= fy
    return solve(A, rhs)[:len(mem)]

P = 15.7
real = member_forces({f"U{i}": -P * (0.5 if i in (0, panels) else 1.0) for i in range(panels + 1)})
unit = member_forces({"L3": -1.0})                      # unit load down at midspan bottom joint
total = 0.0
for (i, j), N, n in zip(mem, real, unit):
    (xi, yi), (xj, yj) = nodes[i], nodes[j]
    L = math.hypot(xj - xi, yj - yi)
    total += n * N * L / (area[(i, j)] * E)
print(f"Midspan deflection under specified load: {total * 12:.2f} in. (span/{span / total:.0f})")
top = sorted(((abs(n * N * math.hypot(nodes[j][0]-nodes[i][0], nodes[j][1]-nodes[i][1]) / (area[(i, j)] * E)), i + j)
              for (i, j), N, n in zip(mem, real, unit)), reverse=True)[:4]
print("Largest contributions:", ", ".join(f"{name} {v / total * 100:.0f}%" for v, name in top))

Midspan deflection under specified load: 0.82 in. (span/878)
Largest contributions: U3U4 12%, U2U3 12%, U6L5 8%, U0L1 8%

The chords dominate the total, so increasing the chord areas reduces deflection most. The specified-load deflection is a small fraction of the span, well within the usual roof limits, but the truss will still be fabricated with a camber equal to its dead load deflection so that the roof is flat once the roofing is installed.