Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,272 @@
+# =========================
+# Combined Loading Calculator — Circular (Solid/Hollow)
+# Axial N, Bending (Mx, My), Torsion T → σ, τ, σ_vm, FoS
+# =========================
+
+import math
+import json
+import gradio as gr
+import pandas as pd
+
+# Optional tiny LLM (safe fallback to deterministic message if not available)
+_USE_LLM = True
+try:
+    from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+    MODEL_ID = "HuggingFaceTB/SmolLM2-135M-Instruct"
+    _tok = AutoTokenizer.from_pretrained(MODEL_ID)
+    _pipe = pipeline(
+        task="text-generation",
+        model=AutoModelForCausalLM.from_pretrained(MODEL_ID),
+        tokenizer=_tok,
+    )
+except Exception:
+    _USE_LLM = False
+    _tok = None
+    _pipe = None
+
+SCOPE_MD = r"""
+### Scope & Assumptions
+- **Cross-section:** Circular shaft or beam (choose **Solid** or **Hollow**).
+- **Loads:** Axial force *N* (tension +), bending moments *Mₓ* and *Mᵧ*, and torsion *T*.
+- **Outputs:** Axial stress at the outer surface (from axial + bending), shear stress from torsion, **von Mises** equivalent stress, and **FoS** vs. yield strength *Sᵧ*.
+- **Theory:** Linear-elastic, small deformation, pure torsion (Saint-Venant), plane sections remain plane.  
+  *Excludes* stress concentrations, transverse shear (**V**), and buckling.
+- **Units:** SI — forces in **N**, moments in **N·m**, diameters in **m**, moduli/strengths in **GPa/MPa**.  
+  Results are shown in **MPa**.
+
+---
+
+### Valid ranges (hard checks)
+- 0.01 < dₒ ≤ 2.0 m  
+- 0 < dᵢ < dₒ (for hollow sections)  
+- |N| ≤ 1×10⁶ N (± tension/compression)  
+- |Mₓ|, |Mᵧ|, |T| ≤ 1×10⁶ N·m  
+- 1 ≤ E ≤ 400 GPa  
+- 10 ≤ Sᵧ ≤ 3000 MPa  
+- 0.00001 < A ≤ 1 m²
+"""
+
+
+def _validate(mode, d, do, di, N, Mx, My, T, Sy):
+    errs = []
+    def rng(name, val, lo, hi):
+        if not (lo < val <= hi):
+            errs.append(f"{name} must be in ({lo}, {hi}] (got {val}).")
+    rng("Sy [MPa]", Sy, 10, 3000)
+    if mode == "Solid":
+        rng("d [m]", d, 1e-4, 2.0)
+    else:
+        rng("Do [m]", do, 1e-4, 2.0)
+        rng("Di [m]", di, 0.0, do)
+        if di >= do:
+            errs.append("Hollow: require Do > Di.")
+    # moments/loads: allow 0 and ± large
+    for name, val in [("N [N]", N), ("Mx [N·m]", Mx), ("My [N·m]", My), ("T [N·m]", T)]:
+        if not math.isfinite(val):
+            errs.append(f"{name} must be finite.")
+    if errs:
+        raise ValueError("\n".join(errs))
+
+def sect_props(mode, d, do, di):
+    if mode == "Solid":
+        A = math.pi * d**2 / 4.0
+        I = math.pi * d**4 / 64.0
+        J = math.pi * d**4 / 32.0
+        c = d / 2.0
+        outer_d = d
+    else:
+        A = math.pi * (do**2 - di**2) / 4.0
+        I = math.pi * (do**4 - di**4) / 64.0
+        J = math.pi * (do**4 - di**4) / 32.0
+        c = do / 2.0
+        outer_d = do
+    return A, I, J, c, outer_d
+
+def combined_loading(mode, d, do, di, N, Mx, My, T, Sy_MPa):
+    _validate(mode, d, do, di, N, Mx, My, T, Sy_MPa)
+    A, I, J, c, outer_d = sect_props(mode, d, do, di)
+
+    # Normal stress at an outer point aligned with resultant bending
+    # Worst-case: take signs to maximize |sigma| → use absolute bending contributions added to axial sign
+    sigma_ax = N / A                               # Pa
+    sigma_bx = (Mx * c) / I if I > 0 else math.inf # Pa
+    sigma_by = (My * c) / I if I > 0 else math.inf # Pa
+
+    # Two extreme points (tension side / compression side). We'll report worst magnitude.
+    sigma_plus  = sigma_ax + abs(sigma_bx) + abs(sigma_by)
+    sigma_minus = sigma_ax - abs(sigma_bx) - abs(sigma_by)
+    # Worst magnitude governs
+    if abs(sigma_plus) >= abs(sigma_minus):
+        sigma = sigma_plus
+        extreme_point = "+ (tension-side from bending)"
+    else:
+        sigma = sigma_minus
+        extreme_point = "− (compression-side from bending)"
+
+    # Shear at perimeter from torsion
+    tau = (T * c) / J if J > 0 else math.inf  # Pa
+
+    # Von Mises
+    sigma_vm = (sigma**2 + 3.0 * tau**2) ** 0.5  # Pa
+    Sy_Pa = Sy_MPa * 1e6
+    fos = Sy_Pa / sigma_vm if sigma_vm > 0 else math.inf
+    ok = sigma_vm <= Sy_Pa
+
+    # Pretty helper
+    def _fmt(x, d=6):
+        try:
+            return f"{x:.{d}g}"
+        except Exception:
+            return str(x)
+
+    steps = []
+    steps.append("## Show the math (combined loading on circular section)")
+    if mode == "Solid":
+        steps.append(f"Mode: Solid  |  d = {_fmt(d)} m")
+        steps.append(f"A = π*d^2/4 = π*{d}^2/4 = {A:.6e} m^2")
+        steps.append(f"I = π*d^4/64 = π*{d}^4/64 = {I:.6e} m^4")
+        steps.append(f"J = π*d^4/32 = π*{d}^4/32 = {J:.6e} m^4")
+        steps.append(f"c = d/2 = {d}/2 = {c:.6e} m")
+    else:
+        steps.append(f"Mode: Hollow  |  Do = {_fmt(do)} m,  Di = {_fmt(di)} m")
+        steps.append(f"A = π*(Do^2 - Di^2)/4 = π*({do}^2 - {di}^2)/4 = {A:.6e} m^2")
+        steps.append(f"I = π*(Do^4 - Di^4)/64 = π*({do}^4 - {di}^4)/64 = {I:.6e} m^4")
+        steps.append(f"J = π*(Do^4 - Di^4)/32 = π*({do}^4 - {di}^4)/32 = {J:.6e} m^4")
+        steps.append(f"c = Do/2 = {do}/2 = {c:.6e} m")
+
+    steps += [
+        "",
+        f"N = {_fmt(N)} N,  Mx = {_fmt(Mx)} N·m,  My = {_fmt(My)} N·m,  T = {_fmt(T)} N·m,  Sy = {_fmt(Sy_MPa)} MPa",
+        "",
+        "Normal stress at an outer fiber (worst-case point):",
+        "σ = N/A ± (Mx*c)/I ± (My*c)/I",
+        f"σ_ax = {N} / {A:.6e} = {sigma_ax/1e6:.6f} MPa",
+        f"(Mx*c)/I = ({Mx} * {c:.6e}) / ({I:.6e}) = {sigma_bx/1e6:.6f} MPa",
+        f"(My*c)/I = ({My} * {c:.6e}) / ({I:.6e}) = {sigma_by/1e6:.6f} MPa",
+        f"σ_max (reported) = {sigma/1e6:.6f} MPa at extreme point {extreme_point}",
+        "",
+        "Shear from torsion at perimeter:",
+        "τ = T*c/J",
+        f"τ = ({T} * {c:.6e}) / ({J:.6e}) = {tau/1e6:.6f} MPa",
+        "",
+        "Von Mises:",
+        "σ_vm = sqrt( σ^2 + 3*τ^2 )",
+        f"σ_vm = sqrt( ({sigma/1e6:.6f})^2 + 3*({tau/1e6:.6f})^2 ) = {sigma_vm/1e6:.6f} MPa",
+        f"FoS = Sy / σ_vm = {Sy_MPa} / {sigma_vm/1e6:.6f} = {fos:.3f}",
+        f"Verdict: {'OK (below yield)' if ok else 'NOT OK (yields by von Mises)'}"
+    ]
+    steps_md = "\n".join(steps)
+
+    results = {
+        "A_m2": A, "I_m4": I, "J_m4": J, "c_m": c, "outer_d_m": outer_d,
+        "sigma_MPa": sigma/1e6, "tau_MPa": tau/1e6,
+        "sigma_vm_MPa": sigma_vm/1e6, "FoS_yield": fos, "ok": bool(ok),
+        "extreme_point": extreme_point
+    }
+    verdict = {
+        "message": "OK: von Mises below yield" if ok else "NOT OK: von Mises exceeds yield",
+        "extreme_point": extreme_point
+    }
+
+    structured = {
+        "problem": "Combined loading on circular section (N, Mx, My, T)",
+        "mode": mode,
+        "inputs": {"N_N": N, "Mx_Nm": Mx, "My_Nm": My, "T_Nm": T, "Sy_MPa": Sy_MPa,
+                   "d_m": d, "Do_m": do, "Di_m": di},
+        "section": {"A_m2": A, "I_m4": I, "J_m4": J, "c_m": c, "outer_d_m": outer_d},
+        "results": results,
+        "verdict": verdict
+    }
+    return results, verdict, steps_md, json.dumps(structured, indent=2)
+
+def _format_chat(system_prompt: str, user_prompt: str) -> str:
+    if _tok is None:
+        return system_prompt + "\n\n" + user_prompt
+    msgs = [{"role":"system","content":system_prompt},{"role":"user","content":user_prompt}]
+    return _tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
+
+def llm_explain(structured_message: str) -> str:
+    if (not _USE_LLM) or (_pipe is None) or (_tok is None):
+        try:
+            d = json.loads(structured_message)
+            ok = d["results"]["ok"]
+            vm = d["results"]["sigma_vm_MPa"]
+            fos = d["results"]["FoS_yield"]
+            return f"Quick take: von Mises = {vm:.2f} MPa (FoS={fos:.2f}) → {'OK' if ok else 'NOT OK'}."
+        except Exception:
+            return "Quick take: combined loading computed; see results."
+    system = "Explain to an engineering student in ONE friendly sentence; refer to the computed von Mises and FoS."
+    user = "Summarize whether the part yields under combined axial, bending, and torsion.\n\n" + structured_message
+    out = _pipe(_format_chat(system, user), max_new_tokens=80, do_sample=True, temperature=0.3, return_full_text=False)
+    return out[0]["generated_text"].split("\n")[0]
+
+def run_once(mode, d, do, di, N, Mx, My, T, Sy_MPa):
+    try:
+        res, ver, steps, structured = combined_loading(
+            mode=mode,
+            d=float(d) if d is not None else 0.0,
+            do=float(do) if do is not None else 0.0,
+            di=float(di) if di is not None else 0.0,
+            N=float(N), Mx=float(Mx), My=float(My), T=float(T),
+            Sy_MPa=float(Sy_MPa)
+        )
+        df = pd.DataFrame([{
+            "σ (outer) [MPa]": round(res["sigma_MPa"], 3),
+            "τ (torsion) [MPa]": round(res["tau_MPa"], 3),
+            "σ_vm [MPa]": round(res["sigma_vm_MPa"], 3),
+            "FoS (yield)": round(res["FoS_yield"], 3),
+            "Extreme point": res["extreme_point"],
+            "Verdict": ver["message"],
+        }])
+        narrative = llm_explain(structured)
+        return df, narrative, steps, ""
+    except Exception as e:
+        return pd.DataFrame(), "", "", f"Input error:\n{e}"
+
+with gr.Blocks(title="Combined Loading — Circular") as demo:
+    gr.Markdown("# Combined Loading Calculator — Circular (Solid/Hollow)")
+    gr.Markdown(SCOPE_MD)
+
+    with gr.Row():
+        with gr.Column():
+            mode = gr.Radio(["Solid", "Hollow"], value="Solid", label="Section type")
+            d  = gr.Number(value=0.05, label="d [m] (solid diameter)")
+            do = gr.Number(value=0.06, label="Do [m] (outer diameter)", visible=False)
+            di = gr.Number(value=0.03, label="Di [m] (inner diameter)", visible=False)
+
+            def _toggle(m):
+                if m == "Solid":
+                    return [gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)]
+                else:
+                    return [gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)]
+            mode.change(_toggle, inputs=[mode], outputs=[d, do, di])
+
+        with gr.Column():
+            gr.Markdown("### Loads & Material")
+            N  = gr.Number(value=5e4, label="Axial N [N]  (tension +)")
+            Mx = gr.Number(value=200.0, label="Mx [N·m]")
+            My = gr.Number(value=0.0, label="My [N·m]")
+            T  = gr.Number(value=500.0, label="T [N·m]")
+            Sy = gr.Number(value=250.0, label="Yield strength Sy [MPa]")
+
+    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=[mode, d, do, di, N, Mx, My, T, Sy],
+        outputs=[results_df, explain_md, steps_md, err_box]
+    )
+
+if __name__ == "__main__":
+    demo.launch(debug=False)