Update app.py

app.py

@@ -1,129 +1,286 @@
-import streamlit as st
-import pandas as pd
-import numpy as np
-import plotly.graph_objects as go
-from datetime import datetime
+#!/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)
+- Simplified UG-37-style nozzle reinforcement area method (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)
+"""
+
+from __future__ import annotations
+from typing import Dict, Any, Optional, Tuple
 import math
+import datetime
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+# Module metadata
+__version__ = "0.1.0"
 
 # ---------------------------
-# Streamlit ASME VIII App
-# Cleaned, self-contained, ready for deployment to Hugging Face Spaces
-# Requirements: streamlit, pandas, numpy, plotly
+# 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", "custom"]
 
-st.set_page_config(
-    page_title="ASME Section VIII Calculator",
-    page_icon="🔧",
-    layout="wide",
-    initial_sidebar_state="expanded",
-)
-
-# --- Simple styling ---
-st.markdown(
-    """
-<style>
-    .main-header { font-size: 2.2rem; font-weight: 700; color: #0b5fff; }
-    .calc-section { background-color: #f8f9fa; padding: 0.8rem; border-radius: 8px; }
-    .result-box { background-color: #e8f5e8; padding: 0.8rem; border-radius: 8px; }
-    .warning-box { background-color: #fff3cd; padding: 0.8rem; border-radius: 8px; }
-    @media (max-width: 768px) { .main-header { font-size: 1.6rem; } }
-</style>
-""",
-    unsafe_allow_html=True,
-)
+# Units formatting
+INCH_DECIMALS = 4
+MM_DECIMALS = 2
 
 # ---------------------------
-# Material database (compact)
+# 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 = {
+
+MATERIALS: Dict[str, Dict[str, Dict[str, Any]]] = {
     "Carbon Steel": {
-        "SA-516 Grade 60": {
+        "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: 15000, 100: 15000, 200: 15000, 300: 15000, 400: 15000, 500: 14750, 600: 14200, 650: 13100},
-                "SI": {-29: 103, 38: 103, 93: 103, 149: 103, 204: 103, 260: 102, 316: 98, 343: 90},
+                "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 Grade 70": {
+        "SA-516-70": {
             "allowable_stress": {
-                "USC": {-20: 17500, 100: 17500, 200: 17500, 300: 17500, 400: 17500, 500: 17200, 600: 16550, 650: 15300},
-                "SI": {-29: 121, 38: 121, 93: 121, 149: 121, 204: 121, 260: 119, 316: 114, 343: 105},
+                "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": {
-        "SA-240 Type 304": {
+        # 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: 18800, 100: 18800, 200: 16200, 300: 15100, 400: 14200, 500: 13500, 600: 12800, 700: 12100},
-                "SI": {-29: 130, 38: 130, 93: 112, 149: 104, 204: 98, 260: 93, 316: 88, 371: 83},
+                "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-240 Type 316": {
+        "SA-312-316L": {
             "allowable_stress": {
-                "USC": {-20: 18800, 100: 18800, 200: 16600, 300: 15600, 400: 14800, 500: 14200, 600: 13600, 700: 13000},
-                "SI": {-29: 130, 38: 130, 93: 114, 149: 107, 204: 102, 260: 98, 316: 94, 371: 90},
+                "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 get_allowable_stress(material_category, material_grade, temperature, units):
-    """Interpolate allowable stress table for the selected unit system."""
+
+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:
-        stress_data = MATERIALS[material_category][material_grade]["allowable_stress"][units]
-        temps = sorted(stress_data.keys())
-        stresses = [stress_data[t] for t in temps]
-        if temperature <= temps[0]:
-            return stresses[0]
-        if temperature >= temps[-1]:
-            return stresses[-1]
-        return float(np.interp(temperature, temps, stresses))
-    except Exception:
-        # Fallback safe value
-        return 15000.0 if units == "USC" else 103.0
-
-
-def convert_temperature(temp, from_unit, to_unit):
+        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 temp
-    if from_unit == "C" and to_unit == "F":
-        return (temp * 9.0 / 5.0) + 32.0
+        return value
     if from_unit == "F" and to_unit == "C":
-        return (temp - 32.0) * 5.0 / 9.0
-    return temp
+        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 calculate_shell_thickness(P, R, S, E):
-    """UG-27 shell thickness. P = design pressure, R = inside radius, S = allowable stress, E = joint eff."""
-    # Use the UG-27 circumferential and longitudinal formulas
-    if P <= 0.385 * S * E:
-        t_circum = (P * R) / (S * E - 0.6 * P)
+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")
+    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} ≤ {0.385 * S * E:.3f}"
+        condition = f"P ≤ 0.385SE: {P:.3f} ≤ {cond_val:.3f}"
     else:
-        t_circum = (P * R) / (S * E + 0.4 * P)
+        t_circ = (P * R) / (S * E + 0.4 * P)
         formula_used = "t = PR/(SE + 0.4P)"
-        condition = f"P > 0.385SE: {P:.3f} > {0.385 * S * E:.3f}"
+        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)
-    t_required = max(t_circum, t_long)
-    governing = "Circumferential" if t_circum >= t_long else "Longitudinal"
+
+    required = max(t_circ, t_long)
+    governing = "Circumferential" if t_circ >= t_long else "Longitudinal"
 
     return {
-        "circumferential_thickness": float(t_circum),
+        "circumferential_thickness": float(t_circ),
         "longitudinal_thickness": float(t_long),
-        "required_thickness": float(t_required),
+        "required_thickness": float(required),
         "governing_case": governing,
         "formula_used": formula_used,
         "condition_check": condition,
@@ -131,139 +288,239 @@ def calculate_shell_thickness(P, R, S, E):
     }
 
 
-def calculate_head_thickness(P, D, S, E, head_type="ellipsoidal"):
-    """UG-32 head thickness (basic implementations). D is inside diameter."""
+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
+        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)"
-        formula = "t = PDK/(2SE - 0.2P)"
     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)"
-        formula = f"t = PLM/(2SE - 0.2P), M={M:.3f}"
     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)"
-        formula = "t = PL/(2SE - 0.2P)"
     else:
-        raise ValueError("Unsupported head type")
+        raise ValueError(f"Unsupported head type '{head_type}'")
 
-    return {"required_thickness": float(t), "head_type": head_type, "formula_used": formula, "asme_clause": clause}
+    return {
+        "required_thickness": float(t),
+        "head_type": head_type,
+        "formula_used": formula,
+        "intermediate_values": inter,
+        "asme_clause": clause,
+    }
 
 
-def calculate_nozzle_reinforcement(d, t_shell, t_nozzle, t_pad, pad_width):
-    """Very conservative, simplified area method for nozzle reinforcement (UG-37 family).
-    d should be the nozzle inside diameter (or opening) — units must be consistent with thickness."""
-    A_required = d * t_shell
-    # conservative shell area (A1) assumed zero if no excess thickness
-    A_shell = 0.0
-    # nozzle area contribution (A2) approximate
-    height_limit = min(2.5 * t_shell, 2.5 * t_nozzle)
+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) -> Dict[str, Any]:
+    """
+    Simplified UG-37 area method approximation.
+    - A_required = d_opening * t_shell_required
+    - A_nozzle approximated as t_nozzle * height (height approximated)
+    - A_pad = t_pad * pad_width
+    - A_shell conservative assumed zero (unless pad provides)
+    ASSUMPTION: This is conservative and simplified; real UG-37 includes integration over reinforcement area and weld contributions.
+    """
+    if d_opening <= 0 or t_shell_required <= 0 or t_nozzle <= 0:
+        raise ValueError("Nozzle dimensions must be positive")
+
+    A_required = d_opening * t_shell_required
+
+    # Approximate nozzle contribution: height limited to 2.5 * smaller thickness
+    height_limit = min(2.5 * t_shell_required, 2.5 * t_nozzle)
     A_nozzle = t_nozzle * height_limit
-    # pad area contribution
-    A_pad = t_pad * pad_width if t_pad > 0 and pad_width > 0 else 0.0
-    A_welds = 0.0
-    A_available = A_shell + A_nozzle + A_pad + A_welds
+
+    # Pad contribution
+    A_pad = t_pad * pad_width if (t_pad and pad_width) else 0.0
+
+    # Shell area conservative: we count none (ASSUMPTION: conservative)
+    A_shell = 0.0
+
+    # Apply pipe grade thickness reduction for nozzle if material_grade indicates pipe
+    reduction_info = ""
+    if material_grade:
+        # find if given material is in data and pipe grade
+        for cat in MATERIALS:
+            mg = MATERIALS[cat].get(material_grade)
+            if mg:
+                if mg.get("is_pipe_grade"):
+                    # reduce nozzle effective thickness for reinforcement calc
+                    effective_nozzle_t = t_nozzle * (1.0 - PIPE_THICKNESS_REDUCTION)
+                    # recalc A_nozzle conservatively with reduced t
+                    height_limit2 = min(2.5 * t_shell_required, 2.5 * effective_nozzle_t)
+                    A_nozzle = effective_nozzle_t * height_limit2
+                    reduction_info = f"Applied {PIPE_THICKNESS_REDUCTION*100:.1f}% pipe thickness reduction to nozzle (effective nozzle thickness = {effective_nozzle_t:.4f})."
+                break
+
+    A_available = A_shell + A_nozzle + A_pad
+    adequate = A_available >= A_required
+    safety_factor = (A_available / A_required) if A_required > 0 else float("inf")
+
+    assumptions = [
+        "A_shell conservative assumed zero (no excess shell area counted).",
+        "Nozzle area approximated with a limited height = min(2.5*t_shell, 2.5*t_nozzle).",
+        "Pad area = pad_thickness * pad_width (rectangular assumption).",
+        "Real UG-37 requires geometric reinforcement calculations; this is a simplified conservative estimate.",
+    ]
+    if reduction_info:
+        assumptions.append(reduction_info)
 
     return {
         "area_required": float(A_required),
         "area_shell": float(A_shell),
         "area_nozzle": float(A_nozzle),
         "area_pad": float(A_pad),
-        "area_welds": float(A_welds),
         "area_available_total": float(A_available),
-        "reinforcement_adequate": A_available >= A_required,
-        "safety_factor": float(A_available / A_required) if A_required > 0 else 0.0,
-        "asme_clause": "UG-37 through UG-45",
+        "reinforcement_adequate": bool(adequate),
+        "safety_factor": float(safety_factor),
+        "assumptions": assumptions,
+        "asme_clause": "UG-37 (approx)",
     }
 
 
-def determine_pwht_requirements(material_category, material_grade, thickness_in, units):
-    """Very simplified PWHT decision logic based on UCS-56 guidance."""
-    if units == "SI":
-        thickness_inch = thickness_in / 25.4
-    else:
-        thickness_inch = thickness_in
-
-    info = MATERIALS[material_category][material_grade]
-    mg = info["material_group"]
-    ce = info["carbon_equivalent"]
+def determine_pwht_requirements(material_group: str, thickness_in_in: float, carbon_equivalent: float) -> Dict[str, Any]:
+    """
+    Very simplified PWHT logic following UCS-56 style rules:
+    - ASSUMPTION: PWHT recommended if thickness > 1.25 in for P1 group or CE > 0.35
+    """
+    if thickness_in_in < 0:
+        raise ValueError("Thickness must be non-negative")
 
     pwht_required = False
     reasons = []
     temp_range = ""
     hold_time = ""
 
-    if mg == "P1":
-        if thickness_inch > 1.25:
+    if material_group == "P1":
+        if thickness_in_in > 1.25:
             pwht_required = True
-            reasons.append("Thickness > 1.25 inches (UCS-56)")
-            temp_range = "1100°F - 1200°F" if units == "USC" else "593°C - 649°C"
-            hold_time = f"Minimum {max(1, thickness_inch):.1f} hours"
-        if ce > 0.35:
+            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 mg == "P8":
-        reasons.append("Stainless steel: PWHT generally not required (consult spec)")
+            reasons.append("Carbon equivalent > 0.35% (UCS-56).")
+    elif material_group == "P8":
+        reasons.append("Stainless steel (P8): PWHT generally not required; follow spec.")
+    else:
+        reasons.append("Material group unknown: consult specification.")
 
     if not pwht_required:
-        reasons.append("Below thickness and CE limits")
+        reasons.append("Below thickness/CE limits for mandatory PWHT (preliminary check).")
 
     return {"pwht_required": pwht_required, "reasons": reasons, "temperature_range": temp_range, "hold_time": hold_time}
 
 
-def determine_impact_test_requirements(material_category, material_grade, design_temp, thickness_in, units):
-    """Very simplified impact test exemption logic (UCS-66 style)."""
+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:
+    - For P1 (carbon): thicker -> higher (warmer) rated MDMT threshold (conservative)
+    - For P8 (stainless): very low rated MDMT (stainless generally exempt)
+    Returns MDMT in °F.
+    """
+    if material_group == "P8":
+        return -325.0  # effectively exempt in many cases (very low)
+    # P1 conservative regression-like mapping (values illustrative)
+    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]:
+    """
+    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.
+    """
+    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_temp_f = convert_temperature(design_temp, "C", "F")
-        thickness_inch = thickness_in / 25.4
+        design_mdmt_f = convert_temp(design_mdmt, "C", "F")
     else:
-        design_temp_f = design_temp
-        thickness_inch = thickness_in
-
-    info = MATERIALS[material_category][material_grade]
-    mg = info["material_group"]
-
-    exemption_map_P1 = {0.5: 60, 1.0: 30, 2.0: 0, 4.0: -20}
-    exemption_map_P8 = {0.5: -325, 1.0: -325, 2.0: -325, 4.0: -325}
-
-    if mg == "P1":
-        xs = sorted(exemption_map_P1.keys())
-        ys = [exemption_map_P1[x] for x in xs]
-        if thickness_inch <= xs[0]:
-            ex_temp = ys[0]
-        elif thickness_inch >= xs[-1]:
-            ex_temp = ys[-1]
-        else:
-            ex_temp = float(np.interp(thickness_inch, xs, ys))
-    else:
-        ex_temp = exemption_map_P8[0.5]
+        design_mdmt_f = design_mdmt
 
-    impact_required = design_temp_f < ex_temp
-    test_temp = design_temp_f - 30
+    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")
+    else:
+        test_temp = design_mdmt_f - 30.0
 
     return {
-        "impact_test_required": impact_required,
-        "design_temperature_f": design_temp_f,
-        "exemption_temperature_f": ex_temp,
-        "test_temperature_f": test_temp,
+        "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.",
     }
 
 
-def calculate_mawp(t, R_or_D, S, E, component_type="shell", head_type="ellipsoidal"):
-    """Calculate MAWP from thickness (t), geometry and allowable stress S.
-    For shell: R_or_D is inside radius; for head we accept D for formulas used earlier."""
+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 component_type == "shell":
-        # P = SE t / (R + 0.6 t)
         P = (S * E * t) / (R_or_D + 0.6 * t)
-        formula = "P = SEt/(R + 0.6t)"
+        formula = "P = SE*t/(R + 0.6t)"
     else:
-        # approximate head MAWP using ellipsoidal/hemispherical style
+        # 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)
@@ -272,6 +529,7 @@ def calculate_mawp(t, R_or_D, S, E, component_type="shell", head_type="ellipsoid
             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)"
 
@@ -282,150 +540,450 @@ def calculate_mawp(t, R_or_D, S, E, component_type="shell", head_type="ellipsoid
 # Streamlit UI
 # ---------------------------
 
-def main():
-    st.markdown('<div class="main-header">🔧 ASME Section VIII Pressure Vessel Calculator</div>', unsafe_allow_html=True)
-
-    # Sidebar
-    st.sidebar.title("Input Parameters")
-    units = st.sidebar.selectbox("Unit System", ["USC", "SI"], index=0)
-    unit_system = "USC" if units == "USC" else "SI"
-
-    if unit_system == "USC":
-        pressure_unit = "psi"
-        length_unit = "in"
-        temp_unit = "°F"
-        stress_unit = "psi"
+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,
+        "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"):
+        # For atmospheric only, P = 0 -> thickness tends to 0. Use minimal thickness assumption.
+        # ASSUMPTION: Provide thickness for vacuum containment? Here we just return a message.
+        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
+    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,
+    )
+
+    # 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:
-        pressure_unit = "bar"
-        length_unit = "mm"
-        temp_unit = "°C"
-        stress_unit = "MPa"
+        reduced_shell_effective = total_shell
+
+    # PWHT
+    # thickness for pwht in inches: if units SI, convert mm to inches (we assume inside_diameter units but thickness returned in same length units)
+    # ASSUMPTION: inputs thickness are in inches when unit_system == USC, mm when SI. For PWHT we need inches.
+    if unit_system == "SI":
+        # convert mm to inches: assume thickness in mm -> mm / 25.4
+        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
 
-    st.sidebar.subheader("Design Conditions")
-    design_pressure = st.sidebar.number_input(f"Design Pressure ({pressure_unit})", value=150.0)
-    design_temperature = st.sidebar.number_input(f"Design Temperature ({temp_unit})", value=200.0)
-    corrosion_allowance = st.sidebar.number_input(f"Corrosion Allowance ({length_unit})", value=0.125)
 
-    st.sidebar.subheader("Material & Geometry")
-    mat_cat = st.sidebar.selectbox("Material Category", list(MATERIALS.keys()))
-    mat_grade = st.sidebar.selectbox("Material Grade", list(MATERIALS[mat_cat].keys()))
-    joint_eff = st.sidebar.selectbox("Joint Efficiency (E)", [1.0, 0.95, 0.9, 0.85], index=0)
-    inside_diameter = st.sidebar.number_input(f"Inside Diameter ({length_unit})", value=60.0)
-    head_type = st.sidebar.selectbox("Head Type", ["ellipsoidal", "torispherical", "hemispherical"]) 
+# ---------------------------
+# Streamlit app layout
+# ---------------------------
 
-    # Derived
-    inside_radius = inside_diameter / 2.0
-    allowable_stress = get_allowable_stress(mat_cat, mat_grade, design_temperature, unit_system)
+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=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)
+    st.session_state["joint_efficiency"] = st.sidebar.selectbox("Joint Efficiency (E)", [1.0, 0.95, 0.9, 0.85], index=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())
+        # select current grade if available
+        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"]))
+
+    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)),
+        "calc_atm_shell": bool(st.session_state.get("calc_atm_shell", False)),
+    }
 
-    tab1, tab2, tab3, tab4, tab5 = st.tabs(["Shell", "Head", "Nozzle", "PWHT", "Summary"])
+    # Run calculations only when requested
+    if run_calc:
+        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)")
-        shell = calculate_shell_thickness(design_pressure, inside_radius, allowable_stress, joint_eff)
-        st.write("**Formula used:**", shell["formula_used"])
-        st.write("**Condition:**", shell["condition_check"])
-        st.write("Circumferential thickness:", f"{shell['circumferential_thickness']:.4f} {length_unit}")
-        st.write("Longitudinal thickness:", f"{shell['longitudinal_thickness']:.4f} {length_unit}")
-        st.write("Required thickness:", f"{shell['required_thickness']:.4f} {length_unit}")
+        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']}")
+                # Show computed values numerically
+                st.write(shell)
+        else:
+            st.info("Press **Calculate** to run shell thickness calculations.")
 
     with tab2:
         st.header("Head Thickness (UG-32)")
-        head = calculate_head_thickness(design_pressure, inside_diameter, allowable_stress, joint_eff, head_type)
-        st.write("**Head Type:**", head["head_type"].title())
-        st.write("**Formula used:**", head["formula_used"])
-        st.write("Required thickness:", f"{head['required_thickness']:.4f} {length_unit}")
+        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)")
-        nozzle_d = st.number_input("Nozzle Opening Diameter (same unit as vessel)", value=6.0)
-        nozzle_t = st.number_input("Nozzle Wall Thickness", value=0.5)
-        use_pad = st.checkbox("Use Reinforcing Pad")
-        pad_t = pad_w = 0.0
-        if use_pad:
-            pad_t = st.number_input("Pad Thickness", value=0.25)
-            pad_w = st.number_input("Pad Width", value=8.0)
-
-        shell_total_thickness = shell['required_thickness'] + corrosion_allowance
-        nozzle_res = calculate_nozzle_reinforcement(nozzle_d, shell_total_thickness, nozzle_t, pad_t, pad_w)
-        st.write("Required area:", f"{nozzle_res['area_required']:.4f} {length_unit}^2")
-        st.write("Available area:", f"{nozzle_res['area_available_total']:.4f} {length_unit}^2")
-        if nozzle_res['reinforcement_adequate']:
-            st.success(f"Reinforcement adequate (SF={nozzle_res['safety_factor']:.2f})")
+        st.header("Nozzle Reinforcement (UG-37 approx)")
+        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:", f"{format_value(nozzle['area_required'], units_len)} {units_len}^2")
+            st.write("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"):
+                st.write(nozzle)
         else:
-            st.error(f"Reinforcement inadequate (SF={nozzle_res['safety_factor']:.2f})")
+            st.info("Press **Calculate** to run nozzle reinforcement calculations.")
 
     with tab4:
-        st.header("PWHT & Impact")
-        total_thick = shell['required_thickness'] + corrosion_allowance
-        pwht = determine_pwht_requirements(mat_cat, mat_grade, total_thick, unit_system)
-        impact = determine_impact_test_requirements(mat_cat, mat_grade, design_temperature, total_thick, unit_system)
-
-        st.subheader("PWHT")
-        if pwht['pwht_required']:
-            st.error("PWHT REQUIRED")
+        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(f"- {r}")
-            st.write("Temperature range:", pwht['temperature_range'])
+            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)")
+            # show rated and design MDMT
+            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")
+            else:
+                st.write("Rated MDMT (°F):", f"{format_value(rated, 'F')} °F")
+                st.write("Design MDMT (°F):", f"{format_value(design, 'F')} °F")
+
+            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.success("PWHT not required")
-
-        st.subheader("Impact Test")
-        st.write("Design temperature (°F):", f"{impact['design_temperature_f']:.1f}")
-        st.write("Exemption temperature (°F):", f"{impact['exemption_temperature_f']:.1f}")
-        if impact['impact_test_required']:
-            st.error("Impact test required — Charpy V-notch")
-            st.write("Test temp (°F):", f"{impact['test_temperature_f']:.1f}")
-        else:
-            st.success("Impact test not required")
+            st.info("Press **Calculate** to run PWHT and impact checks.")
 
     with tab5:
-        st.header("Summary Report")
-        total_shell = shell['required_thickness'] + corrosion_allowance
-        total_head = head['required_thickness'] + corrosion_allowance
-
-        shell_mawp = calculate_mawp(total_shell, inside_radius, allowable_stress, joint_eff, "shell")
-        head_mawp = calculate_mawp(total_head, inside_diameter, allowable_stress, joint_eff, "head", head_type)
-        governing_mawp = min(shell_mawp['mawp'], head_mawp['mawp'])
-
-        st.metric("Governing MAWP", f"{governing_mawp:.2f} {pressure_unit}")
-        st.write("Shell MAWP:", f"{shell_mawp['mawp']:.2f} {pressure_unit}")
-        st.write("Head MAWP:", f"{head_mawp['mawp']:.2f} {pressure_unit}")
-
-        df = pd.DataFrame({
-            "Parameter": [
-                "Design Pressure",
-                "Design Temperature",
-                "Inside Diameter",
-                "Material",
-                "Allowable Stress",
-                "Joint Efficiency",
-                "Corrosion Allowance",
-                "Shell Required Thickness",
-                "Shell Total Thickness",
-                "Head Required Thickness",
-                "Head Total Thickness",
-            ],
-            "Value": [
-                f"{design_pressure} {pressure_unit}",
-                f"{design_temperature} {temp_unit}",
-                f"{inside_diameter} {length_unit}",
-                f"{mat_grade}",
-                f"{allowable_stress:.0f} {stress_unit}",
-                str(joint_eff),
-                f"{corrosion_allowance} {length_unit}",
-                f"{shell['required_thickness']:.4f} {length_unit}",
-                f"{total_shell:.4f} {length_unit}",
-                f"{head['required_thickness']:.4f} {length_unit}",
-                f"{total_head:.4f} {length_unit}",
-            ],
-        })
-
-        st.dataframe(df, use_container_width=True)
-        st.markdown("---")
-        st.caption("Note: This tool is for preliminary design only. Final calculations must be verified by a licensed engineer and checked against the latest ASME code editions.")
-        st.write("Report generated:", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+        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": []
+            }
+            # 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.")
+
+        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()