Update app.py

app.py

@@ -1,429 +1,195 @@
-#!/usr/bin/env python3
-"""
-ASME Section VIII — Preliminary Pressure Vessel Calculator (Streamlit)
-
-- PDF export removed to avoid runtime font/encoding/width issues.
-- CSV export remains.
-- Impact/MDMT checks improved using a conservative UCS-66 approximation (preliminary).
-- Single Run Calculation button; Reset; SI/USC support; joint efficiency includes 0.7.
-- Simplified, preliminary checks only. Verify with a licensed engineer.
-
-Notes:
-This implements a conservative approximation of UCS-66 curves and the coincident-ratio
-reduction (FIG UCS-66.1) for preliminary MDMT / impact-test decisions. It is NOT a
-replacement for a code check with the official ASME figures and a licensed engineer.
-"""
-
-from __future__ import annotations
-import os
-import math
-import datetime
-from typing import Dict, Any, Optional, Tuple
-
 import streamlit as st
 import pandas as pd
-import numpy as np
-
-# -----------------------------
-# Unit conversion helpers & 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 mpa_to_psi(x: float) -> float:
-    return float(x) * MPA_TO_PSI
-
-def psi_to_mpa(x: float) -> float:
-    return float(x) * PSI_TO_MPA
-
-def mm_to_in(x: float) -> float:
-    return float(x) * MM_TO_IN
-
-def in_to_mm(x: float) -> float:
-    return float(x) * IN_TO_MM
-
-def f_to_c(t_f: float) -> float:
-    return (t_f - 32.0) * 5.0 / 9.0
-
-def c_to_f(t_c: float) -> float:
-    return t_c * 9.0 / 5.0 + 32.0
-
-# -----------------------------
-# UCS-66 table data (approximate tabulation of Fig. UCS-66)
-# Source: public summaries of TABLE UCS-66 (used here for conservative, preliminary checks).
-# This is an approximation for preliminary use only — see ASME Fig. UCS-66 for final.
-# -----------------------------
-# thickness (in) sampled and corresponding minimum permissible temperature without impact test (deg F)
-UCS66_THICK_IN = np.array([
-    0.3125, 0.375, 0.4375, 0.5, 0.5625, 0.625, 0.6875, 0.75, 0.8125,
-    0.875, 0.9375, 1.0, 1.0625, 1.125, 1.1875, 1.25, 1.3125, 1.375, 1.4375, 1.5
-])
-# Columns: curve A, B, C, D (deg F)
-UCS66_TABLE_F = np.array([
-    [18,  -20, -55, -55],
-    [18,  -20, -55, -55],
-    [25,  -13, -40, -55],
-    [32,   -7, -34, -55],
-    [37,   -1, -26, -51],
-    [43,    5, -22, -48],
-    [48,   10, -18, -45],
-    [53,   15, -15, -42],
-    [57,   19, -12, -38],
-    [61,   23,  -9, -36],
-    [65,   27,  -6, -33],
-    [68,   31,  -3, -30],
-    [72,   34,  -1, -28],
-    [75,   37,   2, -26],
-    [77,   40,   2, -23],
-    [80,   43,   6, -21],
-    [82,   45,   8, -19],
-    [84,   47,  10, -18],
-    [86,   49,  12, -16],
-    [88,   51,  14, -14],
-], dtype=float)
-
-CURVE_LABELS = ["A", "B", "C", "D"]
-
-# -----------------------------
-# Calculation helpers (pure functions)
-# -----------------------------
-
-def calculate_shell_thickness(P: float, R: float, S: float, E: float, corrosion: float) -> float:
-    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.")
-    denom = S * E - 0.6 * P
-    if denom <= 0:
-        raise ValueError("Invalid combination: denominator (S*E - 0.6*P) <= 0. Check inputs.")
-    t = (P * R) / denom
-    return float(t + corrosion)
-
-
-def calculate_head_thickness(P: float, R: float, S: float, E: float, corrosion: float, head_type: str) -> float:
-    if E <= 0 or E > 1:
-        raise ValueError("Joint efficiency E must be in (0,1].")
+import math
+from fpdf import FPDF
+import os
+import matplotlib.pyplot as plt
+from groq import Groq
+
+# ========== PAGE CONFIG ==========
+st.set_page_config(page_title="ASME Calculator", layout="wide")
+
+# App Title + Description
+st.markdown("<h1 style='text-align: center;'>🛠️ ASME CALCULATOR</h1>", unsafe_allow_html=True)
+st.markdown(
+    "<p style='text-align: center;'>This tool calculates <b>required thicknesses, nozzle reinforcement, "
+    "PWHT, and impact test requirements</b><br>using ASME Section VIII Division 1 formulas.</p>",
+    unsafe_allow_html=True
+)
+
+# ========== API CLIENT ==========
+groq_api_key = os.getenv("GROQ_API_KEY")
+groq_client = Groq(api_key=groq_api_key) if groq_api_key else None
+
+# ========== PDF GENERATOR ==========
+class PDF(FPDF):
+    def __init__(self):
+        super().__init__()
+        self.add_page()
+        self.set_font("Helvetica", "", 12)
+
+    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)
+
+# ========== CALCULATION FUNCTIONS ==========
+def shell_thickness(P, R, S, E, corrosion):
+    return (P * R) / (S * E - 0.6 * P) + corrosion
+
+def head_thickness(P, R, S, E, corrosion, head_type):
     if head_type == "Ellipsoidal":
-        denom = 2 * S * E - 0.2 * P
-        if denom <= 0:
-            raise ValueError("Invalid inputs for ellipsoidal head formula (denominator <= 0).")
-        t = (P * 2.0 * R) / denom
+        return (0.5 * P * R) / (S * E - 0.1 * P) + corrosion
     elif head_type == "Torispherical":
-        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("Invalid inputs for torispherical head formula (denominator <= 0).")
-        t = (P * L * M) / denom
+        return (0.885 * P * R) / (S * E - 0.1 * P) + corrosion
     elif head_type == "Hemispherical":
-        L = R
-        denom = 2 * S * E - 0.2 * P
-        if denom <= 0:
-            raise ValueError("Invalid inputs for hemispherical head formula (denominator <= 0).")
-        t = (P * L) / denom
-    else:
-        raise ValueError("Unsupported head type.")
-    return float(t + corrosion)
+        return (P * R) / (2 * S * E - 0.2 * P) + corrosion
+    return None
 
+def nozzle_reinforcement(P, d, t_shell, t_nozzle, S, E):
+    return (P * d) / (2 * S * E) <= (t_shell + t_nozzle)
 
-def nozzle_reinforcement_check(P: float, d_opening: float, t_shell: float, t_nozzle: float, S: float, E: float) -> Dict[str, Any]:
-    if any(val <= 0 for val in (d_opening, S, E)):
-        raise ValueError("Nozzle diameter, allowable stress and joint efficiency must be positive.")
-    lhs = (P * d_opening) / (2.0 * S * E)
-    rhs = (t_shell + t_nozzle)
-    adequate = lhs <= rhs
-    return {"lhs": float(lhs), "rhs": float(rhs), "adequate": bool(adequate)}
+def pwht_required(thickness, material="CS"):
+    return material == "CS" and thickness > 38
 
+def impact_test_required(thickness, MDMT=-20, material="CS"):
+    return material == "CS" and (MDMT < -29 and thickness > 12)
 
-def pwht_decision(thickness: float, unit_system: str = "SI") -> bool:
-    if unit_system == "SI":
-        return thickness > 38.0  # mm
-    else:
-        return thickness > mm_to_in(38.0)  # in
-
-# -----------------------------
-# UCS-66 based impact test decision (improved)
-# -----------------------------
-
-def _interpolate_ucs66_min_temp_f(thickness_in: float, curve: str) -> float:
-    """
-    Interpolate the UCS-66 table (inches -> deg F) for selected curve (A-D).
-    If thickness is outside table bounds, we extrapolate conservatively using edge values.
-    """
-    if curve not in CURVE_LABELS:
-        raise ValueError("Curve must be one of A/B/C/D")
-    col = CURVE_LABELS.index(curve)
-    # ensure monotonic increasing thickness array
-    if thickness_in <= UCS66_THICK_IN[0]:
-        return UCS66_TABLE_F[0, col]
-    if thickness_in >= UCS66_THICK_IN[-1]:
-        return UCS66_TABLE_F[-1, col]
-    return float(np.interp(thickness_in, UCS66_THICK_IN, UCS66_TABLE_F[:, col]))
-
-
-def impact_test_decision_ucs66(
-    governing_thickness: float,
-    nominal_thickness: float,
-    corrosion_allowance: float,
-    joint_efficiency: float,
-    design_mdmt: float,
-    material_curve: str,
-    unit_system: str = "SI",
-) -> Dict[str, Any]:
-    """
-    Determine preliminary impact-test requirement using UCS-66 approximation.
-
-    Parameters:
-      governing_thickness: governing design thickness (use required design thickness where applicable)
-      nominal_thickness: nominal plate/weld thickness used in table UCS-66
-      corrosion_allowance: corrosion allowance
-      joint_efficiency: E
-      design_mdmt: MDMT (°C if SI, °F if USC)
-      material_curve: 'A'|'B'|'C'|'D'
-      unit_system: 'SI' or 'USC'
-
-    Returns dict with keys:
-      'impact_required' (bool),
-      'ucs66_min_temp' (deg in user's unit),
-      'adjusted_min_temp' (after coincident-ratio reduction),
-      'coincident_ratio',
-      'note'
-
-    NOTE: This is an approximation for preliminary screening only. Always check the
-    official ASME Fig. UCS-66 and Fig. UCS-66.1 and notes and consult a qualified engineer.
-    """
-    # convert thickness to inches for table lookup
-    if unit_system == "SI":
-        t_g_in = mm_to_in(governing_thickness)
-        tn_in = mm_to_in(nominal_thickness)
-        c_in = mm_to_in(corrosion_allowance)
-        mdmt_f = c_to_f(design_mdmt)
-    else:
-        t_g_in = governing_thickness
-        tn_in = nominal_thickness
-        c_in = corrosion_allowance
-        mdmt_f = design_mdmt
-
-    # step 1: lookup UCS-66 minimum permissible temp (deg F) for governing thickness
-    ucs66_min_f = _interpolate_ucs66_min_temp_f(t_g_in, material_curve)
-
-    # step 2: coincident ratio (FIG UCS-66.1) to possibly reduce the required minimum temp
-    # Ratio = tr * E / (tn - c)
-    denom = (tn_in - c_in)
-    ratio = (t_g_in * joint_efficiency / denom) if denom > 0 else 1.0
-
-    # If ratio >= 1: cannot reduce; adjusted = ucs66_min_f
-    # If ratio < 1: FIG UCS-66.1 gives allowable reduction. We implement a conservative
-    # approximation: reduction (deg F) = min( (1 - ratio) * 40, 30 )
-    # (This is an approximation for screening only.)
-    if ratio >= 1.0:
-        adjusted_min_f = ucs66_min_f
-    else:
-        reduction = min((1.0 - ratio) * 40.0, 30.0)  # cap at 30°F
-        adjusted_min_f = ucs66_min_f - reduction
+# ========== SESSION STATE ==========
+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
 
-    # final decision: if MDMT >= adjusted_min_f -> impact not required
-    impact_required = mdmt_f < adjusted_min_f
+# ========== SIDEBAR INPUTS ==========
+with st.sidebar.expander("📥 Manual Design Inputs", expanded=True):
 
-    # convert temps back to user's unit
-    if unit_system == "SI":
-        ucs66_min = f_to_c(ucs66_min_f)
-        adjusted_min = f_to_c(adjusted_min_f)
-    else:
-        ucs66_min = ucs66_min_f
-        adjusted_min = adjusted_min_f
-
-    # note: enforce thickness limitations mentioned in code notes (UCS-66(d) and others)
-    # For conservative handling: if nominal thickness <= 0.1 in (≈2.5 mm) allow limited exemptions per UCS-66(d)
-    small_thickness_exempt = (tn_in <= 0.098)  # 0.098 in ≈ 2.5 mm
-
-    note = (
-        "Preliminary UCS-66 screening (approximated table + conservative coincident-ratio reduction)."
-        " Use official ASME Fig. UCS-66 / UCS-66.1 for final decisions."
-    )
-
-    return {
-        "impact_required": bool(impact_required and not small_thickness_exempt),
-        "ucs66_min_temp_user_unit": ucs66_min,
-        "adjusted_min_temp_user_unit": adjusted_min,
-        "coincident_ratio": float(ratio),
-        "mdmt_user_unit": design_mdmt,
-        "small_thickness_exempt": bool(small_thickness_exempt),
-        "note": note,
-    }
-
-# -----------------------------
-# Streamlit UI
-# -----------------------------
-
-st.set_page_config(page_title="ASME Section VIII Calculator", page_icon="🔧", layout="wide")
-st.title("🔧 ASME Section VIII — Preliminary Calculator (UCS-66 improved)")
-st.caption(
-    "Preliminary calculations only. Final verification must be completed by a licensed professional engineer "
-    "and checked against the latest ASME code editions. This tool uses a conservative UCS-66 approximation for screening."
-)
+    input_mode = st.radio("Input Mode:", ["Manual Entry", "Upload CSV"])
+    run_calculation = False
 
-if "run_done" not in st.session_state:
-    st.session_state.run_done = False
+    if input_mode == "Manual Entry":
+        P = st.number_input("Design Pressure (MPa)", value=2.0, format="%.2f")
+        R = st.number_input("Internal Radius (mm)", value=1000.0, format="%.1f")
+        S = st.number_input("Allowable Stress (MPa)", value=120.0, format="%.1f")
+        corrosion = st.number_input("Corrosion Allowance (mm)", value=1.5, format="%.2f")
 
-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")
-
-    st.markdown("---")
-    if use_si:
-        design_pressure = st.number_input("Design Pressure (MPa)", value=2.0, format="%.3f")
-        inside_diameter = st.number_input("Inside Diameter (mm)", value=1500.0, format="%.1f")
-        R = inside_diameter / 2.0
-        allowable_stress = st.number_input("Allowable Stress (MPa)", value=120.0, format="%.2f")
-        corrosion_allowance = st.number_input("Corrosion Allowance (mm)", value=1.5, format="%.2f")
-        design_mdmt = st.number_input("Design MDMT (°C)", value=-20.0)
-    else:
-        design_pressure = st.number_input("Design Pressure (psi)", value=mpa_to_psi(2.0), format="%.1f")
-        inside_diameter = st.number_input("Inside Diameter (in)", value=mm_to_in(1500.0), format="%.3f")
-        R = inside_diameter / 2.0
-        allowable_stress = st.number_input("Allowable Stress (psi)", value=mpa_to_psi(120.0), format="%.1f")
-        corrosion_allowance = 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"])
-    joint_eff = st.selectbox("Joint Efficiency (E)", [1.0, 0.95, 0.9, 0.85, 0.7], index=0)
-
-    st.markdown("---")
-    # Nozzle inputs (requesting the required inputs)
-    if use_si:
-        nozzle_opening_diameter = st.number_input("Nozzle Opening Diameter (mm)", value=200.0, format="%.1f")
-        nozzle_wall_thickness = st.number_input("Nozzle Wall Thickness (mm)", value=10.0, format="%.2f")
-        shell_thickness_available = st.number_input("Shell thickness available (mm)", value=12.0, format="%.2f")
-    else:
-        nozzle_opening_diameter = st.number_input("Nozzle Opening Diameter (in)", value=mm_to_in(200.0), format="%.3f")
-        nozzle_wall_thickness = st.number_input("Nozzle Wall Thickness (in)", value=mm_to_in(10.0), format="%.4f")
-        shell_thickness_available = st.number_input("Shell thickness available (in)", value=mm_to_in(12.0), format="%.4f")
+        joint_method = st.radio("Joint Efficiency Selection", ["Preset (UW-12)", "Manual Entry"])
+        if joint_method == "Preset (UW-12)":
+            E = st.selectbox("Select E (Joint Efficiency)", [1.0, 0.85, 0.7, 0.65, 0.6, 0.45])
+        else:
+            E = st.number_input("Manual Joint Efficiency (0-1)", value=0.85, min_value=0.1, max_value=1.0)
 
-    st.markdown("---")
-    # UCS-66 / material curve selection for impact testing
-    material_curve = st.selectbox("Material Curve for UCS-66", ["A", "B", "C", "D"], index=3)
+        head_type = st.selectbox("Head Type", ["Ellipsoidal", "Torispherical", "Hemispherical"])
+        d_nozzle = st.number_input("Nozzle Diameter (mm)", value=200.0, format="%.1f")
+        t_shell = st.number_input("Shell Thickness Provided (mm)", value=12.0, format="%.1f")
+        t_nozzle = st.number_input("Nozzle Thickness Provided (mm)", value=10.0, format="%.1f")
+        thickness = st.number_input("Governing Thickness (mm)", value=40.0, format="%.1f")
 
-    st.markdown("---")
-    # Single run and reset
-    run_calc = st.button("Run Calculation")
-    reset = st.button("Reset to defaults")
-    if reset:
-        st.session_state.run_done = False
-        st.experimental_rerun()
+        if st.button("🚀 Run Calculation", use_container_width=True):
+            st.session_state.run_done = True
+            run_calculation = True
 
-if run_calc:
-    st.session_state.run_done = True
+        if st.session_state.run_done:
+            st.success("✅ Calculations completed! See results in the tabs.")
 
-# Tabs and results
-tab_list = ["Shell", "Head", "Nozzle", "PWHT & Impact", "Summary"]
-tabs = st.tabs(tab_list)
+    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):
+                st.session_state.run_done = True
+                run_calculation = True
+
+            if st.session_state.run_done:
+                st.success("✅ Calculations completed! See results in the tabs.")
+
+# ========== TABS ==========
+tabs = st.tabs(["Shell", "Head", "Nozzle", "PWHT", "Impact Test", "Summary", "AI Explanation"])
 
 if st.session_state.run_done:
-    # Shell tab
+    # --- SHELL TAB ---
     with tabs[0]:
-        try:
-            shell_res = calculate_shell_thickness(design_pressure, R, allowable_stress, joint_eff, corrosion_allowance)
-            units_len = "mm" if use_si else "in"
-            st.metric("Required Shell Thickness (incl. corrosion)", f"{shell_res:.4f} {units_len}")
-            st.write("Inputs:", {"P": design_pressure, "R": R, "S": allowable_stress, "E": joint_eff})
-        except Exception as exc:
-            st.error(f"Shell calculation error: {exc}")
-
-    # Head tab
+        t_shell_calc = shell_thickness(P, R, S, E, corrosion)
+        st.metric("Required Shell Thickness (mm)", f"{t_shell_calc:.2f}")
+
+    # --- HEAD TAB ---
     with tabs[1]:
-        try:
-            head_res = calculate_head_thickness(design_pressure, R, allowable_stress, joint_eff, corrosion_allowance, head_type)
-            units_len = "mm" if use_si else "in"
-            st.metric(f"Required {head_type} Head Thickness (incl. corrosion)", f"{head_res:.4f} {units_len}")
-            st.write("Intermediate values: D ≈", 2.0 * R)
-        except Exception as exc:
-            st.error(f"Head calculation error: {exc}")
-
-    # Nozzle tab
+        t_head_calc = head_thickness(P, R, S, E, corrosion, head_type)
+        st.metric(f"Required {head_type} Head Thickness (mm)", f"{t_head_calc:.2f}")
+
+    # --- NOZZLE TAB ---
     with tabs[2]:
-        try:
-            nozzle_check = nozzle_reinforcement_check(design_pressure, nozzle_opening_diameter, shell_thickness_available, nozzle_wall_thickness, allowable_stress, joint_eff)
-            st.write("Nozzle reinforcement conservative check:")
-            st.write(f"LHS = (P * d) / (2SE) = {nozzle_check['lhs']:.6g}")
-            st.write(f"RHS = t_shell + t_nozzle = {nozzle_check['rhs']:.6g}")
-            if nozzle_check["adequate"]:
-                st.success("Conservative nozzle reinforcement check PASSED")
-            else:
-                st.error("Conservative nozzle reinforcement check FAILED")
-            st.caption("This is a simplified, conservative approximation of UG-37. Use full UG-37 projection-area method for final design.")
-        except Exception as exc:
-            st.error(f"Nozzle calculation error: {exc}")
-
-    # PWHT & Impact tab
+        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")
+
+    # --- PWHT TAB ---
     with tabs[3]:
-        try:
-            thickness_for_checks = shell_res if "shell_res" in locals() else shell_thickness_available
-            pwht_flag = pwht_decision(thickness_for_checks, unit_system="SI" if use_si else "USC")
-
-            impact_info = impact_test_decision_ucs66(
-                governing_thickness=thickness_for_checks,
-                nominal_thickness=shell_thickness_available,
-                corrosion_allowance=corrosion_allowance,
-                joint_efficiency=joint_eff,
-                design_mdmt=design_mdmt,
-                material_curve=material_curve,
-                unit_system="SI" if use_si else "USC",
-            )
-
-            st.subheader("PWHT (Preliminary)")
-            st.write("PWHT required:", "YES" if pwht_flag else "NO")
-
-            st.subheader("Impact Test (MDMT) - Preliminary (UCS-66 approximation)")
-            st.write("Material curve:", material_curve)
-            st.write("Governing thickness:", f"{thickness_for_checks:.3f} {'mm' if use_si else 'in'}")
-            st.write("Nominal thickness used for table:", f"{shell_thickness_available:.3f} {'mm' if use_si else 'in'}")
-            st.write("Coincident ratio (tr*E/(tn-c)):", f"{impact_info['coincident_ratio']:.3f}")
-            st.write("Minimum permissible MDMT without impact testing (UCS-66, approx):", f"{impact_info['ucs66_min_temp_user_unit']:.2f} {'°C' if use_si else '°F'}")
-            st.write("Adjusted minimum after coincident-ratio allowance (approx):", f"{impact_info['adjusted_min_temp_user_unit']:.2f} {'°C' if use_si else '°F'}")
-            st.write("Design MDMT:", f"{design_mdmt:.2f} {'°C' if use_si else '°F'}")
-
-            if impact_info['small_thickness_exempt']:
-                st.info("Nominal thickness is <= 2.5 mm — small-thickness exemption per UCS-66(d) may apply (preliminary).")
-
-            if impact_info['impact_required']:
-                st.error("Impact test REQUIRED (preliminary).")
-            else:
-                st.success("Impact test NOT required (preliminary).")
-
-            st.caption(impact_info['note'])
-        except Exception as exc:
-            st.error(f"PWHT/Impact calculation error: {exc}")
-
-    # Summary tab
+        st.write("PWHT Required:", "✅ Yes" if pwht_required(thickness) else "❌ No")
+
+    # --- IMPACT TEST TAB ---
     with tabs[4]:
-        try:
-            summary = {
-                "Unit System": "SI (MPa/mm/°C)" if use_si else "USC (psi/in/°F)",
-                "Design Pressure": design_pressure,
-                "Inside Diameter": inside_diameter,
-                "Shell Required Thickness": shell_res if "shell_res" in locals() else None,
-                "Head Required Thickness": head_res if "head_res" in locals() else None,
-                "Nozzle Check Passed": nozzle_check["adequate"] if "nozzle_check" in locals() else None,
-                "PWHT Required": pwht_flag if "pwht_flag" in locals() else None,
-                "Impact Test Required": impact_info["impact_required"] if "impact_info" in locals() else None,
-                "UCS66 Curve": material_curve,
-                "Generated": datetime.datetime.now().isoformat(),
-            }
-            df_summary = pd.DataFrame([summary])
-            st.dataframe(df_summary, use_container_width=True)
-
-            csv_bytes = df_summary.to_csv(index=False).encode("utf-8")
-            st.download_button("Download Summary CSV", csv_bytes, file_name="asme_summary.csv", mime="text/csv")
-        except Exception as exc:
-            st.error(f"Summary building error: {exc}")
+        st.write("Impact Test Required:", "✅ Yes" if impact_test_required(thickness) else "❌ No")
+
+    # --- SUMMARY TAB ---
+    with tabs[5]:
+        summary_data = {
+            "Shell Thickness": t_shell_calc,
+            "Head Thickness": t_head_calc,
+            "Nozzle Safe": safe_nozzle,
+            "PWHT Required": pwht_required(thickness),
+            "Impact Test Required": impact_test_required(thickness),
+        }
+        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")
+
+    # --- 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}"
+                    chat_completion = 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")
+                    st.write(explanation)
+
+            if st.session_state.ai_done:
+                st.info("✨ AI explanation already generated. Rerun to refresh.")
+        else:
+            st.info("ℹ️ Add your GROQ_API_KEY in Hugging Face secrets to enable AI explanations.")
 
 else:
-    for i, lbl in enumerate(tab_list):
+    # Placeholders
+    for i, msg in enumerate([
+        "Shell results", "Head results", "Nozzle results",
+        "PWHT decision", "Impact Test decision",
+        "Summary", "AI explanation"
+    ]):
         with tabs[i]:
-            st.info("Set inputs in the sidebar and click 'Run Calculation' to execute.")
-
+            st.info(f"Run calculation to see {msg}.")