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.
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: . 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 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.
The moment–curvature equation
Definition— elastic curve
The elastic curve is the deflection of the beam's neutral axis, positive upwards. For small slopes, the curvature is , so the flexure theorem becomes the moment–curvature equation (the Euler–Bernoulli beam equation)
with positive when it makes the beam sag. The product 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, ; at a clamped (built-in) end, and ; at a free end, nothing is prescribed about (instead there).
Example— A simply supported beam under a uniform load
A beam of span carries per unit length downwards. Its reactions are each, so . Integrate twice:
At , gives ; at , gives . At mid-span,
Two more results are worth remembering, because they are the building blocks of superposition: a simply supported beam with a central point load deflects at mid-span, and a cantilever with a point load at its tip deflects 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.
Computing it: integrating the curvature numerically
The hand integration works for simple loads. For any , a computer does the same thing with the trapezoidal rule: integrate once for the slope and again for the deflection, then add the straight line 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 () spanning 6 m under 10 kN/m, and for a 2 m cantilever with 5 kN at its tip.
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")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 with four intervals to 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.
Superposition and indeterminate beams
The moment–curvature equation is linear: double the load and you double , 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:
- Remove enough supports to make the beam determinate. The removed reactions are the redundants.
- Compute the deflection at each removed support under the actual loads.
- Compute the deflection there under a unit force at the same point.
- Choose the redundant so that the two deflections cancel.
Example— A propped cantilever
A beam of length is clamped at the left and rests on a prop at the right, under a uniform load . Remove the prop: the cantilever's tip deflects downwards. A force pushing up at the tip lifts it by . The prop holds the tip at zero, so
The clamp carries the other and a moment of . Notice that 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.
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")The propped cantilever's prop force comes out at exactly 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.
Euler buckling
Now load a slender column along its axis. A perfectly straight column under a compressive force simply shortens. But suppose it bends sideways by a small amount . The load, still vertical, now has a lever arm: it creates a bending moment that bends the column further in the same direction. Meanwhile the column's stiffness tries to straighten it. For small 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 and flexural rigidity , pinned at both ends, can be in equilibrium in a bent shape only when the axial load is
The smallest, , is the Euler buckling load, and the buckled shape is a half sine wave.
Proof
With , the moment–curvature equation becomes . Write ; the general solution is . The pin at requires . The pin at requires . Either , the straight column, or , which needs , that is . At those loads, and only those, the bent shape is an equilibrium for any small amplitude .
∎
The amplitude 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 the straight equilibrium path meets a bent one, and the straight one becomes unstable.
Definition— effective length and slenderness
For other end conditions, , where is the effective length, the length of the half sine wave in the buckled shape: for pinned–pinned, for fixed–free (a flagpole), for fixed–pinned, for fixed–fixed. Dividing by the area and writing , with the radius of gyration, gives the critical stress
which depends only on the material's stiffness and the slenderness ratio .
Example— A bar and a tube
A pinned steel strut 2.0 m long must be made from about 1250 mm² of steel ( GPa, yield strength 275 MPa). As a solid bar of 40 mm diameter, and
a critical stress of only 51.8 MPa, less than a fifth of the yield strength. Its radius of gyration is mm, so its slenderness is 200. Roll slightly less steel, 1209 mm², into a tube 90 mm across with a 4.5 mm wall: , nine times more, and 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.
Computing it: buckling as an eigenvalue problem
For end conditions other than pins, it is easiest to differentiate the equation twice, giving , which holds whatever the supports. Replace the derivatives by finite differences on intervals and the equation becomes a matrix problem, : 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.
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}")The solver reproduces 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 and . The second mode of a pinned column needs four times the first load (), 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 in the Pratt truss of Trusses and frames: it halves the unbraced length of the top chord. The error again falls fourfold each time 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 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.
Why slender structures fail suddenly
Euler's column is perfectly straight and perfectly loaded, so it does nothing at all until , 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 at mid-height. Under a load the bow grows to
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 approaches . The bending moment grows with it, until the most stressed fibre yields, the column's stiffness drops, and it collapses.
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}")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 () reaches 96% of the squash load ; a very slender one () reaches 92% of the Euler load. In between, near , 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.
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.
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.
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 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 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
1. Deflection and buckling
Warm-upHumanA steel cantilever ( 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-upHumanA simply supported beam carries a uniform load of 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
CoreHumanFour steel columns have the same cross-section. Which one has the lowest elastic buckling load?
4. Deflection and buckling
CoreHumanA steel strut ( GPa) is 3.0 m long and pinned at both ends. The second moment of area of its section about the weaker axis is . What is its Euler buckling load, to the nearest kN?
5. Deflection and buckling
CoreHumanA 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
CoreHumanWhich of these statements about buckling are true? Select all that apply.
7. Deflection and buckling
CoreComputationalWrite 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 that makes v zero at both supports.
8. Deflection and buckling
StretchComputationalWrite euler_fd(L, EI, n) that estimates the buckling load of a pinned–pinned column from , , using finite differences on n equal intervals of length .
With the central difference at the interior nodes (and ), the equation becomes , where the tridiagonal matrix with 2 on the diagonal and −1 beside it. Return the smallest eigenvalue of as a float.
Further reading and resources
- Theory of Elastic Stability · Stephen P. Timoshenko and James M. Gere · 1961The classic treatment of the buckling of columns, beams, plates and shells; reprinted by Dover.
- MIT OpenCourseWare 2.001, Mechanics and Materials I · Massachusetts Institute of TechnologyLecture notes and problems on beam deflection and column buckling.
- Eurocodes: building the future (European Commission Joint Research Centre)Background to EN 1993-1-1, whose column buckling curves turn the ideas of this lesson into design rules.
- American Institute of Steel Construction (AISC)Publishes the US specification for structural steel, including its rules for columns and effective length.
- NASA Technical Reports ServerHolds NASA's design monographs and research reports on the buckling of thin-walled shells, including the work on knockdown factors for launch-vehicle structures.