Merged QLBM Application and Added features in EM_Trame

.dockerignore

@@ -0,0 +1,30 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.git/
+.gitignore
+.gitattributes
+venv/
+env/
+ENV/
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+Thumbs.db
+*.md
+README.md
+current_requirements.txt
+tempCodeRunnerFile.py
+em_trame1.py
+em_tramefinal.py
+trial.py

.gitattributes

@@ -33,4 +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
+*.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+.venv/
+synopsys-logo-color-rgb.jpg

app.py

@@ -1,86 +1,27 @@
-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
+import os
 
-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
+# Import pages
+from pages import em_page
+import qlbm as qlbm_page
 
-# --- Server and State Initialization ---
+# Create a single server for the multipage app
 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%;",
-})
+# App state: track which page is active
+state.current_page = "EM"  # or "QLBM"
 
-# Ensure hole snap state exists
-state.hole_snap = True
+# Load Synopsys/Ansys logo as data URI for main toolbar
+import base64
 
-# --- Load Synopsys logo (from quantum folder) as data URI ---
-def load_logo_data_uri():
+def _load_logo_data_uri():
     base_dir = os.path.dirname(__file__)
     candidates = [
+        os.path.join(base_dir, "ansys-part-of-synopsys-logo.svg"),
         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"),
@@ -94,1454 +35,41 @@ def load_logo_data_uri():
             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()
-
+# Safely initialize logo in state (trame state isn't a dict; avoid .get())
 try:
-    plotter.disable_picking()
+    if not hasattr(state, "logo_src") or state.logo_src in (None, ""):
+        state.logo_src = _load_logo_data_uri()
 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.logo_src = _load_logo_data_uri()
 
-        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.title.set_text("Quantum Applications")
     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:
+        # Simple navigation with tabs
+        with vuetify3.VTabs(v_model=("current_page", "EM"), grow=True, density="compact", color="primary"):
+            vuetify3.VTab(value="EM", children=["EM Scattering"])
+            vuetify3.VTab(value="QLBM", children=["Fluids"])  # renamed label only
+        # Right-aligned logo
         vuetify3.VSpacer()
         vuetify3.VImg(
             v_if="logo_src",
             src=("logo_src", None),
-            style="height: 56px; width: auto; margin-right: 0px;",
-            classes="mr-0",
+            style="height: 40px; width: auto;",  # slightly smaller than app bar height
+            classes="ml-2",
         )
-    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()
 
+    with layout.content:
+        # Mount EM page
+        with vuetify3.VContainer(v_if="current_page === 'EM'", fluid=True, classes="pa-0 fill-height"):
+            em_page.build(server)
+        # Mount QLBM page
+        with vuetify3.VContainer(v_if="current_page === 'QLBM'", fluid=True, classes="pa-0 fill-height"):
+            qlbm_page.build(server)
+
+port = int(os.environ.get("PORT", "8080"))
+server.start(address="0.0.0.0", port=port, open_browser=True)
 
 

pages/__init__.py

@@ -0,0 +1,4 @@
+# Make pages a package and re-export builders for convenience
+from . import em_page, qlbm_page
+
+__all__ = ["em_page", "qlbm_page"]

pages/em_page.py

@@ -0,0 +1,62 @@
+from trame_vuetify.widgets import vuetify3
+from trame.widgets import html as trame_html
+import os
+import subprocess
+import sys
+import atexit
+
+# Keep a single child process for the EM app
+_em_proc = None
+
+
+def _kill_em_process():
+    """Ensure any running EM process is terminated."""
+    global _em_proc
+    if _em_proc and _em_proc.poll() is None:
+        try:
+            _em_proc.terminate()
+            _em_proc.wait(timeout=2)
+        except Exception:
+            try:
+                _em_proc.kill()
+            except Exception:
+                pass
+    _em_proc = None
+
+
+def _ensure_em_process_started():
+    global _em_proc
+    # Check if process is still running
+    if (_em_proc and _em_proc.poll() is None):
+        return
+    
+    # Kill any stale process first
+    _kill_em_process()
+    
+    base_dir = os.path.dirname(os.path.dirname(__file__))
+    em_path = os.path.join(base_dir, "em_trame.py")
+    env = os.environ.copy()
+    # Port used by iframe
+    env.setdefault("EM_APP_PORT", env.get("PORT_EM", "8701"))
+    # Start em_trame.py in a separate process
+    python_exe = sys.executable or "python"
+    _em_proc = subprocess.Popen([python_exe, em_path], cwd=base_dir, env=env)
+
+
+# Register cleanup on exit
+atexit.register(_kill_em_process)
+
+
+def build(server):
+    """Render the EM app via iframe and ensure its process is running."""
+    _ensure_em_process_started()
+    port = os.environ.get("EM_APP_PORT", os.environ.get("PORT_EM", "8701"))
+    with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
+        trame_html.Iframe(
+            src=("em_iframe_src", f"http://localhost:{port}/"),
+            style="border:0; width:100%; height: calc(100vh - 64px);",
+        )
+        trame_html.Div(
+            "If the EM page is blank, wait a few seconds for the subprocess to start.",
+            style="color: rgba(0,0,0,.6); padding: 6px;",
+        )

pages/qlbm_page.py

@@ -0,0 +1,203 @@
+from trame_vuetify.widgets import vuetify3
+from trame.widgets import html as trame_html
+from trame_plotly.widgets import plotly as plotly_widgets
+import plotly.graph_objects as go
+import os
+
+GRID_SIZES = [16, 32, 64, 128, 256, 512]
+
+
+def _ensure_state_defaults(state):
+    try:
+        state.update({
+            "qlbm_initialized": True,
+            "logo_src": getattr(state, "logo_src", None),
+            "is_running": False,
+            "simulation_has_run": False,
+            "error_message": "",
+            "geometry_selection": getattr(state, "geometry_selection", None),
+            "lbm_dim": getattr(state, "lbm_dim", "2D"),
+            "domain_L": getattr(state, "domain_L", 1.0),
+            "domain_W": getattr(state, "domain_W", 1.0),
+            "domain_H": getattr(state, "domain_H", 1.0),
+            "dist_type": getattr(state, "dist_type", None),
+            "advecting_field": getattr(state, "advecting_field", None),
+            "inlet_velocity": getattr(state, "inlet_velocity", 1.0),
+            "inlet_temperature": getattr(state, "inlet_temperature", 300.0),
+            "nx_slider_index": getattr(state, "nx_slider_index", None),
+            "nx": getattr(state, "nx", None),
+            "output_type": getattr(state, "output_type", "Surface Plot"),
+        })
+    except Exception:
+        pass
+
+
+def _build_placeholder_figure(state):
+    try:
+        if state.geometry_selection == "Rectangular domain with a heated box (2D/3D)" and str(state.lbm_dim) == "3D":
+            fig = go.Figure(data=[go.Scatter3d(x=[0, 1], y=[0, 1], z=[0, 1], mode="markers")])
+            fig.update_layout(height=560, margin=dict(l=10, r=10, t=30, b=10))
+            return fig
+        fig = go.Figure(data=go.Heatmap(z=[[0, 1], [1, 0]], colorscale="RdBu"))
+        fig.update_layout(height=560, margin=dict(l=10, r=10, t=30, b=10))
+        return fig
+    except Exception:
+        return go.Figure()
+
+
+def build(server):
+    state, ctrl = server.state, server.controller
+    _ensure_state_defaults(state)
+
+    def run_simulation():
+        state.is_running = True
+        state.error_message = ""
+        try:
+            fig = _build_placeholder_figure(state)
+            try:
+                ctrl.qlbm_plot_update(fig)
+            except Exception:
+                pass
+            state.simulation_has_run = True
+        except Exception as e:
+            state.error_message = f"Run failed: {e}"
+        finally:
+            state.is_running = False
+
+    def reset_all():
+        try:
+            state.update({
+                "geometry_selection": None,
+                "lbm_dim": "2D",
+                "domain_L": 1.0,
+                "domain_W": 1.0,
+                "domain_H": 1.0,
+                "dist_type": None,
+                "advecting_field": None,
+                "inlet_velocity": 1.0,
+                "inlet_temperature": 300.0,
+                "nx_slider_index": None,
+                "nx": None,
+                "output_type": "Surface Plot",
+                "is_running": False,
+                "simulation_has_run": False,
+                "error_message": "",
+            })
+            try:
+                ctrl.qlbm_plot_update(go.Figure())
+            except Exception:
+                pass
+        except Exception:
+            pass
+
+    @state.change("nx_slider_index")
+    def _on_nx_index_change(nx_slider_index, **_):
+        try:
+            state.nx = GRID_SIZES[int(nx_slider_index)] if nx_slider_index is not None else None
+        except Exception:
+            state.nx = None
+
+    with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
+        with vuetify3.VRow(no_gutters=True, classes="fill-height"):
+            with vuetify3.VCol(cols=5, classes="pa-4 d-flex flex-column"):
+                with vuetify3.VCard(classes="mb-4"):
+                    vuetify3.VCardTitle("Overview", classes="text-h5 font-weight-bold text-primary")
+                    with vuetify3.VCardText():
+                        vuetify3.VDivider(classes="my-2")
+                        vuetify3.VCardSubtitle("Problems", classes="text-subtitle-1 font-weight-bold mt-2")
+                        vuetify3.VList(density="compact", lines="one", items=(
+                            "qlbm_problems",
+                            [
+                                {"title": "1. Scalar advection-diffusion in a box"},
+                                {"title": "2. Laminar flow & heat transfer for a heated body in water."},
+                            ],
+                        ))
+                        vuetify3.VCardSubtitle("Governing Equations", classes="text-subtitle-1 font-weight-bold mt-2")
+                        vuetify3.VListItemTitle("Laminar Navier-Stokes including energy", classes="text-body-2")
+                        vuetify3.VCardSubtitle("Inputs", classes="text-subtitle-1 font-weight-bold mt-2")
+                        vuetify3.VListItemTitle("Geometry, Boundary conditions - temperature and flow", classes="text-body-2")
+                        vuetify3.VCardSubtitle("Outputs", classes="text-subtitle-1 font-weight-bold mt-2")
+                        vuetify3.VListItemTitle("Surface plots on sections OR sampling through a line in 3D domain", classes="text-body-2")
+
+                with vuetify3.VCard(classes="mb-4"):
+                    vuetify3.VCardTitle("Geometry", classes="text-primary")
+                    with vuetify3.VCardText():
+                        vuetify3.VSelect(
+                            label="Select",
+                            v_model=("geometry_selection", None),
+                            items=(
+                                "geometry_options",
+                                [
+                                    "None",
+                                    "Free space",
+                                    "Rectangular domain with a heated box (2D/3D)",
+                                ],
+                            ),
+                            placeholder="Select",
+                            density="compact",
+                            color="primary",
+                        )
+                        with vuetify3.VContainer(v_if="geometry_selection === 'Rectangular domain with a heated box (2D/3D)'", classes="pa-0 mt-2"):
+                            vuetify3.VRadioGroup(v_model=("lbm_dim", "2D"), row=True, density="compact", color="primary", children=[
+                                vuetify3.VRadio(label="2D", value="2D"),
+                                vuetify3.VRadio(label="3D", value="3D"),
+                            ])
+                            with vuetify3.VRow(dense=True):
+                                vuetify3.VCol(children=[vuetify3.VTextField(label="Length (L)", v_model=("domain_L", 1.0), type="number", step="0.1", density="compact", color="primary")])
+                                vuetify3.VCol(children=[vuetify3.VTextField(label="Width (W)", v_model=("domain_W", 1.0), type="number", step="0.1", density="compact", color="primary")])
+                            vuetify3.VTextField(v_if="lbm_dim === '3D'", label="Height (H)", v_model=("domain_H", 1.0), type="number", step="0.1", density="compact", color="primary")
+
+                with vuetify3.VCard(v_if="geometry_selection === 'Rectangular domain with a heated box (2D/3D)'", classes="mb-4"):
+                    vuetify3.VCardTitle("Initial & Boundary Conditions", classes="text-primary")
+                    with vuetify3.VCardText():
+                        vuetify3.VSelect(label="Initial Condition", v_model=("dist_type", None), items=("dist_type_opts", ["None", "Delta", "Gaussian"]), density="compact", color="primary")
+                        vuetify3.VSelect(label="Advecting field", v_model=("advecting_field", None), items=("advect_fields", ["Uniform", "Swirl", "Shear", "TGV"]), density="compact", color="primary", classes="mt-2")
+                        with vuetify3.VRow(dense=True, classes="mt-2"):
+                            vuetify3.VCol(children=[vuetify3.VTextField(label="Inlet flow velocity", v_model=("inlet_velocity", 1.0), type="number", step="0.1", density="compact", color="primary")])
+                            vuetify3.VCol(children=[vuetify3.VTextField(label="Inlet temperature (K)", v_model=("inlet_temperature", 300.0), type="number", step="1", density="compact", color="primary")])
+
+                with vuetify3.VCard(classes="mb-4"):
+                    vuetify3.VCardTitle("Meshing", classes="text-primary")
+                    with vuetify3.VCardText():
+                        with vuetify3.VSlider(
+                            v_model=("nx_slider_index", None),
+                            label="No. of points per direction:",
+                            min=0,
+                            max=len(GRID_SIZES) - 1,
+                            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] }}"])
+
+                with vuetify3.VCard(classes="mb-4"):
+                    vuetify3.VCardTitle("Backends", classes="text-primary")
+                    with vuetify3.VCardText():
+                        vuetify3.VAlert(type="info", color="primary", variant="tonal", density="compact", children=["Simulator only (placeholder)"])
+
+                with vuetify3.VRow(dense=True, classes="mb-2"):
+                    vuetify3.VCol(children=[
+                        vuetify3.VBtn(text=("Run Simulation"), color="primary", block=True, disabled=("is_running || !geometry_selection || (geometry_selection === 'Rectangular domain with a heated box (2D/3D)' && nx === null)", False), click=run_simulation)
+                    ])
+                    vuetify3.VCol(children=[
+                        vuetify3.VBtn(text=("Reset"), color="secondary", variant="tonal", block=True, click=reset_all)
+                    ])
+
+            with vuetify3.VCol(cols=7, classes="pa-4 d-flex flex-column"):
+                with vuetify3.VCard(v_if="simulation_has_run", classes="mb-4"):
+                    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="Line Sampling", value="Line Sampling")
+
+                with vuetify3.VCard(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-2"):
+                        fig = plotly_widgets.Figure(figure=go.Figure(), responsive=True, style="width: 100%; min-height: 560px;")
+                        ctrl.qlbm_plot_update = fig.update
+                        vuetify3.VContainer(v_if="!simulation_has_run", classes="d-flex align-center justify-center", style="height: 360px; color: rgba(0,0,0,.6);", children=["Configure inputs and run to display results."])

qlbm.py

@@ -0,0 +1,285 @@
+import os
+import numpy as np
+import math
+import re  # Added missing import for regex usage
+from trame.app import get_server
+from trame_vuetify.ui.vuetify3 import SinglePageLayout
+from trame_vuetify.widgets import vuetify3
+from trame.widgets import html as trame_html
+from trame_plotly.widgets import plotly as plotly_widgets
+import plotly.graph_objects as go
+
+GRID_SIZES = [16, 32, 64, 128, 256, 512, 1024, 2048]
+
+def load_logo_data_uri():
+    try:
+        base_dir = os.path.dirname(__file__)
+        for name in [
+            "ansys-part-of-synopsys-logo.svg",
+            "synopsys-logo-color-rgb.svg",
+            "synopsys-logo-color-rgb.png",
+            "synopsys-logo-color-rgb.jpg",
+        ]:
+            p = os.path.join(base_dir, name)
+            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")
+                import base64
+                with open(p, "rb") as f:
+                    b64 = base64.b64encode(f.read()).decode("ascii")
+                return f"data:{mime};base64,{b64}"
+    except Exception:
+        pass
+    return None
+
+def update_qubit_3D_info(grid_size: int):
+    try:
+        num_reg_qubits = int(math.log2(grid_size)) if grid_size > 0 else 3
+        total_qubits = 3 * num_reg_qubits + 3
+        grid_display = f"Grid Size: {grid_size} × {grid_size} × {grid_size}"
+        x = np.array([16, 32, 64, 128, 256])
+        y = np.log2(x).astype(int)
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=x, y=y, mode='lines', name='Qubits/Direction', line=dict(color='#7A3DB5', width=3)))
+        fig.add_trace(go.Scatter(x=[grid_size], y=[num_reg_qubits], mode='markers', marker=dict(size=12, color='red'), name='Current Selection'))
+        fig.update_layout(xaxis_title="Grid Size (Points/Direction)", yaxis_title="Qubits/Direction", width=616, height=320, margin=dict(l=40, r=20, t=20, b=40))
+        warning = "⚠️ Warning: Grid sizes > 64 may exceed simulator/memory limits!" if grid_size > 64 else ""
+        return fig, grid_display, total_qubits, warning
+    except Exception:
+        return go.Figure(), "Grid Size: N/A", 0, ""
+
+# Controllers (created per server instance)
+
+def _make_controllers(server):
+    state, ctrl = server.state, server.controller
+
+    def run_simulation():
+        state.is_running = True
+        state.error_message = ""
+        try:
+            state.simulation_has_run = True
+        except Exception as e:
+            state.error_message = f"Run failed: {e}"
+        finally:
+            state.is_running = False
+
+    def reset_all():
+        state.update({
+            "problems_selection": None,
+            "geometry_selection": None,
+            "domain_L": 1.0,
+            "domain_W": 1.0,
+            "domain_H": 1.0,
+            "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)",
+            "excitation_error_message": "",
+            "advecting_field": None,
+            "inlet_velocity": 1.0,
+            "inlet_temperature": 300.0,
+            "nx_slider_index": None,
+            "nx": None,
+            "output_type": "Surface Plot",
+            "is_running": False,
+            "simulation_has_run": False,
+            "error_message": "",
+            "backend_type": "Simulator",
+            "selected_simulator": "IBM Qiskit simulator",
+            "selected_qpu": "IBM QPU",
+            "qubit_grid_info": "",
+            "qubit_warning": "",
+        })
+
+    ctrl.run_qlbm_sim = run_simulation
+    ctrl.reset_qlbm = reset_all
+
+    def on_nx_index_change(nx_slider_index, **_):
+        try:
+            state.nx = GRID_SIZES[int(nx_slider_index)] if nx_slider_index is not None else None
+        except Exception:
+            state.nx = None
+
+    def update_qubit_plot(nx, **_):
+        try:
+            if nx is None:
+                state.qubit_grid_info = ""
+                state.qubit_warning = ""
+                return
+            fig, grid_info, _, warning = update_qubit_3D_info(nx)
+            state.qubit_grid_info = grid_info
+            state.qubit_warning = warning
+            if hasattr(ctrl, 'qlbm_qubit_update'):
+                ctrl.qlbm_qubit_update(fig)
+        except Exception:
+            pass
+
+    def sync_peak_pair(peak_pair, **_):
+        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
+            state.impulse_x = max(0.0, min(1.0, float(m.group(1))))
+            state.impulse_y = max(0.0, min(1.0, float(m.group(2))))
+            state.excitation_error_message = ""
+        except Exception:
+            state.excitation_error_message = "Invalid Peak. Use (x, y) in [0,1]."
+
+    def sync_mu_pair(mu_pair, **_):
+        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
+            state.mu_x = max(0.0, min(1.0, float(m.group(1))))
+            state.mu_y = max(0.0, min(1.0, float(m.group(2))))
+            state.excitation_error_message = ""
+        except Exception:
+            state.excitation_error_message = "Invalid Mu. Use (x, y) in [0,1]."
+
+    # Register watchers
+    server.state.change("nx_slider_index")(on_nx_index_change)
+    server.state.change("nx")(update_qubit_plot)
+    server.state.change("peak_pair")(sync_peak_pair)
+    server.state.change("mu_pair")(sync_mu_pair)
+
+# Initialize defaults once per server
+
+def _init_state(server):
+    state = server.state
+    if getattr(state, "qlbm_initialized", False):
+        return
+    state.update({
+        "logo_src": load_logo_data_uri(),
+        "is_running": False,
+        "simulation_has_run": False,
+        "error_message": "",
+        "problems_selection": None,
+        "geometry_selection": None,
+        "domain_L": 1.0,
+        "domain_W": 1.0,
+        "domain_H": 1.0,
+        "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)",
+        "excitation_error_message": "",
+        "advecting_field": None,
+        "inlet_velocity": 1.0,
+        "inlet_temperature": 300.0,
+        "nx_slider_index": None,
+        "nx": None,
+        "backend_type": "Simulator",
+        "selected_simulator": "IBM Qiskit simulator",
+        "selected_qpu": "IBM QPU",
+        "output_type": "Surface Plot",
+        "qubit_grid_info": "",
+        "qubit_warning": "",
+        "qlbm_initialized": True,
+    })
+
+# Public build(server) used by multipage app
+
+def build(server):
+    _init_state(server)
+    _make_controllers(server)
+    state, ctrl = server.state, server.controller
+    with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
+        with vuetify3.VRow(no_gutters=True, classes="fill-height"):
+            # Left column
+            with vuetify3.VCol(cols=5, classes="pa-4 d-flex flex-column"):
+                with vuetify3.VCard(classes="mb-4"):
+                    vuetify3.VCardTitle("Overview", classes="text-h5 font-weight-bold text-primary")
+                    with vuetify3.VCardText():
+                        vuetify3.VDivider(classes="my-2")
+                        vuetify3.VCardSubtitle("Problems!", classes="text-subtitle-1 font-weight-bold mt-2")
+                        vuetify3.VSelect(label="Select a problem", v_model=("problems_selection", None), items=("qlbm_problems", ["1. Scalar advection-diffusion in a box", "2. Laminar flow & heat transfer for a heated body in water."]), placeholder="Select", density="compact", color="primary")
+                        vuetify3.VCardSubtitle("Governing Equations", classes="text-subtitle-1 font-weight-bold mt-2")
+                        vuetify3.VListItemTitle("Laminar Navier-Stokes including energy", classes="text-body-2")
+                        vuetify3.VCardSubtitle("Inputs", classes="text-subtitle-1 font-weight-bold mt-2")
+                        vuetify3.VListItemTitle("Geometry, Boundary conditions - temperature and flow", classes="text-body-2")
+                        vuetify3.VCardSubtitle("Outputs", classes="text-subtitle-1 font-weight-bold mt-2")
+                        vuetify3.VListItemTitle("Surface plots on sections OR sampling through a line in 3D domain", classes="text-body-2")
+                with vuetify3.VCard(classes="mb-4"):
+                    vuetify3.VCardTitle("Geometry", classes="text-primary")
+                    with vuetify3.VCardText():
+                        vuetify3.VSelect(label="Select", v_model=("geometry_selection", None), items=("geometry_options", ["Free space", "Rectangular domain with a heated box (3D)"]), placeholder="Select", density="compact", color="primary")
+                        with vuetify3.VContainer(v_if="geometry_selection === 'Rectangular domain with a heated box (3D)'", classes="pa-0 mt-2"):
+                            with vuetify3.VRow(dense=True):
+                                vuetify3.VCol(children=[vuetify3.VTextField(label="Length (L)", v_model=("domain_L", 1.0), type="number", step="0.1", density="compact", color="primary")])
+                                vuetify3.VCol(children=[vuetify3.VTextField(label="Breadth (B)", v_model=("domain_W", 1.0), type="number", step="0.1", density="compact", color="primary")])
+                            vuetify3.VTextField(label="Height (H)", v_model=("domain_H", 1.0), type="number", step="0.1", density="compact", color="primary")
+                with vuetify3.VCard(v_if="geometry_selection === 'Rectangular domain with a heated box (3D)'", classes="mb-4"):
+                    vuetify3.VCardTitle("Initial & Boundary Conditions", classes="text-primary")
+                    with vuetify3.VCardText():
+                        vuetify3.VTextField(v_model=("mu_pair", "(0.5, 0.5)"), label="Gaussian μ (x, y) in [0,1]", density="compact", color="primary")
+                        with vuetify3.VRow(dense=True, classes="mt-1"):
+                            vuetify3.VCol(children=[vuetify3.VTextField(label="Sigma X (0–1)", v_model=("sigma_x", 0.25), type="number", step="0.01", density="compact", color="primary")])
+                            vuetify3.VCol(children=[vuetify3.VTextField(label="Sigma Y (0–1)", v_model=("sigma_y", 0.15), 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.VSelect(label="Advecting field", v_model=("advecting_field", None), items=("advect_fields", ["Uniform", "Swirl", "Shear", "TGV"]), density="compact", color="primary", classes="mt-2")
+                        with vuetify3.VRow(dense=True, classes="mt-2"):
+                            vuetify3.VCol(children=[vuetify3.VTextField(label="Inlet flow velocity", v_model=("inlet_velocity", 1.0), type="number", step="0.1", density="compact", color="primary")])
+                            vuetify3.VCol(children=[vuetify3.VTextField(label="Inlet temperature (K)", v_model=("inlet_temperature", 300.0), type="number", step="1", density="compact", color="primary")])
+                with vuetify3.VCard(classes="mb-4"):
+                    vuetify3.VCardTitle("Meshing", classes="text-primary")
+                    with vuetify3.VCardText():
+                        with vuetify3.VMenu(open_on_hover=True, close_on_content_click=False, location="end"):
+                            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=len(GRID_SIZES)-1, 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, 1024, 2048][modelValue] }}"])
+                            with vuetify3.VSheet(classes="pa-2", elevation=6, rounded=True, style="width: 700px;"):
+                                qubit_fig_widget = plotly_widgets.Figure(figure=go.Figure(), responsive=True, style="width: 616px; height: 320px; min-height: 320px;")
+                                ctrl.qlbm_qubit_update = qubit_fig_widget.update
+                                vuetify3.VCardText(children=["{{ qubit_grid_info }}", "{{ qubit_warning }}"], classes="text-caption mt-2")
+                with vuetify3.VCard(classes="mb-4"):
+                    vuetify3.VCardTitle("Backends", classes="text-primary")
+                    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'")
+                with vuetify3.VRow(dense=True, classes="gap-2 mt-4"):
+                    with vuetify3.VCol():
+                        vuetify3.VBtn(text="Run Simulation", color="primary", block=True, disabled=("is_running || !geometry_selection || (geometry_selection === 'Rectangular domain with a heated box (3D)' && nx === null)", False), click=ctrl.run_qlbm_sim)
+                    with vuetify3.VCol():
+                        vuetify3.VBtn(text="Reset", color="secondary", variant="tonal", block=True, click=ctrl.reset_qlbm)
+            with vuetify3.VCol(cols=7, classes="pa-4 d-flex flex-column"):
+                with vuetify3.VContainer(fluid=True, classes="fill-height d-flex align-center justify-center"):
+                    vuetify3.VCardText("Select a geometry and configure inputs to display results.", classes="text-center text-medium-emphasis")
+
+# Standalone execution
+if __name__ == "__main__":
+    from trame.app import get_server
+    from trame_vuetify.ui.vuetify3 import SinglePageLayout
+    _server = get_server()
+    # NOTE: build must run inside a layout/content context; do not call before layout
+    with SinglePageLayout(_server) as _layout:
+        _layout.title.set_text("QLBM: Lattice Boltzmann")
+        with _layout.content:
+            build(_server)
+    _server.start(open_browser=True)

utils/base_functions.py

@@ -0,0 +1,443 @@
+import numpy as np
+import scipy.sparse as sp
+import math
+import random
+import matplotlib.pyplot as plt
+from scipy.special import jn
+from scipy.sparse import identity, csr_matrix, kron, diags, eye
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit.circuit.library import MCXGate, MCPhaseGate, RXGate, CRXGate, QFTGate, StatePreparation, PauliEvolutionGate, RZGate
+from qiskit.quantum_info import SparsePauliOp, Statevector, Operator, Pauli
+from scipy.linalg import expm
+# from tools import *
+from qiskit.qasm3 import dumps  # QASM 3 exporter
+from qiskit.qasm3 import loads
+from qiskit.circuit.library import QFT
+from qiskit.primitives import StatevectorEstimator
+from qiskit import transpile
+from qiskit_addon_aqc_tensor.simulation import tensornetwork_from_circuit, apply_circuit_to_state, compute_overlap
+from qiskit_aer import AerSimulator
+
+
+simulator_settings = AerSimulator(
+    method="matrix_product_state",
+    matrix_product_state_max_bond_dimension=100,
+)
+
+def Wj(j, theta, lam, name='Wj', xgate=False):    
+    if not xgate:
+        name = f' $W_{j}$ '
+    qc=QuantumCircuit(j, name=name)
+
+    if j > 1:
+        qc.cx(j-1, range(j-1))
+    if lam != 0:
+        qc.p(lam, j-1)
+    qc.h(j-1)
+    if xgate:
+        qc.x(range(j-1))
+
+    # the multicontrolled rz gate 
+    # it will be decomposed in qiskit
+    if j > 1:
+        qc.mcrz(theta, range(j-1), j-1)
+    else:
+        qc.rz(theta, j-1)
+    
+    if xgate:
+        qc.x(range(j-1))
+    qc.h(j-1)
+    if lam != 0:
+        qc.p(-lam, j-1)
+    if j > 1:
+        qc.cx(j-1, range(j-1))
+
+    return qc
+
+def Wj_block(j, n, ctrl_state, theta, lam, name='Wj_block', xgate=False):    
+    if not xgate:
+        name = f' $W_{j}_block$ '
+    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)):  # selective application
+            for idx, flag in enumerate(xgate):
+                if flag:   # only apply where flag == 1
+                    qc.x(n + idx)
+        elif xgate is True:  # apply to all
+            qc.x(range(n, n+j-1))
+
+    # the multicontrolled rz gate 
+    # it will be decomposed in qiskit
+    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)):  # selective application
+            for idx, flag in enumerate(xgate):
+                if flag:   # only apply where flag == 1
+                    qc.x(n + idx)
+        elif xgate is True:  # apply to all
+            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, name = "V1"):
+    n = int(np.ceil(np.log2(nx)))
+
+    derivatives = QuantumRegister(2*n)
+    blocks = QuantumRegister(2)
+
+    qc = QuantumCircuit(derivatives, blocks)
+    
+    W1 = Wj_block(2, n, "0"*n, -dt , 0, xgate=True)
+    qc.append(W1, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W2 = Wj_block(3, n-1, "1"*(n-1), dt , 0, xgate=[0,1])
+    qc.append(W2, list(derivatives[1:n])+[derivatives[0]]+list(blocks[:]))
+
+    # qc.barrier()
+
+    W3 = Wj_block(1, n+1, "0"*(n+1), dt , 0, xgate=False)
+    qc.append(W3, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W4 = Wj_block(2, n, "0"+"1"*(n-1), -dt , 0, xgate=False)
+    qc.append(W4, list(derivatives[n+1:2*n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+
+    return qc
+
+def V2(nx, dt, name = "V2"):
+    n = int(np.ceil(np.log2(nx)))
+
+    derivatives = QuantumRegister(2*n)
+    blocks = QuantumRegister(2)
+
+    qc = QuantumCircuit(derivatives, blocks)
+    
+    W1 = Wj_block(2, 0, "", -2*dt , -np.pi/2, xgate=True)
+    qc.append(W1, list(blocks[:]))
+
+    # qc.barrier()
+
+    for j in range(1, n+1):
+        W2 = Wj_block(2+j, 0, "", 2*dt , -np.pi/2, xgate=[1]*(j-1)+[0,1])
+        qc.append(W2, list(derivatives[0:j])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W3 = Wj_block(2, n, "0"*n, -dt , -np.pi/2, xgate=True)
+    qc.append(W3, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W4 = Wj_block(2, n, "1"*n, 2*dt , -np.pi/2, xgate=True)
+    qc.append(W4, list(derivatives[0:n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W5 = Wj_block(3, n-1, "1"*(n-1), dt , -np.pi/2, xgate=[0,1])
+    qc.append(W5, list(derivatives[1:n])+[derivatives[0]]+list(blocks[:]))
+
+    # qc.barrier()
+
+    W6 = Wj_block(1, 1, "0", 2*dt , -np.pi/2, xgate=False)
+    qc.append(W6, list(blocks[:]))
+
+    # qc.barrier()
+
+    for j in range(1, n+1):
+        W7 = Wj_block(1+j, 1, "0", -2*dt , -np.pi/2, xgate=[1]*(j-1))
+        qc.append(W7, [blocks[0]]+list(derivatives[n:n+j])+[blocks[1]])
+
+        # qc.barrier()
+
+    W8 = Wj_block(1, n+1, "0"*(n+1), dt , -np.pi/2, xgate=False)
+    qc.append(W8, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W9 = Wj_block(1, n+1, "0"+"1"*(n), -2*dt , -np.pi/2, xgate=False)
+    qc.append(W9, list(derivatives[n:2*n])+list(blocks[:]))
+
+    # qc.barrier()
+
+    W10 = Wj_block(2, n, "0"+"1"*(n-1), -dt , -np.pi/2, xgate=False)
+    qc.append(W10, list(derivatives[n+1:2*n]) + [blocks[0]] + [derivatives[n]] + [blocks[1]])
+
+    # qc.barrier()
+    
+    return qc
+
+def schro(nx, na, R, dt, initial_state, steps):
+
+    nq = int(np.ceil(np.log2(nx)))
+
+    # warped phase transformation
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm1 = np.linalg.norm(fp[2**(na-1):]) # norm of p>=0
+
+    # construct quantum circuit
+    system = QuantumRegister(2*nq+2, name='system')
+    ancilla = QuantumRegister(na, name='ancilla')
+    qc = QuantumCircuit(system, ancilla)
+
+    # initialization
+    prep = StatePreparation(initial_state)
+    anc_prep = StatePreparation(fp / np.linalg.norm(fp))
+
+    qc.append(prep, system)
+    # qc.append(anc_prep, ancilla)
+    qc.initialize(fp / np.linalg.norm(fp), ancilla)
+
+
+    # QFT
+    qc.append(QFTGate(na), ancilla)
+    qc.x(ancilla[-1])
+
+    A1 = V1(nx, dt, name = "V1").to_gate()
+    A2 = V2(nx, dt, name = "V2")
+
+    
+    # Hamiltonian simulation for Nt steps
+    for i in range(steps):
+        # circuit for one step
+        for j in range(na):
+            # repeat controlled H1 for 2**j times
+            qc.append(A1.control().repeat(2**j), [ancilla[j]] + system[:])
+
+        # qc.append(A1.inverse().control(ctrl_state = "0").repeat(2**(na-1)), [ancilla[na-1]] + system[:])
+        qc.append(A1.inverse().repeat(2**(na-1)), system[:])
+        qc.append(A2, system[:])
+
+    # rearrange eta
+    qc.x(ancilla[-1])
+    qc.append(QFTGate(na).inverse(), ancilla)
+
+    return qc
+
+
+
+def circ_for_magnitude(field, x, y, nx, na, R, dt, initial_state, steps):
+
+    qc  = schro(nx, na, R, dt, initial_state, steps)
+    naimark = QuantumRegister(1, name='Naimark')
+    qc.add_register(naimark)
+
+    if field == 'Ez':
+        index = nx * y + x
+    elif field == 'Hx':
+        index = 2*nx*nx + nx * y + x
+    else:
+        index = 3*nx*nx + nx * y + x
+
+    index_bin = format(index, f'0{qc.num_qubits-2}b')
+    ctrl_state = '1' + index_bin
+    ctrl_qubits = qc.qubits[:-1]
+    qc.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state)
+
+    return qc
+
+def circuits_for_sign(field, x, y, nx, na, dt, R, initial_state, steps, xref, yref, field_ref = 'Ez'):    
+    qc  = schro(nx, na, R, dt, initial_state, steps)
+
+    naimark = QuantumRegister(1, name='Naimark')
+    qc.add_register(naimark)
+
+    if field == 'Ez':
+        index = nx * y + x
+    elif field == 'Hx':
+        index = 2*nx*nx + nx * y + x
+    else:
+        index = 3*nx*nx + nx * y + x
+
+    if field_ref == 'Ez':
+        index_ref = nx * yref + xref
+    elif field_ref == 'Hx':
+        index_ref = 2*nx*nx + nx * yref + xref
+    else:
+        index_ref = 3*nx*nx + nx * yref + xref
+
+    index_bin = [(index >> i) & 1 for i in range(qc.num_qubits-2)]
+    index_ref_bin = [(index_ref >> i) & 1 for i in range(qc.num_qubits-2)]
+    index_bin.append(1)
+    index_ref_bin.append(1)
+
+    #Convert reference bitstring to 00000 
+    for i, bit in enumerate(index_ref_bin):
+        if bit == 1:
+            qc.x(i)
+
+    d_bits = [b ^ r for b, r in zip(index_ref_bin, index_bin)]
+    control = d_bits.index(1)
+
+    #Convert the other bitstring to 0001000
+    for target, bit in enumerate(d_bits):
+        if bit == 1 and target != control:
+            qc.cx(control, target)
+    qc.h(control)
+
+    ctrl_state_sum = '0'*(qc.num_qubits-1)
+    ctrl_state_diff = '0'*(qc.num_qubits-1-control-1)+'1'+'0'*(control)
+    
+    qcdiff = qc.copy()
+
+    ctrl_qubits = qc.qubits[:-1]
+
+    qc.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state_sum)
+    qcdiff.mcx(ctrl_qubits, naimark[0], ctrl_state=ctrl_state_diff)
+
+    return qc, qcdiff
+
+def get_absolute_field_value(qc, nq, na, offset, norm):
+
+    pauli_label = 'Z'+'I'*(2*nq+2+na)
+    observable  = SparsePauliOp(Pauli(pauli_label))
+    ########################################################################################
+    estimator = StatevectorEstimator() 
+
+    # === Run Estimator (no parameters needed) ===
+    pub = (qc, observable)
+    job = estimator.run([pub])
+    result = job.result()[0]
+    z_exp = result.data.evs.item()
+    #########################################################################################
+    # === Compute projector expectation ===
+    pi_expect = (1 - z_exp) / 2
+
+    Absolute_value = norm*np.sqrt(pi_expect)-offset
+    
+    return Absolute_value
+
+def get_relative_sign(qc, qcdiff, nq, na):
+
+    pauli_label = 'Z'+'I'*(2*nq+2+na)
+    observable  = SparsePauliOp(Pauli(pauli_label))
+    ########################################################################################
+    estimator = StatevectorEstimator() 
+
+    # === Run Estimator ===
+    pub = (qc, observable)
+    job = estimator.run([pub])
+    result = job.result()[0]
+    z_exp = result.data.evs.item()
+
+    pub_diff = (qcdiff, observable)
+    job_diff = estimator.run([pub_diff])
+    result_diff = job_diff.result()[0]
+    z_exp_diff = result_diff.data.evs.item()
+    #########################################################################################
+    # === Compute projector expectation ===
+    pi_expect_sum = (1 - z_exp) / 2
+    pi_expect_diff = (1 - z_exp_diff) / 2
+
+    relative_sign = 'same' if pi_expect_sum >= pi_expect_diff else 'different'
+    
+    return relative_sign
+
+def Eref_value(nx, nq, R, dt, na, steps, xref, yref, field_ref = 'Ez'):
+    if steps < 31:
+        offset = 1
+    else :
+        offset = 0.15
+    deltastate = np.zeros(4*nx*nx)
+    # deltastate[nx*nx//2+nx//2:nx*nx//2+nx//2+1] = 1
+    deltastate[nx*yref+xref] = 1
+    deltastate[0:nx*nx] = deltastate[0:nx*nx] + offset
+    norm1 = np.linalg.norm(deltastate)
+    initial_state = deltastate/norm1
+
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm2 = np.linalg.norm(fp)
+    norm = norm1 * norm2
+
+    qc = circ_for_magnitude(field_ref, xref, yref, nx, na, R, dt, initial_state, steps)
+
+    Ezref = get_absolute_field_value(qc, nq, na, offset, norm)
+
+    return Ezref
+
+
+def transpile_circ(circ, basis_gates=None):
+    """
+    Transpile the circuit to the specified basis gates.
+    """
+    if basis_gates is None:
+        basis_gates = ['z', 'y', 'x', 'sdg', 's', 'h', 'rz', 'ry', 'rx', 'ecr', 'cz', 'cx']
+    
+    transpiled_circ = transpile(circ, basis_gates=basis_gates)
+    return transpiled_circ
+
+def compute_fidelity(circ1, circ2):
+    
+    circ_1 = tensornetwork_from_circuit(transpile_circ(circ1), simulator_settings)
+    circ_2 = tensornetwork_from_circuit(transpile_circ(circ2), simulator_settings)
+    fidelity = abs(compute_overlap(circ_1, circ_2))**2
+    
+    return fidelity
+
+# 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

utils/delta_impulse_generator.py

@@ -0,0 +1,468 @@
+import numpy as np
+import math
+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))
+
+
+
+
+
+
+##### IBM QPU Simulation Code Below (Do Not Edit) #####
+
+from .base_functions import * 
+
+def create_time_frames(total_time, snapshot_interval):
+    dt = 0.1
+    tol = 1e-9
+    try:
+        T_val = float(total_time)
+    except (ValueError, TypeError):
+        return []
+    if T_val <= 0:
+        return []
+    steps = int(np.floor(T_val / dt))
+    if steps <= 0:
+        return [0.0]
+    T_eff = steps * dt
+    try:
+        snapshot_dt_val = float(snapshot_interval)
+    except (ValueError, TypeError):
+        snapshot_dt_val = dt
+    if snapshot_dt_val < dt:
+        snapshot_dt_val = dt
+    k = max(1, int(round(snapshot_dt_val / dt)))
+    snapshot_dt_eff = k * dt
+    times = np.arange(0, T_eff + tol, snapshot_dt_eff)
+    if abs(times[-1] - T_eff) > tol:
+        times = np.append(times, T_eff)
+    times = np.round(times, 12)
+    unique_times = []
+    for t in times:
+        if not unique_times or abs(t - unique_times[-1]) > tol:
+            unique_times.append(float(t))
+    return unique_times
+
+
+
+def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos):
+    """
+    Compute time-series field values. Supports single-point and multi-point modes.
+
+    - Single-point (backward compatible): x, y are integers; returns list[float].
+    - Multi-point: x is a list/tuple of (ix, iy) integer pairs and y is None; returns dict[(ix,iy) -> list[float]].
+    """
+    na = 1
+    dt = 0.1
+    R = 4
+    nq = int(np.ceil(np.log2(nx)))
+
+    # Normalize monitor points input
+    if isinstance(x, (list, tuple)) and y is None:
+        points = [tuple(map(int, pt)) for pt in x]
+        multi = True
+    else:
+        points = [(int(x), int(y))]
+        multi = False
+
+    xref, yref = impulse_pos
+
+    offset = 0
+    grid_dims = (nx, nx)
+    initial_state = create_impulse_state(grid_dims, impulse_pos)
+    
+    dp = 2 * R * np.pi / 2**na
+    p = np.arange(- R * np.pi, R * np.pi, step=dp)
+    fp = np.exp(-np.abs(p))
+    norm = np.linalg.norm(fp)
+
+    time_frames = create_time_frames(T, snapshot_time)
+
+    # Prepare outputs
+    if multi:
+        series_by_point = { (px, py): [] for (px, py) in points }
+    else:
+        series_single = []
+
+    for time in time_frames:
+        steps = int(math.ceil(time / dt))
+        # Reference Ez field at impulse location for sign
+        Eref = Eref_value(nx, nq, R, dt, na, steps, xref, yref, field_ref='Ez')
+
+        for (px, py) in points:
+            circ_magnitude = circ_for_magnitude(field, px, py, nx, na, R, dt, initial_state, steps)
+            magnitude = get_absolute_field_value(circ_magnitude, nq, na, offset, norm)
+
+            if field == 'Ez' and px == xref and py == yref:
+                Field_value = -magnitude if Eref < 0 else magnitude
+            else:
+                circsum, circdiff = circuits_for_sign(field, px, py, nx, na, dt, R, initial_state, steps, xref, yref, field_ref='Ez')
+                sign = get_relative_sign(circsum, circdiff, nq, na)
+                if (sign == 'same' and Eref > 0) or (sign == 'different' and Eref < 0):
+                    Field_value = magnitude
+                else:
+                    Field_value = -magnitude
+
+            if multi:
+                series_by_point[(px, py)].append(Field_value)
+            else:
+                series_single.append(Field_value)
+
+    return series_by_point if multi else series_single

utils/fdtd_demo.ipynb

@@ -0,0 +1,326 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c3fb397b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import scipy.sparse as sp\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.special import jn\n",
+    "from scipy.sparse import identity, csr_matrix, kron, diags, eye\n",
+    "from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister\n",
+    "from qiskit.circuit.library import MCXGate, MCPhaseGate, RXGate, CRXGate, QFTGate, StatePreparation, PauliEvolutionGate, RZGate\n",
+    "from qiskit.quantum_info import SparsePauliOp, Statevector, Operator, Pauli\n",
+    "from scipy.linalg import expm\n",
+    "# from tools import *\n",
+    "from base_functions import *\n",
+    "from qiskit.qasm3 import dumps  # QASM 3 exporter\n",
+    "from qiskit.qasm3 import loads\n",
+    "from qiskit.circuit.library import QFT\n",
+    "from qiskit.primitives import StatevectorEstimator\n",
+    "from qiskit import transpile"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9c5ad55d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Inputs\n",
+    "nx = 16\n",
+    "grid_dims=(nx,nx)\n",
+    "field = 'Hx' \n",
+    "x = 7\n",
+    "y = 7\n",
+    "T = 3\n",
+    "initial_state = 'delta'\n",
+    "impulse_pos = (nx//2,nx//2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ddb3e66c",
+   "metadata": {},
+   "source": [
+    "# Get field at any point"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f885e0a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Time step 0: Ez=2.2376563277501641e-07, Hy=2.2001300842051478e-07, Hx=2.2101993820490713e-07\n",
+      "Time step 1: Ez=0.03713901686823572, Hy=0.07449276224003892, Hx=-0.09915963436446357\n",
+      "Time step 2: Ez=0.1637729220450236, Hy=0.057764577526220356, Hx=-0.06137018919000033\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_field_value(field, x, y, T, nx, initial_state, impulse_pos):\n",
+    "    na = 1\n",
+    "    dt = 0.1\n",
+    "    R = 4\n",
+    "    nq = int(np.ceil(np.log2(nx)))\n",
+    "    \n",
+    "    xref, yref = impulse_pos\n",
+    "\n",
+    "    offset = 0\n",
+    "    # deltastate = np.zeros(4*nx*nx)\n",
+    "    # deltastate[nx*nx//2+nx//2:nx*nx//2+nx//2+1] = 1\n",
+    "    # deltastate[0:nx*nx] = deltastate[0:nx*nx] + offset\n",
+    "    # norm1 = np.linalg.norm(deltastate)\n",
+    "    # initial_state = deltastate/norm1\n",
+    "    grid_dims = (nx,nx)\n",
+    "    initial_state = create_impulse_state(grid_dims, impulse_pos)\n",
+    "\n",
+    "    dp = 2 * R * np.pi / 2**na\n",
+    "    p = np.arange(- R * np.pi, R * np.pi, step=dp)\n",
+    "    fp = np.exp(-np.abs(p))\n",
+    "    norm = np.linalg.norm(fp)\n",
+    "\n",
+    "    steps = int(math.ceil(T / dt))\n",
+    "\n",
+    "    Eref = Eref_value(nx, nq, R, dt, na, steps, xref, yref, field_ref = 'Ez')\n",
+    "    \n",
+    "    circ_magnitude = circ_for_magnitude(field, x, y, nx, na, R, dt, initial_state, steps)\n",
+    "    magnitude = get_absolute_field_value(circ_magnitude, nq, na, offset, norm)\n",
+    "\n",
+    "    if field=='Ez' and x == xref and y == yref:\n",
+    "        if Eref< 0:\n",
+    "            Field_value = -1*magnitude\n",
+    "        else:\n",
+    "            Field_value = magnitude\n",
+    "    else: \n",
+    "        circsum, circdiff = circuits_for_sign(field, x, y, nx, na, dt, R, initial_state, steps, xref, yref, field_ref = 'Ez')\n",
+    "        sign = get_relative_sign(circsum, circdiff, nq, na)\n",
+    "\n",
+    "        if (sign == 'same' and Eref > 0) or (sign == 'different' and Eref < 0):\n",
+    "\n",
+    "            Field_value = magnitude\n",
+    "        else:\n",
+    "            Field_value = -1*magnitude\n",
+    "\n",
+    "    return Field_value\n",
+    "\n",
+    "for i in range(T):\n",
+    "    Exz = get_field_value('Ez', x, y, i, nx, initial_state, impulse_pos)\n",
+    "    Hy = get_field_value('Hy', x, y, i, nx, initial_state, impulse_pos)\n",
+    "    Hx = get_field_value('Hx', x, y, i, nx, initial_state, impulse_pos)\n",
+    "    print(f'Time step {i}: Ez={Exz}, Hy={Hy}, Hx={Hx}')\n",
+    "\n",
+    "\n",
+    "# pl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c7af009",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "def create_time_frames(total_time, snapshot_interval):\n",
+    "    \"\"\"\n",
+    "    Generates a list of snapshot times aligned with the quantum solver's fixed timestep.\n",
+    "\n",
+    "    The solver uses a fixed internal timestep (dt=0.1). This function calculates\n",
+    "    the effective total time and snapshot interval that align with this grid,\n",
+    "    replicating the logic from the `run_sim` function.\n",
+    "\n",
+    "    Args:\n",
+    "        total_time (float): The desired total simulation time (T).\n",
+    "        snapshot_interval (float): The desired time between snapshots (Δt).\n",
+    "\n",
+    "    Returns:\n",
+    "        list: A list of floats representing the actual snapshot time frames.\n",
+    "    \"\"\"\n",
+    "    # Solver's fixed internal timestep\n",
+    "    dt = 0.1\n",
+    "    tol = 1e-9\n",
+    "\n",
+    "    # Validate inputs and compute the solver-aligned end time (T_eff)\n",
+    "    try:\n",
+    "        T_val = float(total_time)\n",
+    "    except (ValueError, TypeError):\n",
+    "        return []\n",
+    "    if T_val <= 0:\n",
+    "        return []\n",
+    "\n",
+    "    steps = int(np.floor(T_val / dt))\n",
+    "    if steps <= 0:\n",
+    "        return [0.0]  # Only the initial frame at t=0 exists\n",
+    "    T_eff = steps * dt\n",
+    "\n",
+    "    # Determine the effective snapshot interval on the solver grid (snapshot_dt_eff)\n",
+    "    try:\n",
+    "        snapshot_dt_val = float(snapshot_interval)\n",
+    "    except (ValueError, TypeError):\n",
+    "        snapshot_dt_val = dt  # Default to solver dt if invalid\n",
+    "\n",
+    "    if snapshot_dt_val < dt - tol:\n",
+    "        snapshot_dt_val = dt  # Clamp to the minimum possible interval\n",
+    "    \n",
+    "    # Snap the interval to the nearest multiple of the solver's dt\n",
+    "    k = max(1, int(round(snapshot_dt_val / dt)))\n",
+    "    snapshot_dt_eff = k * dt\n",
+    "\n",
+    "    # Build the list of target times using the same logic as run_sim\n",
+    "    target_times = [0.0]\n",
+    "    current_time = 0.0\n",
+    "    while current_time + snapshot_dt_eff <= T_eff + tol:\n",
+    "        current_time = round(current_time + snapshot_dt_eff, 12)\n",
+    "        target_times.append(min(current_time, T_eff))\n",
+    "    \n",
+    "    # Ensure the effective end time is included if the loop steps over it\n",
+    "    if abs(target_times[-1] - T_eff) > tol:\n",
+    "        target_times.append(T_eff)\n",
+    "        \n",
+    "    # Remove duplicates that might arise from floating point issues\n",
+    "    unique_times = []\n",
+    "    for t in target_times:\n",
+    "        if not unique_times or abs(t - unique_times[-1]) > tol:\n",
+    "            unique_times.append(t)\n",
+    "\n",
+    "    return unique_times\n",
+    "\n",
+    "# --- Example ---\n",
+    "T = 1.0\n",
+    "# Let's use an interval that is not a multiple of 0.1\n",
+    "snapshot_time = 0.3\n",
+    "# The function will snap 0.33 to the nearest multiple of 0.1, which is 0.3 (k=3)\n",
+    "\n",
+    "time_frames = create_time_frames(T, snapshot_time)\n",
+    "\n",
+    "print(f\"Total Time: {T}\")\n",
+    "print(f\"Requested Snapshot Interval: {snapshot_time}\")\n",
+    "print(f\"Generated Time Frames: {time_frames}\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "719cbaf4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_qpu(field, x, y, T, snapshot_time, nx, initial_state, impulse_pos):\n",
+    "    na = 1\n",
+    "    dt = 0.1\n",
+    "    R = 4\n",
+    "    nq = int(np.ceil(np.log2(nx)))\n",
+    "    \n",
+    "    xref, yref = impulse_pos\n",
+    "\n",
+    "    offset = 0\n",
+    "    # deltastate = np.zeros(4*nx*nx)\n",
+    "    # deltastate[nx*nx//2+nx//2:nx*nx//2+nx//2+1] = 1\n",
+    "    # deltastate[0:nx*nx] = deltastate[0:nx*nx] + offset\n",
+    "    # norm1 = np.linalg.norm(deltastate)\n",
+    "    # initial_state = deltastate/norm1\n",
+    "    grid_dims = (nx,nx)\n",
+    "    initial_state = create_impulse_state(grid_dims, impulse_pos)\n",
+    "    dp = 2 * R * np.pi / 2**na\n",
+    "    p = np.arange(- R * np.pi, R * np.pi, step=dp)\n",
+    "    fp = np.exp(-np.abs(p))\n",
+    "    norm = np.linalg.norm(fp)\n",
+    "\n",
+    "    time_frames = create_time_frames(T, snapshot_time)\n",
+    "    field_values = []\n",
+    "    for time in time_frames:\n",
+    "        \n",
+    "        steps = int(math.ceil(time / dt))\n",
+    "        # use \n",
+    "\n",
+    "        Eref = Eref_value(nx, nq, R, dt, na, steps, xref, yref, field_ref = 'Ez')\n",
+    "\n",
+    "        circ_magnitude = circ_for_magnitude(field, x, y, nx, na, R, dt, initial_state, steps)\n",
+    "        magnitude = get_absolute_field_value(circ_magnitude, nq, na, offset, norm)\n",
+    "\n",
+    "        if field=='Ez' and x == xref and y == yref:\n",
+    "            if Eref< 0:\n",
+    "                Field_value = -1*magnitude\n",
+    "            else:\n",
+    "                Field_value = magnitude\n",
+    "        else: \n",
+    "            circsum, circdiff = circuits_for_sign(field, x, y, nx, na, dt, R, initial_state, steps, xref, yref, field_ref = 'Ez')\n",
+    "            sign = get_relative_sign(circsum, circdiff, nq, na)\n",
+    "\n",
+    "            if (sign == 'same' and Eref > 0) or (sign == 'different' and Eref < 0):\n",
+    "\n",
+    "                Field_value = magnitude\n",
+    "            else:\n",
+    "                Field_value = -1*magnitude\n",
+    "        field_values.append(Field_value)\n",
+    "    return field_values\n",
+    "\n",
+    "\n",
+    "Exz = get_field_value('Ez', x, y, T, 0.3, nx, initial_state, impulse_pos)\n",
+    "Hy = get_field_value('Hy', x, y, T, 0.3, nx, initial_state, impulse_pos)\n",
+    "Hx = get_field_value('Hx', x, y, T, 0.3, nx, initial_state, impulse_pos)\n",
+    "# pl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "76ded7b1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[np.float64(2.2376563277501641e-07), np.float64(9.736590876164155e-05), np.float64(0.0044225353473238554), np.float64(0.024957214558959943), np.float64(0.03713901686823572)]\n",
+      "[np.float64(2.2001300842051478e-07), np.float64(0.0009704034518815665), np.float64(0.01717008973114835), np.float64(0.05764097025932368), np.float64(0.07449276224003892)]\n",
+      "[np.float64(2.2101993820490713e-07), np.float64(-0.0038329627633077764), np.float64(-0.029433776288711664), np.float64(-0.07996477735815476), np.float64(-0.09915963436446357)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(Exz)\n",
+    "print(Hy)\n",
+    "print(Hx)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

utils/tempCodeRunnerFile.py

@@ -0,0 +1 @@
+from tools import *