Update app.py

app.py

@@ -1,1020 +1,357 @@
 #!/usr/bin/env python3
 """
-ASME Section VIII — Preliminary Pressure Vessel Calculator (Streamlit)
-
-Single-file Streamlit app with:
-- USC / SI units
-- Material database (selectable)
-- UG-27 shell thickness (circumferential & longitudinal checks)
-- UG-32 head thickness (ellipsoidal / torispherical / hemispherical)
-- Improved UG-37-style nozzle reinforcement area method (conservative approx)
-- PWHT recommendation (simplified, UCS-56 style)
-- Impact test (Design MDMT vs Rated MDMT) approximation (UCS-66 style approximation)
-- MAWP calculation from thickness
-- CSV export and optional PDF export (reportlab)
-
-ASSUMPTION: This is a preliminary tool. Approximations are labeled and conservative by design.
-APPROXIMATION: MDMT and some reinforcement area calculations are simplified for demo/testing.
-
-Requirements: streamlit, pandas, numpy, plotly (optional), reportlab (optional)
+ASME Calculator (updated) — add Unit System (USC / SI) support.
+
+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.
 """
 
 from __future__ import annotations
-from typing import Dict, Any, Optional, Tuple
+import os
 import math
 import datetime
+from typing import Dict, Any
 
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
 
-# Module metadata
-__version__ = "0.1.1"  # bumped for nozzle + edition + E updates
-
-# ---------------------------
-# Constants
-# ---------------------------
-ATM_PRESSURE_PSI = 14.7  # used only for context
-PIPE_THICKNESS_REDUCTION = 0.125  # 12.5% reduction for pipe grades
-DEFAULT_CORROSION_ALLOWANCE_IN = 0.125
-SUPPORTED_ASME_EDITIONS = ["2019", "2021", "2025", "custom"]  # added 2025
-
-# Units formatting
-INCH_DECIMALS = 4
-MM_DECIMALS = 2
-
-# ---------------------------
-# MATERIALS - simplified ASME Section II style tables (representative)
-# Each material maps to a dict: { 'allowable_stress': {units: {temp: stress, ...}}, 'material_group': str, 'carbon_equivalent': float }
-# Temperatures provided in °F for USC and °C for SI. Values are representative and for demo - not exhaustive.
-# TODO: Replace with full ASME Section II tables keyed by edition.
-# ---------------------------
-
-MATERIALS: Dict[str, Dict[str, Dict[str, Any]]] = {
-    "Carbon Steel": {
-        "SA-106B": {
-            "allowable_stress": {
-                "USC": { -20: 20000, 100: 20000, 200: 19000, 300: 17000 },  # psi
-                "SI": { -29: 138, 38: 138, 93: 131, 149: 117 },  # MPa
-            },
-            "carbon_equivalent": 0.35,
-            "material_group": "P1",
-            "is_pipe_grade": True,
-        },
-        "SA-53B-ERW": {
-            "allowable_stress": {
-                "USC": { -20: 20000, 100: 20000, 200: 19000, 300: 17000 },
-                "SI": { -29: 138, 38: 138, 93: 131, 149: 117 },
-            },
-            "carbon_equivalent": 0.34,
-            "material_group": "P1",
-            "is_pipe_grade": True,
-        },
-        "SA-516-60": {
-            "allowable_stress": {
-                "USC": { -20: 15000, 100: 15000, 200: 15000, 300: 15000 },
-                "SI": { -29: 103, 38: 103, 93: 103, 149: 103 },
-            },
-            "carbon_equivalent": 0.30,
-            "material_group": "P1",
-            "is_pipe_grade": False,
-        },
-        "SA-516-70": {
-            "allowable_stress": {
-                "USC": { -20: 17500, 100: 17500, 200: 17500, 300: 17500 },
-                "SI": { -29: 121, 38: 121, 93: 121, 149: 121 },
-            },
-            "carbon_equivalent": 0.31,
-            "material_group": "P1",
-            "is_pipe_grade": False,
-        },
-    },
-    "Stainless Steel": {
-        # plate/tube
-        "SA-240-304": {
-            "allowable_stress": {
-                "USC": { -20: 18800, 100: 18800, 200: 16200 },
-                "SI": { -29: 130, 38: 130, 93: 112 },
-            },
-            "carbon_equivalent": 0.08,
-            "material_group": "P8",
-            "is_pipe_grade": False,
-        },
-        "SA-240-316": {
-            "allowable_stress": {
-                "USC": { -20: 18800, 100: 18800, 200: 16600 },
-                "SI": { -29: 130, 38: 130, 93: 114 },
-            },
-            "carbon_equivalent": 0.08,
-            "material_group": "P8",
-            "is_pipe_grade": False,
-        },
-        "SA-240-304L": {
-            "allowable_stress": {
-                "USC": { -20: 18000, 100: 18000, 200: 16000 },
-                "SI": { -29: 124, 38: 124, 93: 110 },
-            },
-            "carbon_equivalent": 0.08,
-            "material_group": "P8",
-            "is_pipe_grade": False,
-        },
-        "SA-240-316L": {
-            "allowable_stress": {
-                "USC": { -20: 18000, 100: 18000, 200: 16400 },
-                "SI": { -29: 124, 38: 124, 93: 112 },
-            },
-            "carbon_equivalent": 0.08,
-            "material_group": "P8",
-            "is_pipe_grade": False,
-        },
-        # pipe
-        "SA-312-304": {
-            "allowable_stress": {
-                "USC": { -20: 18800, 100: 18800, 200: 16200 },
-                "SI": { -29: 130, 38: 130, 93: 112 },
-            },
-            "carbon_equivalent": 0.08,
-            "material_group": "P8",
-            "is_pipe_grade": True,
-        },
-        "SA-312-316": {
-            "allowable_stress": {
-                "USC": { -20: 18800, 100: 18800, 200: 16600 },
-                "SI": { -29: 130, 38: 130, 93: 114 },
-            },
-            "carbon_equivalent": 0.08,
-            "material_group": "P8",
-            "is_pipe_grade": True,
-        },
-        "SA-312-304L": {
-            "allowable_stress": {
-                "USC": { -20: 18000, 100: 18000, 200: 16000 },
-                "SI": { -29: 124, 38: 124, 93: 110 },
-            },
-            "carbon_equivalent": 0.08,
-            "material_group": "P8",
-            "is_pipe_grade": True,
-        },
-        "SA-312-316L": {
-            "allowable_stress": {
-                "USC": { -20: 18000, 100: 18000, 200: 16400 },
-                "SI": { -29: 124, 38: 124, 93: 112 },
-            },
-            "carbon_equivalent": 0.08,
-            "material_group": "P8",
-            "is_pipe_grade": True,
-        },
-    },
-    # User Defined handled separately
-}
-
-# ---------------------------
-# Helper functions
-# ---------------------------
-
-
-def _interpolate_allowable(stress_table: Dict[float, float], temperature: float) -> float:
-    """Linear interpolation for stress vs temperature table. Expects sorted keys possible unsorted."""
-    temps = sorted(stress_table.keys())
-    stresses = [stress_table[t] for t in temps]
-    if temperature <= temps[0]:
-        return float(stresses[0])
-    if temperature >= temps[-1]:
-        return float(stresses[-1])
-    return float(np.interp(temperature, temps, stresses))
-
-
-def get_allowable_stress(material_category: str, material_grade: str, design_temperature: float, units: str) -> Tuple[float, Optional[str]]:
-    """
-    Returns (allowable_stress, warning_msg_or_none)
-    units: "USC" or "SI"
-    ASSUMPTION: MATERIALS table is representative. Replace with full ASME II table when available.
-    """
-    if material_category == "User Defined":
-        # Should be handled elsewhere; return sentinel
-        raise ValueError("User Defined materials should provide allowable stress explicitly.")
-    try:
-        mat_info = MATERIALS[material_category][material_grade]
-    except KeyError:
-        raise ValueError(f"Material grade {material_grade} not found under category {material_category}")
-
-    table = mat_info["allowable_stress"].get(units)
-    if table is None:
-        raise ValueError(f"No allowable stress data for units '{units}' for material {material_grade}")
-    temps = sorted(table.keys())
-    wmsg = None
-    if design_temperature < temps[0] or design_temperature > temps[-1]:
-        wmsg = f"Design temperature {design_temperature} outside table range [{temps[0]}, {temps[-1]}]. Using nearest-end value."
-    S = _interpolate_allowable(table, design_temperature)
-    return S, wmsg
-
-
-def convert_temp(value: float, from_unit: str, to_unit: str) -> float:
-    """Convert temperature between 'F' and 'C'."""
-    if from_unit == to_unit:
-        return value
-    if from_unit == "F" and to_unit == "C":
-        return (value - 32.0) * 5.0 / 9.0
-    if from_unit == "C" and to_unit == "F":
-        return (value * 9.0 / 5.0) + 32.0
-    return value
-
-
-def format_value(value: float, units: str, is_length: bool = False) -> str:
-    """Format numeric values with sensible precision per unit."""
-    if is_length:
-        if units in ("in", "psi", "USC"):  # treat as inches for length when USC
-            return f"{value:.{INCH_DECIMALS}f}"
-        else:
-            return f"{value:.{MM_DECIMALS}f}"
-    # default generic formatting
-    if abs(value) >= 1000:
-        return f"{value:,.0f}"
-    if abs(value) >= 1:
-        return f"{value:.3g}"
-    return f"{value:.4g}"
-
-
-# ---------------------------
-# Calculation functions (pure)
-# ---------------------------
-
-def calculate_shell_thickness(P: float, R: float, S: float, E: float) -> Dict[str, Any]:
-    """
-    UG-27 circumferential formula (simplified).
-    P: design pressure (same units as S)
-    R: inside radius
-    S: allowable stress
-    E: joint efficiency (0 < E <= 1)
-    Returns a dict with required thicknesses and metadata.
-    """
-    # Validate
-    if P < 0:
-        raise ValueError("Design pressure must be >= 0")
-    if R <= 0:
-        raise ValueError("Radius must be positive")
+# PDF generator (fpdf2)
+from fpdf import FPDF
+
+# Groq client (optional - requires GROQ_API_KEY in environment or HF secrets)
+try:
+    from groq import Groq
+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
+PSI_TO_MPA = 1.0 / MPA_TO_PSI
+
+def mpato_psi(x: float) -> float:
+    return x * MPA_TO_PSI
+
+def psi_to_mpa(x: float) -> float:
+    return x * PSI_TO_MPA
+
+def mm_to_in(x: float) -> float:
+    return x * MM_TO_IN
+
+def in_to_mm(x: float) -> float:
+    return x * IN_TO_MM
+
+# ========== CALCULATION FUNCTIONS ==========
+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)
+    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")
-    if not (0 < E <= 1):
-        raise ValueError("Joint efficiency E must be in (0, 1]")
-
-    # UG-27 circumferential:
-    # if P <= 0.385 * S * E: t = PR/(SE - 0.6P)
-    # else: t = PR/(SE + 0.4P)
-    cond_val = 0.385 * S * E
-    if P <= cond_val:
-        t_circ = (P * R) / (S * E - 0.6 * P)
-        formula_used = "t = PR/(SE - 0.6P)"
-        condition = f"P ≤ 0.385SE: {P:.3f} ≤ {cond_val:.3f}"
+        raise ValueError("Allowable stress must be positive.")
+    # Use the formula as provided originally (assumes P, R, S in consistent units)
+    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).")
+    t = (P * R) / denom
+    return 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)."""
+    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
+        if denom <= 0:
+            raise ValueError("Denominator invalid for Ellipsoidal head formula.")
+        return (0.5 * P * R) / denom + corrosion
+    elif head_type == "Torispherical":
+        denom = S * E - 0.1 * P
+        if denom <= 0:
+            raise ValueError("Denominator invalid for Torispherical head formula.")
+        return (0.885 * P * R) / denom + corrosion
+    elif head_type == "Hemispherical":
+        denom = 2 * S * E - 0.2 * P
+        if denom <= 0:
+            raise ValueError("Denominator invalid for Hemispherical head formula.")
+        return (P * R) / denom + corrosion
     else:
-        t_circ = (P * R) / (S * E + 0.4 * P)
-        formula_used = "t = PR/(SE + 0.4P)"
-        condition = f"P > 0.385SE: {P:.3f} > {cond_val:.3f}"
-
-    # longitudinal t = PR / (2SE + 0.4P)
-    t_long = (P * R) / (2 * S * E + 0.4 * P)
-
-    required = max(t_circ, t_long)
-    governing = "Circumferential" if t_circ >= t_long else "Longitudinal"
-
-    return {
-        "circumferential_thickness": float(t_circ),
-        "longitudinal_thickness": float(t_long),
-        "required_thickness": float(required),
-        "governing_case": governing,
-        "formula_used": formula_used,
-        "condition_check": condition,
-        "asme_clause": "UG-27",
-    }
+        raise ValueError("Unsupported head type.")
 
-
-def calculate_head_thickness(P: float, D: float, S: float, E: float, head_type: str = "ellipsoidal") -> Dict[str, Any]:
-    """
-    Return required head thickness per simplified UG-32 formulas.
-    P: design pressure
-    D: inside diameter
-    S: allowable stress
-    E: joint efficiency
-    head_type: 'ellipsoidal', 'torispherical', 'hemispherical'
-    """
-    if P < 0:
-        raise ValueError("Design pressure must be >= 0")
-    if D <= 0:
-        raise ValueError("Diameter must be positive")
-    if S <= 0:
-        raise ValueError("Allowable stress must be positive")
-    if not (0 < E <= 1):
-        raise ValueError("Joint efficiency E must be in (0,1]")
-
-    if head_type == "ellipsoidal":
-        K = 1.0  # geometry factor
-        t = (P * D * K) / (2 * S * E - 0.2 * P)
-        formula = "t = P*D*K/(2SE - 0.2P)"
-        inter = {"K": K}
-        clause = "UG-32(d), Appendix 1-4(c)"
-    elif head_type == "torispherical":
-        # approximations for torispherical: crown radius L = D, knuckle r = 0.1D
-        L = D
-        r = 0.1 * D
-        M = 0.25 * (3.0 + math.sqrt(L / r))
-        t = (P * L * M) / (2 * S * E - 0.2 * P)
-        formula = f"t = P*L*M/(2SE - 0.2P), M={M:.3f}"
-        inter = {"L": L, "r": r, "M": M}
-        clause = "UG-32(e), Appendix 1-4(d)"
-    elif head_type == "hemispherical":
-        L = D / 2.0
-        t = (P * L) / (2 * S * E - 0.2 * P)
-        formula = "t = P*L/(2SE - 0.2P)"
-        inter = {"L": L}
-        clause = "UG-32(f), Appendix 1-4(e)"
-    else:
-        raise ValueError(f"Unsupported head type '{head_type}'")
-
-    return {
-        "required_thickness": float(t),
-        "head_type": head_type,
-        "formula_used": formula,
-        "intermediate_values": inter,
-        "asme_clause": clause,
-    }
-
-
-def calculate_nozzle_reinforcement(
-    d_opening: float,
-    t_shell_required: float,
-    t_nozzle: float,
-    t_pad: float,
-    pad_width: float,
-    material_grade: Optional[str] = None,
-    shell_local_extra_thickness: float = 0.0,
-    weld_throat: float = 0.0,
-    weld_efficiency: float = 0.7,
-) -> Dict[str, Any]:
+def nozzle_reinforcement(P: float, d: float, t_shell: float, t_nozzle: float, S: float, E: float) -> bool:
     """
-    Improved simplified UG-37 area method approximation.
-
-    Method (conservative approximations):
-    - Required area: A_req = d_opening * t_shell_required
-    - Nozzle contribution: A_nozzle = pi * d_opening * t_nozzle  (cylindrical projection)
-      # APPROXIMATION: Using circumference*thickness as projected reinforcement area.
-    - Pad contribution: A_pad = pad_width * t_pad * 2 (count both faces as conservative rectangular pads)
-    - Shell local extra thickness contribution: A_shell_local = pi * d_opening * shell_local_extra_thickness
-    - Weld contribution: A_weld = weld_throat * pi * d_opening * weld_efficiency
-    - For pipe grades (SA-106B, SA-53B-ERW, SA-312-*) apply 12.5% thickness reduction to nozzle/pad/weld contributions.
-    - Assumptions and limitations are returned in 'assumptions' and should be reviewed by an engineer.
+    Simplified conservative check originally provided:
+    (P * d) / (2 * S * E) <= (t_shell + t_nozzle)
+    Works if units are consistent.
     """
-    # Input validation
-    if d_opening <= 0:
-        raise ValueError("Nozzle opening diameter must be positive.")
-    if t_shell_required <= 0:
-        raise ValueError("Shell required thickness must be positive.")
-    if t_nozzle <= 0:
-        raise ValueError("Nozzle wall thickness must be positive.")
-
-    A_required = d_opening * t_shell_required  # projection length * thickness
-
-    # Nozzle cylindrical contribution (projection)
-    A_nozzle = math.pi * d_opening * t_nozzle  # circumference * thickness (approx)
-    # Pad contribution: two faces conservative rectangular pad
-    A_pad = pad_width * t_pad * 2.0 if (t_pad and pad_width) else 0.0
-    # Shell local extra thickness contribution (if user provides local reinforcement)
-    A_shell_local = math.pi * d_opening * shell_local_extra_thickness if shell_local_extra_thickness else 0.0
-    # Weld contribution
-    A_weld = weld_throat * math.pi * d_opening * weld_efficiency if weld_throat and weld_efficiency else 0.0
-
-    reduction_info = ""
-    # check pipe grade
-    if material_grade:
-        for cat in MATERIALS:
-            mg = MATERIALS[cat].get(material_grade)
-            if mg:
-                if mg.get("is_pipe_grade"):
-                    # apply reduction to contributions that rely on nominal thickness (nozzle, pad, weld)
-                    A_nozzle = A_nozzle * (1.0 - PIPE_THICKNESS_REDUCTION)
-                    A_pad = A_pad * (1.0 - PIPE_THICKNESS_REDUCTION)
-                    A_weld = A_weld * (1.0 - PIPE_THICKNESS_REDUCTION)
-                    reduction_info = f"Applied {PIPE_THICKNESS_REDUCTION*100:.1f}% pipe thickness reduction to nozzle/pad/weld contributions."
-                break
-
-    A_available = A_shell_local + A_nozzle + A_pad + A_weld
-
-    adequate = A_available >= A_required
-    safety_factor = (A_available / A_required) if A_required > 0 else float("inf")
-
-    assumptions = [
-        "# ASSUMPTION: Using projection-area approximations (circumference*thickness) for nozzle contribution.",
-        "# APPROXIMATION: Pad is modeled as rectangular and both faces are counted for conservatism.",
-        "# ASSUMPTION: Shell local extra thickness is approximated as circumference * extra_thickness.",
-        "# ASSUMPTION: Weld contribution approximated as weld_throat * circumference * efficiency.",
-        "Real UG-37 uses more exact geometric projections and weld strength contribution; this is conservative and simplified.",
-    ]
-    if reduction_info:
-        assumptions.append(reduction_info)
-
-    return {
-        "area_required": float(A_required),
-        "area_shell_local": float(A_shell_local),
-        "area_nozzle": float(A_nozzle),
-        "area_pad": float(A_pad),
-        "area_weld": float(A_weld),
-        "area_available_total": float(A_available),
-        "reinforcement_adequate": bool(adequate),
-        "safety_factor": float(safety_factor),
-        "assumptions": assumptions,
-        "asme_clause": "UG-37 (approx)",
-    }
-
-
-def determine_pwht_requirements(material_group: str, thickness_in_in: float, carbon_equivalent: float) -> Dict[str, Any]:
+    lhs = (P * d) / (2 * S * E)
+    rhs = (t_shell + t_nozzle)
+    return lhs <= rhs
+
+def pwht_required(thickness: float, material: str = "CS", unit_system: str = "SI") -> bool:
     """
-    Very simplified PWHT logic following UCS-56 style rules:
-    - ASSUMPTION: PWHT recommended if thickness > 1.25 in for P1 group or CE > 0.35
+    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)
     """
-    if thickness_in_in < 0:
-        raise ValueError("Thickness must be non-negative")
-
-    pwht_required = False
-    reasons = []
-    temp_range = ""
-    hold_time = ""
-
-    if material_group == "P1":
-        if thickness_in_in > 1.25:
-            pwht_required = True
-            reasons.append("Thickness > 1.25 inches (UCS-56 guidance).")
-            temp_range = "1100°F - 1200°F"
-            hold_time = f"Minimum {max(1, int(math.ceil(thickness_in_in)))} hours (approx)"
-        if carbon_equivalent > 0.35:
-            pwht_required = True
-            reasons.append("Carbon equivalent > 0.35% (UCS-56).")
-    elif material_group == "P8":
-        reasons.append("Stainless steel (P8): PWHT generally not required; follow spec.")
+    if unit_system == "SI":
+        threshold = 38.0
     else:
-        reasons.append("Material group unknown: consult specification.")
-
-    if not pwht_required:
-        reasons.append("Below thickness/CE limits for mandatory PWHT (preliminary check).")
+        threshold = mm_to_in(38.0)
+    return (material == "CS") and (thickness > threshold)
 
-    return {"pwht_required": pwht_required, "reasons": reasons, "temperature_range": temp_range, "hold_time": hold_time}
-
-
-def _approximate_rated_mdmt(material_group: str, thickness_in_in: float) -> float:
-    """
-    APPROXIMATION: Provide a conservative approximate rated MDMT based on material group and thickness.
-    This is NOT the full UCS-66 lookup. Use as a placeholder to compare with Design MDMT.
-    We define a simple table for P1 and P8 (°F).
-    """
-    if material_group == "P8":
-        return -325.0
-    if thickness_in_in <= 0.5:
-        return 60.0
-    if thickness_in_in <= 1.0:
-        return 30.0
-    if thickness_in_in <= 2.0:
-        return 0.0
-    if thickness_in_in <= 4.0:
-        return -20.0
-    return -50.0
-
-
-def determine_impact_test_requirements(material_group: str, design_mdmt: float, thickness_in_in: float, units: str) -> Dict[str, Any]:
+def impact_test_required(thickness: float, MDMT: float = -20.0, material: str = "CS", unit_system: str = "SI") -> bool:
     """
-    Compare Design MDMT (user input) with approximate Rated MDMT.
-    Returns whether impact test required and test temp (Design MDMT - 30°F or -17°C).
-    Units: 'USC' or 'SI' for comparisons and for returned values.
+    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.
     """
-    if thickness_in_in < 0:
-        raise ValueError("Thickness must be non-negative")
-    if units not in ("USC", "SI"):
-        raise ValueError("units must be 'USC' or 'SI'")
-
-    # Work in °F internally for rated_mdmt approximation
-    if units == "SI":
-        design_mdmt_f = convert_temp(design_mdmt, "C", "F")
+    if unit_system == "SI":
+        thickness_threshold = 12.0  # mm
+        mdmt_check_val = -29.0
     else:
-        design_mdmt_f = design_mdmt
-
-    rated_mdmt_f = _approximate_rated_mdmt(material_group, thickness_in_in)
-
-    # Coincident ratio: ASSUMPTION - we use a simple rule: if design_temp within 30°F of rated, may be allowed by coincident rules
-    coincident_info = "Coincident ratio not fully implemented; conservative compare used. See UCS-66 for full logic."
-    impact_required = design_mdmt_f > rated_mdmt_f  # if design is colder (lower), fine; if warmer (higher) -> required
-    # test temperature suggestion
-    if units == "SI":
-        test_temp = convert_temp(design_mdmt_f - 30.0, "F", "C")
+        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 ==========
+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
+
+    # Set sensible defaults depending on unit system (based on previous defaults)
+    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
     else:
-        test_temp = design_mdmt_f - 30.0
+        # 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")
 
-    return {
-        "impact_test_required": bool(impact_required),
-        "rated_mdmt": rated_mdmt_f if units == "USC" else convert_temp(rated_mdmt_f, "F", "C"),
-        "design_mdmt": design_mdmt,
-        "exemption_coincident_ratio_info": coincident_info,
-        "test_temperature": test_temp,
-        "notes": "APPROXIMATION: rated MDMT is an estimate - use UCS-66 tables for precise determination.",
-    }
+        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")
 
-def calculate_mawp_from_thickness(t: float, R_or_D: float, S: float, E: float, component_type: str = "shell", head_type: Optional[str] = None) -> Dict[str, Any]:
-    """
-    Inverse of thickness formulas to compute MAWP.
-    If component_type == 'shell', use P = (SE t) / (R + 0.6 t)
-    For heads, approximate using ellipsoidal style.
-    """
-    if t <= 0:
-        raise ValueError("Thickness must be positive")
-    if R_or_D <= 0:
-        raise ValueError("R_or_D must be positive")
-    if S <= 0:
-        raise ValueError("Allowable stress must be positive")
-    if not (0 < E <= 1):
-        raise ValueError("Joint efficiency E must be in (0,1]")
+        if st.button("🚀 Run Calculation", use_container_width=True):
+            st.session_state.run_done = True
+            run_calculation = True
 
-    if component_type == "shell":
-        P = (S * E * t) / (R_or_D + 0.6 * t)
-        formula = "P = SE*t/(R + 0.6t)"
-    else:
-        # approximate head MAWP (ellipsoidal form)
-        if head_type is None:
-            head_type = "ellipsoidal"
-        if head_type == "ellipsoidal":
-            K = 1.0
-            P = (2 * S * E * t * K) / (R_or_D + 0.2 * t)
-            formula = "P = 2SEtK/(D + 0.2t)"
-        elif head_type == "hemispherical":
-            P = (2 * S * E * t) / (R_or_D + 0.4 * t)
-            formula = "P = 2SEt/(R + 0.4t)"
-        else:
-            # fallback
-            P = (2 * S * E * t) / (R_or_D + 0.2 * t)
-            formula = "P = 2SEt/(D + 0.2t)"
-
-    return {"mawp": float(P), "formula": formula}
-
-
-# ---------------------------
-# Streamlit UI
-# ---------------------------
-
-def init_session_state_defaults():
-    """Initialize session defaults for inputs."""
-    defaults = {
-        "unit_system": "USC",
-        "design_pressure": 150.0,
-        "design_temperature": 200.0,
-        "design_mdmt": -20.0,
-        "corrosion_allowance": DEFAULT_CORROSION_ALLOWANCE_IN,
-        "inside_diameter": 60.0,
-        "head_type": "ellipsoidal",
-        "joint_efficiency": 1.0,
-        "material_category": "Carbon Steel",
-        "material_grade": "SA-516-70",
-        "user_defined_allowable": 15000.0,
-        "nozzle_opening_diameter": 6.0,
-        "nozzle_wall_thickness": 0.5,
-        "use_reinforcing_pad": False,
-        "pad_thickness": 0.25,
-        "pad_width": 8.0,
-        "shell_local_extra_thickness": 0.0,
-        "weld_throat": 0.1,
-        "weld_efficiency": 0.7,
-        "calc_atm_shell": False,
-        "asme_edition": SUPPORTED_ASME_EDITIONS[0],
-    }
-    for k, v in defaults.items():
-        if k not in st.session_state:
-            st.session_state[k] = v
-
-
-def reset_session_state():
-    keys_to_remove = [
-        "last_results",
-        "warnings",
-        "errors",
-    ]
-    for k in keys_to_remove:
-        if k in st.session_state:
-            del st.session_state[k]
-    # Reset inputs to defaults
-    init_session_state_defaults()
-
-
-def run_calculations(inputs: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Orchestrate reads, computes and returns a results dict.
-    Returns also warnings and any messages.
-    """
-    # Validate key inputs
-    errors = []
-    warnings = []
-
-    unit_system = inputs["unit_system"]
-    # Material handling
-    mat_cat = inputs["material_category"]
-    mat_grade = inputs["material_grade"]
-
-    # Allowable stress S
-    if mat_cat == "User Defined":
-        S = inputs.get("user_defined_allowable")
-        if S is None or S <= 0:
-            raise ValueError("User-defined allowable stress must be a positive number")
-        mg = inputs.get("user_defined_group", "P1")
-        ce = inputs.get("user_defined_ce", 0.30)
-        is_pipe_grade = False
-    else:
-        S, wmsg = get_allowable_stress(mat_cat, mat_grade, inputs["design_temperature"], "USC" if unit_system == "USC" else "SI")
-        if wmsg:
-            warnings.append(wmsg)
-        mg = MATERIALS[mat_cat][mat_grade]["material_group"]
-        ce = MATERIALS[mat_cat][mat_grade]["carbon_equivalent"]
-        is_pipe_grade = MATERIALS[mat_cat][mat_grade].get("is_pipe_grade", False)
-
-    # Geometry conversions: unify units so functions get consistent units
-    # In this implementation we expect S and P to be in consistent units already (controller)
-    P = inputs["design_pressure"]
-    D = inputs["inside_diameter"]
-    R = D / 2.0
-    E = inputs["joint_efficiency"]
-    ca = inputs["corrosion_allowance"]
-
-    # Compute shell thicknesses
-    shell = calculate_shell_thickness(P, R, S, E)
-    shell_required = shell["required_thickness"]
-    # Add corrosion allowance to total shell thickness
-    total_shell = shell_required + ca
-
-    # Optionally compute atmospheric shell
-    atm_shell = None
-    if inputs.get("calc_atm_shell"):
-        atm_shell = {"note": "Atmospheric shell check requested: with P=0 this calculation is geometry-specific. Provide loading (wind, vacuum) for meaningful thickness check."}
-
-    # Head thickness
-    head = calculate_head_thickness(P, D, S, E, inputs["head_type"])
-    head_required = head["required_thickness"]
-    total_head = head_required + ca
-
-    # Nozzle reinforcement (improved)
-    nozzle = calculate_nozzle_reinforcement(
-        inputs["nozzle_opening_diameter"],
-        total_shell,
-        inputs["nozzle_wall_thickness"],
-        inputs["pad_thickness"] if inputs["use_reinforcing_pad"] else 0.0,
-        inputs["pad_width"] if inputs["use_reinforcing_pad"] else 0.0,
-        mat_grade if mat_cat != "User Defined" else None,
-        shell_local_extra_thickness=inputs.get("shell_local_extra_thickness", 0.0),
-        weld_throat=inputs.get("weld_throat", 0.0),
-        weld_efficiency=inputs.get("weld_efficiency", 0.7),
-    )
-
-    # For pipe grades, mention 12.5% reduction in shell effective thickness for reinforcement checks
-    if is_pipe_grade:
-        reduced_shell_effective = total_shell * (1.0 - PIPE_THICKNESS_REDUCTION)
-        warnings.append(f"Pipe grade detected; applied {PIPE_THICKNESS_REDUCTION*100:.1f}% reduction to effective shell thickness for reinforcement checks: {reduced_shell_effective:.4f}")
-    else:
-        reduced_shell_effective = total_shell
+        if st.session_state.run_done:
+            st.success("✅ Calculations completed! See results in the tabs.")
 
-    # PWHT
-    if unit_system == "SI":
-        thickness_in_in = total_shell / 25.4
-    else:
-        thickness_in_in = total_shell
-
-    pwht = determine_pwht_requirements(mg, thickness_in_in, ce)
-
-    # Impact test / MDMT
-    design_mdmt = inputs["design_mdmt"]
-    impact = determine_impact_test_requirements(mg, design_mdmt, thickness_in_in, unit_system)
-
-    # MAWPs
-    shell_mawp = calculate_mawp_from_thickness(total_shell, R, S, E, "shell")
-    head_mawp = calculate_mawp_from_thickness(total_head, D, S, E, "head", inputs["head_type"])
-    governing_mawp = min(shell_mawp["mawp"], head_mawp["mawp"])
-
-    results = {
-        "shell": shell,
-        "total_shell_thickness": total_shell,
-        "head": head,
-        "total_head_thickness": total_head,
-        "nozzle": nozzle,
-        "pwht": pwht,
-        "impact": impact,
-        "shell_mawp": shell_mawp,
-        "head_mawp": head_mawp,
-        "governing_mawp": governing_mawp,
-        "reduced_shell_effective": reduced_shell_effective,
-        "warnings": warnings,
-    }
-    return results
-
-
-# ---------------------------
-# Streamlit app layout
-# ---------------------------
-
-def main():
-    st.set_page_config(page_title="ASME Section VIII Calculator", page_icon="🔧", layout="wide")
-    init_session_state_defaults()
-
-    st.markdown("<h2 style='color:#0b5fff'>🔧 ASME Section VIII — Preliminary Calculator</h2>", unsafe_allow_html=True)
-    st.caption("This tool is for preliminary design only. Final verification must be completed by a licensed professional engineer and checked against the latest ASME code editions.")
-    st.sidebar.title("Inputs")
-
-    # Unit system
-    unit_system = st.sidebar.selectbox("Unit System", ["USC", "SI"], index=0 if st.session_state["unit_system"] == "USC" else 1)
-    st.session_state["unit_system"] = unit_system
-
-    # ASME edition placeholder
-    st.session_state["asme_edition"] = st.sidebar.selectbox("ASME Section VIII Edition", SUPPORTED_ASME_EDITIONS, index=SUPPORTED_ASME_EDITIONS.index(st.session_state.get("asme_edition", SUPPORTED_ASME_EDITIONS[0])))
-
-    # Basic design
-    pressure_label = "Design Pressure (psi)" if unit_system == "USC" else "Design Pressure (bar)"
-    temp_label = "Design Temperature (°F)" if unit_system == "USC" else "Design Temperature (°C)"
-    mdmt_label = "Design MDMT (°F)" if unit_system == "USC" else "Design MDMT (°C)"
-    length_label = "Inside Diameter (in)" if unit_system == "USC" else "Inside Diameter (mm)"
-    ca_label = "Corrosion Allowance (in)" if unit_system == "USC" else "Corrosion Allowance (mm)"
-
-    st.session_state["design_pressure"] = st.sidebar.number_input(pressure_label, value=float(st.session_state["design_pressure"]))
-    st.session_state["design_temperature"] = st.sidebar.number_input(temp_label, value=float(st.session_state["design_temperature"]))
-    st.session_state["design_mdmt"] = st.sidebar.number_input(mdmt_label, value=float(st.session_state["design_mdmt"]))
-    st.session_state["corrosion_allowance"] = st.sidebar.number_input(ca_label, value=float(st.session_state["corrosion_allowance"]))
-
-    st.sidebar.markdown("---")
-    st.session_state["inside_diameter"] = st.sidebar.number_input(length_label, value=float(st.session_state["inside_diameter"]))
-    st.session_state["head_type"] = st.sidebar.selectbox("Head Type", ["ellipsoidal", "torispherical", "hemispherical"], index=0 if st.session_state["head_type"] == "ellipsoidal" else 0)
-    # Added E = 0.7 option as requested
-    st.session_state["joint_efficiency"] = st.sidebar.selectbox("Joint Efficiency (E)", [1.0, 0.95, 0.9, 0.85, 0.7], index=[1.0,0.95,0.9,0.85,0.7].index(st.session_state.get("joint_efficiency", 1.0)))
-
-    st.sidebar.markdown("---")
-    st.session_state["material_category"] = st.sidebar.selectbox("Material Category", ["Carbon Steel", "Stainless Steel", "User Defined"], index=0)
-    # material grade selection
-    if st.session_state["material_category"] == "User Defined":
-        st.session_state["material_grade"] = st.sidebar.text_input("Material Grade (user)", value="USER-MAT")
-        st.session_state["user_defined_allowable"] = st.sidebar.number_input("User-defined allowable stress (psi or MPa)", value=float(st.session_state["user_defined_allowable"]))
-        st.session_state["user_defined_group"] = st.sidebar.selectbox("User-defined material group", ["P1", "P8"], index=0)
-        st.session_state["user_defined_ce"] = st.sidebar.number_input("User-defined carbon equivalent (if known)", value=0.30)
     else:
-        grades = list(MATERIALS[st.session_state["material_category"]].keys())
+        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
+
+            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 ---
+    with tabs[0]:
         try:
-            idx = grades.index(st.session_state["material_grade"])
-        except Exception:
-            idx = 0
-            st.session_state["material_grade"] = grades[0]
-        st.session_state["material_grade"] = st.sidebar.selectbox("Material Grade", grades, index=idx)
-
-    st.sidebar.markdown("---")
-    st.session_state["nozzle_opening_diameter"] = st.sidebar.number_input("Nozzle Opening Diameter (same unit as vessel)", value=float(st.session_state["nozzle_opening_diameter"]))
-    st.session_state["nozzle_wall_thickness"] = st.sidebar.number_input("Nozzle Wall Thickness (same unit)", value=float(st.session_state["nozzle_wall_thickness"]))
-    st.session_state["use_reinforcing_pad"] = st.sidebar.checkbox("Use Reinforcing Pad", value=st.session_state["use_reinforcing_pad"])
-    if st.session_state["use_reinforcing_pad"]:
-        st.session_state["pad_thickness"] = st.sidebar.number_input("Pad Thickness (same unit)", value=float(st.session_state["pad_thickness"]))
-        st.session_state["pad_width"] = st.sidebar.number_input("Pad Width (same unit)", value=float(st.session_state["pad_width"]))
-
-    # New inputs for improved nozzle reinforcement
-    st.sidebar.markdown("---")
-    st.session_state["shell_local_extra_thickness"] = st.sidebar.number_input("Local shell extra thickness (for reinforcement) (same unit)", value=float(st.session_state.get("shell_local_extra_thickness", 0.0)))
-    st.session_state["weld_throat"] = st.sidebar.number_input("Effective weld throat (same unit) for weld contribution", value=float(st.session_state.get("weld_throat", 0.1)))
-    st.session_state["weld_efficiency"] = st.sidebar.slider("Weld efficiency factor", min_value=0.0, max_value=1.0, value=float(st.session_state.get("weld_efficiency", 0.7)), step=0.05)
-
-    st.sidebar.markdown("---")
-    st.session_state["calc_atm_shell"] = st.sidebar.checkbox("Also calculate shell at atmospheric pressure", value=st.session_state["calc_atm_shell"])
-
-    # Buttons
-    col1, col2 = st.columns([1, 1])
-    run_calc = col1.button("Calculate")
-    reset_btn = col2.button("Reset to defaults")
-
-    if reset_btn:
-        reset_session_state()
-        st.experimental_rerun()
-
-    # Prepare inputs dict
-    inputs = {
-        "unit_system": st.session_state["unit_system"],
-        "design_pressure": float(st.session_state["design_pressure"]),
-        "design_temperature": float(st.session_state["design_temperature"]),
-        "design_mdmt": float(st.session_state["design_mdmt"]),
-        "corrosion_allowance": float(st.session_state["corrosion_allowance"]),
-        "inside_diameter": float(st.session_state["inside_diameter"]),
-        "head_type": st.session_state["head_type"],
-        "joint_efficiency": float(st.session_state["joint_efficiency"]),
-        "material_category": st.session_state["material_category"],
-        "material_grade": st.session_state["material_grade"],
-        "user_defined_allowable": float(st.session_state.get("user_defined_allowable", 0.0)),
-        "user_defined_group": st.session_state.get("user_defined_group", "P1"),
-        "user_defined_ce": float(st.session_state.get("user_defined_ce", 0.30)),
-        "nozzle_opening_diameter": float(st.session_state["nozzle_opening_diameter"]),
-        "nozzle_wall_thickness": float(st.session_state["nozzle_wall_thickness"]),
-        "use_reinforcing_pad": bool(st.session_state["use_reinforcing_pad"]),
-        "pad_thickness": float(st.session_state.get("pad_thickness", 0.0)),
-        "pad_width": float(st.session_state.get("pad_width", 0.0)),
-        "shell_local_extra_thickness": float(st.session_state.get("shell_local_extra_thickness", 0.0)),
-        "weld_throat": float(st.session_state.get("weld_throat", 0.1)),
-        "weld_efficiency": float(st.session_state.get("weld_efficiency", 0.7)),
-        "calc_atm_shell": bool(st.session_state.get("calc_atm_shell", False)),
-    }
-
-    # Run calculations only when requested
-    if run_calc:
+            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}")
+        except Exception as exc:
+            st.error(f"Error computing shell thickness: {exc}")
+
+    # --- HEAD TAB ---
+    with tabs[1]:
         try:
-            results = run_calculations(inputs)
-            st.session_state["last_results"] = results
-            st.session_state["warnings"] = results.get("warnings", [])
-            st.success("Calculations completed.")
-        except Exception as e:
-            st.session_state["errors"] = str(e)
-            st.error(f"Error during calculation: {e}")
-
-    # show warnings/errors if present
-    if "warnings" in st.session_state and st.session_state["warnings"]:
-        for w in st.session_state["warnings"]:
-            st.warning(w)
-    if "errors" in st.session_state:
-        st.error(st.session_state["errors"])
-
-    # Tabs for outputs
-    tab1, tab2, tab3, tab4, tab5 = st.tabs(["Shell", "Head", "Nozzle", "PWHT & Impact", "Summary"])
-
-    results = st.session_state.get("last_results")
-
-    with tab1:
-        st.header("Shell Thickness (UG-27)")
-        if results:
-            shell = results["shell"]
-            st.write("**Formula used:**", shell["formula_used"])
-            st.write("**Condition:**", shell["condition_check"])
-            units_len = "in" if unit_system == "USC" else "mm"
-            st.metric("Circumferential thickness", f"{format_value(shell['circumferential_thickness'], units_len, True)} {units_len}")
-            st.metric("Longitudinal thickness", f"{format_value(shell['longitudinal_thickness'], units_len, True)} {units_len}")
-            st.metric("Required thickness (governing)", f"{format_value(shell['required_thickness'], units_len, True)} {units_len}")
-            st.markdown("**Total shell thickness including corrosion allowance:**")
-            st.write(f"{format_value(results['total_shell_thickness'], units_len, True)} {units_len}")
-
-            with st.expander("Show step-by-step shell calculations"):
-                st.code(f"Inputs: P={inputs['design_pressure']}, R={inputs['inside_diameter']/2.0}, S={get_allowable_stress(inputs['material_category'], inputs['material_grade'], inputs['design_temperature'], 'USC' if unit_system=='USC' else 'SI')[0]}, E={inputs['joint_efficiency']}")
-                st.write(shell)
-        else:
-            st.info("Press **Calculate** to run shell thickness calculations.")
-
-    with tab2:
-        st.header("Head Thickness (UG-32)")
-        if results:
-            head = results["head"]
-            units_len = "in" if unit_system == "USC" else "mm"
-            st.write("**Head Type:**", head["head_type"].title())
-            st.write("**Formula used:**", head["formula_used"])
-            st.metric("Required head thickness", f"{format_value(results['head']['required_thickness'], units_len, True)} {units_len}")
-            st.write("Total head thickness including corrosion allowance:", f"{format_value(results['total_head_thickness'], units_len, True)} {units_len}")
-            with st.expander("Show step-by-step head calculations"):
-                st.write(head["intermediate_values"])
-        else:
-            st.info("Press **Calculate** to run head thickness calculations.")
-
-    with tab3:
-        st.header("Nozzle Reinforcement (UG-37 approx - improved)")
-        st.info("Provide nozzle geometry inputs below. The method is a conservative projection-area approximation; see assumptions in the result.")
-        if results:
-            nozzle = results["nozzle"]
-            units_len = "in" if unit_system == "USC" else "mm"
-            st.write("Assumptions:")
-            for a in nozzle["assumptions"]:
-                st.write("-", a)
-            st.write("Required area (A_required = d_opening * t_shell):", f"{format_value(nozzle['area_required'], units_len)} {units_len}^2")
-            st.write("Shell local contribution (A_shell_local):", f"{format_value(nozzle['area_shell_local'], units_len)} {units_len}^2")
-            st.write("Nozzle contribution (A_nozzle = pi*d*t_nozzle):", f"{format_value(nozzle['area_nozzle'], units_len)} {units_len}^2")
-            st.write("Pad contribution (A_pad):", f"{format_value(nozzle['area_pad'], units_len)} {units_len}^2")
-            st.write("Weld contribution (A_weld):", f"{format_value(nozzle['area_weld'], units_len)} {units_len}^2")
-            st.write("Total available area:", f"{format_value(nozzle['area_available_total'], units_len)} {units_len}^2")
-            if nozzle["reinforcement_adequate"]:
-                st.success(f"Reinforcement adequate (SF = {nozzle['safety_factor']:.2f})")
-            else:
-                st.error(f"Reinforcement inadequate (SF = {nozzle['safety_factor']:.2f})")
-            with st.expander("Show step-by-step nozzle calculation (raw values)"):
-                st.write(nozzle)
-        else:
-            st.info("Enter inputs and press **Calculate** to run nozzle reinforcement check.")
-
-    with tab4:
-        st.header("PWHT & Impact Test")
-        if results:
-            pwht = results["pwht"]
-            impact = results["impact"]
-
-            st.subheader("PWHT")
-            if pwht["pwht_required"]:
-                st.error("PWHT REQUIRED")
-            else:
-                st.success("PWHT not required by preliminary check")
-            st.write("Reasons:")
-            for r in pwht["reasons"]:
-                st.write("-", r)
-            if pwht["temperature_range"]:
-                st.write("Suggested PWHT temperature range:", pwht["temperature_range"])
-                st.write("Suggested hold time:", pwht["hold_time"])
-
-            st.subheader("Impact Test (MDMT check)")
-            rated = impact["rated_mdmt"]
-            design = impact["design_mdmt"]
-            if unit_system == "SI":
-                st.write("Rated MDMT (°C):", f"{format_value(rated, 'C')} °C")
-                st.write("Design MDMT (°C):", f"{format_value(design, 'C')} °C")
+            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}")
+        except Exception as exc:
+            st.error(f"Error computing head thickness: {exc}")
+
+    # --- NOZZLE TAB ---
+    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.")
+        except Exception as exc:
+            st.error(f"Error computing nozzle reinforcement: {exc}")
+
+    # --- PWHT TAB ---
+    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.write("Rated MDMT (°F):", f"{format_value(rated, 'F')} °F")
-                st.write("Design MDMT (°F):", f"{format_value(design, 'F')} °F")
+                st.caption(f"Threshold used: {mpato_psi(0):.4f} (converted threshold from 38 mm).")
+        except Exception as exc:
+            st.error(f"Error computing PWHT requirement: {exc}")
 
-            if impact["impact_test_required"]:
-                st.error("Impact test required — Charpy V-notch")
-                st.write("Suggested test temperature:", f"{impact['test_temperature']:.1f} {'°C' if unit_system=='SI' else '°F'}")
-            else:
-                st.success("Impact test not required by preliminary check")
-            st.write("Notes:", impact["notes"])
-            with st.expander("Show step-by-step MDMT logic and notes"):
-                st.write(impact)
-        else:
-            st.info("Press **Calculate** to run PWHT and impact checks.")
-
-    with tab5:
-        st.header("Summary")
-        if results:
-            # Build DataFrame summary
-            data = {
-                "Parameter": [
-                    "Design Pressure",
-                    "Design Temperature",
-                    "Design MDMT",
-                    "Inside Diameter",
-                    "Material",
-                    "Allowable Stress",
-                    "Joint Efficiency",
-                    "Corrosion Allowance",
-                    "Shell Required Thickness",
-                    "Shell Total Thickness",
-                    "Head Required Thickness",
-                    "Head Total Thickness",
-                    "Governing MAWP",
-                ],
-                "Value": []
+    # --- IMPACT TEST TAB ---
+    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.")
+        except Exception as exc:
+            st.error(f"Error computing impact test requirement: {exc}")
+
+    # --- SUMMARY TAB ---
+    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)",
             }
-            # allowable stress fetch (again) but safe
-            if inputs["material_category"] == "User Defined":
-                allowable = inputs["user_defined_allowable"]
-            else:
-                allowable, _ = get_allowable_stress(inputs["material_category"], inputs["material_grade"], inputs["design_temperature"], "USC" if unit_system == "USC" else "SI")
-            units_len = "in" if unit_system == "USC" else "mm"
-            units_pres = "psi" if unit_system == "USC" else "MPa"
-            data["Value"] = [
-                f"{inputs['design_pressure']} {'psi' if unit_system=='USC' else 'bar'}",
-                f"{inputs['design_temperature']} {'°F' if unit_system=='USC' else '°C'}",
-                f"{inputs['design_mdmt']} {'°F' if unit_system=='USC' else '°C'}",
-                f"{inputs['inside_diameter']} {units_len}",
-                f"{inputs['material_grade']}",
-                f"{format_value(allowable, units_pres)} {units_pres}",
-                f"{inputs['joint_efficiency']}",
-                f"{inputs['corrosion_allowance']} {units_len}",
-                f"{format_value(results['shell']['required_thickness'], units_len, True)} {units_len}",
-                f"{format_value(results['total_shell_thickness'], units_len, True)} {units_len}",
-                f"{format_value(results['head']['required_thickness'], units_len, True)} {units_len}",
-                f"{format_value(results['total_head_thickness'], units_len, True)} {units_len}",
-                f"{format_value(results['governing_mawp'], 'psi' if unit_system=='USC' else 'bar')} {'psi' if unit_system=='USC' else 'bar'}",
-            ]
-            df = pd.DataFrame(data)
-            st.dataframe(df, use_container_width=True)
-            st.write("Report generated:", datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
-
-            # Exports
-            csv = df.to_csv(index=False).encode("utf-8")
-            st.download_button("Download Summary CSV", csv, file_name="asme_summary.csv", mime="text/csv")
-
-            # PDF export (optional)
-            try:
-                from reportlab.lib.pagesizes import letter
-                from reportlab.pdfgen import canvas
-                # create PDF in-memory
-                from io import BytesIO
-                buffer = BytesIO()
-                c = canvas.Canvas(buffer, pagesize=letter)
-                c.setFont("Helvetica", 12)
-                c.drawString(30, 750, "ASME Section VIII — Preliminary Summary Report")
-                y = 730
-                for i, (param, val) in df.iterrows():
-                    c.drawString(30, y, f"{val['Parameter']}: {val['Value']}")
-                    y -= 15
-                    if y < 50:
-                        c.showPage()
-                        y = 750
-                c.drawString(30, y - 20, f"Generated: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-                c.save()
-                pdf_data = buffer.getvalue()
-                buffer.close()
-                st.download_button("Download Summary PDF", pdf_data, file_name="asme_summary.pdf", mime="application/pdf")
-            except Exception:
-                st.info("PDF export requires optional package 'reportlab'. Install to enable PDF export.")
-
+            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")
+        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(
+                            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)
+                    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.")
         else:
-            st.info("Press **Calculate** to produce a summary.")
-
-    # Footer / disclaimer
-    st.markdown("---")
-    st.caption("Disclaimer: This app provides preliminary calculations only. Verify final design with a licensed professional engineer and use the latest ASME code edition.")
-
-if __name__ == "__main__":
-    main()
+            st.info("ℹ️ Add your GROQ_API_KEY in Hugging Face secrets to enable AI 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"
+    ]):
+        with tabs[i]:
+            st.info(f"Run calculation to see {msg}.")