# ========================= # Column Buckling Calculator — Euler Elastic (Rectangular Section) # ========================= import math import gradio as gr import pandas as pd SCOPE_MD = """ ### Scope & Assumptions - **Problem:** Axially compressed **prismatic column** (rectangular cross-section), **Euler elastic buckling**. - **Outputs:** Governing critical load \(P_{cr}\), governing axis, slenderness \(λ\), factor of safety vs. applied load \(P\), verdict. - **Method:** Euler buckling (linear-elastic, small deflection), **no inelastic (Johnson)**, **no eccentricity**, **no imperfections**. - **Section:** Rectangle (width \(b\), height \(h\)); checks both axes and picks the **weaker axis** (smaller \(P_{cr}\)). - **End conditions:** Choose \(K\): Fixed–Fixed (0.5), Fixed–Pinned (0.7), Pinned–Pinned (1.0), Fixed–Free (2.0). - **Units:** SI (m, N, GPa, MPa). Input \(P\) in kN. Results show \(P_{cr}\) in **kN**. ### Valid Ranges (hard checks) - 0.1 < L ≤ 20 m - 0 < P ≤ 5*10^6 N - 1 ≤ E ≤ 400 GPa - 10 ≤ Sy ≤ 3000 MPa (for context only; not used in Euler (P_{cr}\) - 0.005 < b ≤ 2 m - 0.005 < h ≤ 2 m """ # ----- Validation ----- def _validate_inputs(L_m, P_kN, E_GPa, Sy_MPa, b_m, h_m): errs = [] def in_range(name, val, lo, hi): if not (lo < val <= hi): errs.append(f"{name} must be in ({lo}, {hi}] (got {val}).") in_range("Length L [m]", L_m, 0.1, 20.0) in_range("Load P [kN]", P_kN, 0.0, 5000.0) # 5e6 N in_range("Elastic modulus E [GPa]", E_GPa, 1.0, 400.0) in_range("Yield strength Sy [MPa]", Sy_MPa, 10.0, 3000.0) in_range("Width b [m]", b_m, 0.005, 2.0) in_range("Height h [m]", h_m, 0.005, 2.0) if errs: raise ValueError("\n".join(errs)) # ----- Core Math ----- def euler_buckling_rect(L_m, P_kN, E_GPa, Sy_MPa, b_m, h_m, K): """ Euler elastic buckling for a rectangular column. Checks both principal axes and selects the governing (smaller Pcr). """ _validate_inputs(L_m, P_kN, E_GPa, Sy_MPa, b_m, h_m) # SI conversions P_applied_N = float(P_kN) * 1e3 E_Pa = float(E_GPa) * 1e9 # Section properties A = b_m * h_m Ix = b_m * (h_m**3) / 12.0 Iy = h_m * (b_m**3) / 12.0 rx = (Ix / A) ** 0.5 ry = (Iy / A) ** 0.5 KL = K * L_m Pcr_x = (math.pi**2) * E_Pa * Ix / (KL**2) Pcr_y = (math.pi**2) * E_Pa * Iy / (KL**2) # Governing axis (smaller Pcr) if Pcr_x <= Pcr_y: axis = "x (buckles about the weak direction of Ix → bending about h)" Pcr = Pcr_x r_govern = rx I_govern = Ix else: axis = "y (buckles about the weak direction of Iy → bending about b)" Pcr = Pcr_y r_govern = ry I_govern = Iy slenderness = KL / r_govern if r_govern > 0 else math.inf fos = Pcr / P_applied_N if P_applied_N > 0 else math.inf ok = P_applied_N <= Pcr # Pretty print helpers def _fmt(x, d=6): try: return f"{x:.{d}g}" except Exception: return str(x) steps_md = "\n".join([ "## Show the math (Euler elastic buckling)", f"L = {_fmt(L_m)} m, K = {_fmt(K)}, KL = {K} * {L_m} = {KL:.6g} m", f"E = {_fmt(E_GPa)} GPa, P = {_fmt(P_kN)} kN (= {P_applied_N:.6g} N)", f"b = {_fmt(b_m)} m, h = {_fmt(h_m)} m", "", "Area and moments of inertia:", f"A = b * h = {b_m} * {h_m} = {A:.6e} m^2", f"Ix = b * h^3 / 12 = {b_m} * {h_m}^3 / 12 = {Ix:.6e} m^4", f"Iy = h * b^3 / 12 = {h_m} * {b_m}^3 / 12 = {Iy:.6e} m^4", f"rx = sqrt(Ix / A) = sqrt({Ix:.6e} / {A:.6e}) = {rx:.6e} m", f"ry = sqrt(Iy / A) = sqrt({Iy:.6e} / {A:.6e}) = {ry:.6e} m", "", "Euler critical loads:", "Pcr = π^2 * E * I / (K*L)^2", f"Pcr_x = (π^2) * ({E_GPa} * 10^9) * ({Ix:.6e}) / ({K} * {L_m})^2 = {Pcr_x:.6e} N", f"Pcr_y = (π^2) * ({E_GPa} * 10^9) * ({Iy:.6e}) / ({K} * {L_m})^2 = {Pcr_y:.6e} N", f"Governing axis: {axis}", f"Pcr(governing) = {Pcr:.6e} N = {Pcr/1e3:.3f} kN", "", "Slenderness (governing axis):", f"λ = (K*L) / r_governing = {KL:.6g} / {r_govern:.6e} = {slenderness:.2f}", "", "Check vs applied load:", f"FoS_buckling = Pcr / P = {Pcr:.6e} / {P_applied_N:.6e} = {fos:.3f}", f"Verdict: {'OK (no buckling at P)' if ok else 'NOT OK (buckles at P)'}" ]) results = { "A_m2": A, "Ix_m4": Ix, "Iy_m4": Iy, "rx_m": rx, "ry_m": ry, "Pcr_x_N": Pcr_x, "Pcr_y_N": Pcr_y, "Pcr_governing_N": Pcr, "P_applied_N": P_applied_N, "FoS_buckling": fos, "governing_axis": axis, "slenderness_governing": slenderness, "ok": bool(ok), } verdict = { "message": "OK: no Euler buckling at the applied load" if ok else "NOT OK: Euler buckling likely at the applied load", "governing_axis": axis } return results, verdict, steps_md # ----- Gradio glue ----- END_CONDITIONS = { "Fixed–Fixed (K=0.5)": 0.5, "Fixed–Pinned (K=0.7)": 0.7, "Pinned–Pinned (K=1.0)": 1.0, "Fixed–Free / Cantilever (K=2.0)": 2.0, } def run_once(L_m, P_kN, E_GPa, Sy_MPa, b_m, h_m, end_condition): try: K = END_CONDITIONS[end_condition] res, ver, steps = euler_buckling_rect( float(L_m), float(P_kN), float(E_GPa), float(Sy_MPa), float(b_m), float(h_m), float(K) ) df = pd.DataFrame([{ "Pcr_x [kN]": round(res["Pcr_x_N"]/1e3, 3), "Pcr_y [kN]": round(res["Pcr_y_N"]/1e3, 3), "Pcr (governing) [kN]": round(res["Pcr_governing_N"]/1e3, 3), "Applied P [kN]": round(res["P_applied_N"]/1e3, 3), "FoS_buckling [-]": round(res["FoS_buckling"], 3), "Slenderness (λ)": round(res["slenderness_governing"], 2), "Governing axis": res["governing_axis"], "Verdict": ver["message"], }]) explain = ( f"Column buckles about {res['governing_axis']}: " f"Pcr={res['Pcr_governing_N']/1e3:.2f} kN vs P={res['P_applied_N']/1e3:.2f} kN " f"(FoS={res['FoS_buckling']:.2f}) → {ver['message']}." ) return df, explain, steps, "" except Exception as e: return pd.DataFrame(), "", "", f"Input error:\n{e}" with gr.Blocks(title="Column Buckling — Euler Elastic") as demo: gr.Markdown("# Column Buckling Calculator — Euler Elastic (Rectangular Section)") gr.Markdown(SCOPE_MD) with gr.Row(): with gr.Column(): gr.Markdown("### Geometry & Material") L_m = gr.Number(value=3.0, label="Length L [m]") b_m = gr.Number(value=0.06, label="Width b [m]") h_m = gr.Number(value=0.10, label="Height h [m]") E_GPa = gr.Number(value=200., label="Elastic modulus E [GPa]") Sy_MPa= gr.Number(value=250., label="Yield strength Sy [MPa] (context)") with gr.Column(): gr.Markdown("### Load & End Condition") P_kN = gr.Number(value=200.0, label="Applied load P [kN]") end_condition = gr.Radio( list(END_CONDITIONS.keys()), value="Pinned–Pinned (K=1.0)", label="End conditions (effective-length factor K)" ) run_btn = gr.Button("Compute") gr.Markdown("### Results") results_df = gr.Dataframe(label="Numerical results", interactive=False) gr.Markdown("### Explain the result") explain_md = gr.Markdown() gr.Markdown("### Show the math") steps_md = gr.Markdown() err_box = gr.Textbox(label="Errors", interactive=False) run_btn.click( fn=run_once, inputs=[L_m, P_kN, E_GPa, Sy_MPa, b_m, h_m, end_condition], outputs=[results_df, explain_md, steps_md, err_box] ) if __name__ == "__main__": demo.launch(debug=False)