Skip to content
LumenaryAcademy
Solids 70 min

Deflection and buckling

How far a beam bends, how the extra equations of deformation solve indeterminate beams, and why a slender column that is strong enough can still fail suddenly.

Code tested · 6AI-draftedAwaiting review by a mechanical engineer

Your guides: Chloe · The Designer, Margaret · The Test Engineer, Gideon · The Checker

MotivationH

Strong enough is not enough

In Axial load, torsion and bending you checked that the stresses in a part stay below what the material can bear. That is necessary, but two other questions are just as important, and they have nothing to do with strength.

The first is stiffness. A floor that sags 30 mm under a party cracks the ceiling below and feels alarming even if no fibre is near yield. A machine-tool spindle that deflects by a few micrometres cuts the wrong shape. A gearbox shaft that bends tilts its gears out of mesh, and they wear out in weeks. Engineers therefore limit deflections as well as stresses, often more severely.

The second is stability. Press down on the ends of a plastic ruler and it carries the load perfectly well, until suddenly it bows out sideways and carries no more. The ruler did not break; the material was far from its strength. It lost its shape. This is buckling, and it has caused some of the worst collapses in engineering history, including the Quebec Bridge disaster of 1907 described in Trusses and frames.

Both questions are answered by the same idea: how much a part bends under a given moment. This lesson builds deflection from curvature, uses it to solve beams that statics alone cannot, and then shows how a compressive load can make bending feed on itself.

IntuitionH

Curvature adds up to deflection

You already know the key fact. In the previous lesson, the flexure theorem gave the curvature of a beam at any section: 1/ρ=M/(EI)1/\rho = M/(EI). Where the bending moment is large the beam curves sharply; where it is zero the beam is locally straight.

Curvature is the rate at which the slope changes along the beam, and slope is the rate at which the deflection changes. So going the other way, the slope is the running total of the curvature, and the deflection is the running total of the slope. Knowing M(x)M(x) everywhere, you can build up the deflected shape step by step from one end, like a walker who knows at every step how sharply to turn, and then fix the starting direction so that the path passes through the supports.

vslope θ = dv/dxcurvature 1/ρ = d²v/dx² = M/(EI)w per unit length
The elastic curve of a simply supported beam under a uniform load, much exaggerated. At every point the curvature is M/EI; integrating once gives the slope θ = dv/dx, and integrating again gives the deflection v. The supports fix the two constants of integration: here v = 0 at both ends.
DefinitionsH

The moment–curvature equation

Definition— elastic curve

The elastic curve v(x)v(x) is the deflection of the beam's neutral axis, positive upwards. For small slopes, the curvature is d2v/dx2d^2v/dx^2, so the flexure theorem becomes the moment–curvature equation (the Euler–Bernoulli beam equation)

EI d2vdx2=M(x),EI\,\frac{d^2v}{dx^2} = M(x),

with MM positive when it makes the beam sag. The product EIEI is the flexural rigidity: the material's stiffness times the stiffness of the shape.

Integrating twice leaves two constants, fixed by boundary conditions: at a pin or roller, v=0v = 0; at a clamped (built-in) end, v=0v = 0 and dv/dx=0dv/dx = 0; at a free end, nothing is prescribed about vv (instead M=0M = 0 there).

Example— A simply supported beam under a uniform load

A beam of span LL carries ww per unit length downwards. Its reactions are wL/2wL/2 each, so M(x)=wx(L−x)/2M(x) = wx(L - x)/2. Integrate twice:

EI v=w(Lx312−x424)+C1x+C2.EI\,v = w\left(\frac{Lx^3}{12} - \frac{x^4}{24}\right) + C_1 x + C_2.

At x=0x = 0, v=0v = 0 gives C2=0C_2 = 0; at x=Lx = L, v=0v = 0 gives C1=−wL3/24C_1 = -wL^3/24. At mid-span,

v ⁣(L2)=−5wL4384 EI.v\!\left(\tfrac{L}{2}\right) = -\frac{5wL^4}{384\,EI}.

Two more results are worth remembering, because they are the building blocks of superposition: a simply supported beam with a central point load PP deflects PL3/(48EI)PL^3/(48EI) at mid-span, and a cantilever with a point load PP at its tip deflects PL3/(3EI)PL^3/(3EI) there. Notice the powers. Deflection grows as the cube of the span for a point load and the fourth power for a uniform load (whose total also grows with the span): a beam twice as long sags sixteen times as much under the same load per metre. Long spans are governed by stiffness long before strength.

Deflection limits are set by codes and by the job. In buildings, limits between about span/250 and span/360 under imposed loads are typical, tighter where brittle partitions or finishes sit on the beam. Machine parts are limited by function: the slope of a shaft at its bearings, the misalignment of a gear mesh, the accuracy of a machine tool.

ComputationC

Computing it: integrating the curvature numerically

The hand integration works for simple loads. For any M(x)M(x), a computer does the same thing with the trapezoidal rule: integrate M/EIM/EI once for the slope and again for the deflection, then add the straight line C1x+C2C_1x + C_2 that makes the deflection vanish at the supports. The block checks the method against the two formulas, for a steel I-beam 300 mm deep (I=7.59×10−5 m4I = 7.59 \times 10^{-5}\ \text{m}^4) spanning 6 m under 10 kN/m, and for a 2 m cantilever with 5 kN at its tip.

python
import numpy as np

def integrate(x, f):
    """Running integral of samples f(x) from x[0], by the trapezoidal rule."""
    return np.concatenate([[0.0], np.cumsum((f[1:] + f[:-1]) / 2 * np.diff(x))])

def deflection(x, M, EI, supports=None):
    """Deflection v(x) from bending moment samples M(x): integrate the curvature M/EI twice.
    supports=(xa, xb): v = 0 at two supports. supports=None: clamped at x[0] (v = v' = 0)."""
    v = integrate(x, integrate(x, M / EI))
    if supports is None:
        return v                                   # zero slope and deflection at x[0] already
    xa, xb = supports
    va, vb = np.interp([xa, xb], x, v)
    C1 = -(vb - va) / (xb - xa)                    # add the straight line C1 x + C2 that ...
    return v + C1 * (x - xa) - va                  # ... brings both supports back to v = 0

E = 210e9                                          # Pa
I = 7.59e-5                                        # m^4: an I-beam 300 mm deep (300 x 150, tf 10, tw 7)
EI = E * I

# 1. Simply supported, 6 m span, uniform load 10 kN/m: compare with 5 w L^4 / (384 EI)
L, w = 6.0, 10e3
exact = 5 * w * L**4 / (384 * EI)
print(" elements   mid-span deflection (mm)   error")
for n in [4, 8, 16, 32, 64]:
    x = np.linspace(0.0, L, n + 1)
    M = w * x * (L - x) / 2                        # sagging positive
    v = deflection(x, M, EI, supports=(0.0, L))
    print(f" {n:6d}     {-v[n // 2] * 1e3:10.4f}             {(-v[n // 2] - exact) / exact:+.2e}")
print(f" formula    {exact * 1e3:10.4f}     (span / deflection = {L / exact:.0f})")

# 2. Cantilever 2 m long, 5 kN at the tip: compare with P L^3 / (3 EI)
L, P = 2.0, 5e3
x = np.linspace(0.0, L, 201)
v = deflection(x, -P * (L - x), EI)                # hogging moment, clamped at x = 0
print(f"\ncantilever tip: {v[-1] * 1e3:.4f} mm   formula: {-P * L**3 / (3 * EI) * 1e3:.4f} mm")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The floor beam sags 10.59 mm, span/567, comfortably inside a span/360 limit. The numerical answer converges to the formula, and the error tells you how: each time the number of intervals doubles, the error falls by a factor of four, from −10%-10\% with four intervals to −0.04%-0.04\% with 64. That is the signature of a second-order method, and it is the same kind of convergence study you will run on finite element models in The finite element method. The cantilever, whose moment is linear, comes out exact to four decimal places.

Worked examplesH

Superposition and indeterminate beams

The moment–curvature equation is linear: double the load and you double MM, the curvature and the deflection; apply two loads together and the deflections add. This principle of superposition lets you build complicated cases from tabulated simple ones, as long as the material stays elastic and the deflections stay small.

Its most powerful use is for statically indeterminate beams, which have more supports than statics needs. In Statics and equilibrium the beam with a third support had four unknown reactions and only three equations, and the rank of the equilibrium matrix showed that statics could not share the load out. Deflection supplies the missing equation, called compatibility: at each support, the beam's deflection must be what the support allows.

The method of superposition (or flexibility method) goes like this:

  1. Remove enough supports to make the beam determinate. The removed reactions are the redundants.
  2. Compute the deflection at each removed support under the actual loads.
  3. Compute the deflection there under a unit force at the same point.
  4. Choose the redundant so that the two deflections cancel.

Example— A propped cantilever

A beam of length LL is clamped at the left and rests on a prop at the right, under a uniform load ww. Remove the prop: the cantilever's tip deflects wL4/(8EI)wL^4/(8EI) downwards. A force RR pushing up at the tip lifts it by RL3/(3EI)RL^3/(3EI). The prop holds the tip at zero, so

RL33EI=wL48EI⇒R=3wL8.\frac{RL^3}{3EI} = \frac{wL^4}{8EI} \quad\Rightarrow\quad R = \frac{3wL}{8}.

The clamp carries the other 5wL/85wL/8 and a moment of wL2/8wL^2/8. Notice that EIEI cancelled: for a uniform beam on unyielding supports, the reactions depend only on geometry and loads.

The block does the same thing numerically, reusing the curvature integrator. It checks the propped cantilever, then finally solves the beam the statics lesson left open: the 6 m beam on a pin at A and a roller at B, now with a third roller at C, 3.5 m from A. The section is the I-section chosen in the previous lesson.

python
import numpy as np

def integrate(x, f):
    return np.concatenate([[0.0], np.cumsum((f[1:] + f[:-1]) / 2 * np.diff(x))])

def deflection(x, M, EI, supports=None):
    """As before: v = 0 at two supports, or clamped at x[0] if supports is None."""
    v = integrate(x, integrate(x, M / EI))
    if supports is None:
        return v
    xa, xb = supports
    va, vb = np.interp([xa, xb], x, v)
    return v - (vb - va) / (xb - xa) * (x - xa) - va

def moment(x, forces, w=0.0, x1=0.0, x2=0.0):
    """M(x), sagging positive, from everything to the RIGHT of each cut (so a clamp at the
    left end needs no reactions): point forces [(position, upward force)] and an upward
    distributed load w from x1 to x2."""
    M = np.zeros_like(x)
    for xp, F in forces:
        M += F * np.clip(xp - x, 0.0, None)
    start = np.clip(x, x1, x2)                       # the part of the spread load right of x
    return M + w * (x2 - start) * ((start + x2) / 2 - x)

# 1. Propped cantilever: clamped at x = 0, propped at x = L, uniform load. Remove the prop;
#    the prop force R must cancel the tip deflection: R * v_unit(L) + v_load(L) = 0.
L, w, EI = 4.0, -6e3, 1.0e6
x = np.linspace(0.0, L, 401)
v_load = deflection(x, moment(x, [], w, 0.0, L), EI)
v_unit = deflection(x, moment(x, [(L, 1.0)]), EI)
R = -v_load[-1] / v_unit[-1]
print(f"propped cantilever: prop force {R / 1e3:.3f} kN; formula 3wL/8 = {3 * -w * L / 8 / 1e3:.3f} kN")

# 2. The statics beam: pin at 0, roller at 5 m, overhang to 6 m. Steel I-section from the
#    previous lesson (I = 7.856e-6 m^4).
EI = 210e9 * 7.856e-6
x = np.linspace(0.0, 6.0, 6001)
P, w, x1, x2 = -8e3 * np.cos(np.radians(30)), -2e3, 3.0, 6.0
By = -(2.0 * P + w * (x2 - x1) * (x1 + x2) / 2) / 5.0
Ay = -(P + w * (x2 - x1)) - By
v0 = deflection(x, moment(x, [(2.0, P), (5.0, By)], w, x1, x2), EI, supports=(0.0, 5.0))
k = np.argmin(v0[x <= 5.0])
print(f"\ntwo supports: Ay = {Ay / 1e3:.2f} kN, By = {By / 1e3:.2f} kN")
print(f"  largest sag {-v0[k] * 1e3:.2f} mm at x = {x[k]:.2f} m; free end {v0[-1] * 1e3:+.2f} mm")

# 3. Add a roller at C (x = 3.5 m). Released structure: the beam above. A unit upward force
#    at C, with the reactions it causes (moments about A: By = -0.7, so Ay = -0.3).
vu = deflection(x, moment(x, [(3.5, 1.0), (5.0, -0.7)]), EI, supports=(0.0, 5.0))
iC = np.argmin(abs(x - 3.5))
RC = -v0[iC] / vu[iC]
print(f"\nthree supports: Ay = {(Ay - 0.3 * RC) / 1e3:.2f} kN, Cy = {RC / 1e3:.2f} kN, "
      f"By = {(By - 0.7 * RC) / 1e3:.2f} kN  (total {(Ay + By) / 1e3:.2f} kN)")
v = v0 + RC * vu
M0 = moment(x, [(2.0, P), (5.0, By)], w, x1, x2)
M = moment(x, [(2.0, P), (3.5, RC), (5.0, By - 0.7 * RC)], w, x1, x2)
print(f"  largest sag {-v.min() * 1e3:.2f} mm; deflection at C {abs(v[iC]) * 1e3:.1e} mm")
print(f"  largest moment: {abs(M0).max() / 1e3:.2f} kN m before, {abs(M).max() / 1e3:.2f} kN m after")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The propped cantilever's prop force comes out at exactly 3wL/8=93wL/8 = 9 kN. On two supports, the statics beam sags 12.78 mm at 2.42 m from A, about span/390, and its free end rises 7.30 mm, because the beam rotates over B like a see-saw. The third support changes everything: it takes 8.99 kN, leaving only 2.06 kN at A and 1.88 kN at B, the largest sag falls to 2.16 mm and the largest bending moment from 9.51 to 4.12 kN m. The totals still add up to the 12.93 kN of vertical load, as statics demands; what compatibility added is how it is shared.

DefinitionsH

Euler buckling

Now load a slender column along its axis. A perfectly straight column under a compressive force PP simply shortens. But suppose it bends sideways by a small amount v(x)v(x). The load, still vertical, now has a lever arm: it creates a bending moment M=−PvM = -Pv that bends the column further in the same direction. Meanwhile the column's stiffness tries to straighten it. For small PP stiffness wins, and the column springs back. At one particular load the two exactly balance, and the column can rest in a bent shape with no lateral force at all. That load is the critical or buckling load.

Theorem— Euler's buckling load

A straight, slender, linear-elastic column of length LL and flexural rigidity EIEI, pinned at both ends, can be in equilibrium in a bent shape only when the axial load is

P=n2π2EIL2,n=1,2,3,…P = \frac{n^2\pi^2 EI}{L^2}, \qquad n = 1, 2, 3, \dots

The smallest, Pcr=π2EI/L2P_\text{cr} = \pi^2EI/L^2, is the Euler buckling load, and the buckled shape is a half sine wave.

Proof

With M=−PvM = -Pv, the moment–curvature equation becomes EIv′′+Pv=0EIv'' + Pv = 0. Write k2=P/(EI)k^2 = P/(EI); the general solution is v=Asin⁡kx+Bcos⁡kxv = A\sin kx + B\cos kx. The pin at x=0x = 0 requires v(0)=B=0v(0) = B = 0. The pin at x=Lx = L requires Asin⁡kL=0A\sin kL = 0. Either A=0A = 0, the straight column, or sin⁡kL=0\sin kL = 0, which needs kL=nπkL = n\pi, that is P=n2π2EI/L2P = n^2\pi^2EI/L^2. At those loads, and only those, the bent shape v=Asin⁡(nπx/L)v = A\sin(n\pi x/L) is an equilibrium for any small amplitude AA.

∎

The amplitude AA is undetermined: linear theory says the column can sit in its buckled shape at any small deflection, but cannot say which. That is a sign of a bifurcation: at PcrP_\text{cr} the straight equilibrium path meets a bent one, and the straight one becomes unstable.

Definition— effective length and slenderness

For other end conditions, Pcr=π2EI/(KL)2P_\text{cr} = \pi^2EI/(KL)^2, where Le=KLL_e = KL is the effective length, the length of the half sine wave in the buckled shape: K=1K = 1 for pinned–pinned, K=2K = 2 for fixed–free (a flagpole), K≈0.7K \approx 0.7 for fixed–pinned, K=0.5K = 0.5 for fixed–fixed. Dividing by the area AA and writing I=Ar2I = Ar^2, with rr the radius of gyration, gives the critical stress

σcr=π2E(Le/r)2,\sigma_\text{cr} = \frac{\pi^2 E}{(L_e/r)^2},

which depends only on the material's stiffness and the slenderness ratio Le/rL_e/r.

Ppinned–pinnedfixed–freefixed–pinnedfixed–fixedK = 1K = 2K ≈ 0.7K = 0.5
Buckled shapes of columns with different end conditions, all of the same length L. The effective length KL is the length of a half sine wave in each shape: the whole column for pinned ends, twice its length for a flagpole, and the part between inflection points for columns with fixed ends. Buckling load falls with the square of KL.

Example— A bar and a tube

A pinned steel strut 2.0 m long must be made from about 1250 mm² of steel (E=210E = 210 GPa, yield strength 275 MPa). As a solid bar of 40 mm diameter, I=πd4/64=125 700 mm4I = \pi d^4/64 = 125\,700\ \text{mm}^4 and

Pcr=π2×210 000×125 70020002=65.1 kN,P_\text{cr} = \frac{\pi^2 \times 210\,000 \times 125\,700}{2000^2} = 65.1\ \text{kN},

a critical stress of only 51.8 MPa, less than a fifth of the yield strength. Its radius of gyration is r=d/4=10r = d/4 = 10 mm, so its slenderness is 200. Roll slightly less steel, 1209 mm², into a tube 90 mm across with a 4.5 mm wall: I=1.11×106 mm4I = 1.11 \times 10^6\ \text{mm}^4, nine times more, and Pcr=574P_\text{cr} = 574 kN. Now buckling is no longer the limit; the tube would yield first, at 332 kN. Columns, like beams, want their material far from the axis.

ComputationC

Computing it: buckling as an eigenvalue problem

For end conditions other than pins, it is easiest to differentiate the equation twice, giving EI v′′′′+P v′′=0EI\,v'''' + P\,v'' = 0, which holds whatever the supports. Replace the derivatives by finite differences on NN intervals and the equation becomes a matrix problem, Av=P Bv\mathbf{A}\mathbf{v} = P\,\mathbf{B}\mathbf{v}: a generalised eigenvalue problem, whose eigenvalues are the buckling loads and whose eigenvectors are the buckled shapes. The end conditions enter through "ghost" points one step beyond each end.

python
import numpy as np

def buckling_loads(L, EI, left, right, N=200, modes=3):
    """Lowest buckling loads of a column from EI v'''' + P v'' = 0 by finite differences.
    Each end is 'pinned' (v = v'' = 0) or 'fixed' (v = v' = 0)."""
    h = L / N
    n = N - 1                                          # unknowns: v at interior nodes 1 .. N-1
    D4 = np.zeros((n, n))
    D2 = np.zeros((n, n))
    for i in range(n):
        for off, c in zip(range(-2, 3), [1, -4, 6, -4, 1]):
            if 0 <= i + off < n:
                D4[i, i + off] += c
        for off, c in zip(range(-1, 2), [1, -2, 1]):
            if 0 <= i + off < n:
                D2[i, i + off] += c
    # The ghost node beyond each end is v[-1] = -v[1] (pinned: v'' = 0) or +v[1] (fixed: v' = 0)
    D4[0, 0] += -1 if left == "pinned" else 1
    D4[-1, -1] += -1 if right == "pinned" else 1
    A = EI * D4 / h**4                                 # bending stiffness
    B = -D2 / h**2                                     # what the axial load P multiplies
    P = np.sort(np.linalg.eigvals(np.linalg.solve(B, A)).real)
    return P[:modes]

L, EI = 3.0, 1.0                                       # any units: report P L^2 / EI
euler = np.pi**2 * EI / L**2
print(" ends              P_cr L^2/EI   K = L_e/L   theory K   second mode / first")
for left, right, K in [("pinned", "pinned", 1.0), ("fixed", "pinned", 0.699), ("fixed", "fixed", 0.5)]:
    P = buckling_loads(L, EI, left, right)
    print(f" {left:6} - {right:6}   {P[0] * L**2 / EI:9.3f}    {np.sqrt(euler / P[0]):7.3f}     {K:5.3f}"
          f"      {P[1] / P[0]:5.2f}")
# A flagpole (fixed at the base, free at the top) buckles like half of a pinned column twice as long
P = buckling_loads(2 * L, EI, "pinned", "pinned")
print(f" fixed  - free     {P[0] * L**2 / EI:9.3f}    {np.sqrt(euler / P[0]):7.3f}     2.000")

for N in [10, 20, 40, 80]:
    P = buckling_loads(L, EI, "pinned", "pinned", N=N)
    print(f"N = {N:3d}: pinned-pinned error {(P[0] - euler) / euler:+.2e}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The solver reproduces π2=9.870\pi^2 = 9.870 for pinned ends and finds 20.19 for fixed–pinned and 39.48 for fixed–fixed, which are effective-length factors of 0.699 and 0.500. The flagpole, solved as the lower half of a pinned column twice its length, gives π2/4=2.467\pi^2/4 = 2.467 and K=2K = 2. The second mode of a pinned column needs four times the first load (n2=4n^2 = 4), so in practice only the first matters, unless the column is braced at mid-height, which forces it into the second mode and quadruples its capacity. That is one job of the zero-force vertical L3U3L_3U_3 in the Pratt truss of Trusses and frames: it halves the unbraced length of the top chord. The error again falls fourfold each time NN doubles.

Buckling is an eigenvalue problem because the question is not "what deflection does this load cause?" but "at which loads can the part stay bent with nothing pushing it sideways?" That is the question Av=PBv\mathbf{A}\mathbf{v} = P\mathbf{B}\mathbf{v} asks, and the eigenvectors show where a designer should add bracing: at the bulges of the first mode. Finite element programs answer the same question for whole aircraft wings and ship hulls in what they call a linear buckling analysis.

ExplanationH

Why slender structures fail suddenly

Euler's column is perfectly straight and perfectly loaded, so it does nothing at all until PcrP_\text{cr}, then bends. Real columns are slightly crooked, slightly eccentrically loaded and have locked-in stresses from manufacture. Take a pinned column with a small initial bow e0e_0 at mid-height. Under a load PP the bow grows to

e=e01−P/Pcr,e = \frac{e_0}{1 - P/P_\text{cr}},

the amplification factor of a beam-column. At half the Euler load the bow has only doubled. At 90% it is ten times larger, and it grows without limit as PP approaches PcrP_\text{cr}. The bending moment PePe grows with it, until the most stressed fibre yields, the column's stiffness drops, and it collapses.

python
import numpy as np

E, fy = 210e3, 275.0                       # MPa: a structural steel

# 1. A pinned column with a small initial bow e0 at mid-height. Under load P its bow grows to
#    e0 / (1 - P/Pcr): slowly at first, then without limit as P approaches Pcr.
print(" P / Pcr   bow / initial bow")
for r in [0.1, 0.3, 0.5, 0.7, 0.8, 0.9, 0.95, 0.98]:
    print(f"  {r:4.2f}      {1 / (1 - r):6.1f}  " + "#" * int(round(1 / (1 - r))))

# 2. When does the most stressed fibre yield? Take a solid round bar (radius of gyration r =
#    d/4, extreme fibre c = d/2) bowed by e0 = L/1000. Mean stress s = P/A; Euler stress sE.
#    Yield when s + s * e0 c / r^2 / (1 - s/sE) = fy: a quadratic in s (Perry's formula).
def first_yield_stress(lam, e0_over_L=1e-3, c_over_r=2.0):
    sE = np.pi**2 * E / lam**2
    eta = e0_over_L * lam * c_over_r                 # e0 c / r^2 = (e0/L) (L/r) (c/r)
    b = fy + (1 + eta) * sE
    return (b - np.sqrt(b**2 - 4 * fy * sE)) / 2     # the smaller root

print("\n L/r    Euler (MPa)   squash (MPa)   bowed bar yields at (MPa)   fraction of the lesser")
for lam in [20, 50, 80, 87, 100, 120, 150, 200]:
    sE = np.pi**2 * E / lam**2
    s = first_yield_stress(lam)
    print(f" {lam:4d}   {sE:9.0f}      {fy:7.0f}        {s:9.0f}                    {s / min(sE, fy):5.2f}")
print(f"\nEuler stress equals the yield stress at L/r = {np.pi * np.sqrt(E / fy):.1f}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The first table is the whole story of sudden failure: nothing much to see until the load is close to critical, and then a runaway. The second shows what it means for strength. A stocky column (L/r=20L/r = 20) reaches 96% of the squash load fyAf_yA; a very slender one (L/r=200L/r = 200) reaches 92% of the Euler load. In between, near L/r≈87L/r \approx 87, where the Euler stress equals the yield stress, an initial bow of only a thousandth of the length cuts the strength to two-thirds of either simple prediction. That is why design codes do not use Euler's formula on its own: they use column curves, calibrated on thousands of tests, that blend yielding, buckling and realistic imperfections and residual stresses. Eurocode 3's buckling curves and the AISC column equation are both of this kind.

sideways deflectionload P / P_cr1perfect column: bifurcationimperfect, elasticreal: yields, peaks, collapsese₀
Load against sideways deflection for columns. A perfect elastic column stays straight until the Euler load and then bends at constant load (a bifurcation). An imperfect elastic column bends from the start, approaching the Euler load ever more steeply. A real column also yields: its load peaks below the Euler load and then falls, so past the peak it cannot carry even the load that bent it.

Two more effects make slender structures treacherous. First, post-buckling behaviour differs between structures. A column, once buckled, carries roughly its buckling load (until it yields); a flat plate supported on its edges can carry well above its buckling load, which aircraft skins exploit. But a thin cylindrical shell under axial compression, a drinks can or a rocket's propellant tank, loses most of its load the instant it buckles, and tiny dents reduce its buckling load to a fraction of the theoretical value. Designers of launch vehicles apply empirical knockdown factors to shell buckling loads; NASA's guidance on them dates from the 1960s and has been revisited with modern tests and simulations. Second, buckling takes many forms: local buckling of thin flanges and webs, lateral-torsional buckling of beams whose compression flange is free to swing sideways, and snap-through of shallow arches and domes.

ExplanationH

In professional practice

Codes. Structural design codes check every compression member against a column curve and every beam against lateral-torsional buckling, with effective-length rules for the ends. Because no real connection is perfectly rigid, design guides recommend effective-length factors somewhat larger than the theoretical 0.5 and 0.7 for nominally fixed ends. Deflection limits appear in the serviceability rules. The documents are linked in the references; read the current edition rather than a summary.

Analysis. Finite element programs offer two kinds of buckling analysis. A linear (eigenvalue) buckling analysis solves exactly the problem in the block above, for the whole structure, and reports buckling loads and mode shapes. A nonlinear analysis follows the load–deflection path of an imperfect structure, with plasticity and large deflections, past the peak if it uses an arc-length method; it is what the figure above sketches, and it is needed for shells and for anything near the yield-and-buckle crossover. Engineers often seed the nonlinear model with an imperfection shaped like the first buckling mode, scaled to the fabrication tolerance.

Temporary works. Many structural collapses happen during construction, when props, formwork supports and partially built frames carry load before their bracing is in place. In 1970 two steel box-girder bridges collapsed during erection, at Milford Haven in Wales and the West Gate Bridge in Melbourne, after thin plates in the girders buckled; the inquiries reshaped how steel box girders are designed. Construction sites therefore treat temporary works as designed structures, checked by a competent engineer, with guidance from bodies such as the UK's Health and Safety Executive.

Machines. In machine design, deflection is usually the governing criterion: shaft slopes at bearings, the stiffness of a machine-tool frame, the sag of a robot arm. Long, thin compression members in machines, such as hydraulic cylinder rods, lead screws and connecting rods, are checked for buckling with the same Euler and column-curve ideas.

History & global context

From the elastica to column curves

Jacob Bernoulli worked on the shape of a bent elastic strip in the 1690s, recognising that its curvature is proportional to the bending moment. Leonhard Euler, encouraged by Daniel Bernoulli, solved the whole family of such shapes, the elastica, in an appendix to his 1744 book on the calculus of variations, and found the critical load of a column there; he returned to columns in 1757. Joseph-Louis Lagrange found the higher modes in 1770. For a century the formula was of little practical use, since the timber and masonry columns of the time were stocky, but iron and steel made slender members common, and the formula was found to overestimate the strength of intermediate columns. In the 1880s and 1890s Ludwig von Tetmajer tested hundreds of columns in Zürich, while Friedrich Engesser and Armand Considère proposed using the reduced, tangent stiffness of a partly yielded material; the puzzle of which modulus to use was finally resolved by Francis Shanley in 1947. The Quebec Bridge collapse of 1907 and the box-girder collapses of 1970 each led to new research and new design rules for compression members and plates.

Common misconceptionsH

Common misconceptions

Misconception

"Buckling is a failure of the material." Elastic buckling is a failure of shape: the material is still elastic, and a buckled ruler springs back when you let go. That is why Euler's load contains the stiffness EE and not the strength. Only for stocky columns does yielding take part.

Misconception

"A column twice as long carries half the load." Euler's load falls with the square of the length: twice as long, a quarter of the load. Bracing a column at mid-height therefore quadruples its elastic buckling load.

Misconception

"If the stress is below the yield strength, the column is safe." A slender strut can buckle at a stress far below yield: the 40 mm bar above buckles at 52 MPa. Every compression member needs a stability check as well as a stress check.

Misconception

"Deflection is proportional to load, so I can scale my answer." For beams in bending, yes, while they stay elastic and deflections stay small. But a member that carries axial compression as well as bending is a beam-column, whose deflection grows faster than the load and without limit as the load approaches the buckling load. Superposition does not apply to it.

Misconception

"Adding a support always helps." It usually reduces moments and deflections, as the third roller did. But it makes the beam indeterminate, so settlement of that support, temperature changes or a support that is slightly too high can introduce moments of their own, sometimes larger than the ones removed.

Exercises

Exercises

1. Deflection and buckling

Warm-upHuman

A steel cantilever (E=200E = 200 GPa) is 1.0 m long, with a solid rectangular section 50 mm wide and 30 mm deep. A load of 1350 N hangs from its free end. How far does the tip deflect, in mm? (Ignore the beam's own weight.)

2. Deflection and buckling

Warm-upHuman

A simply supported beam carries a uniform load of ww kN per metre. If its span is doubled, keeping the same beam and the same load per metre, by what factor does its mid-span deflection increase?

3. Deflection and buckling

CoreHuman

Four steel columns have the same cross-section. Which one has the lowest elastic buckling load?

Choose one

4. Deflection and buckling

CoreHuman

A steel strut (E=200E = 200 GPa) is 3.0 m long and pinned at both ends. The second moment of area of its section about the weaker axis is 2.0×106 mm42.0 \times 10^6\ \text{mm}^4. What is its Euler buckling load, to the nearest kN?

5. Deflection and buckling

CoreHuman

A uniform beam 6.0 m long is clamped at its left end and rests on a prop at its right end. It carries a uniform load of 8 kN/m. Using compatibility (the prop stops the tip from moving), find the magnitude of the bending moment at the clamp, in kN m.

6. Deflection and buckling

CoreHuman

Which of these statements about buckling are true? Select all that apply.

Choose all that apply

7. Deflection and buckling

CoreComputational

Write deflection_from_moment(x, M, EI, xa, xb). The array x holds increasing positions along a beam (m), M the bending moment at those positions (N m, sagging positive), EI the flexural rigidity (N m²), and xa, xb the positions of two supports (somewhere within x; not necessarily at its ends). Return a NumPy array of the deflection v (m, upwards positive) at every position in x.

Integrate the curvature M / EI twice with the trapezoidal rule, then add the straight line C1x+C2C_1 x + C_2 that makes v zero at both supports.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

8. Deflection and buckling

StretchComputational

Write euler_fd(L, EI, n) that estimates the buckling load of a pinned–pinned column from EI v′′+P v=0EI\,v'' + P\,v = 0, v(0)=v(L)=0v(0) = v(L) = 0, using finite differences on n equal intervals of length h=L/nh = L/n.

With the central difference vi′′≈(vi−1−2vi+vi+1)/h2v''_i \approx (v_{i-1} - 2v_i + v_{i+1})/h^2 at the interior nodes i=1,…,n−1i = 1, \dots, n-1 (and v0=vn=0v_0 = v_n = 0), the equation becomes Kv=Pv\mathbf{K}\mathbf{v} = P\mathbf{v}, where K=(EI/h2)×\mathbf{K} = (EI/h^2) \times the tridiagonal matrix with 2 on the diagonal and −1 beside it. Return the smallest eigenvalue of K\mathbf{K} as a float.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Further reading and resources