Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,212 @@
+# =========================
+# 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)