Update app.py

app.py

@@ -2,19 +2,15 @@
 Tubesheet Thickness Calculator — ASME (with optional TEMA mode)
 Single-file Streamlit app.
 
-Features:
- - Shows allowable stress in the same units selected (MPa for SI, psi for Imperial).
- - Sketch draws the actual tube centers inside the tubesheet circle using the chosen pitch and layout (square/triangular).
- - Option for tube-side passes (affects reporting only — user should input appropriate tube-side pressure per pass if needed).
- - Calculation follows ASME-style flat-plate bending approximation; TEMA option available as illustrative.
- - BWG selection and manual thickness entry retained.
- - Minimum manufacturing thickness removed per request.
-
-Notes:
- - Bundled material allowable stresses are illustrative. Verify with ASME Section II for production.
- - TEMA uses illustrative modifiers — consult TEMA documentation for strict compliance.
+Improvements:
+ - Fixed minor bugs and syntax errors.
+ - Added additional layout options and improved schematic export safety.
+ - Shows allowable stress in selected units.
+ - Uses pitch/layout to place real tube centers (limited to user N_tubes).
+ - TEMA mode is illustrative only — verify before use.
+
 Author: ChatGPT
-Updated: 2025-09-07
+Updated: 2025-09-07 (fixed & cleaned)
 """
 
 import streamlit as st
@@ -29,8 +25,8 @@ st.set_page_config(page_title="Tubesheet Thickness Calculator", layout="wide")
 st.title("Tubesheet Thickness Calculator — ASME VIII-1 (Preliminary)")
 
 # -----------------------
-# Bundled (example) material table (sample values)
-# NOTE: illustrative only — replace with ASME Section II data for production
+# Material table (example values only — replace with ASME Section II verified data)
+# -----------------------
 MATERIAL_LOOKUP = {
     "SA-516 Gr 70": [
         {"temperature_C": 20,  "allowable_MPa": 138},
@@ -67,93 +63,56 @@ MATERIAL_LOOKUP = {
 # -----------------------
 # Helper functions
 # -----------------------
-def mpato_psi(mpa):  # 1 MPa = 145.0377377 psi
-    return mpa * 145.0377377
-
-def psito_mpa(psi):  # psi to MPa
-    return psi / 145.0377377
-
-def bartompa(bar):  # 1 bar = 0.1 MPa
-    return bar * 0.1
-
-def mpatobar(mpa):
-    return mpa / 0.1
-
-def inchtomm(val_in):
-    return val_in * 25.4
-
-def mmtoinch(val_mm):
-    return val_mm / 25.4
-
-def round_up_standard_mm(val_mm):
-    # round up to nearest 1 mm
-    return math.ceil(val_mm)
-
+def mpato_psi(mpa): return mpa * 145.0377377
+def psito_mpa(psi): return psi / 145.0377377
+def bartompa(bar): return bar * 0.1
+def mpatobar(mpa): return mpa / 0.1
+def inchtomm(val_in): return val_in * 25.4
+def mmtoinch(val_mm): return val_mm / 25.4
+
+def round_up_standard_mm(val_mm): return math.ceil(val_mm)
 def round_up_standard_in(val_in):
-    # round up to nearest 1/16 in
     sixteenth = 1.0 / 16.0
-    n = math.ceil(val_in / sixteenth)
-    return n * sixteenth
+    return math.ceil(val_in / sixteenth) * sixteenth
 
 def interpolate_allowable(material, temp_C):
-    """
-    Interpolate allowable stress from bundled table (MPa vs temp_C).
-    If material not in table -> return None.
-    """
     if material not in MATERIAL_LOOKUP:
         return None
-    table = MATERIAL_LOOKUP[material]
-    table_sorted = sorted(table, key=lambda x: x["temperature_C"])
-    temps = [r["temperature_C"] for r in table_sorted]
-    svals = [r["allowable_MPa"] for r in table_sorted]
+    table = sorted(MATERIAL_LOOKUP[material], key=lambda x: x["temperature_C"])
+    temps = [r["temperature_C"] for r in table]
+    svals = [r["allowable_MPa"] for r in table]
     if temp_C <= temps[0]:
         return svals[0]
     if temp_C >= temps[-1]:
         return svals[-1]
-    # linear interp
     for i in range(len(temps)-1):
         if temps[i] <= temp_C <= temps[i+1]:
-            t0, t1 = temps[i], temps[i+1]
-            s0, s1 = svals[i], svals[i+1]
-            frac = (temp_C - t0) / (t1 - t0)
-            return s0 + frac * (s1 - s0)
+            t0, t1, s0, s1 = temps[i], temps[i+1], svals[i], svals[i+1]
+            return s0 + (s1 - s0) * (temp_C - t0) / (t1 - t0)
     return None
 
 # -----------------------
-# BWG table (typical reference values in inches)
+# BWG thickness table (inches)
+# -----------------------
 BWG_TO_INCH = {
-    "BWG 7":   0.180,
-    "BWG 8":   0.165,
-    "BWG 9":   0.148,
-    "BWG 10":  0.134,
-    "BWG 11":  0.120,
-    "BWG 12":  0.109,
-    "BWG 13":  0.095,
-    "BWG 14":  0.083,
-    "BWG 15":  0.072,
-    "BWG 16":  0.065,
-    "BWG 17":  0.058,
-    "BWG 18":  0.049,
-    "BWG 19":  0.042,
-    "BWG 20":  0.035,
-    "BWG 21":  0.032,
-    "BWG 22":  0.028,
-    "BWG 23":  0.025,
-    "BWG 24":  0.023,
-    "BWG 25":  0.020,
-    "BWG 26":  0.018,
-    "BWG 27":  0.016,
-    "BWG 28":  0.014,
+    "BWG 7": 0.180, "BWG 8": 0.165, "BWG 9": 0.148, "BWG 10": 0.134,
+    "BWG 11": 0.120, "BWG 12": 0.109, "BWG 13": 0.095, "BWG 14": 0.083,
+    "BWG 15": 0.072, "BWG 16": 0.065, "BWG 17": 0.058, "BWG 18": 0.049,
+    "BWG 19": 0.042, "BWG 20": 0.035, "BWG 21": 0.032, "BWG 22": 0.028,
+    "BWG 23": 0.025, "BWG 24": 0.023, "BWG 25": 0.020, "BWG 26": 0.018,
+    "BWG 27": 0.016, "BWG 28": 0.014,
 }
 
 # -----------------------
-# Sidebar — Inputs
+# Sidebar Inputs
+# -----------------------
 with st.sidebar:
     st.header("Inputs")
     project_name = st.text_input("Project name", value="Tubesheet Calculation")
     designer_name = st.text_input("Designer", value="")
-    units = st.selectbox("Units system", options=["SI (mm, bar, °C)", "Imperial (in, psi, °F)"])
+    units = st.selectbox("Units system", ["SI (mm, bar, °C)", "Imperial (in, psi, °F)"])
     use_SI = units.startswith("SI")
+
     if use_SI:
         u_len = "mm"
         u_press = "bar"
@@ -196,11 +155,13 @@ with st.sidebar:
         tube_od_step = 1.0 / 64.0
         tube_od_format = "%.6f"
 
-    OD_tube = st.number_input(f"Tube outside diameter ({u_len})",
-                              min_value=tube_od_min,
-                              value=tube_od_default,
-                              step=tube_od_step,
-                              format=tube_od_format)
+    OD_tube = st.number_input(
+        f"Tube outside diameter ({u_len})",
+        min_value=tube_od_min,
+        value=tube_od_default,
+        step=tube_od_step,
+        format=tube_od_format
+    )
 
     # --- Tube wall thickness input mode: BWG or manual ---
     st.markdown("**Tube wall thickness input**")
@@ -221,29 +182,42 @@ with st.sidebar:
         if use_SI:
             t_tube_min = 0.1
             t_tube_default = 1.0
-            t_tube = st.number_input(f"Tube wall thickness ({u_len})",
-                                      min_value=t_tube_min,
-                                      value=t_tube_default,
-                                      step=0.01,
-                                      format="%.3f")
+            t_tube = st.number_input(
+                f"Tube wall thickness ({u_len})",
+                min_value=t_tube_min,
+                value=t_tube_default,
+                step=0.01,
+                format="%.3f"
+            )
         else:
             t_tube_min = 1.0 / 128.0
             t_tube_default = 0.035
-            t_tube = st.number_input(f"Tube wall thickness ({u_len})",
-                                      min_value=t_tube_min,
-                                      value=t_tube_default,
-                                      step=1.0/128.0,
-                                      format="%.6f")
-
-    layout = st.selectbox("Tube pitch layout", options=["Triangular", "Square"])
+            t_tube = st.number_input(
+                f"Tube wall thickness ({u_len})",
+                min_value=t_tube_min,
+                value=t_tube_default,
+                step=1.0/128.0,
+                format="%.6f"
+            )
+
+    # New: more layout options
+    layout = st.selectbox("Tube pitch layout", options=[
+        "Triangular (hex-packed)",
+        "Square (inline)",
+        "Rotated Square (45°)",
+        "Hexagonal grid",
+        "Concentric rings"
+    ])
 
     # default pitch based on OD_tube; user can edit
     default_pitch = (OD_tube * 1.25) if (OD_tube is not None) else (25.4 * 1.25 if use_SI else 1.0 * 1.25)
-    pitch = st.number_input(f"Tube pitch ({u_len})",
-                             min_value=max(OD_tube * 1.0, tube_od_min),
-                             value=default_pitch,
-                             step=tube_od_step,
-                             format=tube_od_format)
+    pitch = st.number_input(
+        f"Tube pitch ({u_len})",
+        min_value=max(OD_tube * 1.0, tube_od_min),
+        value=default_pitch,
+        step=tube_od_step,
+        format=tube_od_format
+    )
 
     st.subheader("Pressure & Temperature")
     if use_SI:
@@ -284,7 +258,6 @@ with st.sidebar:
         st.write("No auto-lookup available for selected material & temperature in bundled table.")
 
     S_override = st.checkbox("Manual override allowable stress")
-    # prepare both vars so later code can rely on them
     S_allowable_manual = None
     S_allowable_manual_psi = None
     if S_override:
@@ -316,21 +289,20 @@ with st.sidebar:
     compute = st.button("Compute")
 
 # -----------------------
-# Helper: generate tube grid (square or triangular) inside a circle
-def generate_tube_centers(radius_mm, pitch_mm, layout="Triangular", tube_OD_mm=0.0, max_count=None):
-    """
-    radius_mm: circle radius
-    pitch_mm: center-to-center pitch
-    layout: 'Triangular' or 'Square'
-    tube_OD_mm: used to ensure tube edges don't cross the circle (center must be <= radius - tube_OD/2)
-    returns: list of (x_mm, y_mm)
-    """
+# Helper: generate tube grids with more layout options
+# -----------------------
+def rotate_points(points, angle_rad):
+    c = math.cos(angle_rad)
+    s = math.sin(angle_rad)
+    return [(c*x - s*y, s*x + c*y) for (x, y) in points]
+
+def generate_tube_centers(radius_mm, pitch_mm, layout="Triangular (hex-packed)", tube_OD_mm=0.0, max_count=None):
     centers = []
     R = radius_mm
-    if pitch_mm <= 0:
+    if pitch_mm <= 0 or R <= 0:
         return centers
 
-    if layout == "Square":
+    if layout == "Square (inline)":
         xs = np.arange(-R, R + 1e-8, pitch_mm)
         ys = np.arange(-R, R + 1e-8, pitch_mm)
         for x in xs:
@@ -339,29 +311,27 @@ def generate_tube_centers(radius_mm, pitch_mm, layout="Triangular", tube_OD_mm=0
                     centers.append((x, y))
                     if max_count and len(centers) >= max_count:
                         return centers
-    else:
+
+    elif layout == "Rotated Square (45°)":
+        xs = np.arange(-R * math.sqrt(2), R * math.sqrt(2) + 1e-8, pitch_mm)
+        ys = np.arange(-R * math.sqrt(2), R * math.sqrt(2) + 1e-8, pitch_mm)
+        temp = []
+        for x in xs:
+            for y in ys:
+                temp.append((x, y))
+        temp_rot = rotate_points(temp, math.radians(45))
+        for (x, y) in temp_rot:
+            if x**2 + y**2 <= (R - tube_OD_mm/2.0)**2:
+                centers.append((x, y))
+                if max_count and len(centers) >= max_count:
+                    return centers
+
+    elif layout == "Triangular (hex-packed)" or layout == "Hexagonal grid":
         vert = pitch_mm * math.sqrt(3)/2.0
-        # construct rows symmetric about y=0
-        # start from center row and go outwards to cover -R..R
-        row_offsets = []
-        y_center = 0.0
-        row_offsets.append(y_center)
-        step = vert
-        n = 1
-        while True:
-            y_up = n * step
-            y_down = -n * step
-            if abs(y_up) <= R or abs(y_down) <= R:
-                if abs(y_up) <= R:
-                    row_offsets.append(y_up)
-                if abs(y_down) <= R:
-                    row_offsets.append(y_down)
-                n += 1
-            else:
-                break
-        row_offsets = sorted(set(row_offsets))
-        for idx, y in enumerate(row_offsets):
-            if idx % 2 == 0:
+        row_idx = 0
+        y = -R
+        while y <= R:
+            if row_idx % 2 == 0:
                 xs = np.arange(-R, R + 1e-8, pitch_mm)
             else:
                 xs = np.arange(-R + pitch_mm/2.0, R + 1e-8, pitch_mm)
@@ -370,10 +340,36 @@ def generate_tube_centers(radius_mm, pitch_mm, layout="Triangular", tube_OD_mm=0
                     centers.append((x, y))
                     if max_count and len(centers) >= max_count:
                         return centers
+            row_idx += 1
+            y += vert
+
+    elif layout == "Concentric rings":
+        tube_r = tube_OD_mm / 2.0
+        if 0 <= (R - tube_r):
+            centers.append((0.0, 0.0))
+        ring = 1
+        while True:
+            r_ring = ring * pitch_mm
+            if r_ring > (R - tube_r):
+                break
+            n_on_ring = max(1, int(math.floor(2 * math.pi * r_ring / pitch_mm + 0.5)))
+            for i in range(n_on_ring):
+                ang = 2 * math.pi * i / n_on_ring
+                x = r_ring * math.cos(ang)
+                y = r_ring * math.sin(ang)
+                if x**2 + y**2 <= (R - tube_r)**2:
+                    centers.append((x, y))
+                    if max_count and len(centers) >= max_count:
+                        return centers
+            ring += 1
+    else:
+        return generate_tube_centers(radius_mm, pitch_mm, layout="Triangular (hex-packed)", tube_OD_mm=tube_OD_mm, max_count=max_count)
+
     return centers
 
 # -----------------------
 # Calculation logic
+# -----------------------
 def compute_all():
     # Unit conversions into consistent internal units:
     # lengths in mm, pressure in MPa, stresses in MPa
@@ -418,14 +414,12 @@ def compute_all():
         if use_SI:
             S_allow_MPa = float(S_allowable_manual)
         else:
-            # ensure psi->MPa conversion
             S_allow_MPa = psito_mpa(float(S_allowable_manual_psi))
         source_S = "Manual override"
     else:
         S_allow_MPa = S_allowable_auto if S_allowable_auto is not None else None
         source_S = "Auto lookup (interpolated)" if S_allowable_auto is not None else "None available"
 
-    # fallback if none available
     if S_allow_MPa is None:
         S_allow_MPa = 100.0
         source_S = "Default used (no lookup) - user must verify"
@@ -437,7 +431,7 @@ def compute_all():
         else:
             k = 0.375
     else:
-        # TEMA illustrative modifiers (verify with TEMA docs)
+        # TEMA illustrative modifiers
         if edge_condition.startswith("Clamped"):
             k = 0.27
         else:
@@ -575,7 +569,6 @@ def compute_all():
     csv_data = csv_buffer.getvalue().encode("utf-8")
 
     # Convert centers into normalized plot coordinates for schematic: scale by a_mm (radius)
-    # Plot uses coordinates in range [-1,1]
     plot_centers = [(x / a_mm, y / a_mm) for (x, y) in centers]
 
     return results, log_text, summary_df, csv_data, plot_centers, OD_tube_mm, a_mm
@@ -610,18 +603,15 @@ if compute:
     with right:
         st.markdown("**Schematic (to scale in layout) — normalized to tubesheet radius**")
         fig = go.Figure()
-        # outer circle (radius = 1 normalized)
-        theta = np.linspace(0, 2*np.pi, 200)
+        # outer circle (normalized)
+        theta = np.linspace(0, 2*np.pi, 400)
         fig.add_trace(go.Scatter(x=np.cos(theta), y=np.sin(theta), mode="lines", name="Tubesheet OD",
                                  line=dict(width=2, color="RoyalBlue")))
-        # tubes as markers; scale marker size approx proportional to OD_tube_mm / a_mm
         xs = [c[0] for c in plot_centers]
         ys = [c[1] for c in plot_centers]
-        # compute pixel-like marker size but keep within reasonable bounds
+        # compute marker size from tube OD and radius (empirical)
         if a_mm > 0:
-            # fraction of normalized radius occupied by tube radius
             frac = (OD_tube_mm / 2.0) / a_mm
-            # convert fraction to marker size (empirical scaling)
             marker_size = max(4, min(40, frac * 800))
         else:
             marker_size = 6
@@ -631,6 +621,13 @@ if compute:
                           title_text="Tubesheet layout (normalized to radius = 1)")
         st.plotly_chart(fig, use_container_width=True)
 
+        # export PNG option (safe: try/except in case kaleido not installed)
+        try:
+            img_bytes = fig.to_image(format="png", width=1000, height=1000, scale=1)
+            st.download_button("Download schematic PNG", data=img_bytes, file_name="tubesheet_layout.png", mime="image/png")
+        except Exception as e:
+            st.info("PNG export requires 'kaleido'. If you want PNG export, install 'kaleido' (see requirements.txt).")
+
     # Calculation log
     if show_detail:
         st.subheader("Detailed calculation log")
@@ -655,5 +652,4 @@ if st.sidebar.button("Example 1 (SI)"):
     st.info("Preset example: OD 1000 mm, ~100 tubes, tube OD 25.4 mm, P_shell=3 bar, P_tube=1 bar — set values manually or copy/paste into fields.")
 if st.sidebar.button("Example 2 (Imperial)"):
     st.info("Preset example: OD 40 in, ~200 tubes, tube OD 0.75 in, P_shell=50 psi, P_tube=14.7 psi — set values manually or copy/paste into fields.")
-
 # End of app