Update app.py

app.py

@@ -20,19 +20,12 @@ def solve_3d_heat_equation(Lx: float, Ly: float, Lz: float,
     z = np.linspace(0, Lz, Nz)
     
     # 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: # 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.")
+    dx = x[1] - x[0] if Nx > 1 else Lx
+    dy = y[1] - y[0] if Ny > 1 else Ly
+    dz = z[1] - z[0] if Nz > 1 else Lz
+
+    if dx == 0 or dy == 0 or dz == 0:
+        raise ValueError("Grid spacing (dx, dy, dz) cannot be zero. Ensure Nx, Ny, Nz > 1.")
 
     # Stability condition for 3D FTCS scheme
     dt = 0.5 / (Gamma * (1/dx**2 + 1/dy**2 + 1/dz**2))
@@ -43,7 +36,7 @@ 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*(max(Lx,Ly,Lz)/10)**2))) # Adjusted sigma
+        u = np.exp(-(((X - Lx/2)**2 + (Y - Ly/2)**2 + (Z - Lz/2)**2) / (2*(max(Lx,Ly,Lz)/10)**2)))
     elif initial == "random":
         u = np.random.rand(Nx, Ny, Nz)
     elif initial == "sinusoidal":
@@ -57,11 +50,10 @@ def solve_3d_heat_equation(Lx: float, Ly: float, Lz: float,
         raise ValueError(f"Unknown initial condition: {initial}")
 
     U = np.zeros((Nt, Nx, Ny, Nz))
-    U = u.copy() # Store initial condition
+    U[0] = u.copy()  # Store initial condition
 
     for n in range(1, Nt):
         un = u.copy()
-        # 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]
@@ -69,25 +61,18 @@ def solve_3d_heat_equation(Lx: float, Ly: float, Lz: float,
                 + 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":
             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
+        elif bc == "neumann":
             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":
             if Nx > 1: u[0, :, :] = un[-2, :, :]; u[-1, :, :] = un[1, :, :]
-            if Ny > 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}")
@@ -99,27 +84,14 @@ 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()
     
-    # 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
     
-    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
+    data_slice = U[0, :, :, slice_z_idx].T if Nt > 0 and Nz > 0 else np.zeros((Ny, Nx))
     
-    # 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
+    if vmin_val == vmax_val: vmax_val = vmin_val + 1
 
     im = ax.imshow(data_slice, cmap='viridis', origin='lower', 
                    extent=[0, Lx, 0, Ly], vmin=vmin_val, vmax=vmax_val)
@@ -131,45 +103,22 @@ def create_animation_gif_3d_slice(U, Lx, Ly, Lz, initial, bc, Gamma, frame_skip,
     def update(frame):
         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]
 
     # 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
+    if Nt <= 1:
+        idx = [0]  # Only initial frame if Nt is 0 or 1
+    else:
+        current_frame_skip = max(1, frame_skip)
         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)
-        
-        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
-
+        idx = sorted(list(set(idx)))
 
-    ani = FuncAnimation(fig, update, frames=idx if idx else , blit=True) # Ensure frames is not empty
+    ani = FuncAnimation(fig, update, frames=idx, blit=True)
 
     with tempfile.NamedTemporaryFile(suffix='.gif', delete=False) as tmpfile:
-        ani.save(tmpfile.name, writer='pillow', fps=max(1, 30 // max(1,frame_skip)))
+        ani.save(tmpfile.name, writer='pillow', fps=max(1, 30 // max(1, frame_skip)))
         gif_path = tmpfile.name
 
     plt.close(fig)
@@ -178,7 +127,7 @@ 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
+    if Nx == 0 or Ny == 0 or Nz == 0:
         return go.Figure(layout_title_text=f"3D Heat Distribution (No Data) at t={time_label}")
 
     x_coords = np.linspace(0, Lx, Nx)
@@ -187,10 +136,9 @@ def create_plotly_figure_3d(u_3d, Lx, Ly, Lz, time_label):
     
     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
+    if vmin == vmax: vmax = vmin + 0.1
 
     fig = go.Figure(data=go.Volume(
         x=X.flatten(),
@@ -216,7 +164,6 @@ 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))
@@ -225,7 +172,7 @@ def run_simulation_3d(lx, ly, lz, t_max, gamma, nx, ny, nz, initial, bc, frame_s
         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 
+    Nt = U.shape[0]
     
     idx0 = 0
     idx1 = round((Nt - 1) / 4) if Nt > 1 else 0
@@ -250,7 +197,6 @@ def gradio_interface_3d(lx, ly, lz, t_max, gamma, nx, ny, nz, initial, bc, frame
     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)
@@ -305,9 +251,11 @@ with gr.Blocks(theme=gr.themes.Soft(), title="3D Heat Simulator") as demo:
     run_btn.click(fn=gradio_interface_3d, inputs=inputs_list, outputs=outputs_list)
     
     gr.Examples(
-        examples=[1.0, 1.0, 1.0, 0.1, 0.1, 20, 20, 20, "gaussian", "dirichlet", 5], 
+        examples=[
+            [1.0, 1.0, 1.0, 0.1, 0.1, 20, 20, 20, "gaussian", "dirichlet", 5],
             [1.5, 1.0, 0.5, 0.2, 0.05, 25, 20, 15, "sinusoidal", "periodic", 10],
-            [1.0, 1.0, 1.0, 0.05, 0.2, 15, 15, 15, "step", "neumann", 2],
+            [1.0, 1.0, 1.0, 0.05, 0.2, 15, 15, 15, "step", "neumann", 2]
+        ],
         inputs=inputs_list,
         outputs=outputs_list,
         fn=gradio_interface_3d,
@@ -335,7 +283,6 @@ class SimulationParams3D(BaseModel):
 @app.post("/simulate_3d") 
 def simulate_3d_api(params: SimulationParams3D):
     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)