uploaded gradio_app.py

gradio_app.py

@@ -0,0 +1,155 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+import tempfile
+import gradio as gr
+
+def solve_and_animate_2d(Lx: float,
+                         Ly: float,
+                         t_max: float,
+                         Gamma: float = 0.1,
+                         Nx: int = 50,
+                         Ny: int = 50,
+                         initial: str = "gaussian",
+                         bc: str = "dirichlet",
+                         frame_skip: int = 1):
+    """
+    Solve the 2D heat equation u_t = Gamma*(u_xx + u_yy) and return a GIF animation.
+    Initial conditions: {"gaussian", "random", "sinusoidal", "step"}
+    Boundary conditions: {"dirichlet", "neumann", "periodic"}
+    """
+    # Spatial grid
+    x = np.linspace(0, Lx, Nx)
+    y = np.linspace(0, Ly, Ny)
+    dx, dy = x[1] - x[0], y[1] - y[0]
+    if dx == 0 or dy == 0:
+        raise ValueError("Nx and Ny must be > 1.")
+
+    # Time stepping for stability
+    dt = 1.0 / (2 * Gamma * (1/dx**2 + 1/dy**2))
+    Nt = int(np.ceil(t_max / dt)) + 1
+    rx, ry = Gamma * dt / dx**2, Gamma * dt / dy**2
+
+    # Initial condition
+    X, Y = np.meshgrid(x, y, indexing='ij')
+    if initial == "gaussian":
+        u = np.exp(-(((X - Lx/2)**2 + (Y - Ly/2)**2) / (2*(Lx/10)**2)))
+    elif initial == "random":
+        u = np.random.rand(Nx, Ny)
+    elif initial == "sinusoidal":
+        kx, ky = 2 * np.pi / Lx, 2 * np.pi / Ly
+        u = np.sin(kx * X) * np.sin(ky * Y)
+    elif initial == "step":
+        u = np.where((X < Lx/2) & (Y < Ly/2), 1.0, 0.0)
+    else:
+        raise ValueError(f"Unknown initial condition: {initial}")
+
+    # Storage for solution
+    U = np.zeros((Nt, Nx, Ny))
+    U[0] = u.copy()
+
+    # Time-stepping loop
+    for n in range(1, Nt):
+        un = u.copy()
+        # Interior update
+        u[1:-1, 1:-1] = (
+            un[1:-1, 1:-1]
+            + rx * (un[2:, 1:-1] - 2 * un[1:-1, 1:-1] + un[:-2, 1:-1])
+            + ry * (un[1:-1, 2:] - 2 * un[1:-1, 1:-1] + un[1:-1, :-2])
+        )
+        # Boundary conditions
+        if bc == "dirichlet":
+            u[0, :] = u[-1, :] = u[:, 0] = u[:, -1] = 0.0
+        elif bc == "neumann":
+            u[0, :] = u[1, :]
+            u[-1, :] = u[-2, :]
+            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]
+        else:
+            raise ValueError(f"Unknown bc: {bc}")
+        U[n] = u.copy()
+
+    # Create animation with Matplotlib
+    fig, ax = plt.subplots()
+    im = ax.imshow(U[0].T, cmap='viridis', origin='lower', extent=[0, Lx, 0, Ly], vmin=U.min(), vmax=U.max())
+    ax.set_title(f"2D Heat Eq — init={initial}, bc={bc}, Gamma={Gamma:.2f}")
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    plt.colorbar(im, ax=ax, label="u")
+
+    # Animation update function
+    def update(frame):
+        im.set_data(U[frame].T)
+        return [im]
+
+    # Subsample frames
+    idx = list(range(0, Nt, frame_skip))
+    if idx[-1] != Nt - 1:
+        idx.append(Nt - 1)
+
+    # Generate animation
+    ani = FuncAnimation(fig, update, frames=idx, blit=True)
+
+    # Save as GIF
+    with tempfile.NamedTemporaryFile(suffix='.gif', delete=False) as tmpfile:
+        ani.save(tmpfile.name, writer='pillow', fps=30)
+        gif_path = tmpfile.name
+
+    plt.close(fig)
+    return gif_path
+
+def gradio_interface(lx, ly, t_max, gamma, nx, ny, initial, bc, frame_skip):
+    nx, ny, frame_skip = int(nx), int(ny), int(frame_skip)
+    return solve_and_animate_2d(
+        Lx=lx, Ly=ly, t_max=t_max, Gamma=gamma, Nx=nx, Ny=ny,
+        initial=initial, bc=bc, frame_skip=frame_skip
+    )
+
+with gr.Blocks(theme=gr.themes.Soft(), title="2D Heat Simulator") as demo:
+    gr.Markdown("# ♨️ 2D Heat Equation Simulator\nAdjust parameters and run the simulation.")
+    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")
+            nx_slider = gr.Slider(3, 200, 50, 1, label="Nx")
+            ny_slider = gr.Slider(3, 200, 50, 1, label="Ny")
+
+            gr.Markdown("## Simulation")
+            t_slider = gr.Slider(0.01, 5.0, 0.5, 0.01, label="t_max")
+            gamma_slider = gr.Slider(0.001, 1.0, 0.1, 0.001, label="Gamma")
+
+            gr.Markdown("## Conditions")
+            initial_dropdown = gr.Dropdown(
+                ["gaussian", "random", "sinusoidal", "step"], "gaussian", label="Initial"
+            )
+            bc_dropdown = gr.Dropdown(
+                ["dirichlet", "neumann", "periodic"], "dirichlet", label="Boundary"
+            )
+
+            gr.Markdown("## Animation")
+            frame_skip_slider = gr.Slider(1, 50, 5, 1, label="Frame Skip")
+            run_btn = gr.Button("Run Simulation", variant="primary")
+        with gr.Column(scale=3):
+            plot_output = gr.Image(label="Heatmap Animation")
+    inputs_list = [lx_slider, ly_slider, t_slider, gamma_slider,
+                   nx_slider, ny_slider, initial_dropdown, bc_dropdown, frame_skip_slider]
+    run_btn.click(fn=gradio_interface, inputs=inputs_list, outputs=plot_output)
+    gr.Examples(
+        examples=[
+            [1.0, 1.0, 0.5, 0.1, 50, 50, "gaussian", "dirichlet", 5],
+            [2.0, 1.0, 1.0, 0.05, 60, 30, "sinusoidal", "periodic", 10],
+            [1.0, 1.0, 0.2, 0.2, 80, 80, "step", "neumann", 2],
+        ],
+        inputs=inputs_list,
+        outputs=[plot_output],
+        fn=gradio_interface
+    )
+
+if __name__ == "__main__":
+    demo.launch()