Update app.py

app.py

@@ -1,8 +1,8 @@
 import numpy as np
-import pyvista as pv
 import plotly.graph_objects as go
 import gradio as gr
 from scipy.spatial import Delaunay
+import traceback
 
 def solve_and_plot_interactive(Lx: float,
                                Ly: float,
@@ -17,7 +17,7 @@ def solve_and_plot_interactive(Lx: float,
     Solves the 2D heat equation and returns an interactive Plotly figure
     that can be rendered in a web browser.
     """
-    # --- 1. Simulation Setup (Same as before) ---
+    # --- 1. Simulation Setup ---
     x = np.linspace(0, Lx, Nx)
     y = np.linspace(0, Ly, Ny)
     dx, dy = x[1] - x[0], y[1] - y[0]
@@ -37,7 +37,7 @@ def solve_and_plot_interactive(Lx: float,
     elif initial == "step":
         u = np.where((X < Lx/2) & (Y < Ly/2), 1.0, 0.0)
 
-    # --- 2. Solve the Heat Equation (Same as before) ---
+    # --- 2. Solve the Heat Equation ---
     time_indices = np.linspace(0, Nt - 1, M, dtype=int)
     U_slider = np.zeros((M, Nx, Ny))
     store_idx = 0
@@ -64,14 +64,11 @@ def solve_and_plot_interactive(Lx: float,
             store_idx += 1
             
     # --- 3. Create a Plotly Figure for Web ---
-    # We use Delaunay triangulation to create the mesh faces for Plotly
     points_2d = np.vstack([X.ravel(), Y.ravel()]).T
     tri = Delaunay(points_2d)
     
-    # Create the figure
     fig = go.Figure()
 
-    # Add one mesh trace for each time step. We'll make only the first one visible.
     for i in range(M):
         time_value = (time_indices[i] / (Nt-1)) * t_max if Nt > 1 else 0
         z_data = U_slider[i, :, :].flatten()
@@ -82,53 +79,54 @@ def solve_and_plot_interactive(Lx: float,
                 intensity=z_data,
                 colorscale='Viridis',
                 name=f'Time: {time_value:.2f}s',
-                showscale=True if i == 0 else False, # Show colorbar only once
-                visible=(i == 0) # Make only the first trace visible
+                showscale=True if i == 0 else False,
+                visible=(i == 0)
             )
         )
 
-    # Create the slider
     steps = []
     for i in range(len(fig.data)):
         time_value = (time_indices[i] / (Nt-1)) * t_max if Nt > 1 else 0
         step = dict(
             method="update",
-            args=[{"visible": [False] * len(fig.data)}],  # hide all traces
+            args=[{"visible": [False] * len(fig.data)}],
             label=f"{time_value:.2f}s"
         )
-        step["args"][0]["visible"][i] = True  # show the i-th trace
+        step["args"][0]["visible"][i] = True
         steps.append(step)
 
-    sliders = [dict(
-        active=0,
-        currentvalue={"prefix": "Time: "},
-        pad={"t": 50},
-        steps=steps
-    )]
+    sliders = [dict(active=0, currentvalue={"prefix": "Time: "}, pad={"t": 50}, steps=steps)]
 
-    # Update the layout of the figure
     fig.update_layout(
         title=f'2D Heat Eq — init={initial}, bc={bc}',
-        scene=dict(
-            xaxis_title='X',
-            yaxis_title='Y',
-            zaxis_title='Temperature'
-        ),
+        scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Temperature'),
         sliders=sliders
     )
     
     return fig
 
 
-# --- Gradio Interface Function ---
+# --- Gradio Interface Function with Error Handling ---
 def gradio_interface(lx, ly, t_max, m_steps, gamma, nx, ny, initial, bc):
-    nx, ny, m_steps = int(nx), int(ny), int(m_steps)
-    # This function now returns a Plotly figure object
-    return solve_and_plot_interactive(
-        Lx=lx, Ly=ly, t_max=t_max, M=m_steps, Gamma=gamma, Nx=nx, Ny=ny,
-        initial=initial, bc=bc
-    )
-
+    try:
+        nx, ny, m_steps = int(nx), int(ny), int(m_steps)
+        fig = solve_and_plot_interactive(
+            Lx=lx, Ly=ly, t_max=t_max, M=m_steps, Gamma=gamma, Nx=nx, Ny=ny,
+            initial=initial, bc=bc
+        )
+        # On success, return the figure to the Plot component
+        return fig
+    except Exception as e:
+        # If any error occurs, create a text-based error to show in the UI
+        # This prevents the app from crashing.
+        error_text = traceback.format_exc()
+        print(error_text) # Print the full error to the logs for debugging
+        # Return a placeholder Plotly figure with the error message
+        error_fig = go.Figure().update_layout(
+            title_text="⚠️ Application Error",
+            annotations=[dict(text=f"An error occurred: {e}", showarrow=False)]
+        )
+        return error_fig
 
 # --- Gradio UI Definition ---
 with gr.Blocks(theme=gr.themes.Soft(), title="2D Heat Simulator") as demo:
@@ -138,13 +136,14 @@ with gr.Blocks(theme=gr.themes.Soft(), title="2D Heat Simulator") as demo:
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("## Simulation Parameters")
-            lx_slider = gr.Slider(0.1, 5.0, 1.0, 0.1, label="Lx (Domain Length X)")
-            ly_slider = gr.Slider(0.1, 5.0, 1.0, 0.1, label="Ly (Domain Length Y)")
-            nx_slider = gr.Slider(10, 100, 40, 1, label="Nx (Grid Points X)") # Reduced max for performance
-            ny_slider = gr.Slider(10, 100, 40, 1, label="Ny (Grid Points Y)")
-            t_slider = gr.Slider(0.01, 2.0, 0.5, 0.01, label="t_max (Total Time)")
-            gamma_slider = gr.Slider(0.001, 1.0, 0.1, 0.001, label="Gamma (Diffusivity)")
-            m_slider = gr.Slider(10, 100, 30, 1, label="M (Time Steps on Slider)") # Reduced max
+            # Reduced max values to be safer on free hardware
+            lx_slider = gr.Slider(0.1, 5.0, 1.0, 0.1, label="Lx")
+            ly_slider = gr.Slider(0.1, 5.0, 1.0, 0.1, label="Ly")
+            nx_slider = gr.Slider(10, 80, 40, 1, label="Nx (Grid Points X)")
+            ny_slider = gr.Slider(10, 80, 40, 1, label="Ny (Grid Points Y)")
+            t_slider = gr.Slider(0.01, 2.0, 0.5, 0.01, label="t_max")
+            gamma_slider = gr.Slider(0.001, 1.0, 0.1, 0.001, label="Gamma")
+            m_slider = gr.Slider(10, 80, 30, 1, label="M (Time Steps)")
             
             with gr.Row():
                 initial_dropdown = gr.Dropdown(["gaussian", "random", "sinusoidal", "step"], value="gaussian", label="Initial")
@@ -153,7 +152,6 @@ with gr.Blocks(theme=gr.themes.Soft(), title="2D Heat Simulator") as demo:
             run_btn = gr.Button("Run Simulation", variant="primary")
 
         with gr.Column(scale=3):
-            # The output is now a gr.Plot component that will render the Plotly figure
             plot_output = gr.Plot(label="Interactive Heatmap")
 
     inputs_list = [lx_slider, ly_slider, t_slider, m_slider, gamma_slider,
@@ -162,14 +160,16 @@ with gr.Blocks(theme=gr.themes.Soft(), title="2D Heat Simulator") as demo:
     run_btn.click(fn=gradio_interface, inputs=inputs_list, outputs=plot_output)
     
     gr.Examples(
+        # Using more modest values in the examples
         examples=[
-            [1.0, 1.0, 0.5, 30, 0.1, 40, 40, "gaussian", "dirichlet"],
-            [2.0, 1.0, 1.0, 50, 0.05, 50, 25, "sinusoidal", "periodic"],
+            [1.0, 1.0, 0.5, 30, 0.1, 30, 30, "gaussian", "dirichlet"],
+            [2.0, 1.0, 1.0, 40, 0.05, 40, 20, "sinusoidal", "periodic"],
         ],
         inputs=inputs_list,
         outputs=plot_output,
         fn=gradio_interface,
-        cache_examples=True # Caching is fine for Plotly objects
+        # Set cache_examples to False to prevent crashes on startup
+        cache_examples=False
     )
 
 if __name__ == "__main__":