Update app.py

app.py

@@ -12,19 +12,30 @@ from pydantic import BaseModel
 def solve_3d_heat_equation(Lx: float, Ly: float, Lz: float,
                            t_max: float,
                            Gamma: float = 0.1,
-                           Nx: int = 30, Ny: int = 30, Nz: int = 30, # Reduced default for 3D
+                           Nx: int = 30, Ny: int = 30, Nz: int = 30,
                            initial: str = "gaussian",
                            bc: str = "dirichlet"):
     x = np.linspace(0, Lx, Nx)
     y = np.linspace(0, Ly, Ny)
     z = np.linspace(0, Lz, Nz)
-    dx, dy, dz = x[1] - x, y[1] - y, z[1] - z # Corrected indexing
+    
+    # Corrected dx, dy, dz calculation
+    if Nx > 1: dx = x[1] - x
+    else: dx = Lx # Or handle as an error / specific case if Nx=1
+    if Ny > 1: dy = y[1] - y
+    else: dy = Ly
+    if Nz > 1: dz = z[1] - z
+    else: dz = Lz
 
-    if dx == 0 or dy == 0 or dz == 0:
-        raise ValueError("Nx, Ny, and Nz must be > 1 for valid dx, dy, dz.")
+    if dx == 0 or dy == 0 or dz == 0: # This check might need adjustment if Nx/Ny/Nz=1 is allowed and handled differently
+        # If Nx, Ny, or Nz is 1, dx, dy, or dz could be the length itself, or this indicates an issue.
+        # For FTCS, we need at least 3 points in a dimension to compute spatial derivatives,
+        # unless boundary conditions handle the 1-point or 2-point cases specifically.
+        # The current loop u[1:-1,...] assumes at least 3 points.
+        raise ValueError("Nx, Ny, and Nz must be > 1 for the current FTCS scheme. Or dx/dy/dz became zero.")
 
     # Stability condition for 3D FTCS scheme
-    dt = 0.5 / (Gamma * (1/dx**2 + 1/dy**2 + 1/dz**2)) # Adjusted for 3D
+    dt = 0.5 / (Gamma * (1/dx**2 + 1/dy**2 + 1/dz**2))
     Nt = int(np.ceil(t_max / dt)) + 1
     
     rx, ry, rz = Gamma * dt / dx**2, Gamma * dt / dy**2, Gamma * dt / dz**2
@@ -32,11 +43,13 @@ def solve_3d_heat_equation(Lx: float, Ly: float, Lz: float,
     X, Y, Z = np.meshgrid(x, y, z, indexing='ij')
 
     if initial == "gaussian":
-        u = np.exp(-(((X - Lx/2)**2 + (Y - Ly/2)**2 + (Z - Lz/2)**2) / (2*(Lx/10)**2)))
+        u = np.exp(-(((X - Lx/2)**2 + (Y - Ly/2)**2 + (Z - Lz/2)**2) / (2*(max(Lx,Ly,Lz)/10)**2))) # Adjusted sigma
     elif initial == "random":
         u = np.random.rand(Nx, Ny, Nz)
     elif initial == "sinusoidal":
-        kx, ky, kz = 2 * np.pi / Lx, 2 * np.pi / Ly, 2 * np.pi / Lz
+        kx = 2 * np.pi / Lx if Lx > 0 else 0
+        ky = 2 * np.pi / Ly if Ly > 0 else 0
+        kz = 2 * np.pi / Lz if Lz > 0 else 0
         u = np.sin(kx * X) * np.sin(ky * Y) * np.sin(kz * Z)
     elif initial == "step":
         u = np.where((X < Lx/2) & (Y < Ly/2) & (Z < Lz/2), 1.0, 0.0)
@@ -48,31 +61,34 @@ def solve_3d_heat_equation(Lx: float, Ly: float, Lz: float,
 
     for n in range(1, Nt):
         un = u.copy()
-        u[1:-1, 1:-1, 1:-1] = (
-            un[1:-1, 1:-1, 1:-1]
-            + rx * (un[2:, 1:-1, 1:-1] - 2 * un[1:-1, 1:-1, 1:-1] + un[:-2, 1:-1, 1:-1])
-            + ry * (un[1:-1, 2:, 1:-1] - 2 * un[1:-1, 1:-1, 1:-1] + un[1:-1, :-2, 1:-1])
-            + rz * (un[1:-1, 1:-1, 2:] - 2 * un[1:-1, 1:-1, 1:-1] + un[1:-1, 1:-1, :-2])
-        )
+        # Check if dimensions are large enough for slicing
+        if Nx > 2 and Ny > 2 and Nz > 2:
+            u[1:-1, 1:-1, 1:-1] = (
+                un[1:-1, 1:-1, 1:-1]
+                + rx * (un[2:, 1:-1, 1:-1] - 2 * un[1:-1, 1:-1, 1:-1] + un[:-2, 1:-1, 1:-1])
+                + ry * (un[1:-1, 2:, 1:-1] - 2 * un[1:-1, 1:-1, 1:-1] + un[1:-1, :-2, 1:-1])
+                + rz * (un[1:-1, 1:-1, 2:] - 2 * un[1:-1, 1:-1, 1:-1] + un[1:-1, 1:-1, :-2])
+            )
+        else:
+            # If any dimension is too small for the [1:-1] slice,
+            # the heat equation update needs to be handled differently (e.g. only boundaries apply)
+            # For simplicity, we assume Nx,Ny,Nz >=3 for internal point updates.
+            # Otherwise, u remains largely unchanged except by boundary conditions.
+            pass
+
 
         if bc == "dirichlet":
-            u[0, :, :] = u[-1, :, :] = 0.0
-            u[:, 0, :] = u[:, -1, :] = 0.0
-            u[:, :, 0] = u[:, :, -1] = 0.0
+            if Nx > 0: u[0, :, :] = u[-1, :, :] = 0.0
+            if Ny > 0: u[:, 0, :] = u[:, -1, :] = 0.0
+            if Nz > 0: u[:, :, 0] = u[:, :, -1] = 0.0
         elif bc == "neumann": # Zero flux
-            u[0, :, :] = u[1, :, :]
-            u[-1, :, :] = u[-2, :, :]
-            u[:, 0, :] = u[:, 1, :]
-            u[:, -1, :] = u[:, -2, :]
-            u[:, :, 0] = u[:, :, 1]
-            u[:, :, -1] = u[:, :, -2]
+            if Nx > 1: u[0, :, :] = u[1, :, :]; u[-1, :, :] = u[-2, :, :]
+            if Ny > 1: u[:, 0, :] = u[:, 1, :]; u[:, -1, :] = u[:, -2, :]
+            if Nz > 1: u[:, :, 0] = u[:, :, 1]; u[:, :, -1] = u[:, :, -2]
         elif bc == "periodic":
-            u[0, :, :] = un[-2, :, :]
-            u[-1, :, :] = un[1, :, :]
-            u[:, 0, :] = un[:, -2, :]
-            u[:, -1, :] = un[:, 1, :]
-            u[:, :, 0] = un[:, :, -2]
-            u[:, :, -1] = un[:, :, 1]
+            if Nx > 1: u[0, :, :] = un[-2, :, :]; u[-1, :, :] = un[1, :, :]
+            if Ny > 1: u[:, 0, :] = un[:, -2, :]; u[:, -1, :] = un[:, 1, :]
+            if Nz > 1: u[:, :, 0] = un[:, :, -2]; u[:, :, -1] = un[:, :, 1]
         else:
             raise ValueError(f"Unknown bc: {bc}")
         U[n] = u.copy()
@@ -83,35 +99,74 @@ def create_animation_gif_3d_slice(U, Lx, Ly, Lz, initial, bc, Gamma, frame_skip,
     Nt, Nx, Ny, Nz = U.shape
     fig, ax = plt.subplots()
     
-    slice_z_idx = Nz // 2
-    z_coord_slice = np.linspace(0, Lz, Nz)[slice_z_idx]
+    # Ensure Nz is valid for slicing
+    slice_z_idx = Nz // 2 if Nz > 0 else 0
+    z_coord_slice = np.linspace(0, Lz, Nz)[slice_z_idx] if Nz > 0 else 0
     
-    data_slice = U[0, :, :, slice_z_idx].T
+    if Nt == 0: # Should not happen if solve_3d_heat_equation guarantees Nt >= 1
+        # Create a blank image or raise an error
+        # For now, let's assume Nt >= 1 based on solve_3d_heat_equation
+        # If this occurs, U.min()/max() and U will fail.
+        # Returning a placeholder or erroring out early is better.
+        # This path indicates an issue upstream.
+        # For robustness, one might return a path to a pre-made "error" GIF.
+        # However, given Nt = ceil(t_max/dt) + 1, Nt is always >= 1.
+        pass
+
+
+    data_slice = U[0, :, :, slice_z_idx].T if Nt > 0 and Nz > 0 else np.zeros((Ny, Nx)) # Handle empty slice
     
+    # Handle U being potentially empty or having non-finite values for min/max
+    vmin_val = U.min() if Nt > 0 and U.size > 0 and np.all(np.isfinite(U)) else 0
+    vmax_val = U.max() if Nt > 0 and U.size > 0 and np.all(np.isfinite(U)) else 1
+    if vmin_val == vmax_val: vmax_val = vmin_val + 1 # Avoid error in imshow if all values are same
+
     im = ax.imshow(data_slice, cmap='viridis', origin='lower', 
-                   extent=[0, Lx, 0, Ly], vmin=U.min(), vmax=U.max())
+                   extent=[0, Lx, 0, Ly], vmin=vmin_val, vmax=vmax_val)
     ax.set_title(f"3D Heat Eq (xy-slice at z={z_coord_slice:.2f})\ninit={initial}, bc={bc}, Gamma={Gamma:.2f}")
     ax.set_xlabel("x")
     ax.set_ylabel("y")
     plt.colorbar(im, ax=ax, label="u")
 
     def update(frame):
-        im.set_data(U[frame, :, :, slice_z_idx].T)
+        if Nz > 0:
+            im.set_data(U[frame, :, :, slice_z_idx].T)
+        else: # Should not happen if Nz is reasonably set
+            im.set_data(np.zeros((Ny, Nx))) # Placeholder for empty Z dimension
         return [im]
 
-    if Nt <= 1:
-        idx =  # Only one frame (initial state)
-    else:
-        idx = list(range(0, Nt, frame_skip))
-        if not idx: # If frame_skip is too large for Nt > 1
-            idx = 
-        if idx[-1]!= Nt - 1: # Ensure last frame is included
+    # Corrected idx generation
+    if Nt == 0:
+        idx = 
+    elif Nt == 1:
+        idx = 
+    else: # Nt > 1
+        current_frame_skip = max(1, frame_skip) # Ensure frame_skip is at least 1
+        idx = list(range(0, Nt, current_frame_skip))
+        
+        if 0 not in idx : # Should always be true for range(0,...) unless Nt=0
+             idx.insert(0,0)
+
+        if (Nt - 1) not in idx:
             idx.append(Nt - 1)
-        # Remove duplicates if Nt-1 was already included by range
-        idx = sorted(list(set(idx)))
+        
+        idx = sorted(list(set(idx))) 
+    
+    # FuncAnimation requires at least one frame. If Nt=0, idx is empty.
+    # solve_3d_heat_equation ensures Nt >= 1, so idx will have at least .
+    if not idx and Nt > 0: # Fallback, though current logic should prevent this if Nt > 0
+        idx = 
+    
+    if not idx: # If Nt is 0 and idx is empty
+        # Create a dummy animation or return a placeholder path
+        # For now, this will likely cause FuncAnimation to error if idx is empty.
+        # However, as Nt >= 1, idx should not be empty.
+        # If it could be, one might do:
+        # if not idx: fig.savefig(tmp_path_for_static_image); return tmp_path
+        pass
 
 
-    ani = FuncAnimation(fig, update, frames=idx, blit=True)
+    ani = FuncAnimation(fig, update, frames=idx if idx else , blit=True) # Ensure frames is not empty
 
     with tempfile.NamedTemporaryFile(suffix='.gif', delete=False) as tmpfile:
         ani.save(tmpfile.name, writer='pillow', fps=max(1, 30 // max(1,frame_skip)))
@@ -123,21 +178,29 @@ def create_animation_gif_3d_slice(U, Lx, Ly, Lz, initial, bc, Gamma, frame_skip,
 # --- Plotly Figure Generator (3D Volume) ---
 def create_plotly_figure_3d(u_3d, Lx, Ly, Lz, time_label):
     Nx, Ny, Nz = u_3d.shape
+    if Nx==0 or Ny==0 or Nz==0: # Handle empty u_3d
+        return go.Figure(layout_title_text=f"3D Heat Distribution (No Data) at t={time_label}")
+
     x_coords = np.linspace(0, Lx, Nx)
     y_coords = np.linspace(0, Ly, Ny)
     z_coords = np.linspace(0, Lz, Nz)
     
     X, Y, Z = np.meshgrid(x_coords, y_coords, z_coords, indexing='ij')
 
+    # Ensure u_3d is finite for min/max
+    vmin = np.min(u_3d[np.isfinite(u_3d)]) if np.any(np.isfinite(u_3d)) else 0
+    vmax = np.max(u_3d[np.isfinite(u_3d)]) if np.any(np.isfinite(u_3d)) else 1
+    if vmin == vmax: vmax = vmin + 0.1 # Avoid issues with single value
+
     fig = go.Figure(data=go.Volume(
         x=X.flatten(),
         y=Y.flatten(),
         z=Z.flatten(),
         value=u_3d.flatten(),
-        isomin=u_3d.min(), # Use actual min/max of the current data
-        isomax=u_3d.max(),
+        isomin=vmin, 
+        isomax=vmax,
         opacity=0.1, 
-        surface_count=17, # Adjusted for potentially better performance/look
+        surface_count=17, 
         colorscale='viridis'
     ))
     fig.update_layout(
@@ -146,7 +209,6 @@ def create_plotly_figure_3d(u_3d, Lx, Ly, Lz, time_label):
             xaxis_title='x',
             yaxis_title='y',
             zaxis_title='z',
-            # Aspect ratio can be important for 3D visualization
             aspectmode='cube' 
         )
     )
@@ -154,11 +216,16 @@ def create_plotly_figure_3d(u_3d, Lx, Ly, Lz, time_label):
 
 # --- Simulation Runner (Extracted Logic for 3D) ---
 def run_simulation_3d(lx, ly, lz, t_max, gamma, nx, ny, nz, initial, bc, frame_skip):
+    # Ensure grid dimensions are at least 3 for FTCS internal points, or handle 1D/2D cases if needed
+    nx = max(3, int(nx))
+    ny = max(3, int(ny))
+    nz = max(3, int(nz))
+
     U, dt = solve_3d_heat_equation(
         Lx=lx, Ly=ly, Lz=lz, t_max=t_max, Gamma=gamma, 
         Nx=nx, Ny=ny, Nz=nz, initial=initial, bc=bc
     )
-    Nt = U.shape # Corrected: U.shape is Nt
+    Nt = U.shape 
     
     idx0 = 0
     idx1 = round((Nt - 1) / 4) if Nt > 1 else 0
@@ -180,29 +247,34 @@ def run_simulation_3d(lx, ly, lz, t_max, gamma, nx, ny, nz, initial, bc, frame_s
 
 # --- Gradio Interface Logic (3D) ---
 def gradio_interface_3d(lx, ly, lz, t_max, gamma, nx, ny, nz, initial, bc, frame_skip):
-    nx, ny, nz, frame_skip = int(nx), int(ny), int(nz), int(frame_skip)
-    # Ensure frame_skip is at least 1
-    frame_skip = max(1, frame_skip)
+    nx_int, ny_int, nz_int = int(nx), int(ny), int(nz)
+    frame_skip_int = max(1, int(frame_skip))
+
+    # Ensure minimal grid dimensions for the current simulation logic
+    nx_int = max(3, nx_int)
+    ny_int = max(3, ny_int)
+    nz_int = max(3, nz_int)
+
     gif_path, fig0, fig1, fig2, fig3 = run_simulation_3d(
-        lx, ly, lz, t_max, gamma, nx, ny, nz, initial, bc, frame_skip
+        lx, ly, lz, t_max, gamma, nx_int, ny_int, nz_int, initial, bc, frame_skip_int
     )
     return gif_path, fig0, fig1, fig2, fig3
 
 # --- Gradio UI Layout (3D) ---
 with gr.Blocks(theme=gr.themes.Soft(), title="3D Heat Simulator") as demo:
-    gr.Markdown("# 🔥 3D Heat Equation Simulator\nAdjust parameters and run the simulation. Animation shows a central xy-slice.")
+    gr.Markdown("# 🔥 3D Heat Equation Simulator\nAdjust parameters and run the simulation. Animation shows a central xy-slice. Grid (Nx,Ny,Nz) min 3.")
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("## Domain & Grid")
             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")
             lz_slider = gr.Slider(0.1, 5.0, 1.0, 0.1, label="Lz")
-            nx_slider = gr.Slider(3, 60, 20, 1, label="Nx (e.g., 20-40 for speed)") # Max reduced
-            ny_slider = gr.Slider(3, 60, 20, 1, label="Ny (e.g., 20-40 for speed)") # Max reduced
-            nz_slider = gr.Slider(3, 60, 20, 1, label="Nz (e.g., 20-40 for speed)") # Max reduced
+            nx_slider = gr.Slider(3, 60, 20, 1, label="Nx (min 3, e.g., 20-40)")
+            ny_slider = gr.Slider(3, 60, 20, 1, label="Ny (min 3, e.g., 20-40)")
+            nz_slider = gr.Slider(3, 60, 20, 1, label="Nz (min 3, e.g., 20-40)")
 
             gr.Markdown("## Simulation")
-            t_slider = gr.Slider(0.01, 1.0, 0.1, 0.01, label="t_max (e.g., 0.1-0.5)") # Max t_max reduced
+            t_slider = gr.Slider(0.01, 1.0, 0.1, 0.01, label="t_max (e.g., 0.1-0.5)")
             gamma_slider = gr.Slider(0.001, 1.0, 0.1, 0.001, label="Gamma")
 
             gr.Markdown("## Conditions")
@@ -239,7 +311,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="3D Heat Simulator") as demo:
         inputs=inputs_list,
         outputs=outputs_list,
         fn=gradio_interface_3d,
-        cache_examples=False # Consider disabling cache if examples are slow or large
+        cache_examples=False 
     )
 
 # --- FastAPI Setup for API Endpoint (3D) ---
@@ -262,8 +334,12 @@ class SimulationParams3D(BaseModel):
 
 @app.post("/simulate_3d") 
 def simulate_3d_api(params: SimulationParams3D):
-    # Ensure frame_skip is at least 1 for API calls too
     params.frame_skip = max(1, params.frame_skip)
+    # Ensure minimal grid dimensions for API calls too
+    params.nx = max(3, params.nx)
+    params.ny = max(3, params.ny)
+    params.nz = max(3, params.nz)
+
     gif_path, fig0, fig1, fig2, fig3 = run_simulation_3d(**params.dict())
     with open(gif_path, "rb") as f:
         gif_data = base64.b64encode(f.read()).decode('utf-8')