|
|
|
|
|
|
|
|
|
|
|
|
|
|
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 |
|
|
""" |
|
|
|
|
|
|
|
|
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) |
|
|
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)) |
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
P_applied_N = float(P_kN) * 1e3 |
|
|
E_Pa = float(E_GPa) * 1e9 |
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
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) |
|
|
|
