Column Buckling

When a slender column is compressed, it doesn't fail by crushing — it buckles sideways. This sudden instability can be catastrophic, so understanding buckling is crucial for structural design.

Euler's Critical Load

For a perfectly straight, elastic column with pinned ends:

$$P_{cr} = \frac{\pi^2 EI}{L^2}$$

Where:

• $P_{cr}$ = Critical buckling load (N)
• $E$ = Young's modulus (Pa)
• $I$ = Minimum moment of inertia (m⁴)
• $L$ = Column length (m)

Effective Length and End Conditions

Different end conditions change the buckling behavior. We use an effective length $L_e = KL$:

$$P_{cr} = \frac{\pi^2 EI}{(KL)^2} = \frac{\pi^2 EI}{L_e^2}$$

import numpy as np
import matplotlib.pyplot as plt

class ColumnBuckling:
    """Column buckling analysis."""

    # Effective length factors
    K_FACTORS = {
        'pinned_pinned': 1.0,
        'fixed_free': 2.0,
        'fixed_pinned': 0.7,
        'fixed_fixed': 0.5
    }

    @staticmethod
    def critical_load(E_GPa, I_mm4, L_mm, end_condition='pinned_pinned'):
        """
        Calculate Euler critical buckling load.

        Parameters:
        -----------
        E_GPa : float - Young's modulus in GPa
        I_mm4 : float - Minimum moment of inertia in mm⁴
        L_mm : float - Column length in mm
        end_condition : str - End condition type

        Returns:
        --------
        dict with critical load and related values
        """
        K = ColumnBuckling.K_FACTORS.get(end_condition, 1.0)
        L_e = K * L_mm  # Effective length

        E = E_GPa * 1e3  # MPa (N/mm²)

        # Euler critical load
        P_cr = np.pi**2 * E * I_mm4 / L_e**2  # N

        return {
            'P_cr_kN': P_cr / 1000,
            'K': K,
            'L_e_mm': L_e,
            'end_condition': end_condition
        }

    @staticmethod
    def slenderness_ratio(L_mm, r_mm, end_condition='pinned_pinned'):
        """
        Calculate slenderness ratio.

        Parameters:
        -----------
        L_mm : float - Column length
        r_mm : float - Radius of gyration (r = sqrt(I/A))
        """
        K = ColumnBuckling.K_FACTORS.get(end_condition, 1.0)
        L_e = K * L_mm
        slenderness = L_e / r_mm

        return {
            'slenderness': slenderness,
            'L_e': L_e,
            'r': r_mm,
            'is_long': slenderness > 120,  # Typical threshold
            'is_short': slenderness < 30
        }

    @staticmethod
    def critical_stress(E_GPa, slenderness):
        """
        Critical stress from Euler formula.

        σ_cr = π²E / λ²
        """
        E = E_GPa * 1e3  # MPa
        sigma_cr = np.pi**2 * E / slenderness**2
        return sigma_cr


# Example: Steel column
E = 200  # GPa
L = 3000  # mm
d = 100  # mm diameter circular column

# Section properties
A = np.pi * (d/2)**2
I = np.pi * d**4 / 64
r = np.sqrt(I / A)  # Radius of gyration

print("Column Buckling Analysis")
print(f"Steel column: Ø{d} mm, L = {L} mm")
print(f"Area: {A:.1f} mm², I: {I:.2e} mm⁴")
print(f"Radius of gyration: {r:.2f} mm")
print("=" * 50)

for condition in ColumnBuckling.K_FACTORS.keys():
    result = ColumnBuckling.critical_load(E, I, L, condition)
    sr = ColumnBuckling.slenderness_ratio(L, r, condition)

    print(f"\n{condition.replace('_', '-').title()}:")
    print(f"  K = {result['K']}, Le = {result['L_e_mm']:.0f} mm")
    print(f"  Slenderness ratio λ = {sr['slenderness']:.1f}")
    print(f"  Critical load Pcr = {result['P_cr_kN']:.2f} kN")

Slenderness Ratio

The slenderness ratio $\lambda$ characterizes column behavior:

$$\lambda = \frac{L_e}{r}$$

Where $r = \sqrt{I/A}$ is the radius of gyration.

• Short columns ($\lambda < 30$): Fail by yielding
• Intermediate ($30 < \lambda < 120$): Inelastic buckling
• Long columns ($\lambda > 120$): Euler buckling

def column_classification(slenderness, Sy_MPa, E_GPa):
    """
    Classify column behavior and determine failure mode.
    """
    E = E_GPa * 1e3  # MPa

    # Transition slenderness (where Euler stress = yield stress)
    lambda_c = np.pi * np.sqrt(E / Sy_MPa)

    # Euler critical stress
    sigma_cr = np.pi**2 * E / slenderness**2 if slenderness > 0 else float('inf')

    if slenderness < lambda_c / 2:
        mode = "Short column - yielding"
        sigma_fail = Sy_MPa
    elif slenderness < lambda_c:
        mode = "Intermediate - inelastic buckling"
        # Johnson formula (parabolic)
        sigma_fail = Sy_MPa * (1 - (Sy_MPa / (4 * np.pi**2 * E)) * slenderness**2)
    else:
        mode = "Long column - Euler buckling"
        sigma_fail = sigma_cr

    return {
        'mode': mode,
        'sigma_fail_MPa': sigma_fail,
        'sigma_euler_MPa': sigma_cr,
        'lambda_c': lambda_c,
        'slenderness': slenderness
    }

# Classify different columns
print("\nColumn Classification (Steel, Sy=250 MPa):")
print("-" * 50)

for lam in [20, 60, 100, 150, 200]:
    result = column_classification(lam, Sy_MPa=250, E_GPa=200)
    print(f"λ = {lam:3d}: {result['mode']}")
    print(f"        Failure stress: {result['sigma_fail_MPa']:.1f} MPa")

Buckling Curve Visualization

def plot_buckling_curve(Sy_MPa=250, E_GPa=200):
    """
    Plot column buckling curve showing different failure regions.
    """
    E = E_GPa * 1e3

    # Slenderness range
    lam = np.linspace(1, 250, 500)

    # Euler curve
    sigma_euler = np.pi**2 * E / lam**2

    # Transition point
    lambda_c = np.pi * np.sqrt(E / Sy_MPa)

    # Johnson parabola (for intermediate columns)
    sigma_johnson = Sy_MPa * (1 - (Sy_MPa / (4 * np.pi**2 * E)) * lam**2)

    # Combined curve
    sigma_combined = np.where(lam < lambda_c, sigma_johnson, sigma_euler)
    sigma_combined = np.minimum(sigma_combined, Sy_MPa)  # Cap at yield

    # Plot
    fig, ax = plt.subplots(figsize=(12, 7))

    ax.plot(lam, sigma_euler, 'b--', lw=2, label='Euler (elastic buckling)')
    ax.plot(lam, sigma_johnson, 'g--', lw=2, label='Johnson (inelastic)')
    ax.plot(lam, sigma_combined, 'r-', lw=3, label='Design curve')
    ax.axhline(y=Sy_MPa, color='orange', linestyle=':', lw=2, label=f'Yield Sy={Sy_MPa} MPa')
    ax.axvline(x=lambda_c, color='gray', linestyle='--', alpha=0.5)

    # Regions
    ax.fill_between(lam, 0, sigma_combined,
                   where=(lam < 30), alpha=0.2, color='red', label='Short (yielding)')
    ax.fill_between(lam, 0, sigma_combined,
                   where=((lam >= 30) & (lam < lambda_c)), alpha=0.2, color='yellow')
    ax.fill_between(lam, 0, sigma_combined,
                   where=(lam >= lambda_c), alpha=0.2, color='blue')

    ax.annotate(f'λc = {lambda_c:.0f}', xy=(lambda_c, 50),
               fontsize=11, ha='center')

    ax.set_xlabel('Slenderness Ratio λ = Le/r', fontsize=12)
    ax.set_ylabel('Critical Stress σcr (MPa)', fontsize=12)
    ax.set_title('Column Buckling Curve', fontsize=14)
    ax.set_xlim(0, 250)
    ax.set_ylim(0, Sy_MPa * 1.2)
    ax.legend(loc='upper right')
    ax.grid(True, alpha=0.3)

    plt.tight_layout()
    plt.show()

plot_buckling_curve()

Column Design

def design_column(P_kN, L_mm, E_GPa, Sy_MPa, FoS, end_condition='pinned_pinned',
                  section_type='circular'):
    """
    Design a column for given axial load.

    Parameters:
    -----------
    P_kN : float - Design load
    L_mm : float - Column length
    E_GPa : float - Young's modulus
    Sy_MPa : float - Yield strength
    FoS : float - Factor of safety
    end_condition : str - End support condition
    section_type : str - 'circular' or 'square'
    """
    P = P_kN * 1000  # N
    E = E_GPa * 1e3  # MPa
    K = ColumnBuckling.K_FACTORS.get(end_condition, 1.0)
    L_e = K * L_mm

    print(f"Column Design")
    print(f"Load: {P_kN} kN, Length: {L_mm} mm")
    print(f"End condition: {end_condition} (K={K})")
    print(f"Effective length: {L_e} mm")
    print(f"Required FoS: {FoS}")
    print("=" * 50)

    # Required critical load
    P_cr_required = P * FoS  # N

    # Initial guess: assume long column (Euler)
    # P_cr = π²EI/Le² => I = P_cr*Le²/(π²E)
    I_required = P_cr_required * L_e**2 / (np.pi**2 * E)

    if section_type == 'circular':
        # I = πd⁴/64 => d = (64I/π)^0.25
        d_euler = (64 * I_required / np.pi) ** 0.25
        print(f"\nInitial estimate (Euler): d = {d_euler:.1f} mm")

        # Standard sizes
        standard_sizes = [30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 140, 160]
        d_selected = next((s for s in standard_sizes if s >= d_euler), standard_sizes[-1])

        # Check with selected size
        A = np.pi * (d_selected/2)**2
        I = np.pi * d_selected**4 / 64
        r = np.sqrt(I / A)

    else:  # square
        # I = b⁴/12 => b = (12I)^0.25
        b_euler = (12 * I_required) ** 0.25
        print(f"\nInitial estimate (Euler): b = {b_euler:.1f} mm")

        standard_sizes = [30, 40, 50, 60, 70, 80, 90, 100, 120, 140]
        d_selected = next((s for s in standard_sizes if s >= b_euler), standard_sizes[-1])

        A = d_selected**2
        I = d_selected**4 / 12
        r = np.sqrt(I / A)

    # Check slenderness and actual failure mode
    slenderness = L_e / r
    classification = column_classification(slenderness, Sy_MPa, E_GPa)

    # Actual critical load
    sigma_cr = classification['sigma_fail_MPa']
    P_cr_actual = sigma_cr * A / 1000  # kN

    actual_fos = P_cr_actual / P_kN

    print(f"\nSelected size: {d_selected} mm {'diameter' if section_type == 'circular' else 'square'}")
    print(f"Area: {A:.1f} mm², I: {I:.2e} mm⁴")
    print(f"Radius of gyration: {r:.2f} mm")
    print(f"Slenderness ratio: {slenderness:.1f}")
    print(f"Failure mode: {classification['mode']}")
    print(f"Critical stress: {sigma_cr:.1f} MPa")
    print(f"Critical load: {P_cr_actual:.1f} kN")
    print(f"Actual FoS: {actual_fos:.2f}")

    if actual_fos < FoS:
        print(f"\n⚠️  FoS inadequate! Try larger size.")
    else:
        print(f"\n✓ Design OK")

    return d_selected

# Example
d = design_column(
    P_kN=200,
    L_mm=4000,
    E_GPa=200,
    Sy_MPa=250,
    FoS=2.5,
    end_condition='pinned_pinned',
    section_type='circular'
)

Effect of End Conditions

def compare_end_conditions(P_kN, E_GPa, I_mm4, A_mm2):
    """Compare critical lengths for different end conditions."""

    E = E_GPa * 1e3
    P = P_kN * 1000

    print("Critical Lengths for Different End Conditions")
    print(f"Load: {P_kN} kN, E: {E_GPa} GPa")
    print(f"I: {I_mm4:.2e} mm⁴")
    print("=" * 50)

    # Critical length: L = π*sqrt(EI/P) / K
    L_base = np.pi * np.sqrt(E * I_mm4 / P)

    for condition, K in ColumnBuckling.K_FACTORS.items():
        L_cr = L_base / K
        print(f"\n{condition.replace('_', '-').title()}:")
        print(f"  K = {K}")
        print(f"  Critical length Lcr = {L_cr:.0f} mm ({L_cr/1000:.2f} m)")
        print(f"  Relative to pinned-pinned: {1/K:.2f}x")

# Example with 80mm diameter column
d = 80
I = np.pi * d**4 / 64
A = np.pi * (d/2)**2

compare_end_conditions(P_kN=300, E_GPa=200, I_mm4=I, A_mm2=A)

Key Takeaways

• Euler's formula: $P_{cr} = \pi^2 EI / L_e^2$ — for elastic buckling
• Effective length: $L_e = KL$ — depends on end conditions
• Slenderness ratio: $\lambda = L_e/r$ — determines failure mode
• Long columns buckle elastically; short columns yield
• Fixed ends dramatically increase buckling resistance (K=0.5 vs 2.0)

Next lesson: We'll explore strain energy methods for solving structural problems.