Update app.py

app.py

@@ -8,7 +8,6 @@ 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.")
@@ -16,34 +15,30 @@ def _compute(load_type, L_m, E_GPa, Ix_m4, mode, Sx_m3, depth_m, P_kN, w_kNpm, s
     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.")
+    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
+    E = E_GPa * 1e9
+    P = P_kN * 1e3
+    w = w_kNpm * 1e3
 
-    # section modulus
     if has_Sx:
         Sx = Sx_m3
-        c  = Ix_m4 / Sx
-        h  = 2 * c
+        c = Ix_m4 / Sx
+        h = 2 * c
     else:
-        h  = depth_m
-        c  = h / 2
+        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
+    else:
         Mmax = w * (L_m**2) / 8.0
         dmax = 5.0 * w * (L_m**4) / (384.0 * E * Ix_m4)
 
-    sigma = Mmax / Sx  # Pa
+    sigma = Mmax / Sx
 
-    # checks
     stress_ok, SF = None, None
     if sigma_allow_MPa and sigma_allow_MPa > 0:
         sigma_MPa = sigma / 1e6
@@ -54,7 +49,35 @@ def _compute(load_type, L_m, E_GPa, Ix_m4, mode, Sx_m3, depth_m, P_kN, w_kNpm, s
         defl_lim = (L_m * 1e3) / defl_ratio
         defl_ok = (dmax * 1e3) <= defl_lim
 
-    # compact dict result (easy to read in the UI)
+    # Build explanation
+    text = []
+    text.append(f"### 🔍 Contextual Explanation")
+    text.append(f"**Beam Type:** Simply supported ({load_type.lower()}) with span **L = {L_m:.2f} m**.")
+    text.append(f"**Material:** E = {E_GPa:.1f} GPa, **Section:** Ix = {Ix_m4:.2e} m⁴, Sx = {Sx:.2e} m³, depth = {h:.3f} m.")
+
+    text.append(f"\n#### Results Overview")
+    text.append(f"- Maximum bending moment **Mmax = {Mmax/1e3:.2f} kN·m**.")
+    text.append(f"- Maximum deflection **δmax = {dmax*1e3:.3f} mm**, ratio **δ/L = {dmax/L_m:.5f}**.")
+    text.append(f"- Bending stress **σmax = {sigma/1e6:.2f} MPa**.")
+
+    if sigma_allow_MPa > 0:
+        if stress_ok:
+            text.append(f"✅ The beam’s stress **({sigma/1e6:.2f} MPa)** is below the allowable limit **({sigma_allow_MPa:.2f} MPa)**.")
+        else:
+            text.append(f"⚠️ The stress **({sigma/1e6:.2f} MPa)** exceeds the allowable limit **({sigma_allow_MPa:.2f} MPa)**.")
+    if defl_ratio > 0:
+        if defl_ok:
+            text.append(f"✅ Deflection **({dmax*1e3:.3f} mm)** is within the limit (L/{defl_ratio:.0f} = {defl_lim:.2f} mm).")
+        else:
+            text.append(f"⚠️ Deflection **({dmax*1e3:.3f} mm)** exceeds the limit (L/{defl_ratio:.0f} = {defl_lim:.2f} mm).")
+
+    text.append("\n#### Engineering Meaning")
+    text.append("The bending moment represents how much internal torque the beam experiences due to the applied load. "
+                "The deflection quantifies how much the beam bends under that load. "
+                "A safe design keeps both the stress and deflection below their respective limits to avoid failure or excessive sagging.")
+
+    context_text = "\n".join(text)
+
     return {
         "inputs": {
             "load_type": load_type,
@@ -73,50 +96,55 @@ def _compute(load_type, L_m, E_GPa, Ix_m4, mode, Sx_m3, depth_m, P_kN, w_kNpm, s
         },
         "checks": {
             "stress_ok": stress_ok, "SF_stress": SF,
-            "deflection_ok": defl_ok, "deflection_limit_mm": defl_lim, "deflection_ratio": defl_ratio or None,
+            "deflection_ok": defl_ok, "deflection_limit_mm": defl_lim,
+            "deflection_ratio": defl_ratio or None,
         },
+        "context": context_text
     }
 
-# ---------------- Gradio UI (simple, like your example) ----------------
+# ---------------- Gradio UI ----------------
 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)
+        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)
+        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)
+        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)
+        defl_ratio = gradio.Number(value=360, label="Deflection limit L/ratio (0=skip)", precision=0)
+
+    with gradio.Tab("Numerical Results"):
+        out = gradio.JSON(label="Results")
 
-    out = gradio.JSON(label="Results")
+    with gradio.Tab("Understanding the Results"):
+        context_out = gradio.Markdown()
 
-    # 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)
+        comp.change(fn=_compute, inputs=inputs, outputs=[out, context_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],
+            ["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",