Inelastic Column Buckling

Inelastic Column Buckling (structures/fem/inelastic-column-buckling)

Use when the task is the inelastic column strength of a whole solid, round, tube or extruded compression member in the intermediate slenderness band: the yield-anchored Euler-Johnson tangent column strength curve F_col(lambda) whose Johnson parabola arm F_col = F_cy*(1 - F_cylambda^2/(4pi^2E)) interpolates between the yield anchor F_col = F_cy at lambda = 0 and the tangent point F_col = F_cy/2 at the transition lambda_t = sqrt(2pi^2E/F_cy), where it meets the Euler arm F_col = pi^2E/lambda^2 with equal slope. The curve is the standard Johnson form of the published Euler-Johnson tangent column strength curve (Bruhn column analysis chapter, Niu column allowable curves, Timoshenko and Gere inelastic columns, Roark columns chapter; public engineering science, summary paraphrase only). The logic module is pure Python standard library and deterministic. Units are SI: E and F_cy in Pa, L and r in m, A in m^2, forces in N.

The leaf pairs with the elastic Euler owner of the same member: structures/fem/buckling-analysis ends its elastic arm at the yield-crossing classification and hands the inelastic side off; this leaf takes the effective length factor K as a plain given number and reports the Euler arm only as the upper arm of the yield-anchored column strength curve, never as an elastic critical load deliverable. It re-implements the Johnson arm equation family of structures/fem/crippling-analysis re-anchored from the local crippling stress of formed sheet onto the solid-section compressive yield F_cy, covering the extruded and machined whole sections that leaf excludes. Materials/ramberg-osgood defines the material stress-strain response; this leaf consumes only the plain E and F_cy pair. The applied-load context is the certification compression case under FAR 25.301 and CS 25.301 applied loads with the 1.5 ultimate factor of FAR 25.303 and CS 25.303 (standards named and paraphrased, never reproduced).

Domain quick reference

• Effective slenderness of the member:

  lambda = K * L / r
  

  with K the effective length factor (given as a number; resolving K from the support type is the buckling-analysis sibling's job), L the physical length and r the radius of gyration of the section. Solid round rod of diameter d: A = pid^2/4, r = d/4. Round tube with outer and inner diameters d_o, d_i: A = pi(d_o^2 - d_i^2)/4, I = pi*(d_o^4 - d_i^4)/64, r = sqrt(I/A), which equals sqrt((d_o^2 + d_i^2)/16).

• Euler-Johnson tangent transition (tangency of the two arms at F_cy/2):

  lambda_t = sqrt(2 * pi^2 * E / F_cy)
  

  The elastic yield crossing of the Euler owner, lambda_1 = pi*sqrt(E/F_cy), equals lambda_t/sqrt(2): the tangent transition sits sqrt(2) higher, so the Johnson arm also covers the intermediate band where the ideal Euler stress is still below yield but real column allowables follow the parabola.

• Johnson parabola arm (lambda <= lambda_t), the inelastic column allowable stress:

  F_col = F_cy * (1 - F_cy * lambda^2 / (4 * pi^2 * E))
  

  Quadratic between the yield anchor F_cy at lambda = 0 and F_cy/2 at lambda_t; the drop from yield F_cy - F_col is exactly quadratic in lambda, so the drop at lambda_t/2 is one quarter of the drop at lambda_t.

• Euler arm (lambda > lambda_t), the elastic hyperbola of the same curve:

  F_col = pi^2 * E / lambda^2
  

• Column capacity and margin of safety:

  P_col = F_col * A        MS = P_col / P_applied - 1
  

  pass when MS >= 0. Regime: "johnson" at or below lambda_t, "euler" above.

• Materials registry pair (shared with crippling-analysis), used by the worked examples: 7075-T6 E = 71.7 GPa, F_cy = 462 MPa; 2024-T3 E = 72.4 GPa, F_cy = 290 MPa. All functions take E and F_cy as plain float arguments.

Workflow

1. Gather the member inputs and section properties: the material pair E and F_cy (Pa), the effective length factor K (a plain given number; end-condition resolution belongs to buckling-analysis), the physical length L in m, the radius of gyration r and gross section area A in m^2, and the applied axial compression P_applied in N. Solid round rod of diameter d: A = pid^2/4 and r = d/4; round tube d_o/d_i: A = pi(d_o^2 - d_i^2)/4, I = pi*(d_o^4 - d_i^4)/64 and r = sqrt(I/A).
2. Compute the effective slenderness lambda = KL/r with effective_slenderness(k_factor, length, radius_gyration). A member length L = 40r pins lambda = 40 for the stubby-column regime; L = 0.55 m at r = 0.01 m with K = 1.0 pins lambda = 55.
3. Compute the euler-johnson-tangent transition lambda_t = sqrt(2pi^2E/F_cy) with johnson_transition_slenderness(e, f_cy); lambda_t sits sqrt(2) above the elastic yield crossing lambda_1 = pi*sqrt(E/F_cy) of the buckling-analysis sibling.
4. Classify the regime with column_regime(e, f_cy, lam): "johnson" at or below lambda_t, "euler" above it. The intermediate slenderness band below lambda_t is where the yield-anchored parabola governs and the ideal Euler stress overpredicts.
5. Compute the inelastic column allowable stress F_col with column_strength_allowable(e, f_cy, lam): the johnson-parabola stress johnson_parabola_stress(e, f_cy, lam) = F_cy*(1 - F_cylam^2/(4pi^2E)) below the transition (the stubby-column-allowable) and the euler_arm_stress(e, lam) = pi^2E/lam^2 above it.
6. Compute the column capacity P_col = F_col*A with column_capacity(e, f_cy, lam, area).
7. Run the margin of safety and the verdict in one call with column_check(e, f_cy, lam, area, applied_load), which returns the dict {lambda_t, regime, F_col, P_col, margin, verdict} with verdict "pass" when margin >= 0. In the certification compression case, compare against the applied load amplified to the 1.5 ultimate factor per FAR 25.303 / CS 25.303 (summary paraphrase of the requirement, never standard text).

Worked example

Worked example 1 (corpus query 1): 7075-T6 solid round actuator rod, d = 0.04 m, E = 71.7 GPa, F_cy = 462 MPa, K = 1.0, L = 0.55 m, applied axial compression 200 kN. Real module outputs (verified identical under /usr/bin/python3 3.9.6 and pyenv 3.13.12):

• A = pi*d^2/4 = 1.2566370614359172e-03 m^2, r = d/4 = 0.01 m.
• lambda = KL/r = 55; lambda_t = sqrt(2pi^2*E/F_cy) = 55.348194774118063, so lambda 55 sits just below the transition and the regime is johnson.
• Johnson parabola stress F_col = 233897293.82113209 Pa (233.897 MPa). The Euler arm of the curve at the same lambda is 233934094.39937419 Pa (233.934 MPa), 1.573e-4 above the parabola near the tangency point; F_cy/2 = 231 MPa is 1.255e-2 below the allowable.
• P_col = F_col*A = 293924.00798520073 N (293.9 kN).
• MS = P_col/P_applied - 1 = 0.46962003992600376, verdict pass.

Worked example 2 (corpus query 2): 2024-T3 extruded round tube compression member, d_o = 0.05 m, d_i = 0.04 m (5 mm wall), E = 72.4 GPa, F_cy = 290 MPa, K = 1.0, applied axial compression 120 kN. Real module outputs:

• A = pi*(d_o^2 - d_i^2)/4 = 7.0685834705770374e-04 m^2, I = pi*(d_o^4 - d_i^4)/64 = 1.8113245143353656e-07 m^4, r = sqrt(I/A) = 0.016007810593582122 m (the round-tube identity sqrt((d_o^2 + d_i^2)/16) reproduces r exactly).
• Member length L = 40r = 0.6403124237432849 m pins lambda = KL/r = 40; lambda_t = 70.199683594869498, so lambda 40 is deep in the Johnson band (below 0.57*lambda_t) and the regime is johnson.
• Johnson parabola stress F_col = 242922035.66673699 Pa (242.922 MPa, 0.83766 of F_cy), the stubby-column-allowable. The Euler arm at the same lambda is 446599599.14929342 Pa (446.6 MPa), 1.8384482820734314 times F_col and above F_cy itself, the elastic overprediction the parabola corrects.
• P_col = F_col*A = 171711.46859528226 N (171.7 kN).
• MS = P_col/P_applied - 1 = 0.43092890496068548, verdict pass.

Curve shape (real module rows): the 7075-T6 allowable falls from the 462 MPa yield anchor through 454459414.671773 Pa at lambda 10, 341350634.748367 Pa at lambda 40, 233897293.821132 Pa at lambda 55 (johnson regime), then follows the Euler arm 196569620.988363 Pa at lambda 60, 110570411.805954 Pa at lambda 80 and 70765063.5558107 Pa at lambda 100 (euler regime). The 2024-T3 curve runs 287057627.229171 Pa at lambda 10 to 242922035.666737 Pa at lambda 40, 200993223.682425 Pa at lambda 55, 145823734.229382 Pa at lambda 70 (johnson, just below the transition) and 88217204.7702308 Pa at lambda 90, 49622177.6832548 Pa at lambda 120 (euler). Both arms return F_cy/2 at lambda_t to float roundoff and the parabola is tangent to the Euler hyperbola there.

Verification

• Worked examples: the two cases above are asserted in the contract test against the module's real outputs within the tolerances of the spec validation list.
• Tangency by construction: at lambda_t both arms return F_cy/2 (the Johnson arm, the Euler arm and their cross difference sit within 1e-12 relative, anchor residuals 2.58e-16 and 1.29e-16 for 7075-T6 and 0.0 for 2024-T3) and the closed-form slopes agree to 1e-9 relative.
• Quadratic-decay identity: 4*(F_cy - F_col(lam_t/2)) equals F_cy - F_col(lam_t) = F_cy/2 to 1e-9 relative of F_cy.
• Yield anchor: johnson_parabola_stress at lam = lam_t*1e-6 sits within 1e-9 relative of F_cy, so F_col approaches F_cy as lambda approaches zero.
• Regime flip and continuity: column_regime is johnson at lam_t*(1 - 1e-12) and euler at lam_t*(1 + 1e-12), and F_col at the upper point stays within 1e-9 relative of F_cy/2.
• The curve is strictly monotone decreasing on a dense lambda grid from 1 to 200 for both materials; the Euler arm lies strictly above the Johnson parabola inside the Johnson band, the overprediction the parabola corrects.
• ValueError rejection of non-physical inputs: zero or negative k_factor, length, radius_gyration, e, f_cy, lam, area, allowable or applied load all raise ValueError (16 cases in the contract test).
• Determinism: two identical full runs return identical bits; the canonical dump sha256 is 1f3904e5de54c994b725577b30d02c298b726db9a7a2394172f74c6c2c8e1183 on both in-process passes and under both interpreters.

Related leaves

• structures/fem/buckling-analysis: the elastic Euler arm of the same member with the end-condition effective length factor K table (pinned-pinned, fixed-fixed, fixed-pinned, cantilever), the radius-of-gyration-from-section workflow and the yield-crossing classification at lambda_1 = pi*sqrt(E/sigma_y); this leaf takes K as a number and reports the Euler arm only as the upper arm of the yield-anchored column strength curve.
• structures/fem/crippling-analysis: the same Johnson arm equation family anchored on the LOCAL crippling stress of formed sheet stiffeners (never on yield); extruded and machined whole sections are exactly the population this leaf serves on the solid-section yield.
• structures/materials/ramberg-osgood: the elastic-plastic stress-strain curve and tangent-modulus material response; this leaf characterizes the material by plain E and F_cy only.
• structures/fem/plate-buckling and structures/fem/ cylindrical-shell-buckling: local flat-panel and shell wall instability, which can govern thin formed sections and thin-walled tubes before the column curve.
• structures/fem/beam-column-analysis: the axial-plus-bending interaction check; this leaf is compression only.

Pitfalls

• Routing the elastic Euler instability here: the Euler critical load Pcr = pi^2EI/(K*L)^2 at resolved end conditions, the slenderness ratio from the radius of gyration and the yield-crossing classification with the euler_governs flag belong to structures/fem/buckling-analysis; this leaf takes K and r as given numbers.
• Reading the Euler arm below lambda_t as the allowable: inside the Johnson band the ideal Euler stress overpredicts the column strength (in the tube example it exceeds F_cy itself), exactly the overprediction the yield-anchored parabola corrects; the curve value below lambda_t is the johnson-parabola stress.
• Anchoring the parabola on the wrong stress: this leaf anchors on the solid-section compressive yield F_cy of a whole solid, round, tube or extruded member. Formed sheet stiffeners anchor on the local crippling stress F_cc and belong to structures/fem/crippling- analysis, whose scope excludes extruded and machined whole sections.
• Confusing the material curve with the column curve: the elastic-plastic stress-strain response and the secant or tangent modulus of the material itself are the ramberg-osgood leaf's content; here E and F_cy are plain material floats.
• Forgetting the wall-stability check: a thin formed section or thin-walled tube may cripple or buckle locally (plate-buckling, cylindrical-shell-buckling) before the yield-anchored column curve governs; this closed form assumes whole-section behavior.
• Mixing units: E in GPa with L and r in mm, or F_cy in MPa with A in m^2, silently corrupts F_col and P_col by factors of 1e9 or 1e6; keep everything SI (Pa, m, m^2, N).
• Applying a bending interaction: the check is axial compression only; axial-plus-bending members belong to beam-column-analysis.

Behavior contract (gate 3)

The inelastic column logic is exercised by the gate 3 contract test scripts/test_inelastic_column_buckling.py against scripts/inelastic_column_buckling_logic.py (pure stdlib unittest, offline, deterministic). It asserts the two worked examples above, the column strength curve sweeps and monotone shape for both materials, the F_cy/2 tangency of both arms at lambda_t, the slope tangency, the quadratic-decay quarter-drop identity, the yield anchor, the regime flip and continuity across the transition, the Euler-arm overprediction inside the Johnson band, the capacity and margin linearities, all ValueError rejections of non-physical inputs, and the canonical determinism digest. Run:

python3 scripts/test_inelastic_column_buckling.py

Contract test

The contract test must pass offline under BOTH interpreters used by the pre-push hook environment (31 test methods, deterministic, under 20 seconds):

/usr/bin/python3 skills/structures/fem/inelastic-column-buckling/scripts/test_inelastic_column_buckling.py

and

~/.pyenv/versions/3.13.12/bin/python3 skills/structures/fem/inelastic-column-buckling/scripts/test_inelastic_column_buckling.py

Compliance

• FAR-25 and CS-25 are referenced, not reproduced: standards-map.yaml marks them gated: false and reference-only: true. Only the summary paraphrase of the applied-load and 1.5 ultimate-factor context is used (FAR 25.301 / CS 25.301, FAR 25.303 / CS 25.303), never standard text.
• The Euler-Johnson tangent column strength curve is standard engineering methodology (Bruhn, Niu, Timoshenko and Gere, Roark), summary-only.
• compliance: STANDARDS-REF, gated: false.