Create app.py

app.py

@@ -0,0 +1,431 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from datetime import datetime
+import math
+
+# ---------------------------
+# Streamlit ASME VIII App
+# Cleaned, self-contained, ready for deployment to Hugging Face Spaces
+# Requirements: streamlit, pandas, numpy, plotly
+# ---------------------------
+
+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,
+)
+
+# ---------------------------
+# Material database (compact)
+# ---------------------------
+MATERIALS = {
+    "Carbon Steel": {
+        "SA-516 Grade 60": {
+            "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},
+            },
+            "carbon_equivalent": 0.30,
+            "material_group": "P1",
+        },
+        "SA-516 Grade 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},
+            },
+            "carbon_equivalent": 0.31,
+            "material_group": "P1",
+        },
+    },
+    "Stainless Steel": {
+        "SA-240 Type 304": {
+            "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},
+            },
+            "carbon_equivalent": 0.08,
+            "material_group": "P8",
+        },
+        "SA-240 Type 316": {
+            "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},
+            },
+            "carbon_equivalent": 0.08,
+            "material_group": "P8",
+        },
+    },
+}
+
+# ---------------------------
+# Helper functions
+# ---------------------------
+
+def get_allowable_stress(material_category, material_grade, temperature, units):
+    """Interpolate allowable stress table for the selected unit system."""
+    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):
+    if from_unit == to_unit:
+        return temp
+    if from_unit == "C" and to_unit == "F":
+        return (temp * 9.0 / 5.0) + 32.0
+    if from_unit == "F" and to_unit == "C":
+        return (temp - 32.0) * 5.0 / 9.0
+    return temp
+
+
+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)
+        formula_used = "t = PR/(SE - 0.6P)"
+        condition = f"P ≤ 0.385SE: {P:.3f} ≤ {0.385 * S * E:.3f}"
+    else:
+        t_circum = (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}"
+
+    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"
+
+    return {
+        "circumferential_thickness": float(t_circum),
+        "longitudinal_thickness": float(t_long),
+        "required_thickness": float(t_required),
+        "governing_case": governing,
+        "formula_used": formula_used,
+        "condition_check": condition,
+        "asme_clause": "UG-27",
+    }
+
+
+def calculate_head_thickness(P, D, S, E, head_type="ellipsoidal"):
+    """UG-32 head thickness (basic implementations). D is inside diameter."""
+    if head_type == "ellipsoidal":
+        K = 1.0
+        t = (P * D * K) / (2 * S * E - 0.2 * P)
+        clause = "UG-32(d), Appendix 1-4(c)"
+        formula = "t = PDK/(2SE - 0.2P)"
+    elif head_type == "torispherical":
+        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)
+        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)
+        clause = "UG-32(f), Appendix 1-4(e)"
+        formula = "t = PL/(2SE - 0.2P)"
+    else:
+        raise ValueError("Unsupported head type")
+
+    return {"required_thickness": float(t), "head_type": head_type, "formula_used": formula, "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)
+    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
+
+    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",
+    }
+
+
+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"]
+
+    pwht_required = False
+    reasons = []
+    temp_range = ""
+    hold_time = ""
+
+    if mg == "P1":
+        if thickness_inch > 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:
+            pwht_required = True
+            reasons.append("Carbon equivalent > 0.35% (UCS-56)")
+    elif mg == "P8":
+        reasons.append("Stainless steel: PWHT generally not required (consult spec)")
+
+    if not pwht_required:
+        reasons.append("Below thickness and CE limits")
+
+    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)."""
+    if units == "SI":
+        design_temp_f = convert_temperature(design_temp, "C", "F")
+        thickness_inch = thickness_in / 25.4
+    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]
+
+    impact_required = design_temp_f < ex_temp
+    test_temp = design_temp_f - 30
+
+    return {
+        "impact_test_required": impact_required,
+        "design_temperature_f": design_temp_f,
+        "exemption_temperature_f": ex_temp,
+        "test_temperature_f": test_temp,
+    }
+
+
+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."""
+    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)"
+    else:
+        # approximate head MAWP using ellipsoidal/hemispherical style
+        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:
+            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 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"
+    else:
+        pressure_unit = "bar"
+        length_unit = "mm"
+        temp_unit = "°C"
+        stress_unit = "MPa"
+
+    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"]) 
+
+    # Derived
+    inside_radius = inside_diameter / 2.0
+    allowable_stress = get_allowable_stress(mat_cat, mat_grade, design_temperature, unit_system)
+
+    tab1, tab2, tab3, tab4, tab5 = st.tabs(["Shell", "Head", "Nozzle", "PWHT", "Summary"])
+
+    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}")
+
+    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}")
+
+    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})")
+        else:
+            st.error(f"Reinforcement inadequate (SF={nozzle_res['safety_factor']:.2f})")
+
+    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.write("Reasons:")
+            for r in pwht['reasons']:
+                st.write(f"- {r}")
+            st.write("Temperature range:", pwht['temperature_range'])
+        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")
+
+    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"))
+
+
+if __name__ == "__main__":
+    main()