Update app.py

app.py

@@ -1,357 +1,359 @@
 #!/usr/bin/env python3
 """
-ASME Calculator (updated) — add Unit System (USC / SI) support.
+ASME Section VIII — Preliminary Pressure Vessel Calculator (Streamlit)
 
-Notes:
-- Calculation functions assume consistent units (i.e. pressure and allowable stress in matching systems;
-  lengths all in the same linear unit). This app ensures the user supplies values in a single system.
-- If you want the app to accept mixed units and convert internally, we can add that later.
+This version guards the PDF generator import so the app does NOT crash if 'fpdf2' is not installed.
+PDF export remains available when 'fpdf2' is present; otherwise the app offers CSV export and a friendly message.
+
+Note:
+- Groq AI integration is optional and guarded (requires GROQ_API_KEY in environment / HF secrets).
+- Calculations expect consistent units (you choose SI or USC in the sidebar). The app labels inputs accordingly.
 """
 
 from __future__ import annotations
 import os
 import math
 import datetime
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 
 import streamlit as st
 import pandas as pd
 import numpy as np
 
-# PDF generator (fpdf2)
-from fpdf import FPDF
+# Optional AI client (Groq). If not installed or key not provided, AI features are disabled.
+try:
+    from groq import Groq  # optional
+except Exception:
+    Groq = None
 
-# Groq client (optional - requires GROQ_API_KEY in environment or HF secrets)
+# Optional PDF generator (fpdf2). Guard import to avoid ModuleNotFoundError.
 try:
-    from groq import Groq
+    from fpdf import FPDF
+
+    FPDF_AVAILABLE = True
 except Exception:
-    Groq = None  # groq may not be installed or env var not set
-
-# ========== PAGE CONFIG ==========
-st.set_page_config(page_title="ASME Calculator", layout="wide")
-st.title("🛠️ ASME CALCULATOR")
-st.caption("Preliminary ASME Section VIII calculations. Verify with a licensed engineer and latest ASME edition.")
-
-# ========== API CLIENT ==========
-groq_api_key = os.getenv("GROQ_API_KEY")
-groq_client = Groq(api_key=groq_api_key) if (Groq is not None and groq_api_key) else None
-
-# ========== PDF GENERATOR ==========
-class PDF(FPDF):
-    def header(self):
-        self.set_font("Helvetica", "B", 14)
-        self.cell(0, 10, "ASME VIII Div.1 Vessel Design Report", 0, 1, "C")
-
-    def chapter_title(self, title):
-        self.set_font("Helvetica", "B", 12)
-        self.cell(0, 10, title, 0, 1, "L")
-
-    def chapter_body(self, body):
-        self.set_font("Helvetica", "", 11)
-        self.multi_cell(0, 8, body)
-
-# ========== UNIT HELPERS ==========
-# Conversion factors
-MPA_TO_PSI = 145.037737797  # 1 MPa = 145.0377 psi
-MM_TO_IN = 0.03937007874015748  # 1 mm = 0.0393701 in
-IN_TO_MM = 25.4
+    FPDF = None
+    FPDF_AVAILABLE = False
+
+from io import BytesIO
+
+# --------- Page config ----------
+st.set_page_config(page_title="ASME Section VIII Calculator", page_icon="🔧", layout="wide")
+st.title("🔧 ASME Section VIII — Preliminary Calculator")
+st.caption(
+    "Preliminary calculations only. Final verification must be completed by a licensed professional engineer "
+    "and checked against the latest ASME code editions."
+)
+
+# --------- Conversions & constants ----------
+MPA_TO_PSI = 145.037737797
 PSI_TO_MPA = 1.0 / MPA_TO_PSI
+MM_TO_IN = 0.03937007874015748
+IN_TO_MM = 25.4
 
-def mpato_psi(x: float) -> float:
-    return x * MPA_TO_PSI
+def mpa_to_psi(x: float) -> float:
+    return float(x) * MPA_TO_PSI
 
 def psi_to_mpa(x: float) -> float:
-    return x * PSI_TO_MPA
+    return float(x) * PSI_TO_MPA
 
 def mm_to_in(x: float) -> float:
-    return x * MM_TO_IN
+    return float(x) * MM_TO_IN
 
 def in_to_mm(x: float) -> float:
-    return x * IN_TO_MM
+    return float(x) * IN_TO_MM
 
-# ========== CALCULATION FUNCTIONS ==========
+# --------- Simple calculation helpers ----------
 def shell_thickness(P: float, R: float, S: float, E: float, corrosion: float) -> float:
-    """Return governing shell thickness (uses circumferential formula as originally)."""
-    # Validation (basic)
+    """
+    Simple UG-27-like circumferential thickness calculation (keeps original app's simplified logic).
+    Requires inputs in consistent units (e.g., SI: MPa, mm; USC: psi, in).
+    """
     if E <= 0 or E > 1:
         raise ValueError("Joint efficiency E must be in (0,1].")
     if S <= 0:
         raise ValueError("Allowable stress must be positive.")
-    # Use the formula as provided originally (assumes P, R, S in consistent units)
+    # Avoid division by zero: use the conservative branch if denominator non-positive
     denom = S * E - 0.6 * P
     if denom <= 0:
-        # Avoid division by zero; return a large thickness suggestion or raise
-        raise ValueError("Denominator (S*E - 0.6*P) <= 0. Check input values (pressure too high or S/E too low).")
+        raise ValueError("Invalid combination: denominator (S*E - 0.6*P) <= 0. Check pressure / allowable stress / E.")
     t = (P * R) / denom
-    return t + corrosion
+    return float(t + corrosion)
 
 def head_thickness(P: float, R: float, S: float, E: float, corrosion: float, head_type: str) -> float:
-    """Return head thickness per simplified formulas (unit-consistent)."""
+    """
+    Simplified head thickness formulas; return thickness including corrosion allowance.
+    head_type: "Ellipsoidal", "Torispherical", "Hemispherical"
+    """
     if E <= 0 or E > 1:
         raise ValueError("Joint efficiency E must be in (0,1].")
     if head_type == "Ellipsoidal":
-        denom = S * E - 0.1 * P
+        denom = 2 * S * E - 0.2 * P
         if denom <= 0:
-            raise ValueError("Denominator invalid for Ellipsoidal head formula.")
-        return (0.5 * P * R) / denom + corrosion
+            raise ValueError("Invalid inputs for ellipsoidal head formula (denominator <= 0).")
+        t = (P * 2.0 * R) / denom  # simplified geometry mapping D ≈ 2R
     elif head_type == "Torispherical":
-        denom = S * E - 0.1 * P
+        L = 2.0 * R
+        r = 0.1 * L
+        M = 0.25 * (3.0 + math.sqrt(L / r))
+        denom = 2 * S * E - 0.2 * P
         if denom <= 0:
-            raise ValueError("Denominator invalid for Torispherical head formula.")
-        return (0.885 * P * R) / denom + corrosion
+            raise ValueError("Invalid inputs for torispherical head formula (denominator <= 0).")
+        t = (P * L * M) / denom
     elif head_type == "Hemispherical":
+        L = R
         denom = 2 * S * E - 0.2 * P
         if denom <= 0:
-            raise ValueError("Denominator invalid for Hemispherical head formula.")
-        return (P * R) / denom + corrosion
+            raise ValueError("Invalid inputs for hemispherical head formula (denominator <= 0).")
+        t = (P * L) / denom
     else:
         raise ValueError("Unsupported head type.")
+    return float(t + corrosion)
 
-def nozzle_reinforcement(P: float, d: float, t_shell: float, t_nozzle: float, S: float, E: float) -> bool:
+def nozzle_reinforcement_simple(P: float, d: float, t_shell: float, t_nozzle: float, S: float, E: float) -> Dict[str, Any]:
     """
-    Simplified conservative check originally provided:
-    (P * d) / (2 * S * E) <= (t_shell + t_nozzle)
-    Works if units are consistent.
+    Conservative, simplified nozzle reinforcement check (keeps original logic but returns details).
+    Returns a dict with boolean 'adequate' and diagnostic values.
     """
-    lhs = (P * d) / (2 * S * E)
+    if any(val <= 0 for val in (d, S, E)):
+        raise ValueError("Nozzle diameter, allowable stress and joint efficiency must be positive.")
+    lhs = (P * d) / (2.0 * S * E)
     rhs = (t_shell + t_nozzle)
-    return lhs <= rhs
+    adequate = lhs <= rhs
+    return {"lhs": float(lhs), "rhs": float(rhs), "adequate": bool(adequate)}
 
-def pwht_required(thickness: float, material: str = "CS", unit_system: str = "SI") -> bool:
+def pwht_required(thickness: float, unit_system: str = "SI") -> bool:
     """
-    Very simple rule kept from original:
-    In original code thickness threshold 38 (assumed mm). We'll adapt threshold by unit system:
-    - SI: 38 mm threshold (original)
-    - USC: convert 38 mm to inches (~1.496 in)
+    Simple PWHT rule:
+    - SI: threshold 38 mm
+    - USC: threshold ~1.496 in (converted from 38 mm)
     """
     if unit_system == "SI":
-        threshold = 38.0
+        return thickness > 38.0
     else:
-        threshold = mm_to_in(38.0)
-    return (material == "CS") and (thickness > threshold)
+        return thickness > mm_to_in(38.0)
 
-def impact_test_required(thickness: float, MDMT: float = -20.0, material: str = "CS", unit_system: str = "SI") -> bool:
+def impact_test_required(thickness: float, design_mdmt: float, unit_system: str = "SI") -> Dict[str, Any]:
     """
-    Original logic was nonspecific; we keep the original behaviour but map units consistently.
-    The original check: material == CS and (MDMT < -29 and thickness > 12)
-    - 12 assumed mm in original code.
-    We'll adapt thresholds per unit_system:
-    - SI: thickness threshold = 12 mm (original)
-    - USC: convert 12 mm to inches (~0.4724 in)
-    - MDMT comparisons assumed in °C in original? Original used -29 which looks like °C (or °F?). The original code
-      mixed units; we'll treat MDMT input as per user's unit system and compare raw values exactly as original.
-    WARNING: This is a placeholder approximation. For real MDMT logic use UCS-66 tables.
+    Simplified MDMT check placeholder.
+    Returns dict with 'impact_required' and demonstration values.
+    (This is an approximation — use UCS-66 for real decisions.)
     """
     if unit_system == "SI":
+        rated_mdmt = -29.0  # approximate representative number (°C)
         thickness_threshold = 12.0  # mm
-        mdmt_check_val = -29.0
+        test_temp = design_mdmt - 17.0  # suggested test temp (°C)
     else:
-        thickness_threshold = mm_to_in(12.0)
-        mdmt_check_val = -29.0  # user will supply °F when using USC; this retains same numeric test as original.
-    return (material == "CS") and (MDMT < mdmt_check_val and thickness > thickness_threshold)
-
-# ========== SESSION STATE ==========
+        rated_mdmt = -20.0  # representative (°F)
+        thickness_threshold = mm_to_in(12.0)  # inches
+        test_temp = design_mdmt - 30.0  # suggested test temp (°F)
+
+    impact_required = (design_mdmt > rated_mdmt) and (thickness > thickness_threshold)
+    return {
+        "impact_required": bool(impact_required),
+        "rated_mdmt": rated_mdmt,
+        "threshold_thickness": thickness_threshold,
+        "suggested_test_temp": test_temp,
+        "note": "APPROXIMATION: use UCS-66 tables for exact rated MDMT decisions."
+    }
+
+# --------- PDF generation helper ----------
+def generate_pdf_bytes_from_dict(info: Dict[str, Any]) -> Optional[bytes]:
+    """
+    Generate a small PDF bytes payload from a dict summary.
+    Requires fpdf2 (FPDF). If not available, return None.
+    """
+    if not FPDF_AVAILABLE:
+        return None
+    pdf = FPDF()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.add_page()
+    pdf.set_font("Helvetica", "B", 14)
+    pdf.cell(0, 10, "ASME Section VIII — Summary Report", ln=True, align="C")
+    pdf.ln(4)
+    pdf.set_font("Helvetica", size=11)
+    for k, v in info.items():
+        pdf.multi_cell(0, 7, f"{k}: {v}")
+    # fpdf2 can output to string (dest='S') or write to a BytesIO by passing a buffer-like
+    try:
+        pdf_bytes = pdf.output(dest="S")
+        # output(dest="S") returns a str in some versions — convert to bytes
+        if isinstance(pdf_bytes, str):
+            pdf_bytes = pdf_bytes.encode("latin-1", errors="replace")
+        return pdf_bytes
+    except Exception:
+        # fallback: write to BytesIO via file path (temp) — but avoid filesystem use; just return None
+        return None
+
+# --------- App state defaults ----------
 if "run_done" not in st.session_state:
     st.session_state.run_done = False
-if "ai_done" not in st.session_state:
-    st.session_state.ai_done = False
-
-# ========== SIDEBAR INPUTS ==========
-with st.sidebar.expander("📥 Manual Design Inputs", expanded=True):
-    # Unit System selection (new)
-    unit_system = st.radio("Unit System:", ["SI (MPa / mm)", "USC (psi / in)"], index=0)
-    use_si = unit_system.startswith("SI")
 
-    input_mode = st.radio("Input Mode:", ["Manual Entry", "Upload CSV"])
-    run_calculation = False
+# --------- Sidebar inputs ----------
+with st.sidebar.expander("Inputs", expanded=True):
+    unit_system_choice = st.selectbox("Unit System", ["SI (MPa / mm / °C)", "USC (psi / in / °F)"])
+    use_si = unit_system_choice.startswith("SI")
 
-    # Set sensible defaults depending on unit system (based on previous defaults)
+    st.markdown("---")
     if use_si:
-        default_P = 2.0          # MPa (approx previous)
-        default_R = 1000.0       # mm (previous)
-        default_S = 120.0        # MPa (previous)
-        default_corrosion = 1.5  # mm
-        default_d_nozzle = 200.0 # mm
-        default_t_shell = 12.0   # mm
-        default_t_nozzle = 10.0  # mm
-        default_thickness = 40.0 # mm
-        default_mdmt = -20.0     # °C
+        # SI defaults
+        P = st.number_input("Design Pressure (MPa)", value=2.0, format="%.3f")
+        inside_d = st.number_input("Inside Diameter (mm)", value=1500.0, format="%.1f")
+        R = inside_d / 2.0
+        S = st.number_input("Allowable Stress (MPa)", value=120.0, format="%.2f")
+        corrosion = st.number_input("Corrosion Allowance (mm)", value=1.5, format="%.2f")
+        design_mdmt = st.number_input("Design MDMT (°C)", value=-20.0)
     else:
-        # convert defaults to USC
-        default_P = mpato_psi(2.0)           # psi
-        default_R = mm_to_in(1000.0)         # in
-        default_S = mpato_psi(120.0)         # psi
-        default_corrosion = mm_to_in(1.5)    # in
-        default_d_nozzle = mm_to_in(200.0)   # in
-        default_t_shell = mm_to_in(12.0)     # in
-        default_t_nozzle = mm_to_in(10.0)    # in
-        default_thickness = mm_to_in(40.0)   # in
-        default_mdmt = mm_to_in(-20.0) if False else -20.0  # MDMT keep numeric, user interprets units (°F)
-
-    if input_mode == "Manual Entry":
-        # Labels and formats adjusted per unit system
-        if use_si:
-            P = st.number_input("Design Pressure (MPa)", value=float(default_P), format="%.3f")
-            R = st.number_input("Internal Radius (mm)", value=float(default_R), format="%.2f")
-            S = st.number_input("Allowable Stress (MPa)", value=float(default_S), format="%.2f")
-            corrosion = st.number_input("Corrosion Allowance (mm)", value=float(default_corrosion), format="%.2f")
-            mdmt = st.number_input("Design MDMT (°C)", value=float(default_mdmt))
-        else:
-            P = st.number_input("Design Pressure (psi)", value=float(default_P), format="%.2f")
-            R = st.number_input("Internal Radius (in)", value=float(default_R), format="%.3f")
-            S = st.number_input("Allowable Stress (psi)", value=float(default_S), format="%.1f")
-            corrosion = st.number_input("Corrosion Allowance (in)", value=float(default_corrosion), format="%.3f")
-            mdmt = st.number_input("Design MDMT (°F)", value=float(default_mdmt))
-
-        joint_method = st.radio("Joint Efficiency Selection", ["Preset (UW-12)", "Manual Entry"])
-        if joint_method == "Preset (UW-12)":
-            # include the requested 0.7 option
-            E = st.selectbox("Select E (Joint Efficiency)", [1.0, 0.95, 0.9, 0.85, 0.7, 0.65, 0.6, 0.45], index=0)
-        else:
-            E = st.number_input("Manual Joint Efficiency (0-1)", value=0.85, min_value=0.1, max_value=1.0, format="%.2f")
-
-        head_type = st.selectbox("Head Type", ["Ellipsoidal", "Torispherical", "Hemispherical"])
-
-        if use_si:
-            d_nozzle = st.number_input("Nozzle Diameter (mm)", value=float(default_d_nozzle), format="%.1f")
-            t_shell = st.number_input("Shell Thickness Provided (mm)", value=float(default_t_shell), format="%.2f")
-            t_nozzle = st.number_input("Nozzle Thickness Provided (mm)", value=float(default_t_nozzle), format="%.2f")
-            thickness = st.number_input("Governing Thickness (mm)", value=float(default_thickness), format="%.2f")
-        else:
-            d_nozzle = st.number_input("Nozzle Diameter (in)", value=float(default_d_nozzle), format="%.3f")
-            t_shell = st.number_input("Shell Thickness Provided (in)", value=float(default_t_shell), format="%.4f")
-            t_nozzle = st.number_input("Nozzle Thickness Provided (in)", value=float(default_t_nozzle), format="%.4f")
-            thickness = st.number_input("Governing Thickness (in)", value=float(default_thickness), format="%.4f")
-
-        if st.button("🚀 Run Calculation", use_container_width=True):
-            st.session_state.run_done = True
-            run_calculation = True
-
-        if st.session_state.run_done:
-            st.success("✅ Calculations completed! See results in the tabs.")
-
+        P = st.number_input("Design Pressure (psi)", value=mpa_to_psi(2.0), format="%.1f")
+        inside_d = st.number_input("Inside Diameter (in)", value=mm_to_in(1500.0), format="%.3f")
+        R = inside_d / 2.0
+        S = st.number_input("Allowable Stress (psi)", value=mpa_to_psi(120.0), format="%.1f")
+        corrosion = st.number_input("Corrosion Allowance (in)", value=mm_to_in(1.5), format="%.4f")
+        design_mdmt = st.number_input("Design MDMT (°F)", value=-20.0)
+
+    st.markdown("---")
+    head_type = st.selectbox("Head Type", ["Ellipsoidal", "Torispherical", "Hemispherical"])
+    E = st.selectbox("Joint Efficiency (E)", [1.0, 0.95, 0.9, 0.85, 0.7], index=0)
+
+    st.markdown("---")
+    # Nozzle inputs
+    if use_si:
+        d_nozzle = st.number_input("Nozzle Opening Diameter (mm)", value=200.0, format="%.1f")
+        t_shell_provided = st.number_input("Shell thickness available (mm)", value=12.0, format="%.2f")
+        t_nozzle = st.number_input("Nozzle thickness (mm)", value=10.0, format="%.2f")
     else:
-        uploaded_file = st.file_uploader("Upload CSV File", type=["csv"])
-        if uploaded_file:
-            df = pd.read_csv(uploaded_file)
-            st.dataframe(df.head())
-            if st.button("🚀 Run Calculation", use_container_width=True):
-                # NOTE: CSV processing / mapping not implemented here — expecting columns that match manual inputs
-                st.session_state.run_done = True
-                run_calculation = True
+        d_nozzle = st.number_input("Nozzle Opening Diameter (in)", value=mm_to_in(200.0), format="%.3f")
+        t_shell_provided = st.number_input("Shell thickness available (in)", value=mm_to_in(12.0), format="%.4f")
+        t_nozzle = st.number_input("Nozzle thickness (in)", value=mm_to_in(10.0), format="%.4f")
+
+    st.markdown("---")
+    st.button("Run Calculation", key="run_button", help="Click to run calculations")
+    st.button("Reset", key="reset_button", help="Reset not implemented in this lightweight version")
 
-            if st.session_state.run_done:
-                st.success("✅ Calculations completed! See results in the tabs.")
+# --------- Run when user clicked Run Calculation ----------
+if st.sidebar.button("Calculate Now") or st.session_state.get("run_button"):
+    st.session_state.run_done = True
 
-# ========== TABS ==========
-tabs = st.tabs(["Shell", "Head", "Nozzle", "PWHT", "Impact Test", "Summary", "AI Explanation"])
+# --------- Tabs and outputs ----------
+tabs = st.tabs(["Shell", "Head", "Nozzle", "PWHT", "Impact Test", "Summary"])
 
 if st.session_state.run_done:
-    # --- SHELL TAB ---
+    # Shell
     with tabs[0]:
         try:
-            t_shell_calc = shell_thickness(P, R, S, E, corrosion)
-            unit_thickness = "mm" if use_si else "in"
-            st.metric(f"Required Shell Thickness ({unit_thickness})", f"{t_shell_calc:.4f}")
+            t_shell = shell_thickness(P, R, S, E, corrosion)
+            unit_thk = "mm" if use_si else "in"
+            st.metric("Required shell thickness (including corrosion)", f"{t_shell:.4f} {unit_thk}")
+            st.write("Details:")
+            st.write({"P": P, "R": R, "S": S, "E": E, "corrosion": corrosion})
         except Exception as exc:
             st.error(f"Error computing shell thickness: {exc}")
 
-    # --- HEAD TAB ---
+    # Head
     with tabs[1]:
         try:
-            t_head_calc = head_thickness(P, R, S, E, corrosion, head_type)
-            unit_thickness = "mm" if use_si else "in"
-            st.metric(f"Required {head_type} Head Thickness ({unit_thickness})", f"{t_head_calc:.4f}")
+            t_head = head_thickness(P, R, S, E, corrosion, head_type)
+            unit_thk = "mm" if use_si else "in"
+            st.metric(f"Required {head_type} head thickness (including corrosion)", f"{t_head:.4f} {unit_thk}")
+            st.write("Details:")
+            st.write({"P": P, "D (approx)": 2.0 * R, "S": S, "E": E})
         except Exception as exc:
             st.error(f"Error computing head thickness: {exc}")
 
-    # --- NOZZLE TAB ---
+    # Nozzle
     with tabs[2]:
         try:
-            safe_nozzle = nozzle_reinforcement(P, d_nozzle, t_shell, t_nozzle, S, E)
-            st.write("Nozzle Reinforcement Check:", "✅ Safe" if safe_nozzle else "❌ Not Safe")
-            st.write("Note: This is a simplified conservative check. For full UG-37 use geometric projection method.")
+            nozzle_res = nozzle_reinforcement_simple(P, d_nozzle, t_shell_provided, t_nozzle, S, E)
+            ok = nozzle_res["adequate"]
+            st.write("Nozzle reinforcement conservative check (lhs <= rhs):")
+            st.write(f"LHS = (P * d) / (2SE) = {nozzle_res['lhs']:.4g}")
+            st.write(f"RHS = t_shell + t_nozzle = {nozzle_res['rhs']:.4g}")
+            if ok:
+                st.success("Conservative nozzle reinforcement check PASSED")
+            else:
+                st.error("Conservative nozzle reinforcement check FAILED")
+            st.write("Note: This is a conservative/simple check. For full ASME UG-37, use the exact projection-area method.")
         except Exception as exc:
             st.error(f"Error computing nozzle reinforcement: {exc}")
 
-    # --- PWHT TAB ---
+    # PWHT
     with tabs[3]:
         try:
-            pwht_ans = pwht_required(thickness, material="CS", unit_system="SI" if use_si else "USC")
-            st.write("PWHT Required:", "✅ Yes" if pwht_ans else "❌ No")
-            if use_si:
-                st.caption("Threshold used: 38 mm (approx).")
-            else:
-                st.caption(f"Threshold used: {mpato_psi(0):.4f} (converted threshold from 38 mm).")
+            # choose thickness measure to check: use the governing shell thickness
+            check_thickness = t_shell if "t_shell" in locals() else t_shell_provided
+            pwht = pwht_required(check_thickness, unit_system="SI" if use_si else "USC")
+            st.write("PWHT required (preliminary):", "YES" if pwht else "NO")
+            st.caption("This is a simplified check; consult UCS-56 and your material spec for final decision.")
         except Exception as exc:
             st.error(f"Error computing PWHT requirement: {exc}")
 
-    # --- IMPACT TEST TAB ---
+    # Impact test
     with tabs[4]:
         try:
-            impact_ans = impact_test_required(thickness, MDMT=mdmt, material="CS", unit_system="SI" if use_si else "USC")
-            st.write("Impact Test Required:", "✅ Yes" if impact_ans else "❌ No")
-            st.caption("This is a placeholder approximation. Consult UCS-66 for precise MDMT rules.")
+            check_thickness = t_shell if "t_shell" in locals() else t_shell_provided
+            impact_info = impact_test_required(check_thickness, design_mdmt, unit_system="SI" if use_si else "USC")
+            st.write("Impact test required (preliminary):", "YES" if impact_info["impact_required"] else "NO")
+            st.write("Rated MDMT used (approx):", impact_info["rated_mdmt"])
+            st.write("Suggested test temperature (approx):", impact_info["suggested_test_temp"])
+            st.caption(impact_info["note"])
         except Exception as exc:
             st.error(f"Error computing impact test requirement: {exc}")
 
-    # --- SUMMARY TAB ---
+    # Summary
     with tabs[5]:
         try:
-            summary_data = {
-                "Shell Thickness": t_shell_calc,
-                "Head Thickness": t_head_calc,
-                "Nozzle Safe": safe_nozzle,
-                "PWHT Required": pwht_required(thickness, material="CS", unit_system="SI" if use_si else "USC"),
-                "Impact Test Required": impact_test_required(thickness, MDMT=mdmt, material="CS", unit_system="SI" if use_si else "USC"),
-                "Unit System": "SI (MPa/mm)" if use_si else "USC (psi/in)",
+            summary = {
+                "unit_system": "SI (MPa/mm/°C)" if use_si else "USC (psi/in/°F)",
+                "design_pressure": P,
+                "inside_diameter": inside_d,
+                "shell_thickness": t_shell if "t_shell" in locals() else None,
+                "head_thickness": t_head if "t_head" in locals() else None,
+                "nozzle_check_passed": nozzle_res["adequate"] if "nozzle_res" in locals() else None,
+                "pwht_required": pwht if "pwht" in locals() else None,
+                "impact_test_required": impact_info["impact_required"] if "impact_info" in locals() else None,
+                "generated": datetime.datetime.now().isoformat(),
             }
-            df_summary = pd.DataFrame([summary_data])
-            st.dataframe(df_summary)
-
-            # CSV export
-            csv = df_summary.to_csv(index=False).encode("utf-8")
-            st.download_button("📥 Download Results (CSV)", csv, "results.csv")
-
-            # PDF export
-            pdf = PDF()
-            pdf.chapter_title("Calculation Summary")
-            pdf.chapter_body(str(summary_data))
-            pdf_file = "results.pdf"
-            pdf.output(pdf_file)
-            with open(pdf_file, "rb") as f:
-                st.download_button("📄 Download PDF Report", f, "results.pdf")
+            df_sum = pd.DataFrame([summary])
+            st.dataframe(df_sum, use_container_width=True)
+            csv = df_sum.to_csv(index=False).encode("utf-8")
+            st.download_button("Download CSV", csv, file_name="asme_summary.csv", mime="text/csv")
+            if FPDF_AVAILABLE:
+                pdf_bytes = generate_pdf_bytes_from_dict(summary)
+                if pdf_bytes:
+                    st.download_button("Download PDF", pdf_bytes, file_name="asme_summary.pdf", mime="application/pdf")
+                else:
+                    st.info("PDF generation failed at runtime; try installing 'fpdf2' or check runtime logs.")
+            else:
+                st.info("PDF export disabled — install 'fpdf2' (add to requirements.txt) to enable PDF export.")
+                st.caption("To enable PDF export add `fpdf2` to requirements.txt, or install locally: pip install fpdf2")
         except Exception as exc:
-            st.error(f"Error generating summary: {exc}")
-
-    # --- AI EXPLANATION TAB ---
-    with tabs[6]:
-        st.markdown("### 🤖 Ask AI for Explanation")
-        if groq_client:
-            if st.button("✨ Ask AI", use_container_width=True):
-                st.session_state.ai_done = True
-                with st.spinner("AI is preparing explanation..."):
-                    prompt = f"Explain these ASME vessel design results in simple terms: {summary_data}"
-                    try:
-                        chat_completion = groq_client.chat.completions.create(
+            st.error(f"Error building summary/export: {exc}")
+
+    # AI explanation tab (optional)
+    with tabs[6] if len(tabs) > 6 else st.container():
+        # Show optional AI if Groq client exists and key present
+        groq_key = os.getenv("GROQ_API_KEY")
+        if Groq is not None and groq_key:
+            try:
+                groq_client = Groq(api_key=groq_key)
+                if st.button("Generate AI Explanation (Groq)"):
+                    with st.spinner("Generating explanation..."):
+                        prompt = f"Explain these ASME results simply: {summary}"
+                        resp = groq_client.chat.completions.create(
                             messages=[{"role": "user", "content": prompt}],
                             model="llama-3.1-8b-instant",
                         )
-                        explanation = chat_completion.choices[0].message.content
-                        st.success("✅ AI Explanation Generated Below")
+                        explanation = resp.choices[0].message.content
+                        st.markdown("**AI Explanation**")
                         st.write(explanation)
-                    except Exception as exc:
-                        st.error(f"AI request failed: {exc}")
-            if st.session_state.ai_done:
-                st.info("✨ AI explanation already generated. Rerun to refresh.")
+            except Exception as e:
+                st.info("Groq AI not available or failed. Set GROQ_API_KEY in environment/secrets to enable.")
         else:
-            st.info("ℹ️ Add your GROQ_API_KEY in Hugging Face secrets to enable AI explanations.")
+            st.info("Groq AI not configured. Add GROQ_API_KEY to environment to enable optional explanations.")
 else:
-    # Placeholders if not run
-    for i, msg in enumerate([
-        "Shell results", "Head results", "Nozzle results",
-        "PWHT decision", "Impact Test decision",
-        "Summary", "AI explanation"
-    ]):
+    # placeholders explaining how to run
+    with tabs[0]:
+        st.info("Enter inputs in the sidebar and click 'Run Calculation' -> 'Calculate Now' or the Run button to execute.")
+    for i in range(1, 6):
         with tabs[i]:
-            st.info(f"Run calculation to see {msg}.")
+            st.info("Results will appear here after running calculations.")