Update app.py

app.py

@@ -2,42 +2,32 @@
 """
 ASME Section VIII — Preliminary Pressure Vessel Calculator (Streamlit)
 
-This version:
-- Makes PDF export optional and robust (sanitizes and wraps text, avoids unbreakable lines).
-- Guards against PDF runtime errors and returns None if PDF can't be built.
-- Single Run Calculation button; unit system (SI/USC) support.
-- Simplified calculations for preliminary checks only. Verify with licensed engineer.
+- PDF export removed to avoid runtime font/encoding/width issues.
+- CSV export remains.
+- Optional Groq AI explanation is still available if 'groq' is installed and GROQ_API_KEY is set.
+- Single Run Calculation button; Reset; SI/USC support; joint efficiency includes 0.7.
+- Simplified, preliminary checks only. Verify with a licensed engineer.
 """
 
 from __future__ import annotations
 import os
 import math
 import datetime
-import unicodedata
-import textwrap
 from typing import Dict, Any, Optional
 
 import streamlit as st
 import pandas as pd
 import numpy as np
 
-# Optional Groq AI client
+# Optional Groq AI client (guarded)
 try:
     from groq import Groq
 except Exception:
     Groq = None
 
-# Optional fpdf2 PDF generator
-try:
-    from fpdf import FPDF
-    FPDF_AVAILABLE = True
-except Exception:
-    FPDF = None
-    FPDF_AVAILABLE = False
-
-# ----------------------
-# Page config + header
-# ----------------------
+# -----------------------------
+# Page config and header
+# -----------------------------
 st.set_page_config(page_title="ASME Section VIII Calculator", page_icon="🔧", layout="wide")
 st.title("🔧 ASME Section VIII — Preliminary Calculator")
 st.caption(
@@ -45,9 +35,9 @@ st.caption(
     "and checked against the latest ASME code editions."
 )
 
-# ----------------------
-# Unit conversions & constants
-# ----------------------
+# -----------------------------
+# Unit conversion helpers & constants
+# -----------------------------
 MPA_TO_PSI = 145.037737797
 PSI_TO_MPA = 1.0 / MPA_TO_PSI
 MM_TO_IN = 0.03937007874015748
@@ -65,23 +55,30 @@ def mm_to_in(x: float) -> float:
 def in_to_mm(x: float) -> float:
     return float(x) * IN_TO_MM
 
-# ----------------------
-# Calculation helpers (simplified, preliminary)
-# ----------------------
-def shell_thickness(P: float, R: float, S: float, E: float, corrosion: float) -> float:
-    """Simplified UG-27-like circumferential thickness (user-supplied consistent units)."""
+# -----------------------------
+# Calculation helpers (pure functions)
+# -----------------------------
+def calculate_shell_thickness(P: float, R: float, S: float, E: float, corrosion: float) -> float:
+    """
+    Simplified UG-27 circumferential thickness formula (preliminary).
+    Inputs must use consistent units (user-selected system).
+    Returns thickness including corrosion allowance.
+    """
     if E <= 0 or E > 1:
         raise ValueError("Joint efficiency E must be in (0,1].")
     if S <= 0:
         raise ValueError("Allowable stress must be positive.")
     denom = S * E - 0.6 * P
     if denom <= 0:
-        raise ValueError("Invalid combination: denominator (S*E - 0.6*P) <= 0. Check pressure / S / E.")
+        raise ValueError("Invalid combination: denominator (S*E - 0.6*P) <= 0. Check inputs.")
     t = (P * R) / denom
     return float(t + corrosion)
 
-def head_thickness(P: float, R: float, S: float, E: float, corrosion: float, head_type: str) -> float:
-    """Simplified head thickness formulas; returns thickness including corrosion allowance."""
+def calculate_head_thickness(P: float, R: float, S: float, E: float, corrosion: float, head_type: str) -> float:
+    """
+    Simplified UG-32 style head thickness formulas (preliminary).
+    head_type: 'Ellipsoidal', 'Torispherical', 'Hemispherical'
+    """
     if E <= 0 or E > 1:
         raise ValueError("Joint efficiency E must be in (0,1].")
     if head_type == "Ellipsoidal":
@@ -107,38 +104,38 @@ def head_thickness(P: float, R: float, S: float, E: float, corrosion: float, hea
         raise ValueError("Unsupported head type.")
     return float(t + corrosion)
 
-def nozzle_reinforcement_simple(P: float, d: float, t_shell: float, t_nozzle: float, S: float, E: float) -> Dict[str, Any]:
+def nozzle_reinforcement_check(P: float, d_opening: float, t_shell: float, t_nozzle: float, S: float, E: float) -> Dict[str, Any]:
     """
     Conservative simplified nozzle reinforcement check:
       lhs = (P * d) / (2 * S * E)
       rhs = t_shell + t_nozzle
-    Returns diagnostic dict.
+    Returns diagnostic dict {lhs, rhs, adequate}.
     """
-    if any(val <= 0 for val in (d, S, E)):
+    if any(val <= 0 for val in (d_opening, S, E)):
         raise ValueError("Nozzle diameter, allowable stress and joint efficiency must be positive.")
-    lhs = (P * d) / (2.0 * S * E)
+    lhs = (P * d_opening) / (2.0 * S * E)
     rhs = (t_shell + t_nozzle)
     adequate = lhs <= rhs
     return {"lhs": float(lhs), "rhs": float(rhs), "adequate": bool(adequate)}
 
-def pwht_required(thickness: float, unit_system: str = "SI") -> bool:
-    """Very simplified PWHT rule: SI threshold 38 mm; USC equivalent converted."""
+def pwht_decision(thickness: float, unit_system: str = "SI") -> bool:
+    """Very simplified PWHT rule (preliminary)."""
     if unit_system == "SI":
-        return thickness > 38.0
+        return thickness > 38.0  # mm
     else:
-        return thickness > mm_to_in(38.0)
+        return thickness > mm_to_in(38.0)  # in
 
-def impact_test_required(thickness: float, design_mdmt: float, unit_system: str = "SI") -> Dict[str, Any]:
+def impact_test_decision(thickness: float, design_mdmt: float, unit_system: str = "SI") -> Dict[str, Any]:
     """
-    Simplified MDMT approximation. This is NOT UCS-66 — it's a placeholder for preliminary checks.
-    Returns dict with impact_required boolean and suggested test temp.
+    Simplified MDMT/impact test check (placeholder).
+    This is NOT a replacement for UCS-66. It's for preliminary checks only.
     """
     if unit_system == "SI":
-        rated_mdmt = -29.0  # °C approx placeholder
+        rated_mdmt = -29.0  # °C placeholder
         thickness_threshold = 12.0  # mm
         suggested_test_temp = design_mdmt - 17.0  # °C
     else:
-        rated_mdmt = -20.0  # °F approx placeholder
+        rated_mdmt = -20.0  # °F placeholder
         thickness_threshold = mm_to_in(12.0)  # in
         suggested_test_temp = design_mdmt - 30.0  # °F
     impact_required = (design_mdmt > rated_mdmt) and (thickness > thickness_threshold)
@@ -147,255 +144,154 @@ def impact_test_required(thickness: float, design_mdmt: float, unit_system: str
         "rated_mdmt": rated_mdmt,
         "threshold_thickness": thickness_threshold,
         "suggested_test_temp": suggested_test_temp,
-        "note": "APPROXIMATION: use UCS-66 tables for exact rated MDMT decisions.",
+        "note": "APPROXIMATION — use UCS-66 for final decisions.",
     }
 
-# ----------------------
-# PDF helper: sanitize & wrap text to avoid fpdf glyph / width issues
-# ----------------------
-def _sanitize_for_pdf(s: str) -> str:
-    """Make a string safe for Latin-1 PDF fonts: replace common unicode and normalize."""
-    if s is None:
-        return ""
-    if not isinstance(s, str):
-        s = str(s)
-    # Replace characters known to break basic PDF fonts
-    s = s.replace("—", "-").replace("–", "-")
-    s = s.replace("“", "\"").replace("”", "\"").replace("‘", "'").replace("’", "'")
-    # Normalize
-    s = unicodedata.normalize("NFKD", s)
-    # Encode to latin-1 and replace unrepresentable characters
-    s = s.encode("latin-1", "replace").decode("latin-1")
-    # Collapse very long unbroken sequences by inserting spaces every 120 chars
-    if len(s) > 120 and " " not in s:
-        # insert spaces to allow wrapping
-        parts = [s[i:i+100] for i in range(0, len(s), 100)]
-        s = " ".join(parts)
-    return s
-
-def generate_pdf_bytes_from_dict(info: Dict[str, Any]) -> Optional[bytes]:
-    """
-    Build a PDF bytes object from a dict in a safe way.
-    Returns bytes when successful, otherwise None.
-    """
-    if not FPDF_AVAILABLE:
-        return None
-
-    try:
-        pdf = FPDF(unit="mm", format="letter")
-        pdf.set_auto_page_break(auto=True, margin=15)
-        pdf.add_page()
-        # Title
-        pdf.set_font("Helvetica", "B", 14)
-        title = _sanitize_for_pdf("ASME Section VIII - Summary Report")
-        pdf.cell(0, 10, title, ln=True, align="C")
-        pdf.ln(4)
-        pdf.set_font("Helvetica", size=11)
-
-        # For each key/value, sanitize and wrap to safe width using textwrap
-        for k, v in info.items():
-            line = f"{k}: {v}"
-            safe = _sanitize_for_pdf(line)
-            # Wrap to roughly 90 characters per line (safe for letter-size with standard margins)
-            wrapped = textwrap.wrap(safe, width=90)
-            if not wrapped:
-                wrapped = [""]
-            for wl in wrapped:
-                # Avoid empty-line multi_cell issues by writing at least a space
-                try:
-                    pdf.multi_cell(0, 7, wl if wl.strip() != "" else " ")
-                except Exception:
-                    # If writing fails for some line, attempt to write a truncated version
-                    trunc = wl[:250]
-                    try:
-                        pdf.multi_cell(0, 7, trunc if trunc.strip() != "" else " ")
-                    except Exception:
-                        # Give up on PDF generation safely
-                        return None
-
-        # Add generated timestamp
-        pdf.ln(3)
-        try:
-            pdf.set_font("Helvetica", size=9)
-            gen_line = _sanitize_for_pdf(f"Generated: {datetime.datetime.now().isoformat()}")
-            pdf.multi_cell(0, 6, gen_line)
-        except Exception:
-            pass
-
-        pdf_bytes = pdf.output(dest="S")
-        # fpdf2 may return str — convert to bytes
-        if isinstance(pdf_bytes, str):
-            pdf_bytes = pdf_bytes.encode("latin-1", errors="replace")
-        return pdf_bytes
-
-    except Exception:
-        return None
-
-# ----------------------
-# App state defaults
-# ----------------------
+# -----------------------------
+# Session defaults & sidebar UI
+# -----------------------------
 if "run_done" not in st.session_state:
     st.session_state.run_done = False
 
-# ----------------------
-# Sidebar: inputs
-# ----------------------
 with st.sidebar.expander("Inputs", expanded=True):
     unit_system_choice = st.selectbox("Unit System", ["SI (MPa / mm / °C)", "USC (psi / in / °F)"])
     use_si = unit_system_choice.startswith("SI")
 
     st.markdown("---")
     if use_si:
-        P = st.number_input("Design Pressure (MPa)", value=2.0, format="%.3f")
-        inside_d = st.number_input("Inside Diameter (mm)", value=1500.0, format="%.1f")
-        R = inside_d / 2.0
-        S = st.number_input("Allowable Stress (MPa)", value=120.0, format="%.2f")
-        corrosion = st.number_input("Corrosion Allowance (mm)", value=1.5, format="%.2f")
+        design_pressure = st.number_input("Design Pressure (MPa)", value=2.0, format="%.3f")
+        inside_diameter = st.number_input("Inside Diameter (mm)", value=1500.0, format="%.1f")
+        R = inside_diameter / 2.0
+        allowable_stress = st.number_input("Allowable Stress (MPa)", value=120.0, format="%.2f")
+        corrosion_allowance = st.number_input("Corrosion Allowance (mm)", value=1.5, format="%.2f")
         design_mdmt = st.number_input("Design MDMT (°C)", value=-20.0)
     else:
-        P = st.number_input("Design Pressure (psi)", value=mpa_to_psi(2.0), format="%.1f")
-        inside_d = st.number_input("Inside Diameter (in)", value=mm_to_in(1500.0), format="%.3f")
-        R = inside_d / 2.0
-        S = st.number_input("Allowable Stress (psi)", value=mpa_to_psi(120.0), format="%.1f")
-        corrosion = st.number_input("Corrosion Allowance (in)", value=mm_to_in(1.5), format="%.4f")
+        design_pressure = st.number_input("Design Pressure (psi)", value=mpa_to_psi(2.0), format="%.1f")
+        inside_diameter = st.number_input("Inside Diameter (in)", value=mm_to_in(1500.0), format="%.3f")
+        R = inside_diameter / 2.0
+        allowable_stress = st.number_input("Allowable Stress (psi)", value=mpa_to_psi(120.0), format="%.1f")
+        corrosion_allowance = st.number_input("Corrosion Allowance (in)", value=mm_to_in(1.5), format="%.4f")
         design_mdmt = st.number_input("Design MDMT (°F)", value=-20.0)
 
     st.markdown("---")
     head_type = st.selectbox("Head Type", ["Ellipsoidal", "Torispherical", "Hemispherical"])
-    E = st.selectbox("Joint Efficiency (E)", [1.0, 0.95, 0.9, 0.85, 0.7], index=0)
+    joint_eff = st.selectbox("Joint Efficiency (E)", [1.0, 0.95, 0.9, 0.85, 0.7], index=0)
 
     st.markdown("---")
+    # Nozzle inputs (requesting the required inputs)
     if use_si:
-        d_nozzle = st.number_input("Nozzle Opening Diameter (mm)", value=200.0, format="%.1f")
-        t_shell_provided = st.number_input("Shell thickness available (mm)", value=12.0, format="%.2f")
-        t_nozzle = st.number_input("Nozzle thickness (mm)", value=10.0, format="%.2f")
+        nozzle_opening_diameter = st.number_input("Nozzle Opening Diameter (mm)", value=200.0, format="%.1f")
+        nozzle_wall_thickness = st.number_input("Nozzle Wall Thickness (mm)", value=10.0, format="%.2f")
+        shell_thickness_available = st.number_input("Shell thickness available (mm)", value=12.0, format="%.2f")
     else:
-        d_nozzle = st.number_input("Nozzle Opening Diameter (in)", value=mm_to_in(200.0), format="%.3f")
-        t_shell_provided = st.number_input("Shell thickness available (in)", value=mm_to_in(12.0), format="%.4f")
-        t_nozzle = st.number_input("Nozzle thickness (in)", value=mm_to_in(10.0), format="%.4f")
+        nozzle_opening_diameter = st.number_input("Nozzle Opening Diameter (in)", value=mm_to_in(200.0), format="%.3f")
+        nozzle_wall_thickness = st.number_input("Nozzle Wall Thickness (in)", value=mm_to_in(10.0), format="%.4f")
+        shell_thickness_available = st.number_input("Shell thickness available (in)", value=mm_to_in(12.0), format="%.4f")
 
     st.markdown("---")
-    run_now = st.button("Run Calculation", help="Click to run calculations now")
-    if st.button("Reset"):
+    # Single run and reset
+    run_calc = st.button("Run Calculation")
+    reset = st.button("Reset to defaults")
+    if reset:
+        # quick reset: clear session and reload page
         st.session_state.run_done = False
         st.experimental_rerun()
 
-if 'run_now' in locals() and run_now:
+if run_calc:
     st.session_state.run_done = True
 
-# ----------------------
-# Tabs
-# ----------------------
+# -----------------------------
+# Tabs and results
+# -----------------------------
 groq_key = os.getenv("GROQ_API_KEY")
 ai_enabled = (Groq is not None and bool(groq_key))
-tab_labels = ["Shell", "Head", "Nozzle", "PWHT", "Impact Test", "Summary"] + (["AI Explanation"] if ai_enabled else [])
-tabs = st.tabs(tab_labels)
+tab_list = ["Shell", "Head", "Nozzle", "PWHT & Impact", "Summary"] + (["AI Explanation"] if ai_enabled else [])
+tabs = st.tabs(tab_list)
 
-# ----------------------
-# Run calculations when requested
-# ----------------------
 if st.session_state.run_done:
-    # Shell
+    # Shell tab
     with tabs[0]:
         try:
-            t_shell = shell_thickness(P, R, S, E, corrosion)
-            unit_thk = "mm" if use_si else "in"
-            st.metric("Required shell thickness (including corrosion)", f"{t_shell:.4f} {unit_thk}")
-            st.write("Inputs:", {"P": P, "R": R, "S": S, "E": E, "corrosion": corrosion})
+            shell_res = calculate_shell_thickness(design_pressure, R, allowable_stress, joint_eff, corrosion_allowance)
+            units_len = "mm" if use_si else "in"
+            st.metric("Required Shell Thickness (incl. corrosion)", f"{shell_res:.4f} {units_len}")
+            st.write("Inputs:", {"P": design_pressure, "R": R, "S": allowable_stress, "E": joint_eff})
         except Exception as exc:
-            st.error(f"Error computing shell thickness: {exc}")
+            st.error(f"Shell calculation error: {exc}")
 
-    # Head
+    # Head tab
     with tabs[1]:
         try:
-            t_head = head_thickness(P, R, S, E, corrosion, head_type)
-            unit_thk = "mm" if use_si else "in"
-            st.metric(f"Required {head_type} head thickness (including corrosion)", f"{t_head:.4f} {unit_thk}")
-            st.write("Inputs:", {"P": P, "D (approx)": 2.0 * R, "S": S, "E": E})
+            head_res = calculate_head_thickness(design_pressure, R, allowable_stress, joint_eff, corrosion_allowance, head_type)
+            units_len = "mm" if use_si else "in"
+            st.metric(f"Required {head_type} Head Thickness (incl. corrosion)", f"{head_res:.4f} {units_len}")
+            st.write("Intermediate values: D ≈", 2.0 * R)
         except Exception as exc:
-            st.error(f"Error computing head thickness: {exc}")
+            st.error(f"Head calculation error: {exc}")
 
-    # Nozzle
+    # Nozzle tab
     with tabs[2]:
         try:
-            nozzle_res = nozzle_reinforcement_simple(P, d_nozzle, t_shell_provided, t_nozzle, S, E)
-            st.write("Conservative nozzle reinforcement check (lhs <= rhs):")
-            st.write(f"LHS = (P * d) / (2SE) = {nozzle_res['lhs']:.4g}")
-            st.write(f"RHS = t_shell + t_nozzle = {nozzle_res['rhs']:.4g}")
-            if nozzle_res['adequate']:
+            nozzle_check = nozzle_reinforcement_check(design_pressure, nozzle_opening_diameter, shell_thickness_available, nozzle_wall_thickness, allowable_stress, joint_eff)
+            st.write("Nozzle reinforcement conservative check:")
+            st.write(f"LHS = (P * d) / (2SE) = {nozzle_check['lhs']:.6g}")
+            st.write(f"RHS = t_shell + t_nozzle = {nozzle_check['rhs']:.6g}")
+            if nozzle_check["adequate"]:
                 st.success("Conservative nozzle reinforcement check PASSED")
             else:
                 st.error("Conservative nozzle reinforcement check FAILED")
-            st.caption("Note: This is a conservative/simple check; for full ASME UG-37 use the projection-area method.")
+            st.caption("This is a simplified, conservative approximation of UG-37. Use full UG-37 projection-area method for final design.")
         except Exception as exc:
-            st.error(f"Error computing nozzle reinforcement: {exc}")
+            st.error(f"Nozzle calculation error: {exc}")
 
-    # PWHT
+    # PWHT & Impact tab
     with tabs[3]:
         try:
-            check_thickness = t_shell if "t_shell" in locals() else t_shell_provided
-            pwht = pwht_required(check_thickness, unit_system="SI" if use_si else "USC")
-            st.write("PWHT required (preliminary):", "YES" if pwht else "NO")
-            st.caption("This is a simplified check; consult UCS-56 and your material spec for final decision.")
-        except Exception as exc:
-            st.error(f"Error computing PWHT requirement: {exc}")
-
-    # Impact Test
-    with tabs[4]:
-        try:
-            check_thickness = t_shell if "t_shell" in locals() else t_shell_provided
-            impact_info = impact_test_required(check_thickness, design_mdmt, unit_system="SI" if use_si else "USC")
-            st.write("Impact test required (preliminary):", "YES" if impact_info["impact_required"] else "NO")
+            thickness_for_checks = shell_res if "shell_res" in locals() else shell_thickness_available
+            pwht_flag = pwht_decision(thickness_for_checks, unit_system="SI" if use_si else "USC")
+            impact_info = impact_test_decision(thickness_for_checks, design_mdmt, unit_system="SI" if use_si else "USC")
+            st.subheader("PWHT (Preliminary)")
+            st.write("PWHT required:", "YES" if pwht_flag else "NO")
+            st.subheader("Impact Test (MDMT) - Preliminary")
+            st.write("Impact test required:", "YES" if impact_info["impact_required"] else "NO")
             st.write("Rated MDMT used (approx):", impact_info["rated_mdmt"])
             st.write("Suggested test temperature (approx):", impact_info["suggested_test_temp"])
             st.caption(impact_info["note"])
         except Exception as exc:
-            st.error(f"Error computing impact test requirement: {exc}")
+            st.error(f"PWHT/Impact calculation error: {exc}")
 
-    # Summary + exports
-    with tabs[5]:
+    # Summary tab
+    with tabs[4]:
         try:
             summary = {
-                "unit_system": "SI (MPa/mm/°C)" if use_si else "USC (psi/in/°F)",
-                "design_pressure": P,
-                "inside_diameter": inside_d,
-                "shell_thickness": t_shell if "t_shell" in locals() else None,
-                "head_thickness": t_head if "t_head" in locals() else None,
-                "nozzle_check_passed": nozzle_res["adequate"] if "nozzle_res" in locals() else None,
-                "pwht_required": pwht if "pwht" in locals() else None,
-                "impact_test_required": impact_info["impact_required"] if "impact_info" in locals() else None,
-                "generated": datetime.datetime.now().isoformat(),
+                "Unit System": "SI (MPa/mm/°C)" if use_si else "USC (psi/in/°F)",
+                "Design Pressure": design_pressure,
+                "Inside Diameter": inside_diameter,
+                "Shell Required Thickness": shell_res if "shell_res" in locals() else None,
+                "Head Required Thickness": head_res if "head_res" in locals() else None,
+                "Nozzle Check Passed": nozzle_check["adequate"] if "nozzle_check" in locals() else None,
+                "PWHT Required": pwht_flag if "pwht_flag" in locals() else None,
+                "Impact Test Required": impact_info["impact_required"] if "impact_info" in locals() else None,
+                "Generated": datetime.datetime.now().isoformat(),
             }
-            df_sum = pd.DataFrame([summary])
-            st.dataframe(df_sum, use_container_width=True)
-
-            # CSV
-            csv = df_sum.to_csv(index=False).encode("utf-8")
-            st.download_button("Download CSV", csv, file_name="asme_summary.csv", mime="text/csv")
-
-            # PDF (optional, robust)
-            if FPDF_AVAILABLE:
-                pdf_bytes = generate_pdf_bytes_from_dict(summary)
-                if pdf_bytes:
-                    st.download_button("Download PDF", pdf_bytes, file_name="asme_summary.pdf", mime="application/pdf")
-                else:
-                    st.info("PDF generation failed (safe fallback). If you need PDF, check fpdf2 installation or try again.")
-            else:
-                st.info("PDF export disabled — install 'fpdf2' to enable PDF export.")
+            df_summary = pd.DataFrame([summary])
+            st.dataframe(df_summary, use_container_width=True)
 
+            csv_bytes = df_summary.to_csv(index=False).encode("utf-8")
+            st.download_button("Download Summary CSV", csv_bytes, file_name="asme_summary.csv", mime="text/csv")
         except Exception as exc:
-            st.error(f"Error building summary/export: {exc}")
+            st.error(f"Summary building error: {exc}")
 
-    # AI Explanation tab (optional)
+    # AI Explanation (optional)
     if ai_enabled:
         with tabs[-1]:
             groq_key = os.getenv("GROQ_API_KEY")
             if Groq is not None and groq_key:
-                try:
-                    groq_client = Groq(api_key=groq_key)
-                    if st.button("Generate AI Explanation"):
-                        with st.spinner("Generating explanation..."):
-                            prompt = f"Explain these ASME results simply: {summary}"
+                groq_client = Groq(api_key=groq_key)
+                if st.button("Generate AI Explanation"):
+                    with st.spinner("Asking AI..."):
+                        prompt = f"Explain these preliminary ASME vessel results simply: {summary}"
+                        try:
                             resp = groq_client.chat.completions.create(
                                 messages=[{"role": "user", "content": prompt}],
                                 model="llama-3.1-8b-instant",
@@ -403,13 +299,13 @@ if st.session_state.run_done:
                             explanation = resp.choices[0].message.content
                             st.markdown("**AI Explanation**")
                             st.write(explanation)
-                except Exception:
-                    st.info("Groq AI not available or request failed. Ensure GROQ_API_KEY is set and 'groq' package is installed.")
+                        except Exception as e:
+                            st.error(f"AI request failed: {e}")
             else:
-                st.info("Groq AI not configured. Add GROQ_API_KEY to environment/secrets to enable optional AI explanations.")
+                st.info("Groq AI not available. Add GROQ_API_KEY and install 'groq' to enable.")
 
 else:
-    # placeholders
-    for i in range(len(tab_labels) if 'tab_labels' in locals() else 6):
+    # tabs placeholders
+    for i, lbl in enumerate(tab_list):
         with tabs[i]:
-            st.info("Enter inputs in the sidebar and click 'Run Calculation' to execute.")
+            st.info("Set inputs in the sidebar and click 'Run Calculation' to execute.")