Upload 8 files

" First Commit: Application and other files added"

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+synopsys-logo-color-rgb.jpg filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,69 @@
+# 1. Start from a slim Python 3.11 base image
+FROM python:3.11-slim
+
+# 2. Set Environment Variables
+# - DEBIAN_FRONTEND: Prevents installers from asking interactive questions
+# - PYTHONUNBUFFERED/PYTHONDONTWRITEBYTECODE: Standard Python-in-Docker settings
+# - PYVISTA_OFF_SCREEN/DISPLAY: Crucial for running PyVista headless (off-screen)
+#   by telling it to use a "virtual" display at address :99
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYVISTA_OFF_SCREEN=true \
+    DISPLAY=:99 \
+    VTK_SILENCE_GET_VOID_POINTER_WARNINGS=1
+
+# 3. Install System Dependencies
+# This is the most critical part for PyVista/VTK. We need the OS
+# graphics libraries (libosmesa, libgl1) and the X Virtual FrameBuffer (xvfb).
+#
+# *** UPDATED this section to use current package names (e.g., libgl1, libegl1) ***
+#
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential cmake wget xvfb \
+    libosmesa6 libosmesa6-dev \
+    libgl1 libgl1-mesa-dev \
+    libegl1 libegl1-mesa-dev \
+    libglu1-mesa libglu1-mesa-dev \
+    libgles2-mesa-dev \
+    libx11-6 libxt6 libxrender1 libsm6 libice6 \
+    && rm -rf /var/lib/apt/lists/*
+
+# 4. Create a non-root user for security
+RUN useradd -m -u 1000 user
+WORKDIR /home/user/app
+
+# 5. Install Python dependencies (optimized)
+# We copy *only* requirements.txt first and install it.
+# This "layer" is cached by Docker. If you only change app.py later,
+# Docker skips this step, making builds much faster.
+COPY requirements.txt .
+RUN python3 -m pip install --upgrade pip setuptools wheel \
+ && python3 -m pip install --no-cache-dir -r requirements.txt
+
+# 6. Copy the rest of the application code
+# This copies app.py, delta_impulse_generator.py, etc.
+# We set the owner to our new 'user'.
+COPY --chown=user:user . .
+
+# 7. Switch to the non-root user
+USER user
+
+# 8. Expose the port the app will run on
+EXPOSE 7860
+
+# 9. Healthcheck (good practice for hosting platforms)
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:${PORT:-7860}/ || exit 1
+
+# 10. Start Command
+# This command does two things:
+# a) Starts the X Virtual FrameBuffer (Xvfb) in the background (&) on display :99
+# b) 'exec' runs your app. Using 'exec' is important as it makes the Python
+#    process the main one, which properly handles signals (like stopping the container).
+#    '--host 0.0.0.0' is ESSENTIAL to make the server accessible from outside the container.
+CMD ["sh", "-c", "Xvfb :99 -screen 0 1024x768x24 >/dev/null 2>&1 & exec python3 app.py --server --host 0.0.0.0 --port ${PORT:-7860}"]
+
+

README.md

@@ -1,10 +1,10 @@
----
-title: Quantum
-emoji: 📈
-colorFrom: gray
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Quantum
+emoji: 📈
+colorFrom: gray
+colorTo: red
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,1547 @@
+import numpy as np
+import re
+import pyvista as pv
+import webbrowser
+import threading
+import base64
+
+from trame.app import get_server
+from trame_vuetify.ui.vuetify3 import SinglePageLayout
+from trame_vuetify.widgets import vuetify3
+from pyvista.trame.ui import plotter_ui
+import plotly.graph_objects as go
+from trame_plotly.widgets import plotly as plotly_widgets
+import os
+from datetime import datetime
+from trame.widgets import html as trame_html
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister
+from qiskit.circuit.library import StatePreparation, QFTGate, RZGate
+from qiskit.quantum_info import Statevector
+from delta_impulse_generator import * 
+
+# Set PyVista to use off-screen rendering for Trame
+pv.OFF_SCREEN = True
+
+# --- Server and State Initialization ---
+server = get_server()
+state, ctrl = server.state, server.controller
+
+# --- Application State ---
+state.update({
+    "dist_type": None, "impulse_x": 0.5, "impulse_y": 0.5,
+    "peak_pair": "(0.5, 0.5)",
+    "mu_x": 0.5, "mu_y": 0.5, "sigma_x": 0.25, "sigma_y": 0.15,
+    "mu_pair": "(0.5, 0.5)",            # Gaussian Mu as normalized pair string
+    "sigma_pair": "(0.25, 0.15)",       # Gaussian Sigma as normalized pair string
+    "nx": None, "T": 10.0, "time_val": 0.0,
+    "L": 1.0,  # Side length used for coordinate conversion
+    "output_type": "Surface Plot",
+    "surface_field": "Ez",
+    "timeseries_field": "Ez",
+    "timeseries_points": "(8, 8), (10, 8)",
+    "error_message": "",
+    "is_running": False,
+    "simulation_has_run": False,
+    "geometry_selection": None,
+    "show_upload_dialog": False,
+    "uploaded_file_info": None,
+    "show_upload_status": False,
+    "upload_status_message": "",
+    "coeff_permittivity": 1.0,  # Relative permittivity (ε_r)
+    "coeff_permeability": 1.0,  # Relative permeability (μ_r)
+    "run_button_text": "Run Simulation",
+    "backend_type": "Simulator",
+    "selected_simulator": "IBM Qiskit simulator",
+    "selected_qpu": "IBM QPU",
+    "stop_button_disabled": True,  # Stop button is initially disabled
+    "export_format": "vtk",  # Dummy export format for Surface Plot
+    "nx_slider_index": None,  # No selection until user chooses on the slider
+    "show_export_status": False,
+    "export_status_message": "",
+    "logo_src": None,
+    # Dummy geometry-hole controls (UI only)
+    "hole_size_edge": 0.2,      # edge length in [0, 1]
+    "hole_center_x": 0.5,       # center X in (0, 1)
+    "hole_center_y": 0.5,       # center Y in (0, 1)
+    "hole_center_pair": "(0.5, 0.5)",  # bracket-format center for dropdown
+    "hole_error_message": "",  # validation message
+    "excitation_error_message": "",    # parse/validation for Gaussian pair inputs
+    "excitation_info_message": "",     # Snapping info for excitation coordinates
+    "dt_user": 0.1,                     # Dummy Δt input from user (seconds)
+    "temporal_warning": "",            # Warning message for invalid Δt
+    # Square aspect for initial preview
+    "pyvista_view_style": "aspect-ratio: 1 / 1; width: 100%;",
+})
+
+# Ensure hole snap state exists
+state.hole_snap = True
+
+# --- Load Synopsys logo (from quantum folder) as data URI ---
+def load_logo_data_uri():
+    base_dir = os.path.dirname(__file__)
+    candidates = [
+        os.path.join(base_dir, "synopsys-logo-color-rgb.svg"),
+        os.path.join(base_dir, "synopsys-logo-color-rgb.png"),
+        os.path.join(base_dir, "synopsys-logo-color-rgb.jpg"),
+    ]
+    for p in candidates:
+        if os.path.exists(p):
+            ext = os.path.splitext(p)[1].lower()
+            mime = "image/svg+xml" if ext == ".svg" else ("image/png" if ext == ".png" else "image/jpeg")
+            with open(p, "rb") as f:
+                b64 = base64.b64encode(f.read()).decode("ascii")
+            return f"data:{mime};base64,{b64}"
+    return None
+
+state.logo_src = load_logo_data_uri()
+
+# --- Global PyVista and Data Variables ---
+plotter = pv.Plotter()
+simulation_data = None
+current_mesh = None
+data_frames = None
+z_scale = 1.0
+X_grids, Y_grids = {}, {}
+surface_clims = {}
+stop_simulation = False  # Flag to stop running simulation
+snapshot_times = None    # Times corresponding to saved frames (user snapshots)
+
+# --- Constants ---
+GRID_SIZES = ["16", "32", "64", "128", "256", "512"]
+
+# --- Plotting and Simulation Logic ---
+def get_time_series_chart(simulation_data, field_type, positions, nx, times):
+    # times: 1D array of snapshot times aligning with simulation_data frames
+    n_frames = int(simulation_data.shape[0]) if simulation_data is not None else 0
+    time_axis = np.asarray(times) if times is not None else np.arange(n_frames)
+    chart = pv.Chart2D()
+    if (field_type == 'Ez'):
+        grid_width, grid_height = nx, nx
+    elif (field_type == 'Hx'):
+        grid_width, grid_height = nx, nx - 1
+    else:
+        grid_width, grid_height = nx - 1, nx
+    colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
+    for i, (pos_x, pos_y) in enumerate(positions):
+        if not (0 <= pos_x < grid_width and 0 <= pos_y < grid_height):
+            print(f"Warning: Skipping invalid position {(pos_x, pos_y)} for {field_type}")
+            continue
+        if field_type == 'Ez': values = simulation_data[:, pos_y * grid_width + pos_x]
+        elif field_type == 'Hx': values = simulation_data[:, 2*nx*nx : 3*nx*nx-nx].reshape(n_frames, grid_height, grid_width)[:, pos_y, pos_x]
+        else:
+            mask = np.arange(1, nx * nx + 1) % nx != 0
+            raw_block = simulation_data[:, -nx*nx:]
+            values = [raw_block[t, mask].reshape(nx, nx - 1)[pos_y, pos_x] for t in range(n_frames)]
+        chart.line(time_axis, values, label=f'{field_type} at ({pos_x}, {pos_y})', color=colors[i % len(colors)])
+    chart.x_label = "Time (s)"; chart.y_label = "Field Amplitude"; chart.title = f"Time Evolution of {field_type}"
+    return chart
+
+def setup_surface_plot_data(simulation_data, nx):
+    global data_frames, z_scale, X_grids, Y_grids, surface_clims
+    mask = np.arange(1, nx * nx + 1) % nx != 0
+    data_frames = {'Ez': [], 'Hx': [], 'Hy': []}
+    surface_clims = {'Ez': [np.inf, -np.inf], 'Hx': [np.inf, -np.inf], 'Hy': [np.inf, -np.inf]}
+    for u in simulation_data:
+        ez, hx, hy = u[:nx*nx].reshape(nx,nx), u[2*nx*nx:3*nx*nx-nx].reshape(nx-1,nx), u[-nx*nx:][mask].reshape(nx,nx-1)
+        data_frames['Ez'].append(ez); data_frames['Hx'].append(hx); data_frames['Hy'].append(hy)
+        if ez.size > 0: surface_clims['Ez'][0], surface_clims['Ez'][1] = min(surface_clims['Ez'][0], ez.min()), max(surface_clims['Ez'][1], ez.max())
+        if hx.size > 0: surface_clims['Hx'][0], surface_clims['Hx'][1] = min(surface_clims['Hx'][0], hx.min()), max(surface_clims['Hx'][1], hx.max())
+        if hy.size > 0: surface_clims['Hy'][0], surface_clims['Hy'][1] = min(surface_clims['Hy'][0], hy.min()), max(surface_clims['Hy'][1], hy.max())
+    for key in surface_clims:
+        if surface_clims[key][0] == surface_clims[key][1]: surface_clims[key][0] -= 1e-9; surface_clims[key][1] += 1e-9
+    # Revert to integer grid coordinates (like app.py) to keep output plots in grids
+    x, y, x_m1, y_m1 = np.arange(nx), np.arange(nx), np.arange(nx-1), np.arange(nx-1)
+    X_grids['Ez'], Y_grids['Ez'] = np.meshgrid(x, y)
+    X_grids['Hx'], Y_grids['Hx'] = np.meshgrid(x, y_m1)
+    X_grids['Hy'], Y_grids['Hy'] = np.meshgrid(x_m1, y)
+    max_abs = max(abs(v) for pair in surface_clims.values() for v in pair if v is not np.inf and v is not -np.inf)
+    z_scale = (nx / 2) / max(max_abs, 1e-9)
+
+def run_simulation_only():
+    global simulation_data, current_mesh, snapshot_times, stop_simulation
+    # Require selections before running
+    if not state.geometry_selection:
+        state.error_message = "Please select a geometry before running the simulation."
+        state.is_running = False
+        state.run_button_text = "Run Simulation"
+        return
+    if not state.dist_type:
+        state.error_message = "Please select an initial state before running the simulation."
+        state.is_running = False
+        state.run_button_text = "Run Simulation"
+        return
+    
+    # Reset stop flag and enable Stop button at start
+    stop_simulation = False
+    state.stop_button_disabled = False
+
+    plotter.clear()
+    current_mesh = None
+    state.error_message = ""
+    state.is_running = True
+    state.simulation_has_run = False
+    state.run_button_text = "Running"
+    ctrl.view_update()
+    
+    nx, T = int(state.nx), float(state.T)
+    na, R = 1, 4
+    
+    try:
+        if state.dist_type == "Delta":
+            initial_state = create_impulse_state_from_pos((nx, nx), (float(state.impulse_x), float(state.impulse_y)))
+        else:
+            initial_state = create_gaussian_state_from_pos((nx, nx), (float(state.mu_x), float(state.mu_y)), (float(state.sigma_x), float(state.sigma_y)))
+    except ValueError as e:
+        state.error_message = f"Initial State Error: {e}"
+        state.is_running = False
+        state.run_button_text = "Run Simulation"
+        state.stop_button_disabled = True
+        return
+
+    print("Running simulation...")
+    # Pass user-defined snapshot Δt; keep solver dt=0.1 inside run_sim
+    snapshot_dt = float(state.dt_user)
+    def _stop_check():
+        return stop_simulation
+    simulation_data, snapshot_times = run_sim(nx, na, R, initial_state, T, snapshot_dt=snapshot_dt, stop_check=_stop_check)
+    print("Simulation complete.")
+    
+    if simulation_data.size > 0:
+        setup_surface_plot_data(simulation_data, nx)
+        state.simulation_has_run = True
+        state.run_button_text = "Successful!"
+        # Allow the view to use full area after run (remove strict square)
+        state.pyvista_view_style = ""
+        generate_plot()
+    else:
+        state.error_message = "Simulation produced no data. Check parameters (e.g., T > 0)."
+        state.run_button_text = "Run Simulation"
+
+    state.is_running = False
+    state.stop_button_disabled = True
+
+def reset_to_defaults():
+    """Reset all parameters to their default values"""
+    global simulation_data, current_mesh, data_frames, stop_simulation, snapshot_times
+    
+    # Stop any running simulation
+    stop_simulation = True
+    
+    # Reset global variables
+    simulation_data = None
+    current_mesh = None
+    data_frames = None
+    snapshot_times = None
+    
+    # Reset state to default values
+    state.update({
+        "dist_type": None,
+        "impulse_x": 0.5,
+        "impulse_y": 0.5,
+        "peak_pair": "(0.5, 0.5)",
+        "mu_x": 0.5,
+        "mu_y": 0.5,
+        "sigma_x": 0.25,
+        "sigma_y": 0.15,
+        "mu_pair": "(0.5, 0.5)",
+        "sigma_pair": "(0.25, 0.15)",
+        "nx": None,
+        "T": 10.0,
+        "time_val": 0.0,
+        "output_type": "Surface Plot",
+        "surface_field": "Ez",
+        "timeseries_field": "Ez",
+        "timeseries_points": "(8, 8), (10, 8)",
+        "error_message": "",
+        "excitation_info_message": "",
+        "is_running": False,
+        "simulation_has_run": False,
+        "geometry_selection": None,
+        "coeff_permittivity": 1.0,
+        "coeff_permeability": 1.0,
+        "run_button_text": "Run Simulation",
+        "backend_type": "Simulator",
+        "selected_simulator": "IBM Qiskit simulator",
+        "selected_qpu": "IBM QPU",
+        "stop_button_disabled": True,
+        "export_format": "vtk",
+        "nx_slider_index": None,
+        "dt_user": 0.1,
+        "temporal_warning": "",
+        # Restore square aspect for initial preview
+        "pyvista_view_style": "aspect-ratio: 1 / 1; width: 100%;",
+    })
+    
+    # Ensure stop flag is cleared for next run
+    stop_simulation = False
+    
+    # Update the preview with default values
+    update_initial_state_preview()
+    print("Reset to default settings")
+
+@state.change("peak_pair")
+def sync_peak_pair(peak_pair, **kwargs):
+    """Parse normalized pair (x, y) in [0,1] for Peak and update impulse_x/impulse_y."""
+    try:
+        m = re.match(r"\(\s*([0-9]*\.?[0-9]+)\s*,\s*([0-9]*\.?[0-9]+)\s*\)", str(peak_pair))
+        if not m:
+            raise ValueError("Invalid format")
+        x = max(0.0, min(1.0, float(m.group(1))))
+        y = max(0.0, min(1.0, float(m.group(2))))
+        state.impulse_x = x
+        state.impulse_y = y
+        state.excitation_error_message = ""
+    except Exception:
+        state.excitation_error_message = "Invalid Peak. Use format (x, y) in [0,1]."
+    finally:
+        update_excitation_info_message()
+
+@state.change("mu_pair")
+def sync_mu_pair(mu_pair, **kwargs):
+    """Parse normalized pair (x, y) in [0,1] for Mu and update mu_x/mu_y."""
+    try:
+        m = re.match(r"\(\s*([-+]?[0-9]*\.?[0-9]+)\s*,\s*([-+]?[0-9]*\.?[0-9]+)\s*\)", str(mu_pair))
+        if not m:
+            raise ValueError("Invalid format")
+        x = max(0.0, min(1.0, float(m.group(1))))
+        y = max(0.0, min(1.0, float(m.group(2))))
+        state.mu_x = x
+        state.mu_y = y
+        state.excitation_error_message = ""
+    except Exception:
+        state.excitation_error_message = "Invalid Mu. Use format (x, y) in [0,1]."
+    finally:
+        update_excitation_info_message()
+
+def stop_simulation_handler():
+    """Stop the currently running simulation"""
+    global stop_simulation
+    stop_simulation = True
+    state.stop_button_disabled = True
+    print("Stopping simulation...")
+
+def generate_plot():
+    global current_mesh
+    if not state.simulation_has_run: return
+    
+    plotter.clear()
+    try: plotter.disable_picking()
+    except: pass
+
+    nx, T = int(state.nx), float(state.T)
+
+    if state.output_type == "Surface Plot":
+        redraw_surface_plot()
+    else: # Time Series
+        try:
+            points_str = state.timeseries_points
+            positions = [tuple(map(int, match)) for match in re.findall(r'\((\d+)\s*,\s*(\d+)\)', points_str)]
+            if not positions and points_str.strip(): raise ValueError("No valid points found.")
+            chart = get_time_series_chart(simulation_data, state.timeseries_field, positions, nx, snapshot_times)
+            plotter.add_chart(chart)
+            plotter.view_xy() # Set a 2D view for the chart
+        except Exception as e:
+            state.error_message = f"Plotting Error: {e}"
+    
+    ctrl.view_update()
+
+def redraw_surface_plot():
+    global current_mesh
+    plotter.clear()
+    field = state.surface_field
+    if data_frames is None or not data_frames.get(field): return
+    if snapshot_times is None or len(snapshot_times) == 0: return
+
+    # Find nearest snapshot index to requested time and clamp to available frames
+    req_t = float(state.time_val)
+    times = np.asarray(snapshot_times)
+    idx = int(np.argmin(np.abs(times - req_t)))
+    max_idx = len(data_frames[field]) - 1
+    idx = max(0, min(idx, max_idx))
+
+    z_data = data_frames[field][idx]
+    points = np.c_[X_grids[field].ravel(), Y_grids[field].ravel(), z_data.ravel() * z_scale]
+    poly = pv.PolyData(points)
+    mesh = poly.delaunay_2d()
+    mesh['scalars'] = z_data.ravel()
+    current_mesh = mesh
+    plotter.add_mesh(mesh, scalars='scalars', clim=surface_clims[field], cmap="RdBu", show_scalar_bar=False, show_edges=True, edge_color='grey', line_width=0.5)
+    plotter.add_scalar_bar(title=f"{field} Amplitude")
+    try:
+        plotter.disable_picking()
+    except Exception:
+        pass
+    plotter.enable_point_picking(callback=update_value_display, show_message=False)
+    plotter.add_axes()
+    plotter.view_isometric()
+    try:
+        plotter.camera.parallel_projection = True
+    except Exception:
+        pass
+    ctrl.view_update()
+
+# Helper: add a dotted unit grid (0..1) overlay in light Synopsys purple
+def _add_dotted_unit_grid(plotter, ticks=(0.0, 0.25, 0.5, 0.75, 1.0), segments=48, gap_ratio=0.4, color="#AE8BD8", line_width=0.2):
+    try:
+        step = 1.0 / float(max(segments, 1))
+        seg_len = step * float(max(0.0, min(1.0, 1.0 - gap_ratio)))
+        pts = []
+        lines = []
+        # Horizontal dotted lines at given y=tick
+        for y in ticks:
+            pos = 0.0
+            while pos < 1.0 - 1e-9:
+                y0, y1 = pos, min(pos + seg_len, 1.0)
+                pts.extend([(0.0, y, 0.0), (1.0, y, 0.0)])  # end points along x (we'll segment via multiple x positions)
+                # Replace with segmented along X
+                pts[-2] = (pos, y, 0.0)
+                pts[-1] = (y1 if seg_len > 0 else pos, y, 0.0)
+                i0 = len(pts) - 2
+                lines.extend([2, i0, i0 + 1])
+                pos += step
+        # Vertical dotted lines at given x=tick
+        for x in ticks:
+            pos = 0.0
+            while pos < 1.0 - 1e-9:
+                y0, y1 = pos, min(pos + seg_len, 1.0)
+                pts.extend([(x, pos, 0.0), (x, y1 if seg_len > 0 else pos, 0.0)])
+                i0 = len(pts) - 2
+                lines.extend([2, i0, i0 + 1])
+                pos += step
+        if pts and lines:
+            poly = pv.PolyData(np.array(pts))
+            poly.lines = np.array(lines)
+            plotter.add_mesh(poly, color=color, line_width=line_width, name="dotted_unit_grid", pickable=False)
+    except Exception:
+        pass
+
+# Scaled dotted unit grid overlay for integer-coordinate previews (Delta/Gaussian)
+def _add_dotted_unit_grid_scaled(plotter, denom, ticks=(0.0, 0.25, 0.5, 0.75, 1.0), segments=48, gap_ratio=0.6, color="#AE8BD8", line_width=1.0, name="dotted_unit_grid_preview"):
+    """Overlay a 0–1 dotted grid scaled to [0, denom] on the XY plane without changing mesh coordinates."""
+    try:
+        step = 1.0 / float(max(segments, 1))
+        seg_len = step * float(max(0.0, min(1.0, 1.0 - gap_ratio)))
+        # Set a z slightly below mesh to avoid z-fighting
+        try:
+            z0 = float(current_mesh.points[:, 2].min()) - 1e-6 if current_mesh is not None else 0.0
+        except Exception:
+            z0 = 0.0
+        pts, lines = [], []
+        # Vertical lines at x = t * denom
+        for t in ticks:
+            x = float(t) * float(denom)
+            pos = 0.0
+            while pos < 1.0 - 1e-9:
+                y0 = pos * denom
+                y1 = min(pos + seg_len, 1.0) * denom
+                pts.extend([(x, y0, z0), (x, y1, z0)])
+                i0 = len(pts) - 2
+                lines.extend([2, i0, i0 + 1])
+                pos += step
+        # Horizontal lines at y = t * denom
+        for t in ticks:
+            y = float(t) * float(denom)
+            pos = 0.0
+            while pos < 1.0 - 1e-9:
+                x0 = pos * denom
+                x1 = min(pos + seg_len, 1.0) * denom
+                pts.extend([(x0, y, z0), (x1, y, z0)])
+                i0 = len(pts) - 2
+                lines.extend([2, i0, i0 + 1])
+                pos += step
+        try:
+            plotter.remove_actor(name)
+        except Exception:
+            pass
+        if pts and lines:
+            poly = pv.PolyData(np.array(pts))
+            poly.lines = np.array(lines)
+            plotter.add_mesh(poly, color=color, line_width=line_width, name=name, pickable=False)
+    except Exception:
+        pass
+
+# --- Plain Square Domain Preview ---
+def update_geometry_preview():
+    """Render a flat square mesh (Z=0) with edges for 'Square Domain'."""
+    global current_mesh
+    if state.is_running or state.simulation_has_run:
+        return
+    plotter.clear()
+    nx = int(state.nx) if state.nx is not None else 32
+    # Build normalized coordinates in [0, 1]
+    denom = max(nx - 1, 1)
+    x, y = np.arange(nx) / denom, np.arange(nx) / denom
+    X, Y = np.meshgrid(x, y)
+    Z = np.zeros_like(X, dtype=float)
+    points = np.c_[X.ravel(), Y.ravel(), Z.ravel()]
+    poly = pv.PolyData(points)
+    mesh = poly.delaunay_2d()
+    mesh['scalars'] = Z.ravel()
+    current_mesh = mesh
+    plotter.add_mesh(
+        mesh,
+        color="#FFDAB9",  # Peach Puff to match Square Metallic Body domain
+        show_scalar_bar=False,
+        show_edges=False,
+        edge_color='grey',
+        line_width=0.5,
+    )
+    try:
+        plotter.disable_picking()
+    except Exception:
+        pass
+    plotter.enable_point_picking(callback=update_value_display, show_message=False)
+    plotter.add_axes()
+    # Axes scaled 0..1
+    plotter.show_grid(bounds=(0.0, 1.0, 0.0, 1.0, 0.0, 0.0), xtitle="x (0–1)", ytitle="y (0–1)", ztitle=" ", color="#AE8BD8")
+    _add_dotted_unit_grid(plotter, ticks=(0.0, 0.25, 0.5, 0.75, 1.0), segments=48, gap_ratio=0.6, color="#AE8BD8", line_width=1)
+    plotter.view_isometric()
+    try:
+        plotter.camera.parallel_projection = True
+    except Exception:
+        pass
+    ctrl.view_update()
+
+# --- Plain Square Domain (Hole) Preview ---
+def update_geometry_hole_preview():
+    """Render a flat square mesh with a square hole defined by center (cx, cy) and size a."""
+    global current_mesh
+    if state.is_running or state.simulation_has_run:
+        return
+    plotter.clear()
+    nx = int(state.nx) if state.nx is not None else 32
+    denom = max(nx - 1, 1)
+    # Normalized grid in [0,1]
+    x, y = np.arange(nx) / denom, np.arange(nx) / denom
+    X, Y = np.meshgrid(x, y)
+    Z = np.zeros_like(X, dtype=float)
+    points = np.c_[X.ravel(), Y.ravel(), Z.ravel()]
+    poly = pv.PolyData(points)
+    mesh = poly.delaunay_2d()
+
+    # Read user inputs
+    try:
+        a = float(state.hole_size_edge)
+        cx = float(state.hole_center_x)
+        cy = float(state.hole_center_y)
+    except Exception:
+        a, cx, cy = 0.2, 0.5, 0.5  # fallback
+
+    mode_snap = bool(state.hole_snap)
+    edges = _compute_hole_edges(nx, cx, cy, a, snap=mode_snap)
+    if edges is not None:
+        xL, xR, yB, yT = edges
+        # Open rectangle: remove cells with centers strictly inside (boundaries excluded)
+        centers = mesh.cell_centers().points
+        in_x = (centers[:, 0] > xL) & (centers[:, 0] < xR)
+        in_y = (centers[:, 1] > yB) & (centers[:, 1] < yT)
+        hole_mask = in_x & in_y
+        if hole_mask.any():
+            mesh = mesh.remove_cells(np.where(hole_mask)[0])
+            mesh.clean(inplace=True)
+
+    # Color domain peach and overlay a black filled rectangle for the hole
+    current_mesh = mesh
+    try:
+        plotter.remove_actor("hole_overlay")
+    except Exception:
+        pass
+
+    # Draw domain in peach color so it doesn't blend with background
+    plotter.add_mesh(
+        mesh,
+        color="#FFDAB9",  # Peach Puff
+        show_scalar_bar=False,
+        show_edges=False,
+        edge_color='grey',
+        line_width=0.5,
+    )
+
+    # If edges are valid, add a black filled rectangle for the hole area
+    if edges is not None:
+        xL, xR, yB, yT = edges
+        z0 = -1e-6  # Slightly below to avoid z-fighting at boundaries
+        rect_pts = np.array([
+            [xL, yB, z0],
+            [xR, yB, z0],
+            [xR, yT, z0],
+            [xL, yT, z0],
+        ], dtype=float)
+        rect_faces = np.hstack([[4, 0, 1, 2, 3]])
+        rect = pv.PolyData(rect_pts, rect_faces)
+        plotter.add_mesh(rect, color="black", name="hole_overlay", pickable=False)
+
+    # Grid and view setup
+    plotter.show_grid(bounds=(0.0, 1.0, 0.0, 1.0, 0.0, 0.0), xtitle="x (0–1)", ytitle="y (0–1)", ztitle=" ", color="#AE8BD8")
+    _add_dotted_unit_grid(plotter, ticks=(0.0, 0.25, 0.5, 0.75, 1.0), segments=48, gap_ratio=0.6, color="#AE8BD8", line_width=1)
+    try:
+        plotter.disable_picking()
+    except Exception:
+        pass
+    plotter.enable_point_picking(callback=update_value_display, show_message=False)
+    plotter.add_axes()
+    plotter.view_isometric()
+    try:
+        plotter.camera.parallel_projection = True
+    except Exception:
+        pass
+    ctrl.view_update()
+
+# Helper: map normalized [0,1] to nearest node index on an nx×ny grid
+def _nearest_node_index(x: float, y: float, nx: int, ny: int | None = None):
+    ny = ny or nx
+    i = int(round(float(x) * (nx - 1)))
+    j = int(round(float(y) * (ny - 1)))
+    i = max(0, min(nx - 1, i))
+    j = max(0, min(ny - 1, j))
+    return i, j
+
+def update_initial_state_preview():
+    global current_mesh
+    # Don't render any preview while running
+    if state.is_running:
+        plotter.clear(); ctrl.view_update(); return
+    # If no geometry selected, clear and stop
+    if not state.geometry_selection:
+        plotter.clear(); ctrl.view_update(); return
+    # Geometry-only previews before initial state selection
+    if not state.simulation_has_run and not state.dist_type:
+        if state.geometry_selection == "Square Domain":
+            update_geometry_preview(); return
+        if state.geometry_selection == "Square Metallic Body":
+            update_geometry_hole_preview(); return
+    
+    plotter.clear()
+    state.error_message = ""
+    # Default to a high-resolution 128x128 preview grid
+    preview_n = 128
+    nx_sel = state.nx
+    # Show grid edges only when a mesh size is selected
+    show_grid_edges = nx_sel is not None
+
+    try:
+        grid_n = int(nx_sel) if nx_sel is not None else preview_n
+        
+        if state.dist_type == "Delta":
+            ix, iy = _nearest_node_index(float(state.impulse_x), float(state.impulse_y), grid_n)
+            full_state = create_impulse_state((grid_n, grid_n), (ix, iy))
+        elif state.dist_type == "Gaussian":
+            ix, iy = _nearest_node_index(float(state.mu_x), float(state.mu_y), grid_n)
+            sx = max(float(state.sigma_x) * (grid_n - 1), 1e-9)
+            sy = max(float(state.sigma_y) * (grid_n - 1), 1e-9)
+            full_state = create_gaussian_state((grid_n, grid_n), (ix, iy), (sx, sy))
+        else:
+            return
+        
+        # Build preview mesh using the correct grid size
+        initial_grid = full_state[: grid_n * grid_n].reshape(grid_n, grid_n)
+        denom = float(max(grid_n - 1, 1))
+        x, y = np.arange(grid_n) / denom, np.arange(grid_n) / denom
+        X, Y = np.meshgrid(x, y)
+        max_abs = float(np.max(np.abs(initial_grid))) if initial_grid.size else 1.0
+        if max_abs < 1e-12:
+            max_abs = 1.0
+        height_scale = 0.15
+        Z = (initial_grid / max_abs) * height_scale
+        mesh = pv.StructuredGrid()
+        mesh.points = np.c_[X.ravel(), Y.ravel(), Z.ravel()]
+        mesh.dimensions = (grid_n, grid_n, 1)
+        mesh['scalars'] = initial_grid.ravel()
+        current_mesh = mesh
+
+        plotter.add_mesh(
+            mesh,
+            scalars='scalars',
+            cmap="Blues",
+            show_scalar_bar=False,
+            show_edges=show_grid_edges,
+            edge_color='grey',
+            line_width=0.5,
+        )
+        # No scalar bar, axes, or grid overlays in excitation preview; picking only
+        try:
+            plotter.disable_picking()
+        except Exception:
+            pass
+        plotter.enable_point_picking(callback=update_value_display, show_message=False)
+        plotter.view_isometric()
+        try:
+            plotter.camera.parallel_projection = True
+        except Exception:
+            pass
+        ctrl.view_update()
+
+    except ValueError as e:
+        state.error_message = f"Parameter Error: {e}"
+    except Exception as e:
+        state.error_message = f"An unexpected error occurred: {e}"
+
+@state.change("geometry_selection")
+def handle_geometry_add(geometry_selection, **kwargs):
+    # Normalize unselect options to None
+    if geometry_selection in (None, "", "None"):
+        state.geometry_selection = None
+        update_initial_state_preview()
+        return
+    if (geometry_selection == "Add"):
+        state.show_upload_dialog = True
+        state.geometry_selection = None
+        return
+    # Update preview on any geometry change (e.g., show Square Domain flat mesh)
+    update_initial_state_preview()
+
+@state.change("uploaded_file_info")
+def handle_file_upload(uploaded_file_info, **kwargs):
+    if uploaded_file_info:
+        file_name = uploaded_file_info.get("name", "unknown file")
+        print(f"File selected (dummy upload): {file_name}")
+        state.show_upload_dialog = False
+        state.upload_status_message = f"File '{file_name}' uploaded."
+        state.show_upload_status = True
+
+def update_excitation_info_message():
+    """Calculates and displays the coordinate snapping message."""
+    if state.nx is None or state.dist_type is None:
+        state.excitation_info_message = ""
+        return
+
+    try:
+        nx = int(state.nx)
+        denom = float(max(nx - 1, 1))
+        
+        if state.dist_type == "Delta":
+            x_in, y_in = float(state.impulse_x), float(state.impulse_y)
+        elif state.dist_type == "Gaussian":
+            x_in, y_in = float(state.mu_x), float(state.mu_y)
+        else:
+            state.excitation_info_message = ""
+            return
+
+        ix, iy = _nearest_node_index(x_in, y_in, nx)
+        x_snapped, y_snapped = ix / denom, iy / denom
+        
+        if abs(x_in - x_snapped) > 1e-9 or abs(y_in - y_snapped) > 1e-9:
+            state.excitation_info_message = f"Input ({x_in:.3f}, {y_in:.3f}) adjusted to nearest grid point ({x_snapped:.3f}, {y_snapped:.3f})."
+        else:
+            state.excitation_info_message = ""
+    except Exception:
+        state.excitation_info_message = ""
+
+@state.change("nx_slider_index")
+def on_slider_index_change(nx_slider_index, **kwargs):
+    if nx_slider_index is None:
+        state.nx = None
+    else:
+        try:
+            state.nx = int(GRID_SIZES[int(nx_slider_index)])
+        except Exception:
+            state.nx = None
+    update_excitation_info_message()
+
+@state.change("nx", "T", "dist_type", "impulse_x", "impulse_y", "mu_x", "mu_y", "sigma_x", "sigma_y", "coeff_permittivity", "coeff_permeability")
+def on_input_parameter_change(**kwargs):
+    # Do nothing while running
+    if state.is_running:
+        return
+
+    update_excitation_info_message()
+
+    changed_keys = set(kwargs.keys())
+
+    # If a simulation has already run, keep current results and only indicate re-run is needed
+    if state.simulation_has_run:
+        state.run_button_text = "Re-run Simulation"
+        return
+
+    # Before a run, update the initial preview only when relevant preview params changed
+    preview_params = {"nx", "dist_type", "impulse_x", "impulse_y", "mu_x", "mu_y", "sigma_x", "sigma_y"}
+    if changed_keys & preview_params:
+        update_initial_state_preview()
+
+@state.change("output_type", "timeseries_field", "timeseries_points")
+def on_output_config_change(**kwargs):
+    if state.simulation_has_run:
+        generate_plot()
+
+@state.change("surface_field")
+def on_surface_field_change(surface_field, **kwargs):
+    if state.simulation_has_run and state.output_type == "Surface Plot":
+        redraw_surface_plot()
+
+@state.change("time_val")
+def on_time_change(time_val, **kwargs):
+    if not state.simulation_has_run or state.output_type != "Surface Plot" or current_mesh is None or data_frames is None:
+        return
+    if snapshot_times is None or len(snapshot_times) == 0:
+        return
+    field = state.surface_field
+    # Find nearest snapshot index to requested time and clamp to available frames
+    times = np.asarray(snapshot_times)
+    idx = int(np.argmin(np.abs(times - float(time_val))))
+    max_idx = len(data_frames[field]) - 1
+    idx = max(0, min(idx, max_idx))
+    z_data = data_frames[field][idx]
+    if current_mesh.n_points == z_data.size:
+        current_mesh.points[:, 2] = z_data.ravel() * z_scale
+        current_mesh['scalars'] = z_data.ravel()
+        ctrl.view_update()
+    else:
+        redraw_surface_plot()
+    
+def update_value_display(point):
+    if current_mesh is None:
+        return
+    try:
+        plotter.remove_actor("value_text")
+    except Exception:
+        pass
+
+    closest_id = current_mesh.find_closest_point(point)
+    if closest_id == -1:
+        return
+
+    # Sample value and coordinates at closest vertex
+    value = current_mesh['scalars'][closest_id] if 'scalars' in current_mesh.array_names else 0.0
+    px, py, pz = current_mesh.points[closest_id]
+    px = float(px); py = float(py)
+
+    # Determine if current mesh is on unit square [0,1] (initial preview/geometry) or integer grid (output plots)
+    xmin, xmax, ymin, ymax, _, _ = current_mesh.bounds
+    is_unit_square = (xmax <= 1.00001 and ymax <= 1.00001)
+
+    if not state.simulation_has_run and is_unit_square:
+        # Disable updating inputs based on point picking
+        text = f"Position: ({px:.3f}, {py:.3f})\nValue: {value:.3e}"
+    else:
+        # Output configuration or integer-grid context: keep grid indices visible like app.py
+        nx_val = int(state.nx)
+        denom = max(float(nx_val - 1), 1.0)
+        if is_unit_square:
+            ix = int(round(px * denom)); iy = int(round(py * denom))
+            x_code = max(0.0, min(1.0, px)); y_code = max(0.0, min(1.0, py))
+        else:
+            ix = int(round(px)); iy = int(round(py))
+            x_code = max(0.0, min(1.0, px / denom)); y_code = max(0.0, min(1.0, py / denom))
+        ix = max(0, min(ix, nx_val - 1)); iy = max(0, min(iy, nx_val - 1))
+        if state.simulation_has_run:
+            time = float(state.time_val)
+            text = f"Index: ({ix}, {iy}) | Position: ({x_code:.3f}, {y_code:.3f})\nTime: {time:.2f}s\nValue: {value:.3e}"
+        else:
+            text = f"Index: ({ix}, {iy}) | Position: ({x_code:.3f}, {y_code:.3f})\nValue: {value:.3e}"
+
+    plotter.add_text(text, name="value_text", position="lower_left", color="black", font_size=10)
+    ctrl.view_update()
+
+try:
+    plotter.disable_picking()
+except Exception:
+    pass
+plotter.enable_point_picking(callback=update_value_display, show_message=False)
+
+def export_vtk():
+    """Export current surface mesh to user's Downloads as .vtp and notify via snackbar."""
+    global current_mesh
+    if current_mesh is None:
+        state.export_status_message = "No mesh to export."
+        state.show_export_status = True
+        return
+    try:
+        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
+        os.makedirs(dl_dir, exist_ok=True)
+        field = state.surface_field or "Ez"
+        nx = int(state.nx)
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        path = os.path.join(dl_dir, f"surface_{field}_nx{nx}_{suffix}.vtp")
+        current_mesh.save(path)
+        state.export_status_message = f"Exported VTK to {path}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    state.show_export_status = True
+
+def export_vtk_all_frames():
+    """Export a .vtp file for each time frame of the selected component into a timestamped folder in Downloads."""
+    global data_frames, X_grids, z_scale, snapshot_times
+    try:
+        if not state.simulation_has_run:
+            raise ValueError("Run a simulation before exporting all frames.")
+        field = state.surface_field or "Ez"
+        frames = data_frames.get(field)
+        if not frames:
+            raise ValueError(f"No frames available for {field}.")
+        if snapshot_times is None:
+            raise ValueError("Snapshot times are unavailable.")
+
+        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        nx = int(state.nx)
+        out_dir = os.path.join(dl_dir, f"vtk_sequence_{field}_nx{nx}_{suffix}")
+        os.makedirs(out_dir, exist_ok=True)
+
+        times = np.asarray(snapshot_times)
+        for i, (z_data, t) in enumerate(zip(frames, times)):
+            points = np.c_[X_grids[field].ravel(), Y_grids[field].ravel(), z_data.ravel() * z_scale]
+            poly = pv.PolyData(points)
+            mesh = poly.delaunay_2d()
+            mesh["scalars"] = z_data.ravel()
+            fname = f"{field}_frame_{i:04d}_t{t:.3f}s.vtp"
+            mesh.save(os.path.join(out_dir, fname))
+
+        state.export_status_message = f"Exported {len(frames)} frames to {out_dir}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True
+
+def export_mp4():
+    """Export the surface plot time slider animation to MP4 using a dedicated off-screen plotter."""
+    global data_frames
+    try:
+        if not state.simulation_has_run:
+            raise ValueError("Run a simulation before exporting MP4.")
+        field = state.surface_field or "Ez"
+        frames = data_frames.get(field)
+        if not frames:
+            raise ValueError(f"No frames available for {field}.")
+        if len(frames) < 2:
+            raise ValueError("Only one frame available; increase T or simulation steps.")
+
+        # Output path
+        dl_dir = os.path.join(os.path.expanduser("~"), "Downloads")
+        os.makedirs(dl_dir, exist_ok=True)
+        nx = int(state.nx)
+        suffix = datetime.now().strftime("%Y%m%d_%H%M%S")
+        path = os.path.join(dl_dir, f"surface_anim_{field}_nx{nx}_{suffix}.mp4")
+
+        # Build with a dedicated off-screen plotter at a macro-block friendly size
+        movie_plotter = pv.Plotter(off_screen=True, window_size=(1280, 720))
+
+        # Initial mesh from first frame
+        X = X_grids[field]
+        Y = Y_grids[field]
+        first = frames[0]
+        points = np.c_[X.ravel(), Y.ravel(), first.ravel() * z_scale]
+        poly = pv.PolyData(points)
+        mesh = poly.delaunay_2d()
+        mesh['scalars'] = first.ravel()
+        actor = movie_plotter.add_mesh(
+            mesh,
+            scalars='scalars',
+            clim=surface_clims[field],
+            cmap="RdBu",
+            show_scalar_bar=False,
+            show_edges=True,
+            edge_color='grey',
+            line_width=0.5,
+        )
+        movie_plotter.add_axes()
+        # Use similar camera if available, else default
+        try:
+            if hasattr(plotter, 'camera_position') and plotter.camera_position:
+                movie_plotter.camera_position = plotter.camera_position
+            else:
+                movie_plotter.view_isometric()
+        except Exception:
+            movie_plotter.view_isometric()
+
+        movie_plotter.open_movie(path, framerate=20)
+        n_frames = len(frames)
+        for z_data in frames:
+            if mesh.n_points != z_data.size:
+                # Rebuild mesh if topology changes (unlikely here)
+                points = np.c_[X.ravel(), Y.ravel(), z_data.ravel() * z_scale]
+                poly = pv.PolyData(points)
+                mesh = poly.delaunay_2d()
+                mesh['scalars'] = z_data.ravel()
+                movie_plotter.clear()
+                actor = movie_plotter.add_mesh(
+                    mesh,
+                    scalars='scalars',
+                    clim=surface_clims[field],
+                    cmap="RdBu",
+                    show_scalar_bar=False,
+                    show_edges=True,
+                    edge_color='grey',
+                    line_width=0.5,
+                )
+            else:
+                mesh.points[:, 2] = z_data.ravel() * z_scale
+                mesh['scalars'] = z_data.ravel()
+            movie_plotter.render()
+            movie_plotter.write_frame()
+        movie_plotter.close()
+
+        state.export_status_message = f"Exported MP4 to {path}"
+    except Exception as e:
+        state.export_status_message = f"Export failed: {e}"
+    finally:
+        state.show_export_status = True
+
+# --- Small Plot under Meshing: Qubit requirement vs Grid Size ---
+def build_qubit_plot(grid_size: int):
+    x_sizes = np.array([16, 32, 64, 128, 256, 512])
+    y_qubits = 2 * np.ceil(np.log2(x_sizes)).astype(int) + 3
+    current_nq = int(2 * np.ceil(np.log2(max(1, int(grid_size)))) + 3)
+
+    fig = go.Figure()
+    # Match app.py: x = grid size, y = total qubits
+    fig.add_trace(go.Scatter(x=x_sizes, y=y_qubits, mode='lines', name='Total Qubits', line=dict(color='#7A3DB5', width=3)))
+    fig.add_trace(go.Scatter(x=[grid_size], y=[current_nq], mode='markers', marker=dict(size=10, color='#5F259F'), name='Current Selection'))
+
+    x_min = int(x_sizes.min()); x_max = int(x_sizes.max())
+    y_min = int(y_qubits.min()); y_max = int(max(y_qubits.max(), current_nq))
+    fig.update_xaxes(range=[x_min - 8, x_max + 8], tickmode='array', tickvals=x_sizes, ticktext=[str(v) for v in x_sizes], title_text="Grid Size (nx)", gridcolor='rgba(95,37,159,0.1)', zerolinecolor='rgba(95,37,159,0.3)')
+    fig.update_yaxes(range=[y_min - 1, y_max + 1], dtick=1, title_text="Total Qubits (nq)", gridcolor='rgba(95,37,159,0.1)', zerolinecolor='rgba(95,37,159,0.3)')
+    fig.update_layout(
+        margin=dict(l=30, r=10, t=10, b=30),
+        autosize=True,
+        legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1),
+        font=dict(color='#1A1A1A'),
+        paper_bgcolor='#FFFFFF',
+        plot_bgcolor='#FFFFFF',
+        colorway=['#5F259F', '#7A3DB5', '#AE8BD8', '#5F259F'],
+    )
+    return fig
+
+# --- UI Layout ---
+with SinglePageLayout(server) as layout:
+    layout.title.set_text("ELECTROMAGNETIC SCATTERING")
+    # Synopsys branding: primary purple + shades, white surface, dark text
+    layout.title.style = "color: #5f259f; font-weight: 600;"
+    layout.toolbar.classes = "pl-2 pr-1 py-1 elevation-0"
+    layout.toolbar.style = "background-color: #ffffff; border-bottom: 3px solid #5f259f;"
+    trame_html.Style(
+        """
+        :root{
+          --v-theme-primary: 95, 37, 159;       /* #5F259F */
+          --v-theme-secondary: 122, 61, 181;    /* #7A3DB5 */
+          --v-theme-accent: 174, 139, 216;      /* #AE8BD8 */
+          --v-theme-surface: 255, 255, 255;     /* #FFFFFF */
+          --v-theme-background: 255, 255, 255;  /* #FFFFFF */
+          --v-theme-on-primary: 255, 255, 255;  /* #FFFFFF */
+          --v-theme-on-surface: 26, 26, 26;     /* #1A1A1A */
+        }
+        .syn-title{ color:#5f259f !important; }
+        .syn-border-bottom{ border-bottom:3px solid #5f259f !important; }
+        .syn-bg-white{ background:#ffffff !important; }
+        /* Synopsys UI refinements */
+        a, .syn-link { color: #5f259f; text-decoration: none; }
+        a:hover, .syn-link:hover { color: #7A3DB5; text-decoration: underline; }
+        .v-list .v-list-item:hover { background-color: rgba(95,37,159,.08) !important; }
+        .v-list-item--active { background-color: rgba(95,37,159,.16) !important; color: #5f259f !important; }
+        """
+    )
+    with layout.toolbar:
+        vuetify3.VSpacer()
+        vuetify3.VImg(
+            v_if="logo_src",
+            src=("logo_src", None),
+            style="height: 56px; width: auto; margin-right: 0px;",
+            classes="mr-0",
+        )
+    with layout.content:
+        with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
+            with vuetify3.VDialog(v_model=("show_upload_dialog", False), max_width="500px"):
+                with vuetify3.VCard():
+                    vuetify3.VCardTitle("Upload Geometry")
+                    with vuetify3.VCardText():
+                        vuetify3.VFileInput(
+                            show_size=True,
+                            label="Select geometry file",
+                            accept=".vtp,.vtk,.glb,.stl",
+                            update_binary=("uploaded_file_info", 1),
+                        )
+                    with vuetify3.VCardActions():
+                        vuetify3.VSpacer()
+                        vuetify3.VBtn("Cancel", click="show_upload_dialog = false")
+
+            vuetify3.VSnackbar(
+                v_model=("show_upload_status", False),
+                children=["{{ upload_status_message }}"],
+                timeout=4000,
+                location="bottom right",
+                color="primary",
+                variant="tonal",
+            )
+            vuetify3.VSnackbar(
+                v_model=("show_export_status", False),
+                children=["{{ export_status_message }}"],
+                timeout=4000,
+                location="bottom right",
+                color="primary",
+                variant="tonal",
+            )
+
+            with vuetify3.VRow(no_gutters=True, classes="fill-height"):
+                with vuetify3.VCol(cols=5, classes="pa-4 d-flex flex-column"):
+                    # Cell 1: Introduction
+                    with vuetify3.VCard(classes="mb-4"):
+                        with vuetify3.VCardTitle("Overview", classes="text-h5 font-weight-bold text-primary"):
+                            pass
+                        with vuetify3.VCardText():
+                            # Removed subtitle and restyled sections
+                            vuetify3.VDivider(classes="my-2")
+                            vuetify3.VCardSubtitle("Problem", classes="text-subtitle-1 font-weight-bold mt-2")
+                            vuetify3.VDivider(classes="mb-1")
+                            vuetify3.VList(
+                                density="compact",
+                                lines="one",
+                                items=(
+                                    "intro_items_problem",
+                                    [
+                                        {"title": "1. Propagation in a given medium (no bodies)"},
+                                        {"title": "2. Scattering from a perfectly conducting body"},
+                                    ],
+                                ),
+                            )
+                            vuetify3.VCardSubtitle("Governing Equations", classes="text-subtitle-1 font-weight-bold mt-2")
+                            vuetify3.VDivider(classes="mb-1")
+                            vuetify3.VListItemTitle("Maxwell’s time-domain, 2D, TEz polarized.", classes="text-body-2")
+                            vuetify3.VCardSubtitle("Inputs", classes="text-subtitle-1 font-weight-bold mt-2")
+                            vuetify3.VDivider(classes="mb-1")
+                            vuetify3.VListItemTitle("Geometry, excitation, medium, output visualization preferences.", classes="text-body-2")
+                            vuetify3.VCardSubtitle("Outputs", classes="text-subtitle-1 font-weight-bold mt-2")
+                            vuetify3.VDivider(classes="mb-1")
+                            vuetify3.VListItemTitle("Surface plots of field components OR time evolution of field components at specified points.", classes="text-body-2")
+                    # Cell 2: Geometry
+                    with vuetify3.VCard(classes="mb-4"):
+                        with vuetify3.VCardTitle("Geometry", classes="text-primary"):
+                            pass
+                        with vuetify3.VCardText():
+                            vuetify3.VSelect(
+                                label="Select",
+                                v_model=("geometry_selection", None),
+                                items=("geometry_options", ["None", "Square Metallic Body", "Square Domain", "Geometry 2", "Add"]),
+                                placeholder="Select",
+                                density="compact",
+                                color="primary",
+                            )
+                            with vuetify3.VContainer(v_if="geometry_selection === 'Square Metallic Body'", classes="pa-0 mt-2"):
+                                with vuetify3.VRow(dense=True):
+                                    with vuetify3.VCol():
+                                        with vuetify3.VTooltip("Square hole edge length s in domain units [0,1]. Must be ≤ 1. UI-only.", location="bottom", color="primary"):
+                                            with vuetify3.Template(v_slot_activator="{ props }"):
+                                                vuetify3.VTextField(
+                                                    v_bind="props",
+                                                    v_model=("hole_size_edge", 0.2),
+                                                    label="Hole Edge Length [0 - 1]",
+                                                    type="number",
+                                                    step=0.05,
+                                                    min=0,
+                                                    density="compact",
+                                                    color="primary",
+                                                )
+                                    with vuetify3.VCol():
+                                        with vuetify3.VTooltip("Hole center as (x, y). Both x and y must be strictly within (0,1). Example: (0.5, 0.5). UI-only.", location="bottom", color="primary"):
+                                            with vuetify3.Template(v_slot_activator="{ props }"):
+                                                vuetify3.VTextField(
+                                                    v_bind="props",
+                                                    v_model=("hole_center_pair", "(0.5, 0.5)"),
+                                                    label="Hole Center (X, Y)",
+                                                    density="compact",
+                                                    color="primary",
+                                                )
+                                with vuetify3.VRow(dense=True, classes="mt-1"):
+                                    with vuetify3.VCol(cols=12):
+                                        vuetify3.VSwitch(
+                                            v_model=("hole_snap", True),
+                                            label="Snap edges to nearest grid lines",
+                                            color="primary",
+                                            inset=True,
+                                            density="compact",
+                                        )
+                                vuetify3.VAlert(
+                                    v_if="hole_error_message",
+                                    type="error",
+                                    variant="tonal",
+                                    density="compact",
+                                    children=["{{ hole_error_message }}"],
+                                    classes="mt-2",
+                                )
+                    # Restoring all subsequent input cards
+                    # Cell 4: Excitation
+                    with vuetify3.VCard(classes="mb-4"):
+                        with vuetify3.VCardTitle("Excitation: Initial State", classes="text-primary"):
+                            pass
+                        with vuetify3.VCardText():
+                            vuetify3.VSelect(
+                                label="Select",
+                                v_model=("dist_type", None),
+                                items=("dist_type_options", ["None", "Delta", "Gaussian"]),
+                                placeholder="Select",
+                                density="compact",
+                                color="primary",
+                            )
+                            with vuetify3.VContainer(v_if="dist_type === 'Delta'", classes="pa-0"):
+                                with vuetify3.VTooltip("Impulse position (x, y) in [0,1]. Example: (0.6, 0.6).", location="bottom", color="primary"):
+                                    with vuetify3.Template(v_slot_activator="{ props }"):
+                                        vuetify3.VTextField(v_bind="props", v_model=("peak_pair", "(0.5, 0.5)"), label="Peak (x, y) in [0,1]", density="compact", color="primary")
+                            with vuetify3.VContainer(v_if="dist_type === 'Gaussian'", classes="pa-0"):
+                                with vuetify3.VRow(dense=True):
+                                    with vuetify3.VCol():
+                                        with vuetify3.VTooltip("Gaussian center μ (x, y) in [0,1]. Example: (0.5, 0.5).", location="bottom", color="primary"):
+                                            with vuetify3.Template(v_slot_activator="{ props }"):
+                                                vuetify3.VTextField(v_bind="props", v_model=("mu_pair", "(0.5, 0.5)"), label="Mu (x, y) in [0,1]", density="compact", color="primary")
+                                # Separate Sigma inputs (normalized)
+                                with vuetify3.VRow(dense=True, classes="mt-1"):
+                                    with vuetify3.VCol():
+                                        with vuetify3.VTooltip("Gaussian spread σx in [0,1] of domain length.", location="bottom", color="primary"):
+                                            with vuetify3.Template(v_slot_activator="{ props }"):
+                                                vuetify3.VTextField(v_bind="props", v_model=("sigma_x", 0.25), label="Sigma X (0–1)", type="number", step="0.01", density="compact", color="primary")
+                                    with vuetify3.VCol():
+                                        with vuetify3.VTooltip("Gaussian spread σy in [0,1] of domain length.", location="bottom", color="primary"):
+                                            with vuetify3.Template(v_slot_activator="{ props }"):
+                                                vuetify3.VTextField(v_bind="props", v_model=("sigma_y", 0.15), label="Sigma Y (0–1)", type="number", step="0.01", density="compact", color="primary")
+                                vuetify3.VAlert(v_if="excitation_error_message", type="error", variant="tonal", density="compact", children=["{{ excitation_error_message }}"], classes="mt-2")
+                                vuetify3.VAlert(
+                                    v_if="excitation_info_message",
+                                    type="info",
+                                    variant="tonal",
+                                    density="compact",
+                                    children=["{{ excitation_info_message }}"],
+                                    classes="mt-2",
+                                )
+
+                    # Cell 5: Medium
+                    with vuetify3.VCard(classes="mb-4"):
+                        with vuetify3.VCardTitle("Material Properties (Medium)", classes="text-primary"):
+                            pass
+                        with vuetify3.VCardText():
+                            with vuetify3.VRow(dense=True):
+                                with vuetify3.VCol():
+                                    with vuetify3.VTooltip("Relative permittivity. ε_r = ε / ε₀. Default 1.0 (free space).", location="bottom", color="primary"):
+                                        with vuetify3.Template(v_slot_activator="{ props }"):
+                                            vuetify3.VTextField(v_bind="props", v_model=("coeff_permittivity", 1.0), label="Relative permittivity (ε_r)", type="number", density="compact", color="primary")
+                                with vuetify3.VCol():
+                                    with vuetify3.VTooltip("Relative permeability. μ_r = μ / μ₀. Typically 1.0 for non-magnetic materials.", location="bottom", color="primary"):
+                                        with vuetify3.Template(v_slot_activator="{ props }"):
+                                            vuetify3.VTextField(v_bind="props", v_model=("coeff_permeability", 1.0), label="Relative permeability (μ_r)", type="number", density="compact", color="primary")
+
+                    # New Cell: Temporal Settings (moved here)
+                    with vuetify3.VCard(classes="mb-4"):
+                        with vuetify3.VCardTitle("Temporal Settings", classes="text-primary"):
+                            pass
+                        with vuetify3.VCardText():
+                            with vuetify3.VTooltip("Sets the total duration for the simulation to run.", location="bottom", color="primary"):
+                                with vuetify3.Template(v_slot_activator="{ props }"):
+                                    vuetify3.VTextField(v_bind="props", v_model=("T", 1.0), label="Total Time (T)", type="number", step="0.1", density="compact", color="primary")
+                            # Small bold heading before Δt input
+                            vuetify3.VCardSubtitle("Select Δt intervals for plotting output snapshots", classes="text-subtitle-2 font-weight-bold mt-2")
+                            with vuetify3.VTooltip("Snapshot interval (Δt). Solver runs at fixed 0.1 s; frames are saved every Δt. Values < 0.1 or not multiples of 0.1 are unsupported.", location="bottom", color="primary"):
+                                with vuetify3.Template(v_slot_activator="{ props }"):
+                                    vuetify3.VTextField(v_bind="props", v_model=("dt_user", 0.1), label="Δt", type="number", step="0.1", density="compact", color="primary", classes="mt-2")
+                            vuetify3.VAlert(v_if="temporal_warning", type="warning", variant="tonal", density="compact", children=["{{ temporal_warning }}"], classes="mt-2")
+                    # Moved Meshing card: now under Temporal Settings and before Backends
+                    with vuetify3.VCard(classes="mb-4"):
+                        with vuetify3.VCardTitle("Meshing", classes="text-primary"):
+                            pass
+                        with vuetify3.VCardText():
+                            # Show the qubit graph only while hovering over the slider (like app.py)
+                            with vuetify3.VMenu(open_on_hover=True, close_on_content_click=False, location="end", offset=8):
+                                with vuetify3.Template(v_slot_activator="{ props }"):
+                                    with vuetify3.VSlider(
+                                        v_bind="props",
+                                        v_model=("nx_slider_index", None),
+                                        label="No. of points per direction:",
+                                        min=0,
+                                        max=5,
+                                        step=1,
+                                        show_ticks="always",
+                                        thumb_label="always",
+                                        density="compact",
+                                        color="primary",
+                                    ):
+                                        vuetify3.Template(v_slot_thumb_label="{ modelValue }", children=["{{ modelValue === null ? 'Select' : [16, 32, 64, 128, 256, 512][modelValue] }}"])
+                                # Hover content: enlarged Plotly graph with app.py axes (x=nx, y=nq)
+                                with vuetify3.VSheet(classes="pa-2", elevation=6, rounded=True, style="width: 644px;"):
+                                    qubit_fig_widget = plotly_widgets.Figure(
+                                        figure=build_qubit_plot(int(state.nx or 16)),
+                                        responsive=True,
+                                        style="width: 616px; height: 364px; min-height: 364px;",
+                                    )
+                    # Cell: Backends (from app.py)
+                    with vuetify3.VCard(classes="mb-4"):
+                        with vuetify3.VCardTitle("Backends", classes="text-primary"):
+                            pass
+                        with vuetify3.VCardText():
+                            with vuetify3.VRow(dense=True, classes="mb-2"):
+                                with vuetify3.VCol():
+                                    vuetify3.VAlert(
+                                        type="info",
+                                        color="primary",
+                                        variant="tonal",
+                                        density="compact",
+                                        children=[
+                                            "Selected: ",
+                                            "{{ backend_type || '—' }}",
+                                            " - ",
+                                            "{{ backend_type === 'Simulator' ? selected_simulator : (backend_type === 'QPU' ? selected_qpu : '—') }}",
+                                        ],
+                                    )
+                            with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end"):
+                                with vuetify3.Template(v_slot_activator="{ props }"):
+                                    vuetify3.VBtn(v_bind="props", text="Choose Backend", color="primary", variant="tonal", block=True)
+                                with vuetify3.VList(density="compact"):
+                                    with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
+                                        with vuetify3.Template(v_slot_activator="{ props }"):
+                                            vuetify3.VListItem(v_bind="props", title="Simulator", prepend_icon="mdi-robot-outline", append_icon="mdi-chevron-right")
+                                        with vuetify3.VList(density="compact"):
+                                            vuetify3.VListItem(title="IBM Qiskit simulator", click="backend_type = 'Simulator'; selected_simulator = 'IBM Qiskit simulator'")
+                                            vuetify3.VListItem(title="IonQ simulator", click="backend_type = 'Simulator'; selected_simulator = 'IonQ simulator'")
+                                    with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end", offset=8):
+                                        with vuetify3.Template(v_slot_activator="{ props }"):
+                                            vuetify3.VListItem(v_bind="props", title="QPU", prepend_icon="mdi-chip", append_icon="mdi-chevron-right")
+                                        with vuetify3.VList(density="compact"):
+                                            vuetify3.VListItem(title="IBM QPU", click="backend_type = 'QPU'; selected_qpu = 'IBM QPU'")
+                                            vuetify3.VListItem(title="IonQ QPU", click="backend_type = 'QPU'; selected_qpu = 'IonQ QPU'")
+
+                    # Run Simulation and Stop Buttons Row
+                    with vuetify3.VRow(dense=True, classes="mb-2"):
+                        with vuetify3.VCol(cols=9):
+                            with vuetify3.VTooltip("Starts the quantum simulation with the specified parameters. This may take some time.", location="bottom", color="primary"):
+                                with vuetify3.Template(v_slot_activator="{ props }"):
+                                    vuetify3.VBtn(
+                                        v_bind="props",
+                                        text=("run_button_text", "Run Simulation"),
+                                        click=run_simulation_only,
+                                        color="primary",
+                                        block=True,
+                                        disabled=("is_running || run_button_text === 'Successful!' || !geometry_selection || !dist_type || !!temporal_warning || nx === null", False),
+                                    )
+                        with vuetify3.VCol(cols=3):
+                            with vuetify3.VTooltip("Stop the running simulation", location="bottom", color="primary"):
+                                with vuetify3.Template(v_slot_activator="{ props }"):
+                                    vuetify3.VBtn(
+                                        v_bind="props",
+                                        text="Stop",
+                                        click=stop_simulation_handler,
+                                        color="error",
+                                        block=True,
+                                        disabled=("stop_button_disabled", True),
+                                    )
+                    
+                    # Reset Button
+                    with vuetify3.VTooltip("Reset all parameters to their default values", location="bottom", color="primary"):
+                        with vuetify3.Template(v_slot_activator="{ props }"):
+                            vuetify3.VBtn(
+                                v_bind="props",
+                                text="Reset",
+                                click=reset_to_defaults,
+                                color="secondary",
+                                block=True,
+                                classes="mt-auto"
+                            )
+                
+                # Main graph column
+                with vuetify3.VCol(cols=7, classes="pa-4 d-flex flex-column"):
+                    # Output Configuration (appears after simulation)
+                    with vuetify3.VCard(v_if="simulation_has_run", classes="mb-4"):
+                        with vuetify3.VCardSubtitle("Output Configuration", classes="text-primary"):
+                            with vuetify3.VCardText():
+                                with vuetify3.VRadioGroup(v_model=("output_type", "Surface Plot"), row=True, density="compact", color="primary"):
+                                    vuetify3.VRadio(label="Surface", value="Surface Plot")
+                                    vuetify3.VRadio(label="Time Series", value="Time Series Plot")
+                                with vuetify3.VContainer(v_if="output_type === 'Surface Plot'", classes="pa-0"):
+                                    vuetify3.VSelect(v_model=("surface_field", "Ez"), items=("surface_field_options", ["Ez", "Hx", "Hy"]), label="Field Component", density="compact", color="primary")
+                                    # Replace export format dropdown and individual buttons with a single Export menu
+                                    with vuetify3.VMenu(open_on_hover=True, close_on_content_click=True, location="end"):
+                                        with vuetify3.Template(v_slot_activator="{ props }"):
+                                            vuetify3.VBtn(v_bind="props", text="Export", color="primary", variant="tonal", block=True, classes="mt-2")
+                                        with vuetify3.VList(density="compact"):
+                                            vuetify3.VListSubheader("VTK")
+                                            vuetify3.VListItem(title="Current frame (VTK)", prepend_icon="mdi-download", click=export_vtk)
+                                            vuetify3.VListItem(title="All frames (VTK sequence)", prepend_icon="mdi-download-multiple", click=export_vtk_all_frames)
+                                            vuetify3.VDivider()
+                                            vuetify3.VListItem(title="Animation (MP4)", prepend_icon="mdi-movie", click=export_mp4)
+                                with vuetify3.VContainer(v_if="output_type === 'Time Series Plot'", classes="pa-0"):
+                                    vuetify3.VSelect(v_model=("timeseries_field", "Ez"), items=("timeseries_field_options", ["Ez", "Hx", "Hy"]), label="Field Component", density="compact", color="primary")
+                                    vuetify3.VTextarea(v_model=("timeseries_points", "(8, 8), (10, 8)"), label="Monitor Points", hint="e.g., (8, 8), (10, 8)", rows=2, auto_grow=True, color="primary")
+
+                    # Main plot area (hidden until geometry selected)
+                    with vuetify3.VCard(v_if="geometry_selection", classes="flex-grow-1", style="min-height: 0;"):
+                        with vuetify3.VContainer(v_if="is_running", fluid=True, classes="fill-height d-flex flex-column align-center justify-center"):
+                            vuetify3.VProgressCircular(indeterminate=True, size=64, color="primary")
+                            vuetify3.VCardSubtitle("Running simulation...", classes="mt-4")
+                        with vuetify3.VContainer(v_if="!is_running", fluid=True, classes="fill-height pa-0", style=("pyvista_view_style", "aspect-ratio: 1 / 1; width: 100%;")):
+                            view = plotter_ui(plotter)
+                            ctrl.view_update = view.update
+
+                    # Placeholder when no geometry selected
+                    with vuetify3.VContainer(v_if="!geometry_selection", fluid=True, classes="flex-grow-1 d-flex align-center justify-center text-medium-emphasis"):
+                        vuetify3.VCardText("Select a geometry to display the preview and results.")
+                    
+                    # Time slider for surface plot (restored to right panel)
+                    with vuetify3.VContainer(v_if="simulation_has_run && output_type === 'Surface Plot'", fluid=True, classes="pa-0 mt-4"):
+                        vuetify3.VSlider(v_model=("time_val", 0.0), label="Time", min=0, max=("T", 10.0), step=("dt_user", 0.1), thumb_label="always", density="compact", color="primary")
+
+# Store the widget's update method in the controller for later updates
+ctrl.qubit_plot_update = qubit_fig_widget.update
+
+@state.change("nx")
+def update_qubit_plot(nx, **kwargs):
+    try:
+        ctrl.qubit_plot_update(build_qubit_plot(int(nx)))
+    except Exception:
+        pass
+
+@state.change("hole_size_edge", "hole_center_x", "hole_center_y", "geometry_selection", "hole_snap")
+def validate_hole_inputs(**kwargs):
+    # Only validate when Square Metallic Body is selected
+    if state.geometry_selection != "Square Metallic Body":
+        state.hole_error_message = ""
+        return
+    try:
+        s = float(state.hole_size_edge)
+        cx = float(state.hole_center_x)
+        cy = float(state.hole_center_y)
+    except Exception:
+        state.hole_error_message = "Hole size and center must be numeric."
+        return
+
+    # Use selected nx, fall back to a safe default when not selected yet
+    try:
+        nx = int(state.nx or 32)
+    except Exception:
+        nx = 32
+
+    if s > 1.0:
+        state.hole_error_message = "Hole edge length must be <= 1."
+        return
+    if not (0.0 < cx < 1.0) or not (0.0 < cy < 1.0):
+        state.hole_error_message = "Hole center must be strictly within (0, 1) for both X and Y."
+        return
+
+    # Alignment check (strict vs snap)
+    mode_snap = bool(state.hole_snap)
+    edges = _compute_hole_edges(nx, cx, cy, s, snap=mode_snap)
+    if edges is None and not mode_snap:
+        h = _grid_spacing(nx)
+        state.hole_error_message = f"Strict alignment failed: edges must lie on grid lines k·h, h=1/(nx-1) ≈ {h:.4f}."
+        return
+
+    state.hole_error_message = ""
+
+    # Refresh preview if applicable
+    if state.geometry_selection == "Square Metallic Body" and not state.is_running and not state.simulation_has_run:
+        update_geometry_hole_preview()
+
+def _grid_spacing(nx: int) -> float:
+    return 1.0 / float(max(int(nx) - 1, 1))
+
+
+def _is_on_grid(val: float, h: float, atol: float = 1e-9) -> bool:
+    r = val / h
+    return abs(r - round(r)) <= atol
+
+
+def _snap_to_grid(val: float, h: float) -> float:
+    return round(val / h) * h
+
+
+def _compute_hole_edges(nx: int, cx: float, cy: float, a: float, snap: bool, atol: float = 1e-9):
+    """
+    Build requested open rectangle edges from center (cx, cy) and size a, then either
+    validate (strict) or quantize (snap) to grid P = {k*h} with h = 1/(nx-1).
+    Returns (xL, xR, yB, yT) or None if strict alignment fails.
+    """
+    h = _grid_spacing(nx)
+    # Requested edges
+    xL_req, xR_req = cx - a / 2.0, cx + a / 2.0
+    yB_req, yT_req = cy - a / 2.0, cy + a / 2.0
+
+    # Keep edges within (0,1) for numerical stability; open set semantics unchanged
+    eps = 1e-12
+    xL_req = max(eps, min(1.0 - eps, xL_req))
+    xR_req = max(eps, min(1.0 - eps, xR_req))
+    yB_req = max(eps, min(1.0 - eps, yB_req))
+    yT_req = max(eps, min(1.0 - eps, yT_req))
+
+    if not snap:
+        ok = all(_is_on_grid(v, h, atol) for v in (xL_req, xR_req, yB_req, yT_req))
+        if not ok:
+            return None
+        return xL_req, xR_req, yB_req, yT_req
+
+    # Snap each edge independently
+    xL, xR = _snap_to_grid(xL_req, h), _snap_to_grid(xR_req, h)
+    yB, yT = _snap_to_grid(yB_req, h), _snap_to_grid(yT_req, h)
+
+    # Ensure proper ordering and minimum width/height (at least one cell)
+    if xL >= xR:
+        cx_idx = round(cx / h)
+        xL = max(h, (cx_idx - 1) * h)
+        xR = min(1.0 - h, (cx_idx + 1) * h)
+    if yB >= yT:
+        cy_idx = round(cy / h)
+        yB = max(h, (cy_idx - 1) * h)
+        yT = min(1.0 - h, (cy_idx + 1) * h)
+
+    # Clamp into (0,1)
+    xL = max(eps, min(1.0 - eps, xL))
+    xR = max(eps, min(1.0 - eps, xR))
+    yB = max(eps, min(1.0 - eps, yB))
+    yT = max(eps, min(1.0 - eps, yT))
+
+    if xL < xR and yB < yT:
+        return xL, xR, yB, yT
+    return None
+
+@state.change("hole_center_pair")
+def sync_hole_center_pair(hole_center_pair, **kwargs):
+    """Parse bracket-format pair (x, y) from dropdown into numeric center fields."""
+    try:
+        m = re.match(r"\(\s*([0-9]*\.?[0-9]+)\s*,\s*([0-9]*\.?[0-9]+)\s*\)", str(hole_center_pair))
+        if not m:
+            raise ValueError("Invalid format")
+        state.hole_center_x = float(m.group(1))
+        state.hole_center_y = float(m.group(2))
+        # Defer range validation to validate_hole_inputs
+    except Exception:
+        state.hole_error_message = "Invalid hole center. Use format (x, y)."
+
+@state.change("sigma_pair")
+def sync_sigma_pair(sigma_pair, **kwargs):
+    """Parse bracket-format pair (x, y) for Sigma and update sigma_x/sigma_y."""
+    try:
+        m = re.match(r"\(\s*([-+]?[0-9]*\.?[0-9]+)\s*,\s*([-+]?[0-9]*\.?[0-9]+)\s*\)", str(sigma_pair))
+        if not m:
+            raise ValueError("Invalid format")
+        x = max(0.0, min(1.0, float(m.group(1))))
+        y = max(0.0, min(1.0, float(m.group(2))))
+        state.sigma_x = x
+        state.sigma_y = y
+        state.excitation_error_message = ""
+    except Exception:
+        state.excitation_error_message = "Invalid Sigma. Use format (x, y) in [0,1]."
+
+@state.change("dist_type")
+def normalize_dist_type(dist_type, **kwargs):
+    # Allow unselecting via 'None'
+    if dist_type in (None, "", "None"):
+        state.dist_type = None
+        update_initial_state_preview()
+    update_excitation_info_message()
+
+@state.change("dt_user")
+def validate_dt_user(dt_user, **kwargs):
+    """Validate snapshot Δt: must be >= 0.1 (solver dt) and a multiple of 0.1."""
+    try:
+        dt_val = float(dt_user)
+    except Exception:
+        state.temporal_warning = "Δt must be numeric. Frames are captured every Δt."
+        return
+    tol = 1e-9
+    if dt_val < 0.1 - tol:
+        state.temporal_warning = "Δt < 0.1 is unsupported (solver dt = 0.1 s)."
+    elif abs((dt_val / 0.1) - round(dt_val / 0.1)) > 1e-9:
+        state.temporal_warning = "Δt must be a multiple of 0.1 s."
+    else:
+        state.temporal_warning = ""
+
+# --- Initial Setup Call ---
+update_initial_state_preview()
+
+server.start()
+
+
+

delta_impulse_generator.py

@@ -0,0 +1,360 @@
+import numpy as np
+from qiskit.circuit import QuantumCircuit, QuantumRegister
+from qiskit.circuit.library import StatePreparation, QFTGate, RZGate
+from qiskit.quantum_info import Statevector
+import pyvista as pv
+
+def create_impulse_state(grid_dims, impulse_pos):
+    """
+    Creates an initial state vector with a single delta impulse at a specified grid position.
+
+    The 2D grid is flattened into a 1D vector in row-major order, and this
+    vector is then padded to match the full simulation state space size (4x).
+
+    Args:
+        grid_dims (tuple): A tuple (width, height) defining the simulation grid dimensions.
+                           For your original code, this would be (nx, nx).
+        impulse_pos (tuple): A tuple (x, y) for the position of the impulse.
+                             Coordinates are 0-indexed.
+
+    Returns:
+        numpy.ndarray: The full, padded initial state vector with a single 1.
+    
+    Raises:
+        ValueError: If the impulse position is outside the grid dimensions.
+    """
+    grid_width, grid_height = grid_dims
+    impulse_x, impulse_y = impulse_pos
+
+    # --- Input Validation ---
+    # Ensure the requested impulse position is actually on the grid.
+    if not (0 <= impulse_x < grid_width and 0 <= impulse_y < grid_height):
+        raise ValueError(f"Impulse position ({impulse_x}, {impulse_y}) is outside the "
+                         f"grid dimensions ({grid_width}x{grid_height}).")
+
+    # --- 1. Calculate the 1D Array Index ---
+    # Convert the (x, y) coordinate to a single index in a flattened 1D array.
+    # The formula for row-major order is: index = y_coord * width + x_coord
+    flat_index = impulse_y * grid_width + impulse_x
+
+    # --- 2. Create the Full, Padded State Vector ---
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size  # The simulation space is 4x the grid size.
+    initial_state = np.zeros(total_size)
+
+    # --- 3. Set the Delta Impulse ---
+    initial_state[flat_index] = 1
+
+    return initial_state
+
+def create_gaussian_state(grid_dims, mu, sigma):
+    """
+    Creates an initial state vector with a 2D Gaussian distribution.
+
+    The state is normalized and padded to match the full simulation state space size (4x).
+
+    Args:
+        grid_dims (tuple): A tuple (width, height) defining the grid dimensions.
+        mu (tuple): A tuple (mu_x, mu_y) for the center (mean) of the Gaussian.
+        sigma (tuple): A tuple (sigma_x, sigma_y) for the standard deviation (spread).
+
+    Returns:
+        numpy.ndarray: The full, padded initial state vector for the Gaussian state.
+
+    Raises:
+        ValueError: If sigma values are not positive.
+    """
+    grid_width, grid_height = grid_dims
+    mu_x, mu_y = mu
+    sigma_x, sigma_y = sigma
+
+    if sigma_x <= 0 or sigma_y <= 0:
+        raise ValueError("Sigma values (spread) must be positive.")
+
+    # --- 1. Create a Coordinate Grid ---
+    x = np.arange(0, grid_width)
+    y = np.arange(0, grid_height)
+    X, Y = np.meshgrid(x, y)
+
+    # --- 2. Calculate the 2D Gaussian Function ---
+    gaussian_2d = np.exp(-((X - mu_x)**2 / (2 * sigma_x**2)) - 
+                         ((Y - mu_y)**2 / (2 * sigma_y**2)))
+
+    # --- 3. Normalize the State Vector ---
+    # For a valid quantum state, the L2 norm (sum of squares of amplitudes) must be 1.
+    norm = np.linalg.norm(gaussian_2d)
+    if norm > 0:
+        gaussian_2d = gaussian_2d / norm
+    
+    # --- 4. Flatten and Pad the Vector ---
+    gaussian_flat = gaussian_2d.flatten()
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size
+    initial_state = np.pad(gaussian_flat, (0, total_size - grid_size), mode='constant')
+
+    return initial_state
+
+
+
+
+
+# --- New: Continuous-position helpers for excitation before meshing ---
+def _normalize_to_unit(vec: np.ndarray) -> np.ndarray:
+    n = np.linalg.norm(vec)
+    return vec / n if n > 0 else vec
+
+
+
+
+def create_impulse_state_from_pos(grid_dims, pos01):
+    """
+    Create a delta-like initial state from continuous position pos01=(x,y) in [0,1].
+
+    Why grid_dims?
+    - Simulation runs on a discrete nx×ny lattice; the continuous position must be
+      discretized onto that grid to produce the state vector fed into the solver.
+    - grid_dims provides (nx, ny) so we can map (x,y)∈[0,1]→grid coordinates via
+      gx = x*(nx-1), gy = y*(ny-1), then distribute amplitude bilinearly to the 4
+      neighboring nodes. This is required only for the simulation state, not the preview.
+
+    The preview uses create_impulse_preview_state(), which renders a smooth bump on a
+    fixed unit-square grid independent of nx for visualization.
+    """
+    grid_width, grid_height = grid_dims
+    px, py = pos01
+    px = float(max(0.0, min(1.0, px)))
+    py = float(max(0.0, min(1.0, py)))
+
+    gx = px * (grid_width - 1)
+    gy = py * (grid_height - 1)
+    i0, j0 = int(np.floor(gx)), int(np.floor(gy))
+    i1, j1 = min(i0 + 1, grid_width - 1), min(j0 + 1, grid_height - 1)
+    dx, dy = gx - i0, gy - j0
+
+    w00 = (1 - dx) * (1 - dy)
+    w10 = dx * (1 - dy)
+    w01 = (1 - dx) * dy
+    w11 = dx * dy
+
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size
+    field = np.zeros(grid_size)
+    field[j0 * grid_width + i0] += w00
+    field[j0 * grid_width + i1] += w10
+    field[j1 * grid_width + i0] += w01
+    field[j1 * grid_width + i1] += w11
+    field = _normalize_to_unit(field)
+
+    initial_state = np.zeros(total_size)
+    initial_state[:grid_size] = field
+    return initial_state
+
+
+def create_gaussian_state_from_pos(grid_dims, mu01, sigma01):
+    """
+    Create a Gaussian initial state with center mu01=(x,y) and spreads sigma01=(sx,sy)
+    in [0,1] of the domain, then discretize to the solver grid given by grid_dims.
+
+    Why grid_dims?
+    - The quantum solver expects a vector aligned to the chosen nx×ny simulation grid.
+      We convert normalized μ and σ (fractions of the domain) into grid units using
+      (nx-1) and (ny-1). This step is necessary for the simulation, not for the preview.
+
+    For preview-only rendering, use create_impulse_preview_state() to keep the visuals
+    continuous and independent of nx.
+    """
+    grid_width, grid_height = grid_dims
+    mu_x01, mu_y01 = mu01
+    sig_x01, sig_y01 = sigma01
+
+    mu_x01 = float(max(0.0, min(1.0, mu_x01)))
+    mu_y01 = float(max(0.0, min(1.0, mu_y01)))
+    sig_x01 = float(sig_x01)
+    sig_y01 = float(sig_y01)
+    if sig_x01 <= 0 or sig_y01 <= 0:
+        raise ValueError("Sigma values (spread) must be positive.")
+
+    mu_x = mu_x01 * (grid_width - 1)
+    mu_y = mu_y01 * (grid_height - 1)
+    sigma_x = sig_x01 * (grid_width - 1)
+    sigma_y = sig_y01 * (grid_height - 1)
+
+    x = np.arange(0, grid_width)
+    y = np.arange(0, grid_height)
+    X, Y = np.meshgrid(x, y)
+    gaussian_2d = np.exp(-((X - mu_x) ** 2) / (2 * sigma_x ** 2) - ((Y - mu_y) ** 2) / (2 * sigma_y ** 2))
+
+    field = _normalize_to_unit(gaussian_2d.ravel())
+    grid_size = grid_width * grid_height
+    total_size = 4 * grid_size
+    initial_state = np.zeros(total_size)
+    initial_state[:grid_size] = field
+    return initial_state
+
+# --- Simulation Code (from previous context) ---
+def Wj_block(j, n, ctrl_state, theta, lam, name='Wj_block', xgate=False):
+    qc = QuantumCircuit(n + j, name=name)
+    if j > 1: qc.cx(n + j - 1, range(n, n + j - 1))
+    if lam != 0: qc.p(lam, n + j - 1)
+    qc.h(n + j - 1)
+    if xgate and j > 1:
+        if isinstance(xgate, (list, tuple)):
+            for idx, flag in enumerate(xgate):
+                if flag: qc.x(n + idx)
+        elif xgate is True: qc.x(range(n, n + j - 1))
+    if j > 1:
+        mcrz = RZGate(theta).control(len(ctrl_state) + j - 1, ctrl_state="1" * (j - 1) + ctrl_state)
+        qc.append(mcrz, range(0, n + j))
+    else:
+        mcrz = RZGate(theta).control(len(ctrl_state), ctrl_state=ctrl_state)
+        qc.append(mcrz, range(0, n + j))
+    if xgate and j > 1:
+        if isinstance(xgate, (list, tuple)):
+            for idx, flag in enumerate(xgate):
+                if flag: qc.x(n + idx)
+        elif xgate is True: qc.x(range(n, n + j - 1))
+    qc.h(n + j - 1)
+    if lam != 0: qc.p(-lam, n + j - 1)
+    if j > 1: qc.cx(n + j - 1, range(n, n + j - 1))
+    return qc.to_gate(label=name)
+
+def V1(nx, dt):
+    n = int(np.ceil(np.log2(nx)))
+    derivatives, blocks = QuantumRegister(2 * n), QuantumRegister(2)
+    qc = QuantumCircuit(derivatives, blocks)
+    qc.append(Wj_block(2, n, "0" * n, -dt, 0, xgate=True), list(derivatives[0:n]) + list(blocks[:]))
+    qc.append(Wj_block(3, n - 1, "1" * (n - 1), dt, 0, xgate=[0, 1]), list(derivatives[1:n]) + [derivatives[0]] + list(blocks[:]))
+    qc.append(Wj_block(1, n + 1, "0" * (n + 1), dt, 0, xgate=True), list(derivatives[n:2 * n]) + list(blocks[:]))
+    qc.append(Wj_block(2, n, "0" + "1" * (n - 1), -dt, 0, xgate=False), list(derivatives[n + 1:2 * n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+    return qc
+
+def V2(nx, dt):
+    n = int(np.ceil(np.log2(nx)))
+    derivatives, blocks = QuantumRegister(2 * n), QuantumRegister(2)
+    qc = QuantumCircuit(derivatives, blocks)
+    qc.append(Wj_block(2, 0, "", -2 * dt, -np.pi / 2, xgate=True), blocks[:])
+    for j in range(1, n + 1): qc.append(Wj_block(2 + j, 0, "", 2 * dt, -np.pi / 2, xgate=[1] * (j - 1) + [0, 1]), list(derivatives[0:j]) + list(blocks[:]))
+    qc.append(Wj_block(2, n, "0" * n, -dt, -np.pi / 2, xgate=True), list(derivatives[0:n]) + list(blocks[:]))
+    qc.append(Wj_block(2, n, "1" * n, 2 * dt, -np.pi / 2, xgate=True), list(derivatives[0:n]) + list(blocks[:]))
+    qc.append(Wj_block(3, n - 1, "1" * (n - 1), dt, -np.pi / 2, xgate=[0, 1]), list(derivatives[1:n]) + [derivatives[0]] + list(blocks[:]))
+    qc.append(Wj_block(1, 1, "0", 2 * dt, -np.pi / 2, xgate=False), blocks[:])
+    for j in range(1, n + 1): qc.append(Wj_block(1 + j, 1, "0", -2 * dt, -np.pi / 2, xgate=[1] * (j - 1)), [blocks[0]] + list(derivatives[n:n + j]) + [blocks[1]])
+    qc.append(Wj_block(1, n + 1, "0" * (n + 1), dt, -np.pi / 2, xgate=False), list(derivatives[n:2 * n]) + list(blocks[:]))
+    qc.append(Wj_block(1, n + 1, "0" + "1" * n, -2 * dt, -np.pi / 2, xgate=False), list(derivatives[n:2 * n]) + list(blocks[:]))
+    qc.append(Wj_block(2, n, "0" + "1" * (n - 1), -dt, -np.pi / 2, xgate=False), list(derivatives[n + 1:2 * n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+    return qc
+
+def run_sim(nx, na, R, initial_state, T, snapshot_dt=None, stop_check=None, progress_callback=None):
+    """
+    Runs the quantum simulation for electromagnetic scattering with fixed dt=0.1.
+    Captures frames only at user-defined snapshot times: [0, Δt, 2Δt, ..., ≤ T_eff],
+    always including t=0 and the final solver-aligned T (T_eff = floor(T/dt)*dt).
+
+    Returns:
+        frames (np.ndarray), snapshot_times (np.ndarray)
+    """
+    dt = 0.1
+    # Validate total time and compute solver-aligned end time
+    try:
+        T_val = float(T)
+    except Exception:
+        return np.array([]), np.array([])
+    if T_val <= 0:
+        return np.array([]), np.array([])
+
+    steps = int(np.floor(T_val / dt))
+    if steps <= 0:
+        return np.array([]), np.array([])
+    T_eff = steps * dt
+
+    # Determine snapshot Δt on solver grid
+    tol = 1e-12
+    if snapshot_dt is None:
+        snapshot_dt_val = dt
+    else:
+        try:
+            snapshot_dt_val = float(snapshot_dt)
+        except Exception:
+            snapshot_dt_val = dt
+    if snapshot_dt_val < dt - tol:
+        snapshot_dt_val = dt
+    k = max(1, int(round(snapshot_dt_val / dt)))
+    snapshot_dt_eff = k * dt
+
+    # Build requested snapshot times on solver grid
+    target_times = [0.0]
+    t = 0.0
+    while t + snapshot_dt_eff <= T_eff + tol:
+        t = round(t + snapshot_dt_eff, 12)
+        if t <= T_eff + tol:
+            target_times.append(min(t, T_eff))
+    if abs(target_times[-1] - T_eff) > tol:
+        target_times.append(T_eff)
+
+    # Setup circuit
+    nq = int(np.ceil(np.log2(nx)))
+    dp = 2 * R * np.pi / 2 ** na
+    p = np.arange(-R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    system, ancilla = QuantumRegister(2 * nq + 2), QuantumRegister(na)
+    qc = QuantumCircuit(system, ancilla)
+    qc.append(StatePreparation(initial_state), system)
+    qc.append(StatePreparation(fp / np.linalg.norm(fp)), ancilla)
+    expA1 = V1(nx, dt).to_gate()
+    expA2 = V2(nx, dt)
+
+    frames = []
+    # Capture initial frame at t=0
+    sv0 = np.real(Statevector(qc)).reshape(2 ** na, 2 ** (2 * nq + 2))
+    frames.append(sv0[2 ** (na - 1)])
+    next_idx = 1  # next target_times index to capture
+
+    for i in range(steps):
+        if stop_check and stop_check():
+            print(f"Simulation interrupted at step {i}/{steps}")
+            break
+        # One solver step
+        qc.append(QFTGate(na), ancilla)
+        qc.x(ancilla[-1])
+        for j in range(na - 1):
+            qc.append(expA1.control().repeat(2 ** j), [ancilla[j]] + system[:])
+        qc.append(expA1.inverse().control(ctrl_state="0").repeat(2 ** (na - 1)), [ancilla[na - 1]] + system[:])
+        qc.append(expA2, system[:])
+        qc.x(ancilla[-1])
+        qc.append(QFTGate(na).inverse(), ancilla)
+
+        current_time = (i + 1) * dt
+        if next_idx < len(target_times) and abs(current_time - target_times[next_idx]) <= tol:
+            u = np.real(Statevector(qc)).reshape(2 ** na, 2 ** (2 * nq + 2))
+            frames.append(u[2 ** (na - 1)])
+            next_idx += 1
+
+        if progress_callback:
+            try:
+                progress = ((i + 1) / steps) * 100
+                progress_callback(progress)
+            except Exception:
+                pass
+
+    if progress_callback:
+        try:
+            progress_callback(100.0)
+        except Exception:
+            pass
+
+    # Ensure snapshot_times align with number of captured frames (covers early stop)
+    frames_arr = np.asarray(frames)
+    times_arr = np.asarray(target_times[: len(frames_arr)])
+    return frames_arr, times_arr
+
+def create_impulse_preview_state(preview_n: int, pos01, sigma01: float = 0.02):
+    """
+    Smooth delta-like preview on a unit square using a narrow Gaussian (sigma in [0,1]).
+    Preview-only helper, independent of simulation grid size (nx). Use this for the
+    Excitation preview; use the *_from_pos() variants for the actual simulation.
+    """
+    try:
+        sx = float(sigma01) if sigma01 and sigma01 > 0 else 0.02
+    except Exception:
+        sx = 0.02
+    return create_gaussian_state_from_pos((int(preview_n), int(preview_n)), (float(pos01[0]), float(pos01[1])), (sx, sx))

requirements.txt

@@ -0,0 +1,31 @@
+# Core scientific computing
+numpy==2.2.6
+scipy==1.16.2  # Updated to actual latest (1.16.1 doesn't exist)
+
+# 3D Visualization
+pyvista==0.46.3
+vtk==9.4.2
+scooby==0.10.1
+
+# Trame Web Framework
+trame==3.12.0
+trame-client==3.11.2
+trame-server==3.6.3
+trame-vtk==2.10.0
+trame-vuetify==3.1.0
+wslink==2.4.0
+
+# Qiskit Quantum Computing
+qiskit==2.0.0
+qiskit-aer==0.17.1
+rustworkx==0.16.0
+
+# Plotting
+matplotlib==3.10.1
+plotly 
+trame_plotly
+
+# Core dependencies
+Pillow==10.4.0
+packaging==25.0
+python-dateutil==2.9.0.post0