Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,126 @@
+import math
+import gradio
+import pandas as pd
+
+# ---------------- Settings ----------------
+TITLE = "Simply-Supported I-Beam"
+DESC = "Point load @ midspan or uniform load (UDL). SI units. Euler–Bernoulli."
+
+# ---------------- Deterministic backend ----------------
+def _compute(load_type, L_m, E_GPa, Ix_m4, mode, Sx_m3, depth_m, P_kN, w_kNpm, sigma_allow_MPa, defl_ratio):
+    # validate
+    if L_m <= 0: raise ValueError("Span L must be > 0.")
+    if E_GPa <= 0: raise ValueError("E must be > 0.")
+    if Ix_m4 <= 0: raise ValueError("Ix must be > 0.")
+    has_Sx = (mode == "I have Sx")
+    if has_Sx and Sx_m3 <= 0: raise ValueError("Sx must be > 0.")
+    if (not has_Sx) and depth_m <= 0: raise ValueError("Depth must be > 0 when Sx not provided.")
+    if load_type == "Point @ midspan" and P_kN <= 0: raise ValueError("P must be > 0 for point load.")
+    if load_type == "Uniform (UDL)"   and w_kNpm <= 0: raise ValueError("w must be > 0 for UDL.")
+
+    # units
+    E = E_GPa * 1e9     # Pa
+    P = P_kN * 1e3      # N
+    w = w_kNpm * 1e3    # N/m
+
+    # section modulus
+    if has_Sx:
+        Sx = Sx_m3
+        c  = Ix_m4 / Sx
+        h  = 2 * c
+    else:
+        h  = depth_m
+        c  = h / 2
+        Sx = Ix_m4 / c
+
+    # closed-form results
+    if load_type == "Point @ midspan":
+        Mmax = P * L_m / 4.0
+        dmax = P * (L_m**3) / (48.0 * E * Ix_m4)
+    else:  # UDL
+        Mmax = w * (L_m**2) / 8.0
+        dmax = 5.0 * w * (L_m**4) / (384.0 * E * Ix_m4)
+
+    sigma = Mmax / Sx  # Pa
+
+    # checks
+    stress_ok, SF = None, None
+    if sigma_allow_MPa and sigma_allow_MPa > 0:
+        sigma_MPa = sigma / 1e6
+        SF = sigma_allow_MPa / max(sigma_MPa, 1e-12)
+        stress_ok = sigma_MPa <= sigma_allow_MPa
+    defl_ok, defl_lim = None, None
+    if defl_ratio and defl_ratio > 0:
+        defl_lim = (L_m * 1e3) / defl_ratio
+        defl_ok = (dmax * 1e3) <= defl_lim
+
+    # compact dict result (easy to read in the UI)
+    return {
+        "inputs": {
+            "load_type": load_type,
+            "L_m": L_m, "E_GPa": E_GPa, "Ix_m4": Ix_m4,
+            "Sx_m3": Sx, "depth_m": h,
+            "P_kN": P_kN if load_type.startswith("Point") else 0.0,
+            "w_kN_per_m": w_kNpm if load_type.startswith("Uniform") else 0.0,
+            "sigma_allow_MPa": sigma_allow_MPa or None,
+            "deflection_ratio": defl_ratio or None,
+        },
+        "solution": {
+            "M_max_kN_m": Mmax / 1e3,
+            "sigma_max_MPa": sigma / 1e6,
+            "delta_max_mm": dmax * 1e3,
+            "delta_over_L": dmax / L_m,
+        },
+        "checks": {
+            "stress_ok": stress_ok, "SF_stress": SF,
+            "deflection_ok": defl_ok, "deflection_limit_mm": defl_lim, "deflection_ratio": defl_ratio or None,
+        },
+    }
+
+# ---------------- Gradio UI (simple, like your example) ----------------
+with gradio.Blocks() as demo:
+    gradio.Markdown(f"# {TITLE}")
+    gradio.Markdown(DESC)
+
+    with gradio.Row():
+        load_type = gradio.Radio(choices=["Point @ midspan", "Uniform (UDL)"], value="Point @ midspan", label="Load case")
+        L_m   = gradio.Number(value=3.0, label="Span L [m]", precision=4)
+        E_GPa = gradio.Number(value=200.0, label="Young's modulus E [GPa]", precision=3)
+        Ix_m4 = gradio.Number(value=8.0e-6, label="Second moment Ix [m^4]", precision=10)
+
+    with gradio.Row():
+        mode = gradio.Radio(choices=["I have Sx", "I have depth (h) only"], value="I have Sx", label="Section input")
+        Sx_m3   = gradio.Number(value=4.0e-4, label="Section modulus Sx [m^3]", precision=8, visible=True)
+        depth_m = gradio.Number(value=0.30,     label="Depth h [m]", precision=4, visible=False)
+
+    def _toggle(v):
+        return gradio.update(visible=(v=="I have Sx")), gradio.update(visible=(v!="I have Sx"))
+    mode.change(_toggle, inputs=mode, outputs=[Sx_m3, depth_m])
+
+    with gradio.Row():
+        P_kN   = gradio.Number(value=20.0, label="Point load P [kN]", precision=3)
+        w_kNpm = gradio.Number(value=5.0,  label="UDL w [kN/m]", precision=4)
+
+    with gradio.Row():
+        sigma_allow = gradio.Number(value=250.0, label="Allowable stress [MPa] (0=skip)", precision=3)
+        defl_ratio  = gradio.Number(value=360,    label="Deflection limit L/ratio (0=skip)", precision=0)
+
+    out = gradio.JSON(label="Results")
+
+    # Live updates on any input (like your example)
+    inputs = [load_type, L_m, E_GPa, Ix_m4, mode, Sx_m3, depth_m, P_kN, w_kNpm, sigma_allow, defl_ratio]
+    for comp in inputs:
+        comp.change(fn=_compute, inputs=inputs, outputs=out)
+
+    gradio.Examples(
+        examples=[
+            ["Point @ midspan", 3.0, 200.0, 8.0e-6, "I have Sx", 4.0e-4, 0.30, 20.0, 0.0, 250.0, 360],
+            ["Uniform (UDL)",   4.5, 200.0, 1.2e-5, "I have Sx", 6.0e-4, 0.35, 0.0, 8.0, 200.0, 360],
+            ["Uniform (UDL)",   2.5, 70.0,  3.5e-6, "I have depth (h) only", 0.0, 0.22, 0.0, 6.0, 160.0, 240],
+        ],
+        inputs=inputs,
+        label="Examples",
+        cache_examples=False,
+    )
+
+demo.launch()